@agiflowai/aicode-toolkit 0.6.0 → 1.0.2

package/dist/cli.js

@@ -1,17 +1,18 @@
 #!/usr/bin/env node
 import { MCPServer, MCP_SERVER_INFO } from "./mcp-BmhiAfeF.js";
-import { CodingAgentService, NewProjectService, TemplateSelectionService, cloneRepository, cloneSubdirectory, displayBanner, findWorkspaceRoot, parseGitHubUrl } from "./services-DNldrNnu.js";
+import { CodingAgentService, NewProjectService, SPEC_TOOL_INFO, SpecTool, SpecToolService, TemplateSelectionService, cloneRepository, cloneSubdirectory, displayBanner, findWorkspaceRoot, parseGitHubUrl } from "./services-zrdafWTg.js";
 import { Command } from "commander";
 import path from "node:path";
-import { ProjectType, TemplatesManagerService, icons, messages, print, sections } from "@agiflowai/aicode-utils";
+import { ProjectType, TemplatesManagerService, detectProjectType, icons, messages, print, sections } from "@agiflowai/aicode-utils";
 import * as fs from "fs-extra";
 import { confirm, input, select } from "@inquirer/prompts";
+import ora from "ora";
 import { assign, createActor, createMachine, fromPromise } from "xstate";
 
 //#region package.json
 var name = "@agiflowai/aicode-toolkit";
 var description = "AI-powered code toolkit CLI for scaffolding, architecture management, and development workflows";
