@dylanrussell/agent-router 1.0.6 → 1.0.7

package/dist/plugin.js

@@ -14705,8 +14705,300 @@ async function resolvePathsWithConfig(options = {}) {
 import { existsSync as existsSync2 } from "fs";
 import { readFile as readFile2, readdir } from "fs/promises";
 import path3 from "path";
+
+// src/core/yaml-lite.ts
+var RESERVED_WORDS = /* @__PURE__ */ new Set([
+  "null",
+  "true",
+  "false",
+  "yes",
+  "no",
+  "on",
+  "off",
+  "~",
+  // YAML 1.1 nulls
+  "Null",
+  "NULL",
+  "True",
+  "False",
+  "Yes",
+  "No",
+  "On",
+  "Off"
+]);
+var BARE_STRING_RE = /^[A-Za-z0-9._\-\/+@$%^&()~]+$/;
+function needsQuoting(s) {
+  if (s === "") return true;
+  if (RESERVED_WORDS.has(s)) return true;
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(s)) return true;
+  if (/^0x[0-9A-Fa-f]+$/.test(s)) return true;
+  if (/^[+-]?\.(inf|Inf|INF|nan|NaN|NAN)$/.test(s)) return true;
+  if (!BARE_STRING_RE.test(s)) return true;
+  return false;
+}
+function serializeOptionValue(value) {
+  if (value === null || value === void 0) return "null";
+  if (typeof value === "boolean") return value ? "true" : "false";
+  if (typeof value === "number") {
+    if (!Number.isFinite(value)) return String(value);
+    return JSON.stringify(value);
+  }
+  if (typeof value === "bigint") return String(value);
+  if (typeof value === "string") return needsQuoting(value) ? JSON.stringify(value) : value;
+  return JSON.stringify(value);
+}
+function stripComment(line) {
+  let inSingle = false;
+  let inDouble = false;
+  for (let i = 0; i < line.length; i++) {
+    const ch = line[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (ch === "#" && !inSingle && !inDouble) {
+      if (i === 0 || /\s/.test(line[i - 1] ?? "")) return line.slice(0, i);
+    }
+  }
+  return line;
+}
+function tokenize(block) {
+  const out = [];
+  for (const raw of block.split(/\r?\n/)) {
+    if (raw.trim() === "") continue;
+    const indentMatch = /^( *)/.exec(raw);
+    const indent = indentMatch?.[1]?.length ?? 0;
+    const content = stripComment(raw.slice(indent));
+    if (content.trim() === "") continue;
+    out.push({ indent, text: content.trimEnd(), raw });
+  }
+  return out;
+}
+function coerceScalar(raw) {
+  const v = raw.trim();
+  if (v === "" || v === "null" || v === "~" || v === "Null" || v === "NULL") return null;
+  if (v === "true" || v === "True" || v === "TRUE") return true;
+  if (v === "false" || v === "False" || v === "FALSE") return false;
+  if (v === "yes" || v === "Yes" || v === "YES") return true;
+  if (v === "no" || v === "No" || v === "NO") return false;
+  if (v === "on" || v === "On" || v === "ON") return true;
+  if (v === "off" || v === "Off" || v === "OFF") return false;
+  if (/^[+-]?\d+$/.test(v)) return Number.parseInt(v, 10);
+  if (/^[+-]?(\d+\.?\d*|\.\d+)([eE][+-]?\d+)?$/.test(v)) return Number.parseFloat(v);
+  if (/^0x[0-9A-Fa-f]+$/.test(v)) return Number.parseInt(v, 16);
+  return v;
+}
+function parseQuoted(s) {
+  const quote = s[0] ?? "";
+  if (quote !== '"' && quote !== "'") return null;
+  if (quote === '"') {
+    let out2 = "";
+    for (let i = 1; i < s.length; i++) {
+      const ch = s[i] ?? "";
+      if (ch === "\\" && i + 1 < s.length) {
+        const next = s[i + 1] ?? "";
+        const map2 = {
+          n: "\n",
+          t: "	",
+          r: "\r",
+          '"': '"',
+          "\\": "\\",
+          "/": "/",
+          b: "\b",
+          f: "\f"
+        };
+        out2 += map2[next] ?? next;
+        i++;
+      } else if (ch === '"') {
+        return { value: out2, rest: s.slice(i + 1) };
+      } else {
+        out2 += ch;
+      }
+    }
+    return null;
+  }
+  let out = "";
+  for (let i = 1; i < s.length; i++) {
+    const ch = s[i] ?? "";
+    if (ch === "'") {
+      if (s[i + 1] === "'") {
+        out += "'";
+        i++;
+      } else {
+        return { value: out, rest: s.slice(i + 1) };
+      }
+    } else {
+      out += ch;
+    }
+  }
+  return null;
+}
+function splitFlow(raw) {
+  const parts = [];
+  let depth = 0;
+  let inSingle = false;
+  let inDouble = false;
+  let start = 0;
+  for (let i = 0; i < raw.length; i++) {
+    const ch = raw[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (ch === "{" || ch === "[") depth++;
+      else if (ch === "}" || ch === "]") depth--;
+      else if (ch === "," && depth === 0) {
+        parts.push(raw.slice(start, i));
+        start = i + 1;
+      }
+    }
+  }
+  parts.push(raw.slice(start));
+  return parts;
+}
+function parseFlowValue(raw) {
+  const s = raw.trim();
+  if (s === "") return null;
+  const first = s[0] ?? "";
+  if (first === "{") {
+    const inner = s.slice(1, s.length - 1);
+    const obj = {};
+    for (const part of splitFlow(inner)) {
+      const t = part.trim();
+      if (t === "") continue;
+      const colon = findColon(t);
+      if (colon < 0) {
+        obj[t] = null;
+      } else {
+        const k = t.slice(0, colon).trim();
+        const v = t.slice(colon + 1).trim();
+        obj[stripKeyQuotes(k)] = parseFlowValue(v);
+      }
+    }
+    return obj;
+  }
+  if (first === "[") {
+    const inner = s.slice(1, s.length - 1);
+    return splitFlow(inner).filter((p) => p.trim() !== "").map((p) => parseFlowValue(p));
+  }
+  if (first === '"' || first === "'") {
+    const q = parseQuoted(s);
+    return q ? q.value : s;
+  }
+  return coerceScalar(s);
+}
+function findColon(s) {
+  let inSingle = false;
+  let inDouble = false;
+  let depth = 0;
+  for (let i = 0; i < s.length; i++) {
+    const ch = s[i];
+    if (ch === "'" && !inDouble) inSingle = !inSingle;
+    else if (ch === '"' && !inSingle) inDouble = !inDouble;
+    else if (!inSingle && !inDouble) {
+      if (ch === "{" || ch === "[") depth++;
+      else if (ch === "}" || ch === "]") depth--;
+      else if (ch === ":" && depth === 0) return i;
+    }
+  }
+  return -1;
+}
+function stripKeyQuotes(k) {
+  if (k.length >= 2 && (k[0] === '"' && k.at(-1) === '"' || k[0] === "'" && k.at(-1) === "'")) {
+    return k.slice(1, -1);
+  }
+  return k;
+}
+function parseMapping(lines, startIdx, indent) {
+  const out = {};
+  let i = startIdx;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line) break;
+    if (line.indent < indent) break;
+    if (line.indent > indent) {
+      i++;
+      continue;
+    }
+    const colon = findColon(line.text);
+    if (colon < 0) {
+      i++;
+      continue;
+    }
+    const key = stripKeyQuotes(line.text.slice(0, colon).trim());
+    if (key === "") {
+      i++;
+      continue;
+    }
+    const rest = line.text.slice(colon + 1).trim();
+    if (rest !== "") {
+      out[key] = parseFlowValue(rest);
+      i++;
+    } else {
+      const childIndent = lines[i + 1]?.indent ?? line.indent + 1;
+      let j = i + 1;
+      while (j < lines.length && (lines[j]?.indent ?? -1) >= childIndent) j++;
+      if (j === i + 1) {
+        out[key] = null;
+        i++;
+      } else {
+        const childBlock = lines.slice(i + 1, j);
+        const firstChild = childBlock[0];
+        if (firstChild?.text.trimStart().startsWith("- ")) {
+          out[key] = parseSequence(childBlock, childIndent);
+        } else {
+          out[key] = parseMapping(childBlock, 0, childIndent).value;
+        }
+        i = j;
+      }
+    }
+  }
+  return { value: out, next: i };
+}
+function parseSequence(lines, indent) {
+  const out = [];
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (!line) break;
+    if (line.indent < indent) break;
+    const t = line.text.trimStart();
+    if (!t.startsWith("- ")) {
+      i++;
+      continue;
+    }
+    const item = t.slice(2).trim();
+    if (item === "") {
+      const childIndent = lines[i + 1]?.indent ?? line.indent + 1;
+      let j = i + 1;
+      while (j < lines.length && (lines[j]?.indent ?? -1) >= childIndent) j++;
+      out.push(parseMapping(lines.slice(i + 1, j), 0, childIndent).value);
+      i = j;
+    } else {
+      out.push(parseFlowValue(item));
+      i++;
+    }
+  }
+  return out;
+}
+function parseFrontmatterBlock(block) {
+  const lines = tokenize(block);
+  if (lines.length === 0) return null;
+  const { value } = parseMapping(lines, 0, 0);
+  return value;
+}
+
+// src/core/frontmatter.ts
 var FRONTMATTER_RE = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n|$)/;
 var MODEL_LINE_RE = /^model:[ \t]*(.*)$/m;
