@mmapp/react-compiler 0.1.0-alpha.1

package/src/babel/emitters/runtime-glue-emitter.ts

@@ -0,0 +1,39 @@
+/**
+ * Runtime Glue Emitter — for infer mode, emits residual React code that imports
+ * from @mindmatrix/react and wires up the runtime.
+ *
+ * This is a placeholder for now — in strict mode, all hooks are removed.
+ * In infer mode, we keep the original code and inject runtime wiring.
+ */
+
+import * as t from '@babel/types';
+
+/**
+ * Wraps the component in WorkflowProvider (infer mode).
+ */
+export function emitRuntimeGlue(
+  _path: any,
+  _workflowDefinition: any
+): void {
+  // For now, we keep the original code as-is
+  // In a full implementation, we would:
+  // 1. Import { WorkflowProvider, useWorkflow } from '@mindmatrix/react'
+  // 2. Wrap the component return with <WorkflowProvider definition={...}>
+  // 3. Replace hook calls with runtime bindings
+
+  // This is a simplified version that doesn't modify the code
+  // The IR JSON is emitted separately as a sidecar file
+}
+
+/**
+ * Generates import statement for runtime.
+ */
+export function generateRuntimeImports(): t.ImportDeclaration {
+  return t.importDeclaration(
+    [
+      t.importSpecifier(t.identifier('WorkflowProvider'), t.identifier('WorkflowProvider')),
+      t.importSpecifier(t.identifier('useWorkflow'), t.identifier('useWorkflow')),
+    ],
+    t.stringLiteral('@mindmatrix/react')
+  );
+}

package/src/babel/extractors/change-extractor.ts

