task-engine-ai-core/scripts/init.js

Revolutionary AI-driven task management system with complete transformation trilogy: Frontend v0.1.0, Backend v0.2.0, CLI v0.3.0 - Enterprise-grade performance with 95% improvements

/**
 * Task Engine
 * Copyright (c) 2025 Eyal Toledano, Ralph Khreish
 *
 * This software is licensed under the MIT License with Commons Clause.
 * You may use this software for any purpose, including commercial applications,
 * and modify and redistribute it freely, subject to the following restrictions:
 *
 * 1. You may not sell this software or offer it as a service.
 * 2. The origin of this software must not be misrepresented.
 * 3. Altered source versions must be plainly marked as such.
 *
 * For the full license text, see the LICENSE file in the root directory.
 */

import fs from 'fs';
import path from 'path';
import readline from 'readline';
import { fileURLToPath } from 'url';
import { dirname } from 'path';
import chalk from 'chalk';
import figlet from 'figlet';
import boxen from 'boxen';
import gradient from 'gradient-string';
import { isSilentMode } from './modules/utils.js';
import { convertAllCursorRulesToRooRules } from './modules/rule-transformer.js';
import { execSync } from 'child_process';
import { getTaskMasterVersion } from '../src/utils/getVersion.js';
import {
	EXAMPLE_PRD_FILE,
	TASK_ENGINE_CONFIG_FILE,
	TASK_ENGINE_TEMPLATES_DIR,
	TASK_ENGINE_DIR,
	TASK_ENGINE_TASKS_DIR,
	TASK_ENGINE_DOCS_DIR,
	TASK_ENGINE_REPORTS_DIR,
	TASKMASTER_CONFIG_FILE,
	TASKMASTER_TEMPLATES_DIR,
	TASKMASTER_DIR,
	TASKMASTER_TASKS_DIR,
	TASKMASTER_DOCS_DIR,
	TASKMASTER_REPORTS_DIR,
	ENV_EXAMPLE_FILE,
	GITIGNORE_FILE
} from '../src/constants/paths.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);

// Define log levels
const LOG_LEVELS = {
	debug: 0,
	info: 1,
	warn: 2,
	error: 3,
	success: 4
};

// Determine log level from environment variable or default to 'info'
const LOG_LEVEL = process.env.TASKMASTER_LOG_LEVEL
	? LOG_LEVELS[process.env.TASKMASTER_LOG_LEVEL.toLowerCase()]
	: LOG_LEVELS.info; // Default to info

// Create a color gradient for the banner
const coolGradient = gradient(['#00b4d8', '#0077b6', '#03045e']);
const warmGradient = gradient(['#fb8b24', '#e36414', '#9a031e']);

// Display a fancy banner
function displayBanner() {
	if (isSilentMode()) return;

	console.clear();
	const bannerText = figlet.textSync('Task Engine', {
		font: 'Standard',
		horizontalLayout: 'default',
		verticalLayout: 'default'
	});

	console.log(coolGradient(bannerText));

	// Add creator credit line below the banner
	console.log(
		chalk.dim('by ') + chalk.cyan.underline('https://x.com/eyaltoledano')
	);

	console.log(
		boxen(chalk.white(`${chalk.bold('Initializing')} your new project`), {
			padding: 1,
			margin: { top: 0, bottom: 1 },
			borderStyle: 'round',
			borderColor: 'cyan'
		})
	);
}

// Logging function with icons and colors
function log(level, ...args) {
	const icons = {
		debug: chalk.gray('🔍'),
		info: chalk.blue('ℹ️'),
		warn: chalk.yellow('⚠️'),
		error: chalk.red('❌'),
		success: chalk.green('✅')
	};

	if (LOG_LEVELS[level] >= LOG_LEVEL) {
		const icon = icons[level] || '';

		// Only output to console if not in silent mode
		if (!isSilentMode()) {
			if (level === 'error') {
				console.error(icon, chalk.red(...args));
			} else if (level === 'warn') {
				console.warn(icon, chalk.yellow(...args));
			} else if (level === 'success') {
				console.log(icon, chalk.green(...args));
			} else if (level === 'info') {
				console.log(icon, chalk.blue(...args));
			} else {
				console.log(icon, ...args);
			}
		}
	}

	// Write to debug log if DEBUG=true
	if (process.env.DEBUG === 'true') {
		const logMessage = `[${level.toUpperCase()}] ${args.join(' ')}\n`;
		fs.appendFileSync('init-debug.log', logMessage);
	}
}

