@dot-agent/compiler 0.1.0

package/dist/index.js

@@ -0,0 +1,831 @@
+import {
+  aboutmeToJson,
+  buildAboutme,
+  buildId,
+  createZip,
+  extractDigest,
+  extractFiles,
+  extractName,
+  parseAboutme,
+  parseId
+} from "./chunk-IT25ILTQ.js";
+
+// src/parser.ts
+import { createRequire } from "module";
+import { Parser, Language } from "web-tree-sitter";
+import bpInit, { parse_behavior as bpParseBehavior, parse_description as bpParseDescription, get_graph } from "@dot-agent/parser-dsl";
+var require2 = createRequire(import.meta.url);
+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 bpInit();
+  _bpInitialized = true;
+}
+function parseBehaviorFile(text) {
+  return JSON.parse(bpParseBehavior(text));
+}
+function parseDescriptionFile(text) {
+  return JSON.parse(bpParseDescription(text));
+}
+function getBehaviorScxml(text) {
+  return get_graph(text);
+}
+async function initParsers() {
+  if (_initialized) return;
+  await Parser.init();
+  const descriptionLang = await Language.load(descriptionWasmPath);
+  const behaviorLang = await Language.load(behaviorWasmPath);
+  _descriptionParser = new Parser();
+  _descriptionParser.setLanguage(descriptionLang);
+  _behaviorParser = new 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
+import { readFileSync } from "fs";
+import { resolve, dirname } from "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 = resolve(docDir, filename);
+    if (visited.has(absPath)) continue;
+    visited.add(absPath);
+    let mergedText;
+    try {
+      mergedText = 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, 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, 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/zip.ts
+import JSZip from "jszip";
+import { readFile, writeFile } from "fs/promises";
+var MAX_ZIP_SIZE = 500 * 1024 * 1024;
+var MAX_COMPRESSION_RATIO = 100;
+async function readZip(filePath) {
+  const data = await readFile(filePath);
+  return JSZip.loadAsync(data);
+}
+async function validateZipBomb(filePath) {
+  const data = await readFile(filePath);
+  const zip = await JSZip.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 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 writeFile(outPath, Buffer.from(data));
+}
+
+// src/pack.ts
+import { readFile as readFile2, stat, readdir } from "fs/promises";
+import { join, basename } from "path";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+import JSZip2 from "jszip";
+
+// 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 execSync("git describe --tags --abbrev=0", { stdio: "pipe", encoding: "utf-8" }).trim();
+  } catch {
+    return null;
+  }
+}
+function gitRevParseShort() {
+  try {
+    return 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 readdir(subdir);
+      for (const entry of entries) {
+        if (entry === ".gitkeep" || entry.startsWith(".")) continue;
+        const fullPath = join(subdir, entry);
+        const stats = await stat(fullPath);
+        const relativePath = prefix ? `${prefix}/${entry}` : entry;
+        if (stats.isDirectory()) {
+          await walk(fullPath, relativePath);
+        } else {
+          files.set(relativePath, await readFile2(fullPath, "utf-8"));
+        }
+      }
+    } catch {
+    }
+  }
+  files.set("agent.description", await readFile2(join(dir, "agent.description"), "utf-8"));
+  files.set("agent.behavior", await readFile2(join(dir, "agent.behavior"), "utf-8"));
+  try {
+    files.set("SOUL.md", await readFile2(join(dir, "SOUL.md"), "utf-8"));
+  } catch {
+  }
+  await walk(join(dir, "behaviors"), "behaviors");
+  await walk(join(dir, "guides"), "guides");
+  await walk(join(dir, "knowledge"), "knowledge");
+  return files;
+}
+async function pack(options = {}) {
+  const dir = options.dir ?? process.cwd();
+  const outPath = options.out ?? join(dir, `${basename(dir)}.agent`);
+  let descriptionText;
+  let behaviorText;
+  try {
+    descriptionText = await readFile2(join(dir, "agent.description"), "utf-8");
+  } catch {
+    throw new Error("E003: File agent.description not found");
+  }
+  try {
+    behaviorText = await readFile2(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 = 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 JSZip2();
+  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 };
+}
+export {
+  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.js.map