@bike4mind/cli 0.2.64-worktree-refactor-extract-search-query-builders.21815 → 0.2.64

package/dist/commands/headlessCommand.mjs

@@ -0,0 +1,319 @@
+#!/usr/bin/env node
+import { I as isReadOnlyTool, L as ReActAgent, M as setWebSocketToolExecutor, P as buildCoreSystemPrompt, R as CustomCommandStore, S as getApiUrl, T as generateCliTools, V as SessionStore, _ as McpManager, a as createBackgroundAgentTools, c as AgentStore, f as ApiClient, g as ServerLlmBackend, h as WebSocketLlmBackend, i as createWriteTodosTool, l as SubagentOrchestrator, m as WebSocketConnectionManager, n as createFindDefinitionTool, o as BackgroundAgentManager, p as WebSocketToolExecutor, r as createTodoStore, s as createAgentDelegateTool, t as createGetFileStructureTool, u as createSkillTool, w as PermissionManager, x as loadContextFiles, z as CheckpointStore } from "../tools-C6M5aW8W.mjs";
+import { n as logger, t as ConfigStore } from "../ConfigStore-CllM6jOf.mjs";
+import { t as DEFAULT_SANDBOX_CONFIG } from "../types-DBEjF9YS.mjs";
+import { t as createSandboxRuntime } from "../SandboxRuntimeAdapter-C1B4t20N.mjs";
+import { t as SandboxOrchestrator } from "../SandboxOrchestrator-BEW3rqYi.mjs";
+import { t as ProxyManager } from "../ProxyManager-Dl2nFk-A.mjs";
+import { randomBytes } from "crypto";
+import { v4 } from "uuid";
+//#region src/commands/headlessCommand.ts
+/**
+* Headless/programmatic mode command (b4m -p "query")
+*
+* Enables non-interactive execution for CI/CD pipelines, scripting, and automation.
+* Runs the agent once with the given prompt and exits with an appropriate exit code.
+*/
+/** Read all data from stdin if it's being piped (non-TTY). Returns empty string if no piped data. */
+async function readStdin() {
+	if (process.stdin.isTTY) return "";
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		process.stdin.on("data", (chunk) => chunks.push(chunk));
+		process.stdin.on("end", () => resolve(Buffer.concat(chunks).toString("utf-8").trim()));
+		process.stdin.on("error", reject);
+	});
+}
+const silentLogger = {
+	log: () => {},
+	info: () => {},
+	warn: () => {},
+	error: () => {},
+	debug: () => {}
+};
+async function handleHeadlessCommand(options) {
+	const { prompt, outputFormat, dangerouslySkipPermissions, addDirs } = options;
+	logger.setVerbose(options.verbose);
+	const stdinContent = await readStdin();
+	const fullPrompt = stdinContent ? `${prompt}\n\n<stdin>\n${stdinContent}\n</stdin>` : prompt;
+	const configStore = new ConfigStore();
+	const sessionStore = new SessionStore();
+	const customCommandStore = new CustomCommandStore();
+	try {
+		const config = await configStore.load();
+		const configDirs = await configStore.getAdditionalDirectories();
+		const flagDirs = process.env.B4M_ADDITIONAL_DIRS ? JSON.parse(process.env.B4M_ADDITIONAL_DIRS) : [];
+		const additionalDirectories = [...new Set([
+			...configDirs,
+			...flagDirs,
+			...addDirs
+		])];
+		try {
+			await customCommandStore.loadCommands();
+		} catch {}
+		const authTokens = await configStore.getAuthTokens();
+		if (!authTokens) {
+			process.stderr.write("Error: Not authenticated. Run `b4m /login` to authenticate.\n");
+			process.exit(1);
+		}
+		if (new Date(authTokens.expiresAt) <= /* @__PURE__ */ new Date()) {
+			await configStore.clearAuthTokens();
+			process.stderr.write("Error: Authentication token expired. Run `b4m /login` to re-authenticate.\n");
+			process.exit(1);
+		}
+		const apiClient = new ApiClient(getApiUrl(config.apiConfig), configStore);
+		const tokenGetter = async () => {
+			return (await configStore.getAuthTokens())?.accessToken ?? null;
+		};
+		let wsManager = null;
+		let llm;
+		try {
+			const serverConfig = await apiClient.get("/api/settings/serverConfig");
+			const wsUrl = serverConfig?.websocketUrl;
+			const wsCompletionUrl = serverConfig?.wsCompletionUrl;
+			if (wsUrl && wsCompletionUrl) {
+				wsManager = new WebSocketConnectionManager(wsUrl, tokenGetter);
+				await wsManager.connect();
+				setWebSocketToolExecutor(new WebSocketToolExecutor(wsManager, tokenGetter));
+				llm = new WebSocketLlmBackend({
+					wsManager,
+					apiClient,
+					model: config.defaultModel,
+					tokenGetter,
+					wsCompletionUrl
+				});
+				logger.debug("[headless] Using WebSocket transport");
+			} else throw new Error("No websocketUrl or wsCompletionUrl in server config");
+		} catch {
+			wsManager = null;
+			setWebSocketToolExecutor(null);
+			llm = new ServerLlmBackend({
+				apiClient,
+				model: config.defaultModel
+			});
+			logger.debug("[headless] Using SSE transport fallback");
+		}
+		const models = await llm.getModelInfo();
+		if (models.length === 0) throw new Error("No models available from server.");
+		const modelInfo = models.find((m) => m.id === config.defaultModel) ?? models[0];
+		llm.currentModel = modelInfo.id;
+		const session = {
+			id: v4(),
+			name: `Headless ${(/* @__PURE__ */ new Date()).toISOString()}`,
+			createdAt: (/* @__PURE__ */ new Date()).toISOString(),
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			model: modelInfo.id,
+			messages: [],
+			metadata: {
+				totalTokens: 0,
+				totalCost: 0,
+				toolCallCount: 0
+			}
+		};
+		await logger.initialize(session.id);
+		const permissionManager = new PermissionManager(config.trustedTools ?? [], void 0, config.tools.disabled);
+		const promptFn = (toolName, _args, _preview) => {
+			if (dangerouslySkipPermissions) {
+				logger.debug(`[headless] Auto-allowing tool: ${toolName}`);
+				return Promise.resolve({ action: "allow-once" });
+			}
+			process.stderr.write(`Warning: Tool "${toolName}" requires permission and was denied. Use --dangerously-skip-permissions to auto-allow tools in headless mode.\n`);
+			return Promise.resolve({ action: "deny" });
+		};
+		const userQuestionFn = (_payload) => {
+			process.stderr.write("Warning: Agent requested user input; headless mode cannot respond interactively. Answering with empty response.\n");
+			return Promise.resolve({ answers: [] });
+		};
+		const sandboxConfig = config.sandbox ?? DEFAULT_SANDBOX_CONFIG;
+		const checkpointStore = new CheckpointStore(configStore.getProjectConfigDir() ?? process.cwd());
+		const [sandboxRuntime] = await Promise.all([createSandboxRuntime(), checkpointStore.init(session.id).catch(() => {})]);
+		const sandboxOrchestrator = new SandboxOrchestrator(sandboxConfig, sandboxRuntime, new ProxyManager(sandboxConfig.network));
+		permissionManager.setSandboxState(sandboxConfig.mode, sandboxOrchestrator.isActive());
+		const agentContext = {
+			currentAgent: null,
+			observationQueue: []
+		};
+		const { tools: b4mTools } = await generateCliTools(config.userId, llm, modelInfo.id, permissionManager, promptFn, agentContext, configStore, apiClient, void 0, userQuestionFn, checkpointStore, sandboxOrchestrator, additionalDirectories);
+		const mcpManager = new McpManager(config);
+		const projectConfigDir = configStore.getProjectConfigDir();
+		const builtinAgentsDir = new URL("../agents/defaults/", import.meta.url).pathname;
+		const agentStore = new AgentStore(builtinAgentsDir, projectConfigDir ?? process.cwd());
+		const [, , contextResult] = await Promise.all([
+			mcpManager.initialize(),
+			agentStore.loadAgents(),
+			loadContextFiles(projectConfigDir)
+		]);
+		const mcpTools = mcpManager.getTools();
+		const orchestrator = new SubagentOrchestrator({
+			userId: config.userId,
+			llm,
+			logger: silentLogger,
+			permissionManager,
+			showPermissionPrompt: promptFn,
+			configStore,
+			apiClient,
+			agentStore,
+			customCommandStore,
+			enableParallelToolExecution: config.preferences.enableParallelToolExecution === true,
+			showUserQuestion: userQuestionFn,
+			checkpointStore
+		});
+		const backgroundManager = new BackgroundAgentManager(orchestrator);
+		const agentDelegateTool = createAgentDelegateTool(orchestrator, agentStore, session.id, backgroundManager);
+		const backgroundTools = createBackgroundAgentTools(backgroundManager);
+		const writeTodosTool = createWriteTodosTool(createTodoStore());
+		const findDefinitionTool = createFindDefinitionTool();
+		const getFileStructureTool = createGetFileStructureTool();
+		const enableSkillTool = config.preferences.enableSkillTool !== false;
+		const skillTool = enableSkillTool ? createSkillTool({
+			customCommandStore,
+			subagentOrchestrator: orchestrator,
+			sessionId: session.id
+		}) : null;
+		const cliTools = [
+			agentDelegateTool,
+			...backgroundTools,
+			writeTodosTool,
+			findDefinitionTool,
+			getFileStructureTool
+		];
+		if (skillTool) cliTools.push(skillTool);
+		const allTools = [
+			...b4mTools,
+			...mcpTools,
+			...cliTools
+		];
+		const systemPrompt = buildCoreSystemPrompt({
+			contextContent: contextResult.mergedContent,
+			agentStore,
+			customCommands: customCommandStore.getAllCommands(),
+			enableSkillTool,
+			enableDynamicAgentCreation: false,
+			additionalDirectories
+		});
+		const maxIterations = config.preferences.maxIterations === null ? 999999 : config.preferences.maxIterations;
+		const agent = new ReActAgent({
+			userId: config.userId,
+			logger: silentLogger,
+			llm,
+			model: modelInfo.id,
+			tools: allTools,
+			maxIterations,
+			maxTokens: config.preferences.maxTokens,
+			temperature: config.preferences.temperature,
+			systemPrompt
+		});
+		agentContext.currentAgent = agent;
+		agent.observationQueue = agentContext.observationQueue;
+		if (outputFormat === "stream-json") {
+			const emitNdjson = (obj) => process.stdout.write(JSON.stringify(obj) + "\n");
+			agent.on("thought", (step) => {
+				emitNdjson({
+					type: "thought",
+					content: step.content
+				});
+			});
+			agent.on("action", (step) => {
+				emitNdjson({
+					type: "action",
+					content: step.content,
+					toolName: step.metadata?.toolName,
+					toolInput: step.metadata?.toolInput
+				});
+			});
+			agent.on("observation", (step) => {
+				emitNdjson({
+					type: "observation",
+					content: step.content,
+					toolName: step.metadata?.toolName
+				});
+			});
+		}
+		const turnId = `turn-${randomBytes(4).toString("hex")}`;
+		backgroundManager.setCurrentTurn(turnId);
+		let result;
+		try {
+			result = await agent.run(fullPrompt, {
+				parallelExecution: config.preferences.enableParallelToolExecution === true,
+				isReadOnlyTool
+			});
+		} finally {
+			backgroundManager.setCurrentTurn(null);
+		}
+		const finalSession = {
+			...session,
+			messages: [{
+				id: v4(),
+				role: "user",
+				content: fullPrompt,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}, {
+				id: v4(),
+				role: "assistant",
+				content: result.finalAnswer,
+				timestamp: (/* @__PURE__ */ new Date()).toISOString()
+			}],
+			updatedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			metadata: {
+				totalTokens: result.completionInfo.totalTokens,
+				totalCost: 0,
+				toolCallCount: result.completionInfo.toolCalls
+			}
+		};
+		await sessionStore.save(finalSession);
+		switch (outputFormat) {
+			case "text":
+				process.stdout.write(result.finalAnswer + "\n");
+				break;
+			case "json": {
+				const jsonResult = {
+					result: result.finalAnswer,
+					steps: result.steps.map((s) => ({
+						type: s.type,
+						content: s.content,
+						toolName: s.metadata?.toolName,
+						toolInput: s.metadata?.toolInput
+					})),
+					tokenUsage: {
+						totalTokens: result.completionInfo.totalTokens,
+						inputTokens: result.completionInfo.totalInputTokens,
+						outputTokens: result.completionInfo.totalOutputTokens
+					},
+					iterations: result.completionInfo.iterations,
+					toolCalls: result.completionInfo.toolCalls
+				};
+				process.stdout.write(JSON.stringify(jsonResult, null, 2) + "\n");
+				break;
+			}
+			case "stream-json":
+				process.stdout.write(JSON.stringify({
+					type: "result",
+					content: result.finalAnswer,
+					tokenUsage: {
+						totalTokens: result.completionInfo.totalTokens,
+						inputTokens: result.completionInfo.totalInputTokens,
+						outputTokens: result.completionInfo.totalOutputTokens
+					},
+					iterations: result.completionInfo.iterations,
+					toolCalls: result.completionInfo.toolCalls
+				}) + "\n");
+				break;
+		}
+		await mcpManager.disconnect().catch(() => {});
+		if (wsManager) wsManager.disconnect();
+		setWebSocketToolExecutor(null);
+		agent.removeAllListeners();
+		process.exit(0);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		if (outputFormat === "json") process.stdout.write(JSON.stringify({ error: message }) + "\n");
+		else if (outputFormat === "stream-json") process.stdout.write(JSON.stringify({
+			type: "error",
+			error: message
+		}) + "\n");
+		else process.stderr.write(`Error: ${message}\n`);
+		process.exit(1);
+	}
+}
+//#endregion
+export { handleHeadlessCommand };

