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

package/dist/chunk-JQLWFCTM.mjs

@@ -0,0 +1,214 @@
+import {
+  createSourceEnvelope,
+  generateFsTree
+} from "./chunk-5M7DKKBC.mjs";
+import {
+  babelPlugin
+} from "./chunk-E6FZNUR5.mjs";
+
+// src/cli/build.ts
+import { glob } from "glob";
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { transformSync } from "@babel/core";
+import { join, basename, dirname, resolve } from "path";
+import { execSync } from "child_process";
+async function build(options = {}) {
+  const srcDir = options.src ?? "src/workflows";
+  const outDir = options.outDir ?? "dist/workflows";
+  const mode = options.mode ?? "infer";
+  if (!options.skipTypeCheck) {
+    const tsconfigPath = resolve(srcDir, "tsconfig.json");
+    const hasTsconfig = existsSync(tsconfigPath);
+    if (hasTsconfig) {
+      console.log(`[mindmatrix-react] Type checking (tsc --noEmit)...`);
+      try {
+        execSync(`npx tsc --noEmit --project ${tsconfigPath}`, {
+          cwd: resolve(srcDir),
+          stdio: "pipe",
+          encoding: "utf-8"
+        });
+        console.log(`[mindmatrix-react] Type check passed.`);
+      } catch (err) {
+        const tscError = err;
+        const output = tscError.stdout || tscError.stderr || "";
+        const lines = output.split("\n").filter((l) => l.trim());
+        const typeErrors = [];
+        for (const line of lines) {
+          const match = line.match(/^(.+?)\((\d+),\d+\):\s*error\s+(TS\d+):\s*(.+)$/);
+          if (match) {
+            typeErrors.push({
+              file: match[1],
+              message: `${match[3]}: ${match[4]}`,
+              line: parseInt(match[2], 10)
+            });
+          }
+        }
+        if (typeErrors.length > 0) {
+          console.error(`
+[mindmatrix-react] Type check failed with ${typeErrors.length} error(s):
+`);
+          for (const te of typeErrors) {
+            console.error(`  \u2717 ${te.file}:${te.line || "?"} ${te.message}`);
+          }
+          console.error(`
+[mindmatrix-react] Fix type errors or use --skip-type-check to bypass.
+`);
+          return {
+            compiled: 0,
+            errors: typeErrors.length,
+            warnings: 0,
+            definitions: [],
+            errorDetails: typeErrors
+          };
+        } else {
+          console.error(`
+[mindmatrix-react] Type check failed:
+${output}`);
+          return {
+            compiled: 0,
+            errors: 1,
+            warnings: 0,
+            definitions: [],
+            errorDetails: [{ file: "tsconfig.json", message: output.slice(0, 500) }]
+          };
+        }
+      }
+    }
+  }
+  const configPath = resolve(srcDir, "mm.config.ts");
+  if (existsSync(configPath)) {
+    console.log(`[mindmatrix-react] Detected mm.config.ts \u2014 using project compiler...`);
+    const { compileProject } = await import("./project-compiler-YES5FGMD.mjs");
+    const allProjectFiles = await glob(`${srcDir}/**/*.{ts,tsx}`, {
+      ignore: ["**/node_modules/**", "**/dist/**", "**/__tests__/**", "**/*.test.*"]
+    });
+    const fileMap = {};
+    for (const f of allProjectFiles) {
+      const rel = f.startsWith(srcDir + "/") ? f.slice(srcDir.length + 1) : f;
+      fileMap[rel] = readFileSync(f, "utf-8");
+    }
+    mkdirSync(outDir, { recursive: true });
+    const result = compileProject(fileMap, { mode });
+    const errors = result.errors.filter((e) => e.severity === "error");
+    const warnings = result.errors.filter((e) => e.severity === "warning");
+    const definitions2 = [result.ir];
+    const errorDetails2 = [];
+    for (const err of errors) {
+      errorDetails2.push({ file: err.file, message: err.message, line: err.line });
+      console.error(`  x ${err.file}${err.line ? `:${err.line}` : ""} ${err.message}`);
+    }
+    for (const warn of warnings) {
+      console.warn(`  ! ${warn.file}${warn.line ? `:${warn.line}` : ""} ${warn.message}`);
+    }
+    const irPath = join(outDir, `${result.ir.slug}.workflow.json`);
+    writeFileSync(irPath, JSON.stringify(result.ir, null, 2), "utf-8");
+    console.log(`  + ${basename(irPath)}`);
+    const seenSlugs = /* @__PURE__ */ new Set([result.ir.slug]);
+    for (const child of result.childDefinitions) {
+      if (seenSlugs.has(child.slug)) continue;
+      seenSlugs.add(child.slug);
+      definitions2.push(child);
+      const childPath = join(outDir, `${child.slug}.workflow.json`);
+      writeFileSync(childPath, JSON.stringify(child, null, 2), "utf-8");
+      console.log(`  + ${basename(childPath)}`);
+    }
+    console.log(`
+[mindmatrix-react] Compiled ${definitions2.length} definitions, ${errors.length} errors, ${warnings.length} warnings`);
+    return { compiled: definitions2.length, errors: errors.length, warnings: warnings.length, definitions: definitions2, errorDetails: errorDetails2 };
+  }
+  console.log(`[mindmatrix-react] Building workflows from ${srcDir}...`);
+  mkdirSync(outDir, { recursive: true });
+  const workflowFiles = await glob(`${srcDir}/**/*.workflow.{tsx,ts,jsx,js}`);
+  const modelFiles = await glob(`${srcDir}/**/models/**/*.{ts,tsx}`);
+  const serverFiles = await glob(`${srcDir}/**/*.server.{ts,tsx,js,jsx}`);
+  const allFiles = [.../* @__PURE__ */ new Set([...workflowFiles, ...modelFiles, ...serverFiles])];
+  if (allFiles.length === 0) {
+    console.log(`[mindmatrix-react] No workflow files found in ${srcDir}`);
+    return { compiled: 0, errors: 0, warnings: 0, definitions: [], errorDetails: [] };
+  }
+  let compiled = 0;
+  let errorCount = 0;
+  let warningCount = 0;
+  const definitions = [];
+  const errorDetails = [];
+  for (const file of allFiles) {
+    try {
+      const code = readFileSync(file, "utf-8");
+      const result = transformSync(code, {
+        filename: file,
+        plugins: [[babelPlugin, { mode }]],
+        parserOpts: { plugins: ["jsx", "typescript"], attachComment: true }
+      });
+      const ir = result?.metadata?.mindmatrixIR;
+      const definition = result?.metadata?.mindmatrixDefinition;
+      const canonical = result?.metadata?.mindmatrixCanonical;
+      if (ir) {
+        definitions.push(ir);
+        const irErrors = ir.metadata?.errors;
+        const irWarnings = ir.metadata?.warnings;
+        if (irErrors && irErrors.length > 0) {
+          for (const err of irErrors) {
+            errorDetails.push({
+              file: basename(file),
+              message: err.message,
+              line: err.line
+            });
+            console.error(`  \u2717 ${basename(file)}:${err.line || "?"} ${err.message}`);
+          }
+          errorCount += irErrors.length;
+        }
+        if (irWarnings && irWarnings.length > 0) {
+          for (const warn of irWarnings) {
+            console.warn(`  \u26A0 ${basename(file)}:${warn.line || "?"} ${warn.message}`);
+          }
+          warningCount += irWarnings.length;
+        }
+        const compiledFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".json").replace(/\.(tsx?|jsx?)$/, ".json");
+        const compiledFile = join(outDir, compiledFileName);
+        mkdirSync(dirname(compiledFile), { recursive: true });
+        writeFileSync(compiledFile, JSON.stringify({ canonical, ir }, null, 2), "utf-8");
+        const irFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".workflow.json").replace(/\.(tsx?|jsx?)$/, ".json");
+        const irFile = join(outDir, irFileName);
+        writeFileSync(irFile, JSON.stringify(ir, null, 2), "utf-8");
+        if (definition) {
+          const defFileName = basename(file).replace(/\.workflow\.(tsx?|jsx?)$/, ".def.json").replace(/\.(tsx?|jsx?)$/, ".def.json");
+          const defFile = join(outDir, defFileName);
+          writeFileSync(defFile, JSON.stringify(definition, null, 2), "utf-8");
+        }
+        console.log(`  \u2713 ${basename(file)} \u2192 ${compiledFileName}`);
+        compiled++;
+      } else {
+        console.error(`  \u2717 ${basename(file)}: No IR generated`);
+        errorDetails.push({ file: basename(file), message: "No IR generated" });
+        errorCount++;
+      }
+    } catch (error) {
+      const msg = error.message;
+      console.error(`  \u2717 ${basename(file)}: ${msg}`);
+      errorDetails.push({ file: basename(file), message: msg });
+      errorCount++;
+    }
+  }
+  if (options.envelope) {
+    const allSourceFiles = await glob(`${srcDir}/**/*.{ts,tsx,js,jsx}`);
+    const fsTree = generateFsTree(allSourceFiles, resolve(srcDir));
+    const envelope = createSourceEnvelope({
+      blueprintSlug: options.slug || "project",
+      blueprintVersion: options.version || "0.1.0",
+      definitions,
+      fsTree,
+      mode
+    });
+    const envelopePath = join(outDir, "envelope.json");
+    writeFileSync(envelopePath, JSON.stringify(envelope, null, 2), "utf-8");
+    console.log(`
+  \u2713 Source envelope \u2192 envelope.json (${envelope.envelopeId.substring(0, 8)})`);
+  }
+  console.log(`
+[mindmatrix-react] Compiled ${compiled} workflows, ${errorCount} errors, ${warningCount} warnings`);
+  return { compiled, errors: errorCount, warnings: warningCount, definitions, errorDetails };
+}
+
+export {
+  build
+};

