@agiflowai/aicode-toolkit 1.0.3 → 1.0.5

package/dist/{services-zrdafWTg.js → services-BvnOGCDG.mjs}

@@ -1,10 +1,9 @@
-import path from "node:path";
-import { ProjectType, messages, print } from "@agiflowai/aicode-utils";
-import * as fs$1 from "fs-extra";
+import { CLAUDE_CODE, CODEX, CURSOR, ClaudeCodeService, CodexService, CursorService, GEMINI_CLI, GITHUB_COPILOT, GeminiCliService, GitHubCopilotService, NONE } from "@agiflowai/coding-agent-bridge";
+import { ProjectType, copy, ensureDir, messages, mkdir, move, pathExists, print, readFile, readdir, remove, writeFile } from "@agiflowai/aicode-utils";
 import chalk from "chalk";
 import gradient from "gradient-string";
+import path from "node:path";
 import { execa } from "execa";
-import { CLAUDE_CODE, CODEX, CURSOR, ClaudeCodeService, CodexService, CursorService, GEMINI_CLI, GITHUB_COPILOT, GeminiCliService, GitHubCopilotService, NONE } from "@agiflowai/coding-agent-bridge";
 import fs from "node:fs/promises";
 import { Liquid } from "liquidjs";
 import os from "node:os";
@@ -70,6 +69,187 @@ const BANNER_GRADIENT = [
 	THEME.colors.secondary.dark
 ];
 