// Function to create directory if it doesn't exist
function ensureDirectoryExists(dirPath) {
	if (!fs.existsSync(dirPath)) {
		fs.mkdirSync(dirPath, { recursive: true });
		log('info', `Created directory: ${dirPath}`);
	}
}

// Function to add shell aliases to the user's shell configuration
function addShellAliases() {
	const homeDir = process.env.HOME || process.env.USERPROFILE;
	let shellConfigFile;

	// Determine which shell config file to use
	if (process.env.SHELL?.includes('zsh')) {
		shellConfigFile = path.join(homeDir, '.zshrc');
	} else if (process.env.SHELL?.includes('bash')) {
		shellConfigFile = path.join(homeDir, '.bashrc');
	} else {
		log('warn', 'Could not determine shell type. Aliases not added.');
		return false;
	}

	try {
		// Check if file exists
		if (!fs.existsSync(shellConfigFile)) {
			log(
				'warn',
				`Shell config file ${shellConfigFile} not found. Aliases not added.`
			);
			return false;
		}

		// Check if aliases already exist
		const configContent = fs.readFileSync(shellConfigFile, 'utf8');
		if (configContent.includes("alias tm='task-engine'")) {
			log('info', 'Task Engine aliases already exist in shell config.');
			return true;
		}

		// Add aliases to the shell config file
		const aliasBlock = `
# Task Engine aliases added on ${new Date().toLocaleDateString()}
alias tm='task-engine'
alias taskmaster='task-engine'
`;

		fs.appendFileSync(shellConfigFile, aliasBlock);
		log('success', `Added Task Engine aliases to ${shellConfigFile}`);
		log(
			'info',
			`To use the aliases in your current terminal, run: source ${shellConfigFile}`
		);

		return true;
	} catch (error) {
		log('error', `Failed to add aliases: ${error.message}`);
		return false;
	}
}

// Function to detect installation type
function detectInstallationType() {
	const scriptPath = __dirname;

	if (scriptPath.includes('node_modules')) {
		if (scriptPath.includes(path.join('node_modules', 'task-engine-ai-core'))) {
			return 'npm-local';
		}
		return 'npm-global';
	}

	if (fs.existsSync(path.join(__dirname, '..', '.git'))) {
		return 'development';
	}

	return 'unknown';
}

// Function to find the package root directory
function findPackageRoot() {
	const installType = detectInstallationType();
	log('debug', `Detected installation type: ${installType}`);

	// Try multiple strategies to find the package root
	const possibleRoots = [
		// Local development (current working directory)
		process.cwd(),
		// Script directory parent (local development)
		path.join(__dirname, '..'),
		// npm global install
		path.join(__dirname, '..', '..'),
		// npm local install in node_modules
		path.join(process.cwd(), 'node_modules', 'task-engine-ai-core'),
		// Alternative npm global paths
		path.join(process.env.NODE_PATH || '', 'task-engine-ai-core'),
		path.join(process.env.NPM_CONFIG_PREFIX || '', 'lib', 'node_modules', 'task-engine-ai-core'),
		// Windows npm global path
		path.join(process.env.APPDATA || '', 'npm', 'node_modules', 'task-engine-ai-core'),
		// Unix npm global path
		path.join('/usr', 'local', 'lib', 'node_modules', 'task-engine-ai-core')
	];

	// Prioritize based on installation type
	if (installType === 'development') {
		possibleRoots.unshift(path.join(__dirname, '..'));
	} else if (installType === 'npm-local') {
		possibleRoots.unshift(path.join(process.cwd(), 'node_modules', 'task-engine-ai-core'));
	}

	for (const root of possibleRoots) {
		if (root && fs.existsSync(path.join(root, 'package.json'))) {
			try {
				const packageJson = JSON.parse(fs.readFileSync(path.join(root, 'package.json'), 'utf8'));
				if (packageJson.name === 'task-engine-ai-core' || packageJson.name === 'task-engine') {
					log('debug', `Found package root at: ${root}`);
					return root;
				}
			} catch (error) {
				// Continue searching
			}
		}
	}

	// Fallback to script directory parent
	const fallback = path.join(__dirname, '..');
	log('warn', `Could not find package root, using fallback: ${fallback}`);
	return fallback;
}

