@agiflowai/aicode-toolkit 0.6.0

package/dist/services-DNldrNnu.js

@@ -0,0 +1,739 @@
+import path from "node:path";
+import { ProjectType, messages, print } from "@agiflowai/aicode-utils";
+import * as fs 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 os from "node:os";
+
+//#region src/constants/theme.ts
+/**
+* Theme color constants for AICode Toolkit
+* Defines the brand color palette used throughout the CLI
+*/
+const THEME = { colors: {
+	primary: {
+		default: "#10b981",
+		dark: "#059669",
+		text: "#ffffff"
+	},
+	secondary: {
+		default: "#0d9488",
+		dark: "#0f766e",
+		light: "#14b8a6",
+		text: "#ffffff"
+	},
+	accent: {
+		default: "#c44569",
+		dark: "#c44569",
+		text: "#2a0b14"
+	},
+	semantic: {
+		info: "#5fb3d4",
+		success: "#5fb368",
+		error: "#d45959",
+		alert: "#d4b359"
+	},
+	cta: {
+		from: "#10b981",
+		to: "#0d9488",
+		text: "#ffffff"
+	},
+	transparent: "rgba(0, 0, 0, 0)",
+	white: "#c4cccf",
+	black: "#424549",
+	background: {
+		dark: {
+			default: "#0f0f0f",
+			shade: "#141414",
+			dark: "#0a0a0a",
+			light: "#1a1a1a"
+		},
+		light: {
+			default: "#fff",
+			shade: "#EAEAEA",
+			dark: "#17202a",
+			light: "#EAEAEA"
+		}
+	}
+} };
+/**
+* Gradient colors for banner (primary green -> secondary teal)
+*/
+const BANNER_GRADIENT = [
+	THEME.colors.primary.default,
+	THEME.colors.primary.dark,
+	THEME.colors.secondary.default,
+	THEME.colors.secondary.dark
+];
+
+//#endregion
+//#region src/utils/banner.ts
+/**
+* ASCII art for AICode Toolkit - simple and highly readable design
+* Uses clean block style with clear spacing
+*/
+const ASCII_ART = `
+   █████╗ ██╗ ██████╗ ██████╗ ██████╗ ███████╗
+  ██╔══██╗██║██╔════╝██╔═══██╗██╔══██╗██╔════╝
+  ███████║██║██║     ██║   ██║██║  ██║█████╗
+  ██╔══██║██║██║     ██║   ██║██║  ██║██╔══╝
+  ██║  ██║██║╚██████╗╚██████╔╝██████╔╝███████╗
+  ╚═╝  ╚═╝╚═╝ ╚═════╝ ╚═════╝ ╚═════╝ ╚══════╝
+
+  ████████╗ ██████╗  ██████╗ ██╗     ██╗  ██╗██╗████████╗
+  ╚══██╔══╝██╔═══██╗██╔═══██╗██║     ██║ ██╔╝██║╚══██╔══╝
+     ██║   ██║   ██║██║   ██║██║     █████╔╝ ██║   ██║
+     ██║   ██║   ██║██║   ██║██║     ██╔═██╗ ██║   ██║
+     ██║   ╚██████╔╝╚██████╔╝███████╗██║  ██╗██║   ██║
+     ╚═╝    ╚═════╝  ╚═════╝ ╚══════╝╚═╝  ╚═╝╚═╝   ╚═╝
+`;
+/**
+* Displays the AICode Toolkit banner with gradient effect
+* Uses gradient-string with theme colors (primary green -> secondary teal)
+*/
+function displayBanner() {
+	const bannerGradient = gradient(BANNER_GRADIENT);
+	console.log(bannerGradient.multiline(ASCII_ART));
+	console.log(bannerGradient("         AI-Powered Code Toolkit for Modern Development"));
+	console.log(chalk.dim("         v0.6.0"));
+	console.log();
+}
+/**
+* Simplified banner for compact display
+*/
+function displayCompactBanner() {
+	const titleGradient = gradient(BANNER_GRADIENT);
+	console.log();
+	console.log(chalk.bold("▸ ") + titleGradient("AICode Toolkit") + chalk.dim(" v0.6.0"));
+	console.log(chalk.dim("  AI-Powered Code Toolkit"));
+	console.log();
+}
+
+//#endregion
+//#region src/utils/git.ts
+/**
+* Execute a git command safely using execa to prevent command injection
+*/
+async function execGit(args, cwd) {
+	try {
+		await execa("git", args, { cwd });
+	} catch (error) {
+		const execaError = error;
+		throw new Error(`Git command failed: ${execaError.stderr || execaError.message}`);
+	}
+}
+/**
+* Execute git init safely using execa to prevent command injection
+*/
+async function gitInit(projectPath) {
+	try {
+		await execa("git", ["init", projectPath]);
+	} catch (error) {
+		const execaError = error;
+		throw new Error(`Git init failed: ${execaError.stderr || execaError.message}`);
+	}
+}
+/**
+* Find the workspace root by searching upwards for .git folder
+* Returns null if no .git folder is found (indicating a new project setup is needed)
+*/
+async function findWorkspaceRoot(startPath = process.cwd()) {
+	let currentPath = path.resolve(startPath);
+	const rootPath = path.parse(currentPath).root;
+	while (true) {
+		const gitPath = path.join(currentPath, ".git");
+		if (await fs.pathExists(gitPath)) return currentPath;
+		if (currentPath === rootPath) return null;
+		currentPath = path.dirname(currentPath);
+	}
+}
+/**
+* Parse GitHub URL to detect if it's a subdirectory
+* Supports formats:
+* - https://github.com/user/repo
+* - https://github.com/user/repo/tree/branch/path/to/dir
+* - https://github.com/user/repo/tree/main/path/to/dir
+*/
+function parseGitHubUrl(url) {
+	const treeMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/tree\/([^/]+)\/(.+)$/);
+	const blobMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+)\/blob\/([^/]+)\/(.+)$/);
+	const rootMatch = url.match(/^https?:\/\/github\.com\/([^/]+)\/([^/]+?)(?:\.git)?$/);
+	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],
+			isSubdirectory: true
+		};
+	}
+	if (rootMatch) return {
+		owner: rootMatch[1],
+		repo: rootMatch[2],
+		repoUrl: `https://github.com/${rootMatch[1]}/${rootMatch[2]}.git`,
+		isSubdirectory: false
+	};
+	return {
+		repoUrl: url,
+		isSubdirectory: false
+	};
+}
+/**
+* Clone a subdirectory from a git repository using sparse checkout
+*/
+async function cloneSubdirectory(repoUrl, branch, subdirectory, targetFolder) {
+	const tempFolder = `${targetFolder}.tmp`;
+	try {
+		await execGit(["init", tempFolder]);
+		await execGit([
+			"remote",
+			"add",
+			"origin",
+			repoUrl
+		], tempFolder);
+		await execGit([
+			"config",
+			"core.sparseCheckout",
+			"true"
+		], tempFolder);
+		const sparseCheckoutFile = path.join(tempFolder, ".git", "info", "sparse-checkout");
+		await fs.writeFile(sparseCheckoutFile, `${subdirectory}\n`);
+		await execGit([
+			"pull",
+			"--depth=1",
+			"origin",
+			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);
+	} catch (error) {
+		if (await fs.pathExists(tempFolder)) await fs.remove(tempFolder);
+		throw error;
+	}
+}
+/**
+* Clone entire repository
+*/
+async function cloneRepository(repoUrl, targetFolder) {
+	await execGit([
+		"clone",
+		repoUrl,
+		targetFolder
+	]);
+	const gitFolder = path.join(targetFolder, ".git");
+	if (await fs.pathExists(gitFolder)) await fs.remove(gitFolder);
+}
+/**
+* Fetch directory listing from GitHub API
+*/
+async function fetchGitHubDirectoryContents(owner, repo, path$1, branch = "main") {
+	const url = `https://api.github.com/repos/${owner}/${repo}/contents/${path$1}?ref=${branch}`;
+	const response = await fetch(url, { headers: {
+		Accept: "application/vnd.github.v3+json",
+		"User-Agent": "scaffold-mcp"
+	} });
+	if (!response.ok) throw new Error(`Failed to fetch directory contents: ${response.statusText}`);
+	const data = await response.json();
+	if (!Array.isArray(data)) throw new Error("Expected directory but got file");
+	return data.map((item) => ({
+		name: item.name,
+		type: item.type,
+		path: item.path
+	}));
+}
+
+//#endregion
+//#region src/services/CodingAgentService.ts
+var CodingAgentService = class {
+	workspaceRoot;
+	constructor(workspaceRoot) {
+		this.workspaceRoot = workspaceRoot;
+	}
+	/**
+	* Detect which coding agent is enabled in the workspace
+	* Checks for Claude Code, Codex, and Gemini CLI 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 CodexService({ workspaceRoot }).isEnabled()) return CODEX;
+		if (await new GeminiCliService({ workspaceRoot }).isEnabled()) return GEMINI_CLI;
+		return null;
+	}
+	/**
+	* Get available coding agents with their descriptions
+	*/
+	static getAvailableAgents() {
+		return [
+			{
+				value: CLAUDE_CODE,
+				name: "Claude Code",
+				description: "Anthropic Claude Code CLI agent"
+			},
+			{
+				value: CODEX,
+				name: "Codex",
+				description: "OpenAI Codex CLI agent"
+			},
+			{
+				value: GEMINI_CLI,
+				name: "Gemini CLI",
+				description: "Google Gemini CLI agent"
+			},
+			{
+				value: NONE,
+				name: "Other",
+				description: "Other coding agent or skip MCP configuration"
+			}
+		];
+	}
+	/**
+	* Setup MCP configuration for the selected coding agent
+	* @param agent - The coding agent to configure
+	*/
+	async setupMCP(agent) {
+		if (agent === NONE) {
+			print.info("Skipping MCP configuration");
+			return;
+		}
+		print.info(`\nSetting up MCP for ${agent}...`);
+		let service = null;
+		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 === 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";
+		}
+		if (!service) {
+			print.info(`MCP configuration for ${agent} is not yet supported.`);
+			print.info("Please configure MCP servers manually for this coding agent.");
+			return;
+		}
+		await service.updateMcpSettings({ servers: {
+			"scaffold-mcp": {
+				type: "stdio",
+				command: "npx",
+				args: [
+					"-y",
+					"@agiflowai/scaffold-mcp",
+					"mcp-serve"
+				],
+				disabled: false
+			},
+			"architect-mcp": {
+				type: "stdio",
+				command: "npx",
+				args: [
+					"-y",
+					"@agiflowai/architect-mcp",
+					"mcp-serve"
+				],
+				disabled: false
+			}
+		} });
+		print.success(`Added scaffold-mcp and architect-mcp to ${configLocation}`);
+		print.info("\nNext steps:");
+		print.indent(`1. ${restartInstructions}`);
+		print.indent("2. The scaffold-mcp and architect-mcp servers will be available");
+		print.success("\nMCP configuration completed!");
+	}
+};
+
+//#endregion
+//#region src/services/NewProjectService.ts
+const RESERVED_PROJECT_NAMES = [
+	".",
+	"..",
+	"CON",
+	"PRN",
+	"AUX",
+	"NUL",
+	"COM1",
+	"COM2",
+	"COM3",
+	"COM4",
+	"COM5",
+	"COM6",
+	"COM7",
+	"COM8",
+	"COM9",
+	"LPT1",
+	"LPT2",
+	"LPT3",
+	"LPT4",
+	"LPT5",
+	"LPT6",
+	"LPT7",
+	"LPT8",
+	"LPT9"
+];
+var NewProjectService = class {
+	providedName;
+	providedProjectType;
+	constructor(providedName, providedProjectType) {
+		this.providedName = providedName;
+		this.providedProjectType = providedProjectType;
+	}
+	/**
+	* Validate project name against naming rules
+	* @param value - Project name to validate
+	* @returns true if valid, error message string if invalid
+	*/
+	validateProjectName(value) {
+		const trimmed = value.trim();
+		if (!trimmed) return "Project name is required";
+		if (!/^[a-zA-Z0-9]/.test(trimmed)) return "Project name must start with a letter or number";
+		if (!/^[a-zA-Z0-9][a-zA-Z0-9_-]*$/.test(trimmed)) return "Project name can only contain letters, numbers, hyphens, and underscores";
+		if (RESERVED_PROJECT_NAMES.includes(trimmed.toUpperCase())) return "Project name uses a reserved name";
+		return true;
+	}
+	/**
+	* Validate project type
+	* @param projectType - Project type to validate
+	* @throws Error if invalid project type
+	*/
+	validateProjectType(projectType) {
+		if (projectType !== ProjectType.MONOLITH && projectType !== ProjectType.MONOREPO) throw new Error(`Invalid project type '${projectType}'. Must be '${ProjectType.MONOLITH}' or '${ProjectType.MONOREPO}'`);
+	}
+	/**
+	* Get the provided name from constructor
+	*/
+	getProvidedName() {
+		return this.providedName;
+	}
+	/**
+	* Get the provided project type from constructor
+	*/
+	getProvidedProjectType() {
+		return this.providedProjectType;
+	}
+	/**
+	* Create project directory atomically
+	* @param projectPath - Full path where project should be created
+	* @param projectName - Name of the project (for error messages)
+	*/
+	async createProjectDirectory(projectPath, projectName) {
+		try {
+			await fs.mkdir(projectPath, { recursive: false });
+			print.success(`Created project directory: ${projectPath}`);
+		} catch (error) {
+			if (error.code === "EEXIST") throw new Error(`Directory '${projectName}' already exists. Please choose a different name.`);
+			throw error;
+		}
+	}
+	/**
+	* Clone an existing Git repository
+	* @param repoUrl - Repository URL to clone
+	* @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);
+			throw new Error(`Failed to clone repository: ${error.message}`);
+		}
+	}
+	/**
+	* Initialize a new Git repository
+	* @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}`);
+		}
+	}
+	/**
+	* Validate repository URL format
+	* @param value - Repository URL to validate
+	* @returns true if valid, error message string if invalid
+	*/
+	validateRepositoryUrl(value) {
+		if (!value.trim()) return "Repository URL is required";
+		if (!value.match(/^(https?:\/\/|git@)/)) return "Please enter a valid Git repository URL";
+		return true;
+	}
+};
+
+//#endregion
+//#region src/services/TemplateSelectionService.ts
+var TemplateSelectionService = class {
+	tmpDir;
+	constructor(existingTmpDir) {
+		this.tmpDir = existingTmpDir || path.join(os.tmpdir(), `aicode-templates-${Date.now()}`);
+	}
+	/**
+	* Download templates to OS tmp directory
+	* @param repoConfig - Repository configuration
+	* @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);
+			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");
+			if (templateDirs.length === 0) throw new Error("No templates found in repository");
+			print.info(`Found ${templateDirs.length} template(s), downloading...`);
+			for (const template of templateDirs) {
+				const targetFolder = path.join(this.tmpDir, template.name);
+				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}`);
+			}
+			if (globalFiles.length > 0) {
+				print.info("Downloading global RULES.yaml...");
+				const rulesUrl = `https://raw.githubusercontent.com/${repoConfig.owner}/${repoConfig.repo}/${repoConfig.branch}/${repoConfig.path}/RULES.yaml`;
+				const targetFile = path.join(this.tmpDir, "RULES.yaml");
+				const response = await fetch(rulesUrl);
+				if (response.ok) {
+					const content = await response.text();
+					await fs.writeFile(targetFile, content, "utf-8");
+					print.success("Downloaded global RULES.yaml");
+				}
+			}
+			print.success(`\nAll templates downloaded to ${this.tmpDir}`);
+			return this.tmpDir;
+		} catch (error) {
+			await this.cleanup();
+			throw new Error(`Failed to download templates: ${error.message}`);
+		}
+	}
+	/**
+	* List available templates in the tmp directory
+	* @returns Array of template information
+	*/
+	async listTemplates() {
+		try {
+			const entries = await fs.readdir(this.tmpDir, { withFileTypes: true });
+			const templates = [];
+			for (const entry of entries) if (entry.isDirectory()) {
+				const templatePath = path.join(this.tmpDir, entry.name);
+				const description = await this.readTemplateDescription(templatePath);
+				templates.push({
+					name: entry.name,
+					path: templatePath,
+					description
+				});
+			}
+			return templates;
+		} catch (error) {
+			throw new Error(`Failed to list templates: ${error.message}`);
+		}
+	}
+	/**
+	* Copy selected templates to destination
+	* @param templateNames - Names of templates to copy
+	* @param destinationPath - Destination templates folder path
+	* @param projectType - Project type (monolith allows only single template)
+	* @param selectedMcpServers - Optional array of selected MCP servers to filter files
+	*/
+	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);
+			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)) {
+					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);
+				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)) {
+					print.info("Copying global RULES.yaml...");
+					await fs.copy(globalRulesSource, globalRulesTarget);
+					print.success("Copied global RULES.yaml");
+				}
+			}
+			print.success("\nTemplates copied successfully!");
+		} catch (error) {
+			throw new Error(`Failed to copy templates: ${error.message}`);
+		}
+	}
+	/**
+	* Copy template files with MCP server filtering
+	* @param sourcePath - Source template path
+	* @param targetPath - Target template path
+	* @param selectedMcpServers - Selected MCP servers
+	*/
+	async copyTemplateWithMcpFilter(sourcePath, targetPath, selectedMcpServers) {
+		const { MCPServer: MCPServer$1, MCP_CONFIG_FILES: MCP_CONFIG_FILES$1 } = await import("./mcp-CZIiB-6Y.js");
+		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 });
+		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);
+			else if (hasArchitect && !hasScaffold) {
+				if (isArchitectFile) await fs.copy(entrySourcePath, entryTargetPath);
+			} else if (!hasArchitect && hasScaffold) {
+				if (!isArchitectFile) if (entry.isDirectory()) await fs.copy(entrySourcePath, entryTargetPath);
+				else await fs.copy(entrySourcePath, entryTargetPath);
+			}
+		}
+	}
+	/**
+	* Read template description from README or scaffold.yaml
+	* @param templatePath - Path to the template directory
+	* @returns Description string or undefined
+	*/
+	async readTemplateDescription(templatePath) {
+		try {
+			const scaffoldYamlPath = path.join(templatePath, "scaffold.yaml");
+			if (await fs.pathExists(scaffoldYamlPath)) {
+				const yaml = await import("js-yaml");
+				const content = await fs.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();
+			return;
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Get the tmp directory path
+	*/
+	getTmpDir() {
+		return this.tmpDir;
+	}
+	/**
+	* Clean up tmp directory
+	*/
+	async cleanup() {
+		try {
+			if (await fs.pathExists(this.tmpDir)) {
+				await fs.remove(this.tmpDir);
+				print.info("Cleaned up temporary files");
+			}
+		} catch (error) {
+			print.warning(`Warning: Failed to clean up tmp directory: ${error.message}`);
+		}
+	}
+};
+
+//#endregion
+//#region src/services/TemplatesService.ts
+var TemplatesService = class {
+	/**
+	* Download templates from a GitHub repository with UI feedback
+	* @param templatesPath - Local path where templates should be downloaded
+	* @param repoConfig - Repository configuration (owner, repo, branch, path)
+	*/
+	async downloadTemplates(templatesPath, repoConfig) {
+		print.info(`Fetching templates from ${repoConfig.owner}/${repoConfig.repo}...`);
+		try {
+			const templateDirs = (await fetchGitHubDirectoryContents(repoConfig.owner, repoConfig.repo, repoConfig.path, repoConfig.branch)).filter((item) => item.type === "dir");
+			if (templateDirs.length === 0) {
+				messages.warning("No templates found in repository");
+				return;
+			}
+			print.info(`Found ${templateDirs.length} template(s)`);
+			let downloaded = 0;
+			let skipped = 0;
+			for (const template of templateDirs) {
+				const targetFolder = path.join(templatesPath, template.name);
+				if (await fs.pathExists(targetFolder)) {
+					print.info(`Skipping ${template.name} (already exists)`);
+					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++;
+			}
+			print.success("\nAll templates downloaded successfully!");
+		} catch (error) {
+			throw new Error(`Failed to download templates: ${error.message}`);
+		}
+	}
+	/**
+	* Initialize templates folder with README
+	* @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
+
+This folder contains boilerplate templates and scaffolding methods for your projects.
+
+## Templates
+
+Templates are organized by framework/technology and include configuration files (\`scaffold.yaml\`) that define:
+- Boilerplates: Full project starter templates
+- Features: Code scaffolding methods for adding new features to existing projects
+
+## Adding More Templates
+
+Use the \`add\` command to add templates from remote repositories:
+
+\`\`\`bash
+scaffold-mcp add --name my-template --url https://github.com/user/template
+\`\`\`
+
+Or add templates from subdirectories:
+
+\`\`\`bash
+scaffold-mcp add --name nextjs-template --url https://github.com/user/repo/tree/main/templates/nextjs
+\`\`\`
+
+## Creating Custom Templates
+
+Each template should have a \`scaffold.yaml\` configuration file defining:
+- \`boilerplate\`: Array of boilerplate configurations
+- \`features\`: Array of feature scaffold configurations
+
+Template files use Liquid syntax for variable placeholders: \`{{ variableName }}\`
+
+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 };