dirac-lang 0.1.24 → 0.1.26

package/src/tags/execute.ts

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

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

package/src/tags/foreach.ts

@@ -1,170 +0,0 @@
-/**
- * <foreach> tag - iterate over XML elements
- * Usage: <foreach from="<available-subroutines />" as="sub">...</foreach>
- * or: <foreach from="$varname" as="item">...</foreach>
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { setVariable, getVariable, substituteVariables } from '../runtime/session.js';
-import { integrateChildren } from '../runtime/interpreter.js';
-import { XMLParser } from 'fast-xml-parser';
-
-export async function executeForeach(session: DiracSession, element: DiracElement): Promise<void> {
-  const fromAttr = element.attributes.from;
-  const asVar = element.attributes.as || 'item';
-  const xpath = element.attributes.xpath; // Optional: filter like "//subroutine"
-  
-  if (!fromAttr) {
-    throw new Error('<foreach> requires "from" attribute');
-  }
-  
-  // Get the XML content (either from variable or inline content)
-  let xmlContent: string;
-  
-  if (fromAttr.startsWith('$')) {
-    // Get from variable
-    const varName = fromAttr.substring(1);
-    xmlContent = getVariable(session, varName) || '';
-  } else if (fromAttr.startsWith('<')) {
-    // Evaluate the "from" attribute as inline XML (e.g., <available-subroutines />)
-    const savedOutput = session.output;
-    session.output = [];
-    
-    // Parse and execute the from content
-    const { DiracParser } = await import('../runtime/parser.js');
-    const parser = new DiracParser();
-    try {
-      const fromElement = parser.parse(fromAttr);
-      const { integrate } = await import('../runtime/interpreter.js');
-      await integrate(session, fromElement);
-    } catch (e) {
-      session.output = savedOutput;
-      throw new Error(`Failed to evaluate from="${fromAttr}": ${e}`);
-    }
-    
-    xmlContent = session.output.join('');
-    session.output = savedOutput;
-  } else {
-    // Treat as literal XML string
-    xmlContent = substituteVariables(session, fromAttr);
-  }
-  
-  if (!xmlContent || xmlContent.trim() === '') {
-    return; // Nothing to iterate over
-  }
-  
-  // Parse the XML content
-  const parser = new XMLParser({
-    ignoreAttributes: false,
-    attributeNamePrefix: '@_',
-    parseAttributeValue: false,
-    preserveOrder: true,
-  });
-  
-  let parsed;
-  try {
-    parsed = parser.parse(`<root>${xmlContent}</root>`);
-  } catch (e) {
-    throw new Error(`Failed to parse XML in <foreach>: ${e}`);
-  }
-  
-  // Extract elements to iterate over
-  const items = extractElements(parsed, xpath);
-  
-  // Iterate over each item
-  for (const item of items) {
-    // Store the item as a variable (as an object with tag, attributes, text)
-    setVariable(session, asVar, item, false);
-    
-    // Execute the loop body
-    await integrateChildren(session, element);
-    
-    if (session.isBreak) {
-      session.isBreak = false;
-      break;
-    }
-    
-    if (session.isReturn) {
-      break;
-    }
-  }
-}
-
-interface XmlItem {
-  tag: string;
-  attributes: Record<string, string>;
-  text?: string;
-}
-
-function extractElements(parsed: any, xpath?: string): XmlItem[] {
-  const items: XmlItem[] = [];
-  
-  // parsed is array with preserveOrder
-  if (!Array.isArray(parsed)) {
-    return items;
-  }
-  
-  // Recursively extract all elements matching xpath
-  const extractFromNode = (node: any) => {
-    if (!node) return;
-    
-    const tagName = Object.keys(node).find(k => k !== ':@' && k !== '#text' && k !== '#comment');
-    if (!tagName) return;
-    
-    const item: XmlItem = {
-      tag: tagName,
-      attributes: {},
-    };
-    
-    // Extract attributes
-    if (node[':@']) {
-      for (const [key, value] of Object.entries(node[':@'])) {
-        if (key.startsWith('@_')) {
-          item.attributes[key.slice(2)] = value as string;
-        }
-      }
-    }
-    
-    // Extract text content and recurse into children
-    const children = node[tagName];
-    if (Array.isArray(children)) {
-      for (const child of children) {
-        if (child['#text']) {
-          item.text = (item.text || '') + child['#text'];
-        } else {
-          // Recurse into child elements
-          extractFromNode(child);
-        }
-      }
-    }
-    
-    // Add this item if it matches xpath
-    if (!xpath || matchesXPath(item, xpath)) {
-      items.push(item);
-    }
-  };
-  
-  // Start extraction from root
-  for (const rootItem of parsed) {
-    if (rootItem['root']) {
-      const rootChildren = rootItem['root'];
-      if (Array.isArray(rootChildren)) {
-        for (const child of rootChildren) {
-          extractFromNode(child);
-        }
-      }
-    }
-  }
-  
-  return items;
-}
-
-function matchesXPath(item: XmlItem, xpath: string): boolean {
-  // Simple xpath matching - just tag name for now
-  // Supports: "//tagname" or "tagname"
-  const tagMatch = xpath.match(/\/{0,2}(\w+)/);
-  if (tagMatch) {
-    return item.tag === tagMatch[1];
-  }
-  return true;
-}

package/src/tags/if.ts

@@ -1,191 +0,0 @@
-/**
- * <if> tag - conditional execution with <cond>, <then>, <else> children
- * Maps to mask_if_integrate in MASK C implementation
- * 
- * Usage:
- * <if>
- *   <cond>condition expression or <cond> tag</cond>
- *   <then>executed if true</then>
- *   <else>executed if false</else>
- * </if>
- * 
- * The first child can be:
- * - A <cond> tag with condition logic
- * - Any other element that evaluates to a value
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { getOutput } from '../runtime/session.js';
-
-export async function executeIf(session: DiracSession, element: DiracElement): Promise<void> {
-  // Extract condition, then, and else elements from children
-  let conditionElement: DiracElement | null = null;
-  let thenElement: DiracElement | null = null;
-  let elseElement: DiracElement | null = null;
-  
-  for (const child of element.children) {
-    const tag = child.tag.toLowerCase();
-    if (tag === 'cond') {
-      conditionElement = child;
-    } else if (tag === 'then' || tag === 'do') {
-      thenElement = child;
-    } else if (tag === 'else') {
-      elseElement = child;
-    } else if (!conditionElement && child.tag) {
-      // First non-cond/then/else element is treated as condition
-      conditionElement = child;
-    }
-  }
-  
-  // Evaluate the condition
-  const condition = await evaluatePredicate(session, conditionElement);
-  
-  // Execute then or else block based on condition
-  if (condition) {
-    if (thenElement) {
-      const { integrateChildren } = await import('../runtime/interpreter.js');
-      await integrateChildren(session, thenElement);
-    }
-  } else {
-    if (elseElement) {
-      const { integrateChildren } = await import('../runtime/interpreter.js');
-      await integrateChildren(session, elseElement);
-    }
-  }
-}
-
-/**
- * Evaluate a predicate element to determine if it's true or false
- * Maps to mask_predicate_integrate in MASK
- */
-async function evaluatePredicate(session: DiracSession, predicateElement: DiracElement | null): Promise<boolean> {
-  if (!predicateElement) {
-    return false;
-  }
-  
-  // If it's a <cond> tag, process it with condition evaluation
-  if (predicateElement.tag.toLowerCase() === 'cond') {
-    return await evaluateCondition(session, predicateElement);
-  }
-  
-  // Otherwise, execute the element and evaluate its output
-  const outputLengthBefore = session.output.length;
-  const { integrate } = await import('../runtime/interpreter.js');
-  await integrate(session, predicateElement);
-  
-  // Get the new output chunks added during evaluation
-  const newOutputChunks = session.output.slice(outputLengthBefore);
-  const result = newOutputChunks.join('').trim();
-  
-  // Restore output to state before evaluation (remove intermediate output)
-  session.output.length = outputLengthBefore;
-  
-  // Evaluate the result as a boolean
-  if (result === '') {
-    return false;
-  }
-  if (result === '0' || result === 'false') {
-    return false;
-  }
-  if (result === '1' || result === 'true') {
-    return true;
-  }
-  // Non-empty string is truthy
-  return result.length > 0;
-}
-
-/**
- * Evaluate a <cond> element with eval attribute and arguments
- * Maps to mask_condition_integrate in MASK
- */
-async function evaluateCondition(session: DiracSession, condElement: DiracElement): Promise<boolean> {
-  const evalType = condElement.attributes?.eval;
-  
-  if (!evalType) {
-    // No eval attribute, just evaluate children as predicate
-    return await evaluatePredicate(session, condElement);
-  }
-  
-  // Capture the current output level before evaluating args
-  const outputLengthBefore = session.output.length;
-  
-  // Get arguments from children
-  const args: string[] = [];
-  const { integrate } = await import('../runtime/interpreter.js');
-  
-  for (const child of condElement.children) {
-    if (child.tag.toLowerCase() === 'arg') {
-      const argOutputStart = session.output.length;
-      const { integrateChildren } = await import('../runtime/interpreter.js');
-      await integrateChildren(session, child);
-      const newChunks = session.output.slice(argOutputStart);
-      const argValue = newChunks.join('');
-      args.push(argValue);
-    }
-  }
-  
-  // Restore output to state before evaluation (remove arg outputs)
-  session.output.length = outputLengthBefore;
-  
-  // Evaluate based on eval type
-  return evaluateConditionType(evalType, args);
-}
-
-/**
- * Evaluate condition based on type and arguments
- */
-function evaluateConditionType(evalType: string, args: string[]): boolean {
-  const type = evalType.toLowerCase();
-  
-  switch (type) {
-    case 'eq':
-    case 'equal':
-    case 'same':
-      return args.length >= 2 && args[0] === args[1];
-    
-    case 'ne':
-    case 'notequal':
-    case 'different':
-      return args.length >= 2 && args[0] !== args[1];
-    
-    case 'lt':
-    case 'less':
-      if (args.length >= 2) {
-        const a = parseFloat(args[0]);
-        const b = parseFloat(args[1]);
-        return !isNaN(a) && !isNaN(b) && a < b;
-      }
-      return false;
-    
-    case 'le':
-    case 'lessequal':
-      if (args.length >= 2) {
-        const a = parseFloat(args[0]);
-        const b = parseFloat(args[1]);
-        return !isNaN(a) && !isNaN(b) && a <= b;
-      }
-      return false;
-    
-    case 'gt':
-    case 'greater':
-      if (args.length >= 2) {
-        const a = parseFloat(args[0]);
-        const b = parseFloat(args[1]);
-        return !isNaN(a) && !isNaN(b) && a > b;
-      }
-      return false;
-    
-    case 'ge':
-    case 'greaterequal':
-      if (args.length >= 2) {
-        const a = parseFloat(args[0]);
-        const b = parseFloat(args[1]);
-        return !isNaN(a) && !isNaN(b) && a >= b;
-      }
-      return false;
-    
-    default:
-      // Unknown eval type, return false
-      return false;
-  }
-}