// Function to copy a file from the package to the target directory
function copyTemplateFile(templateName, targetPath, replacements = {}) {
	const packageRoot = findPackageRoot();
	let sourcePath;

	// Map template names to their actual source paths
	switch (templateName) {
		case 'dev_workflow.mdc':
			sourcePath = path.join(packageRoot, '.cursor', 'rules', 'dev_workflow.mdc');
			break;
		case 'taskmaster.mdc':
			sourcePath = path.join(packageRoot, '.cursor', 'rules', 'taskmaster.mdc');
			break;
		case 'cursor_rules.mdc':
			sourcePath = path.join(packageRoot, '.cursor', 'rules', 'cursor_rules.mdc');
			break;
		case 'self_improve.mdc':
			sourcePath = path.join(packageRoot, '.cursor', 'rules', 'self_improve.mdc');
			break;
		case 'windsurfrules':
			sourcePath = path.join(packageRoot, 'assets', '.windsurfrules');
			break;
		case '.roomodes':
			sourcePath = path.join(packageRoot, 'assets', 'roocode', '.roomodes');
			break;
		case 'architect-rules':
		case 'ask-rules':
		case 'boomerang-rules':
		case 'code-rules':
		case 'debug-rules':
		case 'test-rules': {
			const mode = templateName.split('-')[0];
			sourcePath = path.join(packageRoot, 'assets', 'roocode', '.roo', `rules-${mode}`, templateName);
			break;
		}
		default:
			// For other files like env.example, gitignore, etc.
			sourcePath = path.join(packageRoot, 'assets', templateName);
	}

	// Check if the source file exists, with multiple fallback strategies
	if (!fs.existsSync(sourcePath)) {
		const fallbackPaths = [
			// Try assets directory in package root
			path.join(packageRoot, 'assets', templateName),
			// Try direct in package root
			path.join(packageRoot, templateName),
			// Try in scripts directory
			path.join(packageRoot, 'scripts', templateName),
			// Try in current working directory assets
			path.join(process.cwd(), 'assets', templateName),
			// Try relative to script location
			path.join(__dirname, '..', 'assets', templateName)
		];

		let found = false;
		for (const fallbackPath of fallbackPaths) {
			if (fs.existsSync(fallbackPath)) {
				sourcePath = fallbackPath;
				found = true;
				log('info', `Found template file at: ${fallbackPath}`);
				break;
			}
		}

		if (!found) {
			log('warn', `Template file '${templateName}' not found. Skipping...`);
			log('debug', `Searched paths: ${fallbackPaths.join(', ')}`);
			return;
		}
	}

	let content = fs.readFileSync(sourcePath, 'utf8');

	// Replace placeholders with actual values
	Object.entries(replacements).forEach(([key, value]) => {
		const regex = new RegExp(`\\{\\{${key}\\}\\}`, 'g');
		content = content.replace(regex, value);
	});

	// Handle special files that should be merged instead of overwritten
	if (fs.existsSync(targetPath)) {
		const filename = path.basename(targetPath);

		// Handle .gitignore - append lines that don't exist
		if (filename === '.gitignore') {
			log('info', `${targetPath} already exists, merging content...`);
			const existingContent = fs.readFileSync(targetPath, 'utf8');
			const existingLines = new Set(
				existingContent.split('\n').map((line) => line.trim())
			);
			const newLines = content
				.split('\n')
				.filter((line) => !existingLines.has(line.trim()));

			if (newLines.length > 0) {
				// Add a comment to separate the original content from our additions
				const updatedContent = `${existingContent.trim()}\n\n# Added by Task Master AI\n${newLines.join('\n')}`;
				fs.writeFileSync(targetPath, updatedContent);
				log('success', `Updated ${targetPath} with additional entries`);
			} else {
				log('info', `No new content to add to ${targetPath}`);
			}
			return;
		}

		// Handle .windsurfrules - append the entire content
		if (filename === '.windsurfrules') {
			log(
				'info',
				`${targetPath} already exists, appending content instead of overwriting...`
			);
			const existingContent = fs.readFileSync(targetPath, 'utf8');

			// Add a separator comment before appending our content
			const updatedContent = `${existingContent.trim()}\n\n# Added by Task Master - Development Workflow Rules\n\n${content}`;
			fs.writeFileSync(targetPath, updatedContent);
			log('success', `Updated ${targetPath} with additional rules`);
			return;
		}

		// Handle README.md - offer to preserve or create a different file
		if (filename === 'README-task-engine.md') {
			log('info', `${targetPath} already exists`);
			// Create a separate README file specifically for this project
			const taskMasterReadmePath = path.join(
				path.dirname(targetPath),
				'README-task-engine.md'
			);
			fs.writeFileSync(taskMasterReadmePath, content);
			log(
				'success',
				`Created ${taskMasterReadmePath} (preserved original README-task-engine.md)`
			);
			return;
		}

		// For other files, warn and prompt before overwriting
		log('warn', `${targetPath} already exists, skipping.`);
		return;
	}

	// If the file doesn't exist, create it normally
	fs.writeFileSync(targetPath, content);
	log('info', `Created file: ${targetPath}`);
}

