dirac-lang 0.1.14 → 0.1.16

package/dist/index.d.ts

@@ -79,6 +79,7 @@ interface DiracSession {
     isReturn: boolean;
     isBreak: boolean;
     skipSubroutineRegistration: boolean;
+    currentSubroutineName?: string;
     debug: boolean;
     currentFile?: string;
     importedFiles?: Set<string>;

package/dist/index.js

@@ -2,11 +2,13 @@ import {
   createLLMAdapter,
   execute,
   executeUserCommand
-} from "./chunk-SOHSXT3M.js";
+} from "./chunk-FEOBVBSI.js";
 import {
-  DiracParser,
   integrate
-} from "./chunk-VOD5GGHB.js";
+} from "./chunk-CP4YCRBG.js";
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
 import "./chunk-E7PWEMZA.js";
 import {
   createSession,

package/dist/{interpreter-FT22JGOO.js → interpreter-GNO4J3HN.js}

@@ -1,7 +1,8 @@
 import {
   integrate,
   integrateChildren
-} from "./chunk-VOD5GGHB.js";
+} from "./chunk-CP4YCRBG.js";
+import "./chunk-HRHAMPOB.js";
 import "./chunk-E7PWEMZA.js";
 import "./chunk-52ED23DR.js";
 export {

package/dist/parser-T6W3WPLU.js

@@ -0,0 +1,6 @@
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
+export {
+  DiracParser
+};

package/dist/{tag-validator-DYWFTEBE.js → tag-validator-CLYGULLQ.js}

@@ -4,21 +4,23 @@ import yaml from "js-yaml";
 var SIMILARITY_CUTOFF = 0.75;
 function getEmbeddingServerConfig() {
   try {
-    const config = yaml.load(fs.readFileSync("config.yml", "utf8"));
+    const configPath = process.env.DIRAC_CONFIG || "config.yml";
+    const config = yaml.load(fs.readFileSync(configPath, "utf8"));
     const host = config.embeddingServer?.host || "localhost";
-    const port = config.embeddingServer?.port || 11435;
-    return { host, port };
-  } catch {
-    return { host: "localhost", port: 11435 };
+    const port = config.embeddingServer?.port || 11434;
+    const model = config.embeddingServer?.model || "embeddinggemma";
+    return { host, port, model };
+  } catch (e) {
+    return { host: "localhost", port: 11434, model: "embeddinggemma" };
   }
 }
 async function getEmbeddings(tags) {
-  const { host, port } = getEmbeddingServerConfig();
+  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: "embeddinggemma", prompt: tag })
+      body: JSON.stringify({ model, prompt: tag })
     });
     const data = await response.json();
     return data.embedding;
