@mmapp/react-compiler 0.1.0-alpha.1

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

@@ -0,0 +1,235 @@
+/**
+ * Event Extractor — extracts useOnEvent calls and converts them to IROnEventSubscription.
+ *
+ * INPUT:
+ *   useOnEvent('message.received', (event) => {
+ *     setField('message_count', getField('message_count') + 1);
+ *   }, { while: 'active' });
+ *
+ * OUTPUT (added to state 'active' on_event):
+ *   {
+ *     match: "message.received",
+ *     conditions: [],
+ *     actions: [
+ *       { type: "set_field", field: "message_count", expression: "message_count + 1" }
+ *     ]
+ *   }
+ */
+
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { IROnEventSubscription, IROnEventAction, IRStateDefinition } from '@mindmatrix/player-core';
+import type { CompilerState } from '../../types';
+
+/**
+ * Analyzes callback body and extracts event actions.
+ */
+function analyzeEventCallback(body: t.Statement[]): IROnEventAction[] {
+  const actions: IROnEventAction[] = [];
+
+  for (const statement of body) {
+    if (t.isExpressionStatement(statement)) {
+      const expr = statement.expression;
+
+      if (t.isCallExpression(expr) && t.isIdentifier(expr.callee)) {
+        const calleeName = expr.callee.name;
+        const args = expr.arguments;
+
+        // setField(field, value)
+        if (calleeName === 'setField' && args.length >= 2) {
+          const field = t.isStringLiteral(args[0]) ? args[0].value : undefined;
+          const expression = generateExpression(args[1]);
+          if (field) {
+            actions.push({
+              type: 'set_field',
+              field,
+              expression,
+            });
+          }
+        }
+        // setMemory(key, value)
+        else if (calleeName === 'setMemory' && args.length >= 2) {
+          const key = t.isStringLiteral(args[0]) ? args[0].value : undefined;
+          const expression = generateExpression(args[1]);
+          if (key) {
+            actions.push({
+              type: 'set_memory',
+              key,
+              expression,
+            });
+          }
+        }
+      }
+      // console.log(message)
+      else if (t.isCallExpression(expr)) {
+        const callee = expr.callee;
+        const args = expr.arguments;
+        if (
+          t.isMemberExpression(callee) &&
+          t.isIdentifier(callee.object) &&
+          callee.object.name === 'console' &&
+          t.isIdentifier(callee.property) &&
+          callee.property.name === 'log'
+        ) {
+          const message = args.length > 0 ? generateExpression(args[0]) : '';
+          actions.push({
+            type: 'log_event',
+            message,
+          });
+        }
+      }
+    }
+  }
+
+  return actions;
+}
+
+/**
+ * Generates expression string from AST node.
+ */
+function generateExpression(node: t.Node): string {
+  if (t.isStringLiteral(node)) return node.value;
+  if (t.isNumericLiteral(node)) return String(node.value);
+  if (t.isBooleanLiteral(node)) return String(node.value);
+  if (t.isNullLiteral(node)) return 'null';
+  if (t.isIdentifier(node)) return node.name;
+  if (t.isBinaryExpression(node)) {
+    return `(${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)})`;
+  }
+  if (t.isLogicalExpression(node)) {
+    return `(${generateExpression(node.left)} ${node.operator} ${generateExpression(node.right)})`;
+  }
+  if (t.isConditionalExpression(node)) {
+    return `(${generateExpression(node.test)} ? ${generateExpression(node.consequent)} : ${generateExpression(node.alternate)})`;
+  }
+  if (t.isUnaryExpression(node) && node.prefix) {
+    return `${node.operator}${generateExpression(node.argument)}`;
+  }
+  if (t.isCallExpression(node) && t.isIdentifier(node.callee)) {
+    const args = node.arguments.map((arg) => generateExpression(arg)).join(', ');
+    return `${node.callee.name}(${args})`;
+  }
+  if (t.isCallExpression(node) && t.isMemberExpression(node.callee)) {
+    const obj = generateExpression(node.callee.object);
+    const prop = t.isIdentifier(node.callee.property) ? node.callee.property.name : '[method]';
+    const args = node.arguments.map((arg) => generateExpression(arg)).join(', ');
+    return `${obj}.${prop}(${args})`;
+  }
+  if (t.isMemberExpression(node)) {
+    const obj = generateExpression(node.object);
+    if (node.computed) {
+      const prop = generateExpression(node.property);
+      return `${obj}[${prop}]`;
+    }
+    const prop = t.isIdentifier(node.property) ? node.property.name : '[property]';
+    return `${obj}.${prop}`;
+  }
+  if (t.isTemplateLiteral(node)) {
+    return node.quasis.map((q, i) => {
+      const raw = q.value.raw;
+      if (i < node.expressions.length) return raw + '${' + generateExpression(node.expressions[i]) + '}';
+      return raw;
+    }).join('');
+  }
+  if (t.isArrayExpression(node)) {
+    const elements = node.elements.map((el) => el ? generateExpression(el) : 'undefined').join(', ');
+    return `[${elements}]`;
+  }
+  if (t.isObjectExpression(node)) {
+    const props = node.properties.map((p) => {
+      if (t.isObjectProperty(p)) {
+        const key = t.isIdentifier(p.key) ? p.key.name : t.isStringLiteral(p.key) ? `"${p.key.value}"` : '[key]';
+        if (p.shorthand && t.isIdentifier(p.value)) return key;
+        return `${key}: ${generateExpression(p.value)}`;
+      }
+      if (t.isSpreadElement(p)) return `...${generateExpression(p.argument)}`;
+      return '';
+    }).filter(Boolean).join(', ');
+    return `{ ${props} }`;
+  }
+  if (t.isTSAsExpression(node)) return generateExpression(node.expression);
+  if (t.isTSNonNullExpression(node)) return generateExpression(node.expression);
+  return '[Expression]';
+}
+
+/**
+ * Ensures a state exists in the state map.
+ */
+function ensureState(
+  states: Map<string, IRStateDefinition>,
+  stateName: string
+): IRStateDefinition {
+  if (!states.has(stateName)) {
+    states.set(stateName, {
+      name: stateName,
+      type: 'REGULAR',
+      on_enter: [],
+      during: [],
+      on_exit: [],
+    });
+  }
+  return states.get(stateName)!;
+}
+
+/**
+ * Main extractor function called from the visitor.
+ */
+export function extractEvents(path: NodePath<t.CallExpression>, state: any): void {
+  const callee = path.node.callee;
+  if (!t.isIdentifier(callee) || callee.name !== 'useOnEvent') return;
+
+  const args = path.node.arguments;
+  if (args.length < 2) return;
+
+  const patternArg = args[0];
+  const callbackArg = args[1];
+  const optionsArg = args.length > 2 ? args[2] : null;
+
+  if (!t.isStringLiteral(patternArg)) return;
+  const pattern = patternArg.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)];
+    }
+  }
+
+  // Extract options: { while: 'active' }
+  let stateName: string | null = null;
+  if (optionsArg && t.isObjectExpression(optionsArg)) {
+    const whileProp = optionsArg.properties.find(
+      (prop) =>
+        t.isObjectProperty(prop) && t.isIdentifier(prop.key) && prop.key.name === 'while'
+    );
+    if (whileProp && t.isObjectProperty(whileProp) && t.isStringLiteral(whileProp.value)) {
+      stateName = whileProp.value.value;
+    }
+  }
+
+  const actions = analyzeEventCallback(callbackBody);
+
+  const subscription: IROnEventSubscription = {
+    match: pattern,
+    conditions: [],
+    actions,
+  };
+
+  const compilerState = state as CompilerState;
+  if (!compilerState.states) compilerState.states = new Map();
+
+  // If a specific state is specified, attach to that state's on_event
+  if (stateName) {
+    const stateDefinition = ensureState(compilerState.states, stateName);
+    if (!stateDefinition.on_event) stateDefinition.on_event = [];
+    stateDefinition.on_event.push(subscription);
+  } else {
+    // Global event subscription (attached to workflow level)
+    if (!compilerState.events) compilerState.events = [];
+    compilerState.events.push(subscription);
+  }
+}

