dirac-browser 0.1.1

package/src/runtime/session.ts

@@ -0,0 +1,209 @@
+/**
+ * Session management - Browser edition (no LLM SDKs)
+ */
+
+import type { DiracSession, DiracConfig, Variable, Subroutine, DiracElement } from '../types/index.js';
+
+export function createSession(config: DiracConfig = {}): DiracSession {
+  // Browser version - no LLM client
+  let llmClient: any = null;
+  
+  return {
+    variables: [],
+    subroutines: [],
+    varBoundary: 0,
+    subBoundary: 0,
+    parameterStack: [],
+    output: [],
+    llmClient,
+    limits: {
+      maxLLMCalls: config.maxLLMCalls || 100,
+      currentLLMCalls: 0,
+      maxDepth: config.maxDepth || 50,
+      currentDepth: 0,
+    },
+    isReturn: false,
+    isBreak: false,
+    debug: config.debug || false,
+    config,  // Store config reference
+  };
+}
+
+// Variable management (maps to var_info functions in MASK)
+
+export function setVariable(session: DiracSession, name: string, value: any, visible: boolean = false): void {
+  session.variables.push({
+    name,
+    value,
+    visible,
+    boundary: session.varBoundary,
+    passby: 'value',
+  });
+}
+
+export function getVariable(session: DiracSession, name: string): any {
+  // Search from end (most recent) to beginning
+  for (let i = session.variables.length - 1; i >= 0; i--) {
+    if (session.variables[i].name === name) {
+      return session.variables[i].value;
+    }
+  }
+  return undefined;
+}
+
+export function hasVariable(session: DiracSession, name: string): boolean {
+  return session.variables.some(v => v.name === name);
+}
+
+/**
+ * Set boundary marker for local variables
+ * Maps to var_info_set_boundary in MASK
+ */
+export function setBoundary(session: DiracSession): number {
+  const oldBoundary = session.varBoundary;
+  session.varBoundary = session.variables.length;
+  return oldBoundary;
+}
+
+/**
+ * Pop variables back to boundary (cleanup local scope)
+ * Maps to var_info_pop_to_boundary in MASK
+ */
+export function popToBoundary(session: DiracSession): void {
+  session.variables = session.variables.slice(0, session.varBoundary);
+}
+
+/**
+ * Clean private variables but keep visible ones
+ * Maps to var_info_clean_to_boundary in MASK
+ */
+export function cleanToBoundary(session: DiracSession): void {
+  const kept: Variable[] = [];
+  
+  for (let i = 0; i < session.varBoundary; i++) {
+    kept.push(session.variables[i]);
+  }
+  
+  for (let i = session.varBoundary; i < session.variables.length; i++) {
+    if (session.variables[i].visible) {
+      kept.push(session.variables[i]);
+    }
+  }
+  
+  session.variables = kept;
+  session.varBoundary = kept.length;
+}
+
+// Subroutine management (maps to subroutine functions in MASK)
+
+export function registerSubroutine(
+  session: DiracSession,
+  name: string,
+  element: DiracElement,
+  description?: string,
+  parameters?: any[]
+): void {
+  console.log(`📝 Registering subroutine: ${name}`, { description, paramCount: parameters?.length || 0 });
+  session.subroutines.push({
+    name,
+    element,
+    boundary: session.subBoundary,
+    description,
+    parameters,
+  });
+  console.log(`✅ Total subroutines registered: ${session.subroutines.length}`);
+}
+
+export function getSubroutine(session: DiracSession, name: string): DiracElement | undefined {
+  console.log(`🔍 Looking up subroutine: ${name} (${session.subroutines.length} registered)`);
+  console.log('Available subroutines:', session.subroutines.map(s => s.name));
+  
+  // Search from end (most recent) to beginning
+  for (let i = session.subroutines.length - 1; i >= 0; i--) {
+    if (session.subroutines[i].name === name) {
+      console.log(`✅ Found subroutine: ${name}`);
+      return session.subroutines[i].element;
+    }
+  }
+  console.log(`❌ Subroutine not found: ${name}`);
+  return undefined;
+}
+
+export function setSubroutineBoundary(session: DiracSession): number {
+  const oldBoundary = session.subBoundary;
+  session.subBoundary = session.subroutines.length;
+  return oldBoundary;
+}
+
+export function popSubroutinesToBoundary(session: DiracSession): void {
+  session.subroutines = session.subroutines.slice(0, session.subBoundary);
+}
+
+export function cleanSubroutinesToBoundary(session: DiracSession): void {
+  // For now, same as pop (visibility not implemented for subroutines yet)
+  popSubroutinesToBoundary(session);
+}
+
+// Variable substitution (maps to var_replace functions in MASK)
+
+export function substituteVariables(session: DiracSession, text: string): string {
+  // Decode HTML entities first
+  let decoded = text
+    .replace(/&#10;/g, '\n')
+    .replace(/&#13;/g, '\r')
+    .replace(/&#9;/g, '\t')
+    .replace(/&lt;/g, '<')
+    .replace(/&gt;/g, '>')
+    .replace(/&amp;/g, '&')
+    .replace(/&quot;/g, '"')
+    .replace(/&apos;/g, "'");
+  
+  // Substitute both ${var}/$var and {var} patterns
+  return decoded
+    .replace(/\$\{?(\w+)\}?/g, (match, varName) => {
+      const value = getVariable(session, varName);
+      return value !== undefined ? String(value) : match;
+    })
+    .replace(/\{(\w+)\}/g, (match, varName) => {
+      const value = getVariable(session, varName);
+      return value !== undefined ? String(value) : match;
+    });
+}
+
+// Output management
+
+export function emit(session: DiracSession, content: string): void {
+  session.output.push(content);
+}
+
+export function getOutput(session: DiracSession): string {
+  return session.output.join('');
+}
+
+/**
+ * Get all available subroutines for reflection
+ * Used by LLM adapter to auto-generate prompts
+ */
+export function getAvailableSubroutines(session: DiracSession) {
+  return session.subroutines
+    .filter(sub => sub.description || sub.parameters)
+    .map(sub => ({
+      name: sub.name,
+      description: sub.description,
+      parameters: sub.parameters || []
+    }));
+}
+
+// Parameter stack (for subroutine calls)
+
+export function pushParameters(session: DiracSession, params: DiracElement[]): void {
+  session.parameterStack.push(params);
+}
+
+export function popParameters(session: DiracSession): DiracElement[] | undefined {
+  return session.parameterStack.pop();
+}
+
+export function getCurrentParameters(session: DiracSession): DiracElement[] | undefined {
+  return session.parameterStack[session.parameterStack.length - 1];
+}

package/src/tags/assign.ts

@@ -0,0 +1,37 @@
+/**
+ * <assign> tag - assign value to existing variable
+ * Maps to mask_tag_assign in MASK
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { getVariable, setVariable, substituteVariables } from '../runtime/session.js';
+
+export function executeAssign(session: DiracSession, element: DiracElement): void {
+  const name = element.attributes.name;
+  const valueAttr = element.attributes.value;
+  
+  if (!name) {
+    throw new Error('<assign> requires name attribute');
+  }
+  
+  // Get value
+  let value: any;
+  if (valueAttr !== undefined) {
+    value = substituteVariables(session, valueAttr);
+  } else if (element.text) {
+    value = substituteVariables(session, element.text);
+  } else {
+    value = '';
+  }
+  
+  // Find existing variable and update it
+  for (let i = session.variables.length - 1; i >= 0; i--) {
+    if (session.variables[i].name === name) {
+      session.variables[i].value = value;
+      return;
+    }
+  }
+  
+  // Variable not found - create it (same as MASK behavior)
+  setVariable(session, name, value, false);
+}

package/src/tags/call.ts

@@ -0,0 +1,166 @@
+/**
+ * <call> tag - invoke subroutine
+ * Maps to mask_call_integrate in MASK
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { 
+  getSubroutine, 
+  setBoundary, 
+  popToBoundary,
+  cleanToBoundary,
+  pushParameters,
+  popParameters,
+  substituteVariables,
+  setVariable,
+  getVariable,
+} from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+
+export async function executeCall(session: DiracSession, element: DiracElement): Promise<void> {
+  // Support both <call name="FOO" /> and direct <FOO /> syntax
+  // For <call> tag, use name/subroutine attribute
+  // For direct syntax, use element.tag
+  let name: string;
+  
+  if (element.tag === 'call') {
+    // Explicit <call> tag - use name or subroutine attribute
+    name = element.attributes.name || element.attributes.subroutine || '';
+  } else {
+    // Direct tag syntax - use tag name itself, ignore name attribute
+    name = element.tag;
+  }
+  
+  if (!name) {
+    throw new Error('<call> requires name or subroutine attribute');
+  }
+  
+  const subroutine = getSubroutine(session, name);
+  if (!subroutine) {
+    throw new Error(`Subroutine '${name}' not found`);
+  }
+  
+  // Handle extension (parent subroutine)
+  const extendsName = subroutine.attributes.extends;
+  if (extendsName) {
+    const parent = getSubroutine(session, extendsName);
+    if (parent) {
+      // Call parent first
+      await executeCallInternal(session, parent, element);
+    }
+  }
+  
+  // Call this subroutine
+  await executeCallInternal(session, subroutine, element);
+}
+
+async function executeCallInternal(
+  session: DiracSession, 
+  subroutine: DiracElement,
+  callElement: DiracElement
+): Promise<void> {
+  // Set boundary for local scope
+  const oldBoundary = setBoundary(session);
+  const wasReturn = session.isReturn;
+  session.isReturn = false;
+  
+  // Substitute variables in call element attributes before pushing to parameter stack
+  const substitutedElement: DiracElement = {
+    tag: callElement.tag,
+    attributes: {},
+    children: callElement.children
+  };
+  
+  // Process each attribute for {variable} substitution
+  for (const [key, value] of Object.entries(callElement.attributes)) {
+    if (typeof value === 'string') {
+      substitutedElement.attributes[key] = substituteVariables(session, value);
+    } else {
+      substitutedElement.attributes[key] = value;
+    }
+  }
+  
+  // Push caller element onto parameter stack for <parameters select="*|@*|@attr"/> access
+  pushParameters(session, [substitutedElement]);
+  
+  try {
+    // Bind call attributes as variables (for <call name="foo" x="1" y="2"/> style)
+    // This allows ${x} and ${y} to be used in the subroutine body
+    for (const [key, value] of Object.entries(substitutedElement.attributes)) {
+      // Skip special attributes
+      if (key === 'name' || key === 'subroutine') continue;
+      
+      // Set as local variable
+      setVariable(session, key, value, false);
+    }
+    
+    // Bind parameters (for <call><parameters>...</parameters></call> style)
+    const paramElements = callElement.children.filter(c => c.tag === 'parameters');
+    if (paramElements.length > 0) {
+      await bindParameters(session, subroutine, paramElements[0]);
+    }
+    
+    // Execute subroutine body
+    await integrateChildren(session, subroutine);
+    
+  } finally {
+    // Pop parameter stack
+    popParameters(session);
+    
+    // Clean up scope (keep visible variables)
+    session.varBoundary = oldBoundary;
+    cleanToBoundary(session);
+    session.isReturn = wasReturn;
+  }
+}
+
+async function bindParameters(
+  session: DiracSession,
+  subroutine: DiracElement, 
+  callParams: DiracElement
+): Promise<void> {
+  // Find <parameters> definition in subroutine
+  const paramDef = subroutine.children.find(c => c.tag === 'parameters');
+  if (!paramDef) {
+    return; // No parameters defined
+  }
+  
+  // Get variable definitions from parameter declaration
+  const paramVars = paramDef.children.filter(c => c.tag === 'variable');
+  const callVars = callParams.children.filter(c => c.tag === 'variable');
+  
+  // Bind each parameter
+  for (let i = 0; i < paramVars.length; i++) {
+    const paramVar = paramVars[i];
+    const callVar = callVars[i];
+    
+    const paramName = paramVar.attributes.name;
+    const passby = paramVar.attributes.passby || 'value';
+    
+    if (!paramName) continue;
+    
+    let value: any;
+    
+    if (callVar) {
+      // Get value from call site
+      const callValue = callVar.attributes.value;
+      if (callValue) {
+        if (passby === 'ref') {
+          // Pass by reference - store variable name
+          setVariable(session, paramName, getVariable(session, callValue), false);
+          session.variables[session.variables.length - 1].passby = 'ref';
+          session.variables[session.variables.length - 1].refName = callValue;
+        } else {
+          // Pass by value
+          value = substituteVariables(session, callValue);
+          setVariable(session, paramName, value, false);
+        }
+      }
+    } else {
+      // No value provided - use default if available
+      const defaultValue = paramVar.attributes.default || '';
+      value = substituteVariables(session, defaultValue);
+      setVariable(session, paramName, value, false);
+    }
+  }
+}

package/src/tags/defvar.ts

@@ -0,0 +1,32 @@
+/**
+ * <defvar> tag - define variable
+ * Maps to mask_tag_defvar in MASK
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { setVariable, substituteVariables } from '../runtime/session.js';
+
+export function executeDefvar(session: DiracSession, element: DiracElement): void {
+  const name = element.attributes.name;
+  const valueAttr = element.attributes.value;
+  const visibleAttr = element.attributes.visible || 'false';
+  
+  if (!name) {
+    throw new Error('<defvar> requires name attribute');
+  }
+  
+  // Determine visibility
+  const visible = visibleAttr === 'true' || visibleAttr === 'variable' || visibleAttr === 'both';
+  
+  // Get value (from attribute or text content)
+  let value: any;
+  if (valueAttr !== undefined) {
+    value = substituteVariables(session, valueAttr);
+  } else if (element.text) {
+    value = substituteVariables(session, element.text);
+  } else {
+    value = '';
+  }
+  
+  setVariable(session, name, value, visible);
+}

package/src/tags/eval.ts

@@ -0,0 +1,65 @@
+/**
+ * <eval> tag - evaluate JavaScript expression
+ * Maps to mask_tag_eval in MASK (but for JS, not C)
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { setVariable, getVariable, substituteVariables } from '../runtime/session.js';
+
+// AsyncFunction constructor
+const AsyncFunction = Object.getPrototypeOf(async function(){}).constructor;
+
+export async function executeEval(session: DiracSession, element: DiracElement): Promise<void> {
+  const name = element.attributes.name;
+  const exprAttr = element.attributes.expr;
+  
+  // Get expression - replace ${var} with var (will be passed as actual JS vars)
+  let expr: string;
+  if (exprAttr) {
+    expr = exprAttr.replace(/\$\{(\w+)\}/g, '$1');
+  } else if (element.text) {
+    expr = element.text.replace(/\$\{(\w+)\}/g, '$1');
+  } else {
+    throw new Error('<eval> requires expr attribute or text content');
+  }
+  
+  if (session.debug) {
+    console.error(`[EVAL] Code after substitution:\n${expr}\n`);
+  }
+  
+  try {
+    // Build context object with all variables
+    const context: Record<string, any> = {};
+    for (const v of session.variables) {
+      context[v.name] = v.value;
+    }
+    
+    // Add customContext if provided (for Angular services, etc.)
+    if (session.config.customContext) {
+      Object.assign(context, session.config.customContext);
+    }
+    
+    // Add helper to get current parameters from stack
+    context.getParams = () => {
+      const params = session.parameterStack[session.parameterStack.length - 1];
+      return params && params[0] ? params[0] : null;
+    };
+    
+    let result: any;
+    // Execute as async function to support top-level await
+    const func = new AsyncFunction(...Object.keys(context), expr);
+    result = await func(...Object.values(context));
+    
+    if (session.debug) {
+      console.error(`[EVAL] Result: ${JSON.stringify(result)}`);
+    }
+    
+    // Store result if name provided
+    if (name) {
+      setVariable(session, name, result, false);
+    }
+    
+  } catch (error) {
+    throw new Error(`Eval error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tags/execute.ts

@@ -0,0 +1,52 @@
+/**
+ * <execute> tag - Execute dynamically generated Dirac code
+ * Takes LLM-generated or variable content and interprets it as Dirac XML
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { getVariable, substituteVariables } from '../runtime/session.js';
+import { DiracParser } from '../runtime/parser.js';
+import { integrate } from '../runtime/interpreter.js';
+
+export async function executeExecute(session: DiracSession, element: DiracElement): Promise<void> {
+  const sourceAttr = element.attributes.source;
+  
+  // Get the Dirac code to execute
+  let diracCode: string;
+  
+  if (sourceAttr) {
+    // Get from variable
+    diracCode = getVariable(session, sourceAttr);
+    if (!diracCode) {
+      throw new Error(`<execute> source variable '${sourceAttr}' not found`);
+    }
+  } else if (element.text) {
+    // Get from text content (with variable substitution)
+    diracCode = substituteVariables(session, element.text);
+  } else {
+    throw new Error('<execute> requires source attribute or text content');
+  }
+  
+  if (session.debug) {
+    console.error(`[EXECUTE] Interpreting dynamic code:\n${diracCode}\n`);
+  }
+  
+  // Strip markdown code blocks if present
+  diracCode = diracCode.trim();
+  if (diracCode.startsWith('```')) {
+    // Remove markdown code fences
+    diracCode = diracCode.replace(/^```(?:xml|html)?\n?/m, '').replace(/\n?```$/m, '').trim();
+  }
+  
+  try {
+    // Parse the dynamic Dirac code
+    const parser = new DiracParser();
+    const dynamicAST = parser.parse(diracCode);
+    
+    // Execute the dynamically generated code
+    await integrate(session, dynamicAST);
+    
+  } catch (error) {
+    throw new Error(`Execute error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}

package/src/tags/expr.ts

@@ -0,0 +1,128 @@
+/**
+ * <expr> tag - arithmetic and logical operations
+ * Maps to mask_tag_expr in MASK
+ * 
+ * Supports: plus, minus, times, divide, mod, lt, gt, eq, and, or, not
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { emit, substituteVariables } from '../runtime/session.js';
+import { integrate } from '../runtime/interpreter.js';
+
+export async function executeExpr(session: DiracSession, element: DiracElement): Promise<void> {
+  const op = element.attributes.eval || element.attributes.op;
+  
+  if (!op) {
+    throw new Error('<expr> requires eval or op attribute');
+  }
+  
+  // Collect arguments from <arg> children
+  const args: number[] = [];
+  const stringArgs: string[] = [];
+  
+  for (const child of element.children) {
+    if (child.tag === 'arg') {
+      let argValue = '';
+      
+      // Check if arg has text content directly
+      if (child.text) {
+        argValue = substituteVariables(session, child.text);
+      } else {
+        // Capture output from arg children
+        const oldOutput = session.output;
+        session.output = [];
+        
+        for (const argChild of child.children) {
+          await integrate(session, argChild);
+        }
+        
+        argValue = session.output.join('');
+        session.output = oldOutput;
+      }
+      
+      stringArgs.push(argValue);
+      const numValue = parseFloat(argValue);
+      args.push(isNaN(numValue) ? 0 : numValue);
+    }
+  }
+  
+  let result: number | boolean = 0;
+  
+  switch (op.toLowerCase()) {
+    case 'plus':
+    case 'add':
+      result = args.reduce((a, b) => a + b, 0);
+      break;
+      
+    case 'minus':
+    case 'subtract':
+      result = args.length > 0 ? args[0] - args.slice(1).reduce((a, b) => a + b, 0) : 0;
+      break;
+      
+    case 'times':
+    case 'multiply':
+    case 'mul':
+      result = args.reduce((a, b) => a * b, 1);
+      break;
+      
+    case 'divide':
+    case 'div':
+      if (args.length >= 2 && args[1] !== 0) {
+        result = args[0] / args[1];
+      } else {
+        result = 0;
+      }
+      break;
+      
+    case 'mod':
+    case 'modulo':
+      if (args.length >= 2 && args[1] !== 0) {
+        result = args[0] % args[1];
+      } else {
+        result = 0;
+      }
+      break;
+      
+    case 'lt':
+    case 'less':
+      result = args.length >= 2 ? args[0] < args[1] : false;
+      break;
+      
+    case 'gt':
+    case 'greater':
+      result = args.length >= 2 ? args[0] > args[1] : false;
+      break;
+      
+    case 'eq':
+    case 'equal':
+      result = args.length >= 2 ? args[0] === args[1] : false;
+      break;
+      
+    case 'and':
+      result = args.every(a => a !== 0);
+      break;
+      
+    case 'or':
+      result = args.some(a => a !== 0);
+      break;
+      
+    case 'not':
+      result = args.length > 0 ? args[0] === 0 : true;
+      break;
+      
+    case 'same':
+    case 'strcmp':
+      result = stringArgs.length >= 2 ? stringArgs[0] === stringArgs[1] : false;
+      break;
+      
+    default:
+      throw new Error(`<expr> unknown operation: ${op}`);
+  }
+  
+  // Emit result
+  if (typeof result === 'boolean') {
+    emit(session, result ? '1' : '0');
+  } else {
+    emit(session, String(result));
+  }
+}