@mmapp/react-compiler 0.1.0-alpha.1 → 0.1.0-alpha.4

package/src/cli/registry-client.ts

@@ -1,175 +0,0 @@
-/**
- * Registry client — fetches workflow definitions from the MindMatrix API.
- * Uses native fetch (Node 18+). No external dependencies.
- */
-
-export interface RegistryConfig {
-  apiUrl: string;
-  authToken?: string;
-}
-
-export interface WorkflowDefinitionResponse {
-  id?: string;
-  slug: string;
-  name: string;
-  version: string;
-  description?: string;
-  category: string;
-  fields: Array<{
-    name: string;
-    type: string;
-    typeVersion?: string;
-    baseType?: string;
-    label?: string;
-    required?: boolean;
-    default_value?: unknown;
-    computed?: string;
-    computed_deps?: string[];
-    validation?: {
-      enum?: string[];
-      min?: number;
-      max?: number;
-      pattern?: string;
-    };
-  }>;
-  states: Array<{
-    name: string;
-    type: string;
-    description?: string;
-  }>;
-  transitions: Array<{
-    name: string;
-    from: string[];
-    to: string;
-    description?: string;
-    roles?: string[];
-    auto?: boolean;
-    required_fields?: string[];
-  }>;
-  roles?: Array<{ name: string; description?: string }>;
-  metadata?: Record<string, unknown>;
-  experience?: unknown;
-  view?: unknown;
-}
-
-function buildHeaders(config: RegistryConfig): Record<string, string> {
-  const headers: Record<string, string> = {
-    'Content-Type': 'application/json',
-  };
-  if (config.authToken) {
-    headers['Authorization'] = `Bearer ${config.authToken}`;
-  }
-  return headers;
-}
-
-function extractDefinition(data: unknown): WorkflowDefinitionResponse | null {
-  if (!data || typeof data !== 'object') return null;
-
-  // Handle array responses
-  if (Array.isArray(data)) {
-    return data.length > 0 ? (data[0] as WorkflowDefinitionResponse) : null;
-  }
-
-  const obj = data as Record<string, unknown>;
-
-  // Handle paginated responses
-  const items = obj.items ?? obj.data;
-  if (items && Array.isArray(items)) {
-    return items.length > 0 ? (items[0] as WorkflowDefinitionResponse) : null;
-  }
-
-  // Direct object — must have slug
-  if ('slug' in obj) {
-    return obj as unknown as WorkflowDefinitionResponse;
-  }
-
-  return null;
-}
-
-function extractDefinitions(data: unknown): WorkflowDefinitionResponse[] {
-  if (!data || typeof data !== 'object') return [];
-
-  if (Array.isArray(data)) {
-    return data as WorkflowDefinitionResponse[];
-  }
-
-  const obj = data as Record<string, unknown>;
-  const items = obj.items ?? obj.data;
-  if (items && Array.isArray(items)) {
-    return items as WorkflowDefinitionResponse[];
-  }
-
-  if ('slug' in obj) {
-    return [obj as unknown as WorkflowDefinitionResponse];
-  }
-
-  return [];
-}
-
-/**
- * Fetch a single workflow definition by slug.
- */
-export async function fetchDefinition(
-  slug: string,
-  config: RegistryConfig,
-): Promise<WorkflowDefinitionResponse> {
-  const url = `${config.apiUrl}/workflow/definitions?slug=${encodeURIComponent(slug)}`;
-
-  let res: Response;
-  try {
-    res = await fetch(url, { headers: buildHeaders(config) });
-  } catch (err) {
-    throw new Error(
-      `Failed to connect to registry at ${config.apiUrl}. ` +
-      `Is the API server running? (${err instanceof Error ? err.message : String(err)})`,
-    );
-  }
-
-  if (!res.ok) {
-    if (res.status === 401) {
-      throw new Error('Authentication required. Provide --token or set MM_AUTH_TOKEN.');
-    }
-    if (res.status === 404) {
-      throw new Error(`Definition "${slug}" not found in registry.`);
-    }
-    throw new Error(`Registry returned ${res.status}: ${res.statusText}`);
-  }
-
-  const data = await res.json();
-  const def = extractDefinition(data);
-  if (!def) {
-    throw new Error(`Definition "${slug}" not found in registry.`);
-  }
-
-  return def;
-}
-
-/**
- * Search definitions by query string.
- */
-export async function searchDefinitions(
-  query: string,
-  config: RegistryConfig,
-): Promise<WorkflowDefinitionResponse[]> {
-  const url = `${config.apiUrl}/workflow/catalog/definitions?search=${encodeURIComponent(query)}`;
-
-  let res: Response;
-  try {
-    res = await fetch(url, { headers: buildHeaders(config) });
-  } catch (err) {
-    throw new Error(
-      `Failed to connect to registry at ${config.apiUrl}. ` +
-      `Is the API server running? (${err instanceof Error ? err.message : String(err)})`,
-    );
-  }
-
-  if (!res.ok) {
-    if (res.status === 401) {
-      throw new Error('Authentication required. Provide --token or set MM_AUTH_TOKEN.');
-    }
-    throw new Error(`Registry returned ${res.status}: ${res.statusText}`);
-  }
-
-  const data = await res.json();
-  return extractDefinitions(data);
-}

package/src/cli/test.ts

@@ -1,397 +0,0 @@
-/**
- * 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 };
-}