// Main function to initialize a new project (No longer needs isInteractive logic)
async function initializeProject(options = {}) {
	// Receives options as argument
	// Only display banner if not in silent mode
	if (!isSilentMode()) {
		displayBanner();
	}

	// Debug logging only if not in silent mode
	// if (!isSilentMode()) {
	// 	console.log('===== DEBUG: INITIALIZE PROJECT OPTIONS RECEIVED =====');
	// 	console.log('Full options object:', JSON.stringify(options));
	// 	console.log('options.yes:', options.yes);
	// 	console.log('==================================================');
	// }

	const skipPrompts = options.yes || (options.name && options.description);

	// if (!isSilentMode()) {
	// 	console.log('Skip prompts determined:', skipPrompts);
	// }

	if (skipPrompts) {
		if (!isSilentMode()) {
			console.log('SKIPPING PROMPTS - Using defaults or provided values');
		}

		// Use provided options or defaults
		const projectName = options.name || 'task-engine-project';
		const projectDescription =
			options.description || 'A project managed with Task Engine AI';
		const projectVersion = options.version || '0.1.0';
		const authorName = options.author || 'Vibe coder';
		const dryRun = options.dryRun || false;
		const addAliases = options.aliases || false;

		if (dryRun) {
			log('info', 'DRY RUN MODE: No files will be modified');
			log('info', 'Would initialize Task Master project');
			log('info', 'Would create/update necessary project files');
			if (addAliases) {
				log('info', 'Would add shell aliases for task-engine');
			}
			return {
				dryRun: true
			};
		}

		createProjectStructure(addAliases, dryRun, options);
	} else {
		// Interactive logic
		log('info', 'Required options not provided, proceeding with prompts.');
		const rl = readline.createInterface({
			input: process.stdin,
			output: process.stdout
		});

		try {
			// Only prompt for shell aliases
			const addAliasesInput = await promptQuestion(
				rl,
				chalk.cyan(
					'Add shell aliases for task-engine? This lets you type "tm" instead of "task-engine" (Y/n): '
				)
			);
			const addAliasesPrompted = addAliasesInput.trim().toLowerCase() !== 'n';

			// Confirm settings...
			console.log('\nTask Master Project settings:');
			console.log(
				chalk.blue(
					'Add shell aliases (so you can use "tm" instead of "task-engine"):'
				),
				chalk.white(addAliasesPrompted ? 'Yes' : 'No')
			);

			const confirmInput = await promptQuestion(
				rl,
				chalk.yellow('\nDo you want to continue with these settings? (Y/n): ')
			);
			const shouldContinue = confirmInput.trim().toLowerCase() !== 'n';
			rl.close();

			if (!shouldContinue) {
				log('info', 'Project initialization cancelled by user');
				process.exit(0);
				return;
			}

			const dryRun = options.dryRun || false;

			if (dryRun) {
				log('info', 'DRY RUN MODE: No files will be modified');
				log('info', 'Would initialize Task Master project');
				log('info', 'Would create/update necessary project files');
				if (addAliasesPrompted) {
					log('info', 'Would add shell aliases for task-engine');
				}
				return {
					dryRun: true
				};
			}

			// Create structure using only necessary values
			createProjectStructure(addAliasesPrompted, dryRun, options);
		} catch (error) {
			rl.close();
			log('error', `Error during initialization process: ${error.message}`);
			process.exit(1);
		}
	}
}

// Helper function to promisify readline question
function promptQuestion(rl, question) {
	return new Promise((resolve) => {
		rl.question(question, (answer) => {
			resolve(answer);
		});
	});
}

