@agiflowai/aicode-toolkit 0.6.0 → 1.0.2

package/dist/cli.cjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-const require_services = require('./services-s1vmufE4.cjs');
+const require_services = require('./services-C6lqyioO.cjs');
 const require_mcp = require('./mcp-Dwt8nYQV.cjs');
 let commander = require("commander");
 commander = require_services.__toESM(commander);
@@ -11,13 +11,15 @@ let fs_extra = require("fs-extra");
 fs_extra = require_services.__toESM(fs_extra);
 let __inquirer_prompts = require("@inquirer/prompts");
 __inquirer_prompts = require_services.__toESM(__inquirer_prompts);
+let ora = require("ora");
+ora = require_services.__toESM(ora);
 let xstate = require("xstate");
 xstate = require_services.__toESM(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 = {
@@ -63,6 +65,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",
@@ -74,7 +77,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";
@@ -186,7 +190,6 @@ const initMachine = (0, xstate.createMachine)({
 		projectType: void 0,
 		projectPath: void 0,
 		repositoryExists: false,
-		detectionConfidence: void 0,
 		detectionIndicators: void 0,
 		templatesPath: void 0,
 		tmpTemplatesPath: void 0,
@@ -194,6 +197,8 @@ const initMachine = (0, xstate.createMachine)({
 		selectedMcpServers: void 0,
 		detectedCodingAgent: void 0,
 		codingAgent: void 0,
+		detectedSpecTool: void 0,
+		useSpecDrivenApproach: void 0,
 		options: input$1.options,
 		error: void 0
 	}),
@@ -222,18 +227,14 @@ const initMachine = (0, xstate.createMachine)({
 			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
 			onDone: [{
 				target: "checkingSkipTemplates",
-				guard: ({ event }) => event.output.confidence === "high",
+				guard: ({ event }) => event.output.projectType !== void 0,
 				actions: (0, xstate.assign)({
 					projectType: ({ event }) => event.output.projectType,
-					detectionConfidence: ({ event }) => event.output.confidence,
 					detectionIndicators: ({ event }) => event.output.indicators
 				})
 			}, {
 				target: "promptingProjectType",
-				actions: (0, xstate.assign)({
-					detectionConfidence: ({ event }) => event.output.confidence,
-					detectionIndicators: ({ event }) => event.output.indicators
-				})
+				actions: (0, xstate.assign)({ detectionIndicators: ({ event }) => event.output.indicators })
 			}],
 			onError: {
 				target: "failed",
@@ -244,6 +245,7 @@ const initMachine = (0, xstate.createMachine)({
 			src: "promptProjectType",
 			input: ({ context }) => ({
 				providedProjectType: context.options.projectType,
+				detectedProjectType: context.projectType,
 				detectionIndicators: context.detectionIndicators
 			}),
 			onDone: {
@@ -315,7 +317,7 @@ const initMachine = (0, xstate.createMachine)({
 		promptingMcpSelection: { invoke: {
 			src: "promptMcpSelection",
 			onDone: {
-				target: "downloadingTemplates",
+				target: "checkingTemplatesFolder",
 				actions: (0, xstate.assign)({ selectedMcpServers: ({ event }) => event.output })
 			},
 			onError: {
@@ -323,6 +325,29 @@ const initMachine = (0, xstate.createMachine)({
 				actions: (0, xstate.assign)({ error: ({ event }) => event.error })
 			}
 		} },
+		checkingTemplatesFolder: { invoke: {
+			src: "checkTemplatesFolder",
+			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
+			onDone: [{
+				target: "creatingConfig",
+				guard: ({ event }) => event.output.skipDownload === true,
+				actions: (0, xstate.assign)({
+					templatesPath: ({ event }) => event.output.templatesPath,
+					skipDownload: ({ event }) => event.output.skipDownload,
+					selectedTemplates: ({ event }) => event.output.existingTemplates
+				})
+			}, {
+				target: "downloadingTemplates",
+				actions: (0, xstate.assign)({
+					templatesPath: ({ event }) => event.output.templatesPath,
+					skipDownload: ({ event }) => event.output.skipDownload
+				})
+			}],
+			onError: {
+				target: "failed",
+				actions: (0, xstate.assign)({ error: ({ event }) => event.error })
+			}
+		} },
 		downloadingTemplates: { invoke: {
 			src: "downloadTemplates",
 			onDone: {
@@ -363,14 +388,12 @@ const initMachine = (0, xstate.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: (0, xstate.assign)({ templatesPath: ({ event }) => event.output })
-			},
+			onDone: { target: "creatingConfig" },
 			onError: {
 				target: "failed",
 				actions: (0, xstate.assign)({ error: ({ event }) => event.error })
@@ -381,6 +404,7 @@ const initMachine = (0, xstate.createMachine)({
 			input: ({ context }) => ({
 				workspaceRoot: context.workspaceRoot,
 				projectType: context.projectType,
+				templatesPath: context.templatesPath,
 				selectedTemplates: context.selectedTemplates
 			}),
 			onDone: { target: "checkingSkipMcp" },
@@ -392,7 +416,7 @@ const initMachine = (0, xstate.createMachine)({
 		checkingSkipMcp: { always: [{
 			target: "detectingCodingAgent",
 			guard: ({ context }) => !context.options.skipMcp
-		}, { target: "cleaningUp" }] },
+		}, { target: "detectingSpecTool" }] },
 		detectingCodingAgent: { invoke: {
 			src: "detectCodingAgent",
 			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
@@ -423,6 +447,66 @@ const initMachine = (0, xstate.createMachine)({
 				workspaceRoot: context.workspaceRoot,
 				codingAgent: context.codingAgent
 			}),
+			onDone: { target: "detectingSpecTool" },
+			onError: {
+				target: "failed",
+				actions: (0, xstate.assign)({ error: ({ event }) => event.error })
+			}
+		} },
+		detectingSpecTool: { invoke: {
+			src: "detectSpecTool",
+			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
+			onDone: {
+				target: "promptingSpecDrivenApproach",
+				actions: (0, xstate.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: (0, xstate.assign)({ useSpecDrivenApproach: () => true })
+			}, {
+				target: "cleaningUp",
+				actions: (0, xstate.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: (0, xstate.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",
@@ -458,6 +542,7 @@ const initActors = {
 	checkWorkspaceExists: (0, xstate.fromPromise)(async () => {
 		const workspaceRoot = await require_services.findWorkspaceRoot();
 		if (workspaceRoot) {
+			__agiflowai_aicode_utils.print.divider();
 			__agiflowai_aicode_utils.print.info(`Found workspace at: ${workspaceRoot}`);
 			return {
 				exists: true,
@@ -467,62 +552,11 @@ const initActors = {
 		return { exists: false };
 	}),
 	detectProjectType: (0, xstate.fromPromise)(async ({ input: input$1 }) => {
-		__agiflowai_aicode_utils.print.info("\nDetecting project type...");
-		const nxJsonPath = node_path.default.join(input$1.workspaceRoot, "nx.json");
-		const lernaJsonPath = node_path.default.join(input$1.workspaceRoot, "lerna.json");
-		const pnpmWorkspacePath = node_path.default.join(input$1.workspaceRoot, "pnpm-workspace.yaml");
-		const turboJsonPath = node_path.default.join(input$1.workspaceRoot, "turbo.json");
-		const indicators = [];
-		let projectType;
-		let confidence = "low";
-		if (await fs_extra.pathExists(nxJsonPath)) {
-			indicators.push("nx.json found");
-			projectType = __agiflowai_aicode_utils.ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		if (await fs_extra.pathExists(lernaJsonPath)) {
-			indicators.push("lerna.json found");
-			projectType = __agiflowai_aicode_utils.ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		if (await fs_extra.pathExists(pnpmWorkspacePath)) {
-			indicators.push("pnpm-workspace.yaml found");
-			projectType = __agiflowai_aicode_utils.ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		if (await fs_extra.pathExists(turboJsonPath)) {
-			indicators.push("turbo.json found");
-			projectType = __agiflowai_aicode_utils.ProjectType.MONOREPO;
-			confidence = "high";
-		}
-		const packageJsonPath = node_path.default.join(input$1.workspaceRoot, "package.json");
-		if (await fs_extra.pathExists(packageJsonPath)) {
-			if ((await fs_extra.readJson(packageJsonPath)).workspaces) {
-				indicators.push("package.json with workspaces found");
-				projectType = __agiflowai_aicode_utils.ProjectType.MONOREPO;
-				if (confidence !== "high") confidence = "medium";
-			}
-		}
-		const toolkitYamlPath = node_path.default.join(input$1.workspaceRoot, "toolkit.yaml");
-		if (await fs_extra.pathExists(toolkitYamlPath)) {
-			const toolkitConfig = await __agiflowai_aicode_utils.TemplatesManagerService.readToolkitConfig(input$1.workspaceRoot);
-			if (toolkitConfig?.projectType) {
-				indicators.push(`toolkit.yaml specifies ${toolkitConfig.projectType}`);
-				projectType = toolkitConfig.projectType;
-				confidence = "high";
-			}
-		}
-		if (!projectType) {
-			projectType = __agiflowai_aicode_utils.ProjectType.MONOLITH;
-			indicators.push("No monorepo indicators found, assuming monolith");
-			confidence = "low";
-		}
-		if (confidence === "high") __agiflowai_aicode_utils.print.success(`Detected ${projectType} project (high confidence)`);
-		return {
-			projectType,
-			confidence,
-			indicators
-		};
+		__agiflowai_aicode_utils.print.divider();
+		__agiflowai_aicode_utils.print.info("Detecting project type...");
+		const result = await (0, __agiflowai_aicode_utils.detectProjectType)(input$1.workspaceRoot);
+		if (result.projectType) __agiflowai_aicode_utils.print.success(`Detected ${result.projectType} project`);
+		return result;
 	}),
 	promptProjectType: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
 		if (actorInput.providedProjectType) {
@@ -530,23 +564,30 @@ const initActors = {
 			__agiflowai_aicode_utils.print.info(`Project type: ${projectType}`);
 			return projectType;
 		}
+		if (actorInput.detectedProjectType) {
+			__agiflowai_aicode_utils.print.info(`Using detected project type: ${actorInput.detectedProjectType}`);
+			return actorInput.detectedProjectType;
+		}
 		if (actorInput.detectionIndicators && actorInput.detectionIndicators.length > 0) {
 			__agiflowai_aicode_utils.print.info("\nDetection results:");
 			for (const indicator of actorInput.detectionIndicators) __agiflowai_aicode_utils.print.indent(`• ${indicator}`);
 			__agiflowai_aicode_utils.print.newline();
 		}
-		return await (0, __inquirer_prompts.select)({
+		__agiflowai_aicode_utils.print.divider();
+		const result = await (0, __inquirer_prompts.select)({
 			message: "Select project type:",
 			choices: [{
-				name: "Monolith - Single application structure",
+				name: "Monolith – Single application structure",
 				value: __agiflowai_aicode_utils.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: __agiflowai_aicode_utils.ProjectType.MONOREPO,
-				description: "Multiple packages managed together (uses workspaces)"
+				description: "\n  Multiple packages managed together (uses workspaces)"
 			}]
 		});
+		__agiflowai_aicode_utils.print.info("");
+		return result;
 	}),
 	promptProjectName: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
 		const newProjectService = new require_services.NewProjectService(actorInput.providedName, void 0);
@@ -558,49 +599,171 @@ const initActors = {
 			__agiflowai_aicode_utils.print.info(`Project name: ${trimmedName}`);
 			return trimmedName;
 		}
-		return await (0, __inquirer_prompts.input)({
-			message: "Enter your project name:",
-			validate: (value) => newProjectService.validateProjectName(value)
+		__agiflowai_aicode_utils.print.divider();
+		const result = await (0, __inquirer_prompts.input)({
+			message: "Enter your project name (press Enter to use current directory):",
+			validate: (value) => {
+				if (!value || value.trim() === "") return true;
+				return newProjectService.validateProjectName(value);
+			}
 		});
+		__agiflowai_aicode_utils.print.info("");
+		if (!result || result.trim() === "") return ".";
+		return result;
 	}),
 	createProjectDirectory: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
-		const projectPath = node_path.default.join(process.cwd(), actorInput.projectName.trim());
-		await new require_services.NewProjectService(void 0, void 0).createProjectDirectory(projectPath, actorInput.projectName);
-		return { projectPath };
+		if (actorInput.projectName === ".") {
+			const projectPath = process.cwd();
+			__agiflowai_aicode_utils.print.success(`Using current directory: ${projectPath}`);
+			return { projectPath };
+		}
+		const spinner = (0, ora.default)("Creating project directory...").start();
+		try {
+			const projectPath = node_path.default.join(process.cwd(), actorInput.projectName.trim());
+			await new require_services.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: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
 		const newProjectService = new require_services.NewProjectService(void 0, void 0);
-		if (await (0, __inquirer_prompts.confirm)({
+		__agiflowai_aicode_utils.print.divider();
+		const hasExistingRepo = await (0, __inquirer_prompts.confirm)({
 			message: "Do you have an existing Git repository you want to use?",
 			default: false
-		})) {
+		});
+		__agiflowai_aicode_utils.print.info("");
+		if (hasExistingRepo) {
+			__agiflowai_aicode_utils.print.divider();
 			const repoUrl = await (0, __inquirer_prompts.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 (0, __inquirer_prompts.confirm)({
-			message: "Initialize a new Git repository?",
-			default: true
-		})) await newProjectService.initializeGitRepository(actorInput.projectPath);
+			__agiflowai_aicode_utils.print.info("");
+			if (repoUrl && repoUrl.trim() !== "") {
+				const spinner = (0, ora.default)("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 __agiflowai_aicode_utils.print.info("Skipped cloning repository");
+		} else {
+			__agiflowai_aicode_utils.print.divider();
+			const initGit = await (0, __inquirer_prompts.confirm)({
+				message: "Initialize a new Git repository?",
+				default: true
+			});
+			__agiflowai_aicode_utils.print.info("");
+			if (initGit) {
+				const spinner = (0, ora.default)("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: (0, xstate.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(require_mcp.MCPServer).map((server) => ({
+			name: require_mcp.MCP_SERVER_INFO[server].name,
+			value: server,
+			description: `\n  ${require_mcp.MCP_SERVER_INFO[server].description}`,
+			checked: true
+		}));
+		__agiflowai_aicode_utils.print.divider();
+		const selected = await checkbox({
 			message: "Select MCP servers to configure:",
-			choices: Object.values(require_mcp.MCPServer).map((server) => ({
-				name: require_mcp.MCP_SERVER_INFO[server].name,
-				value: server,
-				description: require_mcp.MCP_SERVER_INFO[server].description,
-				checked: true
-			})),
+			choices,
 			validate: (answer) => {
 				if (answer.length === 0) return "Please select at least one MCP server";
 				return true;
 			}
 		});
+		__agiflowai_aicode_utils.print.info("");
+		return selected;
+	}),
+	checkTemplatesFolder: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
+		try {
+			const fs = await import("node:fs/promises");
+			const defaultTemplatesPath = node_path.default.join(actorInput.workspaceRoot, "templates");
+			let templatesExists = false;
+			try {
+				await fs.access(defaultTemplatesPath);
+				templatesExists = true;
+			} catch {
+				templatesExists = false;
+			}
+			let finalTemplatesPath = defaultTemplatesPath;
+			let skipDownload = false;
+			if (templatesExists) {
+				__agiflowai_aicode_utils.print.divider();
+				__agiflowai_aicode_utils.print.info(`Templates folder already exists at: ${defaultTemplatesPath}`);
+				const useDifferentDir = await (0, __inquirer_prompts.confirm)({
+					message: "Would you like to use a different directory for templates?",
+					default: false
+				});
+				__agiflowai_aicode_utils.print.info("");
+				if (useDifferentDir) {
+					__agiflowai_aicode_utils.print.divider();
+					const customDir = await (0, __inquirer_prompts.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;
+						}
+					});
+					__agiflowai_aicode_utils.print.info("");
+					finalTemplatesPath = node_path.default.join(actorInput.workspaceRoot, customDir.trim());
+					try {
+						await fs.mkdir(finalTemplatesPath, { recursive: true });
+						__agiflowai_aicode_utils.print.success(`Created templates directory at: ${finalTemplatesPath}`);
+					} catch (error) {
+						throw new Error(`Failed to create templates directory at ${finalTemplatesPath}: ${error.message}`);
+					}
+				} else {
+					skipDownload = true;
+					__agiflowai_aicode_utils.print.info("Using existing templates folder");
+				}
+			}
+			let existingTemplates;
+			if (skipDownload) try {
+				existingTemplates = (await new require_services.TemplateSelectionService(finalTemplatesPath).listTemplates()).map((t) => t.name);
+			} catch (_error) {
+				__agiflowai_aicode_utils.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: (0, xstate.fromPromise)(async () => {
-		return await new require_services.TemplateSelectionService().downloadTemplatesToTmp(DEFAULT_TEMPLATE_REPO);
+		const spinner = (0, ora.default)("Downloading templates from AgiFlow/aicode-toolkit...").start();
+		try {
+			const tmpPath = await new require_services.TemplateSelectionService().downloadTemplatesToTmp(DEFAULT_TEMPLATE_REPO);
+			spinner.succeed("Templates downloaded successfully");
+			return tmpPath;
+		} catch (error) {
+			spinner.fail("Failed to download templates");
+			throw error;
+		}
 	}),
 	listTemplates: (0, xstate.fromPromise)(async ({ input: input$1 }) => {
 		const templates = await new require_services.TemplateSelectionService(input$1.tmpTemplatesPath).listTemplates();
@@ -611,37 +774,52 @@ const initActors = {
 	promptTemplateSelection: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
 		const templates = await new require_services.TemplateSelectionService(actorInput.tmpTemplatesPath).listTemplates();
 		if (templates.length === 0) throw new Error("No templates available");
-		if (actorInput.projectType === __agiflowai_aicode_utils.ProjectType.MONOLITH) return [await (0, __inquirer_prompts.select)({
-			message: "Select template (monolith allows only one):",
-			choices: templates.map((t) => ({
+		if (actorInput.projectType === __agiflowai_aicode_utils.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
+			}));
+			__agiflowai_aicode_utils.print.divider();
+			const selected$1 = await (0, __inquirer_prompts.select)({
+				message: "Select template (monolith allows only one):",
+				choices: choices$1
+			});
+			__agiflowai_aicode_utils.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
+		}));
+		__agiflowai_aicode_utils.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
 		});
+		__agiflowai_aicode_utils.print.info("");
 		if (selected.length === 0) throw new Error("Please select at least one template");
 		return selected;
 	}),
 	copyTemplates: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
-		const templateSelectionService = new require_services.TemplateSelectionService(actorInput.tmpTemplatesPath);
-		const templatesPath = node_path.default.join(actorInput.workspaceRoot, "templates");
-		await templateSelectionService.copyTemplates(actorInput.selectedTemplates, templatesPath, actorInput.projectType, actorInput.selectedMcpServers);
-		return templatesPath;
+		const spinner = (0, ora.default)("Copying templates to workspace...").start();
+		try {
+			await new require_services.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: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
 		if (actorInput.projectType === __agiflowai_aicode_utils.ProjectType.MONOLITH) {
 			const toolkitConfig = {
 				version: "1.0",
-				templatesPath: "templates",
+				templatesPath: node_path.default.relative(actorInput.workspaceRoot, actorInput.templatesPath) || "templates",
 				projectType: "monolith",
 				sourceTemplate: actorInput.selectedTemplates[0]
 			};
@@ -662,20 +840,120 @@ const initActors = {
 			__agiflowai_aicode_utils.print.info(`Using detected coding agent: ${actorInput.detectedAgent}`);
 			return actorInput.detectedAgent;
 		}
-		return await (0, __inquirer_prompts.select)({
+		const agents = require_services.CodingAgentService.getAvailableAgents();
+		__agiflowai_aicode_utils.print.divider();
+		const selected = await (0, __inquirer_prompts.select)({
 			message: "Select coding agent for MCP configuration:",
-			choices: require_services.CodingAgentService.getAvailableAgents().map((agent) => ({
+			choices: agents.map((agent) => ({
 				name: agent.name,
 				value: agent.value,
-				description: agent.description
+				description: `\n  ${agent.description}`
 			}))
 		});
+		__agiflowai_aicode_utils.print.info("");
+		return selected;
 	}),
 	configureMCP: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
-		await new require_services.CodingAgentService(actorInput.workspaceRoot).setupMCP(actorInput.codingAgent);
+		const spinner = (0, ora.default)(`Setting up MCP for ${actorInput.codingAgent}...`).start();
+		try {
+			await new require_services.CodingAgentService(actorInput.workspaceRoot).setupMCP(actorInput.codingAgent);
+			spinner.succeed("MCP configuration completed");
+		} catch (error) {
+			spinner.fail("Failed to configure MCP");
+			throw error;
+		}
 	}),
 	cleanup: (0, xstate.fromPromise)(async ({ input: input$1 }) => {
-		if (input$1.tmpTemplatesPath) await new require_services.TemplateSelectionService(input$1.tmpTemplatesPath).cleanup();
+		if (input$1.tmpTemplatesPath) {
+			const spinner = (0, ora.default)("Cleaning up temporary files...").start();
+			try {
+				await new require_services.TemplateSelectionService(input$1.tmpTemplatesPath).cleanup();
+				spinner.succeed("Cleaned up temporary files");
+			} catch (_error) {
+				spinner.warn("Could not clean up all temporary files");
+			}
+		}
+	}),
+	detectSpecTool: (0, xstate.fromPromise)(async ({ input: input$1 }) => {
+		__agiflowai_aicode_utils.print.info("\nDetecting spec tools...");
+		const detectedTool = await new require_services.SpecToolService(input$1.workspaceRoot).detectSpecTool();
+		if (detectedTool) __agiflowai_aicode_utils.print.success(`Detected ${require_services.SPEC_TOOL_INFO[detectedTool].name} in workspace`);
+		else __agiflowai_aicode_utils.print.info("No spec tool detected");
+		return detectedTool;
+	}),
+	promptSpecDrivenApproach: (0, xstate.fromPromise)(async ({ input: actorInput }) => {
+		if (actorInput.detectedSpecTool) {
+			__agiflowai_aicode_utils.print.divider();
+			const result$1 = await (0, __inquirer_prompts.confirm)({
+				message: `${require_services.SPEC_TOOL_INFO[actorInput.detectedSpecTool].name} is installed. Would you like to update the agent instructions for spec-driven development?`,
+				default: true
+			});
+			__agiflowai_aicode_utils.print.info("");
+			return result$1;
+		}
+		__agiflowai_aicode_utils.print.divider();
+		const result = await (0, __inquirer_prompts.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
+		});
+		__agiflowai_aicode_utils.print.info("");
+		return result;
+	}),
+	setupSpec: (0, xstate.fromPromise)(async ({ input: input$1 }) => {
+		const codingAgentService = new require_services.CodingAgentService(input$1.workspaceRoot);
+		const specToolService = new require_services.SpecToolService(input$1.workspaceRoot, require_services.SpecTool.OPENSPEC, codingAgentService);
+		if (input$1.isAlreadyInstalled) {
+			const spinner = (0, ora.default)("Updating OpenSpec agent instructions...").start();
+			try {
+				const enabledMcps = {
+					scaffoldMcp: input$1.selectedMcpServers?.includes(require_mcp.MCPServer.SCAFFOLD) ?? false,
+					architectMcp: input$1.selectedMcpServers?.includes(require_mcp.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 = (0, ora.default)("Initializing OpenSpec...").start();
+			await new Promise((resolve) => setTimeout(resolve, 1e3));
+			spinner.stop();
+			try {
+				await specToolService.initializeSpec();
+				__agiflowai_aicode_utils.print.success("OpenSpec initialized successfully");
+			} catch (error) {
+				__agiflowai_aicode_utils.print.error("Failed to initialize OpenSpec");
+				throw error;
+			}
+		}
+	}),
+	promptSpecInstructions: (0, xstate.fromPromise)(async () => {
+		__agiflowai_aicode_utils.print.divider();
+		const result = await (0, __inquirer_prompts.confirm)({
+			message: "Would you like to update the agent instructions with OpenSpec workflow guidance?",
+			default: true
+		});
+		__agiflowai_aicode_utils.print.info("");
+		return result;
+	}),
+	updateSpecInstructions: (0, xstate.fromPromise)(async ({ input: input$1 }) => {
+		const spinner = (0, ora.default)("Updating OpenSpec agent instructions...").start();
+		try {
+			const codingAgentService = new require_services.CodingAgentService(input$1.workspaceRoot);
+			const specToolService = new require_services.SpecToolService(input$1.workspaceRoot, require_services.SpecTool.OPENSPEC, codingAgentService);
+			const enabledMcps = {
+				scaffoldMcp: input$1.selectedMcpServers?.includes(require_mcp.MCPServer.SCAFFOLD) ?? false,
+				architectMcp: input$1.selectedMcpServers?.includes(require_mcp.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;
+		}
 	})
 };
 /**