dirac-lang 0.1.97 → 0.1.99

package/dist/scope-validator-TVQIOEAI.js

@@ -0,0 +1,171 @@
+// src/utils/scope-validator.ts
+function extractParameterNames(element) {
+  const params = [];
+  for (const attr in element.attributes) {
+    if (attr.startsWith("param-")) {
+      const paramName = attr.slice(6);
+      params.push(paramName);
+    }
+  }
+  return params;
+}
+function extractVariableReferences(text) {
+  const pattern = /\$\{([a-zA-Z_][a-zA-Z0-9_-]*)\}/g;
+  const matches = [];
+  let match;
+  while ((match = pattern.exec(text)) !== null) {
+    matches.push(match[1]);
+  }
+  return matches;
+}
+var ScopeContext = class {
+  parameters;
+  // Declared parameters
+  declaredVariables;
+  // Variables declared with <defvar>
+  referencedVariables;
+  // Variables referenced with <variable> or ${}
+  referencedParameters;
+  // Parameters actually used
+  constructor(parameters) {
+    this.parameters = new Set(parameters);
+    this.declaredVariables = /* @__PURE__ */ new Set();
+    this.referencedVariables = /* @__PURE__ */ new Set();
+    this.referencedParameters = /* @__PURE__ */ new Set();
+  }
+  /**
+   * Check if a name is available in current scope
+   * Priority: parameters -> declared variables
+   */
+  isInScope(name) {
+    return this.parameters.has(name) || this.declaredVariables.has(name);
+  }
+  /**
+   * Record a variable declaration
+   */
+  declareVariable(name) {
+    this.declaredVariables.add(name);
+  }
+  /**
+   * Record a variable/parameter reference
+   */
+  referenceVariable(name) {
+    this.referencedVariables.add(name);
+    if (this.parameters.has(name)) {
+      this.referencedParameters.add(name);
+    }
+  }
+};
+function validateScope(element, scope, errors, warnings) {
+  if (element.tag === "defvar") {
+    const varName = element.attributes.name;
+    if (varName) {
+      scope.declareVariable(varName);
+    }
+  }
+  if (element.tag === "variable") {
+    const varName = element.attributes.name;
+    if (varName) {
+      scope.referenceVariable(varName);
+      if (!scope.isInScope(varName)) {
+        warnings.push(
+          `Variable reference '${varName}' not found in local scope (may be from parent scope)`
+        );
+      }
+    }
+  }
+  if (element.tag === "parameters") {
+    const select = element.attributes.select;
+    if (select && select.startsWith("@")) {
+      const paramName = select.slice(1);
+      scope.referenceVariable(paramName);
+      if (!scope.isInScope(paramName)) {
+        warnings.push(
+          `Parameter reference '${paramName}' not found in subroutine parameters`
+        );
+      }
+    }
+  }
+  for (const [attrName, attrValue] of Object.entries(element.attributes)) {
+    if (typeof attrValue === "string") {
+      const varRefs = extractVariableReferences(attrValue);
+      for (const varRef of varRefs) {
+        scope.referenceVariable(varRef);
+        if (!scope.isInScope(varRef)) {
+          warnings.push(
+            `Variable substitution '\${${varRef}}' in attribute not found in local scope (may be from parent scope)`
+          );
+        }
+      }
+      const dollarVarPattern = /\$([a-zA-Z_][a-zA-Z0-9_-]*)/g;
+      let dollarMatch;
+      while ((dollarMatch = dollarVarPattern.exec(attrValue)) !== null) {
+        const varName = dollarMatch[1];
+        scope.referenceVariable(varName);
+      }
+    }
+  }
+  for (const child of element.children) {
+    validateScope(child, scope, errors, warnings);
+  }
+}
+function validateSubroutineScope(subroutine) {
+  const errors = [];
+  const warnings = [];
+  const parameters = extractParameterNames(subroutine);
+  const scope = new ScopeContext(parameters);
+  for (const child of subroutine.children) {
+    validateScope(child, scope, errors, warnings);
+  }
+  const unusedParameters = parameters.filter((p) => !scope.referencedParameters.has(p));
+  if (unusedParameters.length > 0) {
+    warnings.push(
+      `Unused parameters: ${unusedParameters.join(", ")}`
+    );
+  }
+  const unusedVariables = Array.from(scope.declaredVariables).filter(
+    (v) => !scope.referencedVariables.has(v)
+  );
+  if (unusedVariables.length > 0) {
+    warnings.push(
+      `Unused variables: ${unusedVariables.join(", ")}`
+    );
+  }
+  const undefinedReferences = Array.from(scope.referencedVariables).filter(
+    (v) => !scope.isInScope(v)
+  );
+  const undefinedParameters = undefinedReferences.filter(
+    (v) => !scope.declaredVariables.has(v)
+  );
+  const undefinedVariables = undefinedReferences.filter(
+    (v) => scope.declaredVariables.has(v)
+  );
+  return {
+    valid: errors.length === 0,
+    errors,
+    warnings,
+    undefinedParameters,
+    undefinedVariables,
+    unusedParameters,
+    unusedVariables
+  };
+}
+function validateAllSubroutineScopes(ast) {
+  const results = /* @__PURE__ */ new Map();
+  function findSubroutines(element) {
+    if (element.tag === "subroutine") {
+      const name = element.attributes.name || "anonymous";
+      const result = validateSubroutineScope(element);
+      results.set(name, result);
+    }
+    for (const child of element.children) {
+      findSubroutines(child);
+    }
+  }
+  findSubroutines(ast);
+  return results;
+}
+export {
+  validateAllSubroutineScopes,
+  validateSubroutineScope
+};