// Function to create the project structure
function createProjectStructure(addAliases, dryRun, options) {
	const targetDir = process.cwd();
	log('info', `Initializing project in ${targetDir}`);

	// Define Roo modes locally (external integration, not part of core Task Engine)
	const ROO_MODES = ['architect', 'ask', 'boomerang', 'code', 'debug', 'test'];

	// Create directories
	ensureDirectoryExists(path.join(targetDir, '.cursor/rules'));

	// Create Roo directories
	ensureDirectoryExists(path.join(targetDir, '.roo'));
	ensureDirectoryExists(path.join(targetDir, '.roo/rules'));
	for (const mode of ROO_MODES) {
		ensureDirectoryExists(path.join(targetDir, '.roo', `rules-${mode}`));
	}

	// Create NEW .task-engine directory structure (using constants)
	ensureDirectoryExists(path.join(targetDir, TASK_ENGINE_DIR));
	ensureDirectoryExists(path.join(targetDir, TASK_ENGINE_TASKS_DIR));
	ensureDirectoryExists(path.join(targetDir, TASK_ENGINE_DOCS_DIR));
	ensureDirectoryExists(path.join(targetDir, TASK_ENGINE_REPORTS_DIR));
	ensureDirectoryExists(path.join(targetDir, TASK_ENGINE_TEMPLATES_DIR));

	// Setup MCP configuration for integration with Cursor
	setupMCPConfiguration(targetDir);

	// Copy template files with proper content
	log('info', 'Starting template file copying...');
	try {
		copyTemplateFiles(targetDir, options);
		log('info', 'Completed template file copying.');
	} catch (error) {
		log('error', `Error in copyTemplateFiles: ${error.message}`);
		log('error', `Stack trace: ${error.stack}`);
	}

	// Copy development workflow template files
	log('info', 'Copying development workflow template files...');
	copyTemplateFile('dev_workflow.mdc', path.join(targetDir, '.cursor', 'rules', 'dev_workflow.mdc'), {
		projectName: options.name || 'task-engine-project'
	});
	copyTemplateFile('cursor_rules.mdc', path.join(targetDir, '.cursor', 'rules', 'cursor_rules.mdc'), {
		projectName: options.name || 'task-engine-project'
	});
	copyTemplateFile('taskmaster.mdc', path.join(targetDir, '.cursor', 'rules', 'taskmaster.mdc'), {
		projectName: options.name || 'task-engine-project'
	});
	log('success', 'Development workflow files copied from templates');

	// Initialize git repository if git is available
	try {
		if (!fs.existsSync(path.join(targetDir, '.git'))) {
			log('info', 'Initializing git repository...');
			execSync('git init', { stdio: 'ignore' });
			log('success', 'Git repository initialized');
		}
	} catch (error) {
		log('warn', 'Git not available, skipping repository initialization');
	}

	// Run npm install automatically
	const npmInstallOptions = {
		cwd: targetDir,
		// Default to inherit for interactive CLI, change if silent
		stdio: 'inherit'
	};

	if (isSilentMode()) {
		// If silent (MCP mode), suppress npm install output
		npmInstallOptions.stdio = 'ignore';
		log('info', 'Running npm install silently...'); // Log our own message
	} else {
		// Interactive mode, show the boxen message
		console.log(
			boxen(chalk.cyan('Installing dependencies...'), {
				padding: 0.5,
				margin: 0.5,
				borderStyle: 'round',
				borderColor: 'blue'
			})
		);
	}

	// === Model Configuration Info ===
	if (!isSilentMode() && !dryRun) {
		log('info', 'AI models have been configured with default settings in .task-engine/config.json');
		log('info', 'You can modify the configuration file or use "task-engine models" commands to change settings');
	} else if (isSilentMode() && !dryRun) {
		log('info', 'AI models configured with defaults in silent (MCP) mode.');
		log(
			'info',
			'You can configure AI models using "task-engine models --set-..." or the "models" MCP tool.'
		);
	} else if (dryRun) {
		log('info', 'DRY RUN: AI models would be configured with defaults.');
	}
	// ====================================

	// Display success message
	if (!isSilentMode()) {
		console.log(
			boxen(
				`${warmGradient.multiline(
					figlet.textSync('Success!', { font: 'Standard' })
				)}\n${chalk.green('Project initialized successfully!')}`,
				{
					padding: 1,
					margin: 1,
					borderStyle: 'double',
					borderColor: 'green'
				}
			)
		);
	}

	// Display next steps in a nice box
	if (!isSilentMode()) {
		console.log(
			boxen(
				`${chalk.cyan.bold('Things you should do next:')}\n\n${chalk.white('1. ')}${chalk.yellow(
					'Configure AI models (if needed) and add API keys to `.env`'
				)}\n${chalk.white('   ├─ ')}${chalk.dim('Models: Use `task-engine models` commands')}\n${chalk.white('   └─ ')}${chalk.dim(
					'Keys: Add provider API keys to .env (or inside the MCP config file i.e. .cursor/mcp.json)'
				)}\n${chalk.white('2. ')}${chalk.yellow(
					'Edit your PRD template in .task-engine/docs/prd.txt with your project requirements'
				)}\n${chalk.white('3. ')}${chalk.yellow(
					'Ask Cursor Agent (or run CLI) to parse your PRD and generate initial tasks:'
				)}\n${chalk.white('   └─ ')}${chalk.dim('MCP Tool: ')}${chalk.cyan('parse_prd')}${chalk.dim(' | CLI: ')}${chalk.cyan('task-engine parse-prd --input=.task-engine/docs/prd.txt')}\n${chalk.white('4. ')}${chalk.yellow(
					'Ask Cursor to analyze the complexity of the tasks in your PRD using research'
				)}\n${chalk.white('   └─ ')}${chalk.dim('MCP Tool: ')}${chalk.cyan('analyze_project_complexity')}${chalk.dim(' | CLI: ')}${chalk.cyan('task-engine analyze-complexity')}\n${chalk.white('5. ')}${chalk.yellow(
					'Ask Cursor to expand all of your tasks using the complexity analysis'
				)}\n${chalk.white('6. ')}${chalk.yellow('Ask Cursor to begin working on the next task')}\n${chalk.white('7. ')}${chalk.yellow(
					'Add new tasks anytime using the add-task command or MCP tool'
				)}\n${chalk.white('8. ')}${chalk.yellow(
					'Ask Cursor to set the status of one or many tasks/subtasks at a time. Use the task id from the task lists.'
				)}\n${chalk.white('9. ')}${chalk.yellow(
					'Ask Cursor to update all tasks from a specific task id based on new learnings or pivots in your project.'
				)}\n${chalk.white('10. ')}${chalk.green.bold('Ship it!')}\n\n${chalk.dim(
					'* Review the README.md file to learn how to use other commands via Cursor Agent.'
				)}\n${chalk.dim(
					'* Use the task-engine command without arguments to see all available commands.'
				)}`,
				{
					padding: 1,
					margin: 1,
					borderStyle: 'round',
					borderColor: 'yellow',
					title: 'Getting Started',
					titleAlignment: 'center'
				}
			)
		);
	}
}