@@ -111,7 +113,7 @@ async function validateDiracCode(session, ast, options = {}) {
   const results = [];
   const errorMessages = [];
   async function validateElement(element) {
-    if (element.tag && element.tag !== "dirac" && element.tag !== "") {
+    if (element.tag && element.tag !== "dirac" && element.tag.trim() !== "") {
       const result = await validateTag(session, element, options);
       results.push(result);
       if (!result.valid) {

package/dist/test-runner.js

@@ -1,7 +1,9 @@
 import {
-  DiracParser,
   integrate
-} from "./chunk-VOD5GGHB.js";
+} from "./chunk-CP4YCRBG.js";
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
 import "./chunk-E7PWEMZA.js";
 import {
   createSession,
@@ -17,9 +19,8 @@ var TestRunner = class {
   config;
   constructor(testDir = "tests", configPath) {
     this.testDir = testDir;
-    const defaultConfigPath = configPath || path.resolve(process.cwd(), "config.yml");
-    if (fs.existsSync(defaultConfigPath)) {
-      this.config = yaml.load(fs.readFileSync(defaultConfigPath, "utf8")) || {};
+    if (configPath && fs.existsSync(configPath)) {
+      this.config = yaml.load(fs.readFileSync(configPath, "utf8")) || {};
     } else {
       this.config = { llmProvider: "ollama", llmModel: "llama2" };
     }

package/examples/llm-command-more.di

@@ -0,0 +1,6 @@
+<dirac>
+  <subroutine name="background" description="set the background color." param-color="string:required:color name" >
+    this is my color: <variable name="color" /> 
+  </subroutine>
+  <llm execute="true">what is the color of red mix with yellow and set the background color to that color</llm>
+</dirac>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dirac-lang",
-  "version": "0.1.14",
+  "version": "0.1.16",
   "description": "LLM-Augmented Declarative Execution",
   "type": "module",
   "main": "dist/index.js",

package/src/runtime/interpreter.ts

@@ -27,6 +27,8 @@ 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';
 
 export async function integrate(session: DiracSession, element: DiracElement): Promise<void> {
   // Check execution limits
@@ -142,6 +144,14 @@ export async function integrate(session: DiracSession, element: DiracElement): P
       case 'available-subroutines':
         await executeAvailableSubroutines(session, element);
         break;
+        
+      case 'foreach':
+        await executeForeach(session, element);
+        break;
+        
+      case 'attr':
+        await executeAttr(session, element);
+        break;
 
       case 'require_module':
         await executeRequireModule(session, element);

package/src/tags/attr.ts

@@ -0,0 +1,64 @@
+/**
+ * <attr> tag - extract attribute value from XML item
+ * Usage: <attr name="description" from="$sub" />
+ * or: <attr name="param-format" from="$sub" />
+ */
+
+import type { DiracSession, DiracElement } from '../types/index.js';
+import { getVariable, substituteVariables } from '../runtime/session.js';
+
+export async function executeAttr(session: DiracSession, element: DiracElement): Promise<void> {
+  const nameAttr = element.attributes.name;
+  const fromAttr = element.attributes.from;
+  
+  if (!nameAttr) {
+    throw new Error('<attr> requires "name" attribute');
+  }
+  
+  if (!fromAttr) {
+    throw new Error('<attr> requires "from" attribute');
+  }
+  
+  // Get the XML item from variable
+  let item: any;
+  
+  if (fromAttr.startsWith('$')) {
+    const varName = fromAttr.substring(1);
+    item = getVariable(session, varName);
+  } else {
+    // Try substitution
+    const substituted = substituteVariables(session, fromAttr);
+    item = getVariable(session, substituted);
+  }
+  
+  if (!item) {
+    // No output if item not found
+    return;
+  }
+  
+  // Extract the attribute value
+  let value = '';
+  
+  if (typeof item === 'object') {
+    // If it's a structured XML item (from foreach)
+    if (item.attributes && typeof item.attributes === 'object') {
+      value = item.attributes[nameAttr] || '';
+    }
+    // If it's a direct object with the attribute
+    else if (item[nameAttr] !== undefined) {
+      value = String(item[nameAttr]);
+    }
+  } else if (typeof item === 'string') {
+    // If it's a string, try to parse as XML and extract
+    value = extractAttrFromXml(item, nameAttr);
+  }
+  
+  session.output.push(value);
+}
+
+function extractAttrFromXml(xml: string, attrName: string): string {
+  // Simple regex-based extraction for single-element XML
+  const regex = new RegExp(`${attrName}="([^"]*)"`, 'i');
+  const match = xml.match(regex);
+  return match ? match[1] : '';
+}

package/src/tags/available-subroutines.ts

@@ -12,20 +12,32 @@ export async function executeAvailableSubroutines(
   // Get all subroutines from current boundary to top of stack
   const availableSubroutines = new Map<string, DiracElement>();
   
+  // Get the name of the currently executing subroutine from the boundary
+  const currentSubroutineName = session.subBoundary < session.subroutines.length
+    ? session.subroutines[session.subBoundary].name
+    : null;
+  
   // Read from top of stack (most recent) backwards to boundary
   // This ensures we get the latest definition (handles extends override)
   for (let i = session.subroutines.length - 1; i >= session.subBoundary; i--) {
     const sub = session.subroutines[i];
     
+    // Skip the currently executing subroutine itself
+    if (sub.name === currentSubroutineName) {
+      continue;
+    }
+    
     // Only add if not already seen (first occurrence wins)
     if (!availableSubroutines.has(sub.name)) {
       availableSubroutines.set(sub.name, sub.element);
     }
   }
   
-  // Generate output for each subroutine
+  // Generate structured output with container
+  session.output.push('<subroutines>');
+  
   for (const [name, subElement] of availableSubroutines) {
-    const attrs: string[] = [];
+    const attrs: string[] = [`name="${escapeXml(name)}"`];
     
     // Add description if available
     const description = subElement.attributes.description;
@@ -36,15 +48,16 @@ export async function executeAvailableSubroutines(
     // Add all param-* attributes with their definitions
     for (const [attrName, attrValue] of Object.entries(subElement.attributes)) {
       if (attrName.startsWith('param-')) {
-        const paramName = attrName.substring(6);
-        attrs.push(`${paramName}="${escapeXml(attrValue)}"`);
+        attrs.push(`${attrName}="${escapeXml(attrValue)}"`);
       }
     }
     
     // Build the output tag
-    const attrString = attrs.length > 0 ? ' ' + attrs.join(' ') : '';
-    session.output.push(`<${name}${attrString} />`);
+    const attrString = attrs.join(' ');
+    session.output.push(`  <subroutine ${attrString} />`);
   }
+  
+  session.output.push('</subroutines>');
 }
 
 function escapeXml(text: string): string {

package/src/tags/call.ts

@@ -135,6 +135,10 @@ async function executeCallInternal(
   const wasReturn = session.isReturn;
   session.isReturn = false;
   
+  // Track current subroutine name for available-subroutines
+  const oldSubroutineName = session.currentSubroutineName;
+  session.currentSubroutineName = callElement.tag;
+  
   // For extend execution, skip subroutine registration during body execution
   const oldSkipFlag = session.skipSubroutineRegistration;
   if (isExtendExecution) {

package/src/tags/defvar.ts

@@ -27,8 +27,10 @@ export async function executeDefvar(session: DiracSession, element: DiracElement
   if (valueAttr !== undefined) {
     value = substituteVariables(session, valueAttr);
   } else if (literal) {
-    // Literal mode: take text or XML as-is
-    if (element.text) {
+    // Literal mode: serialize children to XML text without executing
+    if (element.children && element.children.length > 0) {
+      value = serializeToXml(element.children);
+    } else if (element.text) {
       value = substituteVariables(session, element.text);
     } else {
       value = '';
@@ -60,3 +62,52 @@ export async function executeDefvar(session: DiracSession, element: DiracElement
 
   setVariable(session, name, value, visible);
 }
+
+function serializeToXml(children: DiracElement[]): string {
+  let xml = '';
+  
+  for (const child of children) {
+    if (!child.tag || child.tag === '') {
+      // Text node
+      xml += child.text || '';
+    } else {
+      // Element node
+      xml += `<${child.tag}`;
+      
+      // Add attributes
+      for (const [attrName, attrValue] of Object.entries(child.attributes)) {
+        xml += ` ${attrName}="${escapeXml(attrValue)}"`;
+      }
+      
+      // Self-closing or with children
+      if (child.children.length === 0 && !child.text) {
+        xml += ' />';
+      } else {
+        xml += '>';
+        
+        // Add text content if present
+        if (child.text) {
+          xml += escapeXml(child.text);
+        }
+        
+        // Add children
+        if (child.children.length > 0) {
+          xml += serializeToXml(child.children);
+        }
+        
+        xml += `</${child.tag}>`;
+      }
+    }
+  }
+  
+  return xml;
+}
+
+function escapeXml(text: string): string {
+  return text
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;')
+    .replace(/"/g, '&quot;')
+    .replace(/'/g, '&apos;');
+}

package/src/tags/foreach.ts

@@ -0,0 +1,170 @@
+/**
+ * <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/tag-check.ts

@@ -15,20 +15,27 @@ const SIMILARITY_CUTOFF = 0.75;
 
 // Helper: get embedding server config from config.yml
 function getEmbeddingServerConfig() {
-  const config = yaml.load(fs.readFileSync('config.yml', 'utf8')) as any;
-  const host = config.embeddingServer?.host || 'localhost';
-  const port = config.embeddingServer?.port || 11435;
-  return { host, port };
+  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 } = getEmbeddingServerConfig();
+  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: 'embeddinggemma', prompt: tag })
+      body: JSON.stringify({ model, prompt: tag })
     });
     const data = await response.json();
     return data.embedding;
@@ -67,6 +74,12 @@ export async function executeTagCheck(session: DiracSession, element: DiracEleme
 
   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;

package/src/test-runner.ts

@@ -33,10 +33,10 @@ export class TestRunner {
   constructor(testDir: string = 'tests', configPath?: string) {
     this.testDir = testDir;
     
-    // Load default config
-    const defaultConfigPath = configPath || path.resolve(process.cwd(), 'config.yml');
-    if (fs.existsSync(defaultConfigPath)) {
-      this.config = yaml.load(fs.readFileSync(defaultConfigPath, 'utf8')) || {};
+    // For tests, always use ollama as the default provider (no API keys needed)
+    // Unless a specific test config is provided
+    if (configPath && fs.existsSync(configPath)) {
+      this.config = yaml.load(fs.readFileSync(configPath, 'utf8')) || {};
     } else {
       this.config = { llmProvider: 'ollama', llmModel: 'llama2' };
     }

package/src/types/index.ts

@@ -106,6 +106,7 @@ export interface DiracSession {
   
   // Extend mechanism
   skipSubroutineRegistration: boolean;
+  currentSubroutineName?: string;  // Track currently executing subroutine for available-subroutines
   
   // Debugging
   debug: boolean;

package/src/utils/tag-validator.ts

@@ -23,23 +23,26 @@ export interface ValidationResult {
 // Helper: get embedding server config from config.yml
 function getEmbeddingServerConfig() {
   try {
-    const config = yaml.load(fs.readFileSync('config.yml', 'utf8')) as any;
+    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 || 11435;
-    return { host, port };
-  } catch {
-    return { host: 'localhost', port: 11435 };
+    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 } = getEmbeddingServerConfig();
+  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: 'embeddinggemma', prompt: tag })
+      body: JSON.stringify({ model, prompt: tag })
     });
     const data = await response.json();
     return data.embedding;
@@ -179,7 +182,8 @@ export async function validateDiracCode(
   
   // Recursively validate all elements
   async function validateElement(element: DiracElement) {
-    if (element.tag && element.tag !== 'dirac' && element.tag !== '') {
+    // Skip text nodes and whitespace-only tags
+    if (element.tag && element.tag !== 'dirac' && element.tag.trim() !== '') {
       const result = await validateTag(session, element, options);
       results.push(result);
       

package/tests/available-subroutines-foreach.test.di

@@ -0,0 +1,32 @@
+<!-- TEST: available-subroutines with foreach and attr -->
+<!-- EXPECT: - show-subroutines: 
+- greet: Greets someone
+- gender: Returns gender identity
+- age: Returns the person age -->
+<dirac>
+<subroutine name="TestSuite">
+  <subroutine name="age" description="Returns the person age">
+    <output>42</output>
+  </subroutine>
+  
+  <subroutine name="gender" description="Returns gender identity">
+    <output>Male</output>
+  </subroutine>
+  
+  <subroutine name="greet" description="Greets someone">
+    <output>Hello!</output>
+  </subroutine>
+
+  <subroutine name="show-subroutines">
+    <defvar name="subs"><available-subroutines /></defvar>
+    <foreach from="$subs" as="sub" xpath="//subroutine">
+      <output>- <attr name="name" from="$sub" />: <attr name="description" from="$sub" />
+</output>
+    </foreach>
+  </subroutine>
+
+  <show-subroutines />
+</subroutine>
+
+<TestSuite />
+</dirac>