@dot-agent/cli 1.0.1 → 1.0.2

package/dist/index.cjs

@@ -0,0 +1,799 @@
+"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, {
+  init: () => init,
+  pack: () => pack,
+  run: () => run,
+  unpack: () => unpack
+});
+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/commands/init.ts
+var import_promises = require("fs/promises");
+var import_path = require("path");
+var AGENT_DESCRIPTION_TEMPLATE = (name, domain) => `agent ${name}
+  domain ${domain}
+  license Apache-2.0
+
+description
+  Describe what this agent does.
+
+behavior agent.behavior
+
+capabilities
+  ActionName "Describe this capability"
+`;
+var AGENT_BEHAVIOR_TEMPLATE = `state init
+  transition to responsive
+
+state responsive
+  goal "Help the user with their task."
+  interact
+  on intent "start" transition to responsive
+`;
+var SOUL_TEMPLATE = (name) => `# ${name} \u2014 Persona
+
+## Voice and Tone
+
+Describe the agent's voice, personality, and communication style.
+`;
+var README_TEMPLATE = (name) => `# ${name}
+
+Brief description of what this agent does.
+
+## Usage
+
+Example of how to use this agent.
+`;
+var LICENSE = `Apache License
+Version 2.0, January 2004
+
+http://www.apache.org/licenses/
+
+TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+`;
+async function init(options = {}) {
+  const dir = options.dir || process.cwd();
+  const name = options.name || (0, import_path.basename)(dir);
+  const domain = options.domain || "example.com";
+  try {
+    await (0, import_promises.stat)(dir);
+  } catch {
+    await (0, import_promises.mkdir)(dir, { recursive: true });
+  }
+  const agentDescriptionPath = (0, import_path.join)(dir, "agent.description");
+  try {
+    await (0, import_promises.stat)(agentDescriptionPath);
+    throw new Error(`agent.description already exists at ${agentDescriptionPath}`);
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const files = [];
+  await (0, import_promises.writeFile)(agentDescriptionPath, AGENT_DESCRIPTION_TEMPLATE(name, domain));
+  files.push("agent.description");
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "agent.behavior"), AGENT_BEHAVIOR_TEMPLATE);
+  files.push("agent.behavior");
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "SOUL.md"), SOUL_TEMPLATE(name));
+  files.push("SOUL.md");
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "README.md"), README_TEMPLATE(name));
+  files.push("README.md");
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "LICENSE"), LICENSE);
+  files.push("LICENSE");
+  await (0, import_promises.mkdir)((0, import_path.join)(dir, "behaviors"), { recursive: true });
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "behaviors", ".gitkeep"), "");
+  files.push("behaviors/.gitkeep");
+  await (0, import_promises.mkdir)((0, import_path.join)(dir, "guides"), { recursive: true });
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "guides", ".gitkeep"), "");
+  files.push("guides/.gitkeep");
+  await (0, import_promises.mkdir)((0, import_path.join)(dir, "knowledge"), { recursive: true });
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "knowledge", ".gitkeep"), "");
+  files.push("knowledge/.gitkeep");
+  await (0, import_promises.writeFile)((0, import_path.join)(dir, "AGENTS.md"), "");
+  files.push("AGENTS.md");
+  return { dir, files };
+}
+
+// src/commands/pack.ts
+var import_promises3 = require("fs/promises");
+var import_path2 = require("path");
+var import_child_process = require("child_process");
+var import_crypto = require("crypto");
+var import_jszip2 = __toESM(require("jszip"), 1);
+
+// src/core/lint.ts
+var import_module = require("module");
+var import_web_tree_sitter = require("web-tree-sitter");
+var import_kernel_dsl = require("@dot-agent/kernel-dsl");
+var require2 = (0, import_module.createRequire)(importMetaUrl);
+var { agentWasmPath, behaviorWasmPath } = require2("@dot-agent/tree-sitter");
+var _initialized = false;
+var _agentParser;
+var _behaviorParser;
+var _agentLang;
+var _behaviorLang;
+async function ensureWasmInit() {
+  if (_initialized) return;
+  try {
+    await import_web_tree_sitter.Parser.init();
+  } catch (err) {
+    throw err;
+  }
+  _agentParser = new import_web_tree_sitter.Parser();
+  _behaviorParser = new import_web_tree_sitter.Parser();
+  try {
+    _agentLang = await import_web_tree_sitter.Language.load(agentWasmPath);
+    _behaviorLang = await import_web_tree_sitter.Language.load(behaviorWasmPath);
+  } catch (err) {
+    throw err;
+  }
+  try {
+    await (0, import_kernel_dsl.init)();
+  } catch (err) {
+  }
+  _initialized = true;
+}
+function collectSyntaxErrors(node) {
+  const errors = [];
+  if (node.isError || node.isMissing) errors.push(node);
+  for (const child of node.children) {
+    errors.push(...collectSyntaxErrors(child));
+  }
+  return errors;
+}
+function getLineCol(node) {
+  return { line: node.startPosition.row + 1, col: node.startPosition.column + 1 };
+}
+async function lintDescription(text) {
+  await ensureWasmInit();
+  _agentParser.setLanguage(_agentLang);
+  const tree = _agentParser.parse(text);
+  const messages = [];
+  const syntaxErrors = collectSyntaxErrors(tree.rootNode);
+  if (syntaxErrors.length > 0) {
+    for (const error of syntaxErrors) {
+      const { line, col } = getLineCol(error);
+      messages.push({
+        file: "agent.description",
+        line,
+        col,
+        severity: "error",
+        code: "E004",
+        message: "Syntax error in description"
+      });
+    }
+  }
+  const walk = (node) => {
+    if (node.type === "domain_declaration" && node.childCount > 0) {
+      const valueNode = node.child(node.childCount - 1);
+      if (valueNode && valueNode.text === "example.com") {
+        const { line, col } = getLineCol(valueNode);
+        messages.push({
+          file: "agent.description",
+          line,
+          col,
+          severity: "warning",
+          code: "W003",
+          message: 'domain still has default value "example.com"'
+        });
+      }
+    }
+    for (const child of node.children) walk(child);
+  };
+  walk(tree.rootNode);
+  return messages;
+}
+async function lintBehavior(text) {
+  await ensureWasmInit();
+  _behaviorParser.setLanguage(_behaviorLang);
+  const tree = _behaviorParser.parse(text);
+  const messages = [];
+  const syntaxErrors = collectSyntaxErrors(tree.rootNode);
+  if (syntaxErrors.length > 0) {
+    for (const error of syntaxErrors) {
+      const { line, col } = getLineCol(error);
+      messages.push({
+        file: "agent.behavior",
+        line,
+        col,
+        severity: "error",
+        code: "E004",
+        message: "Syntax error in behavior DSL"
+      });
+    }
+  }
+  const walk = (node) => {
+    if (node.type === "text_block") {
+      if (node.text.length > 280) {
+        const { line, col } = getLineCol(node);
+        messages.push({
+          file: "agent.behavior",
+          line,
+          col,
+          severity: "warning",
+          code: "W002",
+          message: `Text block exceeds 280 characters (${node.text.length})`
+        });
+      }
+    }
+    for (const child of node.children) walk(child);
+  };
+  walk(tree.rootNode);
+  try {
+    const kernel = new import_kernel_dsl.AgentDSLKernel();
+    try {
+      const effects = kernel.load_behavior(text);
+      if (Array.isArray(effects)) {
+        for (const effect of effects) {
+          if (effect.type === "parse_error") {
+            messages.push({
+              file: "agent.behavior",
+              line: 1,
+              col: 1,
+              severity: "error",
+              code: "E006",
+              message: `Parse error: ${effect.message}`
+            });
+          }
+        }
+      }
+      const graph = kernel.get_graph();
+      if (graph?.states) {
+        for (const stateName of Object.keys(graph.states)) {
+          const state = graph.states[stateName];
+          const hasIncoming = graph.transitions?.some((t) => t.to === stateName);
+          const hasOutgoing = graph.transitions?.some((t) => t.from === stateName);
+          if (!hasIncoming && !hasOutgoing && stateName !== graph.current) {
+            messages.push({
+              file: "agent.behavior",
+              line: 1,
+              col: 1,
+              severity: "warning",
+              code: "W001",
+              message: `state "${stateName}" has no transitions`
+            });
+          }
+        }
+      }
+    } catch (kernelErr) {
+    }
+  } catch (err) {
+  }
+  return messages;
+}
+async function createLinter() {
+  await ensureWasmInit();
+  return {
+    lintDescription,
+    lintBehavior
+  };
+}
+
+// src/core/id.ts
+function buildId(parts) {
+  const { namespace, name, version, digest } = parts;
+  if (!namespace || !name || !version || !digest) {
+    throw new Error("Missing required ID parts: namespace, name, version, digest");
+  }
+  return `${namespace}/${name}:${version}~${digest}`;
+}
+
+// src/core/envelope.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.license) throw new Error("Missing license 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.skills)) throw new Error("Missing skills 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,
+    compiler: json.compiler,
+    commit: json.commit,
+    skills: json.skills,
+    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 || "Apache-2.0",
+    persona: opts.persona,
+    compiler: opts.compiler,
+    commit: opts.commit,
+    skills: opts.skills || [],
+    requires: opts.requires || [],
+    integrity: opts.integrity
+  };
+}
+function aboutmeToJson(aboutme) {
+  return JSON.stringify(aboutme, null, 2);
+}
+
+// src/core/zip.ts
+var import_jszip = __toESM(require("jszip"), 1);
+var import_promises2 = require("fs/promises");
+var MAX_ZIP_SIZE = 500 * 1024 * 1024;
+var MAX_COMPRESSION_RATIO = 100;
+async function readZip(filePath) {
+  const data = await (0, import_promises2.readFile)(filePath);
+  return import_jszip.default.loadAsync(data);
+}
+async function validateZipBomb(filePath) {
+  const data = await (0, import_promises2.readFile)(filePath);
+  const zip = await import_jszip.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 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;
+}
+async function writeZip(zip, outPath) {
+  const data = await zip.generateAsync({ type: "arraybuffer" });
+  await (0, import_promises2.writeFile)(outPath, Buffer.from(data));
+}
+async function validateMagicBytes(filePath) {
+  const data = await (0, import_promises2.readFile)(filePath);
+  const magicBytes = data.subarray(0, 4);
+  const isZip = magicBytes[0] === 80 && magicBytes[1] === 75 && magicBytes[2] === 3 && magicBytes[3] === 4;
+  if (!isZip) {
+    throw new Error("File is not a valid ZIP (invalid magic bytes)");
+  }
+  return true;
+}
+
+// src/commands/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;
+  const gitTag = gitDescribeTags();
+  if (gitTag) return gitTag;
+  return "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_promises3.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_promises3.stat)(fullPath);
+        const relativePath = prefix ? `${prefix}/${entry}` : entry;
+        if (stats.isDirectory()) {
+          await walk(fullPath, relativePath);
+        } else {
+          const content = await (0, import_promises3.readFile)(fullPath, "utf-8");
+          files.set(relativePath, content);
+        }
+      }
+    } catch {
+    }
+  }
+  const description = await (0, import_promises3.readFile)((0, import_path2.join)(dir, "agent.description"), "utf-8");
+  files.set("agent.description", description);
+  const behavior = await (0, import_promises3.readFile)((0, import_path2.join)(dir, "agent.behavior"), "utf-8");
+  files.set("agent.behavior", behavior);
+  try {
+    const soul = await (0, import_promises3.readFile)((0, import_path2.join)(dir, "SOUL.md"), "utf-8");
+    files.set("SOUL.md", soul);
+  } 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;
+}
+function parseDescription(text) {
+  const domain = text.match(/domain\s+([^\n]+)/)?.[1] || "";
+  const name = text.match(/agent\s+([^\n]+)/)?.[1] || "";
+  const description = text.match(/description\s+(.+?)(?=\n\n|\n[a-z])/s)?.[1] || "";
+  return {
+    domain: domain.trim(),
+    name: name.trim(),
+    description: description.trim(),
+    capabilities: []
+  };
+}
+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_promises3.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_promises3.readFile)((0, import_path2.join)(dir, "agent.behavior"), "utf-8");
+  } catch {
+    throw new Error("E007: File agent.behavior not found");
+  }
+  const linter = await createLinter();
+  const descriptionMessages = await linter.lintDescription(descriptionText);
+  const behaviorMessages = await linter.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")}`);
+  }
+  const description = parseDescription(descriptionText);
+  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 digest = (0, import_crypto.createHash)("sha256").update(contentForHash).digest("hex").substring(0, 8);
+  const id = buildId({
+    namespace: description.domain,
+    name: description.name,
+    version,
+    digest
+  });
+  const aboutme = buildAboutme({
+    id,
+    name: description.name,
+    description: description.description,
+    version,
+    domain: description.domain,
+    license: "Apache-2.0",
+    persona: "SOUL.md",
+    compiler: "dot-agent/1.0.0",
+    commit,
+    skills: [],
+    requires: [],
+    integrity: {
+      sha256: (0, import_crypto.createHash)("sha256").update(contentForHash).digest("hex"),
+      files: ".agent/files.json"
+    }
+  });
+  const zip = new import_jszip2.default();
+  zip.folder(".agent").file("aboutme.json", aboutmeToJson(aboutme));
+  const filesJson = {
+    description: "agent.description",
+    behavior: "agent.behavior",
+    behaviors: Array.from(allFiles.keys()).filter((f) => f.startsWith("behaviors/") && f !== "behaviors/.gitkeep").map((f) => f),
+    guides: Array.from(allFiles.keys()).filter((f) => f.startsWith("guides/") && f !== "guides/.gitkeep").map((f) => f),
+    knowledge: Array.from(allFiles.keys()).filter((f) => f.startsWith("knowledge/") && f !== "knowledge/.gitkeep").map((f) => f)
+  };
+  zip.folder(".agent").file("files.json", JSON.stringify(filesJson, null, 2));
+  for (const [path, content] of allFiles) {
+    if (path !== "behaviors/.gitkeep" && path !== "guides/.gitkeep" && path !== "knowledge/.gitkeep") {
+      zip.file(path, content);
+    }
+  }
+  await writeZip(zip, outPath);
+  return {
+    path: outPath,
+    id,
+    warnings
+  };
+}
+
+// src/commands/unpack.ts
+var import_promises4 = require("fs/promises");
+var import_path3 = require("path");
+async function unpack(options) {
+  const { file, out, force = false } = options;
+  await validateMagicBytes(file);
+  await validateZipBomb(file);
+  const zip = await readZip(file);
+  const aboutmeFile = zip.file(".agent/aboutme.json");
+  if (!aboutmeFile) {
+    throw new Error("Missing .agent/aboutme.json in ZIP");
+  }
+  const aboutmeText = await aboutmeFile.async("text");
+  const aboutme = parseAboutme(JSON.parse(aboutmeText));
+  const outDir = out || `./${aboutme.name}`;
+  try {
+    await (0, import_promises4.stat)(outDir);
+    if (!force) {
+      throw new Error(`Output directory already exists: ${outDir}. Use --force to overwrite.`);
+    }
+  } catch (err) {
+    if (err.code !== "ENOENT") throw err;
+  }
+  const files = await extractFiles(zip);
+  await (0, import_promises4.mkdir)(outDir, { recursive: true });
+  const extractedFiles = [];
+  for (const [path, content] of files) {
+    if (path.startsWith(".agent/")) continue;
+    const fullPath = (0, import_path3.join)(outDir, path);
+    const dir = fullPath.substring(0, fullPath.lastIndexOf("/"));
+    await (0, import_promises4.mkdir)(dir, { recursive: true });
+    await (0, import_promises4.writeFile)(fullPath, content);
+    extractedFiles.push(path);
+  }
+  return {
+    dir: outDir,
+    id: aboutme.id,
+    files: extractedFiles,
+    aboutme
+  };
+}
+
+// src/commands/run.ts
+var import_events = require("events");
+var import_promises5 = require("fs/promises");
+var import_kernel_dsl2 = require("@dot-agent/kernel-dsl");
+function isZipFile(source) {
+  return source.endsWith(".agent");
+}
+async function run(options) {
+  const { source } = options;
+  const context = new import_events.EventEmitter();
+  try {
+    context.emit("progress", { step: "opening", pct: 0 });
+    let descriptionText;
+    let behaviorText;
+    let aboutme = null;
+    let id;
+    if (isZipFile(source)) {
+      await validateMagicBytes(source);
+      await validateZipBomb(source);
+      const zip = await readZip(source);
+      const aboutmeFile = zip.file(".agent/aboutme.json");
+      if (!aboutmeFile) {
+        throw new Error("Missing .agent/aboutme.json");
+      }
+      const aboutmeText = await aboutmeFile.async("text");
+      aboutme = parseAboutme(JSON.parse(aboutmeText));
+      id = aboutme.id;
+      const descFile = zip.file("agent.description");
+      if (!descFile) throw new Error("Missing agent.description");
+      descriptionText = await descFile.async("text");
+      const behavFile = zip.file("agent.behavior");
+      if (!behavFile) throw new Error("Missing agent.behavior");
+      behaviorText = await behavFile.async("text");
+      context.emit("progress", { step: "parsing", pct: 30 });
+      let kernel;
+      try {
+        await (0, import_kernel_dsl2.init)();
+        kernel = new import_kernel_dsl2.AgentDSLKernel();
+        kernel.load_behavior(behaviorText);
+      } catch (err) {
+        kernel = {
+          get_current_state: () => "init",
+          get_graph: () => ({}),
+          get_memory: () => [],
+          get_valid_intents: () => [],
+          load_behavior: () => {
+          },
+          observe: () => {
+          },
+          send_complete: () => {
+          },
+          send_event: () => {
+          },
+          send_failed: () => {
+          },
+          send_fallback: () => {
+          },
+          send_intent: () => {
+          },
+          send_offtopic: () => {
+          },
+          tick_prompt: () => {
+          },
+          free: () => {
+          }
+        };
+      }
+      context.emit("progress", { step: "loading-files", pct: 60 });
+      const soulFile = zip.file("SOUL.md");
+      const soul = soulFile ? await soulFile.async("text") : void 0;
+      const allFiles = await extractFiles(zip);
+      const guides = [];
+      const knowledge = [];
+      const behaviors = [];
+      for (const [path, content] of allFiles) {
+        if (path.startsWith("guides/") && path !== "guides/.gitkeep") {
+          guides.push({ path, content });
+        } else if (path.startsWith("knowledge/") && path !== "knowledge/.gitkeep") {
+          knowledge.push({ path, content });
+        } else if (path.startsWith("behaviors/") && path !== "behaviors/.gitkeep") {
+          behaviors.push({ path, content });
+        }
+      }
+      context.id = id;
+      context.description = { domain: "example.com", name: "Agent" };
+      context.behavior = {};
+      context.kernel = kernel;
+      context.files = { soul, guides, knowledge, behaviors };
+      context.aboutme = aboutme;
+    } else {
+      const descPath = `${source}/agent.description`;
+      const behavPath = `${source}/agent.behavior`;
+      try {
+        descriptionText = await (0, import_promises5.readFile)(descPath, "utf-8");
+      } catch {
+        throw new Error(`Missing agent.description at ${descPath}`);
+      }
+      try {
+        behaviorText = await (0, import_promises5.readFile)(behavPath, "utf-8");
+      } catch {
+        throw new Error(`Missing agent.behavior at ${behavPath}`);
+      }
+      context.emit("progress", { step: "parsing", pct: 30 });
+      let kernel;
+      try {
+        await (0, import_kernel_dsl2.init)();
+        kernel = new import_kernel_dsl2.AgentDSLKernel();
+        kernel.load_behavior(behaviorText);
+      } catch (err) {
+        kernel = {
+          get_current_state: () => "init",
+          get_graph: () => ({}),
+          get_memory: () => [],
+          get_valid_intents: () => [],
+          load_behavior: () => {
+          },
+          observe: () => {
+          },
+          send_complete: () => {
+          },
+          send_event: () => {
+          },
+          send_failed: () => {
+          },
+          send_fallback: () => {
+          },
+          send_intent: () => {
+          },
+          send_offtopic: () => {
+          },
+          tick_prompt: () => {
+          },
+          free: () => {
+          }
+        };
+      }
+      context.emit("progress", { step: "loading-files", pct: 60 });
+      id = "local/agent:v1.0~unknown";
+      try {
+        const soul = await (0, import_promises5.readFile)(`${source}/SOUL.md`, "utf-8");
+        context.files = {
+          soul,
+          guides: [],
+          knowledge: [],
+          behaviors: []
+        };
+      } catch {
+        context.files = { guides: [], knowledge: [], behaviors: [] };
+      }
+      const defaultAboutme = {
+        schemaVersion: "dot-agent/1.0",
+        id,
+        name: "Agent",
+        description: "",
+        version: "v1.0",
+        domain: "local",
+        license: "Apache-2.0",
+        persona: "SOUL.md",
+        compiler: "dot-agent/1.0.0",
+        skills: [],
+        requires: [],
+        integrity: { sha256: "", files: "" }
+      };
+      context.id = id;
+      context.description = { domain: "example.com", name: "Agent" };
+      context.behavior = {};
+      context.kernel = kernel;
+      context.aboutme = defaultAboutme;
+    }
+    context.emit("progress", { step: "ready", pct: 100 });
+    context.emit("ready", context);
+    return context;
+  } catch (err) {
+    context.emit("error", err);
+    throw err;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  init,
+  pack,
+  run,
+  unpack
+});
+//# sourceMappingURL=index.cjs.map