dirac-lang 0.1.14 → 0.1.16

package/config.test.yml

@@ -0,0 +1,5 @@
+# Test configuration for verifying embedding config works
+embeddingServer:
+  host: localhost
+  port: 11434
+  model: nomic-embed-text  # Different model to test config loading

package/dist/{chunk-VOD5GGHB.js → chunk-CP4YCRBG.js}

@@ -1,3 +1,6 @@
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
 import {
   executeSubroutine
 } from "./chunk-E7PWEMZA.js";
@@ -91,7 +94,9 @@ async function executeDefvar(session, element) {
   if (valueAttr !== void 0) {
     value = substituteVariables(session, valueAttr);
   } else if (literal) {
-    if (element.text) {
+    if (element.children && element.children.length > 0) {
+      value = serializeToXml(element.children);
+    } else if (element.text) {
       value = substituteVariables(session, element.text);
     } else {
       value = "";
@@ -118,6 +123,35 @@ async function executeDefvar(session, element) {
   }
   setVariable(session, name, value, visible);
 }
+function serializeToXml(children) {
+  let xml = "";
+  for (const child of children) {
+    if (!child.tag || child.tag === "") {
+      xml += child.text || "";
+    } else {
+      xml += `<${child.tag}`;
+      for (const [attrName, attrValue] of Object.entries(child.attributes)) {
+        xml += ` ${attrName}="${escapeXml(attrValue)}"`;
+      }
+      if (child.children.length === 0 && !child.text) {
+        xml += " />";
+      } else {
+        xml += ">";
+        if (child.text) {
+          xml += escapeXml(child.text);
+        }
+        if (child.children.length > 0) {
+          xml += serializeToXml(child.children);
+        }
+        xml += `</${child.tag}>`;
+      }
+    }
+  }
+  return xml;
+}
+function escapeXml(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
+}
 
 // src/tags/variable.ts
 function executeVariable(session, element) {
@@ -234,6 +268,8 @@ async function executeCallInternal(session, subroutine, callElement, isExtendExe
   const oldBoundary = setBoundary(session);
   const wasReturn = session.isReturn;
   session.isReturn = false;
+  const oldSubroutineName = session.currentSubroutineName;
+  session.currentSubroutineName = callElement.tag;
   const oldSkipFlag = session.skipSubroutineRegistration;
   if (isExtendExecution) {
     session.skipSubroutineRegistration = true;
@@ -360,12 +396,12 @@ async function executeIf(session, element) {
   const condition = await evaluatePredicate(session, conditionElement);
   if (condition) {
     if (thenElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
       await integrateChildren2(session, thenElement);
     }
   } else {
     if (elseElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
       await integrateChildren2(session, elseElement);
     }
   }
@@ -378,7 +414,7 @@ async function evaluatePredicate(session, predicateElement) {
     return await evaluateCondition(session, predicateElement);
   }
   const outputLengthBefore = session.output.length;
-  const { integrate: integrate2 } = await import("./interpreter-FT22JGOO.js");
+  const { integrate: integrate2 } = await import("./interpreter-GNO4J3HN.js");
   await integrate2(session, predicateElement);
   const newOutputChunks = session.output.slice(outputLengthBefore);
   const result = newOutputChunks.join("").trim();
@@ -401,11 +437,11 @@ async function evaluateCondition(session, condElement) {
   }
   const outputLengthBefore = session.output.length;
   const args = [];
-  const { integrate: integrate2 } = await import("./interpreter-FT22JGOO.js");
+  const { integrate: integrate2 } = await import("./interpreter-GNO4J3HN.js");
   for (const child of condElement.children) {
     if (child.tag.toLowerCase() === "arg") {
       const argOutputStart = session.output.length;
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
       await integrateChildren2(session, child);
       const newChunks = session.output.slice(argOutputStart);
       const argValue = newChunks.join("");
@@ -463,126 +499,6 @@ function evaluateConditionType(evalType, args) {
   }
 }
 
-// src/runtime/parser.ts
-import { XMLParser } from "fast-xml-parser";
-var DiracParser = class {
-  parser;
-  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) {
-    if (source.startsWith("#!")) {
-      source = source.replace(/^#!.*\n/, "");
-    }
-    source = `<DIRAC-ROOT>
-${source}
-</DIRAC-ROOT>`;
-    const result = this.parser.parse(source);
-    if (!Array.isArray(result) || result.length === 0) {
-      throw new Error("Empty or invalid XML");
-    }
-    for (const item of result) {
-      if (!item["#comment"]) {
-        return this.convertOrderedToElement(item);
-      }
-    }
-    throw new Error("No root element found");
-  }
-  convertOrderedToElement(obj) {
-    const tagName = Object.keys(obj).find((k) => k !== ":@" && k !== "#comment");
-    if (!tagName) {
-      throw new Error("Invalid element structure");
-    }
-    const element = {
-      tag: tagName,
-      attributes: {},
-      children: []
-    };
-    if (obj[":@"]) {
-      for (const [key, value] of Object.entries(obj[":@"])) {
-        if (key.startsWith("@_")) {
-          element.attributes[key.slice(2)] = value;
-        }
-      }
-    }
-    const children = obj[tagName];
-    if (Array.isArray(children)) {
-      for (const child of children) {
-        if (child["#text"]) {
-          element.children.push({
-            tag: "",
-            text: child["#text"],
-            attributes: {},
-            children: []
-          });
-          if (!element.text) {
-            element.text = child["#text"];
-          } else {
-            element.text += child["#text"];
-          }
-        } else if (child["#comment"]) {
-          continue;
-        } else {
-          element.children.push(this.convertOrderedToElement(child));
-        }
-      }
-    }
-    return element;
-  }
-  // Old method - no longer used
-  convertToElement(obj, tagName) {
-    if (!tagName) {
-      const keys = Object.keys(obj);
-      if (keys.length === 0) {
-        throw new Error("Empty XML");
-      }
-      tagName = keys[0];
-      obj = obj[tagName];
-    }
-    const element = {
-      tag: tagName,
-      attributes: {},
-      children: []
-    };
-    if (typeof obj === "string") {
-      element.text = obj;
-      return element;
-    }
-    if (!obj) {
-      return element;
-    }
-    for (const key of Object.keys(obj)) {
-      const value = obj[key];
-      if (key === "#text") {
-        element.text = value;
-      } else if (key.startsWith("@_")) {
-        element.attributes[key.slice(2)] = value;
-      } else {
-        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;
-  }
-};
-
 // src/tags/llm.ts
 async function executeLLM(session, element) {
   if (!session.llmClient) {
@@ -761,7 +677,7 @@ ${result}
           const parser = new DiracParser();
           let dynamicAST = parser.parse(diracCode);
           if (validateTags) {
-            const { validateDiracCode, applyCorrectedTags } = await import("./tag-validator-DYWFTEBE.js");
+            const { validateDiracCode, applyCorrectedTags } = await import("./tag-validator-CLYGULLQ.js");
             let validation = await validateDiracCode(session, dynamicAST, { autocorrect });
             let retryCount = 0;
             while (!validation.valid && retryCount < maxRetries) {
@@ -1190,18 +1106,24 @@ import fs from "fs";
 import yaml from "js-yaml";
 var SIMILARITY_CUTOFF = 0.75;
 function getEmbeddingServerConfig() {
-  const config = yaml.load(fs.readFileSync("config.yml", "utf8"));
-  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"));
+    const host = config.embeddingServer?.host || "localhost";
+    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;
@@ -1237,6 +1159,9 @@ async function executeTagCheck(session, element) {
   const shouldExecute = element.attributes?.execute === "true";
   for (const child of element.children) {
     const tagName = child.tag;
+    if (!tagName || tagName.trim() === "") {
+      continue;
+    }
     console.error(`[tag-check] Checking tag: <${tagName}>`);
     let allValid = false;
     let correctedTag = null;
@@ -1319,7 +1244,7 @@ async function executeTagCheck(session, element) {
       const executeTag = correctedTag || tagName;
       console.error(`[tag-check] Executing <${executeTag}/> as all checks passed and execute=true.`);
       const elementToExecute = correctedTag ? { ...child, tag: correctedTag } : child;
-      const { integrate: integrate2 } = await import("./interpreter-FT22JGOO.js");
+      const { integrate: integrate2 } = await import("./interpreter-GNO4J3HN.js");
       await integrate2(session, elementToExecute);
     }
   }
@@ -1328,7 +1253,7 @@ async function executeTagCheck(session, element) {
 // src/tags/throw.ts
 async function executeThrow(session, element) {
   const exceptionName = element.attributes?.name || "exception";
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
   const exceptionDom = {
     tag: "exception-content",
     attributes: { name: exceptionName },
@@ -1341,7 +1266,7 @@ async function executeThrow(session, element) {
 // src/tags/try.ts
 async function executeTry(session, element) {
   setExceptionBoundary(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
   await integrateChildren2(session, element);
   unsetExceptionBoundary(session);
 }
@@ -1351,7 +1276,7 @@ async function executeCatch(session, element) {
   const exceptionName = element.attributes?.name || "exception";
   const caughtCount = lookupException(session, exceptionName);
   if (caughtCount > 0) {
-    const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+    const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
     await integrateChildren2(session, element);
   }
   flushCurrentException(session);
@@ -1360,7 +1285,7 @@ async function executeCatch(session, element) {
 // src/tags/exception.ts
 async function executeException(session, element) {
   const exceptions = getCurrentExceptions(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-FT22JGOO.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-GNO4J3HN.js");
   for (const exceptionDom of exceptions) {
     await integrateChildren2(session, exceptionDom);
   }
@@ -1449,32 +1374,189 @@ function evaluateCondition2(session, test) {
 // src/tags/available-subroutines.ts
 async function executeAvailableSubroutines(session, element) {
   const availableSubroutines = /* @__PURE__ */ new Map();
+  const currentSubroutineName = session.subBoundary < session.subroutines.length ? session.subroutines[session.subBoundary].name : null;
   for (let i = session.subroutines.length - 1; i >= session.subBoundary; i--) {
     const sub = session.subroutines[i];
+    if (sub.name === currentSubroutineName) {
+      continue;
+    }
     if (!availableSubroutines.has(sub.name)) {
       availableSubroutines.set(sub.name, sub.element);
     }
   }
+  session.output.push("<subroutines>");
   for (const [name, subElement] of availableSubroutines) {
-    const attrs = [];
+    const attrs = [`name="${escapeXml2(name)}"`];
     const description = subElement.attributes.description;
     if (description) {
-      attrs.push(`description="${escapeXml(description)}"`);
+      attrs.push(`description="${escapeXml2(description)}"`);
     }
     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}="${escapeXml2(attrValue)}"`);
       }
     }
-    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) {
+function escapeXml2(text) {
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 
+// src/tags/foreach.ts
+import { XMLParser } from "fast-xml-parser";
+async function executeForeach(session, element) {
+  const fromAttr = element.attributes.from;
+  const asVar = element.attributes.as || "item";
+  const xpath = element.attributes.xpath;
+  if (!fromAttr) {
+    throw new Error('<foreach> requires "from" attribute');
+  }
+  let xmlContent;
+  if (fromAttr.startsWith("$")) {
+    const varName = fromAttr.substring(1);
+    xmlContent = getVariable(session, varName) || "";
+  } else if (fromAttr.startsWith("<")) {
+    const savedOutput = session.output;
+    session.output = [];
+    const { DiracParser: DiracParser2 } = await import("./parser-T6W3WPLU.js");
+    const parser2 = new DiracParser2();
+    try {
+      const fromElement = parser2.parse(fromAttr);
+      const { integrate: integrate2 } = await import("./interpreter-GNO4J3HN.js");
+      await integrate2(session, fromElement);
+    } catch (e) {
+      session.output = savedOutput;
+      throw new Error(`Failed to evaluate from="${fromAttr}": ${e}`);
+    }
+    xmlContent = session.output.join("");
+    session.output = savedOutput;
+  } else {
+    xmlContent = substituteVariables(session, fromAttr);
+  }
+  if (!xmlContent || xmlContent.trim() === "") {
+    return;
+  }
+  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}`);
+  }
+  const items = extractElements(parsed, xpath);
+  for (const item of items) {
+    setVariable(session, asVar, item, false);
+    await integrateChildren(session, element);
+    if (session.isBreak) {
+      session.isBreak = false;
+      break;
+    }
+    if (session.isReturn) {
+      break;
+    }
+  }
+}
+function extractElements(parsed, xpath) {
+  const items = [];
+  if (!Array.isArray(parsed)) {
+    return items;
+  }
+  const extractFromNode = (node) => {
+    if (!node) return;
+    const tagName = Object.keys(node).find((k) => k !== ":@" && k !== "#text" && k !== "#comment");
+    if (!tagName) return;
+    const item = {
+      tag: tagName,
+      attributes: {}
+    };
+    if (node[":@"]) {
+      for (const [key, value] of Object.entries(node[":@"])) {
+        if (key.startsWith("@_")) {
+          item.attributes[key.slice(2)] = value;
+        }
+      }
+    }
+    const children = node[tagName];
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        if (child["#text"]) {
+          item.text = (item.text || "") + child["#text"];
+        } else {
+          extractFromNode(child);
+        }
+      }
+    }
+    if (!xpath || matchesXPath(item, xpath)) {
+      items.push(item);
+    }
+  };
+  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, xpath) {
+  const tagMatch = xpath.match(/\/{0,2}(\w+)/);
+  if (tagMatch) {
+    return item.tag === tagMatch[1];
+  }
+  return true;
+}
+
+// src/tags/attr.ts
+async function executeAttr(session, element) {
+  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');
+  }
+  let item;
+  if (fromAttr.startsWith("$")) {
+    const varName = fromAttr.substring(1);
+    item = getVariable(session, varName);
+  } else {
+    const substituted = substituteVariables(session, fromAttr);
+    item = getVariable(session, substituted);
+  }
+  if (!item) {
+    return;
+  }
+  let value = "";
+  if (typeof item === "object") {
+    if (item.attributes && typeof item.attributes === "object") {
+      value = item.attributes[nameAttr] || "";
+    } else if (item[nameAttr] !== void 0) {
+      value = String(item[nameAttr]);
+    }
+  } else if (typeof item === "string") {
+    value = extractAttrFromXml(item, nameAttr);
+  }
+  session.output.push(value);
+}
+function extractAttrFromXml(xml, attrName) {
+  const regex = new RegExp(`${attrName}="([^"]*)"`, "i");
+  const match = xml.match(regex);
+  return match ? match[1] : "";
+}
+
 // src/runtime/interpreter.ts
 async function integrate(session, element) {
   if (session.limits.currentDepth >= session.limits.maxDepth) {
@@ -1561,6 +1643,12 @@ async function integrate(session, element) {
       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);
         break;
@@ -1594,7 +1682,6 @@ async function integrateChildren(session, element) {
 }
 
 export {
-  DiracParser,
   integrate,
   integrateChildren
 };

package/dist/{chunk-SOHSXT3M.js → chunk-FEOBVBSI.js}

@@ -1,7 +1,9 @@
 import {
-  DiracParser,
   integrate
-} from "./chunk-VOD5GGHB.js";
+} from "./chunk-CP4YCRBG.js";
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
 import {
   createSession,
   getAvailableSubroutines,

package/dist/chunk-HRHAMPOB.js

@@ -0,0 +1,123 @@
+// src/runtime/parser.ts
+import { XMLParser } from "fast-xml-parser";
+var DiracParser = class {
+  parser;
+  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) {
+    if (source.startsWith("#!")) {
+      source = source.replace(/^#!.*\n/, "");
+    }
+    source = `<DIRAC-ROOT>
+${source}
+</DIRAC-ROOT>`;
+    const result = this.parser.parse(source);
+    if (!Array.isArray(result) || result.length === 0) {
+      throw new Error("Empty or invalid XML");
+    }
+    for (const item of result) {
+      if (!item["#comment"]) {
+        return this.convertOrderedToElement(item);
+      }
+    }
+    throw new Error("No root element found");
+  }
+  convertOrderedToElement(obj) {
+    const tagName = Object.keys(obj).find((k) => k !== ":@" && k !== "#comment");
+    if (!tagName) {
+      throw new Error("Invalid element structure");
+    }
+    const element = {
+      tag: tagName,
+      attributes: {},
+      children: []
+    };
+    if (obj[":@"]) {
+      for (const [key, value] of Object.entries(obj[":@"])) {
+        if (key.startsWith("@_")) {
+          element.attributes[key.slice(2)] = value;
+        }
+      }
+    }
+    const children = obj[tagName];
+    if (Array.isArray(children)) {
+      for (const child of children) {
+        if (child["#text"]) {
+          element.children.push({
+            tag: "",
+            text: child["#text"],
+            attributes: {},
+            children: []
+          });
+          if (!element.text) {
+            element.text = child["#text"];
+          } else {
+            element.text += child["#text"];
+          }
+        } else if (child["#comment"]) {
+          continue;
+        } else {
+          element.children.push(this.convertOrderedToElement(child));
+        }
+      }
+    }
+    return element;
+  }
+  // Old method - no longer used
+  convertToElement(obj, tagName) {
+    if (!tagName) {
+      const keys = Object.keys(obj);
+      if (keys.length === 0) {
+        throw new Error("Empty XML");
+      }
+      tagName = keys[0];
+      obj = obj[tagName];
+    }
+    const element = {
+      tag: tagName,
+      attributes: {},
+      children: []
+    };
+    if (typeof obj === "string") {
+      element.text = obj;
+      return element;
+    }
+    if (!obj) {
+      return element;
+    }
+    for (const key of Object.keys(obj)) {
+      const value = obj[key];
+      if (key === "#text") {
+        element.text = value;
+      } else if (key.startsWith("@_")) {
+        element.attributes[key.slice(2)] = value;
+      } else {
+        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;
+  }
+};
+
+export {
+  DiracParser
+};

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   execute
-} from "./chunk-SOHSXT3M.js";
-import "./chunk-VOD5GGHB.js";
+} from "./chunk-FEOBVBSI.js";
+import "./chunk-CP4YCRBG.js";
+import "./chunk-HRHAMPOB.js";
 import "./chunk-E7PWEMZA.js";
 import "./chunk-52ED23DR.js";
 
@@ -12,7 +13,7 @@ import "dotenv/config";
 // package.json
 var package_default = {
   name: "dirac-lang",
-  version: "0.1.14",
+  version: "0.1.16",
   description: "LLM-Augmented Declarative Execution",
   type: "module",
   main: "dist/index.js",