@agiflowai/aicode-toolkit 1.0.3 → 1.0.5

package/dist/{services-C6lqyioO.cjs → services-DIUrmi_K.cjs}

@@ -21,24 +21,18 @@ var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__ge
 }) : target, mod));
 
 //#endregion
-let node_path = require("node:path");
-node_path = __toESM(node_path);
+let __agiflowai_coding_agent_bridge = require("@agiflowai/coding-agent-bridge");
 let __agiflowai_aicode_utils = require("@agiflowai/aicode-utils");
-__agiflowai_aicode_utils = __toESM(__agiflowai_aicode_utils);
-let fs_extra = require("fs-extra");
-fs_extra = __toESM(fs_extra);
 let chalk = require("chalk");
 chalk = __toESM(chalk);
 let gradient_string = require("gradient-string");
 gradient_string = __toESM(gradient_string);
+let node_path = require("node:path");
+node_path = __toESM(node_path);
 let execa = require("execa");
-execa = __toESM(execa);
-let __agiflowai_coding_agent_bridge = require("@agiflowai/coding-agent-bridge");
-__agiflowai_coding_agent_bridge = __toESM(__agiflowai_coding_agent_bridge);
 let node_fs_promises = require("node:fs/promises");
 node_fs_promises = __toESM(node_fs_promises);
 let liquidjs = require("liquidjs");
-liquidjs = __toESM(liquidjs);
 let node_os = require("node:os");
 node_os = __toESM(node_os);
 
