dirac-lang 0.1.2

package/dist/chunk-S625X7ME.js

@@ -0,0 +1,1071 @@
+import {
+  cleanToBoundary,
+  createSession,
+  emit,
+  getAvailableSubroutines,
+  getCurrentParameters,
+  getOutput,
+  getSubroutine,
+  getVariable,
+  popParameters,
+  pushParameters,
+  registerSubroutine,
+  setBoundary,
+  setVariable,
+  substituteVariables
+} from "./chunk-NDIRTD3D.js";
+
+// src/runtime/parser.ts
+import { XMLParser } from "fast-xml-parser";
+var DiracParser = class {
+  parser;
+  constructor() {
+    this.parser = new XMLParser({
+      ignoreAttributes: false,
+      attributeNamePrefix: "@_",
+      trimValues: true,
+      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/parameters.ts
+async function executeParameters(session, element) {
+  const select = element.attributes.select;
+  if (!select) {
+    throw new Error("<parameters> requires select attribute");
+  }
+  const params = getCurrentParameters(session);
+  if (!params || params.length === 0) {
+    if (session.debug) {
+      console.error(`[PARAMETERS] No parameters available`);
+    }
+    return;
+  }
+  const caller = params[0];
+  if (select === "*") {
+    if (session.debug) {
+      console.error(`[PARAMETERS] Selecting all children (${caller.children.length} elements)`);
+    }
+    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("@")) {
+    const attrName = select.slice(1);
+    if (attrName === "*") {
+      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 {
+      const value = caller.attributes[attrName];
+      if (session.debug) {
+        console.error(`[PARAMETERS] Setting variable '${attrName}' = '${value}'`);
+      }
+      if (value !== void 0) {
+        setVariable(session, attrName, value, false);
+        console.error(`[PARAMETERS] Variable stack after setting '${attrName}':`, JSON.stringify(session.variables));
+      }
+      for (const child of element.children) {
+        await integrate(session, child);
+      }
+    }
+  } else {
+    throw new Error(`<parameters> invalid select: ${select}`);
+  }
+}
+
+// src/tags/defvar.ts
+async function executeDefvar(session, element) {
+  const name = element.attributes.name;
+  const valueAttr = element.attributes.value;
+  const visibleAttr = element.attributes.visible || "false";
+  const literal = "literal" in element.attributes;
+  if (!name) {
+    throw new Error("<defvar> requires name attribute");
+  }
+  const visible = visibleAttr === "true" || visibleAttr === "variable" || visibleAttr === "both";
+  let value;
+  if (valueAttr !== void 0) {
+    value = substituteVariables(session, valueAttr);
+  } else if (literal) {
+    if (element.text) {
+      value = substituteVariables(session, element.text);
+    } else {
+      value = "";
+    }
+  } else if (element.children && element.children.length > 0) {
+    if (element.children.length === 1 && element.children[0].tag && element.children[0].tag.toLowerCase() === "parameters") {
+      value = await executeParameters(session, element.children[0]);
+    } else {
+      const prevOutput = session.output;
+      session.output = [];
+      for (const child of element.children) {
+        await integrate(session, child);
+      }
+      value = session.output.join("");
+      session.output = prevOutput;
+    }
+  } else if (element.text) {
+    value = substituteVariables(session, element.text);
+  } else {
+    value = "";
+  }
+  setVariable(session, name, value, visible);
+}
+
+// src/tags/variable.ts
+function executeVariable(session, element) {
+  const name = element.attributes.name;
+  if (!name) {
+    console.error("[VariableTagError] <variable> tag missing name attribute:", JSON.stringify(element));
+    throw new Error("<variable> requires name attribute");
+  }
+  const value = getVariable(session, name);
+  if (value === void 0) {
+    if (session.debug) {
+      console.error(`[Warning] Variable '${name}' is undefined`);
+    }
+    return;
+  }
+  emit(session, String(value));
+}
+
+// src/tags/assign.ts
+function executeAssign(session, element) {
+  const name = element.attributes.name;
+  const valueAttr = element.attributes.value;
+  if (!name) {
+    throw new Error("<assign> requires name attribute");
+  }
+  let value;
+  if (valueAttr !== void 0) {
+    value = substituteVariables(session, valueAttr);
+  } else if (element.text) {
+    value = substituteVariables(session, element.text);
+  } else {
+    value = "";
+  }
+  for (let i = session.variables.length - 1; i >= 0; i--) {
+    if (session.variables[i].name === name) {
+      session.variables[i].value = value;
+      return;
+    }
+  }
+  setVariable(session, name, value, false);
+}
+
+// src/tags/output.ts
+async function executeOutput(session, element) {
+  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;
+  }
+}
+
+// src/tags/subroutine.ts
+function executeSubroutine(session, element) {
+  const name = element.attributes.name;
+  if (!name) {
+    throw new Error("<subroutine> requires name attribute");
+  }
+  const description = element.attributes.description;
+  const parameters = [];
+  for (const [attrName, attrValue] of Object.entries(element.attributes)) {
+    if (attrName.startsWith("param-")) {
+      const paramName = attrName.substring(6);
+      const parts = attrValue.split(":");
+      const paramMeta = {
+        name: paramName,
+        type: parts[0] || "string",
+        required: parts[1] === "required",
+        description: parts[2] || void 0
+      };
+      if (parts[3]) {
+        paramMeta.enum = parts[3].split("|");
+      }
+      parameters.push(paramMeta);
+    }
+  }
+  const subroutine = {
+    tag: "subroutine",
+    attributes: { ...element.attributes },
+    children: element.children
+  };
+  registerSubroutine(session, name, subroutine, description, parameters.length > 0 ? parameters : void 0);
+}
+
+// src/tags/call.ts
+async function executeCall(session, element) {
+  let name;
+  if (element.tag === "call") {
+    name = element.attributes.name || element.attributes.subroutine || "";
+  } else {
+    name = element.tag;
+  }
+  if (!name) {
+    throw new Error("<call> requires name or subroutine attribute");
+  }
+  const subroutine = getSubroutine(session, name);
+  if (!subroutine) {
+    throw new Error(`Subroutine '${name}' not found`);
+  }
+  const extendsName = subroutine.attributes.extends;
+  if (extendsName) {
+    const parent = getSubroutine(session, extendsName);
+    if (parent) {
+      await executeCallInternal(session, parent, element);
+    }
+  }
+  await executeCallInternal(session, subroutine, element);
+}
+async function executeCallInternal(session, subroutine, callElement) {
+  const oldBoundary = setBoundary(session);
+  const wasReturn = session.isReturn;
+  session.isReturn = false;
+  const substitutedElement = {
+    tag: callElement.tag,
+    attributes: {},
+    children: callElement.children
+  };
+  for (const [key, value] of Object.entries(callElement.attributes)) {
+    if (typeof value === "string") {
+      substitutedElement.attributes[key] = substituteVariables(session, value);
+    } else {
+      substitutedElement.attributes[key] = value;
+    }
+  }
+  pushParameters(session, [substitutedElement]);
+  try {
+    const paramElements = callElement.children.filter((c) => c.tag === "parameters");
+    if (paramElements.length > 0) {
+      await bindParameters(session, subroutine, paramElements[0]);
+    }
+    await integrateChildren(session, subroutine);
+  } finally {
+    popParameters(session);
+    session.varBoundary = oldBoundary;
+    cleanToBoundary(session);
+    session.isReturn = wasReturn;
+  }
+}
+async function bindParameters(session, subroutine, callParams) {
+  const paramDef = subroutine.children.find((c) => c.tag === "parameters");
+  if (!paramDef) {
+    return;
+  }
+  const paramVars = paramDef.children.filter((c) => c.tag === "variable");
+  const callVars = callParams.children.filter((c) => c.tag === "variable");
+  for (let i = 0; i < paramVars.length; i++) {
+    const paramVar = paramVars[i];
+    const callVar = callVars[i];
+    const paramName = paramVar.attributes.name;
+    const passby = paramVar.attributes.passby || "value";
+    if (!paramName) continue;
+    let value;
+    if (callVar) {
+      const callValue = callVar.attributes.value;
+      if (callValue) {
+        if (passby === "ref") {
+          setVariable(session, paramName, getVariable(session, callValue), false);
+          session.variables[session.variables.length - 1].passby = "ref";
+          session.variables[session.variables.length - 1].refName = callValue;
+        } else {
+          value = substituteVariables(session, callValue);
+          setVariable(session, paramName, value, false);
+        }
+      }
+    } else {
+      const defaultValue = paramVar.attributes.default || "";
+      value = substituteVariables(session, defaultValue);
+      setVariable(session, paramName, value, false);
+    }
+  }
+}
+
+// src/tags/loop.ts
+async function executeLoop(session, element) {
+  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;
+}
+
+// src/tags/if.ts
+async function executeIf(session, element) {
+  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, test) {
+  const substituted = substituteVariables(session, test);
+  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);
+      }
+    }
+  }
+  return substituted.trim() !== "" && substituted.trim() !== "0" && substituted.trim() !== "false";
+}
+
+// src/tags/llm.ts
+async function executeLLM(session, element) {
+  if (!session.llmClient) {
+    throw new Error("<LLM> requires API key (set OPENAI_API_KEY, ANTHROPIC_API_KEY, or LLM_PROVIDER=ollama in .env file)");
+  }
+  if (session.limits.currentLLMCalls >= session.limits.maxLLMCalls) {
+    throw new Error("Maximum LLM calls exceeded");
+  }
+  session.limits.currentLLMCalls++;
+  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";
+  const temperature = parseFloat(element.attributes.temperature || "1.0");
+  const maxTokens = parseInt(element.attributes.maxTokens || "4096", 10);
+  let userPrompt = "";
+  if (element.children.length > 0) {
+    const beforeOutput = session.output.length;
+    for (const child of element.children) {
+      await integrate(session, child);
+    }
+    const childOutput = session.output.slice(beforeOutput);
+    userPrompt = childOutput.join("");
+    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;
+  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 {
+    const { getAvailableSubroutines: getAvailableSubroutines2 } = await import("./session-4QG7OERD.js");
+    const subroutines = getAvailableSubroutines2(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 += `
+- <${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\u2014regenerate 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");
+    }
+    if (contextVar) {
+      const contextValue = getVariable(session, contextVar);
+      if (contextValue) {
+        prompt = `Context: ${contextValue}
+
+${prompt}`;
+      }
+    }
+  }
+  if (session.debug) {
+    console.error(`[LLM] Calling ${model} with prompt length: ${prompt.length}`);
+  }
+  try {
+    let result;
+    if (isOpenAI) {
+      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) {
+      result = await session.llmClient.complete(prompt, {
+        model,
+        temperature,
+        max_tokens: maxTokens
+      });
+    } else {
+      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}`);
+    }
+    if (outputVar) {
+      setVariable(session, outputVar, result, false);
+    } else if (executeMode) {
+      if (session.debug) {
+        console.error(`[LLM] Executing response as Dirac code:
+${result}
+`);
+      }
+      const replaceTick = element.attributes["replace-tick"] === "true";
+      let diracCode = result.trim();
+      if (replaceTick && diracCode.startsWith("```")) {
+        const match = diracCode.match(/^```(\w+)?\n?/m);
+        if (match && match[1] === "bash") {
+          const endIdx = diracCode.indexOf("```", 3);
+          let bashContent = diracCode.slice(match[0].length, endIdx).trim();
+          diracCode = `<system>${bashContent}</system>`;
+        } else {
+          diracCode = diracCode.replace(/^```(?:xml|html|dirac)?\n?/m, "").replace(/\n?```$/m, "").trim();
+        }
+      }
+      try {
+        const parser = new DiracParser();
+        const dynamicAST = parser.parse(diracCode);
+        await integrate(session, dynamicAST);
+      } catch (parseError) {
+        if (session.debug) {
+          console.error(`[LLM] Failed to parse as Dirac, treating as text: ${parseError}`);
+        }
+        emit(session, result);
+      }
+    } else {
+      emit(session, result);
+    }
+  } catch (error) {
+    throw new Error(`LLM error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tags/eval.ts
+var AsyncFunction = Object.getPrototypeOf(async function() {
+}).constructor;
+async function executeEval(session, element) {
+  const name = element.attributes.name;
+  const exprAttr = element.attributes.expr;
+  let expr;
+  if (exprAttr) {
+    expr = exprAttr.replace(/\$\{(\w+)\}/g, "$1");
+  } else if (element.text) {
+    expr = element.text.replace(/\$\{(\w+)\}/g, "$1");
+  } else {
+    throw new Error("<eval> requires expr attribute or text content");
+  }
+  if (session.debug) {
+    console.error(`[EVAL] Code after substitution:
+${expr}
+`);
+  }
+  try {
+    const context = {};
+    for (const v of session.variables) {
+      context[v.name] = v.value;
+    }
+    const { default: fs } = await import("fs");
+    const { default: path } = await import("path");
+    const { fileURLToPath } = await import("url");
+    context.fs = fs;
+    context.path = path;
+    context.__dirname = process.cwd();
+    context.getParams = () => {
+      const params = session.parameterStack[session.parameterStack.length - 1];
+      return params && params[0] ? params[0] : null;
+    };
+    let result;
+    const func = new AsyncFunction(...Object.keys(context), expr);
+    result = await func(...Object.values(context));
+    if (session.debug) {
+      console.error(`[EVAL] Result: ${JSON.stringify(result)}`);
+    }
+    if (name) {
+      setVariable(session, name, result, false);
+    }
+  } catch (error) {
+    throw new Error(`Eval error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tags/execute.ts
+async function executeExecute(session, element) {
+  const sourceAttr = element.attributes.source;
+  let diracCode;
+  if (sourceAttr) {
+    diracCode = getVariable(session, sourceAttr);
+    if (!diracCode) {
+      throw new Error(`<execute> source variable '${sourceAttr}' not found`);
+    }
+  } else if (element.text) {
+    diracCode = substituteVariables(session, element.text);
+  } else {
+    throw new Error("<execute> requires source attribute or text content");
+  }
+  if (session.debug) {
+    console.error(`[EXECUTE] Interpreting dynamic code:
+${diracCode}
+`);
+  }
+  diracCode = diracCode.trim();
+  if (diracCode.startsWith("```")) {
+    diracCode = diracCode.replace(/^```(?:xml|html)?\n?/m, "").replace(/\n?```$/m, "").trim();
+  }
+  try {
+    const parser = new DiracParser();
+    const dynamicAST = parser.parse(diracCode);
+    await integrate(session, dynamicAST);
+  } catch (error) {
+    throw new Error(`Execute error: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+
+// src/tags/import.ts
+import { readFileSync } from "fs";
+import { resolve, dirname } from "path";
+async function executeImport(session, element) {
+  const src = element.attributes.src;
+  if (!src) {
+    throw new Error("<import> requires src attribute");
+  }
+  const currentDir = session.currentFile ? dirname(session.currentFile) : process.cwd();
+  const importPath = resolve(currentDir, src);
+  if (session.debug) {
+    console.error(`[IMPORT] Loading: ${importPath}`);
+  }
+  if (!session.importedFiles) {
+    session.importedFiles = /* @__PURE__ */ new Set();
+  }
+  if (session.importedFiles.has(importPath)) {
+    if (session.debug) {
+      console.error(`[IMPORT] Already imported: ${importPath}`);
+    }
+    return;
+  }
+  session.importedFiles.add(importPath);
+  try {
+    const source = readFileSync(importPath, "utf-8");
+    const parser = new DiracParser();
+    const ast = parser.parse(source);
+    const previousFile = session.currentFile;
+    session.currentFile = importPath;
+    await integrate(session, ast);
+    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)}`);
+  }
+}
+
+// src/tags/expr.ts
+async function executeExpr(session, element) {
+  const op = element.attributes.eval || element.attributes.op;
+  if (!op) {
+    throw new Error("<expr> requires eval or op attribute");
+  }
+  const args = [];
+  const stringArgs = [];
+  for (const child of element.children) {
+    if (child.tag === "arg") {
+      let argValue = "";
+      if (child.text) {
+        argValue = substituteVariables(session, child.text);
+      } else {
+        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 = 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}`);
+  }
+  if (typeof result === "boolean") {
+    emit(session, result ? "1" : "0");
+  } else {
+    emit(session, String(result));
+  }
+}
+
+// src/tags/system.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+var execAsync = promisify(exec);
+async function executeSystem(session, element) {
+  let command;
+  const hasElementChildren = element.children.some((child) => child.tag !== "");
+  if (hasElementChildren) {
+    const beforeOutput = session.output.length;
+    for (const child of element.children) {
+      await integrate(session, child);
+    }
+    const childOutput = session.output.slice(beforeOutput);
+    command = childOutput.join("");
+    session.output = session.output.slice(0, beforeOutput);
+  } else if (element.text) {
+    command = substituteVariables(session, element.text);
+  } else {
+    throw new Error("<system> requires command content");
+  }
+  if (!command.trim()) {
+    return;
+  }
+  if (session.debug) {
+    console.error(`[SYSTEM] Executing: ${command}`);
+  }
+  try {
+    const { stdout, stderr } = await execAsync(command, {
+      encoding: "utf-8",
+      maxBuffer: 10 * 1024 * 1024
+      // 10MB buffer
+    });
+    if (stdout) {
+      emit(session, stdout);
+    }
+    if (stderr && session.debug) {
+      console.error(`[SYSTEM STDERR] ${stderr}`);
+    }
+  } catch (error) {
+    const errorMsg = error.message || String(error);
+    throw new Error(`System command failed: ${errorMsg}`);
+  }
+}
+
+// src/tags/require_module.ts
+async function executeRequireModule(session, element) {
+  const name = element.attributes.name;
+  const varName = element.attributes.var || name;
+  if (!name) throw new Error("<require_module> missing name attribute");
+  try {
+    const mod = await import(name);
+    setVariable(session, varName, mod, true);
+  } catch (err) {
+    throw new Error(`<require_module> failed to load module '${name}': ${err}`);
+  }
+}
+
+// src/runtime/interpreter.ts
+async function integrate(session, element) {
+  if (session.limits.currentDepth >= session.limits.maxDepth) {
+    throw new Error("Maximum execution depth exceeded");
+  }
+  session.limits.currentDepth++;
+  try {
+    if (element.text && !element.tag) {
+      const substituted = substituteVariables(session, element.text);
+      emit(session, substituted);
+      return;
+    }
+    if (session.isReturn || session.isBreak) {
+      return;
+    }
+    switch (element.tag.toLowerCase()) {
+      case "defvar":
+        await executeDefvar(session, element);
+        break;
+      case "variable":
+        await executeVariable(session, element);
+        break;
+      case "assign":
+        await executeAssign(session, element);
+        break;
+      case "output":
+        await executeOutput(session, element);
+        break;
+      case "subroutine":
+        await executeSubroutine(session, element);
+        break;
+      case "call":
+        await executeCall(session, element);
+        break;
+      case "loop":
+        await executeLoop(session, element);
+        break;
+      case "if":
+        await executeIf(session, element);
+        break;
+      case "llm":
+        await executeLLM(session, element);
+        break;
+      case "eval":
+        await executeEval(session, element);
+        break;
+      case "execute":
+        await executeExecute(session, element);
+        break;
+      case "import":
+        await executeImport(session, element);
+        break;
+      case "parameters":
+        await executeParameters(session, element);
+        break;
+      case "expr":
+        await executeExpr(session, element);
+        break;
+      case "system":
+        await executeSystem(session, element);
+        break;
+      case "require_module":
+        await executeRequireModule(session, element);
+        break;
+      default:
+        const subroutine = getSubroutine(session, element.tag);
+        if (subroutine) {
+          await executeCall(session, element);
+        } else {
+          for (const child of element.children) {
+            await integrate(session, child);
+            if (session.isReturn || session.isBreak) break;
+          }
+        }
+    }
+  } finally {
+    session.limits.currentDepth--;
+  }
+}
+async function integrateChildren(session, element) {
+  for (const child of element.children) {
+    await integrate(session, child);
+    if (session.isReturn || session.isBreak) break;
+  }
+}
+
+// src/utils/llm-adapter.ts
+function createLLMAdapter(session) {
+  const subroutines = getAvailableSubroutines(session);
+  const actions = subroutines.map((s) => `"${s.name}"`).join("|");
+  const examples = subroutines.slice(0, 3).map((sub) => {
+    if (!sub.parameters || sub.parameters.length === 0) {
+      return `"${sub.name}" \u2192 {"action":"${sub.name}","params":{}}`;
+    }
+    const firstParam = sub.parameters[0];
+    const exampleValue = firstParam.enum?.[0] || "value";
+    return `"call ${sub.name}" \u2192 {"action":"${sub.name}","params":{"${firstParam.name}":"${exampleValue}"}}`;
+  }).join("\n");
+  return {
+    generatePrompt(userInput) {
+      return `You are a command parser. Convert user input to JSON.
+Return ONLY valid JSON, no other text.
+
+Format: {"action": ${actions}, "params": {}}
+
+Examples:
+${examples}
+
+User: ${userInput}
+JSON:`;
+    },
+    intentToXML(intent) {
+      if (!intent || !intent.action) return null;
+      const sub = subroutines.find((s) => s.name === intent.action);
+      if (!sub) return null;
+      const attrs = [`name="${sub.name}"`];
+      if (sub.parameters) {
+        for (const param of sub.parameters) {
+          const value = intent.params?.[param.name];
+          if (value != null) {
+            if (param.enum && !param.enum.includes(value)) {
+              return null;
+            }
+            attrs.push(`${param.name}="${value}"`);
+          } else if (param.required) {
+            return null;
+          }
+        }
+      }
+      return `<call ${attrs.join(" ")}/>`;
+    }
+  };
+}
+async function executeUserCommand(session, userInput, llmExecuteFn) {
+  try {
+    const adapter = createLLMAdapter(session);
+    const prompt = adapter.generatePrompt(userInput);
+    const llmResponse = await llmExecuteFn(prompt);
+    let jsonStr = llmResponse.trim();
+    jsonStr = jsonStr.replace(/```json\s*/g, "").replace(/```\s*/g, "");
+    const intent = JSON.parse(jsonStr);
+    const xml = adapter.intentToXML(intent);
+    if (!xml) {
+      return { success: false, error: "Could not convert intent to valid command" };
+    }
+    return { success: true, xml };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+
+// src/index.ts
+async function execute(source, config = {}) {
+  const parser = new DiracParser();
+  const session = createSession(config);
+  if (config.filePath) {
+    session.currentFile = config.filePath;
+  }
+  const ast = parser.parse(source);
+  await integrate(session, ast);
+  return getOutput(session);
+}
+
+export {
+  DiracParser,
+  integrate,
+  createLLMAdapter,
+  executeUserCommand,
+  execute
+};