-var version = "0.6.0";
+var version = "1.0.1";
 var license = "AGPL-3.0";
 var author = "AgiflowIO";
 var repository = {
@@ -57,6 +58,7 @@ var dependencies = {
 	"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",
@@ -68,7 +70,8 @@ var devDependencies = {
 	"@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"
 };
 var publishConfig = { "access": "public" };
 var type = "module";
@@ -180,7 +183,6 @@ const initMachine = createMachine({
 		projectType: void 0,
 		projectPath: void 0,
 		repositoryExists: false,
-		detectionConfidence: void 0,
 		detectionIndicators: void 0,
 		templatesPath: void 0,
 		tmpTemplatesPath: void 0,
@@ -188,6 +190,8 @@ const initMachine = createMachine({
 		selectedMcpServers: void 0,
 		detectedCodingAgent: void 0,
 		codingAgent: void 0,
+		detectedSpecTool: void 0,
+		useSpecDrivenApproach: void 0,
 		options: input$1.options,
 		error: void 0
 	}),
@@ -216,18 +220,14 @@ const initMachine = createMachine({
 			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
 			onDone: [{
 				target: "checkingSkipTemplates",
-				guard: ({ event }) => event.output.confidence === "high",
+				guard: ({ event }) => event.output.projectType !== void 0,
 				actions: assign({
 					projectType: ({ event }) => event.output.projectType,
-					detectionConfidence: ({ event }) => event.output.confidence,
 					detectionIndicators: ({ event }) => event.output.indicators
 				})
 			}, {
 				target: "promptingProjectType",
-				actions: assign({
-					detectionConfidence: ({ event }) => event.output.confidence,
-					detectionIndicators: ({ event }) => event.output.indicators
-				})
+				actions: assign({ detectionIndicators: ({ event }) => event.output.indicators })
 			}],
 			onError: {
 				target: "failed",
@@ -238,6 +238,7 @@ const initMachine = createMachine({
 			src: "promptProjectType",
 			input: ({ context }) => ({
 				providedProjectType: context.options.projectType,
+				detectedProjectType: context.projectType,
 				detectionIndicators: context.detectionIndicators
 			}),
 			onDone: {
@@ -309,7 +310,7 @@ const initMachine = createMachine({
 		promptingMcpSelection: { invoke: {
 			src: "promptMcpSelection",
 			onDone: {
-				target: "downloadingTemplates",
+				target: "checkingTemplatesFolder",
 				actions: assign({ selectedMcpServers: ({ event }) => event.output })
 			},
 			onError: {
@@ -317,6 +318,29 @@ const initMachine = createMachine({
 				actions: assign({ error: ({ event }) => event.error })
 			}
 		} },
+		checkingTemplatesFolder: { invoke: {
+			src: "checkTemplatesFolder",
+			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
+			onDone: [{
+				target: "creatingConfig",
+				guard: ({ event }) => event.output.skipDownload === true,
+				actions: assign({
+					templatesPath: ({ event }) => event.output.templatesPath,
+					skipDownload: ({ event }) => event.output.skipDownload,
+					selectedTemplates: ({ event }) => event.output.existingTemplates
+				})
+			}, {
+				target: "downloadingTemplates",
+				actions: assign({
+					templatesPath: ({ event }) => event.output.templatesPath,
+					skipDownload: ({ event }) => event.output.skipDownload
+				})
+			}],
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
 		downloadingTemplates: { invoke: {
 			src: "downloadTemplates",
 			onDone: {
@@ -357,14 +381,12 @@ const initMachine = createMachine({
 			input: ({ context }) => ({
 				tmpTemplatesPath: context.tmpTemplatesPath,
 				workspaceRoot: context.workspaceRoot,
+				templatesPath: context.templatesPath,
 				selectedTemplates: context.selectedTemplates,
 				projectType: context.projectType,
 				selectedMcpServers: context.selectedMcpServers
 			}),
-			onDone: {
-				target: "creatingConfig",
-				actions: assign({ templatesPath: ({ event }) => event.output })
-			},
+			onDone: { target: "creatingConfig" },
 			onError: {
 				target: "failed",
 				actions: assign({ error: ({ event }) => event.error })
@@ -375,6 +397,7 @@ const initMachine = createMachine({
 			input: ({ context }) => ({
 				workspaceRoot: context.workspaceRoot,
 				projectType: context.projectType,
+				templatesPath: context.templatesPath,
 				selectedTemplates: context.selectedTemplates
 			}),
 			onDone: { target: "checkingSkipMcp" },
@@ -386,7 +409,7 @@ const initMachine = createMachine({
 		checkingSkipMcp: { always: [{
 			target: "detectingCodingAgent",
 			guard: ({ context }) => !context.options.skipMcp
-		}, { target: "cleaningUp" }] },
+		}, { target: "detectingSpecTool" }] },
 		detectingCodingAgent: { invoke: {
 			src: "detectCodingAgent",
 			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
@@ -417,6 +440,66 @@ const initMachine = createMachine({
 				workspaceRoot: context.workspaceRoot,
 				codingAgent: context.codingAgent
 			}),
+			onDone: { target: "detectingSpecTool" },
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		detectingSpecTool: { invoke: {
+			src: "detectSpecTool",
+			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
+			onDone: {
+				target: "promptingSpecDrivenApproach",
+				actions: assign({ detectedSpecTool: ({ event }) => event.output })
+			},
+			onError: { target: "cleaningUp" }
+		} },
+		promptingSpecDrivenApproach: { invoke: {
+			src: "promptSpecDrivenApproach",
+			input: ({ context }) => ({ detectedSpecTool: context.detectedSpecTool }),
+			onDone: [{
+				target: "settingUpSpec",
+				guard: ({ event }) => event.output === true,
+				actions: assign({ useSpecDrivenApproach: () => true })
+			}, {
+				target: "cleaningUp",
+				actions: assign({ useSpecDrivenApproach: () => false })
+			}],
+			onError: { target: "cleaningUp" }
+		} },
+		settingUpSpec: { invoke: {
+			src: "setupSpec",
+			input: ({ context }) => ({
+				workspaceRoot: context.workspaceRoot,
+				isAlreadyInstalled: context.detectedSpecTool !== null,
+				selectedMcpServers: context.selectedMcpServers,
+				codingAgent: context.codingAgent
+			}),
+			onDone: [{
+				target: "promptingSpecInstructions",
+				guard: ({ context }) => context.detectedSpecTool === null
+			}, { target: "cleaningUp" }],
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		promptingSpecInstructions: { invoke: {
+			src: "promptSpecInstructions",
+			onDone: [{
+				target: "updatingSpecInstructions",
+				guard: ({ event }) => event.output === true
+			}, { target: "cleaningUp" }],
+			onError: { target: "cleaningUp" }
+		} },
+		updatingSpecInstructions: { invoke: {
+			src: "updateSpecInstructions",
+			input: ({ context }) => ({
+				workspaceRoot: context.workspaceRoot,
+				selectedMcpServers: context.selectedMcpServers,
+				codingAgent: context.codingAgent
+			}),
 			onDone: { target: "cleaningUp" },
 			onError: {
 				target: "failed",
@@ -452,6 +535,7 @@ const initActors = {
 	checkWorkspaceExists: fromPromise(async () => {
 		const workspaceRoot = await findWorkspaceRoot();
 		if (workspaceRoot) {
+			print.divider();
 			print.info(`Found workspace at: ${workspaceRoot}`);
 			return {
 				exists: true,
@@ -461,62 +545,11 @@ const initActors = {
 		return { exists: false };
 	}),
 	detectProjectType: fromPromise(async ({ input: input$1 }) => {
-		print.info("\nDetecting project type...");
-		const nxJsonPath = path.join(input$1.workspaceRoot, "nx.json");
-		const lernaJsonPath = path.join(input$1.workspaceRoot, "lerna.json");
-		const pnpmWorkspacePath = path.join(input$1.workspaceRoot, "pnpm-workspace.yaml");
-		const turboJsonPath = path.join(input$1.workspaceRoot, "turbo.json");
-		const indicators = [];
-		let projectType;
-		let confidence = "low";
-		if (await fs.pathExists(nxJsonPath)) {
-			indicators.push("nx.json found");
-			projectType = ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		if (await fs.pathExists(lernaJsonPath)) {
-			indicators.push("lerna.json found");
-			projectType = ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		if (await fs.pathExists(pnpmWorkspacePath)) {
-			indicators.push("pnpm-workspace.yaml found");
-			projectType = ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		if (await fs.pathExists(turboJsonPath)) {
-			indicators.push("turbo.json found");
-			projectType = ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		const packageJsonPath = path.join(input$1.workspaceRoot, "package.json");
-		if (await fs.pathExists(packageJsonPath)) {
-			if ((await fs.readJson(packageJsonPath)).workspaces) {
-				indicators.push("package.json with workspaces found");
-				projectType = ProjectType.MONOREPO;
-				if (confidence !== "high") confidence = "medium";
-			}
-		}
-		const toolkitYamlPath = path.join(input$1.workspaceRoot, "toolkit.yaml");
-		if (await fs.pathExists(toolkitYamlPath)) {
-			const toolkitConfig = await TemplatesManagerService.readToolkitConfig(input$1.workspaceRoot);
-			if (toolkitConfig?.projectType) {
-				indicators.push(`toolkit.yaml specifies ${toolkitConfig.projectType}`);
-				projectType = toolkitConfig.projectType;
-				confidence = "high";
-			}
-		}
-		if (!projectType) {
-			projectType = ProjectType.MONOLITH;
-			indicators.push("No monorepo indicators found, assuming monolith");
-			confidence = "low";
-		}
-		if (confidence === "high") print.success(`Detected ${projectType} project (high confidence)`);
-		return {
-			projectType,
-			confidence,
-			indicators
-		};
+		print.divider();
+		print.info("Detecting project type...");
+		const result = await detectProjectType(input$1.workspaceRoot);
+		if (result.projectType) print.success(`Detected ${result.projectType} project`);
+		return result;
 	}),
 	promptProjectType: fromPromise(async ({ input: actorInput }) => {
 		if (actorInput.providedProjectType) {
@@ -524,23 +557,30 @@ const initActors = {
 			print.info(`Project type: ${projectType}`);
 			return projectType;
 		}
+		if (actorInput.detectedProjectType) {
+			print.info(`Using detected project type: ${actorInput.detectedProjectType}`);
+			return actorInput.detectedProjectType;
+		}
 		if (actorInput.detectionIndicators && actorInput.detectionIndicators.length > 0) {
 			print.info("\nDetection results:");
 			for (const indicator of actorInput.detectionIndicators) print.indent(`• ${indicator}`);
 			print.newline();
 		}
-		return await select({
+		print.divider();
+		const result = await select({
 			message: "Select project type:",
 			choices: [{
-				name: "Monolith - Single application structure",
+				name: "Monolith – Single application structure",
 				value: ProjectType.MONOLITH,
-				description: "Traditional single-application project structure"
+				description: "\n  Traditional single-application project structure"
 			}, {
-				name: "Monorepo - Multiple packages/apps in one repository",
+				name: "Monorepo – Multiple packages/apps in one repository",
 				value: ProjectType.MONOREPO,
-				description: "Multiple packages managed together (uses workspaces)"
+				description: "\n  Multiple packages managed together (uses workspaces)"
 			}]
 		});
+		print.info("");
+		return result;
 	}),
 	promptProjectName: fromPromise(async ({ input: actorInput }) => {
 		const newProjectService = new NewProjectService(actorInput.providedName, void 0);
@@ -552,49 +592,171 @@ const initActors = {
 			print.info(`Project name: ${trimmedName}`);
 			return trimmedName;
 		}
-		return await input({
-			message: "Enter your project name:",
-			validate: (value) => newProjectService.validateProjectName(value)
+		print.divider();
+		const result = await input({
+			message: "Enter your project name (press Enter to use current directory):",
+			validate: (value) => {
+				if (!value || value.trim() === "") return true;
+				return newProjectService.validateProjectName(value);
+			}
 		});
+		print.info("");
+		if (!result || result.trim() === "") return ".";
+		return result;
 	}),
 	createProjectDirectory: fromPromise(async ({ input: actorInput }) => {
-		const projectPath = path.join(process.cwd(), actorInput.projectName.trim());
-		await new NewProjectService(void 0, void 0).createProjectDirectory(projectPath, actorInput.projectName);
-		return { projectPath };
+		if (actorInput.projectName === ".") {
+			const projectPath = process.cwd();
+			print.success(`Using current directory: ${projectPath}`);
+			return { projectPath };
+		}
+		const spinner = ora("Creating project directory...").start();
+		try {
+			const projectPath = path.join(process.cwd(), actorInput.projectName.trim());
+			await new NewProjectService(void 0, void 0).createProjectDirectory(projectPath, actorInput.projectName);
+			spinner.succeed(`Created project directory: ${projectPath}`);
+			return { projectPath };
+		} catch (error) {
+			spinner.fail("Failed to create project directory");
+			throw error;
+		}
 	}),
 	promptGitSetup: fromPromise(async ({ input: actorInput }) => {
 		const newProjectService = new NewProjectService(void 0, void 0);
-		if (await confirm({
+		print.divider();
+		const hasExistingRepo = await confirm({
 			message: "Do you have an existing Git repository you want to use?",
 			default: false
-		})) {
+		});
+		print.info("");
+		if (hasExistingRepo) {
+			print.divider();
 			const repoUrl = await input({
-				message: "Enter Git repository URL:",
-				validate: (value) => newProjectService.validateRepositoryUrl(value)
+				message: "Enter Git repository URL (press Enter to skip):",
+				validate: (value) => {
+					if (!value || value.trim() === "") return true;
+					return newProjectService.validateRepositoryUrl(value);
+				}
 			});
-			await newProjectService.cloneExistingRepository(repoUrl.trim(), actorInput.projectPath);
-		} else if (await confirm({
-			message: "Initialize a new Git repository?",
-			default: true
-		})) await newProjectService.initializeGitRepository(actorInput.projectPath);
+			print.info("");
+			if (repoUrl && repoUrl.trim() !== "") {
+				const spinner = ora("Cloning repository...").start();
+				try {
+					await newProjectService.cloneExistingRepository(repoUrl.trim(), actorInput.projectPath);
+					spinner.succeed("Repository cloned successfully");
+				} catch (error) {
+					spinner.fail("Failed to clone repository");
+					throw error;
+				}
+			} else print.info("Skipped cloning repository");
+		} else {
+			print.divider();
+			const initGit = await confirm({
+				message: "Initialize a new Git repository?",
+				default: true
+			});
+			print.info("");
+			if (initGit) {
+				const spinner = ora("Initializing Git repository...").start();
+				try {
+					await newProjectService.initializeGitRepository(actorInput.projectPath);
+					spinner.succeed("Git repository initialized");
+				} catch (error) {
+					spinner.fail("Failed to initialize Git repository");
+					throw error;
+				}
+			}
+		}
 	}),
 	promptMcpSelection: fromPromise(async () => {
-		return await (await import("@inquirer/prompts").then((m) => m.checkbox))({
+		const checkbox = await import("@inquirer/prompts").then((m) => m.checkbox);
+		const choices = Object.values(MCPServer).map((server) => ({
+			name: MCP_SERVER_INFO[server].name,
+			value: server,
+			description: `\n  ${MCP_SERVER_INFO[server].description}`,
+			checked: true
+		}));
+		print.divider();
+		const selected = await checkbox({
 			message: "Select MCP servers to configure:",
-			choices: Object.values(MCPServer).map((server) => ({
-				name: MCP_SERVER_INFO[server].name,
-				value: server,
-				description: MCP_SERVER_INFO[server].description,
-				checked: true
-			})),
+			choices,
 			validate: (answer) => {
 				if (answer.length === 0) return "Please select at least one MCP server";
 				return true;
 			}
 		});
+		print.info("");
+		return selected;
+	}),
+	checkTemplatesFolder: fromPromise(async ({ input: actorInput }) => {
+		try {
+			const fs$1 = await import("node:fs/promises");
+			const defaultTemplatesPath = path.join(actorInput.workspaceRoot, "templates");
+			let templatesExists = false;
+			try {
+				await fs$1.access(defaultTemplatesPath);
+				templatesExists = true;
+			} catch {
+				templatesExists = false;
+			}
+			let finalTemplatesPath = defaultTemplatesPath;
+			let skipDownload = false;
+			if (templatesExists) {
+				print.divider();
+				print.info(`Templates folder already exists at: ${defaultTemplatesPath}`);
+				const useDifferentDir = await confirm({
+					message: "Would you like to use a different directory for templates?",
+					default: false
+				});
+				print.info("");
+				if (useDifferentDir) {
+					print.divider();
+					const customDir = await input({
+						message: "Enter custom templates directory path (relative to workspace root):",
+						default: "templates",
+						validate: (value) => {
+							if (!value || value.trim() === "") return "Please enter a valid directory path";
+							return true;
+						}
+					});
+					print.info("");
+					finalTemplatesPath = path.join(actorInput.workspaceRoot, customDir.trim());
+					try {
+						await fs$1.mkdir(finalTemplatesPath, { recursive: true });
+						print.success(`Created templates directory at: ${finalTemplatesPath}`);
+					} catch (error) {
+						throw new Error(`Failed to create templates directory at ${finalTemplatesPath}: ${error.message}`);
+					}
+				} else {
+					skipDownload = true;
+					print.info("Using existing templates folder");
+				}
+			}
+			let existingTemplates;
+			if (skipDownload) try {
+				existingTemplates = (await new TemplateSelectionService(finalTemplatesPath).listTemplates()).map((t) => t.name);
+			} catch (_error) {
+				print.warning("Could not read existing templates, will proceed anyway");
+			}
+			return {
+				templatesPath: finalTemplatesPath,
+				skipDownload,
+				existingTemplates
+			};
+		} catch (error) {
+			throw new Error(`Failed to check templates folder: ${error.message}`);
+		}
 	}),
 	downloadTemplates: fromPromise(async () => {
-		return await new TemplateSelectionService().downloadTemplatesToTmp(DEFAULT_TEMPLATE_REPO);
+		const spinner = ora("Downloading templates from AgiFlow/aicode-toolkit...").start();
+		try {
+			const tmpPath = await new TemplateSelectionService().downloadTemplatesToTmp(DEFAULT_TEMPLATE_REPO);
+			spinner.succeed("Templates downloaded successfully");
+			return tmpPath;
+		} catch (error) {
+			spinner.fail("Failed to download templates");
+			throw error;
+		}
 	}),
 	listTemplates: fromPromise(async ({ input: input$1 }) => {
 		const templates = await new TemplateSelectionService(input$1.tmpTemplatesPath).listTemplates();
@@ -605,37 +767,52 @@ const initActors = {
 	promptTemplateSelection: fromPromise(async ({ input: actorInput }) => {
 		const templates = await new TemplateSelectionService(actorInput.tmpTemplatesPath).listTemplates();
 		if (templates.length === 0) throw new Error("No templates available");
-		if (actorInput.projectType === ProjectType.MONOLITH) return [await select({
-			message: "Select template (monolith allows only one):",
-			choices: templates.map((t) => ({
+		if (actorInput.projectType === ProjectType.MONOLITH) {
+			const choices$1 = templates.map((t) => ({
 				name: t.name,
 				value: t.name,
-				description: t.description
-			}))
-		})];
-		const selected = await (await import("@inquirer/prompts").then((m) => m.checkbox))({
+				description: t.description ? `\n  ${t.description}` : void 0
+			}));
+			print.divider();
+			const selected$1 = await select({
+				message: "Select template (monolith allows only one):",
+				choices: choices$1
+			});
+			print.info("");
+			return [selected$1];
+		}
+		const checkbox = await import("@inquirer/prompts").then((m) => m.checkbox);
+		const choices = templates.map((t) => ({
+			name: t.name,
+			value: t.name,
+			description: t.description ? `\n  ${t.description}` : void 0,
+			checked: true
+		}));
+		print.divider();
+		const selected = await checkbox({
 			message: "Select templates (use space to select, enter to confirm):",
-			choices: templates.map((t) => ({
-				name: t.name,
-				value: t.name,
-				description: t.description,
-				checked: true
-			}))
+			choices
 		});
+		print.info("");
 		if (selected.length === 0) throw new Error("Please select at least one template");
 		return selected;
 	}),
 	copyTemplates: fromPromise(async ({ input: actorInput }) => {
-		const templateSelectionService = new TemplateSelectionService(actorInput.tmpTemplatesPath);
-		const templatesPath = path.join(actorInput.workspaceRoot, "templates");
-		await templateSelectionService.copyTemplates(actorInput.selectedTemplates, templatesPath, actorInput.projectType, actorInput.selectedMcpServers);
-		return templatesPath;
+		const spinner = ora("Copying templates to workspace...").start();
+		try {
+			await new TemplateSelectionService(actorInput.tmpTemplatesPath).copyTemplates(actorInput.selectedTemplates, actorInput.templatesPath, actorInput.projectType, actorInput.selectedMcpServers);
+			spinner.succeed(`Templates copied to ${actorInput.templatesPath}`);
+			return actorInput.templatesPath;
+		} catch (error) {
+			spinner.fail("Failed to copy templates");
+			throw error;
+		}
 	}),
 	createConfig: fromPromise(async ({ input: actorInput }) => {
 		if (actorInput.projectType === ProjectType.MONOLITH) {
 			const toolkitConfig = {
 				version: "1.0",
-				templatesPath: "templates",
+				templatesPath: path.relative(actorInput.workspaceRoot, actorInput.templatesPath) || "templates",
 				projectType: "monolith",
 				sourceTemplate: actorInput.selectedTemplates[0]
 			};
@@ -656,20 +833,120 @@ const initActors = {
 			print.info(`Using detected coding agent: ${actorInput.detectedAgent}`);
 			return actorInput.detectedAgent;
 		}
-		return await select({
+		const agents = CodingAgentService.getAvailableAgents();
+		print.divider();
+		const selected = await select({
 			message: "Select coding agent for MCP configuration:",
-			choices: CodingAgentService.getAvailableAgents().map((agent) => ({
+			choices: agents.map((agent) => ({
 				name: agent.name,
 				value: agent.value,
-				description: agent.description
+				description: `\n  ${agent.description}`
 			}))
 		});
+		print.info("");
+		return selected;
 	}),
 	configureMCP: fromPromise(async ({ input: actorInput }) => {
-		await new CodingAgentService(actorInput.workspaceRoot).setupMCP(actorInput.codingAgent);
+		const spinner = ora(`Setting up MCP for ${actorInput.codingAgent}...`).start();
+		try {
+			await new CodingAgentService(actorInput.workspaceRoot).setupMCP(actorInput.codingAgent);
+			spinner.succeed("MCP configuration completed");
+		} catch (error) {
+			spinner.fail("Failed to configure MCP");
+			throw error;
+		}
 	}),
 	cleanup: fromPromise(async ({ input: input$1 }) => {
-		if (input$1.tmpTemplatesPath) await new TemplateSelectionService(input$1.tmpTemplatesPath).cleanup();
+		if (input$1.tmpTemplatesPath) {
+			const spinner = ora("Cleaning up temporary files...").start();
+			try {
+				await new TemplateSelectionService(input$1.tmpTemplatesPath).cleanup();
+				spinner.succeed("Cleaned up temporary files");
+			} catch (_error) {
+				spinner.warn("Could not clean up all temporary files");
+			}
+		}
+	}),
+	detectSpecTool: fromPromise(async ({ input: input$1 }) => {
+		print.info("\nDetecting spec tools...");
+		const detectedTool = await new SpecToolService(input$1.workspaceRoot).detectSpecTool();
+		if (detectedTool) print.success(`Detected ${SPEC_TOOL_INFO[detectedTool].name} in workspace`);
+		else print.info("No spec tool detected");
+		return detectedTool;
+	}),
+	promptSpecDrivenApproach: fromPromise(async ({ input: actorInput }) => {
+		if (actorInput.detectedSpecTool) {
+			print.divider();
+			const result$1 = await confirm({
+				message: `${SPEC_TOOL_INFO[actorInput.detectedSpecTool].name} is installed. Would you like to update the agent instructions for spec-driven development?`,
+				default: true
+			});
+			print.info("");
+			return result$1;
+		}
+		print.divider();
+		const result = await confirm({
+			message: "Would you like to install OpenSpec for spec-driven development? This helps AI assistants agree on what to build before writing code.",
+			default: false
+		});
+		print.info("");
+		return result;
+	}),
+	setupSpec: fromPromise(async ({ input: input$1 }) => {
+		const codingAgentService = new CodingAgentService(input$1.workspaceRoot);
+		const specToolService = new SpecToolService(input$1.workspaceRoot, SpecTool.OPENSPEC, codingAgentService);
+		if (input$1.isAlreadyInstalled) {
+			const spinner = ora("Updating OpenSpec agent instructions...").start();
+			try {
+				const enabledMcps = {
+					scaffoldMcp: input$1.selectedMcpServers?.includes(MCPServer.SCAFFOLD) ?? false,
+					architectMcp: input$1.selectedMcpServers?.includes(MCPServer.ARCHITECT) ?? false,
+					projectType: input$1.projectType
+				};
+				await specToolService.updateInstructions(enabledMcps, input$1.codingAgent);
+				spinner.succeed("OpenSpec agent instructions updated");
+			} catch (error) {
+				spinner.fail("Failed to update OpenSpec instructions");
+				throw error;
+			}
+		} else {
+			const spinner = ora("Initializing OpenSpec...").start();
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+			spinner.stop();
+			try {
+				await specToolService.initializeSpec();
+				print.success("OpenSpec initialized successfully");
+			} catch (error) {
+				print.error("Failed to initialize OpenSpec");
+				throw error;
+			}
+		}
+	}),
+	promptSpecInstructions: fromPromise(async () => {
+		print.divider();
+		const result = await confirm({
+			message: "Would you like to update the agent instructions with OpenSpec workflow guidance?",
+			default: true
+		});
+		print.info("");
+		return result;
+	}),
+	updateSpecInstructions: fromPromise(async ({ input: input$1 }) => {
+		const spinner = ora("Updating OpenSpec agent instructions...").start();
+		try {
+			const codingAgentService = new CodingAgentService(input$1.workspaceRoot);
+			const specToolService = new SpecToolService(input$1.workspaceRoot, SpecTool.OPENSPEC, codingAgentService);
+			const enabledMcps = {
+				scaffoldMcp: input$1.selectedMcpServers?.includes(MCPServer.SCAFFOLD) ?? false,
+				architectMcp: input$1.selectedMcpServers?.includes(MCPServer.ARCHITECT) ?? false,
+				projectType: input$1.projectType
+			};
+			await specToolService.updateInstructions(enabledMcps, input$1.codingAgent);
+			spinner.succeed("OpenSpec agent instructions updated");
+		} catch (error) {
+			spinner.fail("Failed to update OpenSpec instructions");
+			throw error;
+		}
 	})
 };
 /**