unagent 0.0.3 → 0.0.4

package/dist/stop-B9w8PiPj.mjs

@@ -0,0 +1,39 @@
+import { r as calculateCost } from "./usage-DTaeWIUK.mjs";
+
+//#region src/stop/index.ts
+function iterationCountIs(max) {
+	return (ctx) => ctx.iteration >= max;
+}
+function tokenCountIs(max) {
+	return (ctx) => {
+		if (!ctx.usage) return false;
+		return ctx.usage.inputTokens + ctx.usage.outputTokens >= max;
+	};
+}
+function costIs(maxDollars, rates) {
+	return (ctx) => {
+		if (!ctx.usage) return false;
+		return calculateCost(ctx.usage, rates) >= maxDollars;
+	};
+}
+function timeout(ms) {
+	return (ctx) => Date.now() - ctx.startTime >= ms;
+}
+function and(...conditions) {
+	return async (ctx) => {
+		for (const condition of conditions) if (!await condition(ctx)) return false;
+		return true;
+	};
+}
+function or(...conditions) {
+	return async (ctx) => {
+		for (const condition of conditions) if (await condition(ctx)) return true;
+		return false;
+	};
+}
+function not(condition) {
+	return async (ctx) => !await condition(ctx);
+}
+
+//#endregion
+export { or as a, not as i, costIs as n, timeout as o, iterationCountIs as r, tokenCountIs as s, and as t };

package/dist/stream/index.d.mts

@@ -0,0 +1,3 @@
+import "../index-ucMWydcs.mjs";
+import { a as createStreamResult, i as StreamResultOptions, n as StreamPart, o as formatSSE, r as StreamResult, s as parseSSE, t as SSEParser } from "../index-D5A0wwzb.mjs";
+export { SSEParser, StreamPart, StreamResult, StreamResultOptions, createStreamResult, formatSSE, parseSSE };

package/dist/stream/index.mjs

@@ -0,0 +1,3 @@
+import { i as parseSSE, n as createStreamResult, r as formatSSE, t as SSEParser } from "../stream-CzGvLSeV.mjs";
+
+export { SSEParser, createStreamResult, formatSSE, parseSSE };

package/dist/stream-CzGvLSeV.mjs

@@ -0,0 +1,99 @@
+//#region src/stream/index.ts
+function createStreamResult(options) {
+	const { stream, getValue } = options;
+	let consumed = false;
+	const parts = [];
+	async function* wrapStream() {
+		for await (const part of stream) {
+			parts.push(part);
+			yield part;
+		}
+		consumed = true;
+	}
+	const wrappedStream = wrapStream();
+	return {
+		get value() {
+			return getValue();
+		},
+		get stream() {
+			return wrappedStream;
+		},
+		toResponse() {
+			const encoder = new TextEncoder();
+			const readable = new ReadableStream({ async start(controller) {
+				for await (const part of wrappedStream) if (part.type === "text") controller.enqueue(encoder.encode(part.data));
+				controller.close();
+			} });
+			return new Response(readable, { headers: { "Content-Type": "text/plain; charset=utf-8" } });
+		},
+		toSSEResponse() {
+			const encoder = new TextEncoder();
+			const readable = new ReadableStream({ async start(controller) {
+				for await (const part of wrappedStream) {
+					const data = part.type === "error" ? {
+						type: part.type,
+						data: { message: part.data.message }
+					} : part;
+					controller.enqueue(encoder.encode(formatSSE(part.type, data)));
+				}
+				controller.close();
+			} });
+			return new Response(readable, { headers: {
+				"Content-Type": "text/event-stream",
+				"Cache-Control": "no-cache",
+				"Connection": "keep-alive"
+			} });
+		},
+		async consumeStream() {
+			if (consumed) return;
+			for await (const _part of wrappedStream);
+		}
+	};
+}
+function formatSSE(event, data) {
+	return `event: ${event}\ndata: ${JSON.stringify(data)}\n\n`;
+}
+function parseSSE(line) {
+	const trimmed = line.trim();
+	if (!trimmed || trimmed.startsWith(":")) return null;
+	if (trimmed.startsWith("event:")) return { event: trimmed.slice(6).trim() };
+	if (trimmed.startsWith("data:")) return { data: trimmed.slice(5).trim() };
+	return null;
+}
+var SSEParser = class {
+	currentEvent;
+	dataBuffer = [];
+	parse(chunk) {
+		const results = [];
+		const lines = chunk.split("\n");
+		for (const line of lines) {
+			const trimmed = line.trim();
+			if (!trimmed) {
+				if (this.dataBuffer.length > 0) {
+					const dataStr = this.dataBuffer.join("\n");
+					try {
+						results.push({
+							event: this.currentEvent,
+							data: JSON.parse(dataStr)
+						});
+					} catch {
+						results.push({
+							event: this.currentEvent,
+							data: dataStr
+						});
+					}
+					this.currentEvent = void 0;
+					this.dataBuffer = [];
+				}
+				continue;
+			}
+			if (trimmed.startsWith(":")) continue;
+			if (trimmed.startsWith("event:")) this.currentEvent = trimmed.slice(6).trim();
+			else if (trimmed.startsWith("data:")) this.dataBuffer.push(trimmed.slice(5).trim());
+		}
+		return results;
+	}
+};
+
+//#endregion
+export { parseSSE as i, createStreamResult as n, formatSSE as r, SSEParser as t };