package/dist/chunk-KFJJCQAL.mjs

@@ -0,0 +1,148 @@
+import {
+  mindmatrixReact
+} from "./chunk-72QWL54I.mjs";
+import {
+  build
+} from "./chunk-DPIK3PJS.mjs";
+
+// src/dev-server.ts
+async function createDevServer(options = {}) {
+  const {
+    port = 5199,
+    src = "src/workflows",
+    mode = "infer",
+    include = ["**/*.workflow.tsx"],
+    outDir = "dist/workflows",
+    seed = false,
+    apiUrl = "http://localhost:4200/api/v1",
+    authToken = process.env.MINDMATRIX_TOKEN,
+    ws: enableWs = true,
+    open = false
+  } = options;
+  const clients = /* @__PURE__ */ new Set();
+  const pluginOptions = {
+    mode,
+    include,
+    outDir,
+    seedOnCompile: seed,
+    apiUrl,
+    authToken
+  };
+  const notifyPlugin = {
+    name: "mindmatrix-dev-notify",
+    enforce: "post",
+    handleHotUpdate(ctx) {
+      const isWorkflow = include.some((pattern) => {
+        const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*").replace(/\?/g, ".");
+        return new RegExp(regex).test(ctx.file);
+      });
+      if (!isWorkflow) return;
+      const message = JSON.stringify({
+        type: "workflow:compiled",
+        file: ctx.file,
+        timestamp: ctx.timestamp
+      });
+      for (const client of clients) {
+        try {
+          if (client.readyState === 1) {
+            client.send(message);
+          }
+        } catch {
+          clients.delete(client);
+        }
+      }
+      console.log(`[mm-dev] Compiled ${ctx.file.split("/").pop()} \u2014 notified ${clients.size} client(s)`);
+    }
+  };
+  const viteConfig = {
+    root: process.cwd(),
+    server: {
+      port,
+      open,
+      host: true
+    },
+    plugins: [
+      mindmatrixReact(pluginOptions),
+      notifyPlugin
+    ],
+    logLevel: "info"
+  };
+  const { createServer } = await import("vite");
+  const vite = await createServer(viteConfig);
+  await vite.listen();
+  const resolvedPort = vite.config.server.port ?? port;
+  if (enableWs && vite.httpServer) {
+    try {
+      const wsModule = await Function('return import("ws")')();
+      const WebSocketServer = wsModule.WebSocketServer ?? wsModule.default?.WebSocketServer;
+      if (WebSocketServer) {
+        const wss = new WebSocketServer({
+          server: vite.httpServer,
+          path: "/__mm_dev"
+        });
+        wss.on("connection", (socket) => {
+          clients.add(socket);
+          console.log(`[mm-dev] Editor connected (${clients.size} total)`);
+          socket.on("close", () => {
+            clients.delete(socket);
+            console.log(`[mm-dev] Editor disconnected (${clients.size} total)`);
+          });
+          socket.send(JSON.stringify({
+            type: "mm:connected",
+            version: "0.1.0",
+            capabilities: ["compile", "seed", "notify"]
+          }));
+        });
+      }
+    } catch {
+      console.warn("[mm-dev] ws package not available \u2014 WebSocket notifications disabled");
+    }
+  }
+  console.log(`
+[mm-dev] MindMatrix Dev Server running`);
+  console.log(`  Local:     http://localhost:${resolvedPort}`);
+  console.log(`  WebSocket: ws://localhost:${resolvedPort}/__mm_dev`);
+  console.log(`  Watching:  ${src} (${include.join(", ")})`);
+  if (seed) {
+    console.log(`  Seeding:   ${apiUrl}`);
+  }
+  console.log();
+  return {
+    vite,
+    port: resolvedPort,
+    clients,
+    async rebuild() {
+      console.log("[mm-dev] Full rebuild triggered...");
+      const result = await build({ src, outDir, mode });
+      const message = JSON.stringify({
+        type: "workflow:rebuild",
+        compiled: result.compiled,
+        errors: result.errors,
+        timestamp: Date.now()
+      });
+      for (const client of clients) {
+        try {
+          if (client.readyState === 1) client.send(message);
+        } catch {
+          clients.delete(client);
+        }
+      }
+      return result;
+    },
+    async close() {
+      for (const client of clients) {
+        try {
+          client.close();
+        } catch {
+        }
+      }
+      clients.clear();
+      await vite.close();
+      console.log("[mm-dev] Server stopped");
+    }
+  };
+}
+
+export {
+  createDevServer
+};

