@mmapp/react-compiler 0.1.0-alpha.1

package/dist/cli/index.mjs

@@ -0,0 +1,701 @@
+#!/usr/bin/env node
+import {
+  deploy
+} from "../chunk-EQGA6A6D.mjs";
+import {
+  build
+} from "../chunk-KFGYOOVS.mjs";
+import "../chunk-5M7DKKBC.mjs";
+import "../chunk-HLRGCCIL.mjs";
+import {
+  __require
+} from "../chunk-Y6FXYEAI.mjs";
+
+// src/cli/test.ts
+import { glob } from "glob";
+import { readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+async function test(options = {}) {
+  const srcDir = options.src ?? ".";
+  const label = "[mindmatrix-react]";
+  console.log(`${label} Round-trip fidelity test
+`);
+  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 = {};
+  for (const f of allFiles) {
+    const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
+    fileMap[rel] = readFileSync(f, "utf-8");
+  }
+  const { compileProject } = await import("../project-compiler-EGJUTAJU.mjs");
+  const { decompileProjectEnhanced } = await import("../project-decompiler-5GY2KSG4.mjs");
+  process.stdout.write(`  Compiling project...`);
+  const t0 = performance.now();
+  let ir1;
+  let childDefs1;
+  try {
+    const result = compileProject(fileMap);
+    ir1 = result.ir;
+    childDefs1 = result.childDefinitions;
+    const compileErrors = result.errors.filter((e) => 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.message}`);
+    process.exit(1);
+  }
+  const t1 = performance.now();
+  console.log(` \u2713 (${((t1 - t0) / 1e3).toFixed(1)}s)`);
+  process.stdout.write(`  Decompiling IR...`);
+  const t2 = performance.now();
+  let decompFiles;
+  try {
+    const decompInput = {
+      ...ir1,
+      childDefinitions: childDefs1,
+      experience: ir1.experience
+    };
+    const decompResult = decompileProjectEnhanced(decompInput);
+    decompFiles = {};
+    for (const file of decompResult.files) {
+      decompFiles[file.path] = file.content;
+    }
+  } catch (err) {
+    console.log(` FAIL`);
+    console.error(`    ${err.message}`);
+    process.exit(1);
+  }
+  const t3 = performance.now();
+  console.log(` \u2713 (${((t3 - t2) / 1e3).toFixed(1)}s)`);
+  process.stdout.write(`  Recompiling...`);
+  const t4 = performance.now();
+  let ir2;
+  try {
+    const result2 = compileProject(decompFiles);
+    ir2 = result2.ir;
+    const recompileErrors = result2.errors.filter((e) => 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.message}`);
+    process.exit(1);
+  }
+  const t5 = performance.now();
+  console.log(` \u2713 (${((t5 - t4) / 1e3).toFixed(1)}s)`);
+  process.stdout.write(`  Comparing IR...
+`);
+  const t6 = performance.now();
+  const diffs = [];
+  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" });
+  }
+  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"}`);
+  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"}`);
+  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
+    }
+  };
+}
+function compareFields(diffs, fields1, fields2) {
+  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: void 0, 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: void 0, actual: name, severity: "warning" });
+    }
+  }
+  return { fieldMatch, fieldCount };
+}
+function isCompatibleType(t1, t2) {
+  const stringTypes = /* @__PURE__ */ new Set(["text", "rich_text", "email", "url", "phone", "color", "select"]);
+  const numberTypes = /* @__PURE__ */ 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;
+}
+function compareStates(diffs, states1, states2) {
+  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: void 0, severity: "error" });
+      continue;
+    }
+    if (!s2) {
+      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 };
+}
+function compareTransitions(diffs, transitions1, transitions2) {
+  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: void 0, 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 };
+}
+
+// src/cli/auth.ts
+import { readFileSync as readFileSync2, writeFileSync, mkdirSync, existsSync as existsSync2, unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+import { createInterface } from "readline";
+var MMRC_DIR = join(homedir(), ".mmrc");
+var CREDENTIALS_PATH = join(MMRC_DIR, "credentials.json");
+function loadCredentials() {
+  if (!existsSync2(CREDENTIALS_PATH)) return {};
+  try {
+    return JSON.parse(readFileSync2(CREDENTIALS_PATH, "utf-8"));
+  } catch {
+    return {};
+  }
+}
+function saveCredentials(apiUrl, token) {
+  mkdirSync(MMRC_DIR, { recursive: true, mode: 448 });
+  const creds = loadCredentials();
+  creds[apiUrl] = { token, savedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
+  try {
+    const { chmodSync } = __require("fs");
+    chmodSync(CREDENTIALS_PATH, 384);
+  } catch {
+  }
+}
+function removeCredentials(apiUrl) {
+  if (!existsSync2(CREDENTIALS_PATH)) return;
+  if (!apiUrl) {
+    unlinkSync(CREDENTIALS_PATH);
+    return;
+  }
+  const creds = loadCredentials();
+  delete creds[apiUrl];
+  if (Object.keys(creds).length === 0) {
+    unlinkSync(CREDENTIALS_PATH);
+  } else {
+    writeFileSync(CREDENTIALS_PATH, JSON.stringify(creds, null, 2), "utf-8");
+  }
+}
+function resolveToken(apiUrl, explicitToken) {
+  if (explicitToken) return explicitToken;
+  const envToken = process.env.MMRC_TOKEN;
+  if (envToken) return envToken;
+  const creds = loadCredentials();
+  const entry = creds[apiUrl];
+  if (entry?.token) return entry.token;
+  return null;
+}
+function prompt(question, hidden = false) {
+  return new Promise((resolve2) => {
+    const rl = createInterface({
+      input: process.stdin,
+      output: process.stdout
+    });
+    if (hidden && process.stdin.isTTY) {
+      const origWrite = process.stdout.write.bind(process.stdout);
+      process.stdout.write = ((chunk, encodingOrCb, cb) => {
+        if (typeof chunk === "string" && chunk.includes(question)) {
+          return origWrite(chunk, encodingOrCb, cb);
+        }
+        if (typeof chunk === "string" && !chunk.includes("\n")) {
+          return true;
+        }
+        return origWrite(chunk, encodingOrCb, cb);
+      });
+      rl.question(question, (answer) => {
+        process.stdout.write = origWrite;
+        console.log();
+        rl.close();
+        resolve2(answer.trim());
+      });
+    } else {
+      rl.question(question, (answer) => {
+        rl.close();
+        resolve2(answer.trim());
+      });
+    }
+  });
+}
+async function login(apiUrl, email, password) {
+  if (!email) {
+    email = await prompt("Email: ");
+  }
+  if (!password) {
+    password = await prompt("Password: ", true);
+  }
+  if (!email || !password) {
+    throw new Error("Email and password are required");
+  }
+  console.log(`[mmrc] Logging in to ${apiUrl}...`);
+  const res = await fetch(`${apiUrl}/auth/login`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ email, password })
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`Login failed: ${res.status} ${text}`);
+  }
+  const data = await res.json();
+  const token = data.token ?? data.access_token ?? data.accessToken;
+  if (!token) {
+    throw new Error("Login succeeded but no token in response");
+  }
+  saveCredentials(apiUrl, token);
+  const userName = data.name ?? data.user?.name ?? data.user?.email ?? email;
+  console.log(`[mmrc] Logged in as ${userName}`);
+  console.log(`[mmrc] Token saved to ${CREDENTIALS_PATH}`);
+  return token;
+}
+function logout(apiUrl) {
+  if (apiUrl) {
+    removeCredentials(apiUrl);
+    console.log(`[mmrc] Credentials removed for ${apiUrl}`);
+  } else {
+    removeCredentials();
+    console.log("[mmrc] All saved credentials removed");
+  }
+}
+async function whoami(apiUrl) {
+  const token = resolveToken(apiUrl);
+  if (!token) {
+    console.log("[mmrc] Not logged in. Run `mmrc login` to authenticate.");
+    return;
+  }
+  try {
+    const res = await fetch(`${apiUrl}/auth/me`, {
+      headers: { Authorization: `Bearer ${token}` }
+    });
+    if (!res.ok) {
+      if (res.status === 401) {
+        console.log("[mmrc] Token is expired or invalid. Run `mmrc login` to re-authenticate.");
+        return;
+      }
+      console.log(`[mmrc] Failed to fetch user info: ${res.status}`);
+      return;
+    }
+    const user = await res.json();
+    console.log(`[mmrc] Logged in to ${apiUrl}`);
+    console.log(`  Name:  ${user.name ?? "(unknown)"}`);
+    console.log(`  Email: ${user.email ?? "(unknown)"}`);
+    if (user.id) console.log(`  ID:    ${user.id}`);
+    if (user.role) console.log(`  Role:  ${user.role}`);
+  } catch (error) {
+    console.log(`[mmrc] Could not connect to ${apiUrl}: ${error.message}`);
+  }
+}
+
+// src/cli/index.ts
+var args = process.argv.slice(2);
+var command = args[0];
+function getFlag(flag) {
+  const idx = args.indexOf(flag);
+  return idx !== -1 && idx + 1 < args.length ? args[idx + 1] : void 0;
+}
+function hasFlag(flag) {
+  return args.includes(flag);
+}
+function getPositional() {
+  for (let i = 1; i < args.length; i++) {
+    if (!args[i].startsWith("--")) return args[i];
+  }
+  return void 0;
+}
+async function main() {
+  if (command === "dev") {
+    const port = getFlag("--port") ? parseInt(getFlag("--port"), 10) : void 0;
+    const src = getFlag("--src");
+    const mode = getFlag("--mode");
+    const seed = hasFlag("--seed");
+    const apiUrl = getFlag("--api-url");
+    const authToken = getFlag("--token");
+    const open = hasFlag("--open");
+    const { createDevServer } = await import("../dev-server.mjs");
+    const server = await createDevServer({
+      port,
+      src,
+      mode,
+      seed,
+      apiUrl,
+      authToken,
+      open
+    });
+    const shutdown = async () => {
+      await server.close();
+      process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  } else if (command === "build") {
+    const src = getFlag("--src");
+    const outDir = getFlag("--out");
+    const mode = getFlag("--mode") ?? "infer";
+    const envelope = hasFlag("--envelope");
+    const slug = getFlag("--slug");
+    const version = getFlag("--version");
+    const skipTypeCheck = hasFlag("--skip-type-check");
+    const result = await build({ src, outDir, mode, envelope, slug, version, skipTypeCheck });
+    if (result.errors > 0) process.exit(1);
+  } else if (command === "test") {
+    const src = getFlag("--src");
+    const result = await test({ src });
+    if (!result.success) process.exit(1);
+  } else if (command === "deploy") {
+    const apiUrl = getFlag("--api-url") ?? "http://localhost:4200/api/v1";
+    const token = resolveToken(apiUrl, getFlag("--token"));
+    const dir = getFlag("--dir");
+    const src = getFlag("--src");
+    const force = hasFlag("--force");
+    const dryRun = hasFlag("--dry-run");
+    const shouldBuild = hasFlag("--build");
+    if (!token) {
+      console.error("[mmrc] Error: No auth token found. Either:");
+      console.error("  1. Run `mmrc login` to save credentials");
+      console.error("  2. Pass --token TOKEN");
+      console.error("  3. Set MMRC_TOKEN environment variable");
+      process.exit(1);
+    }
+    if (shouldBuild) {
+      const mode = getFlag("--mode") ?? "infer";
+      const srcDir = src ?? ".";
+      const outDir = dir ?? "dist/workflows";
+      console.log("[mmrc] Building before deploy...\n");
+      const { existsSync: existsSync3, readFileSync: readFileSync3, writeFileSync: writeFileSync2, mkdirSync: mkdirSync2 } = await import("fs");
+      const { resolve: resolve2, join: join2 } = await import("path");
+      const { glob: glob2 } = await import("glob");
+      const configPath = resolve2(srcDir, "mm.config.ts");
+      if (existsSync3(configPath)) {
+        const { compileProject } = await import("../project-compiler-EGJUTAJU.mjs");
+        const allFiles = await glob2(`${srcDir}/**/*.{ts,tsx}`, {
+          ignore: ["**/node_modules/**", "**/dist/**", "**/__tests__/**", "**/*.test.*"]
+        });
+        const fileMap = {};
+        for (const f of allFiles) {
+          const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
+          fileMap[rel] = readFileSync3(f, "utf-8");
+        }
+        console.log(`  Compiling project (${Object.keys(fileMap).length} files)...`);
+        const result = compileProject(fileMap);
+        const errors = result.errors.filter((e) => e.severity === "error");
+        if (errors.length > 0) {
+          for (const err of errors) {
+            console.error(`  x ${err.file} (line ${err.line}): ${err.message}`);
+          }
+          console.error(`
+[mmrc] Build failed with ${errors.length} errors \u2014 aborting deploy.`);
+          process.exit(1);
+        }
+        mkdirSync2(outDir, { recursive: true });
+        const irPath = join2(outDir, `${result.ir.slug}.workflow.json`);
+        writeFileSync2(irPath, JSON.stringify(result.ir, null, 2), "utf-8");
+        console.log(`  + ${result.ir.slug}.workflow.json`);
+        const seenSlugs = /* @__PURE__ */ new Set([result.ir.slug]);
+        for (const child of result.childDefinitions) {
+          if (seenSlugs.has(child.slug)) continue;
+          seenSlugs.add(child.slug);
+          const childPath = join2(outDir, `${child.slug}.workflow.json`);
+          writeFileSync2(childPath, JSON.stringify(child, null, 2), "utf-8");
+          console.log(`  + ${child.slug}.workflow.json`);
+        }
+        console.log(`  Compiled ${1 + result.childDefinitions.length} definitions.
+`);
+      } else {
+        const buildResult = await build({ src: srcDir, outDir, mode });
+        if (buildResult.errors > 0) {
+          console.error("\n[mmrc] Build failed \u2014 aborting deploy.");
+          process.exit(1);
+        }
+        console.log("");
+      }
+      await deploy({ apiUrl, token, dir: outDir, force, dryRun });
+    } else {
+      await deploy({ apiUrl, token, dir, force, dryRun });
+    }
+  } else if (command === "login") {
+    const apiUrl = getFlag("--api-url") ?? "http://localhost:4200/api/v1";
+    const email = getFlag("--email");
+    const password = getFlag("--password");
+    await login(apiUrl, email, password);
+  } else if (command === "logout") {
+    const apiUrl = getFlag("--api-url");
+    logout(apiUrl);
+  } else if (command === "whoami") {
+    const apiUrl = getFlag("--api-url") ?? "http://localhost:4200/api/v1";
+    await whoami(apiUrl);
+  } else if (command === "init") {
+    const name = getPositional();
+    if (!name) {
+      console.error('[mmrc] Error: name is required\n  Usage: mmrc init <name> [--description "..."] [--icon "..."] [--author "..."]');
+      process.exit(1);
+    }
+    const { init } = await import("../init-IXEE2RCF.mjs");
+    await init({
+      name,
+      description: getFlag("--description"),
+      icon: getFlag("--icon"),
+      author: getFlag("--author")
+    });
+  } else if (command === "pull") {
+    const slug = getPositional();
+    const apiUrl = getFlag("--api-url") ?? "http://localhost:4200/api/v1";
+    const token = resolveToken(apiUrl, getFlag("--token"));
+    const outDir = getFlag("--out");
+    if (!slug) {
+      console.error("[mmrc] Error: slug is required\n  Usage: mmrc pull <slug> [--token TOKEN]");
+      process.exit(1);
+    }
+    if (!token) {
+      console.error("[mmrc] Error: No auth token found. Either:");
+      console.error("  1. Run `mmrc login` to save credentials");
+      console.error("  2. Pass --token TOKEN");
+      console.error("  3. Set MMRC_TOKEN environment variable");
+      process.exit(1);
+    }
+    const { pull } = await import("../pull-JBEQWVPE.mjs");
+    await pull({ slug, apiUrl, token, outDir });
+  } else {
+    console.log(`
+MindMatrix React Compiler (mmrc)
+
+Commands:
+  init    Scaffold a new blueprint package
+  login   Authenticate and save credentials
+  logout  Remove saved credentials
+  whoami  Show current authenticated user
+  dev     Start dev server with hot reload
+  build   Compile workflow files to Pure Form IR
+  test    Round-trip fidelity test (compile \u2192 decompile \u2192 recompile \u2192 compare)
+  deploy  Compile + upload workflows to backend DB
+  pull    Fetch a definition from DB and scaffold local project
+
+Usage:
+  mmrc init <name> [options]
+    --description  Blueprint description
+    --icon         Icon name (default: box)
+    --author       Author name (default: MindMatrix)
+
+  mmrc login [options]
+    --api-url   API base URL (default: http://localhost:4200/api/v1)
+    --email     Email (prompted if not provided)
+    --password  Password (prompted if not provided)
+
+  mmrc logout [options]
+    --api-url   Remove credentials for this URL only (default: all)
+
+  mmrc whoami [options]
+    --api-url   API base URL (default: http://localhost:4200/api/v1)
+
+  mmrc dev [options]
+    --port      Dev server port (default: 5199)
+    --src       Source directory (default: src/workflows)
+    --mode      Compilation mode: strict|infer (default: infer)
+    --seed      Seed definitions to dev API on compile
+    --api-url   API base URL (default: http://localhost:4200/api/v1)
+    --token     Auth token for API seeding
+    --open      Open browser on start
+
+  mmrc build [options]
+    --src              Source directory (default: src/workflows)
+    --out              Output directory (default: dist/workflows)
+    --mode             Compilation mode: strict|infer (default: infer)
+    --envelope         Generate source envelope
+    --slug             Blueprint slug for envelope
+    --version          Blueprint version for envelope
+    --skip-type-check  Skip tsc --noEmit type checking (not recommended)
+
+  mmrc test [options]
+    --src       Source directory (default: current directory)
+
+  mmrc deploy [options]
+    --api-url   API base URL (default: http://localhost:4200/api/v1)
+    --token     Auth token (or use mmrc login / MMRC_TOKEN env var)
+    --dir       Compiled workflows directory (default: dist/workflows)
+    --src       Source directory (used with --build)
+    --build     Compile first, then deploy (no separate build step needed)
+    --force     Force update even if instances exist
+    --dry-run   Show what would happen without changes
+
+  mmrc pull <slug> [options]
+    --api-url   API base URL (default: http://localhost:4200/api/v1)
+    --token     Auth token (or use mmrc login / MMRC_TOKEN env var)
+    --out       Output directory (default: <slug>/)
+
+Token resolution (for deploy/pull):
+  1. --token flag (highest priority)
+  2. MMRC_TOKEN environment variable
+  3. Saved credentials from mmrc login (~/.mmrc/credentials.json)
+
+Workflows:
+  First-time setup:
+    mmrc login --api-url https://dev.mindmatrix.club/api/v1
+
+  Author locally, deploy to DB:
+    mmrc deploy --build --src ./src --api-url https://dev.mindmatrix.club/api/v1
+
+  Fetch from DB, edit locally:
+    mmrc pull mod-authentication --api-url https://dev.mindmatrix.club/api/v1
+    cd mod-authentication && mmrc deploy --build --src .
+
+Examples:
+  mmrc login --api-url https://dev.mindmatrix.club/api/v1
+  mmrc whoami
+  mmrc dev --port 5199 --seed
+  mmrc build --src src/workflows
+  mmrc deploy --build --src . --api-url http://localhost:4200/api/v1
+  mmrc pull my-blueprint --out ./my-project
+    `);
+  }
+}
+main().catch((error) => {
+  console.error("[mmrc] Fatal error:", error);
+  process.exit(1);
+});

package/dist/codemod/cli.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/codemod/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node