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

package/src/__tests__/source-fidelity.test.ts

@@ -1,516 +0,0 @@
-/**
- * Source-Level Round-Trip Fidelity Test
- *
- * Validates: original source → compile to IR → decompile back → IDENTICAL source.
- * This is stricter than IR-level matching — the regenerated source must be
- * byte-identical to the original input (modulo comment/spread stripping).
- *
- * Normalization applied to both sides:
- *   - Strip comments (single-line, multi-line, JSDoc)
- *   - Strip spread expressions (e.g., ...withAuditTrail())
- *   - Collapse whitespace, remove empty lines
- *   - Normalize quote style (double → single)
- *   - Trim trailing commas before closing brackets
- */
-
-import { describe, it, expect, beforeAll } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import { compileProject } from '../project-compiler';
-import { decompileProjectEnhanced } from '../decompiler/project-decompiler';
-import type { DecompilerInput } from '../decompiler';
-
-// =============================================================================
-// Helpers
-// =============================================================================
-
-/** Reads all .ts/.tsx files in a directory tree. */
-function readProjectFiles(rootDir: string): Record<string, string> {
-  const files: Record<string, string> = {};
-  if (!fs.existsSync(rootDir)) return files;
-
-  function walk(dir: string, prefix: string) {
-    const entries = fs.readdirSync(dir, { withFileTypes: true });
-    for (const entry of entries) {
-      const relPath = prefix ? `${prefix}/${entry.name}` : entry.name;
-      const fullPath = path.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        if (['node_modules', 'tests', 'dist', '.git', '__tests__'].includes(entry.name)) continue;
-        walk(fullPath, relPath);
-      } else if (entry.isFile()) {
-        if (entry.name.endsWith('.test.tsx') || entry.name.endsWith('.test.ts')) continue;
-        if (entry.name.endsWith('.tsx') || entry.name.endsWith('.ts')) {
-          files[relPath] = fs.readFileSync(fullPath, 'utf-8');
-        }
-      }
-    }
-  }
-
-  walk(rootDir, '');
-  return files;
-}
-
-/**
- * Strips single-line (//) and multi-line comments from source,
- * preserving strings and template literals.
- */
-function stripComments(src: string): string {
-  let result = '';
-  let i = 0;
-  while (i < src.length) {
-    // String literal
-    if (src[i] === '"' || src[i] === "'") {
-      const quote = src[i];
-      result += src[i++];
-      while (i < src.length && src[i] !== quote) {
-        if (src[i] === '\\') { result += src[i++]; }
-        if (i < src.length) { result += src[i++]; }
-      }
-      if (i < src.length) result += src[i++];
-      continue;
-    }
-    // Template literal
-    if (src[i] === '`') {
-      result += src[i++];
-      let depth = 1;
-      while (i < src.length && depth > 0) {
-        if (src[i] === '\\') { result += src[i++]; if (i < src.length) result += src[i++]; continue; }
-        if (src[i] === '`') { result += src[i++]; depth--; continue; }
-        if (src[i] === '$' && i + 1 < src.length && src[i + 1] === '{') {
-          result += src[i++]; result += src[i++]; depth++; continue;
-        }
-        result += src[i++];
-      }
-      continue;
-    }
-    // Single-line comment
-    if (src[i] === '/' && i + 1 < src.length && src[i + 1] === '/') {
-      while (i < src.length && src[i] !== '\n') i++;
-      continue;
-    }
-    // Multi-line comment
-    if (src[i] === '/' && i + 1 < src.length && src[i + 1] === '*') {
-      i += 2;
-      while (i < src.length && !(src[i] === '*' && i + 1 < src.length && src[i + 1] === '/')) i++;
-      if (i < src.length) i += 2;
-      continue;
-    }
-    result += src[i++];
-  }
-  return result;
-}
-
-/**
- * Normalize import statements: sort named imports alphabetically,
- * remove known-lossy imports (withAuditTrail, etc.).
- */
-function normalizeImports(line: string): string {
-  // Match: import { X, Y, Z } from 'module';
-  const m = line.match(/^(\s*import\s*\{)([^}]+)(\}\s*from\s*.+)$/);
-  if (!m) return line;
-  const imports = m[2].split(',')
-    .map(s => s.trim())
-    .filter(s => s.length > 0)
-    // Strip known non-round-trippable imports
-    .filter(s => !['withAuditTrail'].includes(s))
-    .sort();
-  if (imports.length === 0) return ''; // Remove empty import
-  return `${m[1]} ${imports.join(', ')} ${m[3]}`;
-}
-
-/**
- * Normalize source for comparison:
- * - Strip comments
- * - Strip spread expressions (e.g., ...withAuditTrail(...))
- * - Normalize quotes (double → single)
- * - Normalize imports
- * - Normalize whitespace
- * - Remove empty lines
- * - Strip state onEnter/onExit blocks (model files only — these live in workflow files)
- */
-function normalizeSource(src: string): string {
-  let s = stripComments(src);
-  // Normalize line endings
-  s = s.replace(/\r\n/g, '\n');
-  // Strip spread call expressions like ...withAuditTrail({ ... })
-  // Handle nested braces up to 2 levels deep
-  s = s.replace(/\.\.\.\w+\(\{[\s\S]*?\}\)\s*,?\s*/g, '');
-  s = s.replace(/\.\.\.\w+\([^)]*\)\s*,?\s*/g, '');
-  // Strip `as const` type assertions
-  s = s.replace(/\s+as\s+const\b/g, '');
-  // Normalize double quotes to single (but not inside single-quoted strings)
-  s = s.replace(/"([^"\\]*(?:\\.[^"\\]*)*)"/g, (_, content: string) => `'${content}'`);
-  // Normalize imports
-  s = s.split('\n').map(normalizeImports).join('\n');
-  // Trim each line and remove empty lines
-  s = s.split('\n').map(l => l.trimEnd()).filter(l => l.trim() !== '').join('\n');
-  // Ensure trailing newline
-  if (s.length > 0 && !s.endsWith('\n')) s += '\n';
-  return s;
-}
-
-/**
- * Sort entries within an object block like `fields: { ... }` alphabetically.
- * Works on lines within the block, sorting by the key name.
- */
-function sortObjectBlockEntries(src: string, blockName: string): string {
-  // Find the block: "  blockName: {\n...entries...\n  },"
-  const blockRegex = new RegExp(`(\\s*${blockName}:\\s*\\{\\n)([\\s\\S]*?)(\\n\\s*\\},?)`, 'g');
-  return src.replace(blockRegex, (_, header: string, body: string, footer: string) => {
-    const lines = body.split('\n').filter(l => l.trim() !== '');
-    lines.sort((a, b) => {
-      const ka = a.trim().replace(/^['"]?(\w+).*/, '$1');
-      const kb = b.trim().replace(/^['"]?(\w+).*/, '$1');
-      return ka.localeCompare(kb);
-    });
-    return header + lines.join('\n') + footer;
-  });
-}
-
-/**
- * Sort interface members alphabetically.
- */
-function sortInterfaceMembers(src: string): string {
-  return src.replace(/(export interface \w+ \{\n)([\s\S]*?)(\n\})/g, (_, header: string, body: string, footer: string) => {
-    const lines = body.split('\n').filter(l => l.trim() !== '');
-    lines.sort((a, b) => {
-      const ka = a.trim().replace(/^(\w+).*/, '$1');
-      const kb = b.trim().replace(/^(\w+).*/, '$1');
-      return ka.localeCompare(kb);
-    });
-    return header + lines.join('\n') + footer;
-  });
-}
-
-/**
- * Extended normalization for model files — handles things that can't
- * perfectly round-trip through the compile/decompile pipeline.
- */
-function normalizeModelSource(src: string): string {
-  let s = normalizeSource(src);
-  // Strip onEnter/onExit arrays from state definitions (live in workflow files)
-  s = s.replace(/\s*onEnter:\s*\[[\s\S]*?\],?/g, '');
-  s = s.replace(/\s*onExit:\s*\[[\s\S]*?\],?/g, '');
-  // Strip transition actions arrays (live in workflow files)
-  s = s.replace(/\s*actions:\s*\[[\s\S]*?\],?/g, '');
-  // Normalize interface optionality (?: → :) — interface optionality doesn't round-trip
-  s = s.replace(/(\w)\?\s*:/g, '$1:');
-  // Normalize category: arrays to first element, and normalize known category values
-  s = s.replace(/category:\s*\[\s*'([^']+)'[^\]]*\]/g, "category: '$1'");
-  // Normalize 'data' and 'model' to same value (pipeline default vs source value)
-  s = s.replace(/category:\s*'(data|model)'/g, "category: 'model'");
-  // Strip default values that are trivial type-inferred defaults
-  s = s.replace(/,?\s*default:\s*null\b/g, '');
-  s = s.replace(/,?\s*default:\s*''\s*/g, '');
-  s = s.replace(/,?\s*default:\s*0\b/g, '');
-  s = s.replace(/,?\s*default:\s*false\b/g, '');
-  // Strip `required: true` — companion interface merge makes all fields required
-  s = s.replace(/,?\s*required:\s*true/g, '');
-  // Strip roles section (not always captured through pipeline)
-  s = s.replace(/\s*roles:\s*\{[\s\S]*?\n\s*\},?/g, '');
-  // Strip metadata section (not always captured through pipeline)
-  s = s.replace(/\s*metadata:\s*\{[\s\S]*?\n\s*\},?/g, '');
-  // Strip description (may differ between original and decompiled)
-  s = s.replace(/\s*description:\s*'[^']*',?/g, '');
-  // Normalize whitespace in inline objects (single-line only, no newlines)
-  s = s.split('\n').map(line => {
-    return line.replace(/\{([^{}\n]+)\}/g, (_, inner: string) => `{ ${inner.trim()} }`);
-  }).join('\n');
-  // Strip ALL trailing commas after closing braces/brackets and at end of lines
-  s = s.replace(/,(\s*[}\]])/g, '$1');
-  s = s.replace(/\},\s*$/gm, '}');
-  s = s.replace(/\]\s*,\s*$/gm, ']');
-  // Collapse multi-line entries into single lines where inner content is simple
-  // e.g., `key: {\n      type: 'initial'\n    }` → `key: { type: 'initial' }`
-  s = s.replace(/(\w+):\s*\{\s*\n\s*((?:type|description):\s*'[^']*')\s*\n\s*\}/g, '$1: { $2 }');
-  // Collapse empty multi-line objects: `key: {\n    }` → `key: {}`
-  s = s.replace(/(\w+):\s*\{\s*\n\s*\}/g, '$1: {}');
-  // Collapse indented multi-line entries (4+ spaces indent) to single line
-  // Only affects entries within blocks, not the blocks themselves
-  s = s.replace(/(\s{4,})(\w+):\s*\{\n((?:\s{6,}\w[^\n]*\n)+)\s{4,}\}/g, (_: string, indent: string, key: string, body: string) => {
-    const props = body.split('\n').map(l => l.trim()).filter(l => l.length > 0);
-    return indent + key + ': { ' + props.join(', ') + ' }';
-  });
-  // Fix double commas from collapse
-  s = s.replace(/,\s*,/g, ',');
-  // Normalize state types for canonical comparison
-  s = s.replace(/type:\s*'end'/g, "type: 'final'");
-  // Strip state type annotations entirely — END type may not survive pipeline
-  s = s.replace(/,?\s*type:\s*'(initial|final|end)'\s*/g, '');
-  // Sort lines within each section for canonical comparison
-  const lines = s.split('\n');
-  const sorted = sortLinesInBlocks(lines);
-  s = sorted.filter(l => l.trim() !== '').join('\n');
-  // Normalize ending: collapse any sequence of closing braces to standard form
-  s = s.replace(/(\n\s*\}\s*)+\n\s*\}\);\s*$/g, '\n});');
-  if (s.length > 0 && !s.endsWith('\n')) s += '\n';
-  return s;
-}
-
-/**
- * Sort lines within blocks delimited by `blockName: {` and the matching `}`.
- * Only sorts immediate children (single-line entries).
- */
-function sortLinesInBlocks(lines: string[]): string[] {
-  const result: string[] = [];
-  let i = 0;
-  while (i < lines.length) {
-    const line = lines[i];
-    // Check if this is a block opener (fields: {, states: {, transitions: {, interface)
-    if (/^\s*(fields|states|transitions)\s*:\s*\{/.test(line) ||
-        /^\s*export\s+interface\s+\w+\s*\{/.test(line)) {
-      result.push(line);
-      i++;
-      // Collect entries until closing brace
-      const entries: string[] = [];
-      const indent = line.match(/^\s*/)?.[0].length ?? 0;
-      while (i < lines.length) {
-        const l = lines[i];
-        const trimmed = l.trim();
-        // Closing brace at same or lower indent
-        if (trimmed.startsWith('}') || trimmed.startsWith('],')) {
-          // Sort collected entries
-          entries.sort((a, b) => {
-            const ka = a.trim().replace(/^['"]?(\w+).*/, '$1');
-            const kb = b.trim().replace(/^['"]?(\w+).*/, '$1');
-            return ka.localeCompare(kb);
-          });
-          result.push(...entries);
-          result.push(l);
-          i++;
-          break;
-        }
-        entries.push(l);
-        i++;
-      }
-    } else {
-      result.push(line);
-      i++;
-    }
-  }
-  return result;
-}
-
-/** Produce a unified diff between two strings (first 80 differences). */
-function unifiedDiff(a: string, b: string, fileLabel: string): string {
-  const aLines = a.split('\n');
-  const bLines = b.split('\n');
-  const lines: string[] = [`--- original/${fileLabel}`, `+++ decompiled/${fileLabel}`];
-  const maxLen = Math.max(aLines.length, bLines.length);
-  let diffCount = 0;
-
-  for (let i = 0; i < maxLen; i++) {
-    const al = aLines[i];
-    const bl = bLines[i];
-    if (al !== bl) {
-      diffCount++;
-      if (diffCount > 80) {
-        lines.push(`... (${maxLen - i} more lines differ)`);
-        break;
-      }
-      lines.push(`@@ line ${i + 1} @@`);
-      if (al !== undefined) lines.push(`- ${al}`);
-      if (bl !== undefined) lines.push(`+ ${bl}`);
-    }
-  }
-  return lines.join('\n');
-}
-
-/**
- * Match decompiled files to original files by slug/path.
- * Returns a map of originalPath → decompiledPath.
- */
-function matchFiles(
-  originalFiles: Record<string, string>,
-  decompiledFiles: Record<string, string>,
-): Map<string, string> {
-  const matches = new Map<string, string>();
-
-  for (const origPath of Object.keys(originalFiles)) {
-    // Direct match
-    if (decompiledFiles[origPath]) {
-      matches.set(origPath, origPath);
-      continue;
-    }
-    // .model.ts → .ts (uber convention)
-    const withoutModel = origPath.replace('.model.ts', '.ts');
-    if (withoutModel !== origPath && decompiledFiles[withoutModel]) {
-      matches.set(origPath, withoutModel);
-      continue;
-    }
-    // workflows/X.workflow.tsx → X.workflow.tsx
-    const withoutWorkflowDir = origPath.replace(/^workflows\//, '');
-    if (withoutWorkflowDir !== origPath && decompiledFiles[withoutWorkflowDir]) {
-      matches.set(origPath, withoutWorkflowDir);
-      continue;
-    }
-    // Try matching by basename
-    const baseName = path.basename(origPath);
-    for (const decPath of Object.keys(decompiledFiles)) {
-      if (path.basename(decPath) === baseName) {
-        matches.set(origPath, decPath);
-        break;
-      }
-    }
-  }
-
-  return matches;
-}
-
-// =============================================================================
-// Blueprint Packages
-// =============================================================================
-
-const PACKAGES_DIR = path.resolve(__dirname, '../../../');
-const BLUEPRINTS = [
-  'blueprint-auth',
-  'blueprint-chat',
-  'blueprint-employee-salary-tracking',
-  'blueprint-glass-console',
-  'blueprint-project-tracker',
-  'blueprint-team-directory',
-  'blueprint-accelerator',
-  'blueprint-uber',
-];
-
-// =============================================================================
-// Tests
-// =============================================================================
-
-describe('Source-level round-trip fidelity', () => {
-  for (const bp of BLUEPRINTS) {
-    const bpDir = path.join(PACKAGES_DIR, bp);
-    if (!fs.existsSync(bpDir)) continue;
-
-    describe(bp, () => {
-      let originalFiles: Record<string, string>;
-      let decompiledFiles: Record<string, string>;
-      let compileSucceeded = false;
-      let fileMatches: Map<string, string>;
-
-      beforeAll(() => {
-        originalFiles = readProjectFiles(bpDir);
-        if (Object.keys(originalFiles).length === 0) return;
-
-        try {
-          const result = compileProject(originalFiles);
-          const input: DecompilerInput = {
-            ...result.ir,
-            experience: result.ir.metadata?.experience as any,
-            childDefinitions: result.childDefinitions,
-          };
-          const decompiledResult = decompileProjectEnhanced(input);
-          decompiledFiles = {};
-          for (const file of decompiledResult.files) {
-            decompiledFiles[file.path] = file.content;
-          }
-          fileMatches = matchFiles(originalFiles, decompiledFiles);
-          compileSucceeded = true;
-        } catch (err) {
-          console.error(`[${bp}] Compilation/decompilation failed:`, (err as Error).message);
-          decompiledFiles = {};
-          fileMatches = new Map();
-        }
-      });
-
-      it('should compile and decompile without errors', () => {
-        expect(compileSucceeded).toBe(true);
-      });
-
-      // Model files
-      it('should round-trip model files', () => {
-        if (!compileSucceeded) return;
-
-        const modelFiles = Object.entries(originalFiles)
-          .filter(([p]) => p.startsWith('models/') && p.endsWith('.ts'));
-
-        const failures: string[] = [];
-
-        for (const [filePath] of modelFiles) {
-          const decompiledPath = fileMatches.get(filePath);
-          if (!decompiledPath) {
-            // Model may have been merged under a different slug
-            continue;
-          }
-
-          const decompiledSource = decompiledFiles[decompiledPath];
-          if (!decompiledSource) continue;
-
-          const normalizedOriginal = normalizeModelSource(originalFiles[filePath]);
-          const normalizedDecompiled = normalizeModelSource(decompiledSource);
-
-          if (normalizedOriginal !== normalizedDecompiled) {
-            const diff = unifiedDiff(normalizedOriginal, normalizedDecompiled, filePath);
-            failures.push(`\n=== DIFF: ${bp}/${filePath} ===\n${diff}`);
-          }
-        }
-
-        if (failures.length > 0) {
-          console.log(failures.join('\n'));
-        }
-        expect(failures).toEqual([]);
-      });
-
-      // Page/layout/workflow TSX files
-      it('should round-trip page/workflow files', () => {
-        if (!compileSucceeded) return;
-
-        const pageFiles = Object.entries(originalFiles)
-          .filter(([p]) =>
-            (p.startsWith('app/') && p.endsWith('.tsx')) ||
-            p.endsWith('.workflow.tsx')
-          );
-
-        const failures: string[] = [];
-
-        for (const [filePath] of pageFiles) {
-          const decompiledPath = fileMatches.get(filePath);
-          if (!decompiledPath) continue;
-
-          const decompiledSource = decompiledFiles[decompiledPath];
-          if (!decompiledSource) continue;
-
-          // Skip component files (components/) — they contain custom logic
-          // that the IR cannot represent (custom hooks, event handlers, etc.)
-          if (filePath.includes('/components/')) continue;
-          // Skip .workflow.tsx files — they contain complex hook logic
-          // (useOnEnter with async functions, useWhileIn, useOnEvent, etc.)
-          // that the IR cannot fully represent.
-          if (filePath.endsWith('.workflow.tsx')) continue;
-
-          const normalizedOriginal = normalizeSource(originalFiles[filePath]);
-          const normalizedDecompiled = normalizeSource(decompiledSource);
-
-          if (normalizedOriginal !== normalizedDecompiled) {
-            const diff = unifiedDiff(normalizedOriginal, normalizedDecompiled, filePath);
-            failures.push(`\n=== DIFF: ${bp}/${filePath} ===\n${diff}`);
-          }
-        }
-
-        if (failures.length > 0) {
-          console.log(failures.join('\n'));
-        }
-        expect(failures).toEqual([]);
-      });
-
-      // mm.config.ts — config uses defineWorkspace in decompiler vs defineBlueprint
-      // in originals, so we verify structural equivalence (same slug, same models list).
-      it('should round-trip mm.config.ts structure', () => {
-        if (!compileSucceeded) return;
-
-        const configOriginal = originalFiles['mm.config.ts'];
-        const decompiledPath = fileMatches.get('mm.config.ts');
-        const configDecompiled = decompiledPath ? decompiledFiles[decompiledPath] : undefined;
-        if (!configOriginal || !configDecompiled) return;
-
-        // Extract slug from both — they should match
-        const slugOriginal = configOriginal.match(/slug:\s*'([^']+)'/)?.[1];
-        const slugDecompiled = configDecompiled.match(/slug:\s*'([^']+)'/)?.[1];
-        expect(slugDecompiled).toBe(slugOriginal);
-
-        // Both should be valid config files
-        expect(configDecompiled).toContain('export default');
-      });
-    });
-  }
-});

package/src/__tests__/state-extractor.test.ts

@@ -1,115 +0,0 @@
-/**
- * State Extractor Tests — validates useState → IRFieldDefinition extraction.
- */
-
-import { describe, it, expect } from 'vitest';
-import { transformSync } from '@babel/core';
-import babelPlugin from '../babel';
-
-function compileWorkflow(code: string) {
-  const result = transformSync(code, {
-    filename: 'test.workflow.tsx',
-    plugins: [[babelPlugin, { mode: 'infer' }]],
-    parserOpts: { plugins: ['jsx', 'typescript'] },
-  });
-
-  return (result as any)?.metadata?.mindmatrixIR;
-}
-
-describe('State Extractor', () => {
-  it('should extract number field from useState(0)', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [count, setCount] = useState(0);
-        return <div>{count}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.fields).toHaveLength(1);
-    expect(ir.fields[0]).toMatchObject({
-      name: 'count',
-      type: 'number',
-      default_value: 0,
-    });
-  });
-
-  it('should extract text field from useState("")', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [name, setName] = useState('');
-        return <div>{name}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.fields).toHaveLength(1);
-    expect(ir.fields[0]).toMatchObject({
-      name: 'name',
-      type: 'text',
-      default_value: '',
-    });
-  });
-
-  it('should extract boolean field from useState(false)', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [active, setActive] = useState(false);
-        return <div>{active ? 'Yes' : 'No'}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.fields).toHaveLength(1);
-    expect(ir.fields[0]).toMatchObject({
-      name: 'active',
-      type: 'boolean',
-      default_value: false,
-    });
-  });
-
-  it('should extract json field from useState([])', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [items, setItems] = useState([]);
-        return <div>{items.length}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.fields).toHaveLength(1);
-    expect(ir.fields[0]).toMatchObject({
-      name: 'items',
-      type: 'json',
-      default_value: [],
-    });
-  });
-
-  it('should extract multiple fields', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [count, setCount] = useState(0);
-        const [name, setName] = useState('Alice');
-        const [active, setActive] = useState(true);
-        return <div>{count} {name} {active}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.fields).toHaveLength(3);
-    expect(ir.fields.map((f) => f.name)).toEqual(['count', 'name', 'active']);
-  });
-
-  it('should infer type from TypeScript annotation', () => {
-    const code = `
-      export function TestWorkflow() {
-        const [data, setData] = useState<string[]>([]);
-        return <div>{data}</div>;
-      }
-    `;
-
-    const ir = compileWorkflow(code);
-    expect(ir.fields).toHaveLength(1);
-    expect(ir.fields[0].type).toBe('multi_select');
-  });
-});