dirac-lang 0.1.13 → 0.1.15

package/dist/{chunk-34CYTCOP.js → chunk-74EQEVS6.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) {
@@ -206,7 +240,7 @@ async function registerExtendChain(session, subroutine, currentName) {
   } else {
     parentName = currentName;
   }
-  const parent = getParentSubroutine(session, parentName, parentName === currentName);
+  const parent = getParentSubroutine(session, parentName, parentName === currentName ? subroutine : void 0);
   if (!parent) {
     return subroutine;
   }
@@ -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-MAG7PN4D.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.js");
       await integrateChildren2(session, thenElement);
     }
   } else {
     if (elseElement) {
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-MAG7PN4D.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.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-MAG7PN4D.js");
+  const { integrate: integrate2 } = await import("./interpreter-SE5I5ROB.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-MAG7PN4D.js");
+  const { integrate: integrate2 } = await import("./interpreter-SE5I5ROB.js");
   for (const child of condElement.children) {
     if (child.tag.toLowerCase() === "arg") {
       const argOutputStart = session.output.length;
-      const { integrateChildren: integrateChildren2 } = await import("./interpreter-MAG7PN4D.js");
+      const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.js");
       await integrateChildren2(session, child);
       const newChunks = session.output.slice(argOutputStart);
       const argValue = newChunks.join("");
@@ -463,123 +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/, "");
-    }
-    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) {
@@ -1316,7 +1235,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-MAG7PN4D.js");
+      const { integrate: integrate2 } = await import("./interpreter-SE5I5ROB.js");
       await integrate2(session, elementToExecute);
     }
   }
@@ -1325,7 +1244,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-MAG7PN4D.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.js");
   const exceptionDom = {
     tag: "exception-content",
     attributes: { name: exceptionName },
@@ -1338,7 +1257,7 @@ async function executeThrow(session, element) {
 // src/tags/try.ts
 async function executeTry(session, element) {
   setExceptionBoundary(session);
-  const { integrateChildren: integrateChildren2 } = await import("./interpreter-MAG7PN4D.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.js");
   await integrateChildren2(session, element);
   unsetExceptionBoundary(session);
 }
@@ -1348,7 +1267,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-MAG7PN4D.js");
+    const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.js");
     await integrateChildren2(session, element);
   }
   flushCurrentException(session);
@@ -1357,7 +1276,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-MAG7PN4D.js");
+  const { integrateChildren: integrateChildren2 } = await import("./interpreter-SE5I5ROB.js");
   for (const exceptionDom of exceptions) {
     await integrateChildren2(session, exceptionDom);
   }
@@ -1443,6 +1362,192 @@ function evaluateCondition2(session, test) {
   return true;
 }
 
+// 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 = [`name="${escapeXml2(name)}"`];
+    const description = subElement.attributes.description;
+    if (description) {
+      attrs.push(`description="${escapeXml2(description)}"`);
+    }
+    for (const [attrName, attrValue] of Object.entries(subElement.attributes)) {
+      if (attrName.startsWith("param-")) {
+        attrs.push(`${attrName}="${escapeXml2(attrValue)}"`);
+      }
+    }
+    const attrString = attrs.join(" ");
+    session.output.push(`  <subroutine ${attrString} />`);
+  }
+  session.output.push("</subroutines>");
+}
+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-SE5I5ROB.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) {
@@ -1526,9 +1631,25 @@ async function integrate(session, element) {
       case "test-if":
         await executeTestIf(session, element);
         break;
+      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;
+      case "dirac":
+      case "DIRAC-ROOT":
+        for (const child of element.children) {
+          await integrate(session, child);
+          if (session.isReturn || session.isBreak) break;
+        }
+        break;
       default:
         const subroutine = getSubroutine(session, element.tag);
         if (subroutine) {
@@ -1552,7 +1673,6 @@ async function integrateChildren(session, element) {
 }
 
 export {
-  DiracParser,
   integrate,
   integrateChildren
 };

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/{chunk-Z6QGGWWD.js → chunk-UO6QEXZV.js}

@@ -1,7 +1,9 @@
 import {
-  DiracParser,
   integrate
-} from "./chunk-34CYTCOP.js";
+} from "./chunk-74EQEVS6.js";
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
 import {
   createSession,
   getAvailableSubroutines,

package/dist/cli.js

@@ -1,8 +1,9 @@
 #!/usr/bin/env node
 import {
   execute
-} from "./chunk-Z6QGGWWD.js";
-import "./chunk-34CYTCOP.js";
+} from "./chunk-UO6QEXZV.js";
+import "./chunk-74EQEVS6.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.13",
+  version: "0.1.15",
   description: "LLM-Augmented Declarative Execution",
   type: "module",
   main: "dist/index.js",

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-Z6QGGWWD.js";
+} from "./chunk-UO6QEXZV.js";
 import {
-  DiracParser,
   integrate
-} from "./chunk-34CYTCOP.js";
+} from "./chunk-74EQEVS6.js";
+import {
+  DiracParser
+} from "./chunk-HRHAMPOB.js";
 import "./chunk-E7PWEMZA.js";
 import {
   createSession,

package/dist/{interpreter-MAG7PN4D.js → interpreter-SE5I5ROB.js}

@@ -1,7 +1,8 @@
 import {
   integrate,
   integrateChildren
-} from "./chunk-34CYTCOP.js";
+} from "./chunk-74EQEVS6.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
+};