dirac-lang 0.1.24 → 0.1.26

package/src/tags/mongodb.ts

@@ -1,70 +0,0 @@
-import { TagHandler, TagHandlerContext } from '../types';
-
-console.log('[mongodb tag] mongodb.ts loaded');
-import { MongoClient, Db, Collection } from 'mongodb';
-
-// Utility to expand variables/child tags as Dirac does
-async function expandContent(ctx: TagHandlerContext): Promise<any> {
-  if (ctx.body) {
-    // If body is present, expand it (could be JSON, array, or object)
-    const expanded = await ctx.evaluate(ctx.body);
-    try {
-      return JSON.parse(expanded);
-    } catch {
-      return expanded;
-    }
-  }
-  return undefined;
-}
-
-export const mongodb: TagHandler = async (ctx: TagHandlerContext) => {
-  const uri = process.env.MONGODB_URI || 'mongodb://localhost:27017';
-  const database = ctx.getAttr('database');
-  const collection = ctx.getAttr('collection');
-  const action = ctx.getAttr('action');
-  const client = new MongoClient(uri);
-  let result;
-  console.log('[mongodb tag] Connecting to:', uri);
-  console.log('[mongodb tag] Database:', database, 'Collection:', collection, 'Action:', action);
-  try {
-    await client.connect();
-    let db: Db | undefined = database ? client.db(database) : undefined;
-    let col: Collection | undefined = db && collection ? db.collection(collection) : undefined;
-    const content = await expandContent(ctx);
-    console.log('[mongodb tag] Query content:', content);
-    switch (action) {
-      case 'find':
-        if (!col) throw new Error('Collection required for find');
-        result = await col.find(content || {}).toArray();
-        console.log('[mongodb tag] Find result:', result);
-        break;
-      case 'aggregate':
-        if (!col) throw new Error('Collection required for aggregate');
-        result = await col.aggregate(content).toArray();
-        console.log('[mongodb tag] Aggregate result:', result);
-        break;
-      case 'insert':
-        if (!col) throw new Error('Collection required for insert');
-        result = await col.insertOne(content);
-        console.log('[mongodb tag] Insert result:', result);
-        break;
-      case 'createDb':
-        if (!db) throw new Error('Database required for createDb');
-        result = { db: database, created: true };
-        console.log('[mongodb tag] CreateDb result:', result);
-        break;
-      case 'createCollection':
-        if (!db || !collection) throw new Error('Database and collection required');
-        result = await db.createCollection(collection);
-        console.log('[mongodb tag] CreateCollection result:', result);
-        break;
-      default:
-        throw new Error('Unknown action for <mongodb>');
-    }
-  } finally {
-    await client.close();
-  }
-  return result;
-};
-
-export default mongodb;

package/src/tags/output.ts

