@agiflowai/aicode-toolkit 0.6.0 → 1.0.1

package/dist/{services-DNldrNnu.js → services-zrdafWTg.js}

@@ -1,10 +1,12 @@
 import path from "node:path";
 import { ProjectType, messages, print } from "@agiflowai/aicode-utils";
-import * as fs from "fs-extra";
+import * as fs$1 from "fs-extra";
 import chalk from "chalk";
 import gradient from "gradient-string";
 import { execa } from "execa";
-import { CLAUDE_CODE, CODEX, ClaudeCodeService, CodexService, GEMINI_CLI, GeminiCliService, NONE } from "@agiflowai/coding-agent-bridge";
+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";
 
 //#region src/constants/theme.ts
@@ -144,7 +146,7 @@ async function findWorkspaceRoot(startPath = process.cwd()) {
 	const rootPath = path.parse(currentPath).root;
 	while (true) {
 		const gitPath = path.join(currentPath, ".git");
-		if (await fs.pathExists(gitPath)) return currentPath;
+		if (await fs$1.pathExists(gitPath)) return currentPath;
 		if (currentPath === rootPath) return null;
 		currentPath = path.dirname(currentPath);
 	}
@@ -163,11 +165,11 @@ function parseGitHubUrl(url) {
 	if (treeMatch || blobMatch) {
 		const match = treeMatch || blobMatch;
 		return {
-			owner: match[1],
-			repo: match[2],
-			repoUrl: `https://github.com/${match[1]}/${match[2]}.git`,
-			branch: match[3],
-			subdirectory: match[4],
+			owner: match?.[1],
+			repo: match?.[2],
+			repoUrl: `https://github.com/${match?.[1]}/${match?.[2]}.git`,
+			branch: match?.[3],
+			subdirectory: match?.[4],
 			isSubdirectory: true
 		};
 	}
@@ -201,7 +203,7 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 			"true"
 		], tempFolder);
 		const sparseCheckoutFile = path.join(tempFolder, ".git", "info", "sparse-checkout");
-		await fs.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
+		await fs$1.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
 		await execGit([
 			"pull",
 			"--depth=1",
@@ -209,12 +211,12 @@ async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
 			branch
 		], tempFolder);
 		const sourceDir = path.join(tempFolder, subdirectory);
-		if (!await fs.pathExists(sourceDir)) throw new Error(`Subdirectory '${subdirectory}' not found in repository at branch '${branch}'`);
-		if (await fs.pathExists(targetFolder)) throw new Error(`Target folder already exists: ${targetFolder}`);
-		await fs.move(sourceDir, targetFolder);
-		await fs.remove(tempFolder);
+		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);
 	} catch (error) {
-		if (await fs.pathExists(tempFolder)) await fs.remove(tempFolder);
+		if (await fs$1.pathExists(tempFolder)) await fs$1.remove(tempFolder);
 		throw error;
 	}
 }
@@ -228,7 +230,7 @@ async function cloneRepository(repoUrl, targetFolder) {
 		targetFolder
 	]);
 	const gitFolder = path.join(targetFolder, ".git");
-	if (await fs.pathExists(gitFolder)) await fs.remove(gitFolder);
+	if (await fs$1.pathExists(gitFolder)) await fs$1.remove(gitFolder);
 }
 /**
 * Fetch directory listing from GitHub API
@@ -258,12 +260,14 @@ var CodingAgentService = class {
 	}
 	/**
 	* Detect which coding agent is enabled in the workspace
-	* Checks for Claude Code, Codex, and Gemini CLI installations
+	* 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;
@@ -278,6 +282,16 @@ var CodingAgentService = class {
 				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",
@@ -296,6 +310,48 @@ var CodingAgentService = class {
 		];
 	}
 	/**
+	* 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
 	*/
@@ -305,19 +361,22 @@ var CodingAgentService = class {
 			return;
 		}
 		print.info(`\nSetting up MCP for ${agent}...`);
-		let service = null;
+		const service = this.getCodingAgentService(agent);
 		let configLocation = "";
 		let restartInstructions = "";
 		if (agent === CLAUDE_CODE) {
-			service = new ClaudeCodeService({ workspaceRoot: this.workspaceRoot });
 			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) {
-			service = new CodexService({ workspaceRoot: this.workspaceRoot });
 			configLocation = "~/.codex/config.toml";
 			restartInstructions = "Restart Codex CLI to load the new MCP servers";
 		} else if (agent === GEMINI_CLI) {
-			service = new GeminiCliService({ workspaceRoot: this.workspaceRoot });
 			configLocation = "~/.gemini/settings.json";
 			restartInstructions = "Restart Gemini CLI to load the new MCP servers";
 		}