+var RESERVED_AGENT_KEYS = /* @__PURE__ */ new Set([
+  "name",
+  "mode",
+  "description",
+  "permission",
+  "color",
+  "tools",
+  "prompt",
+  "steps",
+  "maxSteps"
+]);
 function cleanModelValue(raw) {
   let v = raw;
   const hash2 = v.search(/[ \t]#/);
@@ -14735,6 +15027,55 @@ function setFrontmatterModel(content, model) {
   const nextFm = fm[0].slice(0, blockStart) + nextBlock + fm[0].slice(blockStart + block.length);
   return nextFm + content.slice(fm[0].length);
 }
+function getFrontmatterOptions(content) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) return {};
+  const parsed = parseFrontmatterBlock(fm[1]);
+  if (!parsed) return {};
+  const out = {};
+  for (const [k, v] of Object.entries(parsed)) {
+    if (k === "model" || RESERVED_AGENT_KEYS.has(k)) continue;
+    out[k] = v;
+  }
+  return out;
+}
+function setFrontmatterOptions(content, options) {
+  const fm = FRONTMATTER_RE.exec(content);
+  if (!fm?.[1]) throw new Error("no frontmatter block");
+  const block = fm[1];
+  const keys = Object.keys(options);
+  if (keys.length === 0) return content;
+  const eol = block.includes("\r\n") ? "\r\n" : "\n";
+  const lines = block.split(/\r?\n/);
+  const handled = /* @__PURE__ */ new Set();
+  for (let i = 0; i < lines.length; i++) {
+    const m = /^([A-Za-z0-9_-]+):[ \t]*(.*)$/.exec(lines[i] ?? "");
+    if (!m) continue;
+    const key = m[1] ?? "";
+    if (!(key in options)) continue;
+    handled.add(key);
+    let end = i + 1;
+    while (end < lines.length && /^[ \t]+/.test(lines[end] ?? "")) end++;
+    const value = options[key];
+    if (value === null || value === void 0) {
+      lines.splice(i, end - i);
+      i--;
+    } else {
+      lines.splice(i, end - i, `${key}: ${serializeOptionValue(value)}`);
+    }
+  }
+  const appended = [];
+  for (const [key, value] of Object.entries(options)) {
+    if (handled.has(key)) continue;
+    if (value === null || value === void 0) continue;
+    appended.push(`${key}: ${serializeOptionValue(value)}`);
+  }
+  const nextBlock = appended.length > 0 ? lines.join(eol) + eol + appended.join(eol) : lines.join(eol);
+  if (nextBlock === block) return content;
+  const blockStart = fm[0].indexOf(block);
+  const nextFm = fm[0].slice(0, blockStart) + nextBlock + fm[0].slice(blockStart + block.length);
+  return nextFm + content.slice(fm[0].length);
+}
 function agentFilePath(agentsDir, name) {
   return path3.join(agentsDir, `${name}.md`);
 }
