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

package/dist/chunk-ELO4TXJL.mjs

@@ -0,0 +1,186 @@
+import {
+  createSourceEnvelope,
+  generateFsTree
+} from "./chunk-5M7DKKBC.mjs";
+import {
+  babelPlugin
+} from "./chunk-7ZKGHTNB.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
+};

package/dist/chunk-EO6SYNCG.mjs

@@ -0,0 +1,175 @@
+import {
+  babelPlugin
+} from "./chunk-OPJKP747.mjs";
+
+// src/vite/index.ts
+import { transformSync } from "@babel/core";
+import { writeFileSync, mkdirSync } from "fs";
+import { dirname, join, relative, basename } from "path";
+function mindmatrixReact(options) {
+  const include = options?.include ?? ["**/*.workflow.tsx"];
+  const mode = options?.mode ?? "infer";
+  const outDir = options?.outDir ?? "dist/workflows";
+  const seedOnCompile = options?.seedOnCompile ?? false;
+  const apiUrl = options?.apiUrl ?? "http://localhost:4200/api/v1";
+  const authToken = options?.authToken ?? process.env.MINDMATRIX_TOKEN;
+  let enableSourceMaps = options?.sourceMaps;
+  let enableSourceAnnotations = options?.sourceAnnotations;
+  let isDev = true;
+  const compiledFiles = /* @__PURE__ */ new Map();
+  function shouldTransform(id) {
+    return include.some((pattern) => {
+      const regex = pattern.replace(/[.+^${}()|[\]\\]/g, "\\$&").replace(/\*\*/g, "<<GLOBSTAR>>").replace(/\*/g, "[^/]*").replace(/<<GLOBSTAR>>/g, ".*").replace(/\?/g, ".");
+      return new RegExp(regex).test(id);
+    });
+  }
+  async function seedToApi(ir, filePath) {
+    if (!seedOnCompile || !authToken) return;
+    try {
+      const body = {
+        slug: ir.slug,
+        name: ir.name,
+        version: ir.version,
+        category: ir.category || "workflow",
+        fields: ir.fields || [],
+        states: ir.states || [],
+        transitions: ir.transitions || [],
+        experience: ir.experience || {},
+        metadata: {
+          ...ir.metadata || {},
+          source_file: relative(process.cwd(), filePath),
+          compiled_at: (/* @__PURE__ */ new Date()).toISOString()
+        }
+      };
+      const resp = await fetch(`${apiUrl}/workflow/definitions`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json",
+          "Authorization": `Bearer ${authToken}`
+        },
+        body: JSON.stringify(body)
+      });
+      if (resp.ok) {
+        console.log(`[mindmatrix-react] Seeded ${ir.slug} to ${apiUrl}`);
+      } else if (resp.status === 409) {
+        const existing = await fetch(
+          `${apiUrl}/workflow/definitions?slug=${encodeURIComponent(ir.slug)}&version=${encodeURIComponent(ir.version)}`,
+          { headers: { "Authorization": `Bearer ${authToken}` } }
+        );
+        if (existing.ok) {
+          const data = await existing.json();
+          const defId = Array.isArray(data) ? data[0]?.id : data?.id;
+          if (defId) {
+            await fetch(`${apiUrl}/workflow/definitions/${defId}`, {
+              method: "PATCH",
+              headers: {
+                "Content-Type": "application/json",
+                "Authorization": `Bearer ${authToken}`
+              },
+              body: JSON.stringify(body)
+            });
+            console.log(`[mindmatrix-react] Updated ${ir.slug} (PATCH)`);
+          }
+        }
+      } else {
+        const text = await resp.text().catch(() => "");
+        console.warn(`[mindmatrix-react] Seed failed (${resp.status}): ${text.slice(0, 200)}`);
+      }
+    } catch (e) {
+      console.warn(`[mindmatrix-react] Seed failed:`, e instanceof Error ? e.message : e);
+    }
+  }
+  return {
+    name: "mindmatrix-react",
+    enforce: "pre",
+    configResolved(config) {
+      isDev = config.command === "serve";
+      if (enableSourceMaps === void 0) enableSourceMaps = isDev;
+      if (enableSourceAnnotations === void 0) enableSourceAnnotations = isDev;
+    },
+    transform(code, id) {
+      if (!shouldTransform(id)) return null;
+      try {
+        const wantMaps = enableSourceMaps !== false;
+        const result = transformSync(code, {
+          filename: id,
+          plugins: [[babelPlugin, { mode, filename: id, sourceAnnotations: enableSourceAnnotations }]],
+          parserOpts: { plugins: ["jsx", "typescript"] },
+          sourceMaps: wantMaps,
+          // Embed original source in the source map so debuggers can show .workflow.tsx
+          ...wantMaps ? { sourceFileName: basename(id) } : {}
+        });
+        if (!result?.code) return null;
+        const metadata = result.metadata || {};
+        const ir = metadata.mindmatrixIR;
+        const warnings = metadata.mindmatrixWarnings;
+        const errors = metadata.mindmatrixErrors;
+        if (warnings?.length) {
+          for (const w of warnings) {
+            console.warn(`[mindmatrix-react] ${basename(id)}: ${w.message}`);
+          }
+        }
+        if (errors?.length) {
+          for (const e of errors) {
+            if (mode === "strict") {
+              this.error(`${basename(id)}: ${e.message}`);
+            } else {
+              this.warn(`${basename(id)}: ${e.message}`);
+            }
+          }
+        }
+        if (ir) {
+          compiledFiles.set(id, ir);
+          const outputFileName = basename(id).replace(/\.tsx?$/, ".workflow.json");
+          const outputPath = join(process.cwd(), outDir, outputFileName);
+          mkdirSync(dirname(outputPath), { recursive: true });
+          writeFileSync(outputPath, JSON.stringify(ir, null, 2), "utf-8");
+          console.log(`[mindmatrix-react] Compiled ${basename(id)} \u2192 ${outputFileName}`);
+          seedToApi(ir, id);
+        }
+        if (!enableSourceAnnotations && ir) {
+          stripSourceAnnotations(ir);
+        }
+        return {
+          code: result.code,
+          map: wantMaps ? result.map : void 0
+        };
+      } catch (error) {
+        const msg = error instanceof Error ? error.message : String(error);
+        if (mode === "strict") {
+          this.error(`Failed to compile ${basename(id)}: ${msg}`);
+        } else {
+          console.error(`[mindmatrix-react] Error compiling ${basename(id)}:`, msg);
+        }
+        return null;
+      }
+    },
+    handleHotUpdate(ctx) {
+      if (!shouldTransform(ctx.file)) return;
+      console.log(`[mindmatrix-react] HMR: ${basename(ctx.file)} changed`);
+      return void 0;
+    }
+  };
+}
+function stripSourceAnnotations(ir) {
+  const strip = (obj) => {
+    if (!obj || typeof obj !== "object") return;
+    if (Array.isArray(obj)) {
+      for (const item of obj) strip(item);
+      return;
+    }
+    const rec = obj;
+    delete rec.__source;
+    for (const val of Object.values(rec)) {
+      if (val && typeof val === "object") strip(val);
+    }
+  };
+  strip(ir.fields);
+  strip(ir.states);
+  strip(ir.transitions);
+  strip(ir.experience);
+}
+
+export {
+  mindmatrixReact
+};