dirac-lang 0.1.23 → 0.1.25

package/src/runtime/interpreter.ts

@@ -1,203 +0,0 @@
-/**
- * Core interpreter - maps to mask_integrate in MASK
- */
-
-import type { DiracElement, DiracSession } from '../types/index.js';
-import { substituteVariables, emit, getSubroutine } from './session.js';
-import { executeDefvar } from '../tags/defvar.js';
-import { executeVariable } from '../tags/variable.js';
-import { executeAssign } from '../tags/assign.js';
-import { executeOutput } from '../tags/output.js';
-import { executeSubroutine } from '../tags/subroutine.js';
-import { executeCall } from '../tags/call.js';
-import { executeLoop } from '../tags/loop.js';
-import { executeIf } from '../tags/if.js';
-import { executeLLM } from '../tags/llm.js';
-import { executeEval } from '../tags/eval.js';
-import { executeExecute } from '../tags/execute.js';
-import { executeImport } from '../tags/import.js';
-import { executeParameters } from '../tags/parameters.js';
-import { executeExpr } from '../tags/expr.js';
-import { executeSystem } from '../tags/system.js';
-import { executeRequireModule } from '../tags/require_module.js';
-import { executeTagCheck } from '../tags/tag-check.js';
-import { executeThrow } from '../tags/throw.js';
-import { executeTry } from '../tags/try.js';
-import { executeCatch } from '../tags/catch.js';
-import { executeException } from '../tags/exception.js';
-import { executeTestIf } from '../tags/test-if.js';
-import { executeAvailableSubroutines } from '../tags/available-subroutines.js';
-import { executeForeach } from '../tags/foreach.js';
-import { executeAttr } from '../tags/attr.js';
-import { executeEnvironment } from '../tags/environment.js';
-import { executeInput } from '../tags/input.js';
-
-export async function integrate(session: DiracSession, element: DiracElement): Promise<void> {
-  // Check execution limits
-  if (session.limits.currentDepth >= session.limits.maxDepth) {
-    throw new Error('Maximum execution depth exceeded');
-  }
-  
-  session.limits.currentDepth++;
-  
-  try {
-    // Handle text nodes
-    if (element.text && !element.tag) {
-      const substituted = substituteVariables(session, element.text);
-      emit(session, substituted);
-      return;
-    }
-    
-    // Check control flow
-    if (session.isReturn || session.isBreak) {
-      return;
-    }
-    
-    // Dispatch to tag handlers
-    switch (element.tag.toLowerCase()) {
-      case 'defvar':
-        await executeDefvar(session, element);
-        break;
-        
-      case 'variable':
-        await executeVariable(session, element);
-        break;
-        
-      case 'assign':
-        await executeAssign(session, element);
-        break;
-        
-      case 'output':
-        await executeOutput(session, element);
-        break;
-        
-      case 'subroutine':
-        await executeSubroutine(session, element);
-        break;
-        
-      case 'call':
-        await executeCall(session, element);
-        break;
-        
-      case 'loop':
-        await executeLoop(session, element);
-        break;
-        
-      case 'if':
-        await executeIf(session, element);
-        break;
-        
-      case 'llm':
-        await executeLLM(session, element);
-        break;
-        
-      case 'eval':
-        await executeEval(session, element);
-        break;
-        
-      case 'execute':
-        await executeExecute(session, element);
-        break;
-        
-      case 'import':
-        await executeImport(session, element);
-        break;
-        
-      case 'parameters': {
-        const result = await executeParameters(session, element);
-        if (typeof result === 'string') {
-          emit(session, result);
-        }
-        break;
-      }
-        
-      case 'expr':
-        await executeExpr(session, element);
-        break;
-        
-      case 'system':
-        await executeSystem(session, element);
-        break;
-        
-      case 'tag-check':
-        await executeTagCheck(session, element);
-        break;
-
-      case 'throw':
-        await executeThrow(session, element);
-        break;
-
-      case 'try':
-        await executeTry(session, element);
-        break;
-
-      case 'catch':
-        await executeCatch(session, element);
-        break;
-
-      case 'exception':
-        await executeException(session, element);
-        break;
-
-      case 'test-if':
-        await executeTestIf(session, element);
-        break;
-        
-      case 'available-subroutines':
-        await executeAvailableSubroutines(session, element);
-        break;
-        
-      case 'foreach':
-        await executeForeach(session, element);
-        break;
-        
-      case 'attr':
-        await executeAttr(session, element);
-        break;
-        
-      case 'environment':
-        await executeEnvironment(session, element);
-        break;
-        
-      case 'input':
-        await executeInput(session, element);
-        break;
-
-      case 'require_module':
-        await executeRequireModule(session, element);
-        break;
-        
-      case 'dirac':
-      case 'DIRAC-ROOT':
-        // Container tags - just execute children
-        for (const child of element.children) {
-          await integrate(session, child);
-          if (session.isReturn || session.isBreak) break;
-        }
-        break;
-        
-      default:
-        // Unknown tag - check if it's a subroutine name
-        const subroutine = getSubroutine(session, element.tag);
-        if (subroutine) {
-          // Treat unknown tag as subroutine call
-          await executeCall(session, element);
-        } else {
-          // Really unknown - just process children
-          for (const child of element.children) {
-            await integrate(session, child);
-            if (session.isReturn || session.isBreak) break;
-          }
-        }
-    }
-  } finally {
-    session.limits.currentDepth--;
-  }
-}
-
-export async function integrateChildren(session: DiracSession, element: DiracElement): Promise<void> {
-  for (const child of element.children) {
-    await integrate(session, child);
-    if (session.isReturn || session.isBreak) break;
-  }
-}