@@ -1,53 +0,0 @@
-/**
- * <output> tag - emit content
- * Maps to mask_tag_output in MASK
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { emit, substituteVariables, substituteAttribute } from '../runtime/session.js';
-import { integrateChildren } from '../runtime/interpreter.js';
-import * as fs from 'fs';
-import * as path from 'path';
-
-export async function executeOutput(session: DiracSession, element: DiracElement): Promise<void> {
-  const fileAttr = element.attributes?.file;
-  const filePath = fileAttr ? substituteAttribute(session, fileAttr) : null;
-  
-  // If writing to a file, collect content first
-  if (filePath) {
-    let content = '';
-    
-    if (element.children && element.children.length > 0) {
-      // Capture output from children
-      const prevOutput = session.output;
-      session.output = [];
-      await integrateChildren(session, element);
-      content = session.output.join('');
-      session.output = prevOutput;
-    } else if (element.text) {
-      content = substituteVariables(session, element.text);
-    }
-    
-    // Ensure directory exists
-    const dir = path.dirname(filePath);
-    if (dir !== '.' && !fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
-    }
-    
-    // Append to file
-    fs.appendFileSync(filePath, content + '\n', 'utf8');
-    return;
-  }
-  
-  // Normal output to stdout
-  if (element.children && element.children.length > 0) {
-    await integrateChildren(session, element);
-    return;
-  }
-  
-  if (element.text) {
-    const content = substituteVariables(session, element.text);
-    emit(session, content);
-    return;
-  }
-}

package/src/tags/parameters.ts

@@ -1,81 +0,0 @@
-/**
- * <parameters> tag - Access parameters passed to subroutine
- * Maps to MASK parameter selection syntax
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { getCurrentParameters, emit, setVariable } from '../runtime/session.js';
-import { integrate } from '../runtime/interpreter.js';
-
-export async function executeParameters(session: DiracSession, element: DiracElement): Promise<string | void> {
-  const select = element.attributes.select;
-  
-  if (!select) {
-    throw new Error('<parameters> requires select attribute');
-  }
-  
-  // Get parameters from current call context
-  const params = getCurrentParameters(session);
-  
-  if (!params || params.length === 0) {
-    if (session.debug) {
-      console.error(`[PARAMETERS] No parameters available`);
-    }
-    return;
-  }
-  
-  // The caller element is params[0] (the calling tag itself)
-  const caller = params[0];
-  
-  if (select === '*') {
-    // Select all child elements - execute them and RETURN output
-    if (session.debug) {
-      console.error(`[PARAMETERS] Selecting all children (${caller.children.length} elements)`);
-    }
-    // Save current output buffer
-    const prevOutput = session.output;
-    session.output = [];
-    for (const child of caller.children) {
-      await integrate(session, child);
-    }
-    const captured = session.output.join('');
-    session.output = prevOutput;
-    return captured;
-  } else if (select.startsWith('@')) {
-    // Select attribute(s)
-    const attrName = select.slice(1); // Remove '@'
-    
-    if (attrName === '*') {
-      // Select all attributes
-      if (session.debug) {
-        console.error(`[PARAMETERS] Selecting all attributes`);
-      }
-      
-      const attrs = Object.entries(caller.attributes)
-        .map(([key, val]) => `${key}="${val}"`)
-        .join(' ');
-      emit(session, attrs);
-      
-    } else {
-      // Select specific attribute - automatically create variable with that name
-      const value = caller.attributes[attrName];
-      
-      if (session.debug) {
-        console.error(`[PARAMETERS] Setting variable '${attrName}' = '${value}'`);
-      }
-      if (value !== undefined) {
-        // Only set variable if not already set in current boundary
-        const alreadySet = session.variables.slice(session.varBoundary).some(v => v.name === attrName);
-        if (!alreadySet) {
-          setVariable(session, attrName, value, false);
-        }
-      }
-      for (const child of element.children) {
-        await integrate(session, child);
-      }
-    }
-    
-  } else {
-    throw new Error(`<parameters> invalid select: ${select}`);
-  }
-}

package/src/tags/require_module.ts

@@ -1,19 +0,0 @@
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { setVariable } from '../runtime/session.js';
-
-/**
- * <require_module name="mongodb" var="mongo" />
- * Loads a Node.js module and stores it in a session variable.
- */
-export async function executeRequireModule(session: DiracSession, element: DiracElement): Promise<void> {
-  const name = element.attributes.name;
-  const varName = element.attributes.var || name;
-  if (!name) throw new Error('<require_module> missing name attribute');
-  try {
-    // Dynamically import the module (ESM compatible)
-    const mod = await import(name);
-    setVariable(session, varName, mod, true); // visible: true
-  } catch (err) {
-    throw new Error(`<require_module> failed to load module '${name}': ${err}`);
-  }
-}

package/src/tags/subroutine.ts