package/dist/{session-IH5LO7FS.js → session-6WX5O74B.js}

@@ -18,6 +18,7 @@ import {
   popToBoundary,
   pushParameters,
   registerSubroutine,
+  removeSubroutine,
   setBoundary,
   setExceptionBoundary,
   setSubroutineBoundary,
@@ -26,7 +27,7 @@ import {
   substituteVariables,
   throwException,
   unsetExceptionBoundary
-} from "./chunk-PPH7KYKH.js";
+} from "./chunk-ZYSWVMID.js";
 export {
   cleanSubroutinesToBoundary,
   cleanToBoundary,
@@ -47,6 +48,7 @@ export {
   popToBoundary,
   pushParameters,
   registerSubroutine,
+  removeSubroutine,
   setBoundary,
   setExceptionBoundary,
   setSubroutineBoundary,

package/dist/{session-server-TQPJVLA4.js → session-server-LMDDND5E.js}

@@ -2,12 +2,12 @@ import {
   SessionServer,
   getSocketPath,
   isSessionRunning
-} from "./chunk-KFMG6CZW.js";
-import "./chunk-4TBIVB4X.js";
-import "./chunk-ECAW4X46.js";
-import "./chunk-SLGJRZ3P.js";
+} from "./chunk-R6R6OHPA.js";
+import "./chunk-3VCKPUTQ.js";
+import "./chunk-53QJQ2CC.js";
 import "./chunk-HRHAMPOB.js";
-import "./chunk-PPH7KYKH.js";
+import "./chunk-EAM7IZWA.js";
+import "./chunk-ZYSWVMID.js";
 export {
   SessionServer,
   getSocketPath,

package/dist/{shell-CY5XIPQC.js → shell-PV6KIJL5.js}

@@ -2,15 +2,15 @@
 import {
   BraKetParser,
   integrate
-} from "./chunk-4TBIVB4X.js";
-import "./chunk-ECAW4X46.js";
-import "./chunk-SLGJRZ3P.js";
+} from "./chunk-3VCKPUTQ.js";
+import "./chunk-53QJQ2CC.js";
 import {
   DiracParser
 } from "./chunk-HRHAMPOB.js";
+import "./chunk-EAM7IZWA.js";
 import {
   createSession
-} from "./chunk-PPH7KYKH.js";
+} from "./chunk-ZYSWVMID.js";
 
 // src/shell.ts
 import * as readline from "readline";