package/dist/tool/index.d.mts

@@ -0,0 +1,2 @@
+import { a as defineTool, i as ToolParameter, n as JSONSchemaProperty, o as toolToSchema, r as ToolDefinition, s as toolsToSchema, t as JSONSchema } from "../index-DShEKmmL.mjs";
+export { JSONSchema, JSONSchemaProperty, ToolDefinition, ToolParameter, defineTool, toolToSchema, toolsToSchema };

package/dist/tool/index.mjs

@@ -0,0 +1,3 @@
+import { n as toolToSchema, r as toolsToSchema, t as defineTool } from "../tool-CESxMfOv.mjs";
+
+export { defineTool, toolToSchema, toolsToSchema };

package/dist/tool-CESxMfOv.mjs

@@ -0,0 +1,45 @@
+//#region src/tool/index.ts
+function defineTool(tool) {
+	return tool;
+}
+function parameterToJSONSchema(param) {
+	const schema = { type: param.type };
+	if (param.description) schema.description = param.description;
+	if (param.enum) schema.enum = param.enum;
+	if (param.default !== void 0) schema.default = param.default;
+	if (param.type === "array" && param.items) schema.items = parameterToJSONSchema(param.items);
+	if (param.type === "object" && param.properties) {
+		schema.properties = {};
+		const required = [];
+		for (const [key, value] of Object.entries(param.properties)) {
+			schema.properties[key] = parameterToJSONSchema(value);
+			if (value.required) required.push(key);
+		}
+		if (required.length > 0) schema.required = required;
+	}
+	return schema;
+}
+function toolToSchema(tool) {
+	const properties = {};
+	const required = [];
+	if (tool.parameters) for (const [key, param] of Object.entries(tool.parameters)) {
+		properties[key] = parameterToJSONSchema(param);
+		if (param.required) required.push(key);
+	}
+	return {
+		name: tool.name,
+		description: tool.description,
+		input_schema: {
+			type: "object",
+			properties,
+			...required.length > 0 ? { required } : {},
+			additionalProperties: false
+		}
+	};
+}
+function toolsToSchema(tools) {
+	return tools.map(toolToSchema);
+}
+
+//#endregion
+export { toolToSchema as n, toolsToSchema as r, defineTool as t };

package/dist/usage/index.d.mts

@@ -0,0 +1,2 @@
+import { a as calculateCost, i as aggregateUsage, n as MODEL_PRICING, o as getRatesForModel, r as UsageInfo, t as CostRates } from "../index-ucMWydcs.mjs";
+export { CostRates, MODEL_PRICING, UsageInfo, aggregateUsage, calculateCost, getRatesForModel };

