@agiflowai/aicode-toolkit 0.6.0

package/dist/cli.js

@@ -0,0 +1,727 @@
+#!/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 { Command } from "commander";
+import path from "node:path";
+import { ProjectType, TemplatesManagerService, icons, messages, print, sections } from "@agiflowai/aicode-utils";
+import * as fs from "fs-extra";
+import { confirm, input, select } from "@inquirer/prompts";
+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 license = "AGPL-3.0";
+var author = "AgiflowIO";
+var repository = {
+	"type": "git",
+	"url": "https://github.com/AgiFlow/aicode-toolkit.git",
+	"directory": "apps/aicode-toolkit"
+};
+var homepage = "https://github.com/AgiFlow/aicode-toolkit#readme";
+var bugs = { "url": "https://github.com/AgiFlow/aicode-toolkit/issues" };
+var keywords = [
+	"mcp",
+	"model-context-protocol",
+	"scaffold",
+	"boilerplate",
+	"template",
+	"code-generation",
+	"nextjs",
+	"react",
+	"vite"
+];
+var bin = { "aicode": "./dist/cli.cjs" };
+var main$1 = "./dist/index.cjs";
+var types = "./dist/index.d.cts";
+var module = "./dist/index.js";
+var files = ["dist", "README.md"];
+var scripts = {
+	"dev": "node --loader ts-node/esm src/cli.ts",
+	"build": "tsdown",
+	"test": "vitest --run",
+	"typecheck": "tsc --noEmit"
+};
+var dependencies = {
+	"@agiflowai/aicode-utils": "workspace:*",
+	"@agiflowai/coding-agent-bridge": "workspace:*",
+	"@composio/json-schema-to-zod": "0.1.15",
+	"@inquirer/prompts": "^7.8.6",
+	"@modelcontextprotocol/sdk": "1.19.1",
+	"chalk": "5.6.2",
+	"commander": "14.0.1",
+	"execa": "^9.5.2",
+	"express": "^4.21.2",
+	"fs-extra": "11.3.2",
+	"gradient-string": "^3.0.0",
+	"js-yaml": "4.1.0",
+	"liquidjs": "10.21.1",
+	"pino": "^10.0.0",
+	"pino-pretty": "^13.1.1",
+	"xstate": "^5.23.0",
+	"zod": "3.25.76"
+};
+var devDependencies = {
+	"@types/express": "^5.0.0",
+	"@types/fs-extra": "^11.0.4",
+	"@types/js-yaml": "^4.0.9",
+	"@types/node": "^22.0.0",
+	"tsdown": "^0.15.6",
+	"typescript": "5.9.3"
+};
+var publishConfig = { "access": "public" };
+var type = "module";
+var exports = {
+	".": {
+		"import": "./dist/index.js",
+		"require": "./dist/index.cjs"
+	},
+	"./cli": {
+		"import": "./dist/cli.js",
+		"require": "./dist/cli.cjs"
+	},
+	"./package.json": "./package.json"
+};
+var package_default = {
+	name,
+	description,
+	version,
+	license,
+	author,
+	repository,
+	homepage,
+	bugs,
+	keywords,
+	bin,
+	main: main$1,
+	types,
+	module,
+	files,
+	scripts,
+	dependencies,
+	devDependencies,
+	publishConfig,
+	type,
+	exports
+};
+
+//#endregion
+//#region src/commands/add.ts
+/**
+* Add command - add a template to templates folder
+*/
+const addCommand = new Command("add").description("Add a template to templates folder").requiredOption("--name <name>", "Template name").requiredOption("--url <url>", "URL of the template repository to download").option("--path <path>", "Override templates folder path (uses toolkit.yaml config by default)").option("--type <type>", "Template type: boilerplate or scaffold", "boilerplate").action(async (options) => {
+	try {
+		const templatesPath = options.path ? path.resolve(options.path) : await TemplatesManagerService.findTemplatesPath();
+		const templateType = options.type.toLowerCase();
+		const templateName = options.name;
+		const templateUrl = options.url;
+		if (templateType !== "boilerplate" && templateType !== "scaffold") {
+			messages.error("Invalid template type. Use: boilerplate or scaffold");
+			process.exit(1);
+		}
+		const targetFolder = path.join(templatesPath, `${templateType}s`, templateName);
+		if (await fs.pathExists(targetFolder)) {
+			messages.error(`Template '${templateName}' already exists at ${targetFolder}`);
+			process.exit(1);
+		}
+		print.info(`${icons.download} Downloading template '${templateName}' from ${templateUrl}...`);
+		await fs.ensureDir(path.dirname(targetFolder));
+		const parsedUrl = parseGitHubUrl(templateUrl);
+		try {
+			if (parsedUrl.isSubdirectory && parsedUrl.branch && parsedUrl.subdirectory) {
+				print.info(`${icons.folder} Detected subdirectory: ${parsedUrl.subdirectory} (branch: ${parsedUrl.branch})`);
+				await cloneSubdirectory(parsedUrl.repoUrl, parsedUrl.branch, parsedUrl.subdirectory, targetFolder);
+			} else await cloneRepository(parsedUrl.repoUrl, targetFolder);
+			messages.success(`Template '${templateName}' added successfully!`);
+			print.header(`\n${icons.folder} Template location:`);
+			print.indent(targetFolder);
+			const configFiles = [path.join(targetFolder, "boilerplate.yaml"), path.join(targetFolder, "scaffold.yaml")];
+			let hasConfig = false;
+			for (const configFile of configFiles) if (await fs.pathExists(configFile)) {
+				print.header(`\n${icons.config} Configuration file found:`);
+				print.indent(path.basename(configFile));
+				hasConfig = true;
+				break;
+			}
+			if (!hasConfig) {
+				messages.warning("Warning: No configuration file found (boilerplate.yaml or scaffold.yaml)");
+				print.indent("You may need to create one manually.");
+			}
+			sections.nextSteps([`Review the template in ${targetFolder}`, `Test it with: scaffold-mcp ${templateType} list`]);
+		} catch (error) {
+			if (error.message.includes("not found") || error.message.includes("command not found")) messages.error("git command not found. Please install git first.");
+			else if (error.message.includes("Authentication failed")) messages.error("Authentication failed. Make sure you have access to the repository.");
+			else if (error.message.includes("Repository not found")) messages.error("Repository not found. Check the URL and try again.");
+			else messages.error("Failed to clone repository:", error);
+			process.exit(1);
+		}
+	} catch (error) {
+		messages.error("Error adding template:", error);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/states/init-machine.ts
+/**
+* Init command state machine
+* Pure declarative state machine definition
+* Actors are provided externally for better separation of concerns
+*/
+const initMachine = createMachine({
+	id: "init",
+	types: {},
+	initial: "displayingBanner",
+	context: ({ input: input$1 }) => ({
+		workspaceRoot: void 0,
+		projectName: void 0,
+		projectType: void 0,
+		projectPath: void 0,
+		repositoryExists: false,
+		detectionConfidence: void 0,
+		detectionIndicators: void 0,
+		templatesPath: void 0,
+		tmpTemplatesPath: void 0,
+		selectedTemplates: void 0,
+		selectedMcpServers: void 0,
+		detectedCodingAgent: void 0,
+		codingAgent: void 0,
+		options: input$1.options,
+		error: void 0
+	}),
+	states: {
+		displayingBanner: { invoke: {
+			src: "displayBanner",
+			onDone: { target: "checkingWorkspace" }
+		} },
+		checkingWorkspace: { invoke: {
+			src: "checkWorkspaceExists",
+			onDone: [{
+				target: "detectingProjectType",
+				guard: ({ event }) => event.output.exists === true,
+				actions: assign({
+					workspaceRoot: ({ event }) => event.output.workspaceRoot,
+					repositoryExists: () => true
+				})
+			}, {
+				target: "creatingNewProject",
+				guard: ({ event }) => event.output.exists === false,
+				actions: assign({ repositoryExists: () => false })
+			}]
+		} },
+		detectingProjectType: { invoke: {
+			src: "detectProjectType",
+			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
+			onDone: [{
+				target: "checkingSkipTemplates",
+				guard: ({ event }) => event.output.confidence === "high",
+				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
+				})
+			}],
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		promptingProjectType: { invoke: {
+			src: "promptProjectType",
+			input: ({ context }) => ({
+				providedProjectType: context.options.projectType,
+				detectionIndicators: context.detectionIndicators
+			}),
+			onDone: {
+				target: "checkingSkipTemplates",
+				actions: assign({ projectType: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		creatingNewProject: {
+			initial: "promptingProjectName",
+			states: {
+				promptingProjectName: { invoke: {
+					src: "promptProjectName",
+					input: ({ context }) => ({ providedName: context.options.name }),
+					onDone: {
+						target: "creatingProjectDirectory",
+						actions: assign({ projectName: ({ event }) => event.output })
+					},
+					onError: {
+						target: "#init.failed",
+						actions: assign({ error: ({ event }) => event.error })
+					}
+				} },
+				creatingProjectDirectory: { invoke: {
+					src: "createProjectDirectory",
+					input: ({ context }) => ({ projectName: context.projectName }),
+					onDone: {
+						target: "promptingGitSetup",
+						actions: assign({
+							projectPath: ({ event }) => event.output.projectPath,
+							workspaceRoot: ({ event }) => event.output.projectPath
+						})
+					},
+					onError: {
+						target: "#init.failed",
+						actions: assign({ error: ({ event }) => event.error })
+					}
+				} },
+				promptingGitSetup: { invoke: {
+					src: "promptGitSetup",
+					input: ({ context }) => ({ projectPath: context.projectPath }),
+					onDone: { target: "promptingProjectType" },
+					onError: {
+						target: "#init.failed",
+						actions: assign({ error: ({ event }) => event.error })
+					}
+				} },
+				promptingProjectType: { invoke: {
+					src: "promptProjectType",
+					input: ({ context }) => ({ providedProjectType: context.options.projectType }),
+					onDone: {
+						target: "#init.checkingSkipTemplates",
+						actions: assign({ projectType: ({ event }) => event.output })
+					},
+					onError: {
+						target: "#init.failed",
+						actions: assign({ error: ({ event }) => event.error })
+					}
+				} }
+			}
+		},
+		checkingSkipTemplates: { always: [{
+			target: "promptingMcpSelection",
+			guard: ({ context }) => !context.options.skipTemplates
+		}, { target: "checkingSkipMcp" }] },
+		promptingMcpSelection: { invoke: {
+			src: "promptMcpSelection",
+			onDone: {
+				target: "downloadingTemplates",
+				actions: assign({ selectedMcpServers: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		downloadingTemplates: { invoke: {
+			src: "downloadTemplates",
+			onDone: {
+				target: "listingTemplates",
+				actions: assign({ tmpTemplatesPath: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		listingTemplates: { invoke: {
+			src: "listTemplates",
+			input: ({ context }) => ({ tmpTemplatesPath: context.tmpTemplatesPath }),
+			onDone: { target: "promptingTemplateSelection" },
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		promptingTemplateSelection: { invoke: {
+			src: "promptTemplateSelection",
+			input: ({ context }) => ({
+				tmpTemplatesPath: context.tmpTemplatesPath,
+				projectType: context.projectType
+			}),
+			onDone: {
+				target: "copyingTemplates",
+				actions: assign({ selectedTemplates: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		copyingTemplates: { invoke: {
+			src: "copyTemplates",
+			input: ({ context }) => ({
+				tmpTemplatesPath: context.tmpTemplatesPath,
+				workspaceRoot: context.workspaceRoot,
+				selectedTemplates: context.selectedTemplates,
+				projectType: context.projectType,
+				selectedMcpServers: context.selectedMcpServers
+			}),
+			onDone: {
+				target: "creatingConfig",
+				actions: assign({ templatesPath: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		creatingConfig: { invoke: {
+			src: "createConfig",
+			input: ({ context }) => ({
+				workspaceRoot: context.workspaceRoot,
+				projectType: context.projectType,
+				selectedTemplates: context.selectedTemplates
+			}),
+			onDone: { target: "checkingSkipMcp" },
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		checkingSkipMcp: { always: [{
+			target: "detectingCodingAgent",
+			guard: ({ context }) => !context.options.skipMcp
+		}, { target: "cleaningUp" }] },
+		detectingCodingAgent: { invoke: {
+			src: "detectCodingAgent",
+			input: ({ context }) => ({ workspaceRoot: context.workspaceRoot }),
+			onDone: {
+				target: "promptingCodingAgent",
+				actions: assign({ detectedCodingAgent: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		promptingCodingAgent: { invoke: {
+			src: "promptCodingAgent",
+			input: ({ context }) => ({ detectedAgent: context.detectedCodingAgent }),
+			onDone: {
+				target: "configuringMCP",
+				actions: assign({ codingAgent: ({ event }) => event.output })
+			},
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		configuringMCP: { invoke: {
+			src: "configureMCP",
+			input: ({ context }) => ({
+				workspaceRoot: context.workspaceRoot,
+				codingAgent: context.codingAgent
+			}),
+			onDone: { target: "cleaningUp" },
+			onError: {
+				target: "failed",
+				actions: assign({ error: ({ event }) => event.error })
+			}
+		} },
+		cleaningUp: { invoke: {
+			src: "cleanup",
+			input: ({ context }) => ({ tmpTemplatesPath: context.tmpTemplatesPath }),
+			onDone: { target: "completed" },
+			onError: { target: "completed" }
+		} },
+		completed: { type: "final" },
+		failed: { type: "final" }
+	}
+}, { guards: {} });
+
+//#endregion
+//#region src/commands/init.ts
+const DEFAULT_TEMPLATE_REPO = {
+	owner: "AgiFlow",
+	repo: "aicode-toolkit",
+	branch: "main",
+	path: "templates"
+};
+/**
+* Actor implementations for the init V2 state machine
+*/
+const initActors = {
+	displayBanner: fromPromise(async () => {
+		displayBanner();
+	}),
+	checkWorkspaceExists: fromPromise(async () => {
+		const workspaceRoot = await findWorkspaceRoot();
+		if (workspaceRoot) {
+			print.info(`Found workspace at: ${workspaceRoot}`);
+			return {
+				exists: true,
+				workspaceRoot
+			};
+		}
+		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
+		};
+	}),
+	promptProjectType: fromPromise(async ({ input: actorInput }) => {
+		if (actorInput.providedProjectType) {
+			const projectType = actorInput.providedProjectType;
+			print.info(`Project type: ${projectType}`);
+			return projectType;
+		}
+		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({
+			message: "Select project type:",
+			choices: [{
+				name: "Monolith - Single application structure",
+				value: ProjectType.MONOLITH,
+				description: "Traditional single-application project structure"
+			}, {
+				name: "Monorepo - Multiple packages/apps in one repository",
+				value: ProjectType.MONOREPO,
+				description: "Multiple packages managed together (uses workspaces)"
+			}]
+		});
+	}),
+	promptProjectName: fromPromise(async ({ input: actorInput }) => {
+		const newProjectService = new NewProjectService(actorInput.providedName, void 0);
+		const providedName = newProjectService.getProvidedName();
+		if (providedName) {
+			const trimmedName = providedName.trim();
+			const validationResult = newProjectService.validateProjectName(trimmedName);
+			if (validationResult !== true) throw new Error(validationResult);
+			print.info(`Project name: ${trimmedName}`);
+			return trimmedName;
+		}
+		return await input({
+			message: "Enter your project name:",
+			validate: (value) => newProjectService.validateProjectName(value)
+		});
+	}),
+	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 };
+	}),
+	promptGitSetup: fromPromise(async ({ input: actorInput }) => {
+		const newProjectService = new NewProjectService(void 0, void 0);
+		if (await confirm({
+			message: "Do you have an existing Git repository you want to use?",
+			default: false
+		})) {
+			const repoUrl = await input({
+				message: "Enter Git repository URL:",
+				validate: (value) => 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);
+	}),
+	promptMcpSelection: fromPromise(async () => {
+		return await (await import("@inquirer/prompts").then((m) => m.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
+			})),
+			validate: (answer) => {
+				if (answer.length === 0) return "Please select at least one MCP server";
+				return true;
+			}
+		});
+	}),
+	downloadTemplates: fromPromise(async () => {
+		return await new TemplateSelectionService().downloadTemplatesToTmp(DEFAULT_TEMPLATE_REPO);
+	}),
+	listTemplates: fromPromise(async ({ input: input$1 }) => {
+		const templates = await new TemplateSelectionService(input$1.tmpTemplatesPath).listTemplates();
+		print.header("\nAvailable templates:");
+		for (const template of templates) print.item(`${template.name}${template.description ? ` - ${template.description}` : ""}`);
+		return templates;
+	}),
+	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) => ({
+				name: t.name,
+				value: t.name,
+				description: t.description
+			}))
+		})];
+		const selected = await (await import("@inquirer/prompts").then((m) => m.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
+			}))
+		});
+		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;
+	}),
+	createConfig: fromPromise(async ({ input: actorInput }) => {
+		if (actorInput.projectType === ProjectType.MONOLITH) {
+			const toolkitConfig = {
+				version: "1.0",
+				templatesPath: "templates",
+				projectType: "monolith",
+				sourceTemplate: actorInput.selectedTemplates[0]
+			};
+			print.info("\nCreating toolkit.yaml...");
+			await TemplatesManagerService.writeToolkitConfig(toolkitConfig, actorInput.workspaceRoot);
+			print.success("toolkit.yaml created");
+		}
+	}),
+	detectCodingAgent: fromPromise(async ({ input: actorInput }) => {
+		print.info("\nDetecting coding agent...");
+		const detectedAgent = await CodingAgentService.detectCodingAgent(actorInput.workspaceRoot);
+		if (detectedAgent) print.success(`Detected ${detectedAgent} in workspace`);
+		else print.info("No coding agent detected automatically");
+		return detectedAgent;
+	}),
+	promptCodingAgent: fromPromise(async ({ input: actorInput }) => {
+		if (actorInput.detectedAgent) {
+			print.info(`Using detected coding agent: ${actorInput.detectedAgent}`);
+			return actorInput.detectedAgent;
+		}
+		return await select({
+			message: "Select coding agent for MCP configuration:",
+			choices: CodingAgentService.getAvailableAgents().map((agent) => ({
+				name: agent.name,
+				value: agent.value,
+				description: agent.description
+			}))
+		});
+	}),
+	configureMCP: fromPromise(async ({ input: actorInput }) => {
+		await new CodingAgentService(actorInput.workspaceRoot).setupMCP(actorInput.codingAgent);
+	}),
+	cleanup: fromPromise(async ({ input: input$1 }) => {
+		if (input$1.tmpTemplatesPath) await new TemplateSelectionService(input$1.tmpTemplatesPath).cleanup();
+	})
+};
+/**
+* Init command - improved V2 implementation
+*/
+const initCommand = new Command("init").description("Initialize project with templates and MCP configuration").option("--name <name>", "Project name (for new projects)").option("--project-type <type>", "Project type: monolith or monorepo (for new projects)").option("--skip-templates", "Skip template download and selection").option("--skip-mcp", "Skip MCP configuration").action(async (options) => {
+	try {
+		const actor = createActor(initMachine.provide({ actors: initActors }), { input: { options: {
+			name: options.name,
+			projectType: options.projectType,
+			skipTemplates: options.skipTemplates || false,
+			skipMcp: options.skipMcp || false
+		} } });
+		actor.start();
+		await new Promise((resolve, reject) => {
+			const subscription = actor.subscribe((state) => {
+				if (state.matches("completed")) {
+					subscription.unsubscribe();
+					resolve();
+				} else if (state.matches("failed")) {
+					subscription.unsubscribe();
+					reject(new Error(state.context.error?.message || "Unknown error"));
+				}
+			});
+		});
+		const { templatesPath, projectType } = actor.getSnapshot().context;
+		print.header("\nSetup Complete!");
+		if (templatesPath) print.info(`Templates location: ${templatesPath}`);
+		if (projectType) print.info(`Project type: ${projectType}`);
+		const gradient = await import("gradient-string");
+		print.newline();
+		console.log(gradient.default.pastel.multiline("🎉 Congratulations! Your project is ready to go!"));
+		print.newline();
+	} catch (error) {
+		print.error(`\nError: ${error.message}`);
+		process.exit(1);
+	}
+});
+
+//#endregion
+//#region src/cli.ts
+/**
+* Main entry point
+*/
+async function main() {
+	const program = new Command();
+	program.name("aicode").description("AI-powered code toolkit CLI for scaffolding, architecture management, and development workflows").version(package_default.version);
+	program.addCommand(initCommand);
+	program.addCommand(addCommand);
+	await program.parseAsync(process.argv);
+}
+main();
+
+//#endregion
+export {  };