@@ -14748,7 +15089,7 @@ async function listAgentFiles(agentsDir) {
   }
   return names.filter((n) => n.endsWith(".md")).map((n) => n.slice(0, -".md".length)).sort();
 }
-async function readAgentModels(agentsDir) {
+async function readAgentEntries(agentsDir) {
   const out = {};
   for (const name of await listAgentFiles(agentsDir)) {
     const filePath = agentFilePath(agentsDir, name);
@@ -14759,10 +15100,17 @@ async function readAgentModels(agentsDir) {
       throw new IOError(`Failed to read ${filePath}: ${cause.message}`, cause);
     }
     const model = getFrontmatterModel(content);
-    if (model !== null) out[name] = model;
+    if (model === null) continue;
+    out[name] = { model, options: getFrontmatterOptions(content) };
   }
   return out;
 }
+async function readAgentModels(agentsDir) {
+  const entries = await readAgentEntries(agentsDir);
+  const out = {};
+  for (const [name, entry] of Object.entries(entries)) out[name] = entry.model;
+  return out;
+}
 async function readAgentFileStrict(agentsDir, name) {
   const filePath = agentFilePath(agentsDir, name);
   if (!existsSync2(filePath)) {
@@ -14778,7 +15126,7 @@ async function readAgentFileStrict(agentsDir, name) {
   if (model === null) {
     throw new AgentFileError(name, filePath, "no frontmatter `model:` line to rewrite");
   }
-  return { filePath, content, model };
+  return { filePath, content, model, options: getFrontmatterOptions(content) };
 }
 
 // src/core/stack-manager.ts
@@ -15036,15 +15384,14 @@ async function applyStack(paths, name, options = {}) {
   const pending = [];
   for (const [agent, entry] of Object.entries(target.agents)) {
     const { filePath, content, model } = await readAgentFileStrict(paths.agentsDir, agent);
-    pending.push({
-      agent,
-      filePath,
-      next: model === entry.model ? null : setFrontmatterModel(content, entry.model)
-    });
+    const wantOptions = entryOptions(entry);
+    const afterOptions = setFrontmatterOptions(content, wantOptions);
+    const nextContent = entry.model === model ? afterOptions : setFrontmatterModel(afterOptions, entry.model);
+    pending.push({ agent, filePath, next: nextContent === content ? null : nextContent });
   }
   const prevState = await readState(paths.statePath);
   const prevActive = prevState?.active ?? null;
-  const displaced = { agents: modelsToStackAgents(await readAgentModels(paths.agentsDir)) };
+  const displaced = { agents: entriesToStackAgents(await readAgentEntries(paths.agentsDir)) };
   const historyId = await appendHistory(
     paths.historyDir,
     prevActive ?? "(none)",
@@ -15074,11 +15421,24 @@ async function applyStack(paths, name, options = {}) {
     restartRequired: true
   };
 }
-function modelsToStackAgents(models) {
+function entryOptions(entry) {
+  const rec = entry;
+  const out = {};
+  for (const [k, v] of Object.entries(rec)) {
+    if (k === "model" || RESERVED_AGENT_KEYS.has(k)) continue;
+    out[k] = v;
+  }
+  return out;
+}
+function entriesToStackAgents(entries) {
   const out = {};
-  for (const k of Object.keys(models).sort()) {
-    const model = models[k];
-    if (model !== void 0) out[k] = { model };
+  for (const name of Object.keys(entries).sort()) {
+    const entry = entries[name];
+    if (!entry) continue;
+    const { model, options } = entry;
+    const stackEntry = { model };
+    for (const [k, v] of Object.entries(options)) stackEntry[k] = v;
+    out[name] = stackEntry;
   }
   return out;
 }
@@ -15115,8 +15475,8 @@ async function captureStack(paths, name, options = {}) {
   if (existsSync5(dest) && !options.force) {
     throw new UserError(`Stack "${name}" already exists. Use --force to overwrite.`);
   }
-  const models = await readAgentModels(paths.agentsDir);
-  const agents = modelsToStackAgents(models);
+  const entries = await readAgentEntries(paths.agentsDir);
+  const agents = entriesToStackAgents(entries);
   if (Object.keys(agents).length === 0) {
     throw new UserError(
       `No agent .md files with a frontmatter \`model:\` line found in ${paths.agentsDir}.`
@@ -15128,7 +15488,7 @@ async function captureStack(paths, name, options = {}) {
 }
 
 // src/version.ts
-var VERSION = "1.0.6";
+var VERSION = "1.0.7";
 
 // src/plugin.ts
 async function safeToast(client, message, variant = "success") {