dirac-lang 0.1.2

package/src/runtime/session.ts

@@ -0,0 +1,228 @@
+/**
+ * Session management - maps to MASK session functions
+ */
+
+import Anthropic from '@anthropic-ai/sdk';
+import OpenAI from 'openai';
+import { OllamaProvider } from '../llm/ollama.js';
+import type { DiracSession, DiracConfig, Variable, Subroutine, DiracElement } from '../types/index.js';
+
+export function createSession(config: DiracConfig = {}): DiracSession {
+  const anthropicKey =  process.env.ANTHROPIC_API_KEY;
+  const openaiKey = config.apiKey || process.env.OPENAI_API_KEY;
+  const llmProvider = config.llmProvider || process.env.LLM_PROVIDER;
+  const ollamaModel = config.llmModel || process.env.LLM_MODEL || 'llama2';
+
+  let llmClient: any;
+  switch (llmProvider) {
+    case 'ollama':
+      llmClient = new OllamaProvider({ model: ollamaModel });
+      break;
+    case 'anthropic':
+      if (!anthropicKey) throw new Error('ANTHROPIC_API_KEY required for Anthropic provider');
+      llmClient = new Anthropic({ apiKey: anthropicKey });
+      break;
+    case 'openai':
+      if (!openaiKey) throw new Error('OPENAI_API_KEY required for OpenAI provider');
+      llmClient = new OpenAI({ apiKey: openaiKey });
+      break;
+    default:
+      throw new Error('No valid LLM provider configured. Set llmProvider in config or LLM_PROVIDER env.');
+  }
+  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,
+  };
+}
+
+// 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 {
+  session.subroutines.push({
+    name,
+    element,
+    boundary: session.subBoundary,
+    description,
+    parameters,
+  });
+}
+
+export function getSubroutine(session: DiracSession, name: string): DiracElement | undefined {
+  // Search from end (most recent) to beginning
+  for (let i = session.subroutines.length - 1; i >= 0; i--) {
+    if (session.subroutines[i].name === name) {
+      return session.subroutines[i].element;
+    }
+  }
+  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('');
+}
+
+// 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];
+}
+
+// Reflection/Introspection API
+
+export function getAvailableSubroutines(session: DiracSession): Array<{
+  name: string;
+  description?: string;
+  parameters?: Array<{
+    name: string;
+    type?: string;
+    required?: boolean;
+    description?: string;
+    enum?: string[];
+  }>;
+}> {
+  return session.subroutines.map(sub => ({
+    name: sub.name,
+    description: sub.description,
+    parameters: sub.parameters,
+  }));
+}

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,156 @@
+/**
+ * <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 parameters
+    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,56 @@
+/**
+ * <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';
+import { integrate } from '../runtime/interpreter.js';
+import { executeParameters } from './parameters.js';
+
+export async function executeDefvar(session: DiracSession, element: DiracElement): Promise<void> {
+  const name = element.attributes.name;
+  const valueAttr = element.attributes.value;
+  const visibleAttr = element.attributes.visible || 'false';
+  const literal = 'literal' in element.attributes;
+
+  if (!name) {
+    throw new Error('<defvar> requires name attribute');
+  }
+
+  // Determine visibility
+  const visible = visibleAttr === 'true' || visibleAttr === 'variable' || visibleAttr === 'both';
+
+  let value: any;
+  if (valueAttr !== undefined) {
+    value = substituteVariables(session, valueAttr);
+  } else if (literal) {
+    // Literal mode: take text or XML as-is
+    if (element.text) {
+      value = substituteVariables(session, element.text);
+    } else {
+      value = '';
+    }
+  } else if (element.children && element.children.length > 0) {
+    // If the first child is a <parameters> tag, call and assign its return value
+    if (element.children.length === 1 && element.children[0].tag && element.children[0].tag.toLowerCase() === 'parameters') {
+      value = await executeParameters(session, element.children[0]);
+    } else {
+      // Otherwise, execute all children and capture output
+      const prevOutput = session.output;
+      session.output = [];
+      for (const child of element.children) {
+        await integrate(session, child);
+      }
+      value = session.output.join('');
+      session.output = prevOutput;
+    }
+  } else if (element.text) {
+    value = substituteVariables(session, element.text);
+  } else {
+    value = '';
+  }
+
+  setVariable(session, name, value, visible);
+}

package/src/tags/eval.ts

@@ -0,0 +1,68 @@
+/**
+ * <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 Node.js modules to context
+    const { default: fs } = await import('fs');
+    const { default: path } = await import('path');
+    const { fileURLToPath } = await import('url');
+    context.fs = fs;
+    context.path = path;
+    context.__dirname = process.cwd();  // ESM doesn't have __dirname, use cwd
+    
+    // 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)}`);
+  }
+}