package/dist/usage/index.mjs

@@ -0,0 +1,3 @@
+import { i as getRatesForModel, n as aggregateUsage, r as calculateCost, t as MODEL_PRICING } from "../usage-DTaeWIUK.mjs";
+
+export { MODEL_PRICING, aggregateUsage, calculateCost, getRatesForModel };

package/dist/usage-DTaeWIUK.mjs

@@ -0,0 +1,165 @@
+//#region src/usage/index.ts
+function calculateCost(usage, rates) {
+	let cost = 0;
+	cost += usage.inputTokens / 1e6 * rates.inputCostPerMillionTokens;
+	cost += usage.outputTokens / 1e6 * rates.outputCostPerMillionTokens;
+	if (usage.cacheReadTokens && rates.cacheReadCostPerMillionTokens) cost += usage.cacheReadTokens / 1e6 * rates.cacheReadCostPerMillionTokens;
+	if (usage.cacheWriteTokens && rates.cacheWriteCostPerMillionTokens) cost += usage.cacheWriteTokens / 1e6 * rates.cacheWriteCostPerMillionTokens;
+	return cost;
+}
+function aggregateUsage(...usages) {
+	const result = usages.reduce((acc, usage) => ({
+		inputTokens: acc.inputTokens + usage.inputTokens,
+		outputTokens: acc.outputTokens + usage.outputTokens,
+		cacheReadTokens: (acc.cacheReadTokens ?? 0) + (usage.cacheReadTokens ?? 0),
+		cacheWriteTokens: (acc.cacheWriteTokens ?? 0) + (usage.cacheWriteTokens ?? 0)
+	}), {
+		inputTokens: 0,
+		outputTokens: 0,
+		cacheReadTokens: 0,
+		cacheWriteTokens: 0
+	});
+	const hasCacheRead = usages.some((u) => u.cacheReadTokens !== void 0);
+	const hasCacheWrite = usages.some((u) => u.cacheWriteTokens !== void 0);
+	return {
+		inputTokens: result.inputTokens,
+		outputTokens: result.outputTokens,
+		...hasCacheRead && { cacheReadTokens: result.cacheReadTokens },
+		...hasCacheWrite && { cacheWriteTokens: result.cacheWriteTokens }
+	};
+}
+const MODEL_PRICING = {
+	"claude-opus-4-20250514": {
+		inputCostPerMillionTokens: 15,
+		outputCostPerMillionTokens: 75,
+		cacheReadCostPerMillionTokens: 1.5,
+		cacheWriteCostPerMillionTokens: 18.75
+	},
+	"claude-sonnet-4-20250514": {
+		inputCostPerMillionTokens: 3,
+		outputCostPerMillionTokens: 15,
+		cacheReadCostPerMillionTokens: .3,
+		cacheWriteCostPerMillionTokens: 3.75
+	},
+	"claude-3-7-sonnet-20250219": {
+		inputCostPerMillionTokens: 3,
+		outputCostPerMillionTokens: 15,
+		cacheReadCostPerMillionTokens: .3,
+		cacheWriteCostPerMillionTokens: 3.75
+	},
+	"claude-3-5-sonnet-20241022": {
+		inputCostPerMillionTokens: 3,
+		outputCostPerMillionTokens: 15,
+		cacheReadCostPerMillionTokens: .3,
+		cacheWriteCostPerMillionTokens: 3.75
+	},
+	"claude-3-5-haiku-20241022": {
+		inputCostPerMillionTokens: .8,
+		outputCostPerMillionTokens: 4,
+		cacheReadCostPerMillionTokens: .08,
+		cacheWriteCostPerMillionTokens: 1
+	},
+	"claude-3-opus-20240229": {
+		inputCostPerMillionTokens: 15,
+		outputCostPerMillionTokens: 75,
+		cacheReadCostPerMillionTokens: 1.5,
+		cacheWriteCostPerMillionTokens: 18.75
+	},
+	"claude-3-haiku-20240307": {
+		inputCostPerMillionTokens: .25,
+		outputCostPerMillionTokens: 1.25,
+		cacheReadCostPerMillionTokens: .03,
+		cacheWriteCostPerMillionTokens: .3
+	},
+	"gpt-4o": {
+		inputCostPerMillionTokens: 2.5,
+		outputCostPerMillionTokens: 10
+	},
+	"gpt-4o-mini": {
+		inputCostPerMillionTokens: .15,
+		outputCostPerMillionTokens: .6
+	},
+	"gpt-4-turbo": {
+		inputCostPerMillionTokens: 10,
+		outputCostPerMillionTokens: 30
+	},
+	"gpt-4": {
+		inputCostPerMillionTokens: 30,
+		outputCostPerMillionTokens: 60
+	},
+	"gpt-3.5-turbo": {
+		inputCostPerMillionTokens: .5,
+		outputCostPerMillionTokens: 1.5
+	},
+	"o1": {
+		inputCostPerMillionTokens: 15,
+		outputCostPerMillionTokens: 60
+	},
+	"o1-mini": {
+		inputCostPerMillionTokens: 3,
+		outputCostPerMillionTokens: 12
+	},
+	"o3-mini": {
+		inputCostPerMillionTokens: 1.1,
+		outputCostPerMillionTokens: 4.4
+	},
+	"gemini-2.0-flash": {
+		inputCostPerMillionTokens: .1,
+		outputCostPerMillionTokens: .4
+	},
+	"gemini-1.5-pro": {
+		inputCostPerMillionTokens: 1.25,
+		outputCostPerMillionTokens: 5
+	},
+	"gemini-1.5-flash": {
+		inputCostPerMillionTokens: .075,
+		outputCostPerMillionTokens: .3
+	},
+	"mistral-large": {
+		inputCostPerMillionTokens: 2,
+		outputCostPerMillionTokens: 6
+	},
+	"mistral-small": {
+		inputCostPerMillionTokens: .2,
+		outputCostPerMillionTokens: .6
+	},
+	"codestral": {
+		inputCostPerMillionTokens: .3,
+		outputCostPerMillionTokens: .9
+	},
+	"command-r-plus": {
+		inputCostPerMillionTokens: 2.5,
+		outputCostPerMillionTokens: 10
+	},
+	"command-r": {
+		inputCostPerMillionTokens: .15,
+		outputCostPerMillionTokens: .6
+	},
+	"llama-3.1-405b": {
+		inputCostPerMillionTokens: 3,
+		outputCostPerMillionTokens: 3
+	},
+	"llama-3.1-70b": {
+		inputCostPerMillionTokens: .88,
+		outputCostPerMillionTokens: .88
+	},
+	"llama-3.1-8b": {
+		inputCostPerMillionTokens: .055,
+		outputCostPerMillionTokens: .055
+	},
+	"deepseek-chat": {
+		inputCostPerMillionTokens: .14,
+		outputCostPerMillionTokens: .28
+	},
+	"deepseek-reasoner": {
+		inputCostPerMillionTokens: .55,
+		outputCostPerMillionTokens: 2.19
+	}
+};
+function getRatesForModel(modelId) {
+	if (MODEL_PRICING[modelId]) return MODEL_PRICING[modelId];
+	for (const [key, rates] of Object.entries(MODEL_PRICING)) if (modelId.includes(key) || key.includes(modelId)) return rates;
+}
+
+//#endregion
+export { getRatesForModel as i, aggregateUsage as n, calculateCost as r, MODEL_PRICING as t };

