@perstack/base 0.0.59 → 0.0.61

package/dist/bin/server.d.ts

@@ -1 +1 @@
-#!/usr/bin/env node
+export { };

package/dist/bin/server.js

@@ -1,18 +1,21 @@
 #!/usr/bin/env node
-import { package_default, createBaseServer } from '../chunk-SPQIG63O.js';
-import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
-import { Command } from 'commander';
+import { F as version, N as description, P as name, r as createBaseServer } from "../server-BM7K7dr8.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { Command } from "commander";
 
+//#region bin/server.ts
 async function main() {
-  const program = new Command();
-  program.name(package_default.name).description(package_default.description).version(package_default.version, "-v, --version", "display the version number").action(async () => {
-    const server = createBaseServer();
-    const transport = new StdioServerTransport();
-    console.error("Running @perstack/base version", package_default.version);
-    await server.connect(transport);
-  });
-  program.parse();
+	const program = new Command();
+	program.name(name).description(description).version(version, "-v, --version", "display the version number").action(async () => {
+		const server = createBaseServer();
+		const transport = new StdioServerTransport();
+		console.error("Running @perstack/base version", version);
+		await server.connect(transport);
+	});
+	program.parse();
 }
 main();
-//# sourceMappingURL=server.js.map
+
+//#endregion
+export {  };
 //# sourceMappingURL=server.js.map

package/dist/bin/server.js.map

@@ -1 +1 @@
-{"version":3,"sources":["../../bin/server.ts"],"names":[],"mappings":";;;;;AAOA,eAAe,IAAA,GAAO;AACpB,EAAA,MAAM,OAAA,GAAU,IAAI,OAAA,EAAQ;AAC5B,EAAA,OAAA,CACG,IAAA,CAAK,eAAA,CAAY,IAAI,CAAA,CACrB,YAAY,eAAA,CAAY,WAAW,CAAA,CACnC,OAAA,CAAQ,gBAAY,OAAA,EAAS,eAAA,EAAiB,4BAA4B,CAAA,CAC1E,OAAO,YAAY;AAClB,IAAA,MAAM,SAAS,gBAAA,EAAiB;AAChC,IAAA,MAAM,SAAA,GAAY,IAAI,oBAAA,EAAqB;AAC3C,IAAA,OAAA,CAAQ,KAAA,CAAM,gCAAA,EAAkC,eAAA,CAAY,OAAO,CAAA;AACnE,IAAA,MAAM,MAAA,CAAO,QAAQ,SAAS,CAAA;AAAA,EAChC,CAAC,CAAA;AACH,EAAA,OAAA,CAAQ,KAAA,EAAM;AAChB;AACA,IAAA,EAAK","file":"server.js","sourcesContent":["#!/usr/bin/env node\n\nimport { StdioServerTransport } from \"@modelcontextprotocol/sdk/server/stdio.js\"\nimport { Command } from \"commander\"\nimport packageJson from \"../package.json\" with { type: \"json\" }\nimport { createBaseServer } from \"../src/server.js\"\n\nasync function main() {\n  const program = new Command()\n  program\n    .name(packageJson.name)\n    .description(packageJson.description)\n    .version(packageJson.version, \"-v, --version\", \"display the version number\")\n    .action(async () => {\n      const server = createBaseServer()\n      const transport = new StdioServerTransport()\n      console.error(\"Running @perstack/base version\", packageJson.version)\n      await server.connect(transport)\n    })\n  program.parse()\n}\nmain()\n"]}
+{"version":3,"file":"server.js","names":["packageJson.name","packageJson.description","packageJson.version"],"sources":["../../bin/server.ts"],"sourcesContent":["#!/usr/bin/env node\n\nimport { StdioServerTransport } from \"@modelcontextprotocol/sdk/server/stdio.js\"\nimport { Command } from \"commander\"\nimport packageJson from \"../package.json\" with { type: \"json\" }\nimport { createBaseServer } from \"../src/server.js\"\n\nasync function main() {\n  const program = new Command()\n  program\n    .name(packageJson.name)\n    .description(packageJson.description)\n    .version(packageJson.version, \"-v, --version\", \"display the version number\")\n    .action(async () => {\n      const server = createBaseServer()\n      const transport = new StdioServerTransport()\n      console.error(\"Running @perstack/base version\", packageJson.version)\n      await server.connect(transport)\n    })\n  program.parse()\n}\nmain()\n"],"mappings":";;;;;;AAOA,eAAe,OAAO;CACpB,MAAM,UAAU,IAAI,SAAS;AAC7B,SACG,KAAKA,KAAiB,CACtB,YAAYC,YAAwB,CACpC,QAAQC,SAAqB,iBAAiB,6BAA6B,CAC3E,OAAO,YAAY;EAClB,MAAM,SAAS,kBAAkB;EACjC,MAAM,YAAY,IAAI,sBAAsB;AAC5C,UAAQ,MAAM,kCAAkCA,QAAoB;AACpE,QAAM,OAAO,QAAQ,UAAU;GAC/B;AACJ,SAAQ,OAAO;;AAEjB,MAAM"}

