@principal-ai/subsystems-core 0.29.0 → 0.31.0

package/src/cli/codegen.ts

@@ -1,286 +0,0 @@
-#!/usr/bin/env node
-/**
- * Code Generation CLI
- *
- * Generate types from canvas files.
- *
- * Usage:
- *   npx @principal-ai/subsystems-core codegen my-flow.canvas
- *   npx @principal-ai/subsystems-core codegen --lang typescript --output types/ my-flow.canvas
- *
- * Similar to:
- *   - graphql-codegen (GraphQL)
- *   - openapi-generator (OpenAPI)
- *   - protoc (Protobuf)
- */
-
-import fs from 'fs';
-import path from 'path';
-import { generateTypes, generatorRegistry } from '../codegen/type-generator';
-import type { ExtendedCanvas } from '../types/canvas';
-import type { CodegenOptions } from '../codegen/type-generator';
-
-interface CliOptions {
-  language: 'typescript' | 'python' | 'go' | 'rust';
-  output?: string;
-  readonly?: boolean;
-  strictNullChecks?: boolean;
-  includeDocComments?: boolean;
-  namespace?: string;
-  watch?: boolean;
-}
-
-/**
- * Parse command line arguments
- */
-function parseArgs(args: string[]): { options: CliOptions; canvasFiles: string[] } {
-  const options: CliOptions = {
-    language: 'typescript',
-    includeDocComments: true,
-    strictNullChecks: true,
-  };
-
-  const canvasFiles: string[] = [];
-
-  for (let i = 0; i < args.length; i++) {
-    const arg = args[i];
-
-    switch (arg) {
-      case '--lang':
-      case '-l':
-        options.language = args[++i] as CliOptions['language'];
-        break;
-      case '--output':
-      case '-o':
-        options.output = args[++i];
-        break;
-      case '--readonly':
-        options.readonly = true;
-        break;
-      case '--no-strict-null-checks':
-        options.strictNullChecks = false;
-        break;
-      case '--no-doc-comments':
-        options.includeDocComments = false;
-        break;
-      case '--namespace':
-      case '-n':
-        options.namespace = args[++i];
-        break;
-      case '--watch':
-      case '-w':
-        options.watch = true;
-        break;
-      case '--help':
-      case '-h':
-        printHelp();
-        process.exit(0);
-        break;
-      case '--list-generators':
-        listGenerators();
-        process.exit(0);
-        break;
-      default:
-        if (!arg.startsWith('--')) {
-          canvasFiles.push(arg);
-        }
-    }
-  }
-
-  return { options, canvasFiles };
-}
-
-/**
- * Generate types for a canvas file
- */
-function generateTypesForFile(canvasPath: string, options: CliOptions) {
-  console.log(`📝 Generating types from ${canvasPath}...`);
-
-  // Read canvas file
-  const canvas: ExtendedCanvas = JSON.parse(fs.readFileSync(canvasPath, 'utf-8'));
-
-  // Generate types
-  const codegenOptions: CodegenOptions = {
-    language: options.language,
-    style: {
-      readonly: options.readonly,
-      strictNullChecks: options.strictNullChecks,
-      includeDocComments: options.includeDocComments,
-    },
-    namespace: options.namespace,
-  };
-
-  const result = generateTypes(canvas, codegenOptions);
-
-  // Determine output path
-  let outputPath: string;
-  if (options.output) {
-    // If output is a directory, use generated filename
-    if (fs.existsSync(options.output) && fs.statSync(options.output).isDirectory()) {
-      outputPath = path.join(options.output, result.filename);
-    } else {
-      outputPath = options.output;
-    }
-  } else {
-    // Default: packages/subsystems-core/src/generated/ for .principal-views canvases
-    // This keeps canvas files in .principal-views/ but generates types to idiomatic locations
-    const canvasDir = path.dirname(canvasPath);
-    const canvasAbsPath = path.resolve(canvasPath);
-
-    if (canvasAbsPath.includes('.principal-views')) {
-      // Canvas is in .principal-views/, output to packages/subsystems-core/src/generated/
-      const repoRoot = canvasAbsPath.split('.principal-views')[0];
-      const generatedDir = path.join(repoRoot, 'packages', 'core', 'src', 'generated');
-      outputPath = path.join(generatedDir, result.filename);
-    } else {
-      // Canvas is elsewhere, use same directory
-      outputPath = path.join(canvasDir, result.filename);
-    }
-  }
-
-  // Ensure output directory exists
-  const outputDir = path.dirname(outputPath);
-  if (!fs.existsSync(outputDir)) {
-    fs.mkdirSync(outputDir, { recursive: true });
-  }
-
-  // Write types file
-  fs.writeFileSync(outputPath, result.code);
-
-  console.log(`✅ Generated ${outputPath}`);
-  console.log(`   Language: ${options.language}`);
-  console.log(`   Size: ${result.code.length} bytes`);
-
-  return outputPath;
-}
-
-/**
- * Print help message
- */
-function printHelp() {
-  console.log(`
-Code Generation CLI - Generate types from canvas files
-
-USAGE:
-  npx @principal-ai/subsystems-core codegen [OPTIONS] <canvas-files...>
-
-OPTIONS:
-  -l, --lang <language>           Target language (typescript|python|go|rust) [default: typescript]
-  -o, --output <path>             Output file or directory [default: same as canvas]
-  -n, --namespace <name>          Wrap types in a namespace
-  --readonly                      Use readonly modifiers (TypeScript)
-  --no-strict-null-checks         Disable strict null checks
-  --no-doc-comments               Omit JSDoc comments
-  -w, --watch                     Watch for changes and regenerate
-  --list-generators               List available code generators
-  -h, --help                      Show this help message
-
-EXAMPLES:
-  # Generate TypeScript types
-  npx @principal-ai/subsystems-core codegen my-flow.canvas
-
-  # Generate with namespace
-  npx @principal-ai/subsystems-core codegen --namespace Events my-flow.canvas
-
-  # Generate to specific output directory
-  npx @principal-ai/subsystems-core codegen --output src/types/ my-flow.canvas
-
-  # Generate multiple files
-  npx @principal-ai/subsystems-core codegen *.canvas
-
-  # Watch mode (future)
-  npx @principal-ai/subsystems-core codegen --watch my-flow.canvas
-
-PRECEDENTS:
-  This tool follows patterns from:
-  - GraphQL Code Generator (graphql-code-generator.com)
-  - OpenAPI Generator (openapi-generator.tech)
-  - Protobuf Compiler (protoc)
-
-  Like these tools, it generates type-safe code from declarative schemas.
-`);
-}
-
-/**
- * List available generators
- */
-function listGenerators() {
-  console.log('\nAvailable Code Generators:\n');
-
-  const languages = generatorRegistry.list();
-
-  for (const lang of languages) {
-    const generator = generatorRegistry.get(lang);
-    console.log(`  • ${lang.padEnd(15)} ${generator ? '✓' : '✗'}`);
-  }
-
-  console.log('\nTo add support for more languages, implement the CodeGenerator interface.');
-  console.log('See: packages/subsystems-core/src/codegen/type-generator.ts\n');
-}
-
-/**
- * Main entry point
- */
-function main() {
-  const { options, canvasFiles } = parseArgs(process.argv.slice(2));
-
-  if (canvasFiles.length === 0) {
-    console.error('❌ Error: No canvas files specified\n');
-    printHelp();
-    process.exit(1);
-  }
-
-  // Validate language
-  const availableLanguages = generatorRegistry.list();
-  if (!availableLanguages.includes(options.language)) {
-    console.error(`❌ Error: Unsupported language '${options.language}'`);
-    console.error(`   Available: ${availableLanguages.join(', ')}\n`);
-    listGenerators();
-    process.exit(1);
-  }
-
-  // Generate types for each file
-  const outputFiles: string[] = [];
-
-  for (const canvasFile of canvasFiles) {
-    try {
-      // Check if file exists
-      if (!fs.existsSync(canvasFile)) {
-        console.error(`❌ Error: File not found: ${canvasFile}`);
-        continue;
-      }
-
-      const outputPath = generateTypesForFile(canvasFile, options);
-      outputFiles.push(outputPath);
-    } catch (error) {
-      console.error(`❌ Error processing ${canvasFile}:`, error);
-      process.exit(1);
-    }
-  }
-
-  console.log(`\n✨ Successfully generated ${outputFiles.length} type file(s)\n`);
-
-  // Watch mode
-  if (options.watch) {
-    console.log('👀 Watching for changes...');
-    for (const canvasFile of canvasFiles) {
-      fs.watch(canvasFile, (eventType) => {
-        if (eventType === 'change') {
-          console.log(`\n🔄 ${canvasFile} changed, regenerating...`);
-          try {
-            generateTypesForFile(canvasFile, options);
-          } catch (error) {
-            console.error('❌ Error:', error);
-          }
-        }
-      });
-    }
-  }
-}
-
-// Run CLI if executed directly
-if (require.main === module) {
-  main();
-}
-
-export { main, parseArgs, generateTypesForFile };