package/dist/utils/index.d.mts

@@ -1,2 +1,2 @@
-import { a as truncate, c as bold, d as gray, f as green, h as yellow, i as pluralize, l as cyan, m as stripAnsi, n as shortenPath, o as ANSI, p as red, r as formatList, s as blue, t as expandPath, u as dim } from "../index-CzPUtptc.mjs";
+import { a as truncate, c as bold, d as gray, f as green, h as yellow, i as pluralize, l as cyan, m as stripAnsi, n as shortenPath, o as ANSI, p as red, r as formatList, s as blue, t as expandPath, u as dim } from "../index-CbYchDwg.mjs";
 export { ANSI, blue, bold, cyan, dim, expandPath, formatList, gray, green, pluralize, red, shortenPath, stripAnsi, truncate, yellow };

package/dist/utils/index.mjs

@@ -1,4 +1,4 @@
-import { n as shortenPath, t as expandPath } from "../path-D5oePhrf.mjs";
-import { a as blue, c as dim, d as red, f as stripAnsi, i as ANSI, l as gray, n as pluralize, o as bold, p as yellow, r as truncate, s as cyan, t as formatList, u as green } from "../utils-BpTrIde9.mjs";
+import { n as shortenPath, t as expandPath } from "../path-Dm-URQvz.mjs";
+import { a as blue, c as dim, d as red, f as stripAnsi, i as ANSI, l as gray, n as pluralize, o as bold, p as yellow, r as truncate, s as cyan, t as formatList, u as green } from "../utils-bP3i6rq3.mjs";
 
 export { ANSI, blue, bold, cyan, dim, expandPath, formatList, gray, green, pluralize, red, shortenPath, stripAnsi, truncate, yellow };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "unagent",
   "type": "module",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Unified agent primitives for AI coding agents",
   "author": "Maximilian Conradt <https://github.com/onmax>",
   "license": "MIT",