package/src/runtime/parser.ts

@@ -1,155 +0,0 @@
-/**
- * XML Parser for Dirac (.di files)
- */
-
-import { XMLParser } from 'fast-xml-parser';
-import type { DiracElement } from '../types/index.js';
-
-export class DiracParser {
-  private parser: XMLParser;
-  
-  constructor() {
-    this.parser = new XMLParser({
-      ignoreAttributes: false,
-      attributeNamePrefix: '@_',
-      trimValues: false,  // Preserve whitespace in mixed content
-      parseAttributeValue: false,
-      parseTagValue: false,
-      textNodeName: '#text',
-      cdataPropName: '#cdata',
-      preserveOrder: true,  // Preserve element order!
-      commentPropName: '#comment',
-    });
-  }
-  
-  parse(source: string): DiracElement {
-    // Strip shebang line if present
-    if (source.startsWith('#!')) {
-      source = source.replace(/^#!.*\n/, '');
-    }
-    
-    // Always wrap in DIRAC-ROOT to ensure valid XML with single root
-    // This allows files with comments, multiple elements, or no root
-    source = `<DIRAC-ROOT>\n${source}\n</DIRAC-ROOT>`;
-    
-    const result = this.parser.parse(source);
-    // With preserveOrder, result is an array
-    if (!Array.isArray(result) || result.length === 0) {
-      throw new Error('Empty or invalid XML');
-    }
-    
-    // Find the first non-comment element
-    for (const item of result) {
-      if (!item['#comment']) {
-        return this.convertOrderedToElement(item);
-      }
-    }
-    
-    throw new Error('No root element found');
-  }
-  
-  private convertOrderedToElement(obj: any): DiracElement {
-    // obj is like { "tagname": [...children], ":@": {...attributes} }
-    const tagName = Object.keys(obj).find(k => k !== ':@' && k !== '#comment');
-    
-    if (!tagName) {
-      throw new Error('Invalid element structure');
-    }
-    
-    const element: DiracElement = {
-      tag: tagName,
-      attributes: {},
-      children: [],
-    };
-    
-    // Extract attributes
-    if (obj[':@']) {
-      for (const [key, value] of Object.entries(obj[':@'])) {
-        if (key.startsWith('@_')) {
-          element.attributes[key.slice(2)] = value as string;
-        }
-      }
-    }
-    
-    // Extract children
-    const children = obj[tagName];
-    if (Array.isArray(children)) {
-      for (const child of children) {
-        if (child['#text']) {
-          // Text node - add as child AND to element.text for backward compat
-          element.children.push({
-            tag: '',
-            text: child['#text'],
-            attributes: {},
-            children: []
-          });
-          // Also set element.text if not set (for simple text-only elements)
-          if (!element.text) {
-            element.text = child['#text'];
-          } else {
-            element.text += child['#text'];
-          }
-        } else if (child['#comment']) {
-          // Skip comments
-          continue;
-        } else {
-          // Child element
-          element.children.push(this.convertOrderedToElement(child));
-        }
-      }
-    }
-    
-    return element;
-  }
-  
-  // Old method - no longer used
-  private convertToElement(obj: any, tagName?: string): DiracElement {
-    if (!tagName) {
-      // Root level - find the actual tag
-      const keys = Object.keys(obj);
-      if (keys.length === 0) {
-        throw new Error('Empty XML');
-      }
-      tagName = keys[0];
-      obj = obj[tagName];
-    }
-    
-    const element: DiracElement = {
-      tag: tagName,
-      attributes: {},
-      children: [],
-    };
-    
-    if (typeof obj === 'string') {
-      element.text = obj;
-      return element;
-    }
-    
-    if (!obj) {
-      return element;
-    }
-    
-    // Extract attributes and children
-    for (const key of Object.keys(obj)) {
-      const value = obj[key];
-      
-      if (key === '#text') {
-        element.text = value;
-      } else if (key.startsWith('@_')) {
-        // Attribute
-        element.attributes[key.slice(2)] = value;
-      } else {
-        // Child element
-        if (Array.isArray(value)) {
-          for (const item of value) {
-            element.children.push(this.convertToElement(item, key));
-          }
-        } else {
-          element.children.push(this.convertToElement(value, key));
-        }
-      }
-    }
-    
-    return element;
-  }
-}

package/src/runtime/session.ts

@@ -1,325 +0,0 @@
-// Substitute both $var and ${var} in a string using session variables
-export function substituteAttribute(session: DiracSession, value: any): string {
-  if (typeof value !== 'string') return value;
-  return value
-    .replace(/\$\{(\w+)\}/g, (match, varName) => {
-      const v = getVariable(session, varName);
-      return v !== undefined ? String(v) : match;
-    })
-    .replace(/\$(\w+)/g, (match, varName) => {
-      const v = getVariable(session, varName);
-      return v !== undefined ? String(v) : match;
-    });
-}
-/**
- * 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: [],
-    exceptions: [],
-    currentException: {
-      size: 0,
-      exceptions: [],
-    },
-    output: [],
-    llmClient,
-    limits: {
-      maxLLMCalls: config.maxLLMCalls || 100,
-      currentLLMCalls: 0,
-      maxDepth: config.maxDepth || 50,
-      currentDepth: 0,
-    },
-    isReturn: false,
-    isBreak: false,
-    skipSubroutineRegistration: 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[],
-  meta?: Record<string, string>
-): void {
-  session.subroutines.push({
-    name,
-    element,
-    boundary: session.subBoundary,
-    description,
-    parameters,
-    meta,
-  });
-}
-
-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 getParentSubroutine(
-  session: DiracSession, 
-  name: string, 
-  currentElement?: DiracElement
-): DiracElement | undefined {
-  // Search from end, finding parent of currentElement
-  // If currentElement provided, skip until we find it, then return next match
-  // If not provided, just return most recent
-  
-  let foundCurrent = currentElement === undefined;
-  
-  for (let i = session.subroutines.length - 1; i >= 0; i--) {
-    if (session.subroutines[i].name === name) {
-      if (!foundCurrent) {
-        // Check if this is the current element
-        if (session.subroutines[i].element === currentElement) {
-          foundCurrent = true;
-          continue; // Skip current, look for parent
-        }
-        continue; // Not current yet, keep searching
-      }
-      // Found current, this is the parent
-      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 only; do NOT substitute variables globally
-  return 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, "'");
-}
-
-// 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,
-    meta: sub.meta,
-  }));
-}
-
-// Exception handling (for try/catch/throw)
-
-export function throwException(session: DiracSession, name: string, dom: DiracElement): void {
-  session.exceptions.push({
-    name,
-    dom,
-    isBoundary: 0,
-  });
-}
-
-export function setExceptionBoundary(session: DiracSession): void {
-  const size = session.exceptions.length;
-  if (size === 0) return;
-  const top = session.exceptions[size - 1];
-  top.isBoundary++;
-}
-
-export function unsetExceptionBoundary(session: DiracSession): void {
-  const size = session.exceptions.length;
-  if (size === 0) return;
-  for (let i = size - 1; i >= 0; i--) {
-    const exception = session.exceptions[i];
-    if (exception.isBoundary > 0) {
-      exception.isBoundary--;
-      break;
-    }
-  }
-}
-
-export function lookupException(session: DiracSession, name: string): number {
-  const size = session.exceptions.length;
-  if (size === 0) return 0;
-  
-  let count = 0;
-  for (let i = size - 1; i >= 0; i--) {
-    const exception = session.exceptions[i];
-    if (exception.isBoundary > 0) break;  // Stop at boundary
-    
-    if (exception.name === name) {
-      // Add to current exception list
-      session.currentException.exceptions.push(exception.dom);
-      session.currentException.size++;
-      count++;
-    }
-  }
-  
-  return count;
-}
-
-export function flushCurrentException(session: DiracSession): void {
-  session.currentException.size = 0;
-  session.currentException.exceptions = [];
-}
-
-export function getCurrentExceptions(session: DiracSession): DiracElement[] {
-  return session.currentException.exceptions;
-}