Type System

// types-package/src/define-genome.ts
export interface Genome {
  version: string;
  project: {
    name: string;
    framework: string;
    path: string;
    description?: string;
  };
  modules: GenomeModule[];
  options?: {
    skipInstall?: boolean;
  };
}
 
export interface GenomeModule {
  id: string;
  parameters?: Record<string, any>;
  features?: Record<string, boolean>;
}

import { defineGenome } from '@thearchitech.xyz/types';
 
export default defineGenome({
  project: { ... },  // ← Autocomplete
  modules: [ ... ]   // ← Type-checked
});

// types-package/src/blueprint.ts
export interface Blueprint {
  id: string;
  name: string;
  description: string;
  version: string;
  requires?: string[];
  provides?: string[];
  contextualFiles?: string[];
  actions: BlueprintAction[];
}

// types-package/src/blueprint-actions.ts
export type BlueprintAction =
  | CreateFileAction
  | EnhanceFileAction
  | InstallPackagesAction
  | AddScriptAction
  | RunCommandAction
  // ... more action types
  
export interface CreateFileAction {
  type: 'CREATE_FILE';
  path: string;
  content?: string;
  template?: string;
  data?: Record<string, any>;
  forEach?: string;
}
 
export interface EnhanceFileAction {
  type: 'ENHANCE_FILE';
  path: string;
  modifier: string;
  params: Record<string, any>;
  fallback?: 'create' | 'skip' | 'error';
}

// types-package/src/constitutional-architecture.ts
export interface MergedConfiguration {
  module: {
    id: string;
    version: string;
    defaults: Record<string, any>;
    parameters: Record<string, any>;
  };
  project: ProjectContext;
  activeFeatures: string[];
}

export default function(config: MergedConfiguration): BlueprintAction[] {
  // Access merged parameters
  if (config.module.parameters.typescript) { ... }
  
  // Check active features
  if (config.activeFeatures.includes('auth')) { ... }
}

// CLI's package.json
{
  "dependencies": {
    "@thearchitech.xyz/types": "file:../types-package"
  }
}
 
// Marketplace's package.json
{
  "dependencies": {
    "@thearchitech.xyz/types": "file:../types-package"
  }
}

import { defineGenome, Genome } from '@thearchitech.xyz/types';

User writes genome.ts
   ↓ (imports from @thearchitech.xyz/types)
TypeScript checks types
   ↓ (compile-time validation)
User runs architech new
   ↓ (runtime execution)
CLI validates against types
   ↓ (runtime validation)
Marketplace blueprints use same types
   ↓
Type-safe execution

// CLI adds new action type
case 'NEW_ACTION':
  return newActionHandler.handle(action);
 
// But types-package not updated
// TypeScript doesn't know about NEW_ACTION