package/src/babel/extractors/grammar-island-extractor.ts

@@ -0,0 +1,302 @@
+/**
+ * Grammar Island Extractor — extracts tagged template DSL expressions.
+ *
+ * Detects tagged template expressions where the tag function is one of:
+ * cedar, sql, cron, dmn, graphql, jsonpath
+ *
+ * INPUT (model file):
+ *   export const access = cedar`
+ *     permit (principal, action == Action::"read", resource)
+ *     when { principal.role == "member" };
+ *   `;
+ *
+ *   export const computed = {
+ *     messageCount: sql`SELECT COUNT(*) FROM messages WHERE channel_id = $instance_id`,
+ *   };
+ *
+ * OUTPUT (stored in compilerState metadata.grammarIslands[]):
+ *   [
+ *     { slug: 'access', contextTag: 'cedar', rawSource: '...', parsed: { policies: [...] } },
+ *     { slug: 'messageCount', contextTag: 'sql', rawSource: 'SELECT...', parsed: { query: '...' } },
+ *   ]
+ */
+
+import type { NodePath } from '@babel/traverse';
+import * as t from '@babel/types';
+import type { CompilerState } from '../../types';
+import type { IRGrammarIsland } from '@mindmatrix/player-core';
+
+// =============================================================================
+// Supported grammar tags
+// =============================================================================
+
+const GRAMMAR_TAGS = new Set(['cedar', 'sql', 'cron', 'dmn', 'graphql', 'jsonpath']);
+
+// =============================================================================
+// Parsing helpers
+// =============================================================================
+
+interface CedarPolicy {
+  effect: 'permit' | 'forbid';
+  principal?: string;
+  action?: string;
+  resource?: string;
+  conditions: string[];
+}
+
+/**
+ * Parse Cedar policy text into structured policy objects.
+ * Uses regex-based parsing (not a full Cedar parser).
+ */
+function parseCedar(source: string): { policies: CedarPolicy[] } {
+  const policies: CedarPolicy[] = [];
+
+  // Match permit/forbid statements
+  const policyRegex = /(permit|forbid)\s*\(([^)]*)\)(?:\s*when\s*\{([^}]*)\})?/g;
+  let match: RegExpExecArray | null;
+
+  while ((match = policyRegex.exec(source)) !== null) {
+    const [, effect, scope, condition] = match;
+    const parts = scope.split(',').map((s) => s.trim());
+
+    const policy: CedarPolicy = {
+      effect: effect as 'permit' | 'forbid',
+      conditions: [],
+    };
+
+    for (const part of parts) {
+      if (part.startsWith('principal')) {
+        policy.principal = part;
+      } else if (part.startsWith('action')) {
+        policy.action = part;
+      } else if (part.startsWith('resource')) {
+        policy.resource = part;
+      }
+    }
+
+    if (condition) {
+      policy.conditions.push(condition.trim());
+    }
+
+    policies.push(policy);
+  }
+
+  return { policies };
+}
+
+interface CronFields {
+  minute: string;
+  hour: string;
+  dayOfMonth: string;
+  month: string;
+  dayOfWeek: string;
+}
+
+/**
+ * Parse and validate a cron expression (5-field format).
+ */
+function parseCron(source: string): { expression: string; fields: CronFields; valid: boolean } {
+  const trimmed = source.trim();
+  const parts = trimmed.split(/\s+/);
+  const valid = parts.length === 5;
+
+  return {
+    expression: trimmed,
+    fields: {
+      minute: parts[0] || '*',
+      hour: parts[1] || '*',
+      dayOfMonth: parts[2] || '*',
+      month: parts[3] || '*',
+      dayOfWeek: parts[4] || '*',
+    },
+    valid,
+  };
+}
+
+interface DmnRule {
+  inputs: Record<string, string>;
+  output: Record<string, string>;
+  annotation?: string;
+}
+
+/**
+ * Parse a markdown-style DMN decision table.
+ *
+ * Format:
+ *   | input1 | input2 | output |
+ *   |--------|--------|--------|
+ *   | <18    | *      | reject |
+ */
+function parseDmn(source: string): { hitPolicy: string; rules: DmnRule[]; headers: string[] } {
+  const lines = source.split('\n').map((l) => l.trim()).filter((l) => l.length > 0);
+  const rules: DmnRule[] = [];
+  const headers: string[] = [];
+  let hitPolicy = 'first';
+
+  if (lines.length === 0) return { hitPolicy, rules, headers };
+
+  // Parse header row
+  const headerLine = lines[0];
+  const headerCells = headerLine.split('|').map((c) => c.trim()).filter((c) => c.length > 0);
+  headers.push(...headerCells);
+
+  // Find output column divider — last column(s) are output
+  // Convention: all columns after the last input are output
+  // For simplicity, last column is output
+  const outputStartIndex = headers.length - 1;
+
+  // Skip separator row (----)
+  let dataStart = 1;
+  if (lines.length > 1 && /^[|\s-]+$/.test(lines[1])) {
+    dataStart = 2;
+  }
+
+  // Check for hit policy annotation
+  const hitPolicyMatch = source.match(/@hitPolicy\s*=\s*"?(\w+)"?/);
+  if (hitPolicyMatch) {
+    hitPolicy = hitPolicyMatch[1];
+  }
+
+  // Parse data rows
+  for (let i = dataStart; i < lines.length; i++) {
+    const cells = lines[i].split('|').map((c) => c.trim()).filter((c) => c.length > 0);
+    if (cells.length < headers.length) continue;
+
+    const inputs: Record<string, string> = {};
+    const output: Record<string, string> = {};
+
+    for (let j = 0; j < headers.length; j++) {
+      if (j >= outputStartIndex) {
+        output[headers[j]] = cells[j];
+      } else {
+        inputs[headers[j]] = cells[j];
+      }
+    }
+
+    rules.push({ inputs, output });
+  }
+
+  return { hitPolicy, rules, headers };
+}
+
+// =============================================================================
+// Main extraction
+// =============================================================================
+
+/**
+ * Extracts a grammar island from a TaggedTemplateExpression.
+ */
+export function extractGrammarIsland(
+  path: NodePath<t.TaggedTemplateExpression>,
+  state: any,
+  slug: string
+): void {
+  const tag = path.node.tag;
+  if (!t.isIdentifier(tag)) return;
+
+  const tagName = tag.name;
+  if (!GRAMMAR_TAGS.has(tagName)) return;
+
+  const compilerState = state as CompilerState;
+
+  // Reconstruct the raw template source
+  const quasi = path.node.quasi;
+  let rawSource = '';
+  for (let i = 0; i < quasi.quasis.length; i++) {
+    rawSource += quasi.quasis[i].value.raw;
+    if (i < quasi.expressions.length) {
+      // For expressions, emit a placeholder
+      const expr = quasi.expressions[i];
+      if (t.isIdentifier(expr)) {
+        rawSource += `\${${expr.name}}`;
+      } else {
+        rawSource += `\${expr_${i}}`;
+      }
+    }
+  }
+
+  rawSource = rawSource.trim();
+
+  // Parse based on context tag
+  let parsed: unknown = undefined;
+
+  switch (tagName) {
+    case 'cedar':
+      parsed = parseCedar(rawSource);
+      break;
+    case 'cron':
+      parsed = parseCron(rawSource);
+      break;
+    case 'dmn':
+      parsed = parseDmn(rawSource);
+      break;
+    case 'sql':
+      parsed = { query: rawSource };
+      break;
+    case 'graphql':
+      parsed = { query: rawSource };
+      break;
+    case 'jsonpath':
+      parsed = { expression: rawSource };
+      break;
+  }
+
+  const island: IRGrammarIsland = {
+    slug,
+    contextTag: tagName,
+    rawSource,
+    parsed,
+  };
+
+  // Store in compiler state metadata
+  if (!compilerState.metadata) compilerState.metadata = {};
+  const meta = compilerState.metadata as Record<string, unknown>;
+  if (!meta.grammarIslands) meta.grammarIslands = [];
+  (meta.grammarIslands as IRGrammarIsland[]).push(island);
+}
+
+/**
+ * Checks if a node is a grammar island tagged template.
+ */
+export function isGrammarIsland(node: t.Node): node is t.TaggedTemplateExpression {
+  return (
+    t.isTaggedTemplateExpression(node) &&
+    t.isIdentifier(node.tag) &&
+    GRAMMAR_TAGS.has(node.tag.name)
+  );
+}
+
+/**
+ * Extracts grammar islands from a Program node (model file top-level).
+ * Looks for patterns like:
+ *   export const access = cedar`...`;
+ *   export const computed = { field: sql`...` };
+ *   export const schedule = { job: cron`...` };
+ */
+export function extractGrammarIslands(path: NodePath<t.Program>, state: any): void {
+  path.traverse({
+    TaggedTemplateExpression(templatePath) {
+      const tag = templatePath.node.tag;
+      if (!t.isIdentifier(tag) || !GRAMMAR_TAGS.has(tag.name)) return;
+
+      // Derive slug from assignment context
+      let slug = 'unnamed';
+
+      // Check if this is assigned to a variable: const x = cedar`...`
+      const parent = templatePath.parentPath;
+      if (parent && parent.isVariableDeclarator() && t.isIdentifier(parent.node.id)) {
+        slug = parent.node.id.name;
+      }
+
+      // Check if this is a property value: { key: sql`...` }
+      if (parent && parent.isObjectProperty() && t.isIdentifier(parent.node.key)) {
+        slug = parent.node.key.name;
+      }
+      if (parent && parent.isObjectProperty() && t.isStringLiteral(parent.node.key)) {
+        slug = parent.node.key.value;
+      }
+
+      extractGrammarIsland(templatePath as NodePath<t.TaggedTemplateExpression>, state, slug);
+    },
+  });
+}