package/dist/server-BM7K7dr8.js

@@ -0,0 +1,588 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { z } from "zod/v4";
+import fs, { constants, lstat, mkdir, open, stat } from "node:fs/promises";
+import { existsSync, realpathSync } from "node:fs";
+import os from "node:os";
+import path, { dirname, extname } from "node:path";
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { getFilteredEnv } from "@perstack/core";
+
+//#region package.json
+var name = "@perstack/base";
+var version = "0.0.61";
+var description = "Perstack base skills for agents.";
+
+//#endregion
+//#region src/lib/tool-result.ts
+function successToolResult(result) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify(result)
+	}] };
+}
+function errorToolResult(e) {
+	return { content: [{
+		type: "text",
+		text: JSON.stringify({
+			error: e.name,
+			message: e.message
+		})
+	}] };
+}
+
+//#endregion
+//#region src/tools/todo.ts
+var Todo = class {
+	currentTodoId = 0;
+	todos = [];
+	processTodo(input) {
+		const { newTodos, completedTodos } = input;
+		if (newTodos) this.todos.push(...newTodos.map((title) => ({
+			id: this.currentTodoId++,
+			title,
+			completed: false
+		})));
+		if (completedTodos) this.todos = this.todos.map((todo) => ({
+			...todo,
+			completed: todo.completed || completedTodos.includes(todo.id)
+		}));
+		return { todos: this.todos };
+	}
+	clearTodo() {
+		this.todos = [];
+		this.currentTodoId = 0;
+		return { todos: this.todos };
+	}
+};
+const todoSingleton = new Todo();
+async function todo(input) {
+	return todoSingleton.processTodo(input);
+}
+async function clearTodo() {
+	return todoSingleton.clearTodo();
+}
+function getRemainingTodos() {
+	return todoSingleton.todos.filter((t) => !t.completed);
+}
+function registerTodo(server) {
+	server.registerTool("todo", {
+		title: "todo",
+		description: "Manage a todo list: add tasks and mark them completed.",
+		inputSchema: {
+			newTodos: z.array(z.string()).describe("New todos to add").optional(),
+			completedTodos: z.array(z.number()).describe("Todo ids that are completed").optional()
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await todo(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+function registerClearTodo(server) {
+	server.registerTool("clearTodo", {
+		title: "clearTodo",
+		description: "Clear all todos.",
+		inputSchema: {}
+	}, async () => {
+		try {
+			return successToolResult(await clearTodo());
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/tools/attempt-completion.ts
+async function attemptCompletion() {
+	const remainingTodos = getRemainingTodos();
+	if (remainingTodos.length > 0) return { remainingTodos };
+	return {};
+}
+function registerAttemptCompletion(server) {
+	server.registerTool("attemptCompletion", {
+		title: "Attempt completion",
+		description: "Signal task completion. Validates all todos are complete before ending.",
+		inputSchema: {}
+	}, async () => {
+		try {
+			return successToolResult(await attemptCompletion());
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/lib/path.ts
+const workspacePath = realpathSync(expandHome(process.cwd()));
+function expandHome(filepath) {
+	if (filepath.startsWith("~/") || filepath === "~") return path.join(os.homedir(), filepath.slice(1));
+	return filepath;
+}
+async function validatePath(requestedPath) {
+	const expandedPath = expandHome(requestedPath);
+	const absolute = path.isAbsolute(expandedPath) ? path.resolve(expandedPath) : path.resolve(process.cwd(), expandedPath);
+	const perstackDir = `${workspacePath}/perstack`.toLowerCase();
+	if (absolute.toLowerCase() === perstackDir || absolute.toLowerCase().startsWith(`${perstackDir}/`)) throw new Error("Access denied - perstack directory is not allowed");
+	try {
+		const realAbsolute = await fs.realpath(absolute);
+		if (!isWithinWorkspace(realAbsolute)) throw new Error("Access denied - symlink target outside allowed directories");
+		return realAbsolute;
+	} catch (_error) {
+		const parentDir = path.dirname(absolute);
+		try {
+			if (!isWithinWorkspace(await fs.realpath(parentDir))) throw new Error("Access denied - parent directory outside allowed directories");
+			return absolute;
+		} catch {
+			if (!isWithinWorkspace(absolute)) throw new Error(`Access denied - path outside allowed directories: ${absolute} not in ${workspacePath}`);
+			throw new Error(`Parent directory does not exist: ${parentDir}`);
+		}
+	}
+}
+function isWithinWorkspace(absolutePath) {
+	return absolutePath === workspacePath || absolutePath.startsWith(`${workspacePath}/`);
+}
+
+//#endregion
+//#region src/lib/safe-file.ts
+const O_NOFOLLOW = constants.O_NOFOLLOW ?? 0;
+const O_NOFOLLOW_SUPPORTED = typeof constants.O_NOFOLLOW === "number";
+async function checkNotSymlink(path) {
+	if ((await lstat(path).catch(() => null))?.isSymbolicLink()) throw new Error("Operation denied: target is a symbolic link");
+}
+async function safeWriteFile(path, data) {
+	let handle;
+	try {
+		await checkNotSymlink(path);
+		handle = await open(path, constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | O_NOFOLLOW, 420);
+		await handle.writeFile(data, "utf-8");
+	} finally {
+		await handle?.close();
+	}
+}
+async function safeReadFile(path) {
+	let handle;
+	try {
+		await checkNotSymlink(path);
+		handle = await open(path, constants.O_RDONLY | O_NOFOLLOW);
+		return await handle.readFile("utf-8");
+	} finally {
+		await handle?.close();
+	}
+}
+
+//#endregion
+//#region src/tools/edit-text-file.ts
+async function editTextFile(input) {
+	const { path, newText, oldText } = input;
+	const validatedPath = await validatePath(path);
+	const stats = await stat(validatedPath).catch(() => null);
+	if (!stats) throw new Error(`File ${path} does not exist.`);
+	if (!(stats.mode & 128)) throw new Error(`File ${path} is not writable`);
+	await applyFileEdit(validatedPath, newText, oldText);
+	return {
+		path: validatedPath,
+		newText,
+		oldText
+	};
+}
+function normalizeLineEndings(text) {
+	return text.replace(/\r\n/g, "\n");
+}
+async function applyFileEdit(filePath, newText, oldText) {
+	const content = normalizeLineEndings(await safeReadFile(filePath));
+	const normalizedOld = normalizeLineEndings(oldText);
+	const normalizedNew = normalizeLineEndings(newText);
+	if (!content.includes(normalizedOld)) throw new Error(`Could not find exact match for oldText in file ${filePath}`);
+	await safeWriteFile(filePath, content.replace(normalizedOld, normalizedNew));
+}
+function registerEditTextFile(server) {
+	server.registerTool("editTextFile", {
+		title: "Edit text file",
+		description: "Replace exact text in an existing file. Normalizes line endings (CRLF → LF).",
+		inputSchema: {
+			path: z.string().describe("Target file path to edit."),
+			newText: z.string().describe("Text to replace with."),
+			oldText: z.string().describe("Exact text to find and replace.")
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await editTextFile(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/tools/exec.ts
+const execFileAsync = promisify(execFile);
+function isExecError(error) {
+	return error instanceof Error && "code" in error;
+}
+async function exec(input) {
+	const validatedCwd = await validatePath(input.cwd);
+	const { stdout, stderr } = await execFileAsync(input.command, input.args, {
+		cwd: validatedCwd,
+		env: getFilteredEnv(input.env),
+		timeout: input.timeout,
+		maxBuffer: 10 * 1024 * 1024
+	});
+	let output = "";
+	if (input.stdout) output += stdout;
+	if (input.stderr) output += stderr;
+	if (!output.trim()) output = "Command executed successfully, but produced no output.";
+	return { output };
+}
+function registerExec(server) {
+	server.registerTool("exec", {
+		title: "Execute Command",
+		description: "Execute a system command. Returns stdout/stderr.",
+		inputSchema: {
+			command: z.string().describe("The command to execute"),
+			args: z.array(z.string()).describe("The arguments to pass to the command"),
+			env: z.record(z.string(), z.string()).describe("The environment variables to set"),
+			cwd: z.string().describe("The working directory to execute the command in"),
+			stdout: z.boolean().describe("Whether to capture the standard output"),
+			stderr: z.boolean().describe("Whether to capture the standard error"),
+			timeout: z.number().optional().default(6e4).describe("Timeout in milliseconds (default: 60000)")
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await exec(input));
+		} catch (error) {
+			let message;
+			let stdout;
+			let stderr;
+			if (isExecError(error)) {
+				if ((error.killed || error.signal === "SIGTERM") && typeof input.timeout === "number") message = `Command timed out after ${input.timeout}ms.`;
+				else if (error.message.includes("timeout")) message = `Command timed out after ${input.timeout}ms.`;
+				else message = error.message;
+				stdout = error.stdout;
+				stderr = error.stderr;
+			} else if (error instanceof Error) message = error.message;
+			else message = "An unknown error occurred.";
+			const result = { error: message };
+			if (stdout && input.stdout) result.stdout = stdout;
+			if (stderr && input.stderr) result.stderr = stderr;
+			return { content: [{
+				type: "text",
+				text: JSON.stringify(result)
+			}] };
+		}
+	});
+}
+
+//#endregion
+//#region src/lib/mime.ts
+const MIME_TYPES = {
+	".png": "image/png",
+	".jpg": "image/jpeg",
+	".jpeg": "image/jpeg",
+	".gif": "image/gif",
+	".webp": "image/webp",
+	".pdf": "application/pdf"
+};
+function lookupMimeType(filePath) {
+	return MIME_TYPES[extname(filePath).toLowerCase()];
+}
+
+//#endregion
+//#region src/tools/read-image-file.ts
+const MAX_IMAGE_SIZE = 15 * 1024 * 1024;
+async function readImageFile(input) {
+	const { path } = input;
+	const validatedPath = await validatePath(path);
+	if (!existsSync(validatedPath)) throw new Error(`File ${path} does not exist.`);
+	const mimeType = lookupMimeType(validatedPath);
+	if (!mimeType || ![
+		"image/png",
+		"image/jpeg",
+		"image/gif",
+		"image/webp"
+	].includes(mimeType)) throw new Error(`File ${path} is not supported.`);
+	const fileStats = await stat(validatedPath);
+	const fileSizeMB = fileStats.size / (1024 * 1024);
+	if (fileStats.size > MAX_IMAGE_SIZE) throw new Error(`Image file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_IMAGE_SIZE / (1024 * 1024)}MB. Please use a smaller image file.`);
+	return {
+		path: validatedPath,
+		mimeType,
+		size: fileStats.size
+	};
+}
+function registerReadImageFile(server) {
+	server.registerTool("readImageFile", {
+		title: "Read image file",
+		description: "Read an image file as base64. Supports PNG, JPEG, GIF, WebP. Max 15MB.",
+		inputSchema: { path: z.string() }
+	}, async (input) => {
+		try {
+			return successToolResult(await readImageFile(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/tools/read-pdf-file.ts
+const MAX_PDF_SIZE = 30 * 1024 * 1024;
+async function readPdfFile(input) {
+	const { path } = input;
+	const validatedPath = await validatePath(path);
+	if (!existsSync(validatedPath)) throw new Error(`File ${path} does not exist.`);
+	const mimeType = lookupMimeType(validatedPath);
+	if (mimeType !== "application/pdf") throw new Error(`File ${path} is not a PDF file.`);
+	const fileStats = await stat(validatedPath);
+	const fileSizeMB = fileStats.size / (1024 * 1024);
+	if (fileStats.size > MAX_PDF_SIZE) throw new Error(`PDF file too large (${fileSizeMB.toFixed(1)}MB). Maximum supported size is ${MAX_PDF_SIZE / (1024 * 1024)}MB. Please use a smaller PDF file.`);
+	return {
+		path: validatedPath,
+		mimeType,
+		size: fileStats.size
+	};
+}
+function registerReadPdfFile(server) {
+	server.registerTool("readPdfFile", {
+		title: "Read PDF file",
+		description: "Read a PDF file as base64. Max 30MB.",
+		inputSchema: { path: z.string() }
+	}, async (input) => {
+		try {
+			return successToolResult(await readPdfFile(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/tools/read-text-file.ts
+async function readTextFile(input) {
+	const { path, from, to } = input;
+	const validatedPath = await validatePath(path);
+	if (!await stat(validatedPath).catch(() => null)) throw new Error(`File ${path} does not exist.`);
+	const lines = (await safeReadFile(validatedPath)).split("\n");
+	const fromLine = from ?? 0;
+	const toLine = to ?? lines.length;
+	return {
+		path,
+		content: lines.slice(fromLine, toLine).join("\n"),
+		from: fromLine,
+		to: toLine
+	};
+}
+function registerReadTextFile(server) {
+	server.registerTool("readTextFile", {
+		title: "Read text file",
+		description: "Read a UTF-8 text file. Supports partial reading via line ranges.",
+		inputSchema: {
+			path: z.string(),
+			from: z.number().optional().describe("The line number to start reading from."),
+			to: z.number().optional().describe("The line number to stop reading at.")
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await readTextFile(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/tools/skill-management.ts
+function registerAddSkill(server, callbacks) {
+	server.registerTool("addSkill", {
+		title: "Add skill",
+		description: "Dynamically add an MCP skill. Returns the list of tool names provided by the new skill.",
+		inputSchema: {
+			name: z.string().describe("Unique skill name"),
+			type: z.enum(["mcpStdioSkill", "mcpSseSkill"]).describe("Skill transport type"),
+			command: z.string().optional().describe("Command to execute (for stdio skills)"),
+			packageName: z.string().optional().describe("Package name for npx/uvx (for stdio skills)"),
+			args: z.array(z.string()).optional().describe("Additional command arguments"),
+			requiredEnv: z.array(z.string()).optional().describe("Required environment variable names"),
+			endpoint: z.string().optional().describe("SSE endpoint URL (for SSE skills)"),
+			description: z.string().optional().describe("Human-readable description"),
+			rule: z.string().optional().describe("Usage rules for the LLM"),
+			pick: z.array(z.string()).optional().describe("Tool names to include (whitelist)"),
+			omit: z.array(z.string()).optional().describe("Tool names to exclude (blacklist)")
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await callbacks.addSkill(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+function registerRemoveSkill(server, callbacks) {
+	server.registerTool("removeSkill", {
+		title: "Remove skill",
+		description: "Dynamically remove an MCP skill by name. Disconnects and removes the skill.",
+		inputSchema: { skillName: z.string().describe("Name of the skill to remove") }
+	}, async (input) => {
+		try {
+			await callbacks.removeSkill(input.skillName);
+			return successToolResult({ removed: input.skillName });
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+function registerAddDelegate(server, callbacks) {
+	server.registerTool("addDelegate", {
+		title: "Add delegate",
+		description: "Dynamically add a delegate expert. Returns the delegate tool name so you know what to call.",
+		inputSchema: { expertKey: z.string().describe("Key of the expert to add as a delegate") }
+	}, async (input) => {
+		try {
+			return successToolResult(await callbacks.addDelegate(input.expertKey));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+function registerRemoveDelegate(server, callbacks) {
+	server.registerTool("removeDelegate", {
+		title: "Remove delegate",
+		description: "Dynamically remove a delegate expert by name.",
+		inputSchema: { expertName: z.string().describe("Name of the delegate expert to remove") }
+	}, async (input) => {
+		try {
+			await callbacks.removeDelegate(input.expertName);
+			return successToolResult({ removed: input.expertName });
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+function registerCreateExpert(server, callbacks) {
+	server.registerTool("createExpert", {
+		title: "Create expert",
+		description: "Dynamically create an expert definition in memory. Returns the expert key so you can add it as a delegate.",
+		inputSchema: {
+			key: z.string().describe("Unique expert key (kebab-case)"),
+			instruction: z.string().describe("System instruction for the expert"),
+			description: z.string().optional().describe("Human-readable description"),
+			version: z.string().optional().describe("Semantic version (defaults to 1.0.0)"),
+			skills: z.record(z.string(), z.object({
+				type: z.enum(["mcpStdioSkill", "mcpSseSkill"]).describe("Skill transport type"),
+				command: z.string().optional().describe("Command to execute (for stdio skills)"),
+				packageName: z.string().optional().describe("Package name for npx/uvx (for stdio skills)"),
+				args: z.array(z.string()).optional().describe("Additional command arguments"),
+				requiredEnv: z.array(z.string()).optional().describe("Required environment variable names"),
+				endpoint: z.string().optional().describe("SSE endpoint URL (for SSE skills)"),
+				description: z.string().optional().describe("Human-readable description"),
+				rule: z.string().optional().describe("Usage rules for the LLM"),
+				pick: z.array(z.string()).optional().describe("Tool names to include (whitelist)"),
+				omit: z.array(z.string()).optional().describe("Tool names to exclude (blacklist)"),
+				lazyInit: z.boolean().optional().describe("Lazy initialization")
+			})).optional().describe("Skills map (defaults to @perstack/base)"),
+			delegates: z.array(z.string()).optional().describe("Expert keys to delegate to"),
+			tags: z.array(z.string()).optional().describe("Tags for categorization"),
+			providerTools: z.array(z.string()).optional().describe("Provider-specific tool names")
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await callbacks.createExpert(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+function registerSkillManagementTools(server, callbacks) {
+	registerAddSkill(server, callbacks);
+	registerRemoveSkill(server, callbacks);
+	registerAddDelegate(server, callbacks);
+	registerRemoveDelegate(server, callbacks);
+	registerCreateExpert(server, callbacks);
+}
+
+//#endregion
+//#region src/tools/write-text-file.ts
+async function writeTextFile(input) {
+	const { path, text } = input;
+	const validatedPath = await validatePath(path);
+	const stats = await stat(validatedPath).catch(() => null);
+	if (stats && !(stats.mode & 128)) throw new Error(`File ${path} is not writable`);
+	await mkdir(dirname(validatedPath), { recursive: true });
+	await safeWriteFile(validatedPath, text);
+	return {
+		path: validatedPath,
+		text
+	};
+}
+function registerWriteTextFile(server) {
+	server.registerTool("writeTextFile", {
+		title: "writeTextFile",
+		description: "Create or overwrite a UTF-8 text file. Creates parent directories as needed.",
+		inputSchema: {
+			path: z.string().describe("Target file path (relative or absolute)."),
+			text: z.string().describe("Text to write to the file.")
+		}
+	}, async (input) => {
+		try {
+			return successToolResult(await writeTextFile(input));
+		} catch (e) {
+			if (e instanceof Error) return errorToolResult(e);
+			throw e;
+		}
+	});
+}
+
+//#endregion
+//#region src/server.ts
+/** Base skill name */
+const BASE_SKILL_NAME = name;
+/** Base skill version */
+const BASE_SKILL_VERSION = version;
+/**
+* Register all base skill tools on an MCP server.
+* This is useful for both standalone and in-process server creation.
+*/
+function registerAllTools(server) {
+	registerAttemptCompletion(server);
+	registerTodo(server);
+	registerClearTodo(server);
+	registerExec(server);
+	registerReadTextFile(server);
+	registerReadImageFile(server);
+	registerReadPdfFile(server);
+	registerWriteTextFile(server);
+	registerEditTextFile(server);
+}
+/**
+* Create a base skill MCP server with all tools registered.
+* Used by the runtime for in-process execution via InMemoryTransport.
+*/
+function createBaseServer(options) {
+	const server = new McpServer({
+		name: BASE_SKILL_NAME,
+		version: BASE_SKILL_VERSION
+	}, { capabilities: { tools: {} } });
+	registerAllTools(server);
+	if (options?.skillManagement) registerSkillManagementTools(server, options.skillManagement);
+	return server;
+}
+
+//#endregion
+export { todo as A, validatePath as C, getRemainingTodos as D, clearTodo as E, version as F, successToolResult as M, description as N, registerClearTodo as O, name as P, registerEditTextFile as S, registerAttemptCompletion as T, readImageFile as _, registerWriteTextFile as a, registerExec as b, registerAddSkill as c, registerRemoveSkill as d, registerSkillManagementTools as f, registerReadPdfFile as g, readPdfFile as h, registerAllTools as i, errorToolResult as j, registerTodo as k, registerCreateExpert as l, registerReadTextFile as m, BASE_SKILL_VERSION as n, writeTextFile as o, readTextFile as p, createBaseServer as r, registerAddDelegate as s, BASE_SKILL_NAME as t, registerRemoveDelegate as u, registerReadImageFile as v, attemptCompletion as w, editTextFile as x, exec as y };
+//# sourceMappingURL=server-BM7K7dr8.js.map