@dot-agent/compiler 0.5.0-alpha.2 → 0.10.1

package/dist/index.mjs

@@ -0,0 +1,1057 @@
+import { a as buildId, c as isValidVersion, d as aboutmeToJson, f as buildAboutme, i as validateZipBomb$1, l as parseId, m as COMPILER_VERSION, n as extractFiles, o as extractDigest, p as parseAboutme, r as validateMagicBytes$1, s as extractName, t as createZip, u as slugify } from "./zip-core-Dw_OgIjV.mjs";
+import { createRequire } from "module";
+import { Language, Parser } from "web-tree-sitter";
+import { get_graph, init, parse_behavior, parse_description } from "@dot-agent/parser-dsl";
+import { readFileSync } from "fs";
+import { basename, dirname, isAbsolute, join, normalize, relative, resolve } from "path";
+import JSZip from "jszip";
+import { readFile, readdir, stat, writeFile } from "fs/promises";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
+//#region src/parser.ts
+const { descriptionWasmPath, behaviorWasmPath } = createRequire(import.meta.url)("@dot-agent/tree-sitter");
+let _initialized = false;
+let _descriptionParser;
+let _behaviorParser;
+let _bpInitialized = false;
+async function initBehaviorParser() {
+	if (_bpInitialized) return;
+	await init();
+	_bpInitialized = true;
+}
+function parseBehaviorFile(text) {
+	return JSON.parse(parse_behavior(text));
+}
+function parseDescriptionFile(text) {
+	return JSON.parse(parse_description(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;
+}
+/**
+* Parse source text and return a tree-sitter Tree.
+*
+* @param langId  - 'description' or 'behavior'
+* @param text    - source text to parse
+* @param previousTree - optional previous tree for incremental parsing (LSP use)
+*/
+async function parse(langId, text, previousTree) {
+	await initParsers();
+	return (langId === "behavior" ? _behaviorParser : _descriptionParser).parse(text, previousTree);
+}
+/** Parse without initializing if parsers are already ready. Returns null if not initialized. */
+function parseSync(langId, text, previousTree) {
+	if (!_initialized) return null;
+	return (langId === "behavior" ? _behaviorParser : _descriptionParser).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 parent = nodeAtOffset(tree, offset)?.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;
+}
+//#endregion
+//#region src/linter.ts
+function nodePosition(node) {
+	return {
+		line: node.startPosition.row + 1,
+		col: node.startPosition.column + 1
+	};
+}
+const MISSING_HINTS = {
+	interact_stmt: "Missing 'interact' — oriented states require 'goal … interact … on intent … on offtopic'.",
+	offtopic_handler: "Missing 'on offtopic' handler — every state with 'interact' must handle the offtopic case.",
+	intent_handler: "Missing at least one 'on intent' handler after 'interact'.",
+	goal_stmt: "Missing 'goal' — every state with 'interact' must declare a goal.",
+	state_name: "Missing state name after 'state' keyword.",
+	quoted_string: "Missing quoted string — 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") {
+			if (!node.descendantsOfType("ERROR").some((e) => e !== null && e.id !== node.id)) {
+				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);
+}
+const 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")) {
+		if (metaNode.childForFieldName("key")?.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\""
+			});
+		}
+	}
+	if (!nodesOfType(tree, "agent_meta").some((n) => n.childForFieldName("key")?.text === "domain" && n.childForFieldName("value")?.text?.trim())) messages.push({
+		file,
+		line: 1,
+		col: 1,
+		severity: "warning",
+		code: "W007",
+		message: "No domain declared — agent will be packaged as unknown/name. Interoperability between runtimes is not guaranteed."
+	});
+	const behaviorBlocks = nodesOfType(tree, "behavior_block");
+	if (behaviorBlocks.length > 1) {
+		const { line, col } = nodePosition(behaviorBlocks[1]);
+		messages.push({
+			file,
+			line,
+			col,
+			severity: "error",
+			code: "E017",
+			message: "Multiple 'behavior' declarations — only one is allowed. To combine multiple files, use 'merge' in your .behavior file."
+		});
+	}
+	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 }, (_, 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;
+}
+const 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 absPath = resolve(docDir, pathNode.text.replace(/^"|"$/g, ""));
+		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, consolidated = false, externalStates, mergedText) {
+	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'. 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'.`
+			});
+		}
+		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 — 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")) if (t.childForFieldName("state")?.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 — 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 — prompts must be ≥ 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 'guide' to load long orientation text from an external text 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. 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 {}
+	if (externalStates) for (const name of externalStates) definedStates.add(name);
+	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;
+		if (!(ancestor.descendantsOfType("intent_handler").length + ancestor.descendantsOfType("offtopic_handler").length > 0)) {
+			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 wholeFsm = mergedText !== void 0 ? parseBehaviorFile(mergedText).ok : null;
+	const reachabilityStates = wholeFsm?.states ?? fsm.states;
+	const allTargets = new Set(collectTransitionTargets(reachabilityStates.flatMap((s) => s.body)));
+	for (const state of fsm.states) {
+		const hasOutgoing = collectTransitionTargets(state.body).length > 0;
+		if (!allTargets.has(state.name) && !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 — no other state transitions to it.`
+			});
+		}
+	}
+	if (consolidated) {
+		const wholeTreeFsm = wholeFsm ?? fsm;
+		const seenStates = /* @__PURE__ */ new Set();
+		for (const state of wholeTreeFsm.states) if (seenStates.has(state.name)) messages.push({
+			file,
+			line: 1,
+			col: 1,
+			severity: "error",
+			code: "E015",
+			message: `Duplicate state '${state.name}' across merged files — each state name must be unique in the consolidated FSM.`
+		});
+		else seenStates.add(state.name);
+		if (!wholeTreeFsm.states.some((s) => s.name === "init")) messages.push({
+			file,
+			line: 1,
+			col: 1,
+			severity: "error",
+			code: "E016",
+			message: `Required 'init' state is missing. Add a state named 'init' as the entry point of your behavior.`
+		});
+		const seenTriggers = /* @__PURE__ */ new Set();
+		for (const trigger of wholeTreeFsm.global_triggers) if (seenTriggers.has(trigger.event)) messages.push({
+			file,
+			line: 1,
+			col: 1,
+			severity: "warning",
+			code: "W014",
+			message: `Duplicate global trigger '${trigger.event}' across merged files — only the last definition takes effect.`
+		});
+		else seenTriggers.add(trigger.event);
+	}
+	return messages;
+}
+async function createLinter() {
+	return {
+		lintDescription,
+		lintBehavior
+	};
+}
+//#endregion
+//#region src/zip.ts
+async function readZip(filePath) {
+	const data = await readFile(filePath);
+	return JSZip.loadAsync(data);
+}
+async function validateZipBomb(filePath) {
+	const data = await readFile(filePath);
+	validateZipBomb$1(await JSZip.loadAsync(data), data.length);
+	return true;
+}
+async function validateMagicBytes(filePath) {
+	validateMagicBytes$1(await readFile(filePath));
+	return true;
+}
+async function writeZip(zip, outPath) {
+	const data = await zip.generateAsync({ type: "arraybuffer" });
+	await writeFile(outPath, Buffer.from(data));
+}
+//#endregion
+//#region src/schema.ts
+const 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}` };
+}
+/** Returns JSON Schema 2020-12 string for types.json, or null if nothing to write. */
+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);
+}
+//#endregion
+//#region src/pack.ts
+function gitRevParseShort() {
+	try {
+		return execSync("git rev-parse --short HEAD", {
+			stdio: "pipe",
+			encoding: "utf-8"
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+async function resolveCommit(explicit) {
+	if (explicit) return explicit;
+	return gitRevParseShort() ?? void 0;
+}
+function recentTagCandidates(limit = 5) {
+	let tags;
+	try {
+		tags = execSync("git tag --sort=-creatordate", {
+			stdio: "pipe",
+			encoding: "utf-8"
+		}).trim().split("\n").filter(Boolean);
+	} catch {
+		return [];
+	}
+	return tags.slice(0, limit).map((tag) => {
+		const atIdx = tag.lastIndexOf("@");
+		const version = atIdx === -1 ? tag : tag.slice(atIdx + 1);
+		return {
+			version,
+			label: atIdx === -1 ? tag : `${version}   (tag: ${tag})`
+		};
+	}).filter((c) => isValidVersion(c.version));
+}
+const CUSTOM_VERSION = "__dot-agent-custom-version__";
+const BARE_VERSION = "__dot-agent-bare-version__";
+async function resolveVersionInteractive(explicit) {
+	if (explicit) {
+		if (!isValidVersion(explicit)) throw new Error(`E019: Invalid version format '${explicit}' — expected vX.Y[.Z][-prerelease] or X.Y[.Z][-prerelease]`);
+		return explicit;
+	}
+	if (!process.stdin.isTTY || !process.stdout.isTTY) {
+		process.stderr.write("[dot-agent] no TTY and no --version — packing without a version\n");
+		return;
+	}
+	const candidates = recentTagCandidates();
+	const clack = await import("@clack/prompts");
+	const choice = await clack.select({
+		message: "Choose a version for this package",
+		options: [
+			...candidates.map((c) => ({
+				value: c.version,
+				label: c.label
+			})),
+			{
+				value: CUSTOM_VERSION,
+				label: "Type a custom version…"
+			},
+			{
+				value: BARE_VERSION,
+				label: "None (bare — no version)"
+			}
+		]
+	});
+	if (clack.isCancel(choice)) {
+		clack.cancel("Pack cancelled.");
+		process.exit(1);
+	}
+	if (choice === BARE_VERSION) return void 0;
+	if (choice === CUSTOM_VERSION) {
+		const typed = await clack.text({
+			message: "Version",
+			validate: (v) => v && isValidVersion(v) ? void 0 : "Invalid version format — expected vX.Y[.Z][-prerelease] or X.Y[.Z][-prerelease]"
+		});
+		if (clack.isCancel(typed)) {
+			clack.cancel("Pack cancelled.");
+			process.exit(1);
+		}
+		return typed;
+	}
+	return choice;
+}
+function isExternalPath(agentRoot, declaredPath) {
+	if (isAbsolute(declaredPath)) return true;
+	const normRoot = normalize(resolve(agentRoot));
+	return relative(normRoot, resolve(normRoot, declaredPath)).startsWith("..");
+}
+async function discoverDescriptionFile(dir, explicit) {
+	if (explicit) try {
+		await stat(join(dir, explicit));
+		return explicit;
+	} catch {
+		throw new Error(`E003: Description file '${explicit}' not found in ${dir}`);
+	}
+	const descFiles = (await readdir(dir)).filter((f) => f.endsWith(".description"));
+	if (descFiles.length === 0) throw new Error(`E003: No .description file found in ${dir}`);
+	if (descFiles.length > 1) throw new Error(`E003: Multiple .description files found: ${descFiles.join(", ")} — use PackOptions.description to specify one`);
+	const name = descFiles[0];
+	if (name !== "agent.description") console.info(`[dot-agent] using description file: ${name}`);
+	return name;
+}
+async function consolidate(agentRoot, entryFile) {
+	await initBehaviorParser();
+	const normRoot = normalize(resolve(agentRoot));
+	const visiting = /* @__PURE__ */ new Set();
+	const visited = /* @__PURE__ */ new Set();
+	const order = [];
+	const textCache = /* @__PURE__ */ new Map();
+	async function dfs(relPath) {
+		const absPath = resolve(normRoot, relPath);
+		if (visiting.has(absPath)) throw new Error(`E013: Circular merge dependency involving '${relPath}'`);
+		if (visited.has(absPath)) return;
+		visiting.add(absPath);
+		let fileText;
+		try {
+			fileText = await readFile(absPath, "utf-8");
+		} catch {
+			throw new Error(`E012: Merge target not found: '${relPath}'`);
+		}
+		textCache.set(absPath, fileText);
+		const merges = parseBehaviorFile(fileText).ok?.merges ?? [];
+		for (const mergePath of merges) {
+			if (isAbsolute(mergePath)) throw new Error(`E014: Merge path '${mergePath}' in '${relPath}' is absolute — only paths within the agent root are allowed`);
+			const mergeAbs = resolve(dirname(absPath), mergePath);
+			const mergeRel = relative(normRoot, mergeAbs);
+			if (mergeRel.startsWith("..")) throw new Error(`E014: Merge path '${mergePath}' in '${relPath}' escapes the agent root`);
+			await dfs(mergeRel);
+		}
+		visiting.delete(absPath);
+		visited.add(absPath);
+		order.push(relPath);
+	}
+	await dfs(entryFile);
+	return {
+		mergedText: order.map((relPath) => textCache.get(resolve(normRoot, relPath))).join("\n"),
+		mergeSources: order
+	};
+}
+const FILE_REF_RE = /\.(txt|md)$/i;
+function collectFileRefs(stmts, out) {
+	for (const s of stmts) switch (s.type) {
+		case "guide_stmt":
+			if (FILE_REF_RE.test(s.text)) out.set(`guide:${s.text}`, {
+				kind: "guide",
+				text: s.text
+			});
+			break;
+		case "teach_stmt":
+			if (FILE_REF_RE.test(s.text)) out.set(`teach:${s.text}`, {
+				kind: "teach",
+				text: s.text
+			});
+			break;
+		case "interact_stmt":
+			collectFileRefs(s.handlers, out);
+			break;
+		case "intent_handler":
+			if (Array.isArray(s.body)) collectFileRefs(s.body, out);
+			break;
+		case "offtopic_handler":
+		case "after_stmt":
+		case "parallel_stmt":
+			collectFileRefs(s.body, out);
+			break;
+		case "conditional_stmt":
+			collectFileRefs(s.then, out);
+			if (s.else) collectFileRefs(s.else, out);
+			break;
+	}
+}
+function namespaceOf(kind) {
+	return kind === "guide" ? "guides" : "knowledge";
+}
+async function collectBehaviorFileRefs(mergedBehaviorText) {
+	await initBehaviorParser();
+	const refs = /* @__PURE__ */ new Map();
+	const behaviorAst = parseBehaviorFile(mergedBehaviorText).ok;
+	if (!behaviorAst) return refs;
+	for (const state of behaviorAst.states) collectFileRefs(state.body, refs);
+	for (const trigger of behaviorAst.global_triggers) collectFileRefs(trigger.body, refs);
+	return refs;
+}
+async function listContentFiles(dir, ns) {
+	const found = [];
+	async function walk(subdir, prefix) {
+		let entries;
+		try {
+			entries = await readdir(subdir);
+		} catch {
+			return;
+		}
+		for (const entry of entries) {
+			if (entry.startsWith(".")) continue;
+			const fullPath = join(subdir, entry);
+			const relativePath = `${prefix}/${entry}`;
+			if ((await stat(fullPath)).isDirectory()) await walk(fullPath, relativePath);
+			else found.push(relativePath);
+		}
+	}
+	await walk(join(dir, ns), ns);
+	return found;
+}
+async function findOrphanContentFiles(dir, mergedBehaviorText) {
+	const refs = await collectBehaviorFileRefs(mergedBehaviorText);
+	const referenced = /* @__PURE__ */ new Set();
+	for (const { kind, text } of refs.values()) referenced.add(`${namespaceOf(kind)}/${text}`);
+	return [...await listContentFiles(dir, "guides"), ...await listContentFiles(dir, "knowledge")].filter((path) => !referenced.has(path)).map((path) => ({
+		file: path,
+		line: 1,
+		col: 1,
+		severity: "warning",
+		code: "W015",
+		message: `'${path}' is not referenced by any guide or teach statement — it will not be included in the bundle`
+	}));
+}
+async function collectFiles(dir, descriptionFile, mergedBehaviorText, mergeSources, personaFile) {
+	const files = /* @__PURE__ */ new Map();
+	files.set(descriptionFile, await readFile(join(dir, descriptionFile), "utf-8"));
+	const flatBehaviorText = mergedBehaviorText.replace(/^\s*merge\s+"[^"]*"\s*$/gm, "");
+	files.set("agent.behavior", flatBehaviorText);
+	for (const relPath of mergeSources) files.set(`behaviors/${relPath}`, await readFile(join(dir, relPath), "utf-8"));
+	if (personaFile) {
+		if (isExternalPath(dir, personaFile)) throw new Error(`E014: persona path '${personaFile}' in '${descriptionFile}' is absolute or escapes the agent root`);
+		let personaText;
+		try {
+			personaText = await readFile(join(dir, personaFile), "utf-8");
+		} catch {
+			throw new Error(`E_DESC: persona file '${personaFile}' declared in '${descriptionFile}' not found`);
+		}
+		files.set(personaFile, personaText);
+	}
+	const refs = await collectBehaviorFileRefs(mergedBehaviorText);
+	for (const { kind, text } of refs.values()) {
+		if (isExternalPath(dir, text)) throw new Error(`E014: '${kind}' path '${text}' is absolute or escapes the agent root`);
+		const ns = namespaceOf(kind);
+		const nsPath = `${ns}/${text}`;
+		let content;
+		for (const candidate of [join(dir, ns, text), join(dir, text)]) try {
+			content = await readFile(candidate, "utf-8");
+			break;
+		} catch {}
+		if (content === void 0) throw new Error(`E018: '${kind}' file '${text}' referenced in agent.behavior not found in ${dir} — looked for '${nsPath}' and '${text}'`);
+		files.set(nsPath, content);
+	}
+	return files;
+}
+function withAgentExtension(path) {
+	return path.endsWith(".agent") ? path : `${path}.agent`;
+}
+async function pack(options = {}) {
+	const dir = options.dir ?? process.cwd();
+	const outPath = withAgentExtension(options.out ?? join(dir, basename(dir)));
+	const descriptionFileName = await discoverDescriptionFile(dir, options.description);
+	const descriptionText = await readFile(join(dir, descriptionFileName), "utf-8");
+	const descriptionMessages = await lintDescription(descriptionText, descriptionFileName);
+	const descErrors = descriptionMessages.filter((m) => m.severity === "error");
+	if (descErrors.length > 0) throw new Error(`Lint failed:\n${descErrors.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;
+	if (!df.behavior) throw new Error(`E_DESC: '${descriptionFileName}' must declare a behavior file — add 'behavior "agent.behavior"' (or the name of your entry .behavior file)`);
+	if (isExternalPath(dir, df.behavior)) throw new Error(`E014: behavior path '${df.behavior}' in '${descriptionFileName}' is absolute or escapes the agent root`);
+	const { mergedText, mergeSources } = await consolidate(dir, df.behavior);
+	const behaviorMessages = await lintBehavior(mergedText, "agent.behavior", void 0, true);
+	const allMessages = [...descriptionMessages, ...behaviorMessages];
+	const errors = allMessages.filter((m) => m.severity === "error");
+	const lintWarnings = allMessages.filter((m) => m.severity === "warning");
+	if (errors.length > 0) throw new Error(`Lint failed:\n${errors.map((e) => `  ${e.file}:${e.line}:${e.col} ${e.code} ${e.message}`).join("\n")}`);
+	const version = await resolveVersionInteractive(options.version);
+	const commit = await resolveCommit(options.commit);
+	const allFiles = await collectFiles(dir, descriptionFileName, mergedText, mergeSources, df.persona ?? void 0);
+	const warnings = [...lintWarnings, ...await findOrphanContentFiles(dir, mergedText)];
+	const contentForHash = Array.from(allFiles.values()).join("");
+	const sha256 = createHash("sha256").update(contentForHash).digest("hex");
+	const id = buildId({
+		namespace: df.agent.domain ?? "unknown",
+		name: slugify(df.agent.name),
+		version,
+		digest: version ? commit : void 0
+	});
+	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: version ?? "",
+		domain: df.agent.domain ?? "",
+		license: df.agent.license ?? "",
+		persona: df.persona ?? void 0,
+		purpose: "unknown",
+		compiler: `dot-agent/${COMPILER_VERSION}`,
+		commit,
+		capabilities: df.capabilities.map((c) => ({
+			id: c.name,
+			description: c.description ?? ""
+		})),
+		requires: df.requires,
+		integrity
+	});
+	const zip = new JSZip();
+	const agentFolder = zip.folder(".agent");
+	agentFolder.file("aboutme.json", aboutmeToJson(aboutme));
+	if (typesJson) agentFolder.file("types.json", typesJson);
+	const filesJson = {
+		description: descriptionFileName,
+		behavior: "agent.behavior",
+		...df.persona ? { persona: df.persona } : {},
+		behaviors: Array.from(allFiles.keys()).filter((f) => f.startsWith("behaviors/")),
+		guides: Array.from(allFiles.keys()).filter((f) => f.startsWith("guides/")),
+		knowledge: Array.from(allFiles.keys()).filter((f) => f.startsWith("knowledge/"))
+	};
+	agentFolder.file("files.json", JSON.stringify(filesJson, null, 2));
+	for (const [path, content] of allFiles) zip.file(path, content);
+	await writeZip(zip, outPath);
+	return {
+		path: outPath,
+		id,
+		warnings
+	};
+}
+//#endregion
+//#region src/bundle.ts
+async function bundleFromDir(dir) {
+	const descriptionFileName = await discoverDescriptionFile(dir);
+	const descriptionText = await readFile(join(dir, descriptionFileName), "utf-8");
+	const descMessages = await lintDescription(descriptionText, descriptionFileName);
+	const descErrors = descMessages.filter((m) => m.severity === "error");
+	if (descErrors.length > 0) throw new Error(`Lint failed:\n${descErrors.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;
+	if (!df.behavior) throw new Error(`E_DESC: '${descriptionFileName}' must declare a behavior file`);
+	const { mergedText, mergeSources } = await consolidate(dir, df.behavior);
+	const behaviorMessages = await lintBehavior(mergedText, "agent.behavior", void 0, true);
+	const orphanMessages = await findOrphanContentFiles(dir, mergedText);
+	const allMessages = [
+		...descMessages,
+		...behaviorMessages,
+		...orphanMessages
+	];
+	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:\n${errors.map((e) => `  ${e.file}:${e.line}:${e.col} ${e.code} ${e.message}`).join("\n")}`);
+	for (const w of warnings) process.stderr.write(`\x1b[33m⚠\x1b[0m ${w.file}:${w.line}:${w.col} ${w.code} ${w.message}\n`);
+	const allFiles = await collectFiles(dir, descriptionFileName, mergedText, mergeSources, df.persona ?? void 0);
+	const sha256 = createHash("sha256").update(Array.from(allFiles.values()).join("")).digest("hex");
+	const id = buildId({
+		namespace: df.agent.domain ?? "unknown",
+		name: slugify(df.agent.name),
+		version: "dev"
+	});
+	return {
+		id,
+		aboutme: buildAboutme({
+			id,
+			name: df.agent.name,
+			description: df.description ?? "",
+			version: "dev",
+			domain: df.agent.domain ?? "",
+			license: df.agent.license ?? "",
+			persona: df.persona ?? void 0,
+			purpose: "development",
+			compiler: `dot-agent/${COMPILER_VERSION}`,
+			capabilities: df.capabilities.map((c) => ({
+				id: c.name,
+				description: c.description ?? ""
+			})),
+			requires: df.requires,
+			integrity: {
+				sha256,
+				files: ".agent/files.json"
+			}
+		}),
+		files: {
+			description: descriptionText,
+			behavior: allFiles.get("agent.behavior") ?? mergedText,
+			persona: df.persona ? allFiles.get(df.persona) : void 0,
+			guides: Array.from(allFiles.entries()).filter(([p]) => p.startsWith("guides/")).map(([path, content]) => ({
+				path,
+				content
+			})),
+			knowledge: Array.from(allFiles.entries()).filter(([p]) => p.startsWith("knowledge/")).map(([path, content]) => ({
+				path,
+				content
+			})),
+			behaviors: Array.from(allFiles.entries()).filter(([p]) => p.startsWith("behaviors/")).map(([path, content]) => ({
+				path,
+				content
+			}))
+		}
+	};
+}
+//#endregion
+export { aboutmeToJson, buildAboutme, buildId, bundleFromDir, collectFiles, consolidate, 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.mjs.map