TODO Tasks

Current development tasks and priorities for ReX.

Registry Facade Architecture Implementation

Proposed File Structure

src/
  ├── components/                        # Presentation Layer
  │   ├── core/                          # Core UI components (unchanged)
  │   │   └── [existing components]
  │   ├── content/                       # Content-specific components
  │   │   ├── MdxContent/                # MDX content component
  │   │   │   ├── index.tsx              # Main component
  │   │   │   ├── MdxContent.module.css  # Styles
  │   │   │   └── MdxContent.test.tsx    # Tests
  │   │   ├── MdxPage/                   # MDX page component
  │   │   │   ├── index.tsx
  │   │   │   ├── MdxPage.module.css
  │   │   │   └── MdxPage.test.tsx
  │   │   └── index.ts                   # Exports
  │   ├── pages/                         # Page components (unchanged)
  │   └── hooks/                         # React hooks
  │       ├── content/                   # Content hooks
  │       │   ├── useContent.ts          # Hook to load content
  │       │   ├── useContentList.ts      # Hook to list content
  │       │   └── index.ts               # Exports
  │       └── index.ts                   # All hooks exports
  │
  ├── lib/                               # Library code
  │   ├── content/                       # Content system
  │   │   ├── facade/                    # Registry Facade Layer
  │   │   │   ├── registry.ts            # Main registry facade
  │   │   │   ├── hook-factory.ts        # Hook creation factory
  │   │   │   ├── capabilities.ts        # Registry capabilities
  │   │   │   └── index.ts               # Exports
  │   │   ├── loader/                    # Loader Layer (Strategy Provider)
  │   │   │   ├── content-loader.ts      # Main loader implementation
  │   │   │   ├── strategies/            # Content loading strategies
  │   │   │   │   ├── filesystem.ts      # Filesystem strategy
  │   │   │   │   ├── http.ts            # HTTP strategy
  │   │   │   │   ├── memory.ts          # Memory strategy
  │   │   │   │   └── index.ts           # Exports
  │   │   │   └── index.ts               # Exports
  │   │   ├── processor/                 # Processor Registry
  │   │   │   ├── registry.ts            # Processor registry
  │   │   │   ├── processors/            # Content processors
  │   │   │   │   ├── mdx.ts             # MDX processor
  │   │   │   │   ├── plaintext.ts       # Plaintext processor
  │   │   │   │   ├── protobuf.ts        # Protobuf processor
  │   │   │   │   └── index.ts           # Exports
  │   │   │   └── index.ts               # Exports
  │   │   ├── adapter/                   # Adapter Registry
  │   │   │   ├── registry.ts            # Adapter registry
  │   │   │   ├── providers/             # Adapter providers
  │   │   │   │   ├── filesystem.ts      # Filesystem provider
  │   │   │   │   ├── http.ts            # HTTP provider
  │   │   │   │   ├── memory.ts          # Memory provider
  │   │   │   │   └── index.ts           # Exports
  │   │   │   ├── adapters/              # Content adapters
  │   │   │   │   ├── filesystem.ts      # Filesystem adapter
  │   │   │   │   ├── http.ts            # HTTP adapter
  │   │   │   │   ├── memory.ts          # Memory adapter
  │   │   │   │   └── index.ts           # Exports
  │   │   │   └── index.ts               # Exports
  │   │   ├── types/                     # Type system
  │   │   │   ├── core.ts                # Core content types
  │   │   │   ├── registry.ts            # Registry-related types
  │   │   │   ├── processor.ts           # Processor-related types
  │   │   │   ├── adapter.ts             # Adapter-related types
  │   │   │   ├── loader.ts              # Loader-related types
  │   │   │   └── index.ts               # Type exports
  │   │   └── index.ts                   # Content system exports
  │   ├── mdx/                           # MDX-specific utilities
  │   │   ├── compiler/                  # MDX compilation
  │   │   │   ├── compiler.ts            # MDX compiler
  │   │   │   ├── frontmatter.ts         # Frontmatter extraction
  │   │   │   └── index.ts               # Exports
  │   │   ├── factory/                   # Component creation
  │   │   │   ├── component-factory.tsx  # MDX component factory
  │   │   │   ├── hook-factory.tsx       # MDX hook factory
  │   │   │   └── index.ts               # Exports
  │   │   └── index.ts                   # MDX exports
  │   ├── telemetry/                     # Telemetry system (unchanged)
  │   └── utils/                         # Utilities (unchanged)
  │
  └── index.ts                           # Main exports

Registry Facade Architecture Tasks

Phase 1: Setup (April 23-30)

• Create initial directories for new structure
• Set up branch for development work
• Move Architecture Decision Record (ADR-003) to accepted status
• Create initial type interfaces for central concepts
• Set up project milestones and deadlines

Phase 2: Core Type System (May 1-7)

• Define and implement core type interfaces in /lib/content/types/
  • Create core.ts with ContentSource, ContentMediaType, etc.
  • Create registry.ts with Registry interfaces
  • Create adapter.ts, processor.ts, and loader.ts
  • Set up type exports and documentation

Phase 3: Strategy Pattern Implementation (May 8-15)

• Implement ContentLoadStrategy interface
• Create initial strategy implementations:
  • FileSystemLoadStrategy
  • HttpLoadStrategy
  • MemoryLoadStrategy
• Create ContentLoader with strategy selection logic
• Write tests for strategies and loader

Phase 4: Adapter & Processor Registry (May 16-23)

• Implement AdapterRegistry with provider pattern
• Create adapter providers (Filesystem, HTTP, Memory)
• Implement ProcessorRegistry with pluggable processors
• Create initial processors (MDX, Plaintext, Protobuf)
• Write tests for registries and providers

Phase 5: Registry Facade (May 24-31)

• Implement UnifiedRegistry as facade
• Create hook factory for React integration
• Implement registry capabilities system
• Create compatibility layer for existing code
• Write tests for registry facade

Phase 6: Component Integration (June 1-7)

• Refactor content components to use new structure
• Create dedicated content hooks
• Update existing component imports
• Create development-specific debugging tools
• Write tests for components and hooks

Phase 7: Testing & Documentation (June 8-15)

• Create comprehensive test suite for all layers
• Update documentation to reflect new architecture
• Create developer guides for extension points
• Measure and document performance improvements
• Finalize migration guidance

Implementation Status

• Create Architecture Decision Record
• Update documentation to reflect new architecture
• Everything else

Benefits of the New Architecture

• Clear Layer Separation: Each layer has specific responsibilities
• Enhanced Testability: Easier to test each layer in isolation
• Improved Extensibility: Simple to add new content types and sources
• Better Developer Experience: Clearer code organization and interfaces
• Performance Optimization: More efficient caching and processing

See full implementation details in the 2025 Roadmap.