package/dist/chunk-KJUIIEQE.mjs

@@ -0,0 +1,186 @@
+import {
+  createSourceEnvelope,
+  generateFsTree
+} from "./chunk-5M7DKKBC.mjs";
+import {
+  babelPlugin
+} from "./chunk-7B4TRI7C.mjs";
+
+// src/envelope.ts
+import { createHash } from "crypto";
+import { readFileSync } from "fs";
+import { resolve, relative, basename } from "path";
+import { glob } from "glob";
+import { transformSync } from "@babel/core";
+async function buildEnvelope(projectDir, options = {}) {
+  const root = resolve(projectDir);
+  const slug = options.slug ?? basename(root);
+  const version = options.version ?? "0.1.0";
+  const mode = options.mode ?? "infer";
+  const patterns = options.include ?? [
+    `${root}/**/*.workflow.{tsx,ts,jsx,js}`,
+    `${root}/**/models/**/*.{ts,tsx}`,
+    `${root}/**/*.server.{ts,tsx,js,jsx}`
+  ];
+  const discoveredFiles = [];
+  for (const pattern of patterns) {
+    const matches = await glob(pattern, { absolute: true });
+    discoveredFiles.push(...matches);
+  }
+  const uniqueFiles = [...new Set(discoveredFiles)];
+  const allSourceFiles = await glob(`${root}/**/*.{ts,tsx,js,jsx,css,json}`, {
+    absolute: true,
+    ignore: ["**/node_modules/**", "**/dist/**", "**/.git/**"]
+  });
+  const fsTree = generateFsTree(allSourceFiles, root);
+  const definitions = [];
+  const envelopeFiles = [];
+  const errors = [];
+  const sourceBindings = [];
+  for (const file of uniqueFiles) {
+    const relativePath = relative(root, file);
+    let fileContent;
+    try {
+      fileContent = readFileSync(file);
+    } catch {
+      errors.push({ file: relativePath, message: "Could not read file" });
+      continue;
+    }
+    const fileHash = createHash("sha256").update(fileContent).digest("hex");
+    const code = fileContent.toString("utf-8");
+    try {
+      const hasTsx = /\.(tsx|jsx)$/.test(file);
+      const parserPlugins = ["typescript"];
+      if (hasTsx) parserPlugins.push("jsx");
+      const result = transformSync(code, {
+        filename: file,
+        plugins: [[babelPlugin, { mode }]],
+        parserOpts: { plugins: parserPlugins, attachComment: true },
+        sourceMaps: true
+      });
+      const ir = result?.metadata?.mindmatrixIR;
+      if (ir) {
+        definitions.push(ir);
+        const bindings = extractSourceBindings(ir, relativePath);
+        sourceBindings.push(...bindings);
+        const irErrors = ir.metadata?.errors;
+        if (irErrors?.length) {
+          for (const e of irErrors) {
+            errors.push({ file: relativePath, message: e.message, line: e.line });
+          }
+        }
+        envelopeFiles.push({
+          path: relativePath,
+          hash: fileHash,
+          size: fileContent.length,
+          slug: ir.slug,
+          compiled: true
+        });
+      } else {
+        envelopeFiles.push({
+          path: relativePath,
+          hash: fileHash,
+          size: fileContent.length,
+          compiled: false
+        });
+      }
+    } catch (error) {
+      const msg = error instanceof Error ? error.message : String(error);
+      errors.push({ file: relativePath, message: msg });
+      envelopeFiles.push({
+        path: relativePath,
+        hash: fileHash,
+        size: fileContent.length,
+        compiled: false
+      });
+    }
+  }
+  const envelope = createSourceEnvelope({
+    blueprintSlug: slug,
+    blueprintVersion: version,
+    definitions,
+    fsTree,
+    sourceBindings,
+    environment: options.environment,
+    mode
+  });
+  const envelopeJson = JSON.stringify(envelope);
+  const manifestHash = createHash("sha256").update(envelopeJson).digest("hex");
+  const manifest = {
+    hash: manifestHash,
+    files: envelopeFiles,
+    version,
+    timestamp: envelope.createdAt,
+    definitionCount: definitions.length,
+    errorCount: errors.length
+  };
+  return {
+    envelope,
+    manifest,
+    files: envelopeFiles,
+    definitions,
+    errors
+  };
+}
+function extractSourceBindings(ir, filePath) {
+  const bindings = [];
+  const slug = ir.slug ?? "";
+  for (const field of ir.fields) {
+    const source = field.__source;
+    bindings.push({
+      kind: "field",
+      name: field.name,
+      workflowSlug: slug,
+      file: filePath,
+      startLine: source?.line ?? 0,
+      startColumn: source?.column ?? 0,
+      endLine: source?.endLine,
+      endColumn: source?.endColumn
+    });
+  }
+  for (const state of ir.states) {
+    const source = state.__source;
+    bindings.push({
+      kind: "state",
+      name: state.name,
+      workflowSlug: slug,
+      file: filePath,
+      startLine: source?.line ?? 0,
+      startColumn: source?.column ?? 0,
+      endLine: source?.endLine,
+      endColumn: source?.endColumn
+    });
+  }
+  for (const transition of ir.transitions) {
+    const source = transition.__source;
+    bindings.push({
+      kind: "transition",
+      name: transition.name,
+      workflowSlug: slug,
+      file: filePath,
+      startLine: source?.line ?? 0,
+      startColumn: source?.column ?? 0,
+      endLine: source?.endLine,
+      endColumn: source?.endColumn
+    });
+  }
+  if (ir.extensions) {
+    for (const [tag, islands] of Object.entries(ir.extensions)) {
+      for (const island of islands) {
+        bindings.push({
+          kind: "grammar-island",
+          name: `${tag}:${island.contextTag}`,
+          workflowSlug: slug,
+          file: filePath,
+          startLine: island.__source?.line ?? 0,
+          startColumn: island.__source?.column ?? 0
+        });
+      }
+    }
+  }
+  return bindings;
+}
+
+export {
+  buildEnvelope
+};