@mmapp/react-compiler 0.1.0-alpha.1

package/dist/codemod/cli.mjs

@@ -0,0 +1,157 @@
+#!/usr/bin/env node
+import {
+  transform
+} from "../chunk-CKGOZAB7.mjs";
+import "../chunk-Y6FXYEAI.mjs";
+
+// src/codemod/cli.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { resolve, relative, dirname } from "path";
+import { glob } from "glob";
+function parseArgs(argv) {
+  const args = argv.slice(2);
+  const direction = args[0];
+  if (!direction || !["forward", "reverse", "verify"].includes(direction)) {
+    console.error("Usage: mm-codemod <forward|reverse|verify> <paths...> [options]");
+    console.error("");
+    console.error("Options:");
+    console.error("  --dry-run           Print diff without writing");
+    console.error("  --strip-annotations Remove @mm-original comments");
+    console.error("  --mode <mode>       State mode: preserve|migrate|annotate");
+    console.error("  --out <dir>         Output directory (default: in-place)");
+    console.error("  --verbose           Log every transformation");
+    process.exit(1);
+  }
+  const paths = [];
+  let dryRun = false;
+  let stripAnnotations = false;
+  let stateMode = "preserve";
+  let verbose = false;
+  let outDir;
+  for (let i = 1; i < args.length; i++) {
+    const arg = args[i];
+    if (arg === "--dry-run") {
+      dryRun = true;
+    } else if (arg === "--strip-annotations") {
+      stripAnnotations = true;
+    } else if (arg === "--mode") {
+      stateMode = args[++i];
+    } else if (arg === "--out") {
+      outDir = args[++i];
+    } else if (arg === "--verbose") {
+      verbose = true;
+    } else if (!arg.startsWith("-")) {
+      paths.push(arg);
+    }
+  }
+  if (paths.length === 0) {
+    console.error("Error: No paths specified");
+    process.exit(1);
+  }
+  return { direction, paths, dryRun, stripAnnotations, stateMode, verbose, outDir };
+}
+async function findFiles(paths) {
+  const files = [];
+  for (const p of paths) {
+    const resolved = resolve(p);
+    const matches = await glob("**/*.{tsx,jsx}", {
+      cwd: resolved,
+      absolute: true,
+      ignore: ["**/node_modules/**", "**/__tests__/**", "**/dist/**"]
+    });
+    files.push(...matches);
+  }
+  return files.sort();
+}
+function transformFile(filePath, options, verbose) {
+  const source = readFileSync(filePath, "utf-8");
+  try {
+    const result = transform(source, options);
+    const changed = result.code !== source;
+    if (verbose && changed) {
+      console.log(`  [${options.direction}] ${relative(process.cwd(), filePath)}`);
+    }
+    return { code: result.code, changed };
+  } catch (err) {
+    console.error(`  [ERROR] ${relative(process.cwd(), filePath)}: ${err.message}`);
+    return { code: source, changed: false };
+  }
+}
+async function main() {
+  const opts = parseArgs(process.argv);
+  const files = await findFiles(opts.paths);
+  console.log(`mm-codemod: ${opts.direction} \u2014 ${files.length} file(s)`);
+  if (opts.direction === "verify") {
+    let pass = 0;
+    let fail = 0;
+    for (const file of files) {
+      const source = readFileSync(file, "utf-8");
+      const forward = transform(source, {
+        direction: "forward",
+        annotate: true,
+        stateMode: opts.stateMode
+      });
+      const roundTripped = transform(forward.code, {
+        direction: "reverse",
+        annotate: false,
+        stateMode: opts.stateMode
+      });
+      const normalize = (s) => s.replace(/\s+/g, " ").trim();
+      if (normalize(roundTripped.code) === normalize(source)) {
+        pass++;
+        if (opts.verbose) console.log(`  [PASS] ${relative(process.cwd(), file)}`);
+      } else {
+        fail++;
+        console.log(`  [FAIL] ${relative(process.cwd(), file)}`);
+        if (opts.verbose) {
+          console.log("    Expected (normalized):");
+          console.log(`      ${normalize(source).slice(0, 200)}...`);
+          console.log("    Got (normalized):");
+          console.log(`      ${normalize(roundTripped.code).slice(0, 200)}...`);
+        }
+      }
+    }
+    console.log(`
+Results: ${pass} pass, ${fail} fail out of ${files.length} files`);
+    process.exit(fail > 0 ? 1 : 0);
+  }
+  const codemodOptions = {
+    direction: opts.direction,
+    annotate: !opts.stripAnnotations,
+    stateMode: opts.stateMode
+  };
+  let changed = 0;
+  let unchanged = 0;
+  let errors = 0;
+  for (const file of files) {
+    try {
+      const result = transformFile(file, codemodOptions, opts.verbose);
+      if (!result.changed) {
+        unchanged++;
+        continue;
+      }
+      changed++;
+      if (opts.dryRun) {
+        console.log(`  [WOULD CHANGE] ${relative(process.cwd(), file)}`);
+        continue;
+      }
+      let outPath = file;
+      if (opts.outDir) {
+        const rel = relative(resolve(opts.paths[0]), file);
+        outPath = resolve(opts.outDir, rel);
+        const dir = dirname(outPath);
+        if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+      }
+      writeFileSync(outPath, result.code, "utf-8");
+    } catch (err) {
+      errors++;
+      console.error(`  [ERROR] ${relative(process.cwd(), file)}: ${err.message}`);
+    }
+  }
+  console.log(`
+Done: ${changed} changed, ${unchanged} unchanged, ${errors} errors`);
+}
+main().catch((err) => {
+  console.error(err);
+  process.exit(1);
+});

