@mmapp/react-compiler 0.1.0-alpha.1

package/src/cli/test.ts

@@ -0,0 +1,397 @@
+/**
+ * CLI Test Command — round-trip fidelity verification.
+ *
+ * Compiles project sources → decompiles IR → recompiles → compares.
+ * Validates that the compiler↔decompiler round trip preserves all structural data.
+ *
+ * Usage: mmrc test [--src ./src]
+ */
+
+import { glob } from 'glob';
+import { readFileSync, existsSync } from 'fs';
+import { resolve } from 'path';
+import type { IRWorkflowDefinition } from '@mindmatrix/player-core';
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface TestOptions {
+  /** Source directory containing workflow project files. Default: '.' */
+  src?: string;
+}
+
+export interface TestResult {
+  success: boolean;
+  fieldCount: number;
+  fieldMatch: number;
+  stateCount: number;
+  stateMatch: number;
+  transitionCount: number;
+  transitionMatch: number;
+  diffs: TestDiff[];
+  timings: { compile: number; decompile: number; recompile: number; compare: number };
+}
+
+interface TestDiff {
+  path: string;
+  expected: unknown;
+  actual: unknown;
+  severity: 'error' | 'warning';
+}
+
+// =============================================================================
+// Main
+// =============================================================================
+
+export async function test(options: TestOptions = {}): Promise<TestResult> {
+  const srcDir = options.src ?? '.';
+  const label = '[mindmatrix-react]';
+
+  console.log(`${label} Round-trip fidelity test\n`);
+
+  // ─── Step 1: Read source files ─────────────────────────────────────────────
+  const configPath = resolve(srcDir, 'mm.config.ts');
+  const isProject = existsSync(configPath);
+
+  if (!isProject) {
+    console.error(`${label} Error: No mm.config.ts found in ${srcDir}`);
+    console.error(`  Round-trip test requires a project with mm.config.ts`);
+    process.exit(1);
+  }
+
+  const allFiles = await glob(`${srcDir}/**/*.{ts,tsx}`, {
+    ignore: ['**/node_modules/**', '**/dist/**', '**/*.test.*'],
+  });
+
+  if (allFiles.length === 0) {
+    console.error(`${label} Error: No source files found in ${srcDir}`);
+    process.exit(1);
+  }
+
+  const fileMap: Record<string, string> = {};
+  for (const f of allFiles) {
+    const rel = f.startsWith(srcDir + '/') ? f.slice(srcDir.length + 1) : f;
+    fileMap[rel] = readFileSync(f, 'utf-8');
+  }
+
+  // ─── Step 2: Compile ──────────────────────────────────────────────────────
+  const { compileProject } = await import('../project-compiler');
+  const { decompileProjectEnhanced } = await import('../decompiler/project-decompiler');
+  type DecompilerInput = import('../decompiler').DecompilerInput;
+
+  process.stdout.write(`  Compiling project...`);
+  const t0 = performance.now();
+
+  let ir1: IRWorkflowDefinition;
+  let childDefs1: IRWorkflowDefinition[];
+  try {
+    const result = compileProject(fileMap);
+    ir1 = result.ir;
+    childDefs1 = result.childDefinitions;
+    const compileErrors = result.errors.filter((e: { severity: string }) => e.severity === 'error');
+    if (compileErrors.length > 0) {
+      console.log(` FAIL`);
+      for (const err of compileErrors) {
+        console.error(`    ${err.file}: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  } catch (err) {
+    console.log(` FAIL`);
+    console.error(`    ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  const t1 = performance.now();
+  console.log(` \u2713 (${((t1 - t0) / 1000).toFixed(1)}s)`);
+
+  // ─── Step 3: Decompile ────────────────────────────────────────────────────
+  process.stdout.write(`  Decompiling IR...`);
+  const t2 = performance.now();
+
+  let decompFiles: Record<string, string>;
+  try {
+    const decompInput: DecompilerInput = {
+      ...ir1,
+      childDefinitions: childDefs1,
+      experience: ir1.experience as any,
+    };
+    const decompResult = decompileProjectEnhanced(decompInput);
+    decompFiles = {};
+    for (const file of decompResult.files) {
+      decompFiles[file.path] = file.content;
+    }
+  } catch (err) {
+    console.log(` FAIL`);
+    console.error(`    ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  const t3 = performance.now();
+  console.log(` \u2713 (${((t3 - t2) / 1000).toFixed(1)}s)`);
+
+  // ─── Step 4: Recompile ────────────────────────────────────────────────────
+  process.stdout.write(`  Recompiling...`);
+  const t4 = performance.now();
+
+  let ir2: IRWorkflowDefinition;
+  try {
+    const result2 = compileProject(decompFiles);
+    ir2 = result2.ir;
+    const recompileErrors = result2.errors.filter((e: { severity: string }) => e.severity === 'error');
+    if (recompileErrors.length > 0) {
+      console.log(` FAIL`);
+      for (const err of recompileErrors) {
+        console.error(`    ${err.file}: ${err.message}`);
+      }
+      process.exit(1);
+    }
+  } catch (err) {
+    console.log(` FAIL`);
+    console.error(`    ${(err as Error).message}`);
+    process.exit(1);
+  }
+
+  const t5 = performance.now();
+  console.log(` \u2713 (${((t5 - t4) / 1000).toFixed(1)}s)`);
+
+  // ─── Step 5: Compare ─────────────────────────────────────────────────────
+  process.stdout.write(`  Comparing IR...\n`);
+  const t6 = performance.now();
+
+  const diffs: TestDiff[] = [];
+
+  // Metadata
+  if (ir1.slug !== ir2.slug) {
+    diffs.push({ path: 'slug', expected: ir1.slug, actual: ir2.slug, severity: 'error' });
+  }
+  if (ir1.version !== ir2.version) {
+    diffs.push({ path: 'version', expected: ir1.version, actual: ir2.version, severity: 'error' });
+  }
+  if (JSON.stringify(ir1.category) !== JSON.stringify(ir2.category)) {
+    diffs.push({ path: 'category', expected: ir1.category, actual: ir2.category, severity: 'error' });
+  }
+
+  // Fields
+  const { fieldMatch, fieldCount } = compareFields(diffs, ir1.fields, ir2.fields);
+  const fieldOk = diffs.filter(d => d.path.startsWith('fields') && d.severity === 'error').length === 0;
+  console.log(`    Fields: ${fieldMatch}/${fieldCount} match ${fieldOk ? '\u2713' : 'FAIL'}`);
+
+  // States
+  const { stateMatch, stateCount } = compareStates(diffs, ir1.states, ir2.states);
+  const stateOk = diffs.filter(d => d.path.startsWith('states') && d.severity === 'error').length === 0;
+  console.log(`    States: ${stateMatch}/${stateCount} match ${stateOk ? '\u2713' : 'FAIL'}`);
+
+  // Transitions
+  const { transitionMatch, transitionCount } = compareTransitions(diffs, ir1.transitions, ir2.transitions);
+  const transitionOk = diffs.filter(d => d.path.startsWith('transitions') && d.severity === 'error').length === 0;
+  console.log(`    Transitions: ${transitionMatch}/${transitionCount} match ${transitionOk ? '\u2713' : 'FAIL'}`);
+
+  const t7 = performance.now();
+
+  const errors = diffs.filter(d => d.severity === 'error');
+  const success = errors.length === 0;
+
+  if (success) {
+    console.log(`  PASS \u2014 round-trip produces identical IR`);
+  } else {
+    console.log(`  FAIL \u2014 ${errors.length} difference(s) found:`);
+    for (const diff of errors) {
+      console.log(`    ${diff.path}: expected ${JSON.stringify(diff.expected)}, got ${JSON.stringify(diff.actual)}`);
+    }
+  }
+
+  return {
+    success,
+    fieldCount,
+    fieldMatch,
+    stateCount,
+    stateMatch,
+    transitionCount,
+    transitionMatch,
+    diffs,
+    timings: {
+      compile: t1 - t0,
+      decompile: t3 - t2,
+      recompile: t5 - t4,
+      compare: t7 - t6,
+    },
+  };
+}
+
+// =============================================================================
+// Field Comparison
+// =============================================================================
+
+function compareFields(
+  diffs: TestDiff[],
+  fields1: IRWorkflowDefinition['fields'],
+  fields2: IRWorkflowDefinition['fields'],
+): { fieldMatch: number; fieldCount: number } {
+  const map1 = new Map(fields1.map(f => [f.name, f]));
+  const map2 = new Map(fields2.map(f => [f.name, f]));
+  const fieldCount = map1.size;
+  let fieldMatch = 0;
+
+  for (const [name, f1] of map1) {
+    const f2 = map2.get(name);
+    if (!f2) {
+      diffs.push({ path: `fields[${name}]`, expected: name, actual: undefined, severity: 'error' });
+      continue;
+    }
+
+    if (f1.type !== f2.type && !isCompatibleType(f1.type, f2.type)) {
+      diffs.push({ path: `fields[${name}].type`, expected: f1.type, actual: f2.type, severity: 'warning' });
+    }
+    fieldMatch++;
+  }
+
+  for (const [name] of map2) {
+    if (!map1.has(name)) {
+      diffs.push({ path: `fields[${name}]`, expected: undefined, actual: name, severity: 'warning' });
+    }
+  }
+
+  return { fieldMatch, fieldCount };
+}
+
+function isCompatibleType(t1: string, t2: string): boolean {
+  const stringTypes = new Set(['text', 'rich_text', 'email', 'url', 'phone', 'color', 'select']);
+  const numberTypes = new Set(['number', 'currency', 'percentage', 'rating', 'duration']);
+  if (stringTypes.has(t1) && stringTypes.has(t2)) return true;
+  if (numberTypes.has(t1) && numberTypes.has(t2)) return true;
+  return false;
+}
+
+// =============================================================================
+// State Comparison
+// =============================================================================
+
+function compareStates(
+  diffs: TestDiff[],
+  states1: IRWorkflowDefinition['states'],
+  states2: IRWorkflowDefinition['states'],
+): { stateMatch: number; stateCount: number } {
+  const map1 = new Map(states1.map(s => [s.name, s]));
+  const map2 = new Map(states2.map(s => [s.name, s]));
+  const stateCount = map1.size;
+  let stateMatch = 0;
+
+  for (const [name, s1] of map1) {
+    const s2 = map2.get(name);
+    const hasActions = s1.on_enter.length > 0 || s1.on_exit.length > 0 || s1.during.length > 0;
+
+    if (!s2 && hasActions) {
+      diffs.push({ path: `states[${name}]`, expected: name, actual: undefined, severity: 'error' });
+      continue;
+    }
+    if (!s2) {
+      // States without actions may differ — still count as match
+      stateMatch++;
+      continue;
+    }
+
+    let matched = true;
+    if (s1.on_enter.length !== s2.on_enter.length) {
+      diffs.push({
+        path: `states[${name}].on_enter.length`,
+        expected: s1.on_enter.length,
+        actual: s2.on_enter.length,
+        severity: s1.on_enter.length > 0 ? 'error' : 'warning',
+      });
+      if (s1.on_enter.length > 0) matched = false;
+    }
+    if (s1.on_exit.length !== s2.on_exit.length) {
+      diffs.push({
+        path: `states[${name}].on_exit.length`,
+        expected: s1.on_exit.length,
+        actual: s2.on_exit.length,
+        severity: s1.on_exit.length > 0 ? 'error' : 'warning',
+      });
+      if (s1.on_exit.length > 0) matched = false;
+    }
+    if (s1.during.length !== s2.during.length) {
+      diffs.push({
+        path: `states[${name}].during.length`,
+        expected: s1.during.length,
+        actual: s2.during.length,
+        severity: s1.during.length > 0 ? 'error' : 'warning',
+      });
+      if (s1.during.length > 0) matched = false;
+    }
+
+    if (matched) stateMatch++;
+  }
+
+  return { stateMatch, stateCount };
+}
+
+// =============================================================================
+// Transition Comparison
+// =============================================================================
+
+function compareTransitions(
+  diffs: TestDiff[],
+  transitions1: IRWorkflowDefinition['transitions'],
+  transitions2: IRWorkflowDefinition['transitions'],
+): { transitionMatch: number; transitionCount: number } {
+  const map1 = new Map(transitions1.map(t => [t.name, t]));
+  const map2 = new Map(transitions2.map(t => [t.name, t]));
+  const transitionCount = map1.size;
+  let transitionMatch = 0;
+
+  if (transitions1.length !== transitions2.length) {
+    diffs.push({
+      path: 'transitions.length',
+      expected: transitions1.length,
+      actual: transitions2.length,
+      severity: 'error',
+    });
+  }
+
+  for (const [name, t1] of map1) {
+    const t2 = map2.get(name);
+    if (!t2) {
+      diffs.push({ path: `transitions[${name}]`, expected: name, actual: undefined, severity: 'error' });
+      continue;
+    }
+
+    let matched = true;
+
+    if (t1.to !== t2.to) {
+      diffs.push({ path: `transitions[${name}].to`, expected: t1.to, actual: t2.to, severity: 'error' });
+      matched = false;
+    }
+
+    const from1 = [...t1.from].sort();
+    const from2 = [...t2.from].sort();
+    if (JSON.stringify(from1) !== JSON.stringify(from2)) {
+      diffs.push({ path: `transitions[${name}].from`, expected: from1, actual: from2, severity: 'error' });
+      matched = false;
+    }
+
+    const roles1 = [...(t1.roles ?? [])].sort();
+    const roles2 = [...(t2.roles ?? [])].sort();
+    if (JSON.stringify(roles1) !== JSON.stringify(roles2)) {
+      diffs.push({ path: `transitions[${name}].roles`, expected: roles1, actual: roles2, severity: 'error' });
+      matched = false;
+    }
+
+    const req1 = [...(t1.required_fields ?? [])].sort();
+    const req2 = [...(t2.required_fields ?? [])].sort();
+    if (JSON.stringify(req1) !== JSON.stringify(req2)) {
+      diffs.push({ path: `transitions[${name}].required_fields`, expected: req1, actual: req2, severity: 'error' });
+      matched = false;
+    }
+
+    if (!!t1.auto !== !!t2.auto) {
+      diffs.push({ path: `transitions[${name}].auto`, expected: t1.auto, actual: t2.auto, severity: 'error' });
+      matched = false;
+    }
+
+    if (matched) transitionMatch++;
+  }
+
+  return { transitionMatch, transitionCount };
+}

package/src/cli/type-generator.ts

@@ -0,0 +1,243 @@
+/**
+ * Type Generator — converts a WorkflowDefinition into a TypeScript .d.ts file.
+ *
+ * Generates:
+ *   - defineModel() call with `as const` assertion
+ *   - Field types mapped to TypeScript types
+ *   - State names as union type
+ *   - Transition names as union type
+ */
+
+import type { WorkflowDefinitionResponse } from './registry-client';
+
+/** Map workflow field types to TypeScript types */
+const FIELD_TYPE_MAP: Record<string, string> = {
+  string: 'string',
+  text: 'string',
+  email: 'string',
+  url: 'string',
+  phone: 'string',
+  password: 'string',
+  slug: 'string',
+  color: 'string',
+  number: 'number',
+  integer: 'number',
+  float: 'number',
+  decimal: 'number',
+  currency: 'number',
+  percentage: 'number',
+  boolean: 'boolean',
+  date: 'string',
+  datetime: 'string',
+  time: 'string',
+  timestamp: 'string',
+  json: 'unknown',
+  object: 'Record<string, unknown>',
+  array: 'unknown[]',
+  file: 'string',
+  image: 'string',
+  reference: 'string',
+  enum: 'string',
+  select: 'string',
+};
+
+function getTsType(fieldType: string): string {
+  return FIELD_TYPE_MAP[fieldType] ?? 'unknown';
+}
+
+function escapeStringLiteral(s: string): string {
+  return s.replace(/\\/g, '\\\\').replace(/'/g, "\\'");
+}
+
+function serializeDefault(value: unknown): string {
+  if (value === undefined || value === null) return "''";
+  if (typeof value === 'string') return `'${escapeStringLiteral(value)}'`;
+  if (typeof value === 'number' || typeof value === 'boolean') return String(value);
+  if (Array.isArray(value)) return JSON.stringify(value);
+  return JSON.stringify(value);
+}
+
+/**
+ * Generate a .d.ts file from a workflow definition response.
+ */
+export function generateTypeDeclaration(def: WorkflowDefinitionResponse): string {
+  const lines: string[] = [];
+
+  lines.push("import { defineModel } from '@mindmatrix/react';");
+  lines.push('');
+  lines.push('declare const _default: ReturnType<typeof defineModel<{');
+  lines.push(`  readonly slug: '${escapeStringLiteral(def.slug)}';`);
+  lines.push(`  readonly version: '${escapeStringLiteral(def.version || '1.0.0')}';`);
+
+  // Fields
+  if (def.fields && def.fields.length > 0) {
+    lines.push('  readonly fields: {');
+    for (const field of def.fields) {
+      const props: string[] = [];
+      props.push(`readonly type: '${escapeStringLiteral(field.type)}'`);
+
+      if (field.default_value !== undefined && field.default_value !== null) {
+        props.push(`readonly default: ${serializeDefault(field.default_value)}`);
+      } else {
+        // Provide a sensible default based on type
+        const tsType = getTsType(field.type);
+        if (tsType === 'string') props.push("readonly default: ''");
+        else if (tsType === 'number') props.push('readonly default: 0');
+        else if (tsType === 'boolean') props.push('readonly default: false');
+      }
+
+      if (field.validation?.enum && field.validation.enum.length > 0) {
+        const enumValues = field.validation.enum
+          .map(v => `'${escapeStringLiteral(v)}'`)
+          .join(', ');
+        props.push(`readonly enum: readonly [${enumValues}]`);
+      }
+
+      if (field.required) {
+        props.push('readonly required: true');
+      }
+
+      lines.push(`    readonly ${field.name}: { ${props.join('; ')} };`);
+    }
+    lines.push('  };');
+  } else {
+    lines.push('  readonly fields: {};');
+  }
+
+  // States
+  if (def.states && def.states.length > 0) {
+    lines.push('  readonly states: {');
+    for (const state of def.states) {
+      const stateProps: string[] = [];
+      if (state.type === 'initial') {
+        stateProps.push("readonly type: 'initial'");
+      } else if (state.type === 'final') {
+        stateProps.push("readonly type: 'final'");
+      }
+      lines.push(`    readonly ${state.name}: { ${stateProps.join('; ')} };`);
+    }
+    lines.push('  };');
+  } else {
+    lines.push('  readonly states: {};');
+  }
+
+  // Transitions
+  if (def.transitions && def.transitions.length > 0) {
+    lines.push('  readonly transitions: {');
+    for (const transition of def.transitions) {
+      const tProps: string[] = [];
+
+      // from — use first element as string literal, or union if multiple
+      if (transition.from.length === 1) {
+        tProps.push(`readonly from: '${escapeStringLiteral(transition.from[0])}'`);
+      } else if (transition.from.length > 1) {
+        const fromUnion = transition.from.map(f => `'${escapeStringLiteral(f)}'`).join(' | ');
+        tProps.push(`readonly from: ${fromUnion}`);
+      }
+
+      tProps.push(`readonly to: '${escapeStringLiteral(transition.to)}'`);
+
+      lines.push(`    readonly ${transition.name}: { ${tProps.join('; ')} };`);
+    }
+    lines.push('  };');
+  } else {
+    lines.push('  readonly transitions: {};');
+  }
+
+  lines.push('}>>;');
+  lines.push('export default _default;');
+  lines.push('');
+
+  // Also export state and transition union types for convenience
+  if (def.states && def.states.length > 0) {
+    const stateUnion = def.states.map(s => `'${escapeStringLiteral(s.name)}'`).join(' | ');
+    lines.push(`export type States = ${stateUnion};`);
+  }
+
+  if (def.transitions && def.transitions.length > 0) {
+    const transitionUnion = def.transitions.map(t => `'${escapeStringLiteral(t.name)}'`).join(' | ');
+    lines.push(`export type Transitions = ${transitionUnion};`);
+  }
+
+  if (def.fields && def.fields.length > 0) {
+    lines.push('');
+    lines.push('export interface Fields {');
+    for (const field of def.fields) {
+      const tsType = getTsType(field.type);
+      lines.push(`  ${field.name}: ${tsType};`);
+    }
+    lines.push('}');
+  }
+
+  lines.push('');
+
+  return lines.join('\n');
+}
+
+/**
+ * Generate a full source index.ts for a workflow package (--full mode).
+ */
+export function generateFullSource(def: WorkflowDefinitionResponse): string {
+  const lines: string[] = [];
+
+  lines.push("import { defineModel } from '@mindmatrix/react';");
+  lines.push('');
+  lines.push('export default defineModel({');
+  lines.push(`  slug: '${escapeStringLiteral(def.slug)}',`);
+  lines.push(`  version: '${escapeStringLiteral(def.version || '1.0.0')}',`);
+
+  if (def.fields && def.fields.length > 0) {
+    lines.push('  fields: {');
+    for (const field of def.fields) {
+      const props: string[] = [];
+      props.push(`type: '${escapeStringLiteral(field.type)}'`);
+      if (field.default_value !== undefined && field.default_value !== null) {
+        props.push(`default: ${serializeDefault(field.default_value)}`);
+      }
+      if (field.validation?.enum) {
+        const enumValues = field.validation.enum
+          .map(v => `'${escapeStringLiteral(v)}'`)
+          .join(', ');
+        props.push(`enum: [${enumValues}] as const`);
+      }
+      if (field.required) {
+        props.push('required: true');
+      }
+      lines.push(`    ${field.name}: { ${props.join(', ')} },`);
+    }
+    lines.push('  },');
+  }
+
+  if (def.states && def.states.length > 0) {
+    lines.push('  states: {');
+    for (const state of def.states) {
+      if (state.type === 'initial' || state.type === 'final') {
+        lines.push(`    ${state.name}: { type: '${state.type}' },`);
+      } else {
+        lines.push(`    ${state.name}: {},`);
+      }
+    }
+    lines.push('  },');
+  }
+
+  if (def.transitions && def.transitions.length > 0) {
+    lines.push('  transitions: {');
+    for (const transition of def.transitions) {
+      const tProps: string[] = [];
+      if (transition.from.length === 1) {
+        tProps.push(`from: '${escapeStringLiteral(transition.from[0])}'`);
+      } else {
+        const fromArr = transition.from.map(f => `'${escapeStringLiteral(f)}'`).join(', ');
+        tProps.push(`from: [${fromArr}]`);
+      }
+      tProps.push(`to: '${escapeStringLiteral(transition.to)}'`);
+      lines.push(`    ${transition.name}: { ${tProps.join(', ')} },`);
+    }
+    lines.push('  },');
+  }
+
+  lines.push('} as const);');
+  lines.push('');
+
+  return lines.join('\n');
+}