dirac-lang 0.1.2

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));
+  }
+}

package/src/tags/if.ts

@@ -0,0 +1,58 @@
+/**
+ * <if> tag - conditional execution
+ * Maps to mask_tag_if in MASK
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { substituteVariables, getVariable } from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+
+export async function executeIf(session: DiracSession, element: DiracElement): Promise<void> {
+  const test = element.attributes.test;
+  
+  if (!test) {
+    throw new Error('<if> requires test attribute');
+  }
+  
+  const condition = evaluateCondition(session, test);
+  
+  if (condition) {
+    await integrateChildren(session, element);
+  }
+}
+
+function evaluateCondition(session: DiracSession, test: string): boolean {
+  // Substitute variables first
+  const substituted = substituteVariables(session, test);
+  
+  // Simple condition evaluation (can be enhanced later)
+  // Supports: ==, !=, <, >, <=, >=
+  
+  const operators = ['==', '!=', '<=', '>=', '<', '>'];
+  
+  for (const op of operators) {
+    const parts = substituted.split(op);
+    if (parts.length === 2) {
+      const left = parts[0].trim();
+      const right = parts[1].trim();
+      
+      switch (op) {
+        case '==':
+          return left === right;
+        case '!=':
+          return left !== right;
+        case '<':
+          return parseFloat(left) < parseFloat(right);
+        case '>':
+          return parseFloat(left) > parseFloat(right);
+        case '<=':
+          return parseFloat(left) <= parseFloat(right);
+        case '>=':
+          return parseFloat(left) >= parseFloat(right);
+      }
+    }
+  }
+  
+  // If no operator, treat as boolean (non-empty = true)
+  return substituted.trim() !== '' && substituted.trim() !== '0' && substituted.trim() !== 'false';
+}

package/src/tags/import.ts

@@ -0,0 +1,66 @@
+/**
+ * <import> tag - Import subroutines from other Dirac files
+ * Similar to Node.js require/import
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { readFileSync } from 'fs';
+import { resolve, dirname } from 'path';
+import { DiracParser } from '../runtime/parser.js';
+import { integrate } from '../runtime/interpreter.js';
+
+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
+  const importPath = resolve(currentDir, src);
+  
+  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)}`);
+  }
+}

package/src/tags/index.ts

@@ -0,0 +1,37 @@
+import * as system from './system';
+import * as execute from './execute';
+import * as llm from './llm';
+import * as variable from './variable';
+import * as subroutine from './subroutine';
+import * as assign from './assign';
+import * as parameters from './parameters';
+import * as loop from './loop';
+import * as evalTag from './eval';
+import * as call from './call';
+import * as defvar from './defvar';
+import * as output from './output';
+import * as expr from './expr';
+import * as ifTag from './if';
+import * as importTag from './import';
+import * as mongodb from './mongodb';
+import * as requireModule from './require_module';
+
+export default {
+  ...system,
+  ...execute,
+  ...llm,
+  ...variable,
+  ...subroutine,
+  ...assign,
+  ...parameters,
+  ...loop,
+  ...evalTag,
+  ...call,
+  ...defvar,
+  ...output,
+  ...expr,
+  ...ifTag,
+  ...importTag,
+  ...mongodb,
+  ...requireModule,
+};

package/src/tags/llm.ts

@@ -0,0 +1,207 @@
+/**
+ * <LLM> tag - THE INNOVATION
+ * Execute LLM operation with recursive Dirac execution capability
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { setVariable, substituteVariables, emit, getVariable } from '../runtime/session.js';
+import { integrate } from '../runtime/interpreter.js';
+import { DiracParser } from '../runtime/parser.js';
+
+
+export async function executeLLM(session: DiracSession, element: DiracElement): Promise<void> {
+  if (!session.llmClient) {
+    throw new Error('<LLM> requires API key (set OPENAI_API_KEY, ANTHROPIC_API_KEY, or LLM_PROVIDER=ollama in .env file)');
+  }
+
+  // Check limits
+  if (session.limits.currentLLMCalls >= session.limits.maxLLMCalls) {
+    throw new Error('Maximum LLM calls exceeded');
+  }
+
+  session.limits.currentLLMCalls++;
+
+  // Detect provider from client type
+  const providerName = session.llmClient.constructor.name;
+  const isOpenAI = providerName === 'OpenAI';
+  const isOllama = providerName === 'OllamaProvider';
+  const defaultModel = isOpenAI
+    ? 'gpt-4.1-2025-04-14'
+    : isOllama
+      ? 'llama2'
+      : 'claude-sonnet-4-20250514';
+  console.log('LLM Provider:', providerName);
+
+  const model = element.attributes.model || process.env.DEFAULT_MODEL || defaultModel;
+  console.log('LLM Model:', model);
+  const outputVar = element.attributes.output;
+  const contextVar = element.attributes.context;
+  const executeMode = element.attributes.execute === 'true'; // NEW: seamless execution mode
+  const temperature = parseFloat(element.attributes.temperature || '1.0');
+  const maxTokens = parseInt(element.attributes.maxTokens || '4096', 10);
+  
+  // Build prompt from children or text
+  let userPrompt = '';
+  if (element.children.length > 0) {
+    // Execute children to build prompt
+    const beforeOutput = session.output.length;
+    for (const child of element.children) {
+      await integrate(session, child);
+    }
+    // Collect output from children
+    const childOutput = session.output.slice(beforeOutput);
+    userPrompt = childOutput.join('');
+    // Remove child output from main output
+    session.output = session.output.slice(0, beforeOutput);
+  } else if (element.text) {
+    userPrompt = substituteVariables(session, element.text);
+  } else {
+    throw new Error('<LLM> requires prompt content');
+  }
+
+  const noExtra = element.attributes.noextra === 'true';
+  let prompt: string;
+  if (noExtra) {
+    prompt = userPrompt;
+    if (session.debug || process.env.DIRAC_LOG_PROMPT === '1') {
+      console.error('[LLM] Full prompt sent to LLM (noextra):\n' + prompt + '\n');
+    }
+  } else {
+    // Reflect subroutines for system prompt
+    const { getAvailableSubroutines } = await import('../runtime/session.js');
+    const subroutines = getAvailableSubroutines(session);
+    if (session.debug) {
+      console.error('[LLM] Subroutines available at prompt composition:',
+        subroutines.map(s => ({ name: s.name, description: s.description, parameters: s.parameters })));
+    }
+    let systemPrompt = `Dirac is a XML based language, you define the subroutine like
+\`\`\`xml
+<subroutine name=background >
+ <parameters select="@color" />
+ <paint_the_color_somewhere />
+</subroutine>
+\`\`\`
+then you call it like
+\`\`\`xml
+<background color="blue" />
+\`\`\`
+`;
+    systemPrompt += 'Now, You are an expert Dirac XML code generator.\nAllowed Dirac XML tags (use ONLY these tags):';
+    for (const sub of subroutines) {
+      systemPrompt += `\n- <${sub.name} />: ${sub.description || ''}`;
+      if (sub.parameters && sub.parameters.length > 0) {
+        systemPrompt += ' Parameters: ' + sub.parameters.map(p => `${p.name} (${p.type || 'string'})`).join(', ');
+      }
+    }
+    systemPrompt += '\nDo NOT invent or use any tags not listed above. For example, do NOT use <changeBackground> or <set-background>. Only use the allowed tags.\nInstructions: Output only valid Dirac XML tags from the list above. Do not include explanations or extra text.';
+    systemPrompt += '\nAfter generating your answer, check the command/tag list again and ensure every tag you use is in the list above. If any tag is not in the list, do not output it—regenerate your answer using only allowed tags.';
+
+    prompt = systemPrompt + '\nUser: ' + userPrompt + '\nOutput:';
+    if (session.debug || process.env.DIRAC_LOG_PROMPT === '1') {
+      console.error('[LLM] Full prompt sent to LLM:\n' + prompt + '\n');
+    }
+    // Add context if specified
+    if (contextVar) {
+      const contextValue = getVariable(session, contextVar);
+      if (contextValue) {
+        prompt = `Context: ${contextValue}\n\n${prompt}`;
+      }
+    }
+  }
+  
+  if (session.debug) {
+    console.error(`[LLM] Calling ${model} with prompt length: ${prompt.length}`);
+  }
+  
+  try {
+    let result: string;
+    if (isOpenAI) {
+      // Call OpenAI API
+      const response = await session.llmClient.chat.completions.create({
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [
+          {
+            role: 'user',
+            content: prompt,
+          },
+        ],
+      });
+      result = response.choices[0]?.message?.content || '';
+    } else if (isOllama) {
+      // Call OllamaProvider
+      result = await session.llmClient.complete(prompt, {
+        model,
+        temperature,
+        max_tokens: maxTokens,
+      });
+    } else {
+      // Call Anthropic API
+      const response = await session.llmClient.messages.create({
+        model,
+        max_tokens: maxTokens,
+        temperature,
+        messages: [
+          {
+            role: 'user',
+            content: prompt,
+          },
+        ],
+      });
+      const content = response.content[0];
+      result = content.type === 'text' ? content.text : '';
+    }
+    
+    if (session.debug) {
+      console.error(`[LLM] Response length: ${result.length}`);
+    }
+    
+    // Store in variable if requested
+    if (outputVar) {
+      setVariable(session, outputVar, result, false);
+    } else if (executeMode) {
+      // NEW: Execute mode - parse and interpret LLM response as Dirac code
+      if (session.debug) {
+        console.error(`[LLM] Executing response as Dirac code:\n${result}\n`);
+      }
+
+      // Only replace triple backtick code blocks if replace-tick="true" is set
+      const replaceTick = element.attributes['replace-tick'] === 'true';
+      let diracCode = result.trim();
+      if (replaceTick && diracCode.startsWith('```')) {
+        // Check for bash, xml, html, dirac, or no language
+        const match = diracCode.match(/^```(\w+)?\n?/m);
+        if (match && match[1] === 'bash') {
+          // Find closing triple backticks
+          const endIdx = diracCode.indexOf('```', 3);
+          let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+          diracCode = `<system>${bashContent}</system>`;
+        } else {
+          // Remove opening and closing backticks for xml/html/dirac/none
+          diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, '').replace(/\n?```$/m, '').trim();
+        }
+      }
+      try {
+        // Parse and execute the LLM's output as Dirac code
+        const parser = new DiracParser();
+        const dynamicAST = parser.parse(diracCode);
+        await integrate(session, dynamicAST);
+      } catch (parseError) {
+        // If parsing fails, treat as plain text
+        if (session.debug) {
+          console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
+        }
+        emit(session, result);
+      }
+    } else {
+      // Otherwise emit to output as text
+      emit(session, result);
+    }
+    
+  } catch (error) {
+    throw new Error(`LLM error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+

package/src/tags/loop.ts

@@ -0,0 +1,43 @@
+/**
+ * <loop> tag - iteration
+ * Maps to mask_tag_loop in MASK
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { setVariable, substituteVariables, getVariable } from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+
+export async function executeLoop(session: DiracSession, element: DiracElement): Promise<void> {
+  const countAttr = element.attributes.count;
+  const varName = element.attributes.var || 'i';
+  
+  if (!countAttr) {
+    throw new Error('<loop> requires count attribute');
+  }
+  
+  const count = parseInt(substituteVariables(session, countAttr), 10);
+  
+  if (isNaN(count) || count < 0) {
+    throw new Error(`Invalid loop count: ${countAttr}`);
+  }
+  
+  const wasBreak = session.isBreak;
+  session.isBreak = false;
+  
+  for (let i = 0; i < count; i++) {
+    setVariable(session, varName, i, false);
+    
+    await integrateChildren(session, element);
+    
+    if (session.isBreak) {
+      session.isBreak = false;
+      break;
+    }
+    
+    if (session.isReturn) {
+      break;
+    }
+  }
+  
+  session.isBreak = wasBreak;
+}

package/src/tags/mongodb.ts

@@ -0,0 +1,70 @@
+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

@@ -0,0 +1,23 @@
+/**
+ * <output> tag - emit content
+ * Maps to mask_tag_output in MASK
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { emit, substituteVariables } from '../runtime/session.js';
+import { integrateChildren } from '../runtime/interpreter.js';
+
+export async function executeOutput(session: DiracSession, element: DiracElement): Promise<void> {
+  // If has children, process them (handles mixed content)
+  if (element.children && element.children.length > 0) {
+    await integrateChildren(session, element);
+    return;
+  }
+  
+  // If only text content, use it (with variable substitution)
+  if (element.text) {
+    const content = substituteVariables(session, element.text);
+    emit(session, content);
+    return;
+  }
+}