@@ -431,8 +490,7 @@ var NewProjectService = class {
 	*/
 	async createProjectDirectory(projectPath, projectName) {
 		try {
-			await fs.mkdir(projectPath, { recursive: false });
-			print.success(`Created project directory: ${projectPath}`);
+			await fs$1.mkdir(projectPath, { recursive: false });
 		} catch (error) {
 			if (error.code === "EEXIST") throw new Error(`Directory '${projectName}' already exists. Please choose a different name.`);
 			throw error;
@@ -444,14 +502,12 @@ var NewProjectService = class {
 	* @param projectPath - Destination path for the cloned repository
 	*/
 	async cloneExistingRepository(repoUrl, projectPath) {
-		print.info("Cloning repository...");
 		try {
 			const parsed = parseGitHubUrl(repoUrl.trim());
 			if (parsed.isSubdirectory && parsed.branch && parsed.subdirectory) await cloneSubdirectory(parsed.repoUrl, parsed.branch, parsed.subdirectory, projectPath);
 			else await cloneRepository(parsed.repoUrl, projectPath);
-			print.success("Repository cloned successfully");
 		} catch (error) {
-			await fs.remove(projectPath);
+			await fs$1.remove(projectPath);
 			throw new Error(`Failed to clone repository: ${error.message}`);
 		}
 	}
@@ -460,10 +516,8 @@ var NewProjectService = class {
 	* @param projectPath - Path where git repository should be initialized
 	*/
 	async initializeGitRepository(projectPath) {
-		print.info("Initializing Git repository...");
 		try {
 			await gitInit(projectPath);
-			print.success("Git repository initialized");
 		} catch (error) {
 			messages.warning(`Failed to initialize Git: ${error.message}`);
 		}
@@ -480,6 +534,153 @@ var NewProjectService = class {
 	}
 };
 
+//#endregion
+//#region src/instructions/specs/openspec.md?raw
+var openspec_default = "When working on this project, follow the OpenSpec spec-driven development workflow{% if scaffoldMcp or architectMcp %} integrated with MCP tools{% endif %}.\n\n{% if scaffoldMcp %}\n\n## {% if scaffoldMcp %}1{% else %}1{% endif %}. Create Proposals with scaffold-mcp\n\nWhen implementing new features or changes, use scaffold-mcp MCP tools:\n\n**For new projects/features:**\n1. Use `list-boilerplates` MCP tool to see available templates\n2. Use `use-boilerplate` MCP tool to scaffold new projects{% if projectType == 'monolith' %} (set `monolith: true`){% elsif projectType == 'monorepo' %} (omit `monolith` parameter){% endif %}\n3. Use `list-scaffolding-methods` MCP tool to understand which methods can be used to add features\n4. Create OpenSpec proposal with available scaffolding methods in mind: \"Create an OpenSpec proposal for [feature description]\"\n\n**For adding features to existing code:**\n1. Use `list-scaffolding-methods` MCP tool with projectPath to see available features{% if projectType == 'monolith' %} (`projectPath` = workspace root){% elsif projectType == 'monorepo' %} (`projectPath` = project directory with project.json){% endif %}\n2. Review available methods and plan which ones to use for the feature\n3. Use `use-scaffold-method` MCP tool to generate boilerplate code\n4. Create OpenSpec proposal to capture the specs\n{% if projectType %}\n\n**Path Mapping ({% if projectType == 'monolith' %}Monolith{% else %}Monorepo{% endif %} Project):**\n{% if projectType == 'monolith' %}\n*This is a monolith project:*\n- Single project at workspace root\n- Config file: `toolkit.yaml` at root\n- All code in workspace root (src/, lib/, etc.)\n- When scaffolding: Use `monolith: true` parameter\n- When using scaffold methods: `projectPath` = workspace root\n\nExample: For workspace at `/path/to/project`:\n- Project config: `/path/to/project/toolkit.yaml`\n- Source code: `/path/to/project/src/`\n- OpenSpec: `/path/to/project/openspec/`\n{% else %}\n*This is a monorepo project:*\n- Multiple projects in subdirectories\n- Config file: `project.json` in each project\n- Projects in apps/, packages/, libs/, etc.\n- When scaffolding: Omit `monolith` parameter (defaults to false)\n- When using scaffold methods: `projectPath` = path to specific project\n\nExample: For workspace at `/path/to/workspace`:\n- App config: `/path/to/workspace/apps/my-app/project.json`\n- App source: `/path/to/workspace/apps/my-app/src/`\n- OpenSpec: `/path/to/workspace/openspec/` (workspace-level)\n{% endif %}\n{% endif %}\n\nAI will scaffold: openspec/changes/[feature-name]/ with proposal.md, tasks.md, and spec deltas\n{% endif %}\n{% if architectMcp %}\n\n## {% if scaffoldMcp %}2{% else %}1{% endif %}. Review & Validate with architect-mcp\n\nBefore and after editing files, use architect-mcp MCP tools:\n\n**Before editing:**\n- Use `get-file-design-pattern` MCP tool to understand:\n  - Applicable design patterns from architect.yaml\n  - Coding rules from RULES.yaml (must_do, should_do, must_not_do)\n  - Code examples showing the patterns\n\n**After editing:**\n- Use `review-code-change` MCP tool to check for:\n  - Must not do violations (critical issues)\n  - Must do missing (required patterns not followed)\n  - Should do suggestions (best practices)\n\n**Validate OpenSpec specs:**\n- Use `openspec validate [feature-name]` to check spec formatting\n- Iterate with AI until specs are agreed upon\n{% endif %}\n\n## {% if scaffoldMcp and architectMcp %}3{% elsif scaffoldMcp or architectMcp %}2{% else %}1{% endif %}. Implement{% if architectMcp %} with MCP-Guided Development{% endif %}\n\nDuring implementation:\n1. Ask AI to implement: \"Apply the OpenSpec change [feature-name]\"\n{% if architectMcp %}\n2. **Before each file edit**: Use `get-file-design-pattern` to understand patterns\n3. AI implements tasks from tasks.md following design patterns\n4. **After each file edit**: Use `review-code-change` to verify compliance\n5. Fix any violations before proceeding\n{% else %}\n2. AI implements tasks from tasks.md following the agreed specs\n{% endif %}\n\n## {% if scaffoldMcp and architectMcp %}4{% elsif scaffoldMcp or architectMcp %}3{% else %}2{% endif %}. Archive Completed Changes\n{% if scaffoldMcp or architectMcp %}\n\n## MCP Tools Reference\n{% endif %}\n{% if scaffoldMcp %}\n\n### scaffold-mcp\n- `list-boilerplates` - List available project templates\n- `use-boilerplate` - Create new project from template\n- `list-scaffolding-methods` - List features for existing project\n- `use-scaffold-method` - Add feature to existing project\n{% endif %}\n{% if architectMcp %}\n\n### architect-mcp\n- `get-file-design-pattern` - Get design patterns for file\n- `review-code-change` - Review code for violations\n{% endif %}\n\n## Workflow Summary\n\n{% if scaffoldMcp %}\n1. **Plan**: Use scaffold-mcp to generate boilerplate + OpenSpec proposal for specs\n{% else %}\n1. **Plan**: Create OpenSpec proposal with specs\n{% endif %}\n{% if architectMcp %}\n{% if scaffoldMcp %}2{% else %}2{% endif %}. **Design**: Use architect-mcp to understand patterns before editing\n{% endif %}\n{% if scaffoldMcp and architectMcp %}3{% elsif scaffoldMcp or architectMcp %}{% if architectMcp %}3{% else %}2{% endif %}{% else %}2{% endif %}. **Implement**: Follow specs{% if architectMcp %} and patterns{% endif %}\n{% if architectMcp %}\n{% if scaffoldMcp %}4{% else %}4{% endif %}. **Review**: Use architect-mcp to validate code quality\n{% endif %}\n{% if scaffoldMcp and architectMcp %}5{% elsif scaffoldMcp or architectMcp %}{% if architectMcp %}5{% else %}3{% endif %}{% else %}3{% endif %}. **Archive**: Merge specs into source of truth\n";
+
+//#endregion
+//#region src/specs/openspec.ts
+/**
+* OpenSpec configuration
+*/
+const OPENSPEC_CONFIG = {
+	folderName: "openspec",
+	packageName: "@fission-ai/openspec",
+	name: "OpenSpec",
+	description: "Spec-driven development for AI coding assistants"
+};
+/**
+* Bridge implementation for OpenSpec
+*
+* Provides integration with OpenSpec spec tool through a standardized interface.
+*/
+var OpenSpecBridge = class {
+	/**
+	* Check if OpenSpec is enabled/installed in the workspace
+	*
+	* @param workspaceRoot - Absolute path to the workspace root directory
+	* @returns Promise resolving to true if OpenSpec folder exists, false otherwise
+	*/
+	async isEnabled(workspaceRoot) {
+		try {
+			const openspecPath = path.join(workspaceRoot, OPENSPEC_CONFIG.folderName);
+			await fs.access(openspecPath);
+			return true;
+		} catch {
+			return false;
+		}
+	}
+	/**
+	* Initialize OpenSpec in the workspace
+	*
+	* Runs `npx @fission-ai/openspec init` interactively, allowing the user
+	* to configure OpenSpec during setup.
+	*
+	* @param workspaceRoot - Absolute path to the workspace root directory
+	* @throws Error if initialization fails
+	*/
+	async initialize(workspaceRoot) {
+		try {
+			await execa("npx", [OPENSPEC_CONFIG.packageName, "init"], {
+				cwd: workspaceRoot,
+				stdio: "inherit"
+			});
+		} catch (error) {
+			throw new Error(`Failed to initialize ${OPENSPEC_CONFIG.name}: ${error.message}`);
+		}
+	}
+	/**
+	* Generate agent instruction prompt for OpenSpec with MCP integration
+	*
+	* Creates a comprehensive instruction prompt that guides AI agents to use
+	* spec-driven development workflow with OpenSpec, leveraging enabled MCP servers.
+	*
+	* @param enabledMcps - Configuration of which MCP servers are enabled
+	* @returns Promise resolving to the instruction prompt string
+	*/
+	async updateInstruction(enabledMcps) {
+		return (await new Liquid().parseAndRender(openspec_default, enabledMcps)).trim();
+	}
+};
+
+//#endregion
+//#region src/services/SpecToolService.ts
+/**
+* Available spec tools
+*/
+let SpecTool = /* @__PURE__ */ function(SpecTool$1) {
+	SpecTool$1["OPENSPEC"] = "openspec";
+	return SpecTool$1;
+}({});
+/**
+* Spec tool information
+*/
+const SPEC_TOOL_INFO = { [SpecTool.OPENSPEC]: {
+	name: "OpenSpec",
+	description: "Spec-driven development for AI coding assistants",
+	docUrl: "https://github.com/Fission-AI/OpenSpec"
+} };
+/**
+* Service for managing spec tools (e.g., OpenSpec)
+*
+* This service acts as a facade for spec tool operations, using bridge
+* implementations to interact with specific spec tools.
+*/
+var SpecToolService = class {
+	bridge;
+	constructor(workspaceRoot, specTool = SpecTool.OPENSPEC, codingAgentService) {
+		this.workspaceRoot = workspaceRoot;
+		this.codingAgentService = codingAgentService;
+		this.bridge = this.createBridge(specTool);
+	}
+	/**
+	* Create a bridge instance for the specified spec tool
+	*/
+	createBridge(specTool) {
+		switch (specTool) {
+			case SpecTool.OPENSPEC: return new OpenSpecBridge();
+			default: throw new Error(`Unsupported spec tool: ${specTool}`);
+		}
+	}
+	/**
+	* Detect if a spec tool is installed in the workspace
+	*/
+	async detectSpecTool() {
+		try {
+			return await this.bridge.isEnabled(this.workspaceRoot) ? SpecTool.OPENSPEC : null;
+		} catch (error) {
+			print.error(`Error detecting spec tool: ${error.message}`);
+			return null;
+		}
+	}
+	/**
+	* Initialize the spec tool in the workspace
+	*/
+	async initializeSpec() {
+		await this.bridge.initialize(this.workspaceRoot);
+	}
+	/**
+	* Update spec tool agent instructions
+	*
+	* Generates instruction prompt and updates the coding agent's custom instructions
+	*
+	* @param enabledMcps - Configuration of which MCP servers are enabled
+	* @param codingAgent - The coding agent to update instructions for
+	* @param customInstructionFile - Optional custom file to write instructions to (e.g., '.claude/aicode-instructions.md')
+	* @returns Promise resolving to the instruction prompt string
+	*/
+	async updateInstructions(enabledMcps, codingAgent, customInstructionFile) {
+		const prompt = await this.bridge.updateInstruction(enabledMcps);
+		if (this.codingAgentService && codingAgent) await this.codingAgentService.updateCustomInstructions(codingAgent, prompt, customInstructionFile ?? ".claude/aicode-instructions.md");
+		else {
+			print.info("\nGenerated OpenSpec instruction prompt:");
+			print.info("\nYou can append this to your CLAUDE.md or agent config file:");
+			print.info(`\n${prompt}`);
+		}
+		return prompt;
+	}
+};
+
 //#endregion
 //#region src/services/TemplateSelectionService.ts
 var TemplateSelectionService = class {
@@ -493,9 +694,8 @@ var TemplateSelectionService = class {
 	* @returns Path to the tmp directory containing templates
 	*/
 	async downloadTemplatesToTmp(repoConfig) {
-		print.info(`Downloading templates from ${repoConfig.owner}/${repoConfig.repo}...`);
 		try {
-			await fs.ensureDir(this.tmpDir);
+			await fs$1.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");
@@ -514,7 +714,7 @@ var TemplateSelectionService = class {
 				const response = await fetch(rulesUrl);
 				if (response.ok) {
 					const content = await response.text();
-					await fs.writeFile(targetFile, content, "utf-8");
+					await fs$1.writeFile(targetFile, content, "utf-8");
 					print.success("Downloaded global RULES.yaml");
 				}
 			}
@@ -531,7 +731,7 @@ var TemplateSelectionService = class {
 	*/
 	async listTemplates() {
 		try {
-			const entries = await fs.readdir(this.tmpDir, { withFileTypes: true });
+			const entries = await fs$1.readdir(this.tmpDir, { withFileTypes: true });
 			const templates = [];
 			for (const entry of entries) if (entry.isDirectory()) {
 				const templatePath = path.join(this.tmpDir, entry.name);
@@ -557,27 +757,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.ensureDir(destinationPath);
+			await fs$1.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.pathExists(sourcePath)) throw new Error(`Template '${templateName}' not found in downloaded templates`);
-				if (await fs.pathExists(targetPath)) {
+				if (!await fs$1.pathExists(sourcePath)) throw new Error(`Template '${templateName}' not found in downloaded templates`);
+				if (await fs$1.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.copy(sourcePath, targetPath);
+				else await fs$1.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.pathExists(globalRulesSource)) {
-				if (!await fs.pathExists(globalRulesTarget)) {
+			if (await fs$1.pathExists(globalRulesSource)) {
+				if (!await fs$1.pathExists(globalRulesTarget)) {
 					print.info("Copying global RULES.yaml...");
-					await fs.copy(globalRulesSource, globalRulesTarget);
+					await fs$1.copy(globalRulesSource, globalRulesTarget);
 					print.success("Copied global RULES.yaml");
 				}
 			}
@@ -597,19 +797,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.ensureDir(targetPath);
-		const entries = await fs.readdir(sourcePath, { withFileTypes: true });
+		await fs$1.ensureDir(targetPath);
+		const entries = await fs$1.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.copy(entrySourcePath, entryTargetPath);
-			else await fs.copy(entrySourcePath, entryTargetPath);
+			if (hasArchitect && hasScaffold) if (entry.isDirectory()) await fs$1.copy(entrySourcePath, entryTargetPath);
+			else await fs$1.copy(entrySourcePath, entryTargetPath);
 			else if (hasArchitect && !hasScaffold) {
-				if (isArchitectFile) await fs.copy(entrySourcePath, entryTargetPath);
+				if (isArchitectFile) await fs$1.copy(entrySourcePath, entryTargetPath);
 			} else if (!hasArchitect && hasScaffold) {
-				if (!isArchitectFile) if (entry.isDirectory()) await fs.copy(entrySourcePath, entryTargetPath);
-				else await fs.copy(entrySourcePath, entryTargetPath);
+				if (!isArchitectFile) if (entry.isDirectory()) await fs$1.copy(entrySourcePath, entryTargetPath);
+				else await fs$1.copy(entrySourcePath, entryTargetPath);
 			}
 		}
 	}
@@ -621,15 +821,15 @@ var TemplateSelectionService = class {
 	async readTemplateDescription(templatePath) {
 		try {
 			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
-			if (await fs.pathExists(scaffoldYamlPath)) {
+			if (await fs$1.pathExists(scaffoldYamlPath)) {
 				const yaml = await import("js-yaml");
-				const content = await fs.readFile(scaffoldYamlPath, "utf-8");
+				const content = await fs$1.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.pathExists(readmePath)) return (await fs.readFile(readmePath, "utf-8")).split("\n\n")[0].substring(0, 200).trim();
+			if (await fs$1.pathExists(readmePath)) return (await fs$1.readFile(readmePath, "utf-8")).split("\n\n")[0].substring(0, 200).trim();
 			return;
 		} catch {
 			return;
@@ -646,10 +846,7 @@ var TemplateSelectionService = class {
 	*/
 	async cleanup() {
 		try {
-			if (await fs.pathExists(this.tmpDir)) {
-				await fs.remove(this.tmpDir);
-				print.info("Cleaned up temporary files");
-			}
+			if (await fs$1.pathExists(this.tmpDir)) await fs$1.remove(this.tmpDir);
 		} catch (error) {
 			print.warning(`Warning: Failed to clean up tmp directory: ${error.message}`);
 		}
@@ -673,19 +870,19 @@ var TemplatesService = class {
 				return;
 			}
 			print.info(`Found ${templateDirs.length} template(s)`);
-			let downloaded = 0;
-			let skipped = 0;
+			let _downloaded = 0;
+			let _skipped = 0;
 			for (const template of templateDirs) {
 				const targetFolder = path.join(templatesPath, template.name);
-				if (await fs.pathExists(targetFolder)) {
+				if (await fs$1.pathExists(targetFolder)) {
 					print.info(`Skipping ${template.name} (already exists)`);
-					skipped++;
+					_skipped++;
 					continue;
 				}
 				print.info(`Downloading ${template.name}...`);
 				await cloneSubdirectory(`https://github.com/${repoConfig.owner}/${repoConfig.repo}.git`, repoConfig.branch, template.path, targetFolder);
 				print.success(`Downloaded ${template.name}`);
-				downloaded++;
+				_downloaded++;
 			}
 			print.success("\nAll templates downloaded successfully!");
 		} catch (error) {
@@ -697,8 +894,8 @@ var TemplatesService = class {
 	* @param templatesPath - Path where templates folder should be created
 	*/
 	async initializeTemplatesFolder(templatesPath) {
-		await fs.ensureDir(templatesPath);
-		await fs.writeFile(path.join(templatesPath, "README.md"), `# Templates
+		await fs$1.ensureDir(templatesPath);
+		await fs$1.writeFile(path.join(templatesPath, "README.md"), `# Templates
 
 This folder contains boilerplate templates and scaffolding methods for your projects.
 
@@ -736,4 +933,4 @@ See existing templates for examples and documentation for more details.
 };
 
 //#endregion
-export { BANNER_GRADIENT, CodingAgentService, NewProjectService, THEME, TemplateSelectionService, TemplatesService, cloneRepository, cloneSubdirectory, displayBanner, displayCompactBanner, fetchGitHubDirectoryContents, findWorkspaceRoot, gitInit, parseGitHubUrl };
+export { BANNER_GRADIENT, CodingAgentService, NewProjectService, SPEC_TOOL_INFO, SpecTool, SpecToolService, THEME, TemplateSelectionService, TemplatesService, cloneRepository, cloneSubdirectory, displayBanner, displayCompactBanner, fetchGitHubDirectoryContents, findWorkspaceRoot, gitInit, parseGitHubUrl };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@agiflowai/aicode-toolkit",
   "description": "AI-powered code toolkit CLI for scaffolding, architecture management, and development workflows",
-  "version": "0.6.0",
+  "version": "1.0.1",
   "license": "AGPL-3.0",
   "author": "AgiflowIO",
   "repository": {
@@ -46,12 +46,13 @@
     "gradient-string": "^3.0.0",
     "js-yaml": "4.1.0",
     "liquidjs": "10.21.1",
+    "ora": "^9.0.0",
     "pino": "^10.0.0",
     "pino-pretty": "^13.1.1",
     "xstate": "^5.23.0",
     "zod": "3.25.76",
-    "@agiflowai/aicode-utils": "1.0.0",
-    "@agiflowai/coding-agent-bridge": "1.0.0"
+    "@agiflowai/coding-agent-bridge": "1.0.1",
+    "@agiflowai/aicode-utils": "1.0.1"
   },
   "devDependencies": {
     "@types/express": "^5.0.0",
@@ -59,7 +60,8 @@
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",
     "tsdown": "^0.15.6",
-    "typescript": "5.9.3"
+    "typescript": "5.9.3",
+    "unplugin-raw": "^0.6.3"
   },
   "publishConfig": {
     "access": "public"