@@ -1,75 +0,0 @@
-/**
- * <subroutine> tag - define reusable code block
- * Maps to mask_tag_subroutine in MASK
- */
-
-import type { DiracSession, DiracElement, ParameterMetadata } from '../types/index.js';
-import { registerSubroutine } from '../runtime/session.js';
-
-export function executeSubroutine(session: DiracSession, element: DiracElement): void {
-  // Skip registration if we're in extend mode (nested subroutines already registered)
-  if (session.skipSubroutineRegistration) {
-    return;
-  }
-  
-  const name = element.attributes.name;
-  
-  if (!name) {
-    throw new Error('<subroutine> requires name attribute');
-  }
-  
-  // Extract metadata from attributes (no structural changes!)
-  const description = element.attributes.description;
-  const parameters: ParameterMetadata[] = [];
-  const meta: Record<string, any> = {};
-
-  // Parse param- prefixed attributes for metadata
-  function parseMetaField(metaString: string) {
-    const parts = metaString.split(':');
-    return {
-      type: parts[0] || 'string',
-      required: parts[1] === 'required',
-      description: parts[2] || undefined,
-      example: parts[3] || undefined
-    };
-  }
-  for (const [attrName, attrValue] of Object.entries(element.attributes)) {
-    if (attrName.startsWith('param-')) {
-      const paramName = attrName.substring(6);
-      const parts = attrValue.split(':');
-      const paramMeta: ParameterMetadata = {
-        name: paramName,
-        type: parts[0] || 'string',
-        required: parts[1] === 'required',
-        description: parts[2] || undefined,
-      };
-      if (parts.length > 3 && parts[3]) {
-        paramMeta.enum = parts[3].split('|');
-      }
-      if (parts.length > 4 && parts[4]) {
-        paramMeta.example = parts[4];
-      }
-      parameters.push(paramMeta);
-    } else if (attrName.startsWith('meta-')) {
-      const metaName = attrName.substring(5);
-      meta[metaName] = parseMetaField(attrValue);
-    }
-  }
-  
-  // Store subroutine exactly as before (preserves nesting and extends)
-  const subroutine: DiracElement = {
-    tag: 'subroutine',
-    attributes: { ...element.attributes },
-    children: element.children,
-  };
-  
-  // Pass meta as a field in the subroutine registry, not on the element
-  registerSubroutine(
-    session,
-    name,
-    subroutine,
-    description,
-    parameters.length > 0 ? parameters : undefined,
-    Object.keys(meta).length > 0 ? meta : undefined
-  );
-}

package/src/tags/system.ts