package/dist/commands/mcpCommand.mjs

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { t as ConfigStore } from "../ConfigStore-CllM6jOf.mjs";
+//#region src/commands/mcpCommand.ts
+/**
+* External MCP commands (b4m mcp list, b4m mcp add, etc.)
+* These run outside the interactive CLI session
+*/
+/**
+* Main handler for MCP subcommands
+*/
+async function handleMcpCommand(subcommand, argv) {
+	const configStore = new ConfigStore();
+	const config = await configStore.load();
+	switch (subcommand) {
+		case "list":
+			await handleList(config);
+			break;
+		case "add": {
+			if (!argv.name) {
+				console.error("❌ Usage: b4m mcp add <name> -- <command> [args...]");
+				console.error("");
+				console.error("The -- separator is required to separate the server name from the command.");
+				console.error("");
+				console.error("Examples:");
+				console.error("  b4m mcp add context7 -- npx -y @upstash/context7-mcp");
+				console.error("  b4m mcp add github -- docker run -i ghcr.io/modelcontextprotocol/servers/github");
+				process.exit(1);
+			}
+			const dashDashIndex = process.argv.indexOf("--");
+			if (dashDashIndex === -1) {
+				console.error("❌ Missing -- separator");
+				console.error("");
+				console.error("Usage: b4m mcp add <name> -- <command> [args...]");
+				console.error("");
+				console.error("The -- separator is required to separate the server name from the command.");
+				process.exit(1);
+			}
+			const commandParts = process.argv.slice(dashDashIndex + 1);
+			if (commandParts.length === 0) {
+				console.error("❌ No command specified after --");
+				console.error("");
+				console.error("Usage: b4m mcp add <name> -- <command> [args...]");
+				process.exit(1);
+			}
+			const command = commandParts[0];
+			const args = commandParts.slice(1);
+			await handleAdd(config, argv.name, command, args, configStore);
+			break;
+		}
+		case "remove":
+			if (!argv.name) {
+				console.error("❌ Usage: b4m mcp remove <name>");
+				process.exit(1);
+			}
+			await handleRemove(config, argv.name, configStore);
+			break;
+		case "enable":
+			if (!argv.name) {
+				console.error("❌ Usage: b4m mcp enable <name>");
+				process.exit(1);
+			}
+			await handleEnable(config, argv.name, configStore);
+			break;
+		case "disable":
+			if (!argv.name) {
+				console.error("❌ Usage: b4m mcp disable <name>");
+				process.exit(1);
+			}
+			await handleDisable(config, argv.name, configStore);
+			break;
+		default:
+			console.error(`❌ Unknown MCP subcommand: ${subcommand}`);
+			console.error("");
+			console.error("Available commands:");
+			console.error("  b4m mcp list                      - List configured MCP servers");
+			console.error("  b4m mcp add <name> -- <command>   - Add a new MCP server");
+			console.error("  b4m mcp remove <name>             - Remove an MCP server");
+			console.error("  b4m mcp enable <name>             - Enable an MCP server");
+			console.error("  b4m mcp disable <name>            - Disable an MCP server");
+			process.exit(1);
+	}
+}
+/**
+* List configured MCP servers
+*/
+async function handleList(config) {
+	if (config.mcpServers.length === 0) {
+		console.log("📡 No MCP servers configured.");
+		console.log("");
+		console.log("To add an MCP server:");
+		console.log("  b4m mcp add <name> -- <command> [args...]");
+		console.log("");
+		console.log("Examples:");
+		console.log("  b4m mcp add context7 -- npx -y @upstash/context7-mcp");
+		console.log("  b4m mcp add github -- docker run -i ghcr.io/modelcontextprotocol/servers/github");
+		return;
+	}
+	console.log("📡 Configured MCP Servers:\n");
+	for (const server of config.mcpServers) {
+		const status = server.enabled ? "✅ Enabled" : "⏸️  Disabled";
+		const commandInfo = server.command ? `${server.command} ${(server.args || []).join(" ")}` : "(internal)";
+		console.log(`• ${server.name} - ${status}`);
+		console.log(`  Command: ${commandInfo}`);
+		if (Object.keys(server.env).length > 0) {
+			const envKeys = Object.keys(server.env).join(", ");
+			console.log(`  Env vars: ${envKeys}`);
+		}
+		console.log("");
+	}
+	console.log("To manage servers:");
+	console.log("  b4m mcp add <name> -- <command> [args...]  - Add server");
+	console.log("  b4m mcp remove <name>                      - Remove server");
+	console.log("  b4m mcp enable <name>                      - Enable server");
+	console.log("  b4m mcp disable <name>                     - Disable server");
+}
+/**
+* Add a new MCP server
+*/
+async function handleAdd(config, name, command, args, configStore) {
+	if (config.mcpServers.find((s) => s.name === name)) {
+		console.error(`❌ MCP server "${name}" already exists.`);
+		console.error("   Use \"b4m mcp remove\" first to replace it.");
+		process.exit(1);
+	}
+	if (!/^[a-zA-Z0-9_-]+$/.test(name)) {
+		console.error("❌ Server name must contain only alphanumeric characters, dashes, and underscores.");
+		process.exit(1);
+	}
+	const newServer = {
+		name,
+		command,
+		args,
+		env: {},
+		enabled: true
+	};
+	config.mcpServers.push(newServer);
+	try {
+		await configStore.save(config);
+		console.log(`✅ Added MCP server "${name}"`);
+		console.log("");
+		console.log("Configuration saved to: ~/.bike4mind/config.json");
+		console.log("");
+		console.log("The server will be available next time you start the CLI.");
+	} catch (error) {
+		console.error(`❌ Failed to save configuration:`, error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+}
+/**
+* Remove an MCP server
+*/
+async function handleRemove(config, name, configStore) {
+	const index = config.mcpServers.findIndex((s) => s.name === name);
+	if (index === -1) {
+		console.error(`❌ MCP server "${name}" not found.`);
+		process.exit(1);
+	}
+	config.mcpServers.splice(index, 1);
+	try {
+		await configStore.save(config);
+		console.log(`✅ Removed MCP server "${name}"`);
+		console.log("");
+		console.log("Configuration saved to: ~/.bike4mind/config.json");
+	} catch (error) {
+		console.error(`❌ Failed to save configuration:`, error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+}
+/**
+* Enable an MCP server
+*/
+async function handleEnable(config, name, configStore) {
+	const server = config.mcpServers.find((s) => s.name === name);
+	if (!server) {
+		console.error(`❌ MCP server "${name}" not found.`);
+		process.exit(1);
+	}
+	if (server.enabled) {
+		console.log(`ℹ️  MCP server "${name}" is already enabled.`);
+		return;
+	}
+	server.enabled = true;
+	try {
+		await configStore.save(config);
+		console.log(`✅ Enabled MCP server "${name}"`);
+		console.log("");
+		console.log("The server will connect next time you start the CLI.");
+	} catch (error) {
+		console.error(`❌ Failed to save configuration:`, error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+}
+/**
+* Disable an MCP server
+*/
+async function handleDisable(config, name, configStore) {
+	const server = config.mcpServers.find((s) => s.name === name);
+	if (!server) {
+		console.error(`❌ MCP server "${name}" not found.`);
+		process.exit(1);
+	}
+	if (!server.enabled) {
+		console.log(`ℹ️  MCP server "${name}" is already disabled.`);
+		return;
+	}
+	server.enabled = false;
+	try {
+		await configStore.save(config);
+		console.log(`✅ Disabled MCP server "${name}"`);
+		console.log("");
+		console.log("The server will not connect next time you start the CLI.");
+	} catch (error) {
+		console.error(`❌ Failed to save configuration:`, error instanceof Error ? error.message : String(error));
+		process.exit(1);
+	}
+}
+//#endregion
+export { handleMcpCommand };

package/dist/commands/updateCommand.mjs

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { i as version, r as forceCheckForUpdate } from "../updateChecker-Cu9dkHxV.mjs";
+import { execSync } from "child_process";
+//#region src/commands/updateCommand.ts
+/**
+* External update command (b4m update)
+* Checks for and installs CLI updates.
+* Runs outside the interactive CLI session.
+*/
+async function handleUpdateCommand() {
+	const currentVersion = version;
+	console.log(`Current version: v${currentVersion}`);
+	console.log("Checking for updates...\n");
+	const result = await forceCheckForUpdate(currentVersion);
+	if (!result) {
+		console.error("Failed to check for updates. Check your internet connection.");
+		process.exit(1);
+	}
+	if (!result.updateAvailable) {
+		console.log(`Already on the latest version (v${currentVersion}).`);
+		return;
+	}
+	console.log(`Update available: v${currentVersion} → v${result.latestVersion}\n`);
+	console.log("Installing update...\n");
+	try {
+		execSync("npm install -g @bike4mind/cli@latest", {
+			stdio: "inherit",
+			timeout: 12e4
+		});
+		console.log(`\nSuccessfully updated to v${result.latestVersion}.`);
+	} catch {
+		console.error("\nUpdate failed. Try running manually:");
+		console.error("  npm install -g @bike4mind/cli@latest");
+		console.error("\nIf you get permission errors, try:");
+		console.error("  sudo npm install -g @bike4mind/cli@latest");
+		process.exit(1);
+	}
+}
+//#endregion
+export { handleUpdateCommand };

package/dist/createFile-yQfh8uvk-I-yM5DxC.mjs

@@ -0,0 +1,63 @@
+#!/usr/bin/env node
+import { t as assertPathAllowed } from "./pathValidation-Cgjh5WQO-DiCZTcq6.mjs";
+import { existsSync, promises } from "fs";
+import path from "path";
+//#region ../../b4m-core/packages/services/dist/createFile-yQfh8uvk.mjs
+async function createFile(params, allowedDirectories) {
+	const { path: filePath, content, createDirectories = true } = params;
+	const resolvedPath = assertPathAllowed(filePath, allowedDirectories, "create");
+	const action = existsSync(resolvedPath) ? "overwritten" : "created";
+	if (createDirectories) {
+		const dir = path.dirname(resolvedPath);
+		await promises.mkdir(dir, { recursive: true });
+	}
+	await promises.writeFile(resolvedPath, content, "utf-8");
+	const stats = await promises.stat(resolvedPath);
+	const lines = content.split("\n").length;
+	return `File ${action} successfully: ${filePath}\nSize: ${stats.size} bytes\nLines: ${lines}`;
+}
+const createFileTool = {
+	name: "create_file",
+	implementation: (context) => ({
+		toolFn: async (value) => {
+			const params = value;
+			const fileExists = existsSync(path.resolve(process.cwd(), path.normalize(params.path)));
+			context.logger.info(`📝 CreateFile: ${fileExists ? "Overwriting" : "Creating"} file`, {
+				path: params.path,
+				size: params.content.length
+			});
+			try {
+				const result = await createFile(params, context.allowedDirectories);
+				context.logger.info("✅ CreateFile: Success", { path: params.path });
+				return result;
+			} catch (error) {
+				context.logger.error("❌ CreateFile: Failed", error);
+				throw error;
+			}
+		},
+		toolSchema: {
+			name: "create_file",
+			description: "Create a new file or overwrite an existing file with the provided content. Will create parent directories if they do not exist. Restricted to current working directory for security. Always prompts user for confirmation before writing.",
+			parameters: {
+				type: "object",
+				properties: {
+					path: {
+						type: "string",
+						description: "Path where the file should be created (relative to current working directory)"
+					},
+					content: {
+						type: "string",
+						description: "Content to write to the file"
+					},
+					createDirectories: {
+						type: "boolean",
+						description: "Create parent directories if they do not exist (default: true)"
+					}
+				},
+				required: ["path", "content"]
+			}
+		}
+	})
+};
+//#endregion
+export { createFileTool };