+//#endregion
+//#region src/services/CodingAgentService.ts
+/**
+* CodingAgentService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Strategy pattern for different agent configurations
+* - Single responsibility: Handle MCP setup for coding agents
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Document methods with JSDoc comments
+*
+* AVOID:
+* - Direct UI interaction (no prompts in services)
+* - Hard-coding agent configurations (use strategies)
+*/
+var CodingAgentService = class {
+	workspaceRoot;
+	constructor(workspaceRoot) {
+		this.workspaceRoot = workspaceRoot;
+	}
+	/**
+	* Detect which coding agent is enabled in the workspace
+	* Checks for Claude Code, Codex, Gemini CLI, GitHub Copilot, and Cursor installations
+	* @param workspaceRoot - The workspace root directory
+	* @returns Promise resolving to detected agent ID or null
+	*/
+	static async detectCodingAgent(workspaceRoot) {
+		if (await new ClaudeCodeService({ workspaceRoot }).isEnabled()) return CLAUDE_CODE;
+		if (await new CursorService({ workspaceRoot }).isEnabled()) return CURSOR;
+		if (await new GitHubCopilotService({ workspaceRoot }).isEnabled()) return GITHUB_COPILOT;
+		if (await new CodexService({ workspaceRoot }).isEnabled()) return CODEX;
+		if (await new GeminiCliService({ workspaceRoot }).isEnabled()) return GEMINI_CLI;
+		return null;
+	}
+	/**
+	* Get available coding agents with their descriptions
+	*/
+	static getAvailableAgents() {
+		return [
+			{
+				value: CLAUDE_CODE,
+				name: "Claude Code",
+				description: "Anthropic Claude Code CLI agent"
+			},
+			{
+				value: CURSOR,
+				name: "Cursor",
+				description: "Cursor AI-first code editor"
+			},
+			{
+				value: GITHUB_COPILOT,
+				name: "GitHub Copilot",
+				description: "GitHub Copilot coding agent and CLI"
+			},
+			{
+				value: CODEX,
+				name: "Codex",
+				description: "OpenAI Codex CLI agent"
+			},
+			{
+				value: GEMINI_CLI,
+				name: "Gemini CLI",
+				description: "Google Gemini CLI agent"
+			},
+			{
+				value: NONE,
+				name: "Other",
+				description: "Other coding agent or skip MCP configuration"
+			}
+		];
+	}
+	/**
+	* Get the coding agent service instance
+	* @param agent - The coding agent to get service for
+	* @returns The service instance or null if not supported
+	*/
+	getCodingAgentService(agent) {
+		if (agent === CLAUDE_CODE) return new ClaudeCodeService({ workspaceRoot: this.workspaceRoot });
+		if (agent === CURSOR) return new CursorService({ workspaceRoot: this.workspaceRoot });
+		if (agent === GITHUB_COPILOT) return new GitHubCopilotService({ workspaceRoot: this.workspaceRoot });
+		if (agent === CODEX) return new CodexService({ workspaceRoot: this.workspaceRoot });
+		if (agent === GEMINI_CLI) return new GeminiCliService({ workspaceRoot: this.workspaceRoot });
+		return null;
+	}
+	/**
+	* Update custom instructions/prompts for the coding agent
+	* Appends custom instruction prompt to the agent's configuration
+	* @param agent - The coding agent to update
+	* @param instructionPrompt - The instruction prompt to append
+	* @param customInstructionFile - Optional custom file path to write instructions to (e.g., '.claude/aicode-instructions.md')
+	*/
+	async updateCustomInstructions(agent, instructionPrompt, customInstructionFile) {
+		if (agent === NONE) {
+			print.info("Skipping custom instruction update");
+			return;
+		}
+		print.info(`\nUpdating custom instructions for ${agent}...`);
+		const service = this.getCodingAgentService(agent);
+		if (!service) {
+			print.info(`Custom instruction update for ${agent} is not yet supported.`);
+			print.info("Please manually add the instructions to your agent configuration.");
+			print.info("\nInstruction prompt to add:");
+			print.info(instructionPrompt);
+			return;
+		}
+		await service.updatePrompt({
+			systemPrompt: instructionPrompt,
+			customInstructionFile,
+			marker: true
+		});
+		if (customInstructionFile) print.success(`Custom instructions written to ${customInstructionFile} and referenced in CLAUDE.md and AGENTS.md`);
+		else print.success(`Custom instructions appended to CLAUDE.md and AGENTS.md`);
+	}
+	/**
+	* Setup MCP configuration for the selected coding agent
+	* @param agent - The coding agent to configure
+	*/
+	async setupMCP(agent) {
+		if (agent === NONE) {
+			print.info("Skipping MCP configuration");
+			return;
+		}
+		print.info(`\nSetting up MCP for ${agent}...`);
+		const service = this.getCodingAgentService(agent);
+		let configLocation = "";
+		let restartInstructions = "";
+		if (agent === CLAUDE_CODE) {
+			configLocation = ".mcp.json";
+			restartInstructions = "Restart Claude Code to load the new MCP servers";
+		} else if (agent === CURSOR) {
+			configLocation = "~/.cursor/mcp.json (or .cursor/mcp.json for workspace)";
+			restartInstructions = "Restart Cursor to load the new MCP servers";
+		} else if (agent === GITHUB_COPILOT) {
+			configLocation = "~/.copilot/config.json (CLI) or GitHub UI (Coding Agent)";
+			restartInstructions = "Restart GitHub Copilot CLI or configure via GitHub repository settings";
+		} else if (agent === CODEX) {
+			configLocation = "~/.codex/config.toml";
+			restartInstructions = "Restart Codex CLI to load the new MCP servers";
+		} else if (agent === GEMINI_CLI) {
+			configLocation = "~/.gemini/settings.json";
+			restartInstructions = "Restart Gemini CLI to load the new MCP servers";
+		}
+		if (!service) {
+			print.info(`MCP configuration for ${agent} is not yet supported.`);
+			print.info("Please configure MCP servers manually for this coding agent.");
+			return;
+		}
+		await service.updateMcpSettings({ servers: {
+			"scaffold-mcp": {
+				type: "stdio",
+				command: "npx",
+				args: [
+					"-y",
+					"@agiflowai/scaffold-mcp",
+					"mcp-serve"
+				],
+				disabled: false
+			},
+			"architect-mcp": {
+				type: "stdio",
+				command: "npx",
+				args: [
+					"-y",
+					"@agiflowai/architect-mcp",
+					"mcp-serve"
+				],
+				disabled: false
+			}
+		} });
+		print.success(`Added scaffold-mcp and architect-mcp to ${configLocation}`);
+		print.info("\nNext steps:");
+		print.indent(`1. ${restartInstructions}`);
+		print.indent("2. The scaffold-mcp and architect-mcp servers will be available");
+		print.success("\nMCP configuration completed!");
+	}
+};
+
 //#endregion
 //#region src/utils/banner.ts
 /**
@@ -145,8 +325,7 @@ async function findWorkspaceRoot(startPath = process.cwd()) {
 	let currentPath = path.resolve(startPath);
 	const rootPath = path.parse(currentPath).root;
 	while (true) {
-		const gitPath = path.join(currentPath, ".git");
-		if (await fs$1.pathExists(gitPath)) return currentPath;
+		if (await pathExists(path.join(currentPath, ".git"))) return currentPath;
 		if (currentPath === rootPath) return null;
 		currentPath = path.dirname(currentPath);
 	}
@@ -202,8 +381,7 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 			"core.sparseCheckout",
 			"true"
 		], tempFolder);
-		const sparseCheckoutFile = path.join(tempFolder, ".git", "info", "sparse-checkout");
-		await fs$1.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
+		await writeFile(path.join(tempFolder, ".git", "info", "sparse-checkout"), `${subdirectory}\n`);
 		await execGit([
 			"pull",
 			"--depth=1",
@@ -211,12 +389,12 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 			branch
 		], tempFolder);
 		const sourceDir = path.join(tempFolder, subdirectory);
-		if (!await fs$1.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
-		if (await fs$1.pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
-		await fs$1.move(sourceDir, targetFolder);
-		await fs$1.remove(tempFolder);
+		if (!await pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
+		if (await pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
+		await move(sourceDir, targetFolder);
+		await remove(tempFolder);
 	} catch (error) {
-		if (await fs$1.pathExists(tempFolder)) await fs$1.remove(tempFolder);
+		if (await pathExists(tempFolder)) await remove(tempFolder);
 		throw error;
 	}
 }
@@ -230,7 +408,7 @@ async function cloneRepository(repoUrl, targetFolder) {
 		targetFolder
 	]);
 	const gitFolder = path.join(targetFolder, ".git");
-	if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
+	if (await pathExists(gitFolder)) await remove(gitFolder);
 }
 /**
 * Fetch directory listing from GitHub API
@@ -251,172 +429,27 @@ async function fetchGitHubDirectoryContents(owner, repo, path$1, branch = "main"
 	}));
 }
 
-//#endregion
-//#region src/services/CodingAgentService.ts
-var CodingAgentService = class {
-	workspaceRoot;
-	constructor(workspaceRoot) {
-		this.workspaceRoot = workspaceRoot;
-	}
-	/**
-	* Detect which coding agent is enabled in the workspace
-	* Checks for Claude Code, Codex, Gemini CLI, GitHub Copilot, and Cursor installations
-	* @param workspaceRoot - The workspace root directory
-	* @returns Promise resolving to detected agent ID or null
-	*/
-	static async detectCodingAgent(workspaceRoot) {
-		if (await new ClaudeCodeService({ workspaceRoot }).isEnabled()) return CLAUDE_CODE;
-		if (await new CursorService({ workspaceRoot }).isEnabled()) return CURSOR;
-		if (await new GitHubCopilotService({ workspaceRoot }).isEnabled()) return GITHUB_COPILOT;
-		if (await new CodexService({ workspaceRoot }).isEnabled()) return CODEX;
-		if (await new GeminiCliService({ workspaceRoot }).isEnabled()) return GEMINI_CLI;
-		return null;
-	}
-	/**
-	* Get available coding agents with their descriptions
-	*/
-	static getAvailableAgents() {
-		return [
-			{
-				value: CLAUDE_CODE,
-				name: "Claude Code",
-				description: "Anthropic Claude Code CLI agent"
-			},
-			{
-				value: CURSOR,
-				name: "Cursor",
-				description: "Cursor AI-first code editor"
-			},
-			{
-				value: GITHUB_COPILOT,
-				name: "GitHub Copilot",
-				description: "GitHub Copilot coding agent and CLI"
-			},
-			{
-				value: CODEX,
-				name: "Codex",
-				description: "OpenAI Codex CLI agent"
-			},
-			{
-				value: GEMINI_CLI,
-				name: "Gemini CLI",
-				description: "Google Gemini CLI agent"
-			},
-			{
-				value: NONE,
-				name: "Other",
-				description: "Other coding agent or skip MCP configuration"
-			}
-		];
-	}
-	/**
-	* Get the coding agent service instance
-	* @param agent - The coding agent to get service for
-	* @returns The service instance or null if not supported
-	*/
-	getCodingAgentService(agent) {
-		if (agent === CLAUDE_CODE) return new ClaudeCodeService({ workspaceRoot: this.workspaceRoot });
-		if (agent === CURSOR) return new CursorService({ workspaceRoot: this.workspaceRoot });
-		if (agent === GITHUB_COPILOT) return new GitHubCopilotService({ workspaceRoot: this.workspaceRoot });
-		if (agent === CODEX) return new CodexService({ workspaceRoot: this.workspaceRoot });
-		if (agent === GEMINI_CLI) return new GeminiCliService({ workspaceRoot: this.workspaceRoot });
-		return null;
-	}
-	/**
-	* Update custom instructions/prompts for the coding agent
-	* Appends custom instruction prompt to the agent's configuration
-	* @param agent - The coding agent to update
-	* @param instructionPrompt - The instruction prompt to append
-	* @param customInstructionFile - Optional custom file path to write instructions to (e.g., '.claude/aicode-instructions.md')
-	*/
-	async updateCustomInstructions(agent, instructionPrompt, customInstructionFile) {
-		if (agent === NONE) {
-			print.info("Skipping custom instruction update");
-			return;
-		}
-		print.info(`\nUpdating custom instructions for ${agent}...`);
-		const service = this.getCodingAgentService(agent);
-		if (!service) {
-			print.info(`Custom instruction update for ${agent} is not yet supported.`);
-			print.info("Please manually add the instructions to your agent configuration.");
-			print.info("\nInstruction prompt to add:");
-			print.info(instructionPrompt);
-			return;
-		}
-		await service.updatePrompt({
-			systemPrompt: instructionPrompt,
-			customInstructionFile,
-			marker: true
-		});
-		if (customInstructionFile) print.success(`Custom instructions written to ${customInstructionFile} and referenced in CLAUDE.md and AGENTS.md`);
-		else print.success(`Custom instructions appended to CLAUDE.md and AGENTS.md`);
-	}
-	/**
-	* Setup MCP configuration for the selected coding agent
-	* @param agent - The coding agent to configure
-	*/
-	async setupMCP(agent) {
-		if (agent === NONE) {
-			print.info("Skipping MCP configuration");
-			return;
-		}
-		print.info(`\nSetting up MCP for ${agent}...`);
-		const service = this.getCodingAgentService(agent);
-		let configLocation = "";
-		let restartInstructions = "";
-		if (agent === CLAUDE_CODE) {
-			configLocation = ".mcp.json";
-			restartInstructions = "Restart Claude Code to load the new MCP servers";
-		} else if (agent === CURSOR) {
-			configLocation = "~/.cursor/mcp.json (or .cursor/mcp.json for workspace)";
-			restartInstructions = "Restart Cursor to load the new MCP servers";
-		} else if (agent === GITHUB_COPILOT) {
-			configLocation = "~/.copilot/config.json (CLI) or GitHub UI (Coding Agent)";
-			restartInstructions = "Restart GitHub Copilot CLI or configure via GitHub repository settings";
-		} else if (agent === CODEX) {
-			configLocation = "~/.codex/config.toml";
-			restartInstructions = "Restart Codex CLI to load the new MCP servers";
-		} else if (agent === GEMINI_CLI) {
-			configLocation = "~/.gemini/settings.json";
-			restartInstructions = "Restart Gemini CLI to load the new MCP servers";
-		}
-		if (!service) {
-			print.info(`MCP configuration for ${agent} is not yet supported.`);
-			print.info("Please configure MCP servers manually for this coding agent.");
-			return;
-		}
-		await service.updateMcpSettings({ servers: {
-			"scaffold-mcp": {
-				type: "stdio",
-				command: "npx",
-				args: [
-					"-y",
-					"@agiflowai/scaffold-mcp",
-					"mcp-serve"
-				],
-				disabled: false
-			},
-			"architect-mcp": {
-				type: "stdio",
-				command: "npx",
-				args: [
-					"-y",
-					"@agiflowai/architect-mcp",
-					"mcp-serve"
-				],
-				disabled: false
-			}
-		} });
-		print.success(`Added scaffold-mcp and architect-mcp to ${configLocation}`);
-		print.info("\nNext steps:");
-		print.indent(`1. ${restartInstructions}`);
-		print.indent("2. The scaffold-mcp and architect-mcp servers will be available");
-		print.success("\nMCP configuration completed!");
-	}
-};
-
 //#endregion
 //#region src/services/NewProjectService.ts