package/src/codegen/type-generator.test.ts

@@ -1,219 +0,0 @@
-/**
- * Type Generator Tests
- */
-
-import { describe, test, expect } from 'bun:test';
-import fs from 'fs';
-import path from 'path';
-import { generateTypes, generatorRegistry } from './type-generator';
-import type { ExtendedCanvas } from '../types/canvas';
-
-// Load the example canvas
-const canvasPath = path.join(__dirname, '../../../../.principal-views/graph-converter-execution.otel.canvas');
-const canvas: ExtendedCanvas = JSON.parse(fs.readFileSync(canvasPath, 'utf-8'));
-
-describe('TypeScript Type Generator', () => {
-  test('should generate TypeScript types from canvas', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    expect(result.extension).toBe('ts');
-    expect(result.filename).toBe('graph-converter-execution.types.ts');
-    expect(result.code).toContain('export namespace GraphConverter');
-    expect(result.code).toContain('DO NOT EDIT MANUALLY');
-  });
-
-  test('should generate event interfaces with correct structure', () => {
-    const result = generateTypes(canvas, {
-      language: 'typescript',
-      style: { includeDocComments: true },
-    });
-
-    // Should have ConversionStarted interface
-    expect(result.code).toContain('export interface ConversionStarted');
-    expect(result.code).toContain("name: 'conversion.started'");
-    expect(result.code).toContain("'config.nodeTypes': number");
-    expect(result.code).toContain("'config.edgeTypes': number");
-
-    // Should have ConversionComplete interface
-    expect(result.code).toContain('export interface ConversionComplete');
-    expect(result.code).toContain("'result.nodes.count': number");
-    expect(result.code).toContain("'result.edges.count': number");
-  });
-
-  test('should handle required vs optional fields', () => {
-    const result = generateTypes(canvas, {
-      language: 'typescript',
-      style: { strictNullChecks: true },
-    });
-
-    // Required field (no question mark)
-    expect(result.code).toMatch(/'config\.nodeTypes': number/);
-
-    // Optional field (with question mark)
-    expect(result.code).toMatch(/'duration\.ms'\?: number/);
-  });
-
-  test('should generate union types for all events', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    // Union of event types
-    expect(result.code).toContain('export type Event =');
-    expect(result.code).toContain('ConversionStarted');
-    expect(result.code).toContain('ConversionComplete');
-
-    // Union of event names
-    expect(result.code).toContain('export type EventName =');
-    expect(result.code).toContain("'conversion.started'");
-    expect(result.code).toContain("'conversion.complete'");
-  });
-
-  test('should generate all event names union', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    expect(result.code).toContain('export type AllEventNames =');
-    expect(result.code).toContain("'conversion.started'");
-    expect(result.code).toContain("'validation.started'");
-    expect(result.code).toContain("'output.created'");
-  });
-
-  test('should generate helper emitter types', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    expect(result.code).toContain('export type NodeEmitter<');
-    expect(result.code).toContain('export type NodeEmitterByName<');
-  });
-
-  test('should include JSDoc comments when enabled', () => {
-    const result = generateTypes(canvas, {
-      language: 'typescript',
-      style: { includeDocComments: true },
-    });
-
-    expect(result.code).toContain('/**');
-    expect(result.code).toContain('Triggered when graph conversion begins');
-    expect(result.code).toContain('Number of node types in config');
-  });
-
-  test('should omit JSDoc comments when disabled', () => {
-    const result = generateTypes(canvas, {
-      language: 'typescript',
-      style: { includeDocComments: false },
-    });
-
-    // Should still have file header comment
-    expect(result.code).toContain('DO NOT EDIT MANUALLY');
-
-    // But fewer JSDoc blocks overall (updated for per-node-instance namespaces)
-    const commentBlocks = result.code.match(/\/\*\*/g) || [];
-    expect(commentBlocks.length).toBeLessThan(25);
-  });
-
-  test('should support readonly modifier', () => {
-    const result = generateTypes(canvas, {
-      language: 'typescript',
-      style: { readonly: true },
-    });
-
-    expect(result.code).toContain('readonly name:');
-    expect(result.code).toContain('readonly attributes:');
-    expect(result.code).toContain("readonly 'config.nodeTypes':");
-  });
-
-  test('should support namespace option', () => {
-    const result = generateTypes(canvas, {
-      language: 'typescript',
-      namespace: 'TelemetryEvents',
-    });
-
-    expect(result.code).toContain('export namespace TelemetryEvents {');
-    expect(result.code).toMatch(/^export namespace TelemetryEvents \{/m);
-    expect(result.code).toMatch(/\}$/m);
-  });
-
-  test('should handle multiple nodes with event schemas', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    // GraphConverter namespace
-    expect(result.code).toContain('export namespace GraphConverter {');
-
-    // Validation namespace
-    expect(result.code).toContain('export namespace Validation {');
-
-    // GraphOutput namespace
-    expect(result.code).toContain('export namespace GraphOutput {');
-  });
-
-  test('should convert node IDs to PascalCase type names', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    // 'graph-converter' -> 'GraphConverter'
-    expect(result.code).toContain('export namespace GraphConverter');
-
-    // 'validation' -> 'Validation'
-    expect(result.code).toContain('export namespace Validation');
-
-    // 'graph-output' -> 'GraphOutput'
-    expect(result.code).toContain('export namespace GraphOutput');
-  });
-
-  test('should convert event names to PascalCase interface names', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    // 'conversion.started' -> 'ConversionStarted'
-    expect(result.code).toContain('export interface ConversionStarted');
-
-    // 'validation.complete' -> 'ValidationComplete'
-    expect(result.code).toContain('export interface ValidationComplete');
-  });
-
-  test('should write generated types to file', () => {
-    const result = generateTypes(canvas, { language: 'typescript' });
-
-    const outputPath = path.join(
-      __dirname,
-      '../../../../.principal-views',
-      result.filename
-    );
-
-    // Ensure directory exists
-    const dir = path.dirname(outputPath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-
-    fs.writeFileSync(outputPath, result.code);
-
-    expect(fs.existsSync(outputPath)).toBe(true);
-
-    const written = fs.readFileSync(outputPath, 'utf-8');
-    expect(written).toBe(result.code);
-  });
-});
-
-describe('Code Generator Registry', () => {
-  test('should list available generators', () => {
-    const languages = generatorRegistry.list();
-    expect(languages).toContain('typescript');
-  });
-
-  test('should get TypeScript generator', () => {
-    const generator = generatorRegistry.get('typescript');
-    expect(generator).toBeDefined();
-    expect(generator?.language).toBe('typescript');
-  });
-
-  test('should allow registering custom generators', () => {
-
-    const customGenerator = {
-      language: 'custom',
-      generate: () => ({ code: 'test', extension: 'txt', filename: 'test.txt' }),
-    };
-
-    generatorRegistry.register(customGenerator);
-
-    const retrieved = generatorRegistry.get('custom');
-    expect(retrieved).toBe(customGenerator);
-
-    expect(generatorRegistry.list()).toContain('custom');
-  });
-});