@@ -358,7 +358,7 @@ var DiracShell = class {
     if (this.client) {
       this.client.disconnect();
     }
-    import("./schedule-KMBLI46W.js").then(({ stopAllScheduledTasks }) => {
+    import("./schedule-OYEKDXZV.js").then(({ stopAllScheduledTasks }) => {
       stopAllScheduledTasks();
       console.log("\nGoodbye!");
       process.exit(0);
@@ -504,6 +504,15 @@ var DiracShell = class {
       if (this.session.output.length > 0) {
         console.log(this.session.output.join(""));
       }
+      const silentExecution = this.session.variables.find((v) => v.name === "__llm_silent_execution__");
+      if (silentExecution?.value) {
+        console.error(`
+[LLM generated]
+${silentExecution.value}
+`);
+        const idx = this.session.variables.findIndex((v) => v.name === "__llm_silent_execution__");
+        if (idx !== -1) this.session.variables.splice(idx, 1);
+      }
     } catch (error) {
       console.error("Error:", error instanceof Error ? error.message : String(error));
       if (this.config.debug && error instanceof Error && error.stack) {
@@ -532,6 +541,8 @@ Commands:
   :search <query> Search indexed subroutines
   :load <query>   Load context (search and import subroutines)
   :save <name> [file]  Save subroutine (default: ~/.dirac/lib/TIMESTAMP/name.di)
+  :edit <name>    Edit subroutine in external editor
+  :remove <name>  Remove subroutine from session stack (not from disk)
   :stats          Show registry statistics
   :tasks          List all scheduled tasks
   :stop <name>    Stop a scheduled task
@@ -543,6 +554,7 @@ Commands:
   :cancel <name>  Cancel a scheduled run
   :cancelall      Cancel all scheduled runs
   :save-training [mode=full|pruned|both]  Save LLM dialog as training data (opens in editor)
+  :save-subroutine-training <name>  Save subroutine as training data with description
   :exit           Exit shell
 
 Syntax:
@@ -749,6 +761,49 @@ Examples:
           }
         }
         break;
+      case "edit":
+        if (args.length === 0) {
+          console.log("Usage: :edit <subroutine-name>");
+          console.log("  Opens the subroutine in your default editor ($EDITOR or vi)");
+          console.log("Examples:");
+          console.log("  :edit greet                    # edit greet subroutine in default editor");
+          console.log("  Use :save after editing to persist changes to disk");
+        } else {
+          const subName = args[0];
+          try {
+            const xml = `<edit-subroutine name="${subName}" />`;
+            const ast = this.xmlParser.parse(xml);
+            await integrate(this.session, ast);
+            if (this.session.output.length > 0) {
+              console.log(this.session.output.join(""));
+            }
+          } catch (error) {
+            console.error("Error editing subroutine:", error instanceof Error ? error.message : String(error));
+          }
+        }
+        break;
+      case "remove":
+        if (args.length === 0) {
+          console.log("Usage: :remove <subroutine-name>");
+          console.log("  Removes all instances of the subroutine from the session stack");
+          console.log("  Note: This does NOT delete the subroutine from disk");
+          console.log("Examples:");
+          console.log("  :remove greet                  # remove greet subroutine from session");
+        } else {
+          const subName = args[0];
+          try {
+            const { removeSubroutine } = await import("./session-6WX5O74B.js");
+            const removed = removeSubroutine(this.session, subName);
+            if (removed) {
+              console.log(`Removed subroutine '${subName}' from session stack`);
+            } else {
+              console.log(`Subroutine '${subName}' not found in session`);
+            }
+          } catch (error) {
+            console.error("Error removing subroutine:", error instanceof Error ? error.message : String(error));
+          }
+        }
+        break;
       case "stats":
         try {
           const xml = "<registry-stats />";
@@ -763,7 +818,7 @@ Examples:
         break;
       case "tasks":
         try {
-          const { listScheduledTasks } = await import("./schedule-KMBLI46W.js");
+          const { listScheduledTasks } = await import("./schedule-OYEKDXZV.js");
           const tasks = listScheduledTasks();
           if (tasks.length === 0) {
             console.log("No scheduled tasks running.");
@@ -782,7 +837,7 @@ Examples:
           console.log("Usage: :stop <task-name>");
         } else {
           try {
-            const { stopScheduledTask } = await import("./schedule-KMBLI46W.js");
+            const { stopScheduledTask } = await import("./schedule-OYEKDXZV.js");
             const taskName = args[0];
             const stopped = stopScheduledTask(taskName);
             if (stopped) {
@@ -797,7 +852,7 @@ Examples:
         break;
       case "stopall":
         try {
-          const { stopAllScheduledTasks } = await import("./schedule-KMBLI46W.js");
+          const { stopAllScheduledTasks } = await import("./schedule-OYEKDXZV.js");
           stopAllScheduledTasks();
           console.log("All scheduled tasks stopped.");
         } catch (error) {
@@ -806,7 +861,7 @@ Examples:
         break;
       case "crons":
         try {
-          const { listCronJobs } = await import("./cron-2J3SEPZW.js");
+          const { listCronJobs } = await import("./cron-TTPFON3Y.js");
           const jobs = listCronJobs();
           if (jobs.length === 0) {
             console.log("No cron jobs running.");
@@ -826,7 +881,7 @@ Examples:
           console.log("Usage: :stopcron <job-name>");
         } else {
           try {
-            const { stopCronJob } = await import("./cron-2J3SEPZW.js");
+            const { stopCronJob } = await import("./cron-TTPFON3Y.js");
             const jobName = args[0];
             const stopped = stopCronJob(jobName);
             if (stopped) {
@@ -841,7 +896,7 @@ Examples:
         break;
       case "stopallcrons":
         try {
-          const { stopAllCronJobs } = await import("./cron-2J3SEPZW.js");
+          const { stopAllCronJobs } = await import("./cron-TTPFON3Y.js");
           stopAllCronJobs();
           console.log("All cron jobs stopped.");
         } catch (error) {
@@ -850,7 +905,7 @@ Examples:
         break;
       case "scheduled":
         try {
-          const { listScheduledRuns } = await import("./run-at-MHURF5PL.js");
+          const { listScheduledRuns } = await import("./run-at-A3CJX4TR.js");
           const runs = listScheduledRuns();
           if (runs.length === 0) {
             console.log("No scheduled runs pending.");
@@ -870,7 +925,7 @@ Examples:
           console.log("Usage: :cancel <run-name>");
         } else {
           try {
-            const { cancelScheduledRun } = await import("./run-at-MHURF5PL.js");
+            const { cancelScheduledRun } = await import("./run-at-A3CJX4TR.js");
             const runName = args[0];
             const cancelled = cancelScheduledRun(runName);
             if (cancelled) {
@@ -885,13 +940,99 @@ Examples:
         break;
       case "cancelall":
         try {
-          const { cancelAllScheduledRuns } = await import("./run-at-MHURF5PL.js");
+          const { cancelAllScheduledRuns } = await import("./run-at-A3CJX4TR.js");
           cancelAllScheduledRuns();
           console.log("All scheduled runs cancelled.");
         } catch (error) {
           console.error("Error cancelling runs:", error instanceof Error ? error.message : String(error));
         }
         break;
+      case "save-subroutine-training":
+        if (args.length === 0) {
+          console.log("Usage: :save-subroutine-training <subroutine-name>");
+          console.log("  Saves a subroutine as training data (opens in editor)");
+          console.log("  You will be prompted to provide a description for the training example");
+          console.log("Examples:");
+          console.log("  :save-subroutine-training greet");
+        } else {
+          const subName = args[0];
+          try {
+            let subroutine = void 0;
+            const subroutines = this.client ? (await this.client.getState()).subroutines || [] : this.session.subroutines;
+            for (let i = subroutines.length - 1; i >= 0; i--) {
+              if (subroutines[i].name === subName) {
+                subroutine = subroutines[i];
+                break;
+              }
+            }
+            if (!subroutine) {
+              console.log(`Subroutine '${subName}' not found in session`);
+              break;
+            }
+            const description = await new Promise((resolve2) => {
+              this.rl.question(`Enter description (user's request that would generate this subroutine): `, resolve2);
+            });
+            if (!description.trim()) {
+              console.log("Cancelled (no description provided)");
+              break;
+            }
+            const { serializeSubroutineForTraining } = await import("./subroutine-serializer-LNFHABUC.js");
+            const subroutineContent = serializeSubroutineForTraining(subroutine);
+            const trainingExample = {
+              messages: [
+                { role: "user", content: description.trim() },
+                { role: "assistant", content: subroutineContent }
+              ]
+            };
+            const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").split("T")[0] + "-" + Date.now();
+            const tempFile = path.join(os.tmpdir(), `dirac-subroutine-training-${timestamp}.jsonl`);
+            const tempContent = JSON.stringify(trainingExample, null, 2);
+            fs.writeFileSync(tempFile, tempContent, "utf-8");
+            console.log("Opening in editor...");
+            const editor = process.env.EDITOR || process.env.VISUAL || "vi";
+            const { spawnSync } = await import("child_process");
+            const result = spawnSync(editor, [tempFile], {
+              stdio: "inherit",
+              shell: true
+            });
+            if (result.error) {
+              fs.unlinkSync(tempFile);
+              console.error(`Failed to open editor: ${result.error.message}`);
+              break;
+            }
+            if (result.status !== 0) {
+              fs.unlinkSync(tempFile);
+              console.error(`Editor exited with code ${result.status}`);
+              break;
+            }
+            const answer = await new Promise((resolve2) => {
+              this.rl.question("Save to file (or press Enter to cancel): ", resolve2);
+            });
+            if (!answer.trim()) {
+              fs.unlinkSync(tempFile);
+              console.log("Cancelled");
+              break;
+            }
+            let savePath;
+            if (answer.startsWith("/") || answer.startsWith("~")) {
+              savePath = answer.replace(/^~/, os.homedir());
+            } else if (answer.includes("/")) {
+              savePath = path.resolve(answer);
+            } else {
+              const trainingDir = path.join(os.homedir(), ".dirac", "training");
+              fs.mkdirSync(trainingDir, { recursive: true });
+              savePath = path.join(trainingDir, answer.endsWith(".jsonl") ? answer : `${answer}.jsonl`);
+            }
+            const editedContent = fs.readFileSync(tempFile, "utf-8");
+            const editedData = JSON.parse(editedContent);
+            fs.appendFileSync(savePath, JSON.stringify(editedData) + "\n");
+            console.log(`\u2713 Saved training example for '${subName}' to ${savePath}`);
+            fs.unlinkSync(tempFile);
+          } catch (error) {
+            console.error("Error saving subroutine training data:", error instanceof Error ? error.message : String(error));
+          }
+        }
+        break;
       case "save-training":
         try {
           const fullCommand = cmd.slice(1);
@@ -1153,7 +1294,7 @@ ${JSON.stringify(prunedExample, null, 2)}`;
       console.log("Set ANTHROPIC_API_KEY or OPENAI_API_KEY environment variable,");
       console.log("or create ~/.dirac/config.yml with llmProvider and llmModel.\n");
     }
-    const { registry } = await import("./subroutine-index-RVJSWWJ7.js");
+    const { registry } = await import("./subroutine-index-GB3OSH56.js");
     const wasIndexed = await registry.autoIndexStdlib();
     await this.loadEssentialSubroutines();
     if (this.config.initScript) {

package/dist/{subroutine-7JJKHTV4.js → subroutine-O3YGYHRZ.js}

@@ -1,7 +1,7 @@
 import {
   executeSubroutine
-} from "./chunk-ECAW4X46.js";
-import "./chunk-PPH7KYKH.js";
+} from "./chunk-EAM7IZWA.js";
+import "./chunk-ZYSWVMID.js";
 export {
   executeSubroutine
 };

package/dist/{subroutine-index-RVJSWWJ7.js → subroutine-index-GB3OSH56.js}

@@ -3,9 +3,9 @@ import {
   executeRegistryStats,
   executeSearchSubroutines,
   registry
-} from "./chunk-SLGJRZ3P.js";
+} from "./chunk-53QJQ2CC.js";
 import "./chunk-HRHAMPOB.js";
-import "./chunk-PPH7KYKH.js";
+import "./chunk-ZYSWVMID.js";
 export {
   executeIndexSubroutines,
   executeRegistryStats,

package/dist/subroutine-serializer-LNFHABUC.js

@@ -0,0 +1,160 @@
+// src/utils/subroutine-serializer.ts
+function serializeSubroutineForTraining(sub) {
+  const lines = [];
+  serializeElement(sub.element, lines, "");
+  return lines.join("\n");
+}
+function serializeSubroutineToXML(sub) {
+  const lines = [];
+  lines.push("<!-- Editing subroutine: " + sub.name + " -->");
+  lines.push("");
+  serializeElement(sub.element, lines, "");
+  return lines.join("\n");
+}
+function serializeElement(el, lines, indent) {
+  if (!el.tag || el.tag === "") {
+    if (el.text) {
+      let lastIdx = lines.length - 1;
+      if (lastIdx >= 0 && !lines[lastIdx].endsWith(">")) {
+        lines[lastIdx] += el.text;
+      } else {
+        lines.push(indent + el.text);
+      }
+    }
+    return;
+  }
+  let tag = `${indent}<${el.tag}`;
+  if (el.attributes) {
+    for (const [key, value] of Object.entries(el.attributes)) {
+      if (typeof value === "string") {
+        tag += ` ${key}="${value.replace(/"/g, "&quot;")}"`;
+      }
+    }
+  }
+  const hasChildren = el.children && el.children.length > 0;
+  if (!hasChildren) {
+    let lastIdx = lines.length - 1;
+    if (lastIdx >= 0 && !lines[lastIdx].endsWith(">") && !lines[lastIdx].trim().startsWith("<")) {
+      lines[lastIdx] += tag.slice(indent.length) + " />";
+    } else {
+      lines.push(tag + " />");
+    }
+  } else {
+    let lastIdx = lines.length - 1;
+    const shouldInline = lastIdx >= 0 && !lines[lastIdx].endsWith(">");
+    if (shouldInline) {
+      lines[lastIdx] += tag.slice(indent.length) + ">";
+    } else {
+      lines.push(tag + ">");
+    }
+    let allInline = true;
+    for (let i = 0; i < el.children.length; i++) {
+      const child = el.children[i];
+      if (!child.tag || child.tag === "") {
+        if (child.text) {
+          lastIdx = lines.length - 1;
+          lines[lastIdx] += child.text;
+        }
+      } else {
+        const isComplex = child.children && child.children.length > 0;
+        if (isComplex) {
+          allInline = false;
+          serializeElement(child, lines, indent + "  ");
+        } else {
+          let childTag = `<${child.tag}`;
+          if (child.attributes) {
+            for (const [key, value] of Object.entries(child.attributes)) {
+              if (typeof value === "string") {
+                childTag += ` ${key}="${value.replace(/"/g, "&quot;")}"`;
+              }
+            }
+          }
+          childTag += " />";
+          lastIdx = lines.length - 1;
+          lines[lastIdx] += childTag;
+        }
+      }
+    }
+    lastIdx = lines.length - 1;
+    if (allInline && lines[lastIdx].indexOf("<") > 0) {
+      lines[lastIdx] += `</${el.tag}>`;
+    } else {
+      lines.push(`${indent}</${el.tag}>`);
+    }
+  }
+}
+function serializeSubroutineToBraKet(sub) {
+  const lines = [];
+  lines.push("<!-- Editing subroutine: " + sub.name + " -->");
+  lines.push("");
+  serializeElementToBraKet(sub.element, lines, 0);
+  return lines.join("\n");
+}
+function serializeElementToBraKet(el, lines, indent) {
+  const indentStr = "  ".repeat(indent);
+  if (!el.tag || el.tag === "") {
+    if (el.text) {
+      lines.push(indentStr + el.text);
+    }
+    return;
+  }
+  if (el.tag === "subroutine") {
+    const name = el.attributes?.name || "unnamed";
+    let braLine = `${indentStr}<${name}|`;
+    if (el.attributes) {
+      for (const [key, value] of Object.entries(el.attributes)) {
+        if (key === "name") continue;
+        const needsQuotes = typeof value === "string" && (value.includes(" ") || value.includes("="));
+        braLine += ` ${key}=${needsQuotes ? '"' + value + '"' : value}`;
+      }
+    }
+    lines.push(braLine);
+    if (el.children && el.children.length > 0) {
+      for (const child of el.children) {
+        serializeElementToBraKet(child, lines, indent + 1);
+      }
+    }
+    return;
+  }
+  let ketLine = `${indentStr}|${el.tag}`;
+  if (el.attributes) {
+    for (const [key, value] of Object.entries(el.attributes)) {
+      if (typeof value === "string") {
+        const needsQuotes = value.includes(" ") || value.includes("=");
+        ketLine += ` ${key}=${needsQuotes ? '"' + value + '"' : value}`;
+      }
+    }
+  }
+  ketLine += ">";
+  if (el.children && el.children.length > 0) {
+    const hasComplexChildren = el.children.some(
+      (c) => c.tag && c.tag !== "variable" && (c.children?.length > 0 || c.tag === "subroutine")
+    );
+    if (!hasComplexChildren) {
+      let inlineContent = "";
+      for (const child of el.children) {
+        if (!child.tag || child.tag === "") {
+          inlineContent += child.text || "";
+        } else if (child.tag === "variable") {
+          const varName = child.attributes?.name || "";
+          inlineContent += `|variable name=${varName}>`;
+        } else {
+          inlineContent += `|${child.tag}>`;
+        }
+      }
+      lines.push(ketLine + inlineContent);
+    } else {
+      lines.push(ketLine);
+      for (const child of el.children) {
+        serializeElementToBraKet(child, lines, indent + 1);
+      }
+    }
+  } else {
+    lines.push(ketLine);
+  }
+}
+export {
+  serializeSubroutineForTraining,
+  serializeSubroutineToBraKet,
+  serializeSubroutineToXML
+};