@dot-agent/compiler 0.10.2 → 0.12.0-alpha.0

package/dist/index.d.mts

@@ -2,15 +2,15 @@ import { A as PackOptions, C as Capability, D as LangId, E as Integrity, F as St
 import { Node, Tree } from "web-tree-sitter";
 import JSZip from "jszip";
 //#region src/parser.d.ts
-declare function initBehaviorParser(): Promise<void>;
+export declare function initBehaviorParser(): Promise<void>;
 interface ParseResult<T> {
   ok: T | null;
   diagnostics: ParseDiagnostic[];
 }
-declare function parseBehaviorFile(text: string): ParseResult<BehaviorFile>;
-declare function parseDescriptionFile(text: string): ParseResult<DescriptionFile>;
-declare function getBehaviorScxml(text: string): string;
-declare function initParsers(): Promise<void>;
+export declare function parseBehaviorFile(text: string): ParseResult<BehaviorFile>;
+export declare function parseDescriptionFile(text: string): ParseResult<DescriptionFile>;
+export declare function getBehaviorScxml(text: string): string;
+export declare function initParsers(): Promise<void>;
 /**
  * Parse source text and return a tree-sitter Tree.
  *
@@ -18,12 +18,12 @@ declare function initParsers(): Promise<void>;
  * @param text    - source text to parse
  * @param previousTree - optional previous tree for incremental parsing (LSP use)
  */
-declare function parse(langId: LangId, text: string, previousTree?: Tree): Promise<Tree>;
+export declare function parse(langId: LangId, text: string, previousTree?: Tree): Promise<Tree>;
 /** Parse without initializing if parsers are already ready. Returns null if not initialized. */
-declare function parseSync(langId: LangId, text: string, previousTree?: Tree): Tree | null;
-declare function nodesOfType(tree: Tree, type: string): Node[];
-declare function nodeAtOffset(tree: Tree, offset: number): Node | null;
-declare function nodeToRange(node: Node): {
+export declare function parseSync(langId: LangId, text: string, previousTree?: Tree): Tree | null;
+export declare function nodesOfType(tree: Tree, type: string): Node[];
+export declare function nodeAtOffset(tree: Tree, offset: number): Node | null;
+export declare function nodeToRange(node: Node): {
   start: {
     line: number;
     character: number;
@@ -33,34 +33,34 @@ declare function nodeToRange(node: Node): {
     character: number;
   };
 };
-declare function positionToOffset(text: string, line: number, character: number): number;
-declare function getContextNode(tree: Tree, offset: number): Node;
+export declare function positionToOffset(text: string, line: number, character: number): number;
+export declare function getContextNode(tree: Tree, offset: number): Node;
 //#endregion
 //#region src/linter.d.ts
-declare function lintDescription(text: string, file?: string): Promise<LintMessage[]>;
-declare function lintBehavior(text: string, file?: string, docPath?: string, consolidated?: boolean, externalStates?: Set<string>, mergedText?: string): Promise<LintMessage[]>;
-declare function createLinter(): Promise<{
+export declare function lintDescription(text: string, file?: string): Promise<LintMessage[]>;
+export declare function lintBehavior(text: string, file?: string, docPath?: string, consolidated?: boolean, externalStates?: Set<string>, mergedText?: string): Promise<LintMessage[]>;
+export declare function createLinter(): Promise<{
   lintDescription: typeof lintDescription;
   lintBehavior: typeof lintBehavior;
 }>;
 //#endregion
 //#region src/zip.d.ts
-declare function readZip(filePath: string): Promise<JSZip>;
-declare function validateZipBomb(filePath: string): Promise<boolean>;
-declare function validateMagicBytes(filePath: string): Promise<boolean>;
-declare function writeZip(zip: JSZip, outPath: string): Promise<void>;
+export declare function readZip(filePath: string): Promise<JSZip>;
+export declare function validateZipBomb(filePath: string): Promise<boolean>;
+export declare function validateMagicBytes(filePath: string): Promise<boolean>;
+export declare function writeZip(zip: JSZip, outPath: string): Promise<void>;
 //#endregion
 //#region src/pack.d.ts
 interface ConsolidateResult {
   mergedText: string;
   mergeSources: string[];
 }
-declare function consolidate(agentRoot: string, entryFile: string): Promise<ConsolidateResult>;
-declare function collectFiles(dir: string, descriptionFile: string, mergedBehaviorText: string, mergeSources: string[], personaFile?: string): Promise<Map<string, string>>;
-declare function pack(options?: PackOptions): Promise<PackResult>;
+export declare function consolidate(agentRoot: string, entryFile: string): Promise<ConsolidateResult>;
+export declare function collectFiles(dir: string, descriptionFile: string, mergedBehaviorText: string, mergeSources: string[], personaFile?: string): Promise<Map<string, string>>;
+export declare function pack(options?: PackOptions): Promise<PackResult>;
 //#endregion
 //#region src/bundle.d.ts
-declare function bundleFromDir(dir: string): Promise<AgentBundle>;
+export declare function bundleFromDir(dir: string): Promise<AgentBundle>;
 //#endregion
-export { type AboutMe, type AgentBundle, type AgentDecl, type AgentFiles, type AnnotatedRef, type BehaviorFile, type BuildAboutmeOptions, CONTENT_NAMESPACES, type Capability, type ContentNamespace, type DescriptionFile, type IdParts, type Integrity, type LangId, type LintMessage, type OntologyRef, type PackOptions, type PackResult, type PropertyDecl, type PropertyType, type StateDef, type Statement, type TriggerDecl, type TypeDefinition, aboutmeToJson, buildAboutme, buildId, bundleFromDir, classifyContentPath, collectFiles, consolidate, createLinter, createZip, extractDigest, extractFiles, extractName, getBehaviorScxml, getContextNode, initBehaviorParser, initParsers, isInContentNamespace, lintBehavior, lintDescription, nodeAtOffset, nodeToRange, nodesOfType, pack, parse, parseAboutme, parseBehaviorFile, parseDescriptionFile, parseId, parseSync, positionToOffset, readZip, validateMagicBytes, validateZipBomb, writeZip };
+export { type AboutMe, type AgentBundle, type AgentDecl, type AgentFiles, type AnnotatedRef, type BehaviorFile, type BuildAboutmeOptions, CONTENT_NAMESPACES, type Capability, type ContentNamespace, type DescriptionFile, type IdParts, type Integrity, type LangId, type LintMessage, type OntologyRef, type PackOptions, type PackResult, type PropertyDecl, type PropertyType, type StateDef, type Statement, type TriggerDecl, type TypeDefinition, aboutmeToJson, buildAboutme, buildId, classifyContentPath, createZip, extractDigest, extractFiles, extractName, isInContentNamespace, parseAboutme, parseId };
 //# sourceMappingURL=index.d.mts.map

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/parser.ts","../src/linter.ts","../src/zip.ts","../src/pack.ts","../src/bundle.ts"],"mappings":";;;;iBAyBsB,sBAAsB;UAM3B,YAAY;EAC3B,IAAI;EACJ,aAAa;;iBAGC,kBAAkB,eAAe,YAAY;iBAI7C,qBAAqB,eAAe,YAAY;iBAIhD,iBAAiB;iBAIX,eAAe;;;;;;;;iBAmBf,MACpB,QAAQ,QACR,cACA,eAAe,OACd,QAAQ;;iBAOK,UAAU,QAAQ,QAAQ,cAAc,eAAe,OAAO;iBAQ9D,YAAY,MAAM,MAAM,eAAe;iBAKvC,aAAa,MAAM,MAAM,iBAAiB;iBAK1C,YAAY,MAAM;EAChC;IAAS;IAAc;;EACvB;IAAO;IAAc;;;iBAQP,iBAAiB,cAAc,cAAc;iBAS7C,eAAe,MAAM,MAAM,iBAAiB;;;iBCtCtC,gBAAgB,cAAc,gBAA6B,QAAQ;iBAqKnE,aACpB,cACA,eACA,kBACA,wBACA,iBAAiB,aACjB,sBACC,QAAQ;iBAgUW,gBAAY;;;;;;iBCniBZ,QAAQ,mBAAmB,QAAQ;iBAKnC,gBAAgB,mBAAmB;iBAOnC,mBAAmB,mBAAmB;iBAMtC,SAAS,KAAK,OAAO,kBAAkB;;;UC6HnD;EACR;EACA;;iBAGoB,YAAY,mBAAmB,oBAAoB,QAAQ;iBAoN3D,aACpB,aACA,yBACA,4BACA,wBACA,uBACC,QAAQ;iBAiFW,KAAK,UAAS,cAAmB,QAAQ;;;iBCjczC,cAAc,cAAc,QAAQ"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/parser.ts","../src/linter.ts","../src/zip.ts","../src/pack.ts","../src/bundle.ts"],"mappings":";;;;wBAmBsB,sBAAsB;UAM3B,YAAY;EAC3B,IAAI;EACJ,aAAa;;wBAGC,kBAAkB,eAAe,YAAY;wBAI7C,qBAAqB,eAAe,YAAY;wBAIhD,iBAAiB;wBAIX,eAAe;;;;;;;;wBAmBf,MACpB,QAAQ,QACR,cACA,eAAe,OACd,QAAQ;;wBAOK,UAAU,QAAQ,QAAQ,cAAc,eAAe,OAAO;wBAQ9D,YAAY,MAAM,MAAM,eAAe;wBAKvC,aAAa,MAAM,MAAM,iBAAiB;wBAK1C,YAAY,MAAM;EAChC;IAAS;IAAc;;EACvB;IAAO;IAAc;;;wBAQP,iBAAiB,cAAc,cAAc;wBAS7C,eAAe,MAAM,MAAM,iBAAiB;;;wBCxCtC,gBAAgB,cAAc,gBAA6B,QAAQ;wBAqKnE,aACpB,cACA,eACA,kBACA,wBACA,iBAAiB,aACjB,sBACC,QAAQ;wBAuXW,gBAAY;;;;;;wBC9lBZ,QAAQ,mBAAmB,QAAQ;wBAKnC,gBAAgB,mBAAmB;wBAOnC,mBAAmB,mBAAmB;wBAMtC,SAAS,KAAK,OAAO,kBAAkB;;;UCmInD;EACR;EACA;;wBAGoB,YAAY,mBAAmB,oBAAoB,QAAQ;wBAqN3D,aACpB,aACA,yBACA,4BACA,wBACA,uBACC,QAAQ;wBAkFW,KAAK,UAAS,cAAmB,QAAQ;;;wBCnczC,cAAc,cAAc,QAAQ"}

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import { _ as COMPILER_VERSION, a as extractFiles, c as buildId, d as isValidVersion, f as parseId, g as parseAboutme, h as buildAboutme, i as createZip, l as extractDigest, m as aboutmeToJson, n as classifyContentPath, o as validateMagicBytes$1, p as slugify, r as isInContentNamespace, s as validateZipBomb$1, t as CONTENT_NAMESPACES, u as extractName } from "./namespace-CjeG5-7u.mjs";
+import { _ as COMPILER_VERSION, a as extractFiles, c as buildId, d as isValidVersion, f as parseId, g as parseAboutme, h as buildAboutme, i as createZip, l as extractDigest, m as aboutmeToJson, n as classifyContentPath, o as validateMagicBytes$1, p as slugify, r as isInContentNamespace, s as validateZipBomb$1, t as CONTENT_NAMESPACES, u as extractName } from "./namespace-B8prujsD.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";
@@ -257,7 +257,8 @@ function collectMergedStates(tree, docDir, states, visited = /* @__PURE__ */ new
 	for (const mergeNode of nodesOfType(tree, "merge_decl")) {
 		const pathNode = mergeNode.childForFieldName("path");
 		if (!pathNode) continue;
-		const absPath = resolve(docDir, pathNode.text.replace(/^"|"$/g, ""));
+		const filename = pathNode.text.replace(/^"|"$/g, "");
+		const absPath = resolve(docDir, filename);
 		if (visited.has(absPath)) continue;
 		visited.add(absPath);
 		let mergedText;
@@ -287,6 +288,8 @@ async function lintBehavior(text, file = "agent.behavior", docPath, consolidated
 		const stateName = nameNode?.text ?? "?";
 		const hasInteract = stateNode.descendantsOfType("interact_stmt").length > 0;
 		const hasGoal = stateNode.descendantsOfType("goal_stmt").length > 0;
+		const hasGuide = stateNode.descendantsOfType("guide_stmt").length > 0;
+		const hasTeach = stateNode.descendantsOfType("teach_stmt").length > 0;
 		const intentHandlers = stateNode.descendantsOfType("intent_handler");
 		if (hasInteract && !hasGoal) {
 			const { line, col } = nodePosition(nameNode ?? stateNode);
@@ -299,17 +302,54 @@ async function lintBehavior(text, file = "agent.behavior", docPath, consolidated
 				message: `'interact' without 'goal'. Add 'goal "..."' before 'interact'.`
 			});
 		}
-		if (hasGoal && !hasInteract) {
+		const presentOrientationNames = [
+			hasGoal && "goal",
+			hasGuide && "guide",
+			hasTeach && "teach"
+		].filter((n) => n !== false);
+		if (presentOrientationNames.length > 0 && !hasInteract) {
 			const { line, col } = nodePosition(nameNode ?? stateNode);
+			const list = presentOrientationNames.map((n) => `'${n}'`).join(", ");
+			const isPlural = presentOrientationNames.length > 1;
 			messages.push({
 				file,
 				line,
 				col,
 				severity: "warning",
 				code: "W012",
-				message: `'goal' is only valid in an oriented state. Add 'interact' or remove 'goal'.`
+				message: `${list} ${isPlural ? "are" : "is"} only valid in an oriented state. Add 'interact' or remove ${isPlural ? "them" : "it"}.`
 			});
 		}
+		const bodyStmts = (stateNode.childForFieldName("body")?.children ?? []).filter((n) => n !== null);
+		const firstTransitionIndex = bodyStmts.findIndex((n) => n.type === "transition_stmt");
+		const interactsBeforeFirstTransition = bodyStmts.filter((n, i) => n.type === "interact_stmt" && (firstTransitionIndex === -1 || i < firstTransitionIndex));
+		if (interactsBeforeFirstTransition.length > 1) for (const dup of interactsBeforeFirstTransition.slice(1)) {
+			const { line, col } = nodePosition(dup);
+			messages.push({
+				file,
+				line,
+				col,
+				severity: "warning",
+				code: "W017",
+				message: `Duplicate 'interact' in state '${stateName}' before any transition. Only one 'interact' is allowed per state before a 'transition to' — a second one, still reachable in the same entry batch, emits a second 'request_interact' effect with no dedupe at the host layer.`
+			});
+		}
+		const leavingIndex = bodyStmts.findIndex((n) => n.type === "transition_stmt" && n.childForFieldName("state")?.text !== stateName);
+		if (leavingIndex !== -1) {
+			const target = bodyStmts[leavingIndex].childForFieldName("state")?.text ?? "?";
+			for (const stmt of bodyStmts.slice(leavingIndex + 1)) {
+				if (stmt.type === "intent_handler" || stmt.type === "offtopic_handler" || stmt.type === "comment") continue;
+				const { line, col } = nodePosition(stmt);
+				messages.push({
+					file,
+					line,
+					col,
+					severity: "warning",
+					code: "W018",
+					message: `Unreachable: state '${stateName}' leaves for '${target}' on entry before this statement runs. Everything after a state-level 'transition to' is skipped, like code after a return — move it before the transition or remove it.`
+				});
+			}
+		}
 		if (hasInteract && intentHandlers.length === 0) {
 			const { line, col } = nodePosition(nameNode ?? stateNode);
 			messages.push({
@@ -585,11 +625,13 @@ async function readZip(filePath) {
 }
 async function validateZipBomb(filePath) {
 	const data = await readFile(filePath);
-	validateZipBomb$1(await JSZip.loadAsync(data), data.length);
+	const zip = await JSZip.loadAsync(data);
+	validateZipBomb$1(zip, data.length);
 	return true;
 }
 async function validateMagicBytes(filePath) {
-	validateMagicBytes$1(await readFile(filePath));
+	const data = await readFile(filePath);
+	validateMagicBytes$1(data);
 	return true;
 }
 async function writeZip(zip, outPath) {
@@ -731,7 +773,8 @@ async function resolveVersionInteractive(explicit) {
 function isExternalPath(agentRoot, declaredPath) {
 	if (isAbsolute(declaredPath)) return true;
 	const normRoot = normalize(resolve(agentRoot));
-	return relative(normRoot, resolve(normRoot, declaredPath)).startsWith("..");
+	const resolved = resolve(normRoot, declaredPath);
+	return relative(normRoot, resolved).startsWith("..");
 }
 async function discoverDescriptionFile(dir, explicit) {
 	if (explicit) try {
@@ -813,7 +856,6 @@ function collectFileRefs(stmts, out) {
 		case "conditional_stmt":
 			collectFileRefs(s.then, out);
 			if (s.else) collectFileRefs(s.else, out);
-			break;
 	}
 }
 function normalizeRefPath(text) {
@@ -865,9 +907,9 @@ async function findOrphanContentFiles(dir, mergedBehaviorText) {
 			file: bundlePath,
 			line: 1,
 			col: 1,
-			severity: "warning",
-			code: "W016",
-			message: `'${kind}' reference '${text}' resolves outside guides/ or knowledge/ — it will be bundled but is unreachable at runtime; move it under knowledge/ (or guides/) and reference it there`
+			severity: "error",
+			code: "E022",
+			message: `'${kind}' reference '${text}' resolves to '${bundlePath}', which is outside guides/ and knowledge/ — those are the only two directories the runtime can serve content from; move '${bundlePath}' under guides/ or knowledge/ and update the '${kind}' statement to reference it there`
 		});
 	}
 	return [...[...await listContentFiles(dir, "guides"), ...await listContentFiles(dir, "knowledge")].filter((path) => !referenced.has(path)).map((path) => ({
@@ -939,11 +981,15 @@ async function pack(options = {}) {
 	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 contentMessages = await findOrphanContentFiles(dir, mergedText);
+	const contentErrors = contentMessages.filter((m) => m.severity === "error");
+	if (contentErrors.length > 0) throw new Error(`Lint failed:\n${contentErrors.map((e) => `  ${e.file}:${e.line}:${e.col} ${e.code} ${e.message}`).join("\n")}`);
+	const warnings = [...lintWarnings, ...contentMessages.filter((m) => m.severity === "warning")];
 	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: df.agent.domain ?? "unknown",
+		namespace,
 		name: slugify(df.agent.name),
 		version,
 		digest: version ? commit : void 0