@@ -0,0 +1,199 @@
+/**
+ * Change Extractor — extracts useOnChange calls and converts them to field watcher metadata.
+ *
+ * INPUT:
+ *   useOnChange('status', (newVal, oldVal) => {
+ *     console.log(`Status changed from ${oldVal} to ${newVal}`);
+ *   });
+ *
+ * OUTPUT (stored in compilerState metadata.fieldWatchers[]):
+ *   {
+ *     id: "watcher_1",
+ *     field: "status",
+ *     actions: [{ id: "auto_N", type: "log_event", mode: "auto", config: { message: "..." } }]
+ *   }
+ */
+
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { IRActionDefinition } from '@mindmatrix/player-core';
+import type { CompilerState } from '../../types';
+
+export interface FieldWatcher {
+  id: string;
+  field: string;
+  actions: IRActionDefinition[];
+}
+
+let watcherIdCounter = 0;
+
+/**
+ * Resets the watcher ID counter. Call between file compilations.
+ */
+export function resetWatcherIdCounter(): void {
+  watcherIdCounter = 0;
+}
+
+/**
+ * Analyzes a callback body and extracts action definitions.
+ */
+function analyzeCallbackBody(
+  body: t.Statement[],
+  actionCounter: { value: number }
+): IRActionDefinition[] {
+  const actions: IRActionDefinition[] = [];
+
+  for (const statement of body) {
+    if (!t.isExpressionStatement(statement)) continue;
+    const expr = statement.expression;
+
+    if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
+      const calleeName = expr.callee.name;
+      const args = expr.arguments;
+
+      if (calleeName === 'setField' && args.length >= 2) {
+        const field = t.isStringLiteral(args[0]) ? args[0].value : undefined;
+        if (field !== undefined) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: 'set_field',
+            mode: 'auto',
+            config: { field, value: extractValue(args[1]) },
+          });
+        }
+      } else if (calleeName === 'setMemory' && args.length >= 2) {
+        const key = t.isStringLiteral(args[0]) ? args[0].value : undefined;
+        if (key !== undefined) {
+          actions.push({
+            id: `auto_${++actionCounter.value}`,
+            type: 'set_memory',
+            mode: 'auto',
+            config: { key, value: extractValue(args[1]) },
+          });
+        }
+      } else if (calleeName.startsWith('set') && calleeName.length > 3 && args.length >= 1) {
+        const fieldName = calleeName.slice(3, 4).toLowerCase() + calleeName.slice(4);
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: 'set_field',
+          mode: 'auto',
+          config: { field: fieldName, value: extractValue(args[0]) },
+        });
+      }
+    } else if (t.isCallExpression(expr)) {
+      const callee = expr.callee;
+      if (
+        t.isMemberExpression(callee) &&
+        t.isIdentifier(callee.object) &&
+        callee.object.name === 'console' &&
+        t.isIdentifier(callee.property) &&
+        callee.property.name === 'log' &&
+        expr.arguments.length > 0
+      ) {
+        actions.push({
+          id: `auto_${++actionCounter.value}`,
+          type: 'log_event',
+          mode: 'auto',
+          config: { message: extractValue(expr.arguments[0]) },
+        });
+      }
+    }
+  }
+
+  return actions;
+}
+
+function extractValue(node: t.Node): unknown {
+  if (t.isNumericLiteral(node)) return node.value;
+  if (t.isStringLiteral(node)) return node.value;
+  if (t.isBooleanLiteral(node)) return node.value;
+  if (t.isNullLiteral(node)) return null;
+  if (t.isIdentifier(node)) return node.name;
+  if (t.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < (node as t.TemplateLiteral).expressions.length) {
+        const expr = (node as t.TemplateLiteral).expressions[i];
+        return raw + '${' + (t.isIdentifier(expr) ? expr.name : '[expr]') + '}';
+      }
+      return raw;
+    }).join('');
+  }
+  if (t.isArrayExpression(node)) {
+    return node.elements.map((el) => (el && t.isExpression(el) ? extractValue(el) : null));
+  }
+  if (t.isObjectExpression(node)) {
+    const obj: Record<string, unknown> = {};
+    node.properties.forEach((prop) => {
+      if (t.isObjectProperty(prop) && t.isIdentifier(prop.key) && t.isExpression(prop.value)) {
+        obj[prop.key.name] = extractValue(prop.value);
+      }
+    });
+    return obj;
+  }
+  if (t.isMemberExpression(node)) {
+    const obj = t.isIdentifier(node.object) ? node.object.name : '[object]';
+    const prop = t.isIdentifier(node.property) ? node.property.name : '[property]';
+    return `${obj}.${prop}`;
+  }
+  if (t.isConditionalExpression(node)) {
+    return `(${extractValue(node.test)} ? ${extractValue(node.consequent)} : ${extractValue(node.alternate)})`;
+  }
+  if (t.isBinaryExpression(node)) {
+    return `(${extractValue(node.left)} ${node.operator} ${extractValue(node.right)})`;
+  }
+  if (t.isLogicalExpression(node)) {
+    return `(${extractValue(node.left)} ${node.operator} ${extractValue(node.right)})`;
+  }
+  if (t.isTSAsExpression(node)) return extractValue(node.expression);
+  if (t.isTSNonNullExpression(node)) return extractValue(node.expression);
+  return '[Expression]';
+}
+
+/**
+ * Main extractor function called from the visitor.
+ *
+ * Handles: useOnChange(field, handler)
+ */
+export function extractChangeWatcher(path: NodePath<t.CallExpression>, state: any): void {
+  const callee = path.node.callee;
+  if (!t.isIdentifier(callee) || callee.name !== 'useOnChange') return;
+
+  const args = path.node.arguments;
+  if (args.length < 2) return;
+
+  const fieldArg = args[0];
+  const callbackArg = args[1];
+
+  if (!t.isStringLiteral(fieldArg)) return;
+  const field = fieldArg.value;
+
+  // Extract callback body
+  let callbackBody: t.Statement[] = [];
+  if (t.isArrowFunctionExpression(callbackArg) || t.isFunctionExpression(callbackArg)) {
+    const body = callbackArg.body;
+    if (t.isBlockStatement(body)) {
+      callbackBody = body.body;
+    } else if (t.isExpression(body)) {
+      callbackBody = [t.expressionStatement(body)];
+    }
+  }
+
+  const compilerState = state as CompilerState;
+  if (!compilerState.actionCounter) compilerState.actionCounter = 0;
+
+  const actions = analyzeCallbackBody(callbackBody, { value: compilerState.actionCounter });
+  compilerState.actionCounter += actions.length;
+
+  const watcher: FieldWatcher = {
+    id: `watcher_${++watcherIdCounter}`,
+    field,
+    actions,
+  };
+
+  // Store in compiler state metadata
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata as Record<string, unknown>;
+  if (!meta.fieldWatchers) meta.fieldWatchers = [];
+  (meta.fieldWatchers as FieldWatcher[]).push(watcher);
+}