+/**
+* NewProjectService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Single responsibility principle
+* - No UI interaction (prompts handled by CLI layer)
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Keep methods focused and well-named
+* - Document complex logic with comments
+*
+* AVOID:
+* - Mixing concerns (keep focused on single domain)
+* - Direct UI interaction (no @inquirer/prompts in services)
+* - Direct tool implementation (services should be tool-agnostic)
+*/
 const RESERVED_PROJECT_NAMES = [
 	".",
 	"..",
@@ -490,7 +523,7 @@ var NewProjectService = class {
 	*/
 	async createProjectDirectory(projectPath, projectName) {
 		try {
-			await fs$1.mkdir(projectPath, { recursive: false });
+			await mkdir(projectPath, { recursive: false });
 		} catch (error) {
 			if (error.code === "EEXIST") throw new Error(`Directory '${projectName}' already exists. Please choose a different name.`);
 			throw error;
@@ -507,7 +540,7 @@ var NewProjectService = class {
 			if (parsed.isSubdirectory && parsed.branch && parsed.subdirectory) await cloneSubdirectory(parsed.repoUrl, parsed.branch, parsed.subdirectory, projectPath);
 			else await cloneRepository(parsed.repoUrl, projectPath);
 		} catch (error) {
-			await fs$1.remove(projectPath);
+			await remove(projectPath);
 			throw new Error(`Failed to clone repository: ${error.message}`);
 		}
 	}
@@ -541,6 +574,18 @@ var openspec_default = "When working on this project, follow the OpenSpec spec-d
 //#endregion
 //#region src/specs/openspec.ts
 /**
+* OpenSpec Bridge Implementation
+*
+* DESIGN PATTERNS:
+* - Bridge pattern implementation for OpenSpec
+* - Singleton pattern for OpenSpec configuration
+*
+* CODING STANDARDS:
+* - Implement ISpecBridge interface
+* - Use async/await for I/O operations
+* - Handle errors with descriptive messages
+*/
+/**
 * OpenSpec configuration
 */
 const OPENSPEC_CONFIG = {
@@ -606,6 +651,18 @@ var OpenSpecBridge = class {
 //#endregion
 //#region src/services/SpecToolService.ts
 /**
+* Spec Tool Service
+*
+* DESIGN PATTERNS:
+* - Service pattern for spec tool detection and installation
+* - Bridge pattern to abstract spec tool implementations
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Handle errors with try/catch blocks
+* - Use descriptive method names
+*/
+/**
 * Available spec tools
 */
 let SpecTool = /* @__PURE__ */ function(SpecTool$1) {
@@ -683,6 +740,22 @@ var SpecToolService = class {
 
 //#endregion
 //#region src/services/TemplateSelectionService.ts
+/**
+* TemplateSelectionService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Single responsibility: Handle template download, listing, and selection
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Document methods with JSDoc comments
+*
+* AVOID:
+* - Direct UI interaction (no prompts in services)
+* - Mixing concerns beyond template management
+*/
 var TemplateSelectionService = class {
 	tmpDir;
 	constructor(existingTmpDir) {
@@ -695,7 +768,7 @@ var TemplateSelectionService = class {
 	*/
 	async downloadTemplatesToTmp(repoConfig) {
 		try {
-			await fs$1.ensureDir(this.tmpDir);
+			await ensureDir(this.tmpDir);
 			const contents = await fetchGitHubDirectoryContents(repoConfig.owner, repoConfig.repo, repoConfig.path, repoConfig.branch);
 			const templateDirs = contents.filter((item) => item.type === "dir");
 			const globalFiles = contents.filter((item) => item.type === "file" && item.name === "RULES.yaml");
@@ -713,8 +786,7 @@ var TemplateSelectionService = class {
 				const targetFile = path.join(this.tmpDir, "RULES.yaml");
 				const response = await fetch(rulesUrl);
 				if (response.ok) {
-					const content = await response.text();
-					await fs$1.writeFile(targetFile, content, "utf-8");
+					await writeFile(targetFile, await response.text(), "utf-8");
 					print.success("Downloaded global RULES.yaml");
 				}
 			}
@@ -731,7 +803,7 @@ var TemplateSelectionService = class {
 	*/
 	async listTemplates() {
 		try {
-			const entries = await fs$1.readdir(this.tmpDir, { withFileTypes: true });
+			const entries = await readdir(this.tmpDir, { withFileTypes: true });
 			const templates = [];
 			for (const entry of entries) if (entry.isDirectory()) {
 				const templatePath = path.join(this.tmpDir, entry.name);
@@ -757,27 +829,27 @@ var TemplateSelectionService = class {
 	async copyTemplates(templateNames, destinationPath, projectType, selectedMcpServers) {
 		try {
 			if (projectType === ProjectType.MONOLITH && templateNames.length > 1) throw new Error("Monolith projects can only use a single template");
-			await fs$1.ensureDir(destinationPath);
+			await ensureDir(destinationPath);
 			print.info(`\nCopying templates to ${destinationPath}...`);
 			for (const templateName of templateNames) {
 				const sourcePath = path.join(this.tmpDir, templateName);
 				const targetPath = path.join(destinationPath, templateName);
-				if (!await fs$1.pathExists(sourcePath)) throw new Error(`Template '${templateName}' not found in downloaded templates`);
-				if (await fs$1.pathExists(targetPath)) {
+				if (!await pathExists(sourcePath)) throw new Error(`Template '${templateName}' not found in downloaded templates`);
+				if (await pathExists(targetPath)) {
 					print.info(`Skipping ${templateName} (already exists)`);
 					continue;
 				}
 				print.info(`Copying ${templateName}...`);
 				if (selectedMcpServers && selectedMcpServers.length > 0) await this.copyTemplateWithMcpFilter(sourcePath, targetPath, selectedMcpServers);
-				else await fs$1.copy(sourcePath, targetPath);
+				else await copy(sourcePath, targetPath);
 				print.success(`Copied ${templateName}`);
 			}
 			const globalRulesSource = path.join(this.tmpDir, "RULES.yaml");
 			const globalRulesTarget = path.join(destinationPath, "RULES.yaml");
-			if (await fs$1.pathExists(globalRulesSource)) {
-				if (!await fs$1.pathExists(globalRulesTarget)) {
+			if (await pathExists(globalRulesSource)) {
+				if (!await pathExists(globalRulesTarget)) {
 					print.info("Copying global RULES.yaml...");
-					await fs$1.copy(globalRulesSource, globalRulesTarget);
+					await copy(globalRulesSource, globalRulesTarget);
 					print.success("Copied global RULES.yaml");
 				}
 			}
@@ -793,23 +865,23 @@ var TemplateSelectionService = class {
 	* @param selectedMcpServers - Selected MCP servers
 	*/
 	async copyTemplateWithMcpFilter(sourcePath, targetPath, selectedMcpServers) {
-		const { MCPServer: MCPServer$1, MCP_CONFIG_FILES: MCP_CONFIG_FILES$1 } = await import("./mcp-CZIiB-6Y.js");
+		const { MCPServer: MCPServer$1, MCP_CONFIG_FILES: MCP_CONFIG_FILES$1 } = await import("./mcp-BgNkvV6h.mjs");
 		const architectFiles = MCP_CONFIG_FILES$1[MCPServer$1.ARCHITECT];
 		const hasArchitect = selectedMcpServers.includes(MCPServer$1.ARCHITECT);
 		const hasScaffold = selectedMcpServers.includes(MCPServer$1.SCAFFOLD);
-		await fs$1.ensureDir(targetPath);
-		const entries = await fs$1.readdir(sourcePath, { withFileTypes: true });
+		await ensureDir(targetPath);
+		const entries = await readdir(sourcePath, { withFileTypes: true });
 		for (const entry of entries) {
 			const entrySourcePath = path.join(sourcePath, entry.name);
 			const entryTargetPath = path.join(targetPath, entry.name);
 			const isArchitectFile = architectFiles.includes(entry.name);
-			if (hasArchitect && hasScaffold) if (entry.isDirectory()) await fs$1.copy(entrySourcePath, entryTargetPath);
-			else await fs$1.copy(entrySourcePath, entryTargetPath);
+			if (hasArchitect && hasScaffold) if (entry.isDirectory()) await copy(entrySourcePath, entryTargetPath);
+			else await copy(entrySourcePath, entryTargetPath);
 			else if (hasArchitect && !hasScaffold) {
-				if (isArchitectFile) await fs$1.copy(entrySourcePath, entryTargetPath);
+				if (isArchitectFile) await copy(entrySourcePath, entryTargetPath);
 			} else if (!hasArchitect && hasScaffold) {
-				if (!isArchitectFile) if (entry.isDirectory()) await fs$1.copy(entrySourcePath, entryTargetPath);
-				else await fs$1.copy(entrySourcePath, entryTargetPath);
+				if (!isArchitectFile) if (entry.isDirectory()) await copy(entrySourcePath, entryTargetPath);
+				else await copy(entrySourcePath, entryTargetPath);
 			}
 		}
 	}
@@ -821,15 +893,15 @@ var TemplateSelectionService = class {
 	async readTemplateDescription(templatePath) {
 		try {
 			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
-			if (await fs$1.pathExists(scaffoldYamlPath)) {
+			if (await pathExists(scaffoldYamlPath)) {
 				const yaml = await import("js-yaml");
-				const content = await fs$1.readFile(scaffoldYamlPath, "utf-8");
+				const content = await readFile(scaffoldYamlPath, "utf-8");
 				const scaffoldConfig = yaml.load(content);
 				if (scaffoldConfig?.description) return scaffoldConfig.description;
 				if (scaffoldConfig?.boilerplate?.[0]?.description) return scaffoldConfig.boilerplate[0].description;
 			}
 			const readmePath = path.join(templatePath, "README.md");
-			if (await fs$1.pathExists(readmePath)) return (await fs$1.readFile(readmePath, "utf-8")).split("\n\n")[0].substring(0, 200).trim();
+			if (await pathExists(readmePath)) return (await readFile(readmePath, "utf-8")).split("\n\n")[0].substring(0, 200).trim();
 			return;
 		} catch {
 			return;
@@ -846,7 +918,7 @@ var TemplateSelectionService = class {
 	*/
 	async cleanup() {
 		try {
-			if (await fs$1.pathExists(this.tmpDir)) await fs$1.remove(this.tmpDir);
+			if (await pathExists(this.tmpDir)) await remove(this.tmpDir);
 		} catch (error) {
 			print.warning(`Warning: Failed to clean up tmp directory: ${error.message}`);
 		}
@@ -855,6 +927,23 @@ var TemplateSelectionService = class {
 
 //#endregion
 //#region src/services/TemplatesService.ts
+/**
+* TemplatesService
+*
+* DESIGN PATTERNS:
+* - Service pattern for business logic encapsulation
+* - Single responsibility principle
+*
+* CODING STANDARDS:
+* - Use async/await for asynchronous operations
+* - Throw descriptive errors for error cases
+* - Keep methods focused and well-named
+* - Document complex logic with comments
+*
+* AVOID:
+* - Mixing concerns (keep focused on single domain)
+* - Direct tool implementation (services should be tool-agnostic)
+*/
 var TemplatesService = class {
 	/**
 	* Download templates from a GitHub repository with UI feedback
@@ -874,7 +963,7 @@ var TemplatesService = class {
 			let _skipped = 0;
 			for (const template of templateDirs) {
 				const targetFolder = path.join(templatesPath, template.name);
-				if (await fs$1.pathExists(targetFolder)) {
+				if (await pathExists(targetFolder)) {
 					print.info(`Skipping ${template.name} (already exists)`);
 					_skipped++;
 					continue;
@@ -894,8 +983,8 @@ var TemplatesService = class {
 	* @param templatesPath - Path where templates folder should be created
 	*/
 	async initializeTemplatesFolder(templatesPath) {
-		await fs$1.ensureDir(templatesPath);
-		await fs$1.writeFile(path.join(templatesPath, "README.md"), `# Templates
+		await ensureDir(templatesPath);
+		await writeFile(path.join(templatesPath, "README.md"), `# Templates
 
 This folder contains boilerplate templates and scaffolding methods for your projects.
 
@@ -933,4 +1022,4 @@ See existing templates for examples and documentation for more details.
 };
 
 //#endregion
-export { BANNER_GRADIENT, CodingAgentService, NewProjectService, SPEC_TOOL_INFO, SpecTool, SpecToolService, THEME, TemplateSelectionService, TemplatesService, cloneRepository, cloneSubdirectory, displayBanner, displayCompactBanner, fetchGitHubDirectoryContents, findWorkspaceRoot, gitInit, parseGitHubUrl };
+export { THEME as _, SpecToolService as a, cloneSubdirectory as c, gitInit as d, parseGitHubUrl as f, BANNER_GRADIENT as g, CodingAgentService as h, SpecTool as i, fetchGitHubDirectoryContents as l, displayCompactBanner as m, TemplateSelectionService as n, NewProjectService as o, displayBanner as p, SPEC_TOOL_INFO as r, cloneRepository as s, TemplatesService as t, findWorkspaceRoot as u };