@dot-agent/compiler 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1059 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  aboutmeToJson: () => aboutmeToJson,
+  buildAboutme: () => buildAboutme,
+  buildId: () => buildId,
+  collectFiles: () => collectFiles,
+  createLinter: () => createLinter,
+  createZip: () => createZip,
+  extractDigest: () => extractDigest,
+  extractFiles: () => extractFiles,
+  extractName: () => extractName,
+  getBehaviorScxml: () => getBehaviorScxml,
+  getContextNode: () => getContextNode,
+  initBehaviorParser: () => initBehaviorParser,
+  initParsers: () => initParsers,
+  lintBehavior: () => lintBehavior,
+  lintDescription: () => lintDescription,
+  nodeAtOffset: () => nodeAtOffset,
+  nodeToRange: () => nodeToRange,
+  nodesOfType: () => nodesOfType,
+  pack: () => pack,
+  parse: () => parse,
+  parseAboutme: () => parseAboutme,
+  parseBehaviorFile: () => parseBehaviorFile,
+  parseDescriptionFile: () => parseDescriptionFile,
+  parseId: () => parseId,
+  parseSync: () => parseSync,
+  positionToOffset: () => positionToOffset,
+  readZip: () => readZip,
+  validateMagicBytes: () => validateMagicBytes,
+  validateZipBomb: () => validateZipBomb,
+  writeZip: () => writeZip
+});
+module.exports = __toCommonJS(index_exports);
+
+// ../../node_modules/tsup/assets/cjs_shims.js
+var getImportMetaUrl = () => typeof document === "undefined" ? new URL(`file:${__filename}`).href : document.currentScript && document.currentScript.tagName.toUpperCase() === "SCRIPT" ? document.currentScript.src : new URL("main.js", document.baseURI).href;
+var importMetaUrl = /* @__PURE__ */ getImportMetaUrl();
+
+// src/parser.ts
+var import_module = require("module");
+var import_web_tree_sitter = require("web-tree-sitter");
+var import_parser_dsl = __toESM(require("@dot-agent/parser-dsl"), 1);
+var require2 = (0, import_module.createRequire)(importMetaUrl);
+var { descriptionWasmPath, behaviorWasmPath } = require2("@dot-agent/tree-sitter");
+var _initialized = false;
+var _descriptionParser;
+var _behaviorParser;
+var _bpInitialized = false;
+async function initBehaviorParser() {
+  if (_bpInitialized) return;
+  await (0, import_parser_dsl.default)();
+  _bpInitialized = true;
+}
+function parseBehaviorFile(text) {
+  return JSON.parse((0, import_parser_dsl.parse_behavior)(text));
+}
+function parseDescriptionFile(text) {
+  return JSON.parse((0, import_parser_dsl.parse_description)(text));
+}
+function getBehaviorScxml(text) {
+  return (0, import_parser_dsl.get_graph)(text);
+}
+async function initParsers() {
+  if (_initialized) return;
+  await import_web_tree_sitter.Parser.init();
+  const descriptionLang = await import_web_tree_sitter.Language.load(descriptionWasmPath);
+  const behaviorLang = await import_web_tree_sitter.Language.load(behaviorWasmPath);
+  _descriptionParser = new import_web_tree_sitter.Parser();
+  _descriptionParser.setLanguage(descriptionLang);
+  _behaviorParser = new import_web_tree_sitter.Parser();
+  _behaviorParser.setLanguage(behaviorLang);
+  _initialized = true;
+}
+async function parse(langId, text, previousTree) {
+  await initParsers();
+  const parser = langId === "behavior" ? _behaviorParser : _descriptionParser;
+  return parser.parse(text, previousTree);
+}
+function parseSync(langId, text, previousTree) {
+  if (!_initialized) return null;
+  const parser = langId === "behavior" ? _behaviorParser : _descriptionParser;
+  return parser.parse(text, previousTree);
+}
+function nodesOfType(tree, type) {
+  if (!tree) return [];
+  return tree.rootNode.descendantsOfType(type).filter((n) => n !== null);
+}
+function nodeAtOffset(tree, offset) {
+  if (!tree) return null;
+  return tree.rootNode.descendantForIndex(offset);
+}
+function nodeToRange(node) {
+  return {
+    start: { line: node.startPosition.row, character: node.startPosition.column },
+    end: { line: node.endPosition.row, character: node.endPosition.column }
+  };
+}
+function positionToOffset(text, line, character) {
+  let offset = 0;
+  for (let i = 0; i < line; i++) {
+    const nl = text.indexOf("\n", offset);
+    offset = nl === -1 ? text.length : nl + 1;
+  }
+  return offset + character;
+}
+function getContextNode(tree, offset) {
+  let node = nodeAtOffset(tree, offset);
+  while (node && (node.isError || node.isMissing)) {
+    node = node.parent;
+  }
+  if (!node || node.type === "ERROR") {
+    const raw = nodeAtOffset(tree, offset);
+    const parent = raw?.parent;
+    if (parent) {
+      const siblings = parent.children;
+      const idx = siblings.findIndex((c) => c !== null && c.startIndex > offset);
+      const prev = idx > 0 ? siblings[idx - 1] : siblings[siblings.length - 1];
+      if (prev && !prev.isError) node = prev;
+    }
+  }
+  return node ?? tree.rootNode;
+}
+
+// src/linter.ts
+var import_fs = require("fs");
+var import_path = require("path");
+function nodePosition(node) {
+  return { line: node.startPosition.row + 1, col: node.startPosition.column + 1 };
+}
+var MISSING_HINTS = {
+  interact_stmt: "Missing 'interact' \u2014 oriented states require 'goal \u2026 interact \u2026 on intent \u2026 on offtopic'.",
+  offtopic_handler: "Missing 'on offtopic' handler \u2014 every state with 'interact' must handle the offtopic case.",
+  intent_handler: "Missing at least one 'on intent' handler after 'interact'.",
+  goal_stmt: "Missing 'goal' \u2014 every state with 'interact' must declare a goal.",
+  state_name: "Missing state name after 'state' keyword.",
+  quoted_string: "Missing quoted string \u2014 expected a value in double quotes."
+};
+function collectSyntaxErrors(root, messages, file) {
+  const seen = /* @__PURE__ */ new Set();
+  function push(node, message, code, severity = "error") {
+    const key = `${node.startIndex}:${node.endIndex}:${message}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    const { line, col } = nodePosition(node);
+    messages.push({ file, line, col, severity, code, message });
+  }
+  function walk(node) {
+    if (node.isMissing) {
+      const hint = MISSING_HINTS[node.type];
+      push(node, hint ?? `Syntax error: missing '${node.type}'.`, "E004");
+      return;
+    }
+    if (node.type === "ERROR") {
+      const hasNestedError = node.descendantsOfType("ERROR").some((e) => e !== null && e.id !== node.id);
+      if (!hasNestedError) {
+        const snippet = node.text.replace(/\s+/g, " ").trim().slice(0, 40);
+        push(node, snippet ? `Syntax error near '${snippet}'.` : "Syntax error.", "E004");
+        return;
+      }
+    }
+    for (const child of node.children) {
+      if (child) walk(child);
+    }
+  }
+  walk(root);
+}
+var STRICT_BLOCK_TYPES = {
+  input_block: "input",
+  output_block: "output",
+  requires_block: "requires",
+  capabilities_block: "capabilities"
+};
+async function lintDescription(text, file = "agent.description") {
+  const tree = await parse("description", text);
+  const messages = [];
+  collectSyntaxErrors(tree.rootNode, messages, file);
+  for (const metaNode of nodesOfType(tree, "agent_meta")) {
+    const keyNode = metaNode.childForFieldName("key");
+    if (keyNode?.text !== "domain") continue;
+    const valueNode = metaNode.childForFieldName("value");
+    if (valueNode?.text === "example.com") {
+      const { line, col } = nodePosition(valueNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "W003",
+        message: 'domain still has default value "example.com"'
+      });
+    }
+  }
+  const hasDomain = nodesOfType(tree, "agent_meta").some(
+    (n) => n.childForFieldName("key")?.text === "domain" && n.childForFieldName("value")?.text?.trim()
+  );
+  if (!hasDomain) {
+    messages.push({
+      file,
+      line: 1,
+      col: 1,
+      severity: "warning",
+      code: "W007",
+      message: "No domain declared \u2014 agent will be packaged as unknown/name. Interoperability between runtimes is not guaranteed."
+    });
+  }
+  const declaredTypes = new Set(
+    nodesOfType(tree, "type_decl").map((n) => n.childForFieldName("name")?.text).filter(Boolean)
+  );
+  if (declaredTypes.size > 0) {
+    for (const blockType of Object.keys(STRICT_BLOCK_TYPES)) {
+      for (const blockNode of nodesOfType(tree, blockType)) {
+        for (const typeRefNode of blockNode.descendantsOfType("type_reference").filter((n) => n !== null)) {
+          const idNode = typeRefNode.firstNamedChild;
+          if (!idNode) continue;
+          const typeName = idNode.text;
+          if (!declaredTypes.has(typeName)) {
+            const { line, col } = nodePosition(idNode);
+            messages.push({
+              file,
+              line,
+              col,
+              severity: "warning",
+              code: "W004",
+              message: `Type '${typeName}' is not declared in this file (assuming native or external).`
+            });
+          }
+        }
+      }
+    }
+  }
+  return messages;
+}
+function levenshtein(a, b) {
+  const la = a.length, lb = b.length;
+  const dp = Array.from(
+    { length: la + 1 },
+    (_, i) => Array.from({ length: lb + 1 }, (_2, j) => i === 0 ? j : j === 0 ? i : 0)
+  );
+  for (let i = 1; i <= la; i++) {
+    for (let j = 1; j <= lb; j++) {
+      dp[i][j] = a[i - 1] === b[j - 1] ? dp[i - 1][j - 1] : 1 + Math.min(dp[i - 1][j], dp[i][j - 1], dp[i - 1][j - 1]);
+    }
+  }
+  return dp[la][lb];
+}
+function closestName(token, candidates) {
+  let best;
+  let bestDist = Infinity;
+  for (const name of candidates) {
+    const d = levenshtein(token.toLowerCase(), name.toLowerCase());
+    if (d > 0 && d <= 2 && d < bestDist) {
+      bestDist = d;
+      best = name;
+    }
+  }
+  return best;
+}
+var KERNEL_LIFECYCLE_NAMES = ["init", "welcome", "end", "online", "offline"];
+function collectTransitionTargets(stmts) {
+  const targets = [];
+  for (const stmt of stmts) {
+    if (!stmt || typeof stmt !== "object") continue;
+    if (stmt.type === "transition_stmt" && typeof stmt["state"] === "string") {
+      targets.push(stmt["state"]);
+    }
+    if (stmt.type === "intent_handler" && typeof stmt["body"] === "string") {
+      targets.push(stmt["body"]);
+    }
+    const recurse = (v) => {
+      if (Array.isArray(v)) targets.push(...collectTransitionTargets(v));
+    };
+    if (stmt.type !== "intent_handler") recurse(stmt["body"]);
+    recurse(stmt["handlers"]);
+    recurse(stmt["then"]);
+    recurse(stmt["else"]);
+    recurse(stmt["on_complete"]);
+    recurse(stmt["on_failure"]);
+  }
+  return targets;
+}
+function collectMergedStates(tree, docDir, states, visited = /* @__PURE__ */ new Set()) {
+  for (const mergeNode of nodesOfType(tree, "merge_decl")) {
+    const pathNode = mergeNode.childForFieldName("path");
+    if (!pathNode) continue;
+    const filename = pathNode.text.replace(/^"|"$/g, "");
+    const absPath = (0, import_path.resolve)(docDir, filename);
+    if (visited.has(absPath)) continue;
+    visited.add(absPath);
+    let mergedText;
+    try {
+      mergedText = (0, import_fs.readFileSync)(absPath, "utf-8");
+    } catch {
+      continue;
+    }
+    const mergedTree = parseSync("behavior", mergedText);
+    if (!mergedTree) continue;
+    nodesOfType(mergedTree, "state_decl").forEach((n) => {
+      const name = n.childForFieldName("name")?.text;
+      if (name) states.add(name);
+    });
+    collectMergedStates(mergedTree, (0, import_path.dirname)(absPath), states, visited);
+  }
+}
+async function lintBehavior(text, file = "agent.behavior", docPath) {
+  await initBehaviorParser();
+  if (!text.endsWith("\n")) text = text + "\n";
+  const tree = await parse("behavior", text);
+  const messages = [];
+  collectSyntaxErrors(tree.rootNode, messages, file);
+  for (const stateNode of nodesOfType(tree, "state_decl")) {
+    if (stateNode.hasError) continue;
+    const nameNode = stateNode.childForFieldName("name");
+    const stateName = nameNode?.text ?? "?";
+    const hasInteract = stateNode.descendantsOfType("interact_stmt").length > 0;
+    const hasGoal = stateNode.descendantsOfType("goal_stmt").length > 0;
+    const intentHandlers = stateNode.descendantsOfType("intent_handler");
+    if (hasInteract && !hasGoal) {
+      const { line, col } = nodePosition(nameNode ?? stateNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "W013",
+        message: `'interact' without 'goal' \u2014 the prettifier will insert one. To set it explicitly, add 'goal "..."' before 'interact'.`
+      });
+    }
+    if (hasGoal && !hasInteract) {
+      const { line, col } = nodePosition(nameNode ?? stateNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "W012",
+        message: `'goal' is only valid in an oriented state. Add 'interact' or remove 'goal' \u2014 the prettifier can adjust this.`
+      });
+    }
+    if (hasInteract && intentHandlers.length === 0) {
+      const { line, col } = nodePosition(nameNode ?? stateNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "error",
+        code: "E009",
+        message: `Oriented state '${stateName}' has no 'on intent' handlers. At least one is required.`
+      });
+    }
+    const seenIntents = /* @__PURE__ */ new Map();
+    for (const handler of intentHandlers) {
+      const intentNode = handler.childForFieldName("intent");
+      if (!intentNode) continue;
+      const label = intentNode.text.replace(/^"|"$/g, "");
+      if (seenIntents.has(label)) {
+        const { line, col } = nodePosition(handler);
+        messages.push({
+          file,
+          line,
+          col,
+          severity: "error",
+          code: "W008",
+          message: `Duplicate 'on intent "${label}"' in state '${stateName}'. The FSM cannot route ambiguous intents \u2014 use a unique label for each handler.`
+        });
+      } else {
+        seenIntents.set(label, true);
+      }
+    }
+    for (const handler of intentHandlers) {
+      for (const t of handler.descendantsOfType("transition_stmt")) {
+        const targetNode = t.childForFieldName("state");
+        if (targetNode?.text === stateName) {
+          const { line, col } = nodePosition(handler);
+          messages.push({
+            file,
+            line,
+            col,
+            severity: "warning",
+            code: "W011",
+            message: `'on intent' handler in state '${stateName}' transitions back to itself. The user expressed an intent but receives no progress \u2014 did you mean a different target state?`
+          });
+        }
+      }
+    }
+    if (stateName === "init" || stateName === "end") {
+      const { line, col } = nodePosition(nameNode ?? stateNode);
+      if (stateName === "init") {
+        messages.push({
+          file,
+          line,
+          col,
+          severity: "info",
+          code: "I001",
+          message: `State 'init' overrides the kernel's default entry lifecycle. The kernel will use this definition instead of its built-in init sequence.`
+        });
+      } else {
+        messages.push({
+          file,
+          line,
+          col,
+          severity: "info",
+          code: "I002",
+          message: `State 'end' overrides the kernel's default terminal lifecycle. The kernel will treat this state as the canonical exit point.`
+        });
+      }
+    }
+    if (!KERNEL_LIFECYCLE_NAMES.includes(stateName)) {
+      const closest = closestName(stateName, KERNEL_LIFECYCLE_NAMES);
+      if (closest) {
+        const { line, col } = nodePosition(nameNode ?? stateNode);
+        messages.push({
+          file,
+          line,
+          col,
+          severity: "hint",
+          code: "H001",
+          message: `State name '${stateName}' resembles the kernel lifecycle name '${closest}'. If this is intentional, ignore this hint.`
+        });
+      }
+    }
+  }
+  for (const parallelNode of nodesOfType(tree, "parallel_stmt")) {
+    if (parallelNode.hasError) continue;
+    if (parallelNode.descendantsOfType("run_stmt").length === 0) {
+      const { line, col } = nodePosition(parallelNode);
+      let stateName = "?";
+      let ancestor = parallelNode.parent;
+      while (ancestor && ancestor.type !== "state_decl") ancestor = ancestor.parent;
+      if (ancestor) stateName = ancestor.childForFieldName("name")?.text ?? "?";
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "E010",
+        message: `'parallel' block in state '${stateName}' has no 'run' statements and does nothing.`
+      });
+    }
+  }
+  for (const afterNode of nodesOfType(tree, "after_stmt")) {
+    if (afterNode.hasError) continue;
+    const countNode = afterNode.childForFieldName("count");
+    if (countNode?.text === "0") {
+      const { line, col } = nodePosition(countNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "error",
+        code: "E011",
+        message: `'after 0' is invalid \u2014 prompts must be \u2265 1. Use 'after 1' for the next prompt.`
+      });
+    }
+  }
+  for (const stmtNode of nodesOfType(tree, "goal_stmt")) {
+    const strNode = stmtNode.descendantsOfType("quoted_string").find((n) => n !== null);
+    if (!strNode) continue;
+    const content = strNode.text.replace(/^"|"$/g, "");
+    if (content.length > 280) {
+      const { line, col } = nodePosition(strNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "W002",
+        message: `Text block exceeds 280 characters (${content.length}). Consider using 'teach' to load long goal text from an external file.`
+      });
+    }
+  }
+  for (const stmtNode of nodesOfType(tree, "guide_stmt")) {
+    const strNode = stmtNode.descendantsOfType("quoted_string").find((n) => n !== null);
+    if (!strNode) continue;
+    const content = strNode.text.replace(/^"|"$/g, "");
+    if (content.length > 280) {
+      const { line, col } = nodePosition(strNode);
+      let p = stmtNode.parent;
+      while (p && p.type !== "state_decl") p = p.parent;
+      const stateName = p?.childForFieldName("name")?.text ?? "?";
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "W010",
+        message: `'guide' text in state '${stateName}' is ${content.length} characters (limit: 280). Consider using an external file.`
+      });
+    }
+  }
+  const definedStates = new Set(
+    nodesOfType(tree, "state_decl").map((n) => n.childForFieldName("name")?.text).filter(Boolean)
+  );
+  if (docPath) {
+    try {
+      collectMergedStates(tree, (0, import_path.dirname)(docPath), definedStates);
+    } catch {
+    }
+  }
+  const stateNameList = Array.from(definedStates);
+  for (const transitionNode of nodesOfType(tree, "transition_stmt")) {
+    const stateNode = transitionNode.childForFieldName("state");
+    if (!stateNode) continue;
+    const target = stateNode.text;
+    if (!definedStates.has(target)) {
+      const { line, col } = nodePosition(stateNode);
+      const isExternal = target.includes(".");
+      const hint = !isExternal ? closestName(target, stateNameList) : void 0;
+      messages.push({
+        file,
+        line,
+        col,
+        severity: isExternal ? "warning" : "error",
+        code: isExternal ? "W005" : "E005",
+        message: isExternal ? `State '${target}' is not defined locally (assuming external flow reference).` : `State '${target}' is not defined in this file.`,
+        ...hint ? { hint: `did you mean '${hint}'?` } : {}
+      });
+    }
+  }
+  for (const interactNode of nodesOfType(tree, "interact_stmt")) {
+    let ancestor = interactNode.parent;
+    while (ancestor && ancestor.type !== "state_decl") ancestor = ancestor.parent;
+    if (!ancestor) continue;
+    const hasHandlers = ancestor.descendantsOfType("intent_handler").length + ancestor.descendantsOfType("offtopic_handler").length > 0;
+    if (!hasHandlers) {
+      const { line, col } = nodePosition(interactNode);
+      messages.push({
+        file,
+        line,
+        col,
+        severity: "warning",
+        code: "W006",
+        message: "This state calls interact but has no handlers (on intent/offtopic). This will trap the agent."
+      });
+    }
+  }
+  const fsmResult = parseBehaviorFile(text);
+  if (fsmResult.ok === null) {
+    const firstMsg = fsmResult.diagnostics[0]?.message ?? "Parse error";
+    messages.push({
+      file,
+      line: 1,
+      col: 1,
+      severity: "error",
+      code: "E006",
+      message: `Parse error: ${firstMsg}`
+    });
+    return messages;
+  }
+  const fsm = fsmResult.ok;
+  const allTargets = new Set(collectTransitionTargets(fsm.states.flatMap((s) => s.body)));
+  for (const state of fsm.states) {
+    const hasOutgoing = collectTransitionTargets(state.body).length > 0;
+    const hasIncoming = allTargets.has(state.name);
+    if (!hasIncoming && !hasOutgoing) {
+      messages.push({
+        file,
+        line: 1,
+        col: 1,
+        severity: "warning",
+        code: "W001",
+        message: `State "${state.name}" has no transitions`
+      });
+    }
+  }
+  for (let i = 1; i < fsm.states.length; i++) {
+    const state = fsm.states[i];
+    if (!allTargets.has(state.name)) {
+      const stateNode = nodesOfType(tree, "state_decl").find((n) => n.childForFieldName("name")?.text === state.name);
+      const pos = stateNode ? nodePosition(stateNode) : { line: 1, col: 1 };
+      messages.push({
+        file,
+        line: pos.line,
+        col: pos.col,
+        severity: "warning",
+        code: "W009",
+        message: `State '${state.name}' is unreachable \u2014 no other state transitions to it.`
+      });
+    }
+  }
+  return messages;
+}
+async function createLinter() {
+  return { lintDescription, lintBehavior };
+}
+
+// src/manifest.ts
+function parseAboutme(json) {
+  if (!json.schemaVersion) throw new Error("Missing schemaVersion in aboutme.json");
+  if (!json.id) throw new Error("Missing id in aboutme.json");
+  if (!json.name) throw new Error("Missing name in aboutme.json");
+  if (!json.description) throw new Error("Missing description in aboutme.json");
+  if (!json.version) throw new Error("Missing version in aboutme.json");
+  if (!json.domain) throw new Error("Missing domain in aboutme.json");
+  if (!json.persona) throw new Error("Missing persona in aboutme.json");
+  if (!json.compiler) throw new Error("Missing compiler in aboutme.json");
+  if (!Array.isArray(json.capabilities)) throw new Error("Missing capabilities array in aboutme.json");
+  if (!Array.isArray(json.requires)) throw new Error("Missing requires array in aboutme.json");
+  if (!json.integrity) throw new Error("Missing integrity in aboutme.json");
+  return {
+    schemaVersion: json.schemaVersion,
+    id: json.id,
+    name: json.name,
+    description: json.description,
+    version: json.version,
+    domain: json.domain,
+    license: json.license ?? "",
+    persona: json.persona,
+    purpose: json.purpose ?? "unknown",
+    compiler: json.compiler,
+    commit: json.commit,
+    capabilities: json.capabilities,
+    requires: json.requires,
+    integrity: json.integrity
+  };
+}
+function buildAboutme(opts) {
+  return {
+    schemaVersion: "dot-agent/1.0",
+    id: opts.id,
+    name: opts.name,
+    description: opts.description,
+    version: opts.version,
+    domain: opts.domain,
+    license: opts.license ?? "",
+    persona: opts.persona,
+    purpose: opts.purpose ?? "unknown",
+    compiler: opts.compiler,
+    commit: opts.commit,
+    capabilities: opts.capabilities ?? [],
+    requires: opts.requires ?? [],
+    integrity: opts.integrity
+  };
+}
+function aboutmeToJson(aboutme) {
+  return JSON.stringify(aboutme, null, 2);
+}
+
+// src/id.ts
+var KNOWN_PLATFORMS = ["github.com", "gitlab.com", "codeberg.org", "sr.ht"];
+function parseNamespaceName(identifier) {
+  const atIdx = identifier.indexOf("@");
+  if (atIdx !== -1 && (identifier.indexOf("/") === -1 || atIdx < identifier.indexOf("/"))) {
+    const slashIdx = identifier.indexOf("/");
+    if (slashIdx === -1) {
+      throw new Error(`Invalid agent ID: email namespace requires a name after '/' (got '${identifier}')`);
+    }
+    return {
+      namespace: identifier.slice(0, slashIdx),
+      name: identifier.slice(slashIdx + 1)
+    };
+  }
+  for (const platform of KNOWN_PLATFORMS) {
+    if (identifier.startsWith(platform + "/")) {
+      const afterPlatform = identifier.slice(platform.length + 1);
+      const slashIdx = afterPlatform.indexOf("/");
+      if (slashIdx === -1) {
+        throw new Error(
+          `Invalid agent ID: '${platform}' namespace requires a user segment and a name (got '${identifier}')`
+        );
+      }
+      return {
+        namespace: platform + "/" + afterPlatform.slice(0, slashIdx),
+        name: afterPlatform.slice(slashIdx + 1)
+      };
+    }
+  }
+  const lastSlash = identifier.lastIndexOf("/");
+  if (lastSlash === -1) {
+    throw new Error(`Invalid agent ID: missing '/' separator in '${identifier}'`);
+  }
+  return {
+    namespace: identifier.slice(0, lastSlash),
+    name: identifier.slice(lastSlash + 1)
+  };
+}
+function parseId(id) {
+  if (!id) throw new Error("Invalid agent ID: empty string");
+  const colonIdx = id.indexOf(":");
+  let identifier;
+  let version;
+  let digest;
+  if (colonIdx === -1) {
+    identifier = id;
+  } else {
+    identifier = id.slice(0, colonIdx);
+    const rest = id.slice(colonIdx + 1);
+    if (!rest) throw new Error(`Invalid agent ID: empty version after ':' in '${id}'`);
+    const tildeIdx = rest.indexOf("~");
+    if (tildeIdx === -1) {
+      version = rest;
+    } else {
+      version = rest.slice(0, tildeIdx);
+      digest = rest.slice(tildeIdx + 1);
+      if (!version) throw new Error(`Invalid agent ID: empty version before '~' in '${id}'`);
+      if (!digest) throw new Error(`Invalid agent ID: empty digest after '~' in '${id}'`);
+    }
+  }
+  const { namespace, name } = parseNamespaceName(identifier);
+  if (!namespace) throw new Error(`Invalid agent ID: empty namespace in '${id}'`);
+  if (!name) throw new Error(`Invalid agent ID: empty name in '${id}'`);
+  return { namespace, name, version, digest };
+}
+function buildId(parts) {
+  const { namespace, name, version, digest } = parts;
+  if (!namespace || !name) {
+    throw new Error("Missing required ID parts: namespace and name");
+  }
+  if (digest && !version) {
+    throw new Error("Invalid ID parts: digest requires version");
+  }
+  let result = `${namespace}/${name}`;
+  if (version) {
+    result += `:${version}`;
+    if (digest) result += `~${digest}`;
+  }
+  return result;
+}
+function extractDigest(id) {
+  try {
+    return parseId(id).digest ?? "";
+  } catch {
+    return "";
+  }
+}
+function extractName(id) {
+  try {
+    return parseId(id).name;
+  } catch {
+    return "";
+  }
+}
+
+// src/zip.ts
+var import_jszip2 = __toESM(require("jszip"), 1);
+var import_promises = require("fs/promises");
+
+// src/zip-core.ts
+var import_jszip = __toESM(require("jszip"), 1);
+function createZip() {
+  return new import_jszip.default();
+}
+async function extractFiles(zip, filter) {
+  const files = /* @__PURE__ */ new Map();
+  const promises = [];
+  zip.forEach((relativePath, file) => {
+    if (file.dir) return;
+    if (filter && !filter.some((f) => relativePath.startsWith(f))) return;
+    promises.push(
+      file.async("text").then((content) => {
+        files.set(relativePath, content);
+      })
+    );
+  });
+  await Promise.all(promises);
+  return files;
+}
+
+// src/zip.ts
+var MAX_ZIP_SIZE = 500 * 1024 * 1024;
+var MAX_COMPRESSION_RATIO = 100;
+async function readZip(filePath) {
+  const data = await (0, import_promises.readFile)(filePath);
+  return import_jszip2.default.loadAsync(data);
+}
+async function validateZipBomb(filePath) {
+  const data = await (0, import_promises.readFile)(filePath);
+  const zip = await import_jszip2.default.loadAsync(data);
+  let totalUncompressed = 0;
+  zip.forEach((_relativePath, file) => {
+    if (!file.dir) {
+      totalUncompressed += file._data?.uncompressedSize || 0;
+    }
+  });
+  const compressedSize = data.length;
+  const ratio = totalUncompressed / compressedSize;
+  if (totalUncompressed > MAX_ZIP_SIZE) {
+    throw new Error(`ZIP uncompressed size exceeds 500MB limit: ${totalUncompressed}`);
+  }
+  if (ratio > MAX_COMPRESSION_RATIO) {
+    throw new Error(`ZIP compression ratio exceeds 100x limit: ${ratio.toFixed(1)}x`);
+  }
+  return true;
+}
+async function validateMagicBytes(filePath) {
+  const data = await (0, import_promises.readFile)(filePath);
+  const magic = data.subarray(0, 4);
+  if (!(magic[0] === 80 && magic[1] === 75 && magic[2] === 3 && magic[3] === 4)) {
+    throw new Error("File is not a valid ZIP (invalid magic bytes)");
+  }
+  return true;
+}
+async function writeZip(zip, outPath) {
+  const data = await zip.generateAsync({ type: "arraybuffer" });
+  await (0, import_promises.writeFile)(outPath, Buffer.from(data));
+}
+
+// src/pack.ts
+var import_promises2 = require("fs/promises");
+var import_path2 = require("path");
+var import_child_process = require("child_process");
+var import_crypto = require("crypto");
+var import_jszip3 = __toESM(require("jszip"), 1);
+
+// src/schema.ts
+var STD_BASE = "https://dot-agent.dev/schema/std/v1/";
+function propertyTypeToSchema(pt) {
+  switch (pt.kind) {
+    case "primitive":
+      return { type: pt.value };
+    case "reference":
+      return pt.value.startsWith("std.") ? { $ref: `${STD_BASE}${pt.value.slice(4)}.json` } : { $ref: `#/$defs/${pt.value}` };
+    case "array":
+      return { type: "array", items: propertyTypeToSchema(pt.value) };
+    case "enum":
+      return { type: "string", enum: pt.value };
+  }
+}
+function typeDefinitionToSchema(td) {
+  const required = td.properties.filter((p) => !p.is_optional).map((p) => p.name);
+  const properties = {};
+  for (const p of td.properties) {
+    properties[p.name] = {
+      ...propertyTypeToSchema(p.type),
+      ...p.description ? { description: p.description } : {}
+    };
+  }
+  return {
+    $schema: "https://json-schema.org/draft/2020-12/schema",
+    "x-category": td.category.uri,
+    ...td.category.label ? { "x-category-label": td.category.label } : {},
+    ...td.concept ? { "x-concept": td.concept.uri } : {},
+    ...td.concept?.label ? { "x-concept-label": td.concept.label } : {},
+    type: "object",
+    properties,
+    ...required.length ? { required } : {}
+  };
+}
+function refFromAnnotatedRef(ref) {
+  return ref.name.startsWith("std.") ? { $ref: `${STD_BASE}${ref.name.slice(4)}.json` } : { $ref: `#/$defs/${ref.name}` };
+}
+function buildTypesJson(df) {
+  if (df.types.length === 0 && df.input.length === 0 && df.output.length === 0) return null;
+  const defs = {};
+  for (const td of df.types) {
+    defs[td.name] = typeDefinitionToSchema(td);
+  }
+  return JSON.stringify(
+    {
+      ...df.input.length ? { input: df.input.map(refFromAnnotatedRef) } : {},
+      ...df.output.length ? { output: df.output.map(refFromAnnotatedRef) } : {},
+      ...Object.keys(defs).length ? { $defs: defs } : {}
+    },
+    null,
+    2
+  );
+}
+
+// src/pack.ts
+function gitDescribeTags() {
+  try {
+    return (0, import_child_process.execSync)("git describe --tags --abbrev=0", { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function gitRevParseShort() {
+  try {
+    return (0, import_child_process.execSync)("git rev-parse --short HEAD", { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+async function resolveVersion(explicit) {
+  if (explicit) return explicit;
+  return gitDescribeTags() ?? "v1.0.0";
+}
+async function resolveCommit(explicit) {
+  if (explicit) return explicit;
+  return gitRevParseShort() ?? void 0;
+}
+async function collectFiles(dir) {
+  const files = /* @__PURE__ */ new Map();
+  async function walk(subdir, prefix = "") {
+    try {
+      const entries = await (0, import_promises2.readdir)(subdir);
+      for (const entry of entries) {
+        if (entry === ".gitkeep" || entry.startsWith(".")) continue;
+        const fullPath = (0, import_path2.join)(subdir, entry);
+        const stats = await (0, import_promises2.stat)(fullPath);
+        const relativePath = prefix ? `${prefix}/${entry}` : entry;
+        if (stats.isDirectory()) {
+          await walk(fullPath, relativePath);
+        } else {
+          files.set(relativePath, await (0, import_promises2.readFile)(fullPath, "utf-8"));
+        }
+      }
+    } catch {
+    }
+  }
+  files.set("agent.description", await (0, import_promises2.readFile)((0, import_path2.join)(dir, "agent.description"), "utf-8"));
+  files.set("agent.behavior", await (0, import_promises2.readFile)((0, import_path2.join)(dir, "agent.behavior"), "utf-8"));
+  try {
+    files.set("SOUL.md", await (0, import_promises2.readFile)((0, import_path2.join)(dir, "SOUL.md"), "utf-8"));
+  } catch {
+  }
+  await walk((0, import_path2.join)(dir, "behaviors"), "behaviors");
+  await walk((0, import_path2.join)(dir, "guides"), "guides");
+  await walk((0, import_path2.join)(dir, "knowledge"), "knowledge");
+  return files;
+}
+async function pack(options = {}) {
+  const dir = options.dir ?? process.cwd();
+  const outPath = options.out ?? (0, import_path2.join)(dir, `${(0, import_path2.basename)(dir)}.agent`);
+  let descriptionText;
+  let behaviorText;
+  try {
+    descriptionText = await (0, import_promises2.readFile)((0, import_path2.join)(dir, "agent.description"), "utf-8");
+  } catch {
+    throw new Error("E003: File agent.description not found");
+  }
+  try {
+    behaviorText = await (0, import_promises2.readFile)((0, import_path2.join)(dir, "agent.behavior"), "utf-8");
+  } catch {
+    throw new Error("E007: File agent.behavior not found");
+  }
+  const [descriptionMessages, behaviorMessages] = await Promise.all([
+    lintDescription(descriptionText),
+    lintBehavior(behaviorText)
+  ]);
+  const allMessages = [...descriptionMessages, ...behaviorMessages];
+  const errors = allMessages.filter((m) => m.severity === "error");
+  const warnings = allMessages.filter((m) => m.severity === "warning");
+  if (errors.length > 0) {
+    throw new Error(
+      `Lint failed:
+${errors.map((e) => `  ${e.file}:${e.line}:${e.col} ${e.code} ${e.message}`).join("\n")}`
+    );
+  }
+  await initBehaviorParser();
+  const descResult = parseDescriptionFile(descriptionText);
+  if (descResult.ok === null) {
+    const firstError = descResult.diagnostics.find((d) => d.severity === "error");
+    throw new Error(`E_DESC: ${firstError?.message ?? "parse failed"}`);
+  }
+  const df = descResult.ok;
+  const version = await resolveVersion(options.version);
+  const commit = await resolveCommit(options.commit);
+  const allFiles = await collectFiles(dir);
+  const contentForHash = Array.from(allFiles.values()).join("");
+  const sha256 = (0, import_crypto.createHash)("sha256").update(contentForHash).digest("hex");
+  const namespace = df.agent.domain ?? "unknown";
+  const id = buildId({ namespace, name: df.agent.name, version, digest: commit });
+  const typesJson = buildTypesJson(df);
+  const integrity = {
+    sha256,
+    ...typesJson ? { types: ".agent/types.json" } : {},
+    files: ".agent/files.json"
+  };
+  const aboutme = buildAboutme({
+    id,
+    name: df.agent.name,
+    description: df.description ?? "",
+    version,
+    domain: df.agent.domain ?? "",
+    license: df.agent.license ?? "",
+    persona: df.persona ?? "SOUL.md",
+    purpose: "unknown",
+    compiler: "dot-agent/1.0.0",
+    commit,
+    capabilities: df.capabilities.map((c) => ({ id: c.name, description: c.description ?? "" })),
+    requires: df.requires,
+    integrity
+  });
+  const zip = new import_jszip3.default();
+  const agentFolder = zip.folder(".agent");
+  agentFolder.file("aboutme.json", aboutmeToJson(aboutme));
+  if (typesJson) {
+    agentFolder.file("types.json", typesJson);
+  }
+  const gitkeepPaths = /* @__PURE__ */ new Set(["behaviors/.gitkeep", "guides/.gitkeep", "knowledge/.gitkeep"]);
+  const filesJson = {
+    description: "agent.description",
+    behavior: "agent.behavior",
+    behaviors: Array.from(allFiles.keys()).filter((f) => f.startsWith("behaviors/") && !gitkeepPaths.has(f)),
+    guides: Array.from(allFiles.keys()).filter((f) => f.startsWith("guides/") && !gitkeepPaths.has(f)),
+    knowledge: Array.from(allFiles.keys()).filter((f) => f.startsWith("knowledge/") && !gitkeepPaths.has(f))
+  };
+  agentFolder.file("files.json", JSON.stringify(filesJson, null, 2));
+  for (const [path, content] of allFiles) {
+    if (!gitkeepPaths.has(path)) zip.file(path, content);
+  }
+  await writeZip(zip, outPath);
+  return { path: outPath, id, warnings };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  aboutmeToJson,
+  buildAboutme,
+  buildId,
+  collectFiles,
+  createLinter,
+  createZip,
+  extractDigest,
+  extractFiles,
+  extractName,
+  getBehaviorScxml,
+  getContextNode,
+  initBehaviorParser,
+  initParsers,
+  lintBehavior,
+  lintDescription,
+  nodeAtOffset,
+  nodeToRange,
+  nodesOfType,
+  pack,
+  parse,
+  parseAboutme,
+  parseBehaviorFile,
+  parseDescriptionFile,
+  parseId,
+  parseSync,
+  positionToOffset,
+  readZip,
+  validateMagicBytes,
+  validateZipBomb,
+  writeZip
+});
+//# sourceMappingURL=index.cjs.map