@@ -1,93 +0,0 @@
-/**
- * <system> tag - Execute shell commands
- * Spawns a Unix process and runs the command
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { substituteVariables, emit } from '../runtime/session.js';
-import { exec, spawn } from 'child_process';
-import { promisify } from 'util';
-import { integrate } from '../runtime/interpreter.js';
-
-const execAsync = promisify(exec);
-
-export async function executeSystem(session: DiracSession, element: DiracElement): Promise<void> {
-  // Build command from text content or children
-  let command: string;
-  
-  // Check if has non-text children (actual element children)
-  const hasElementChildren = element.children.some(child => child.tag !== '');
-  
-  if (hasElementChildren) {
-    // Execute children to build command dynamically
-    const beforeOutput = session.output.length;
-    
-    for (const child of element.children) {
-      await integrate(session, child);
-    }
-    
-    // Collect output from children as the command
-    const childOutput = session.output.slice(beforeOutput);
-    command = childOutput.join('');
-    
-    // Remove child output from main output
-    session.output = session.output.slice(0, beforeOutput);
-  } else if (element.text) {
-    // Simple text command with variable substitution
-    command = substituteVariables(session, element.text);
-  } else {
-    throw new Error('<system> requires command content');
-  }
-  
-  if (!command.trim()) {
-    return;
-  }
-  
-  // Check for background attribute
-  const backgroundAttr = element.attributes?.background;
-  const isBackground = backgroundAttr === 'true';
-  
-  if (session.debug) {
-    console.error(`[SYSTEM] Executing${isBackground ? ' (background)' : ''}: ${command}`);
-  }
-  
-  // Background mode - spawn and don't wait
-  if (isBackground) {
-    const child = spawn(command, {
-      detached: true,
-      stdio: 'ignore',
-      shell: true,
-    });
-    
-    // Unref so parent can exit without waiting
-    child.unref();
-    
-    if (session.debug) {
-      console.error(`[SYSTEM] Background process started with PID: ${child.pid}`);
-    }
-    
-    return;
-  }
-  
-  // Foreground mode - wait for completion (original behavior)
-  try {
-    const { stdout, stderr } = await execAsync(command, {
-      encoding: 'utf-8',
-      maxBuffer: 10 * 1024 * 1024, // 10MB buffer
-    });
-    
-    // Emit stdout
-    if (stdout) {
-      emit(session, stdout);
-    }
-    
-    // Emit stderr if debug mode
-    if (stderr && session.debug) {
-      console.error(`[SYSTEM STDERR] ${stderr}`);
-    }
-    
-  } catch (error: any) {
-    const errorMsg = error.message || String(error);
-    throw new Error(`System command failed: ${errorMsg}`);
-  }
-}

package/src/tags/tag-check.ts

@@ -1,176 +0,0 @@
-/**
- * <tag-check> tag - validates child tags against allowed subroutines
- * If a tag is not found, uses embedding similarity to suggest the closest match.
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { emit } from '../runtime/session.js';
-// Use global fetch (Node.js 18+)
-import fs from 'fs';
-import yaml from 'js-yaml';
-
-// Configurable similarity cutoff
-const SIMILARITY_CUTOFF = 0.75;
-
-
-// Helper: get embedding server config from config.yml
-function getEmbeddingServerConfig() {
-  try {
-    const configPath = process.env.DIRAC_CONFIG || 'config.yml';
-    const config = yaml.load(fs.readFileSync(configPath, 'utf8')) as any;
-    const host = config.embeddingServer?.host || 'localhost';
-    const port = config.embeddingServer?.port || 11434;
-    const model = config.embeddingServer?.model || 'embeddinggemma';
-    return { host, port, model };
-  } catch (e) {
-    // Fallback to defaults if config file not found
-    return { host: 'localhost', port: 11434, model: 'embeddinggemma' };
-  }
-}
-
-// Helper: call Ollama embedding API directly
-async function getEmbeddings(tags: string[]): Promise<number[][]> {
-  const { host, port, model } = getEmbeddingServerConfig();
-  return await Promise.all(tags.map(async tag => {
-    const response = await fetch(`http://${host}:${port}/api/embeddings`, {
-      method: 'POST',
-      headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ model, prompt: tag })
-    });
-    const data = await response.json();
-    return data.embedding;
-  }));
-}
-
-function cosine(a: number[], b: number[]): number {
-  const dot = a.reduce((sum, v, i) => sum + v * b[i], 0);
-  const normA = Math.sqrt(a.reduce((sum, v) => sum + v * v, 0));
-  const normB = Math.sqrt(b.reduce((sum, v) => sum + v * v, 0));
-  return dot / (normA * normB);
-}
-
-async function getBestTagMatch(candidate: string, allowed: string[]): Promise<{tag: string, score: number}> {
-  const tags = [candidate, ...allowed];
-  const embeddings = await getEmbeddings(tags);
-  const candidateVec = embeddings[0];
-  const allowedVecs = embeddings.slice(1);
-  let bestIdx = 0, bestScore = -1;
-  allowedVecs.forEach((vec, i) => {
-    const score = cosine(candidateVec, vec);
-    if (score > bestScore) { bestScore = score; bestIdx = i; }
-  });
-  return { tag: allowed[bestIdx], score: bestScore };
-}
-
-export async function executeTagCheck(session: DiracSession, element: DiracElement): Promise<void> {
-  // Get allowed subroutine names
-  const { getAvailableSubroutines } = await import('../runtime/session.js');
-  const subroutines = getAvailableSubroutines(session);
-  const allowed = new Set(subroutines.map(s => s.name));
-  console.error('[tag-check] Allowed subroutines:', Array.from(allowed));
-
-  const autocorrect = element.attributes?.autocorrect === "true";
-  const shouldExecute = element.attributes?.execute === "true";
-
-  for (const child of element.children) {
-    const tagName = child.tag;
-    
-    // Skip text nodes (empty tag names) and whitespace
-    if (!tagName || tagName.trim() === '') {
-      continue;
-    }
-    
-    console.error(`[tag-check] Checking tag: <${tagName}>`);
-    let allValid = false;
-    let correctedTag: string | null = null;
-
-    if (allowed.has(tagName)) {
-      // Tag name is valid, now check required and unknown parameters
-      const sub = subroutines.find(s => s.name === tagName);
-      let missing: string[] = [];
-      let unknown: string[] = [];
-      let paramNames: string[] = [];
-      if (sub && Array.isArray(sub.parameters)) {
-        paramNames = sub.parameters.map(p => p.name);
-        for (const param of sub.parameters) {
-          if (param.required && !(param.name in child.attributes)) {
-            missing.push(param.name);
-          }
-        }
-        for (const attr in child.attributes) {
-          if (!paramNames.includes(attr)) {
-            unknown.push(attr);
-          }
-        }
-      }
-      if (missing.length > 0) {
-        emit(session, `<${tagName}/> is missing required parameter(s): ${missing.join(', ')}`);
-        console.error(`[tag-check] <${tagName}/> missing required: ${missing.join(', ')}`);
-      }
-      if (unknown.length > 0) {
-        emit(session, `<${tagName}/> has unknown attribute(s): ${unknown.join(', ')}`);
-        console.error(`[tag-check] <${tagName}/> unknown attributes: ${unknown.join(', ')}`);
-      }
-      if (missing.length === 0 && unknown.length === 0) {
-        emit(session, `<${tagName}/> is valid.`);
-        console.error(`[tag-check] <${tagName}/> is valid.`);
-        allValid = true;
-      }
-    } else {
-      // Find best semantic match
-      console.error(`[tag-check] <${tagName}/> not found, searching for best match...`);
-      const best = await getBestTagMatch(tagName, Array.from(allowed));
-      console.error(`[tag-check] Best match: <${best.tag}> (score: ${best.score})`);
-      if (best.score >= SIMILARITY_CUTOFF) {
-        if (autocorrect) {
-          emit(session, `The tag <${tagName}> was auto-corrected to <${best.tag}> (similarity: ${best.score.toFixed(2)})`);
-          console.error(`[tag-check] Auto-correcting <${tagName}/> to <${best.tag}>`);
-          correctedTag = best.tag;
-          // Validate parameters for corrected tag
-          const sub = subroutines.find(s => s.name === correctedTag);
-          let missing: string[] = [];
-          let unknown: string[] = [];
-          let paramNames: string[] = [];
-          if (sub && Array.isArray(sub.parameters)) {
-            paramNames = sub.parameters.map(p => p.name);
-            for (const param of sub.parameters) {
-              if (param.required && !(param.name in child.attributes)) {
-                missing.push(param.name);
-              }
-            }
-            for (const attr in child.attributes) {
-              if (!paramNames.includes(attr)) {
-                unknown.push(attr);
-              }
-            }
-          }
-          if (missing.length > 0) {
-            emit(session, `<${correctedTag}/> is missing required parameter(s): ${missing.join(', ')}`);
-            console.error(`[tag-check] <${correctedTag}/> missing required: ${missing.join(', ')}`);
-          }
-          if (unknown.length > 0) {
-            emit(session, `<${correctedTag}/> has unknown attribute(s): ${unknown.join(', ')}`);
-            console.error(`[tag-check] <${correctedTag}/> unknown attributes: ${unknown.join(', ')}`);
-          }
-          if (missing.length === 0 && unknown.length === 0) {
-            allValid = true;
-          }
-        } else {
-          emit(session, `The tag <${tagName}> does not exist. Did you mean <${best.tag}>? (similarity: ${best.score.toFixed(2)})`);
-        }
-      } else {
-        emit(session, `The tag <${tagName}> does not exist and no similar tag was found.`);
-      }
-    }
-    // If all checks pass and execute="true" is present, execute the child tag
-    if (allValid && shouldExecute) {
-      const executeTag = correctedTag || tagName;
-      console.error(`[tag-check] Executing <${executeTag}/> as all checks passed and execute=true.`);
-      // Create a corrected element if tag was auto-corrected
-      const elementToExecute = correctedTag ? { ...child, tag: correctedTag } : child;
-      // Dynamically import interpreter and execute the child tag
-      const { integrate } = await import('../runtime/interpreter.js');
-      await integrate(session, elementToExecute);
-    }
-  }
-}

package/src/tags/test-if.ts

@@ -1,112 +0,0 @@
-/**
- * <test-if> tag - conditional execution with test attribute
- * This is the attribute-based conditional (original Dirac style)
- * 
- * Usage: <test-if test="$var == value">...</test-if>
- */
-
-import type { DiracSession, DiracElement } from '../types/index.js';
-import { substituteAttribute } from '../runtime/session.js';
-import { integrateChildren } from '../runtime/interpreter.js';
-
-export async function executeTestIf(session: DiracSession, element: DiracElement): Promise<void> {
-  const test = element.attributes.test;
-  
-  if (!test) {
-    throw new Error('<test-if> requires test attribute');
-  }
-  
-  // Get variable value
-  const value = substituteAttribute(session, test);
-  
-  // Check comparison attributes
-  const eq = element.attributes.eq;
-  const ne = element.attributes.ne;
-  const lt = element.attributes.lt;
-  const gt = element.attributes.gt;
-  const le = element.attributes.le;
-  const ge = element.attributes.ge;
-  
-  let condition = false;
-  
-  if (eq !== undefined) {
-    const compareValue = substituteAttribute(session, eq);
-    condition = value === compareValue;
-  } else if (ne !== undefined) {
-    const compareValue = substituteAttribute(session, ne);
-    condition = value !== compareValue;
-  } else if (lt !== undefined) {
-    const compareValue = substituteAttribute(session, lt);
-    const valueNum = parseFloat(value);
-    const compareNum = parseFloat(compareValue);
-    condition = !isNaN(valueNum) && !isNaN(compareNum) && valueNum < compareNum;
-  } else if (gt !== undefined) {
-    const compareValue = substituteAttribute(session, gt);
-    const valueNum = parseFloat(value);
-    const compareNum = parseFloat(compareValue);
-    condition = !isNaN(valueNum) && !isNaN(compareNum) && valueNum > compareNum;
-  } else if (le !== undefined) {
-    const compareValue = substituteAttribute(session, le);
-    const valueNum = parseFloat(value);
-    const compareNum = parseFloat(compareValue);
-    condition = !isNaN(valueNum) && !isNaN(compareNum) && valueNum <= compareNum;
-  } else if (ge !== undefined) {
-    const compareValue = substituteAttribute(session, ge);
-    const valueNum = parseFloat(value);
-    const compareNum = parseFloat(compareValue);
-    condition = !isNaN(valueNum) && !isNaN(compareNum) && valueNum >= compareNum;
-  } else {
-    // No comparison attribute, evaluate test value as boolean
-    condition = evaluateCondition(session, test);
-  }
-  
-  if (condition) {
-    await integrateChildren(session, element);
-  }
-}
-
-function evaluateCondition(session: DiracSession, test: string): boolean {
-  // Substitute variables first
-  // Use attribute-style substitution for test condition
-  const substituted = substituteAttribute(session, test);
-  
-  // Simple condition evaluation
-  // Supports: ==, !=, <, >, <=, >=
-  
-  const operators = ['==', '!=', '<=', '>=', '<', '>'];
-  
-  for (const op of operators) {
-    const parts = substituted.split(op);
-    if (parts.length === 2) {
-      let left = parts[0].trim();
-      let right = parts[1].trim();
-      const leftNum = parseFloat(left);
-      const rightNum = parseFloat(right);
-      const bothNumbers = !isNaN(leftNum) && !isNaN(rightNum);
-      
-      switch (op) {
-        case '==':
-          return bothNumbers ? leftNum === rightNum : left === right;
-        case '!=':
-          return bothNumbers ? leftNum !== rightNum : left !== right;
-        case '<':
-          return leftNum < rightNum;
-        case '>':
-          return leftNum > rightNum;
-        case '<=':
-          return leftNum <= rightNum;
-        case '>=':
-          return leftNum >= rightNum;
-      }
-    }
-  }
-  
-  // If no operator found, treat as boolean
-  // Empty, "0", or "false" is false
-  // Everything else is true
-  if (substituted === '' || substituted === '0' || substituted === 'false') {
-    return false;
-  }
-  
-  return true;
-}