// Function to copy all template files with proper content
function copyTemplateFiles(targetDir, options = {}) {
	log('info', 'Inside copyTemplateFiles function');
	const projectName = options.name || 'task-engine-project';
	const projectDescription = options.description || 'A project managed with Task Engine AI';
	const authorName = options.author || 'Developer';
	const currentDate = new Date().toISOString();
	const currentDateFormatted = new Date().toLocaleDateString();
	const taskEngineVersion = getTaskMasterVersion();
	const projectNameLower = projectName.toLowerCase().replace(/\s+/g, '-');

	log('info', `Project details: ${projectName}, ${projectDescription}`);

	// Prepare replacement variables
	const replacements = {
		projectName,
		projectDescription,
		authorName,
		currentDate,
		currentDateFormatted,
		taskEngineVersion,
		projectNameLower
	};

	// 1. Copy tasks.json template
	const tasksJsonPath = path.join(targetDir, TASK_ENGINE_TASKS_DIR, 'tasks.json');
	if (!fs.existsSync(tasksJsonPath)) {
		copyTemplateFile('tasks.json', tasksJsonPath, replacements);
		log('success', `Created tasks.json from template`);
	}

	// 2. Copy config.json template
	const configJsonPath = path.join(targetDir, TASK_ENGINE_DIR, 'config.json');
	if (!fs.existsSync(configJsonPath)) {
		copyTemplateFile('config.json', configJsonPath, replacements);
		log('success', `Created config.json from template`);
	}

	// 3. Copy project README.md template
	const docsReadmePath = path.join(targetDir, TASK_ENGINE_DOCS_DIR, 'README.md');
	if (!fs.existsSync(docsReadmePath)) {
		copyTemplateFile('project-readme.md', docsReadmePath, replacements);
		log('success', `Created project README.md from template`);
	}

	// 4. Copy PRD template
	const prdPath = path.join(targetDir, TASK_ENGINE_DOCS_DIR, 'prd.txt');
	if (!fs.existsSync(prdPath)) {
		copyTemplateFile('prd-template.txt', prdPath, replacements);
		log('success', `Created PRD template from template file`);
	}

	// 5. Copy .env.example template
	const envExamplePath = path.join(targetDir, '.env.example');
	if (!fs.existsSync(envExamplePath)) {
		copyTemplateFile('env-enhanced.example', envExamplePath, replacements);
		log('success', `Created .env.example from template`);
	}

	// 6. Copy .gitignore template
	const gitignorePath = path.join(targetDir, '.gitignore');
	if (!fs.existsSync(gitignorePath)) {
		copyTemplateFile('gitignore-enhanced', gitignorePath, replacements);
		log('success', `Created .gitignore from template`);
	}

	// 7. Copy architecture.md template
	const architecturePath = path.join(targetDir, TASK_ENGINE_DOCS_DIR, 'architecture.md');
	if (!fs.existsSync(architecturePath)) {
		copyTemplateFile('architecture-template.md', architecturePath, replacements);
		log('success', `Created architecture.md from template`);
	}

	// 8. Copy API documentation template
	const apiDocsPath = path.join(targetDir, TASK_ENGINE_DOCS_DIR, 'api-documentation.md');
	if (!fs.existsSync(apiDocsPath)) {
		copyTemplateFile('api-documentation-template.md', apiDocsPath, replacements);
		log('success', `Created api-documentation.md from template`);
	}

	log('success', `Generated complete project structure with ${projectName} using templates`);
}