@@ -103,6 +97,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 __agiflowai_coding_agent_bridge.ClaudeCodeService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.CLAUDE_CODE;
+		if (await new __agiflowai_coding_agent_bridge.CursorService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.CURSOR;
+		if (await new __agiflowai_coding_agent_bridge.GitHubCopilotService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.GITHUB_COPILOT;
+		if (await new __agiflowai_coding_agent_bridge.CodexService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.CODEX;
+		if (await new __agiflowai_coding_agent_bridge.GeminiCliService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.GEMINI_CLI;
+		return null;
+	}
+	/**
+	* Get available coding agents with their descriptions
+	*/
+	static getAvailableAgents() {
+		return [
+			{
+				value: __agiflowai_coding_agent_bridge.CLAUDE_CODE,
+				name: "Claude Code",
+				description: "Anthropic Claude Code CLI agent"
+			},
+			{
+				value: __agiflowai_coding_agent_bridge.CURSOR,
+				name: "Cursor",
+				description: "Cursor AI-first code editor"
+			},
+			{
+				value: __agiflowai_coding_agent_bridge.GITHUB_COPILOT,
+				name: "GitHub Copilot",
+				description: "GitHub Copilot coding agent and CLI"
+			},
+			{
+				value: __agiflowai_coding_agent_bridge.CODEX,
+				name: "Codex",
+				description: "OpenAI Codex CLI agent"
+			},
+			{
+				value: __agiflowai_coding_agent_bridge.GEMINI_CLI,
+				name: "Gemini CLI",
+				description: "Google Gemini CLI agent"
+			},
+			{
+				value: __agiflowai_coding_agent_bridge.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 === __agiflowai_coding_agent_bridge.CLAUDE_CODE) return new __agiflowai_coding_agent_bridge.ClaudeCodeService({ workspaceRoot: this.workspaceRoot });
+		if (agent === __agiflowai_coding_agent_bridge.CURSOR) return new __agiflowai_coding_agent_bridge.CursorService({ workspaceRoot: this.workspaceRoot });
+		if (agent === __agiflowai_coding_agent_bridge.GITHUB_COPILOT) return new __agiflowai_coding_agent_bridge.GitHubCopilotService({ workspaceRoot: this.workspaceRoot });
+		if (agent === __agiflowai_coding_agent_bridge.CODEX) return new __agiflowai_coding_agent_bridge.CodexService({ workspaceRoot: this.workspaceRoot });
+		if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) return new __agiflowai_coding_agent_bridge.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 === __agiflowai_coding_agent_bridge.NONE) {
+			__agiflowai_aicode_utils.print.info("Skipping custom instruction update");
+			return;
+		}
+		__agiflowai_aicode_utils.print.info(`\nUpdating custom instructions for ${agent}...`);
+		const service = this.getCodingAgentService(agent);
+		if (!service) {
+			__agiflowai_aicode_utils.print.info(`Custom instruction update for ${agent} is not yet supported.`);
+			__agiflowai_aicode_utils.print.info("Please manually add the instructions to your agent configuration.");
+			__agiflowai_aicode_utils.print.info("\nInstruction prompt to add:");
+			__agiflowai_aicode_utils.print.info(instructionPrompt);
+			return;
+		}
+		await service.updatePrompt({
+			systemPrompt: instructionPrompt,
+			customInstructionFile,
+			marker: true
+		});
+		if (customInstructionFile) __agiflowai_aicode_utils.print.success(`Custom instructions written to ${customInstructionFile} and referenced in CLAUDE.md and AGENTS.md`);
+		else __agiflowai_aicode_utils.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 === __agiflowai_coding_agent_bridge.NONE) {
+			__agiflowai_aicode_utils.print.info("Skipping MCP configuration");
+			return;
+		}
+		__agiflowai_aicode_utils.print.info(`\nSetting up MCP for ${agent}...`);
+		const service = this.getCodingAgentService(agent);
+		let configLocation = "";
+		let restartInstructions = "";
+		if (agent === __agiflowai_coding_agent_bridge.CLAUDE_CODE) {
+			configLocation = ".mcp.json";
+			restartInstructions = "Restart Claude Code to load the new MCP servers";
+		} else if (agent === __agiflowai_coding_agent_bridge.CURSOR) {
+			configLocation = "~/.cursor/mcp.json (or .cursor/mcp.json for workspace)";
+			restartInstructions = "Restart Cursor to load the new MCP servers";
+		} else if (agent === __agiflowai_coding_agent_bridge.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 === __agiflowai_coding_agent_bridge.CODEX) {
+			configLocation = "~/.codex/config.toml";
+			restartInstructions = "Restart Codex CLI to load the new MCP servers";
+		} else if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) {
+			configLocation = "~/.gemini/settings.json";
+			restartInstructions = "Restart Gemini CLI to load the new MCP servers";
+		}
+		if (!service) {
+			__agiflowai_aicode_utils.print.info(`MCP configuration for ${agent} is not yet supported.`);
+			__agiflowai_aicode_utils.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
+			}
+		} });
+		__agiflowai_aicode_utils.print.success(`Added scaffold-mcp and architect-mcp to ${configLocation}`);
+		__agiflowai_aicode_utils.print.info("\nNext steps:");
+		__agiflowai_aicode_utils.print.indent(`1. ${restartInstructions}`);
+		__agiflowai_aicode_utils.print.indent("2. The scaffold-mcp and architect-mcp servers will be available");
+		__agiflowai_aicode_utils.print.success("\nMCP configuration completed!");
+	}
+};
+
 //#endregion
 //#region src/utils/banner.ts
 /**
@@ -178,8 +353,7 @@ async function findWorkspaceRoot(startPath = process.cwd()) {
 	let currentPath = node_path.default.resolve(startPath);
 	const rootPath = node_path.default.parse(currentPath).root;
 	while (true) {
-		const gitPath = node_path.default.join(currentPath, ".git");
-		if (await fs_extra.pathExists(gitPath)) return currentPath;
+		if (await (0, __agiflowai_aicode_utils.pathExists)(node_path.default.join(currentPath, ".git"))) return currentPath;
 		if (currentPath === rootPath) return null;
 		currentPath = node_path.default.dirname(currentPath);
 	}
@@ -235,8 +409,7 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 			"core.sparseCheckout",
 			"true"
 		], tempFolder);
-		const sparseCheckoutFile = node_path.default.join(tempFolder, ".git", "info", "sparse-checkout");
-		await fs_extra.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
+		await (0, __agiflowai_aicode_utils.writeFile)(node_path.default.join(tempFolder, ".git", "info", "sparse-checkout"), `${subdirectory}\n`);
 		await execGit([
 			"pull",
 			"--depth=1",
@@ -244,12 +417,12 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 			branch
 		], tempFolder);
 		const sourceDir = node_path.default.join(tempFolder, subdirectory);
-		if (!await fs_extra.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
-		if (await fs_extra.pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
-		await fs_extra.move(sourceDir, targetFolder);
-		await fs_extra.remove(tempFolder);
+		if (!await (0, __agiflowai_aicode_utils.pathExists)(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
+		if (await (0, __agiflowai_aicode_utils.pathExists)(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
+		await (0, __agiflowai_aicode_utils.move)(sourceDir, targetFolder);
+		await (0, __agiflowai_aicode_utils.remove)(tempFolder);
 	} catch (error) {
-		if (await fs_extra.pathExists(tempFolder)) await fs_extra.remove(tempFolder);
+		if (await (0, __agiflowai_aicode_utils.pathExists)(tempFolder)) await (0, __agiflowai_aicode_utils.remove)(tempFolder);
 		throw error;
 	}
 }
@@ -263,7 +436,7 @@ async function cloneRepository(repoUrl, targetFolder) {
 		targetFolder
 	]);
 	const gitFolder = node_path.default.join(targetFolder, ".git");
-	if (await fs_extra.pathExists(gitFolder)) await fs_extra.remove(gitFolder);
+	if (await (0, __agiflowai_aicode_utils.pathExists)(gitFolder)) await (0, __agiflowai_aicode_utils.remove)(gitFolder);
 }
 /**
 * Fetch directory listing from GitHub API
@@ -284,172 +457,27 @@ async function fetchGitHubDirectoryContents(owner, repo, path$4, 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 __agiflowai_coding_agent_bridge.ClaudeCodeService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.CLAUDE_CODE;
-		if (await new __agiflowai_coding_agent_bridge.CursorService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.CURSOR;
-		if (await new __agiflowai_coding_agent_bridge.GitHubCopilotService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.GITHUB_COPILOT;
-		if (await new __agiflowai_coding_agent_bridge.CodexService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.CODEX;
-		if (await new __agiflowai_coding_agent_bridge.GeminiCliService({ workspaceRoot }).isEnabled()) return __agiflowai_coding_agent_bridge.GEMINI_CLI;
-		return null;
-	}
-	/**
-	* Get available coding agents with their descriptions
-	*/
-	static getAvailableAgents() {
-		return [
-			{
-				value: __agiflowai_coding_agent_bridge.CLAUDE_CODE,
-				name: "Claude Code",
-				description: "Anthropic Claude Code CLI agent"
-			},
-			{
-				value: __agiflowai_coding_agent_bridge.CURSOR,
-				name: "Cursor",
-				description: "Cursor AI-first code editor"
-			},
-			{
-				value: __agiflowai_coding_agent_bridge.GITHUB_COPILOT,
-				name: "GitHub Copilot",
-				description: "GitHub Copilot coding agent and CLI"
-			},
-			{
-				value: __agiflowai_coding_agent_bridge.CODEX,
-				name: "Codex",
-				description: "OpenAI Codex CLI agent"
-			},
-			{
-				value: __agiflowai_coding_agent_bridge.GEMINI_CLI,
-				name: "Gemini CLI",
-				description: "Google Gemini CLI agent"
-			},
-			{
-				value: __agiflowai_coding_agent_bridge.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 === __agiflowai_coding_agent_bridge.CLAUDE_CODE) return new __agiflowai_coding_agent_bridge.ClaudeCodeService({ workspaceRoot: this.workspaceRoot });
-		if (agent === __agiflowai_coding_agent_bridge.CURSOR) return new __agiflowai_coding_agent_bridge.CursorService({ workspaceRoot: this.workspaceRoot });
-		if (agent === __agiflowai_coding_agent_bridge.GITHUB_COPILOT) return new __agiflowai_coding_agent_bridge.GitHubCopilotService({ workspaceRoot: this.workspaceRoot });
-		if (agent === __agiflowai_coding_agent_bridge.CODEX) return new __agiflowai_coding_agent_bridge.CodexService({ workspaceRoot: this.workspaceRoot });
-		if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) return new __agiflowai_coding_agent_bridge.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 === __agiflowai_coding_agent_bridge.NONE) {
-			__agiflowai_aicode_utils.print.info("Skipping custom instruction update");
-			return;
-		}
-		__agiflowai_aicode_utils.print.info(`\nUpdating custom instructions for ${agent}...`);
-		const service = this.getCodingAgentService(agent);
-		if (!service) {
-			__agiflowai_aicode_utils.print.info(`Custom instruction update for ${agent} is not yet supported.`);
-			__agiflowai_aicode_utils.print.info("Please manually add the instructions to your agent configuration.");
-			__agiflowai_aicode_utils.print.info("\nInstruction prompt to add:");
-			__agiflowai_aicode_utils.print.info(instructionPrompt);
-			return;
-		}
-		await service.updatePrompt({
-			systemPrompt: instructionPrompt,
-			customInstructionFile,
-			marker: true
-		});
-		if (customInstructionFile) __agiflowai_aicode_utils.print.success(`Custom instructions written to ${customInstructionFile} and referenced in CLAUDE.md and AGENTS.md`);
-		else __agiflowai_aicode_utils.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 === __agiflowai_coding_agent_bridge.NONE) {
-			__agiflowai_aicode_utils.print.info("Skipping MCP configuration");
-			return;
-		}
-		__agiflowai_aicode_utils.print.info(`\nSetting up MCP for ${agent}...`);
-		const service = this.getCodingAgentService(agent);
-		let configLocation = "";
-		let restartInstructions = "";
-		if (agent === __agiflowai_coding_agent_bridge.CLAUDE_CODE) {
-			configLocation = ".mcp.json";
-			restartInstructions = "Restart Claude Code to load the new MCP servers";
-		} else if (agent === __agiflowai_coding_agent_bridge.CURSOR) {
-			configLocation = "~/.cursor/mcp.json (or .cursor/mcp.json for workspace)";
-			restartInstructions = "Restart Cursor to load the new MCP servers";
-		} else if (agent === __agiflowai_coding_agent_bridge.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 === __agiflowai_coding_agent_bridge.CODEX) {
-			configLocation = "~/.codex/config.toml";
-			restartInstructions = "Restart Codex CLI to load the new MCP servers";
-		} else if (agent === __agiflowai_coding_agent_bridge.GEMINI_CLI) {
-			configLocation = "~/.gemini/settings.json";
-			restartInstructions = "Restart Gemini CLI to load the new MCP servers";
-		}
-		if (!service) {
-			__agiflowai_aicode_utils.print.info(`MCP configuration for ${agent} is not yet supported.`);
-			__agiflowai_aicode_utils.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
-			}
-		} });
-		__agiflowai_aicode_utils.print.success(`Added scaffold-mcp and architect-mcp to ${configLocation}`);
-		__agiflowai_aicode_utils.print.info("\nNext steps:");
-		__agiflowai_aicode_utils.print.indent(`1. ${restartInstructions}`);
-		__agiflowai_aicode_utils.print.indent("2. The scaffold-mcp and architect-mcp servers will be available");
-		__agiflowai_aicode_utils.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 = [
 	".",
 	"..",
@@ -523,7 +551,7 @@ var NewProjectService = class {
 	*/
 	async createProjectDirectory(projectPath, projectName) {
 		try {
-			await fs_extra.mkdir(projectPath, { recursive: false });
+			await (0, __agiflowai_aicode_utils.mkdir)(projectPath, { recursive: false });
 		} catch (error) {
 			if (error.code === "EEXIST") throw new Error(`Directory '${projectName}' already exists. Please choose a different name.`);
 			throw error;
@@ -540,7 +568,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_extra.remove(projectPath);
+			await (0, __agiflowai_aicode_utils.remove)(projectPath);
 			throw new Error(`Failed to clone repository: ${error.message}`);
 		}
 	}
@@ -574,6 +602,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 = {
@@ -639,6 +679,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) {
@@ -716,6 +768,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) {
@@ -728,7 +796,7 @@ var TemplateSelectionService = class {
 	*/
 	async downloadTemplatesToTmp(repoConfig) {
 		try {
-			await fs_extra.ensureDir(this.tmpDir);
+			await (0, __agiflowai_aicode_utils.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");
@@ -746,8 +814,7 @@ var TemplateSelectionService = class {
 				const targetFile = node_path.default.join(this.tmpDir, "RULES.yaml");
 				const response = await fetch(rulesUrl);
 				if (response.ok) {
-					const content = await response.text();
-					await fs_extra.writeFile(targetFile, content, "utf-8");
+					await (0, __agiflowai_aicode_utils.writeFile)(targetFile, await response.text(), "utf-8");
 					__agiflowai_aicode_utils.print.success("Downloaded global RULES.yaml");
 				}
 			}
@@ -764,7 +831,7 @@ var TemplateSelectionService = class {
 	*/
 	async listTemplates() {
 		try {
-			const entries = await fs_extra.readdir(this.tmpDir, { withFileTypes: true });
+			const entries = await (0, __agiflowai_aicode_utils.readdir)(this.tmpDir, { withFileTypes: true });
 			const templates = [];
 			for (const entry of entries) if (entry.isDirectory()) {
 				const templatePath = node_path.default.join(this.tmpDir, entry.name);
@@ -790,27 +857,27 @@ var TemplateSelectionService = class {
 	async copyTemplates(templateNames, destinationPath, projectType, selectedMcpServers) {
 		try {
 			if (projectType === __agiflowai_aicode_utils.ProjectType.MONOLITH && templateNames.length > 1) throw new Error("Monolith projects can only use a single template");
-			await fs_extra.ensureDir(destinationPath);
+			await (0, __agiflowai_aicode_utils.ensureDir)(destinationPath);
 			__agiflowai_aicode_utils.print.info(`\nCopying templates to ${destinationPath}...`);
 			for (const templateName of templateNames) {
 				const sourcePath = node_path.default.join(this.tmpDir, templateName);
 				const targetPath = node_path.default.join(destinationPath, templateName);
-				if (!await fs_extra.pathExists(sourcePath)) throw new Error(`Template '${templateName}' not found in downloaded templates`);
-				if (await fs_extra.pathExists(targetPath)) {
+				if (!await (0, __agiflowai_aicode_utils.pathExists)(sourcePath)) throw new Error(`Template '${templateName}' not found in downloaded templates`);
+				if (await (0, __agiflowai_aicode_utils.pathExists)(targetPath)) {
 					__agiflowai_aicode_utils.print.info(`Skipping ${templateName} (already exists)`);
 					continue;
 				}
 				__agiflowai_aicode_utils.print.info(`Copying ${templateName}...`);
 				if (selectedMcpServers && selectedMcpServers.length > 0) await this.copyTemplateWithMcpFilter(sourcePath, targetPath, selectedMcpServers);
-				else await fs_extra.copy(sourcePath, targetPath);
+				else await (0, __agiflowai_aicode_utils.copy)(sourcePath, targetPath);
 				__agiflowai_aicode_utils.print.success(`Copied ${templateName}`);
 			}
 			const globalRulesSource = node_path.default.join(this.tmpDir, "RULES.yaml");
 			const globalRulesTarget = node_path.default.join(destinationPath, "RULES.yaml");
-			if (await fs_extra.pathExists(globalRulesSource)) {
-				if (!await fs_extra.pathExists(globalRulesTarget)) {
+			if (await (0, __agiflowai_aicode_utils.pathExists)(globalRulesSource)) {
+				if (!await (0, __agiflowai_aicode_utils.pathExists)(globalRulesTarget)) {
 					__agiflowai_aicode_utils.print.info("Copying global RULES.yaml...");
-					await fs_extra.copy(globalRulesSource, globalRulesTarget);
+					await (0, __agiflowai_aicode_utils.copy)(globalRulesSource, globalRulesTarget);
 					__agiflowai_aicode_utils.print.success("Copied global RULES.yaml");
 				}
 			}
@@ -830,19 +897,19 @@ var TemplateSelectionService = class {
 		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_extra.ensureDir(targetPath);
-		const entries = await fs_extra.readdir(sourcePath, { withFileTypes: true });
+		await (0, __agiflowai_aicode_utils.ensureDir)(targetPath);
+		const entries = await (0, __agiflowai_aicode_utils.readdir)(sourcePath, { withFileTypes: true });
 		for (const entry of entries) {
 			const entrySourcePath = node_path.default.join(sourcePath, entry.name);
 			const entryTargetPath = node_path.default.join(targetPath, entry.name);
 			const isArchitectFile = architectFiles.includes(entry.name);
-			if (hasArchitect && hasScaffold) if (entry.isDirectory()) await fs_extra.copy(entrySourcePath, entryTargetPath);
-			else await fs_extra.copy(entrySourcePath, entryTargetPath);
+			if (hasArchitect && hasScaffold) if (entry.isDirectory()) await (0, __agiflowai_aicode_utils.copy)(entrySourcePath, entryTargetPath);
+			else await (0, __agiflowai_aicode_utils.copy)(entrySourcePath, entryTargetPath);
 			else if (hasArchitect && !hasScaffold) {
-				if (isArchitectFile) await fs_extra.copy(entrySourcePath, entryTargetPath);
+				if (isArchitectFile) await (0, __agiflowai_aicode_utils.copy)(entrySourcePath, entryTargetPath);
 			} else if (!hasArchitect && hasScaffold) {
-				if (!isArchitectFile) if (entry.isDirectory()) await fs_extra.copy(entrySourcePath, entryTargetPath);
-				else await fs_extra.copy(entrySourcePath, entryTargetPath);
+				if (!isArchitectFile) if (entry.isDirectory()) await (0, __agiflowai_aicode_utils.copy)(entrySourcePath, entryTargetPath);
+				else await (0, __agiflowai_aicode_utils.copy)(entrySourcePath, entryTargetPath);
 			}
 		}
 	}
@@ -854,15 +921,15 @@ var TemplateSelectionService = class {
 	async readTemplateDescription(templatePath) {
 		try {
 			const scaffoldYamlPath = node_path.default.join(templatePath, "scaffold.yaml");
-			if (await fs_extra.pathExists(scaffoldYamlPath)) {
+			if (await (0, __agiflowai_aicode_utils.pathExists)(scaffoldYamlPath)) {
 				const yaml = await import("js-yaml");
-				const content = await fs_extra.readFile(scaffoldYamlPath, "utf-8");
+				const content = await (0, __agiflowai_aicode_utils.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 = node_path.default.join(templatePath, "README.md");
-			if (await fs_extra.pathExists(readmePath)) return (await fs_extra.readFile(readmePath, "utf-8")).split("\n\n")[0].substring(0, 200).trim();
+			if (await (0, __agiflowai_aicode_utils.pathExists)(readmePath)) return (await (0, __agiflowai_aicode_utils.readFile)(readmePath, "utf-8")).split("\n\n")[0].substring(0, 200).trim();
 			return;
 		} catch {
 			return;
@@ -879,7 +946,7 @@ var TemplateSelectionService = class {
 	*/
 	async cleanup() {
 		try {
-			if (await fs_extra.pathExists(this.tmpDir)) await fs_extra.remove(this.tmpDir);
+			if (await (0, __agiflowai_aicode_utils.pathExists)(this.tmpDir)) await (0, __agiflowai_aicode_utils.remove)(this.tmpDir);
 		} catch (error) {
 			__agiflowai_aicode_utils.print.warning(`Warning: Failed to clean up tmp directory: ${error.message}`);
 		}
@@ -888,6 +955,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
@@ -907,7 +991,7 @@ var TemplatesService = class {
 			let _skipped = 0;
 			for (const template of templateDirs) {
 				const targetFolder = node_path.default.join(templatesPath, template.name);
-				if (await fs_extra.pathExists(targetFolder)) {
+				if (await (0, __agiflowai_aicode_utils.pathExists)(targetFolder)) {
 					__agiflowai_aicode_utils.print.info(`Skipping ${template.name} (already exists)`);
 					_skipped++;
 					continue;
@@ -927,8 +1011,8 @@ var TemplatesService = class {
 	* @param templatesPath - Path where templates folder should be created
 	*/
 	async initializeTemplatesFolder(templatesPath) {
-		await fs_extra.ensureDir(templatesPath);
-		await fs_extra.writeFile(node_path.default.join(templatesPath, "README.md"), `# Templates
+		await (0, __agiflowai_aicode_utils.ensureDir)(templatesPath);
+		await (0, __agiflowai_aicode_utils.writeFile)(node_path.default.join(templatesPath, "README.md"), `# Templates
 
 This folder contains boilerplate templates and scaffolding methods for your projects.