package/dist/codemod/index.d.mts

@@ -0,0 +1,148 @@
+import * as t from '@babel/types';
+
+/**
+ * State transform — handles useState ↔ useQuery/useMutation migration.
+ *
+ * Three modes:
+ *   preserve (default): useState stays as-is
+ *   annotate: Adds @mm-field comments without changing code
+ *   migrate: Converts annotated useState to useQuery/useMutation
+ */
+
+type StateMode = 'preserve' | 'annotate' | 'migrate';
+
+/**
+ * Import manager — tracks atom usage and rewrites imports.
+ */
+
+interface ImportTracker {
+    /** Mark an atom as used (forward: add to imports) */
+    addAtom(name: string): void;
+    /** Mark an atom as removed (reverse: remove from imports) */
+    removeAtom(name: string): void;
+    /** Get the set of atoms that need importing */
+    getUsedAtoms(): Set<string>;
+    /** Get the set of atoms that were removed */
+    getRemovedAtoms(): Set<string>;
+}
+declare function createImportTracker(): ImportTracker;
+
+/**
+ * Element classifier — analyzes tag name + className to determine target atom.
+ */
+
+interface ClassifyResult {
+    atom: string;
+    /** Classes to remove from className (implicit in atom) */
+    removeClasses: string[];
+    /** Props to add to the element */
+    addProps: Record<string, string | boolean>;
+    /** Original tag for annotation */
+    originalTag: string;
+}
+interface ReverseClassifyResult {
+    htmlTag: string;
+    /** Classes to inject into className */
+    injectClasses: string[];
+    /** Props to remove (encoded in HTML tag) */
+    removeProps: string[];
+}
+/**
+ * Extract static class names from a className JSX attribute value.
+ * Handles: string literals, template literals (static parts), cn() first arg.
+ */
+declare function extractStaticClasses(attrValue: t.Node | null | undefined): string[];
+/**
+ * Classify a raw HTML element into its target workflow atom.
+ */
+declare function classifyElement(tagName: string, classNames: string[]): ClassifyResult | null;
+/**
+ * Reverse-classify a workflow atom into its target HTML element.
+ */
+declare function reverseClassifyAtom(atomName: string, props: Map<string, t.Node>): ReverseClassifyResult | null;
+
+/**
+ * Bidirectional element mapping rules.
+ *
+ * Each rule defines:
+ *  - htmlTag: The raw React element tag name
+ *  - atom: The workflow atom component name
+ *  - classSignal: Tailwind classes that trigger this mapping (forward)
+ *  - implicitClasses: Classes that are implicit in the atom and should be
+ *    removed on forward / added on reverse
+ *  - props: Additional props to set on forward / remove on reverse
+ */
+interface MappingRule {
+    htmlTag: string;
+    atom: string;
+    /** Classes in className that signal this atom (forward classification) */
+    classSignal?: string[];
+    /** Classes implicit in the atom — removed on forward, injected on reverse */
+    implicitClasses?: string[];
+    /** Props added on forward, removed on reverse */
+    props?: Record<string, string | boolean>;
+    /** Priority when multiple rules match (higher wins) */
+    priority?: number;
+}
+/**
+ * Forward rules: HTML element → Atom
+ * Ordered by specificity — more specific signals checked first.
+ */
+declare const FORWARD_RULES: MappingRule[];
+/**
+ * Reverse rules: Atom → HTML element
+ * Derived from forward rules but keyed by atom name.
+ */
+interface ReverseRule {
+    atom: string;
+    htmlTag: string;
+    /** Classes to inject into className on reverse */
+    injectClasses?: string[];
+    /** Props to remove on reverse (they're encoded in the HTML tag) */
+    removeProps?: string[];
+}
+declare const REVERSE_RULES: ReverseRule[];
+/**
+ * Atom import source
+ */
+declare const ATOM_IMPORT_SOURCE = "@mindmatrix/react/atoms";
+
+/**
+ * Bidirectional React ↔ Workflow Atom Codemod
+ *
+ * Babel plugin entry point. Dispatches by `direction` option.
+ *
+ * Usage as Babel plugin:
+ *   plugins: [['@mindmatrix/react-compiler/codemod', { direction: 'forward' }]]
+ *
+ * Usage programmatic:
+ *   import { transform } from '@mindmatrix/react-compiler/codemod';
+ *   const result = transform(source, { direction: 'forward' });
+ */
+
+interface CodemodOptions {
+    /** Transform direction */
+    direction: 'forward' | 'reverse';
+    /** Add/strip @mm-original annotations */
+    annotate?: boolean;
+    /** State transform mode (default: 'preserve') */
+    stateMode?: StateMode;
+}
+/**
+ * Babel plugin — use via .babelrc or programmatic config.
+ */
+declare const codemodPlugin: any;
+
+/**
+ * Programmatic transform API.
+ *
+ * @param source - Source code string
+ * @param options - Codemod options
+ * @returns Transformed source code
+ */
+declare function transform(source: string, options: CodemodOptions): {
+    code: string;
+    map: any;
+};
+
+export { ATOM_IMPORT_SOURCE, type ClassifyResult, type CodemodOptions, FORWARD_RULES, type MappingRule, REVERSE_RULES, type ReverseClassifyResult, type ReverseRule, classifyElement, codemodPlugin, createImportTracker, codemodPlugin as default, extractStaticClasses, reverseClassifyAtom, transform };