// Function to setup MCP configuration for Cursor integration
function setupMCPConfiguration(targetDir) {
	const mcpDirPath = path.join(targetDir, '.cursor');
	const mcpJsonPath = path.join(mcpDirPath, 'mcp.json');
	const installType = detectInstallationType();
	const packageRoot = findPackageRoot();

	log('info', 'Setting up MCP configuration for Cursor integration...');

	// Create .cursor directory if it doesn't exist
	ensureDirectoryExists(mcpDirPath);

	// Configure MCP server based on installation type
	let mcpServerConfig;

	if (installType === 'development') {
		// For development, use the local server file
		const serverPath = path.join(packageRoot, 'mcp-server', 'server.js');
		if (fs.existsSync(serverPath)) {
			mcpServerConfig = {
				command: 'node',
				args: [serverPath],
				env: {
					ANTHROPIC_API_KEY: 'ANTHROPIC_API_KEY_HERE',
					PERPLEXITY_API_KEY: 'PERPLEXITY_API_KEY_HERE',
					OPENAI_API_KEY: 'OPENAI_API_KEY_HERE',
					GOOGLE_API_KEY: 'GOOGLE_API_KEY_HERE',
					XAI_API_KEY: 'XAI_API_KEY_HERE',
					OPENROUTER_API_KEY: 'OPENROUTER_API_KEY_HERE',
					MISTRAL_API_KEY: 'MISTRAL_API_KEY_HERE',
					AZURE_OPENAI_API_KEY: 'AZURE_OPENAI_API_KEY_HERE',
					OLLAMA_API_KEY: 'OLLAMA_API_KEY_HERE'
				}
			};
			log('info', 'Using development MCP server configuration');
		} else {
			// Fallback to npx for development if server.js not found
			mcpServerConfig = {
				command: 'npx',
				args: ['-y', '--package=task-engine-ai-core', 'task-engine-ai'],
				env: {
					ANTHROPIC_API_KEY: 'ANTHROPIC_API_KEY_HERE',
					PERPLEXITY_API_KEY: 'PERPLEXITY_API_KEY_HERE',
					OPENAI_API_KEY: 'OPENAI_API_KEY_HERE',
					GOOGLE_API_KEY: 'GOOGLE_API_KEY_HERE',
					XAI_API_KEY: 'XAI_API_KEY_HERE',
					OPENROUTER_API_KEY: 'OPENROUTER_API_KEY_HERE',
					MISTRAL_API_KEY: 'MISTRAL_API_KEY_HERE',
					AZURE_OPENAI_API_KEY: 'AZURE_OPENAI_API_KEY_HERE',
					OLLAMA_API_KEY: 'OLLAMA_API_KEY_HERE'
				}
			};
			log('warn', 'Development server.js not found, using npx fallback');
		}
	} else {
		// For npm installs (local or global), use npx
		mcpServerConfig = {
			command: 'npx',
			args: ['-y', '--package=task-engine-ai-core', 'task-engine-ai'],
			env: {
				ANTHROPIC_API_KEY: 'ANTHROPIC_API_KEY_HERE',
				PERPLEXITY_API_KEY: 'PERPLEXITY_API_KEY_HERE',
				OPENAI_API_KEY: 'OPENAI_API_KEY_HERE',
				GOOGLE_API_KEY: 'GOOGLE_API_KEY_HERE',
				XAI_API_KEY: 'XAI_API_KEY_HERE',
				OPENROUTER_API_KEY: 'OPENROUTER_API_KEY_HERE',
				MISTRAL_API_KEY: 'MISTRAL_API_KEY_HERE',
				AZURE_OPENAI_API_KEY: 'AZURE_OPENAI_API_KEY_HERE',
				OLLAMA_API_KEY: 'OLLAMA_API_KEY_HERE'
			}
		};
		log('info', 'Using npm package MCP server configuration');
	}

	const newMCPServer = {
		'task-engine-ai-core': mcpServerConfig
	};

	// Check if mcp.json already existsimage.png
	if (fs.existsSync(mcpJsonPath)) {
		log(
			'info',
			'MCP configuration file already exists, checking for existing task-engine-ai-core...'
		);
		try {
			// Read existing config
			const mcpConfig = JSON.parse(fs.readFileSync(mcpJsonPath, 'utf8'));

			// Initialize mcpServers if it doesn't exist
			if (!mcpConfig.mcpServers) {
				mcpConfig.mcpServers = {};
			}

			// Check if any existing server configuration already has task-engine-ai-core in its args
			const hasMCPString = Object.values(mcpConfig.mcpServers).some(
				(server) =>
					server.args &&
					server.args.some(
						(arg) => typeof arg === 'string' && arg.includes('task-engine-ai-core')
					)
			);

			if (hasMCPString) {
				log(
					'info',
					'Found existing task-engine-ai-core MCP configuration in mcp.json, leaving untouched'
				);
				return; // Exit early, don't modify the existing configuration
			}

			// Add the task-engine-ai-core server if it doesn't exist
			if (!mcpConfig.mcpServers['task-engine-ai-core']) {
				mcpConfig.mcpServers['task-engine-ai-core'] = newMCPServer['task-engine-ai-core'];
				log(
					'info',
					'Added task-engine-ai-core server to existing MCP configuration'
				);
			} else {
				log('info', 'task-engine-ai-core server already configured in mcp.json');
			}

			// Write the updated configuration
			fs.writeFileSync(mcpJsonPath, JSON.stringify(mcpConfig, null, 4));
			log('success', 'Updated MCP configuration file');
		} catch (error) {
			log('error', `Failed to update MCP configuration: ${error.message}`);
			// Create a backup before potentially modifying
			const backupPath = `${mcpJsonPath}.backup-${Date.now()}`;
			if (fs.existsSync(mcpJsonPath)) {
				fs.copyFileSync(mcpJsonPath, backupPath);
				log('info', `Created backup of existing mcp.json at ${backupPath}`);
			}

			// Create new configuration
			const newMCPConfig = {
				mcpServers: newMCPServer
			};

			fs.writeFileSync(mcpJsonPath, JSON.stringify(newMCPConfig, null, 4));
			log(
				'warn',
				'Created new MCP configuration file (backup of original file was created if it existed)'
			);
		}
	} else {
		// If mcp.json doesn't exist, create it
		const newMCPConfig = {
			mcpServers: newMCPServer
		};

		fs.writeFileSync(mcpJsonPath, JSON.stringify(newMCPConfig, null, 4));
		log('success', 'Created MCP configuration file for Cursor integration');
	}

	// Add note to console about MCP integration
	log('info', 'MCP server will use the installed task-engine-ai-core package');
}

// Ensure necessary functions are exported
export { initializeProject, log }; // Only export what's needed by commands.js