@@ -26,13 +26,29 @@
       "types": "./dist/index.d.mts",
       "default": "./dist/index.mjs"
     },
+    "./context": {
+      "types": "./dist/context/index.d.mts",
+      "default": "./dist/context/index.mjs"
+    },
     "./env": {
       "types": "./dist/env/index.d.mts",
       "default": "./dist/env/index.mjs"
     },
-    "./skill": {
-      "types": "./dist/skill/index.d.mts",
-      "default": "./dist/skill/index.mjs"
+    "./exec": {
+      "types": "./dist/exec/index.d.mts",
+      "default": "./dist/exec/index.mjs"
+    },
+    "./fs": {
+      "types": "./dist/fs/index.d.mts",
+      "default": "./dist/fs/index.mjs"
+    },
+    "./git": {
+      "types": "./dist/git/index.d.mts",
+      "default": "./dist/git/index.mjs"
+    },
+    "./hooks": {
+      "types": "./dist/hooks/index.d.mts",
+      "default": "./dist/hooks/index.mjs"
     },
     "./link": {
       "types": "./dist/link/index.d.mts",
@@ -42,13 +58,37 @@
       "types": "./dist/lock/index.d.mts",
       "default": "./dist/lock/index.mjs"
     },
+    "./registry": {
+      "types": "./dist/registry/index.d.mts",
+      "default": "./dist/registry/index.mjs"
+    },
+    "./sandbox": {
+      "types": "./dist/sandbox/index.d.mts",
+      "default": "./dist/sandbox/index.mjs"
+    },
+    "./skill": {
+      "types": "./dist/skill/index.d.mts",
+      "default": "./dist/skill/index.mjs"
+    },
     "./source": {
       "types": "./dist/source/index.d.mts",
       "default": "./dist/source/index.mjs"
     },
-    "./git": {
-      "types": "./dist/git/index.d.mts",
-      "default": "./dist/git/index.mjs"
+    "./stop": {
+      "types": "./dist/stop/index.d.mts",
+      "default": "./dist/stop/index.mjs"
+    },
+    "./stream": {
+      "types": "./dist/stream/index.d.mts",
+      "default": "./dist/stream/index.mjs"
+    },
+    "./tool": {
+      "types": "./dist/tool/index.d.mts",
+      "default": "./dist/tool/index.mjs"
+    },
+    "./usage": {
+      "types": "./dist/usage/index.d.mts",
+      "default": "./dist/usage/index.mjs"
     },
     "./utils": {
       "types": "./dist/utils/index.d.mts",
@@ -61,7 +101,24 @@
   "files": [
     "dist"
   ],
+  "peerDependencies": {
+    "@cloudflare/sandbox": ">=0.1.0",
+    "@vercel/sandbox": ">=0.1.0",
+    "unstorage": ">=1.10.0"
+  },
+  "peerDependenciesMeta": {
+    "@cloudflare/sandbox": {
+      "optional": true
+    },
+    "@vercel/sandbox": {
+      "optional": true
+    },
+    "unstorage": {
+      "optional": true
+    }
+  },
   "dependencies": {
+    "hookable": "^5.5.3",
     "pathe": "^2.0.3",
     "std-env": "^3.10.0",
     "yaml": "^2.7.0"

package/dist/index-BT7sxFbS.d.mts

@@ -1,47 +0,0 @@
-//#region src/skill/parse.d.ts
-interface SkillFrontmatter {
-  "name": string;
-  "description": string;
-  "license"?: string;
-  "compatibility"?: string;
-  "metadata"?: Record<string, string>;
-  "allowed-tools"?: string;
-  "globs"?: string | string[];
-  "alwaysApply"?: boolean;
-  "tags"?: string[];
-}
-interface ParsedSkill {
-  frontmatter: SkillFrontmatter;
-  content: string;
-  raw: string;
-}
-declare function parseSkillMd(content: string): ParsedSkill;
-declare function extractSkillName(frontmatter: SkillFrontmatter, filename?: string): string;
-/** @deprecated Use validateSkill from './validate' for spec-compliant validation */
-declare function validateSkillMd(parsed: ParsedSkill): string[];
-//#endregion
-//#region src/skill/discover.d.ts
-interface DiscoveredSkill {
-  path: string;
-  name: string;
-  parsed: ParsedSkill;
-}
-interface DiscoverOptions {
-  recursive?: boolean;
-}
-declare function discoverSkills(dir: string, options?: DiscoverOptions): DiscoveredSkill[];
-declare function filterSkills(skills: DiscoveredSkill[], query: string): DiscoveredSkill[];
-declare function findSkillByName(skills: DiscoveredSkill[], name: string): DiscoveredSkill | undefined;
-//#endregion
-//#region src/skill/prompt.d.ts
-declare function toPromptXml(skills: DiscoveredSkill[]): string;
-//#endregion
-//#region src/skill/validate.d.ts
-interface ValidationResult {
-  valid: boolean;
-  errors: string[];
-  warnings: string[];
-}
-declare function validateSkill(skill: ParsedSkill, dirName?: string): ValidationResult;
-//#endregion
-export { DiscoveredSkill as a, findSkillByName as c, extractSkillName as d, parseSkillMd as f, DiscoverOptions as i, ParsedSkill as l, validateSkill as n, discoverSkills as o, validateSkillMd as p, toPromptXml as r, filterSkills as s, ValidationResult as t, SkillFrontmatter as u };

package/dist/skill-Bnz84tJ5.mjs

@@ -1,125 +0,0 @@
-import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
-import { basename, join } from "pathe";
-import { parse } from "yaml";
-
-//#region src/skill/_frontmatter.ts
-function parseFrontmatter(input) {
-	const match = input.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
-	if (!match) return {
-		data: {},
-		content: input.trim()
-	};
-	return {
-		data: parse(match[1]),
-		content: match[2].trim()
-	};
-}
-
-//#endregion
-//#region src/skill/parse.ts
-function parseSkillMd(content) {
-	const { data, content: body } = parseFrontmatter(content);
-	return {
-		frontmatter: data,
-		content: body,
-		raw: content
-	};
-}
-function extractSkillName(frontmatter, filename) {
-	if (frontmatter.name) return frontmatter.name;
-	if (filename) return filename.replace(/\.md$/i, "").replace(/^SKILL[._-]?/i, "").replace(/[._-]/g, " ").trim();
-	return "Unnamed Skill";
-}
-/** @deprecated Use validateSkill from './validate' for spec-compliant validation */
-function validateSkillMd(parsed) {
-	const errors = [];
-	if (!parsed.content) errors.push("Skill content is empty");
-	if (parsed.frontmatter.globs) {
-		const globs = Array.isArray(parsed.frontmatter.globs) ? parsed.frontmatter.globs : [parsed.frontmatter.globs];
-		for (const glob of globs) if (typeof glob !== "string") errors.push(`Invalid glob pattern: ${glob}`);
-	}
-	return errors;
-}
-
-//#endregion
-//#region src/skill/discover.ts
-const SKILL_FILE = "SKILL.md";
-function discoverSkills(dir, options = {}) {
-	const { recursive = false } = options;
-	if (!existsSync(dir)) return [];
-	const skills = [];
-	const entries = readdirSync(dir);
-	for (const entry of entries) {
-		const fullPath = join(dir, entry);
-		if (!statSync(fullPath).isDirectory()) continue;
-		const skillFile = join(fullPath, SKILL_FILE);
-		if (existsSync(skillFile)) try {
-			const parsed = parseSkillMd(readFileSync(skillFile, "utf-8"));
-			skills.push({
-				path: fullPath,
-				name: basename(fullPath),
-				parsed
-			});
-		} catch {}
-		else if (recursive) skills.push(...discoverSkills(fullPath, options));
-	}
-	return skills;
-}
-function filterSkills(skills, query) {
-	const lowerQuery = query.toLowerCase();
-	return skills.filter((skill) => {
-		const nameMatch = skill.name.toLowerCase().includes(lowerQuery);
-		const descMatch = skill.parsed.frontmatter.description?.toLowerCase().includes(lowerQuery);
-		const tagMatch = skill.parsed.frontmatter.tags?.some((tag) => tag.toLowerCase().includes(lowerQuery));
-		return nameMatch || descMatch || tagMatch;
-	});
-}
-function findSkillByName(skills, name) {
-	const lowerName = name.toLowerCase();
-	return skills.find((skill) => skill.name.toLowerCase() === lowerName);
-}
-
-//#endregion
-//#region src/skill/prompt.ts
-function toPromptXml(skills) {
-	if (skills.length === 0) return "";
-	return `<available_skills>\n${skills.map((skill) => {
-		return `  <skill>
-    <name>${escapeXml(skill.name)}</name>
-    <description>${escapeXml(skill.parsed.frontmatter.description || "")}</description>
-    <location>${escapeXml(skill.path)}</location>
-  </skill>`;
-	}).join("\n")}\n</available_skills>`;
-}
-function escapeXml(str) {
-	return str.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
-}
-
-//#endregion
-//#region src/skill/validate.ts
-const NAME_PATTERN = /^[a-z][a-z0-9-]*[a-z0-9]$|^[a-z]$/;
-function validateSkill(skill, dirName) {
-	const errors = [];
-	const warnings = [];
-	const { frontmatter, content } = skill;
-	if (!frontmatter.name) errors.push("name is required");
-	else {
-		const name = frontmatter.name;
-		if (name.length < 1 || name.length > 64) errors.push("name must be 1-64 characters");
-		if (!NAME_PATTERN.test(name)) errors.push("name must be lowercase letters, numbers, and hyphens; cannot start/end with hyphen");
-		if (name.includes("--")) errors.push("name cannot contain consecutive hyphens");
-		if (dirName && name !== dirName) errors.push(`name "${name}" must match directory name "${dirName}"`);
-	}
-	if (!frontmatter.description) errors.push("description is required");
-	else if (frontmatter.description.length < 1 || frontmatter.description.length > 1024) errors.push("description must be 1-1024 characters");
-	if (frontmatter.compatibility && frontmatter.compatibility.length > 500) errors.push("compatibility must be max 500 characters");
-	if (!content) warnings.push("skill content is empty");
-	return {
-		valid: errors.length === 0,
-		errors,
-		warnings
-	};
-}
-
-//#endregion
-export { findSkillByName as a, validateSkillMd as c, filterSkills as i, toPromptXml as n, extractSkillName as o, discoverSkills as r, parseSkillMd as s, validateSkill as t };