package/dist/codemod/index.d.ts

@@ -0,0 +1,148 @@
+import * as t from '@babel/types';
+
+/**
+ * State transform — handles useState ↔ useQuery/useMutation migration.
+ *
+ * Three modes:
+ *   preserve (default): useState stays as-is
+ *   annotate: Adds @mm-field comments without changing code
+ *   migrate: Converts annotated useState to useQuery/useMutation
+ */
+
+type StateMode = 'preserve' | 'annotate' | 'migrate';
+
+/**
+ * Import manager — tracks atom usage and rewrites imports.
+ */
+
+interface ImportTracker {
+    /** Mark an atom as used (forward: add to imports) */
+    addAtom(name: string): void;
+    /** Mark an atom as removed (reverse: remove from imports) */
+    removeAtom(name: string): void;
+    /** Get the set of atoms that need importing */
+    getUsedAtoms(): Set<string>;
+    /** Get the set of atoms that were removed */
+    getRemovedAtoms(): Set<string>;
+}
+declare function createImportTracker(): ImportTracker;
+
+/**
+ * Element classifier — analyzes tag name + className to determine target atom.
+ */
+
+interface ClassifyResult {
+    atom: string;
+    /** Classes to remove from className (implicit in atom) */
+    removeClasses: string[];
+    /** Props to add to the element */
+    addProps: Record<string, string | boolean>;
+    /** Original tag for annotation */
+    originalTag: string;
+}
+interface ReverseClassifyResult {
+    htmlTag: string;
+    /** Classes to inject into className */
+    injectClasses: string[];
+    /** Props to remove (encoded in HTML tag) */
+    removeProps: string[];
+}
+/**
+ * Extract static class names from a className JSX attribute value.
+ * Handles: string literals, template literals (static parts), cn() first arg.
+ */
+declare function extractStaticClasses(attrValue: t.Node | null | undefined): string[];
+/**
+ * Classify a raw HTML element into its target workflow atom.
+ */
+declare function classifyElement(tagName: string, classNames: string[]): ClassifyResult | null;
+/**
+ * Reverse-classify a workflow atom into its target HTML element.
+ */
+declare function reverseClassifyAtom(atomName: string, props: Map<string, t.Node>): ReverseClassifyResult | null;
+
+/**
+ * Bidirectional element mapping rules.
+ *
+ * Each rule defines:
+ *  - htmlTag: The raw React element tag name
+ *  - atom: The workflow atom component name
+ *  - classSignal: Tailwind classes that trigger this mapping (forward)
+ *  - implicitClasses: Classes that are implicit in the atom and should be
+ *    removed on forward / added on reverse
+ *  - props: Additional props to set on forward / remove on reverse
+ */
+interface MappingRule {
+    htmlTag: string;
+    atom: string;
+    /** Classes in className that signal this atom (forward classification) */
+    classSignal?: string[];
+    /** Classes implicit in the atom — removed on forward, injected on reverse */
+    implicitClasses?: string[];
+    /** Props added on forward, removed on reverse */
+    props?: Record<string, string | boolean>;
+    /** Priority when multiple rules match (higher wins) */
+    priority?: number;
+}
+/**
+ * Forward rules: HTML element → Atom
+ * Ordered by specificity — more specific signals checked first.
+ */
+declare const FORWARD_RULES: MappingRule[];
+/**
+ * Reverse rules: Atom → HTML element
+ * Derived from forward rules but keyed by atom name.
+ */
+interface ReverseRule {
+    atom: string;
+    htmlTag: string;
+    /** Classes to inject into className on reverse */
+    injectClasses?: string[];
+    /** Props to remove on reverse (they're encoded in the HTML tag) */
+    removeProps?: string[];
+}
+declare const REVERSE_RULES: ReverseRule[];
+/**
+ * Atom import source
+ */
+declare const ATOM_IMPORT_SOURCE = "@mindmatrix/react/atoms";
+
+/**
+ * Bidirectional React ↔ Workflow Atom Codemod
+ *
+ * Babel plugin entry point. Dispatches by `direction` option.
+ *
+ * Usage as Babel plugin:
+ *   plugins: [['@mindmatrix/react-compiler/codemod', { direction: 'forward' }]]
+ *
+ * Usage programmatic:
+ *   import { transform } from '@mindmatrix/react-compiler/codemod';
+ *   const result = transform(source, { direction: 'forward' });
+ */
+
+interface CodemodOptions {
+    /** Transform direction */
+    direction: 'forward' | 'reverse';
+    /** Add/strip @mm-original annotations */
+    annotate?: boolean;
+    /** State transform mode (default: 'preserve') */
+    stateMode?: StateMode;
+}
+/**
+ * Babel plugin — use via .babelrc or programmatic config.
+ */
+declare const codemodPlugin: any;
+
+/**
+ * Programmatic transform API.
+ *
+ * @param source - Source code string
+ * @param options - Codemod options
+ * @returns Transformed source code
+ */
+declare function transform(source: string, options: CodemodOptions): {
+    code: string;
+    map: any;
+};
+
+export { ATOM_IMPORT_SOURCE, type ClassifyResult, type CodemodOptions, FORWARD_RULES, type MappingRule, REVERSE_RULES, type ReverseClassifyResult, type ReverseRule, classifyElement, codemodPlugin, createImportTracker, codemodPlugin as default, extractStaticClasses, reverseClassifyAtom, transform };