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

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

@@ -1,235 +0,0 @@
-/**
- * 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

@@ -1,302 +0,0 @@
-/**
- * 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);
-    },
-  });
-}