package/src/tags/import.ts

@@ -1,135 +0,0 @@
-/**
- * <import> tag - Import subroutines from other Dirac files
- * Similar to Node.js require/import
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { readFileSync, existsSync } from 'fs';
-import { resolve, dirname, join } from 'path';
-import { DiracParser } from '../runtime/parser.js';
-import { integrate } from '../runtime/interpreter.js';
-
-/**
- * Resolve import path - supports relative paths and node_modules packages
- * @param src - The import source (e.g., "./file.di" or "package-name")
- * @param currentDir - Current directory context
- * @returns Resolved absolute path
- */
-function resolveImportPath(src: string, currentDir: string): string {
-  // If it starts with ./ or ../ or /, it's a relative/absolute path
-  if (src.startsWith('./') || src.startsWith('../') || src.startsWith('/')) {
-    const resolved = resolve(currentDir, src);
-    // Add .di extension if not present
-    return resolved.endsWith('.di') ? resolved : resolved + '.di';
-  }
-  
-  // Otherwise, try to resolve as a package from node_modules
-  // Walk up the directory tree looking for node_modules
-  let searchDir = currentDir;
-  
-  while (true) {
-    const nodeModulesPath = join(searchDir, 'node_modules', src);
-    
-    if (existsSync(nodeModulesPath)) {
-      // Found the package, now find the entry point
-      // Try to read package.json to get the "main" field
-      const packageJsonPath = join(nodeModulesPath, 'package.json');
-      
-      if (existsSync(packageJsonPath)) {
-        try {
-          const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
-          const mainFile = packageJson.main || 'lib/index.di';
-          const entryPath = join(nodeModulesPath, mainFile);
-          
-          if (existsSync(entryPath)) {
-            return entryPath;
-          }
-        } catch (err) {
-          // If package.json parse fails, fall through to default
-        }
-      }
-      
-      // Fallback: try common entry points
-      const fallbacks = [
-        join(nodeModulesPath, 'lib', 'index.di'),
-        join(nodeModulesPath, 'index.di'),
-      ];
-      
-      for (const fallback of fallbacks) {
-        if (existsSync(fallback)) {
-          return fallback;
-        }
-      }
-      
-      throw new Error(`Package "${src}" found but no entry point (.di file) available`);
-    }
-    
-    // Move up one directory
-    const parentDir = dirname(searchDir);
-    if (parentDir === searchDir) {
-      // Reached root, package not found
-      break;
-    }
-    searchDir = parentDir;
-  }
-  
-  // Package not found in node_modules, treat as relative path with .di extension
-  const resolved = resolve(currentDir, src);
-  return resolved.endsWith('.di') ? resolved : resolved + '.di';
-}
-
-export async function executeImport(session: DiracSession, element: DiracElement): Promise<void> {
-  const src = element.attributes.src;
-  
-  if (!src) {
-    throw new Error('<import> requires src attribute');
-  }
-  
-  // Get the current file's directory (if available in session)
-  const currentDir = session.currentFile ? dirname(session.currentFile) : process.cwd();
-  
-  // Resolve the import path (handles both relative paths and node_modules packages)
-  const importPath = resolveImportPath(src, currentDir);
-  
-  if (session.debug) {
-    console.error(`[IMPORT] Loading: ${importPath}`);
-  }
-  
-  // Check if already imported (prevent circular imports)
-  if (!session.importedFiles) {
-    session.importedFiles = new Set();
-  }
-  
-  if (session.importedFiles.has(importPath)) {
-    if (session.debug) {
-      console.error(`[IMPORT] Already imported: ${importPath}`);
-    }
-    return;
-  }
-  
-  session.importedFiles.add(importPath);
-  
-  try {
-    // Read and parse the imported file
-    const source = readFileSync(importPath, 'utf-8');
-    const parser = new DiracParser();
-    const ast = parser.parse(source);
-    
-    // Save current file context and set new one
-    const previousFile = session.currentFile;
-    session.currentFile = importPath;
-    
-    // Execute the imported file (this will register its subroutines)
-    await integrate(session, ast);
-    
-    // Restore previous file context
-    session.currentFile = previousFile;
-    
-    if (session.debug) {
-      console.error(`[IMPORT] Loaded: ${importPath}`);
-    }
-    
-  } catch (error) {
-    throw new Error(`Import error: ${error instanceof Error ? error.message : String(error)}`);
-  }
-}