@bhimudev/gnanai 0.4.0

package/dist/commands/init.js

@@ -0,0 +1,711 @@
+import inquirer from 'inquirer';
+import chalk from 'chalk';
+import ora from 'ora';
+import fs from 'fs-extra';
+import path from 'path';
+import { scaffoldProject } from '../scaffold/create-structure.js';
+import { copyCoreAgents } from '../scaffold/copy-core-agents.js';
+import { createConfigTemplate } from '../scaffold/create-config.js';
+import { createProjectDescription } from '../scaffold/create-project-description.js';
+import { createClaudeSettings } from '../scaffold/create-claude-settings.js';
+import { detectProject } from '../utils/detect-project.js';
+import { logger } from '../utils/logger.js';
+import { createBackup, pruneOldBackups } from '../utils/backup.js';
+import { loadVersionFile, saveVersionFile, createVersionFile, bulkUpdateFileHashes, } from '../utils/version-tracker.js';
+import { detectLegacyInstall, hasExistingInstall, migrateFromLegacy, getArchaiVersion, getTemplateFiles, getTemplatesDir, } from '../utils/migration.js';
+import { hashFile, } from '../utils/file-comparison.js';
+import { mergeFile, applyMerge, } from '../utils/file-merger.js';
+import { analyzeAllFiles } from '../utils/analyze-files.js';
+import { setup } from './setup.js';
+const PROJECT_TYPES = [
+    { name: 'Web Application (frontend/backend/fullstack)', value: 'web' },
+    { name: 'Mobile Application', value: 'mobile' },
+    { name: 'CLI Tool / Library', value: 'cli' },
+    { name: 'Game', value: 'game' },
+    { name: 'Data Science / ML', value: 'ml' },
+    { name: 'DevOps / Infrastructure', value: 'devops' },
+    { name: 'Other', value: 'other' },
+];
+const CLAUDE_DIR = '.claude';
+// Folders that will be created by scaffoldProject
+const FOLDERS = [
+    '.claude/agents',
+    '.claude/state',
+    '.claude/state/archived',
+    '.claude/plans',
+    '.claude/plans/archived',
+    '.claude/templates',
+    '.knowledge/context',
+    '.knowledge/decisions',
+    '.knowledge/learnings',
+    '.knowledge/planning',
+    '.knowledge/status',
+    '.tasks/inbox',
+    '.tasks/done',
+    '.tasks/epics',
+    '.tasks/review',
+    '.tasks/blocked',
+    '.tasks/templates',
+    '.supervisor',
+    '.agents/plans',
+    '.agents/scratch',
+    '.agents/thoughts',
+];
+export async function init(options) {
+    logger.banner();
+    const archaiVersion = await getArchaiVersion();
+    const existingInstall = await hasExistingInstall(CLAUDE_DIR);
+    const isLegacy = await detectLegacyInstall(CLAUDE_DIR);
+    // Handle existing installation
+    if (existingInstall && !options.force) {
+        // Check if we can do a smart update instead of failing
+        if (isLegacy) {
+            logger.info('Found existing archai installation (pre-0.2.0).');
+            logger.info('Running migration to enable smart updates...');
+            console.log('');
+            const migration = await migrateFromLegacy(CLAUDE_DIR, archaiVersion);
+            if (!migration.success) {
+                logger.error(`Migration failed: ${migration.error}`);
+                return;
+            }
+            if (migration.warnings.length > 0) {
+                for (const warning of migration.warnings) {
+                    logger.warn(warning);
+                }
+            }
+            logger.success('Migration complete!');
+            logger.info('Your files have been analyzed. Run "archai update" to check for updates.');
+            return;
+        }
+        // Already has version.json - suggest using update command
+        logger.warn('archai is already initialized in this directory.');
+        logger.info('To update archai, run: archai update');
+        logger.info('To reinitialize from scratch, use: archai init --force');
+        return;
+    }
+    // --force mode with existing installation: do smart comparison
+    if (existingInstall && options.force) {
+        await handleForceInit(options, archaiVersion);
+        return;
+    }
+    // Fresh installation
+    await handleFreshInit(options, archaiVersion);
+}
+/**
+ * Handle --force init on existing installation.
+ * Creates backup, compares files, and updates intelligently.
+ */
+async function handleForceInit(options, archaiVersion) {
+    // First, ensure we have version.json (migrate if needed)
+    const isLegacy = await detectLegacyInstall(CLAUDE_DIR);
+    if (isLegacy) {
+        const migration = await migrateFromLegacy(CLAUDE_DIR, archaiVersion);
+        if (!migration.success) {
+            logger.error(`Migration failed: ${migration.error}`);
+            return;
+        }
+    }
+    // Create backup before any changes
+    logger.info('Creating backup...');
+    const backup = await createBackup(CLAUDE_DIR, 'pre-force-init', archaiVersion);
+    if (!backup.success) {
+        logger.error(`Backup failed: ${backup.error}`);
+        logger.info('Aborting to prevent data loss. Fix the issue and try again.');
+        return;
+    }
+    logger.success(`Backup created: ${backup.timestamp}`);
+    // Prune old backups
+    await pruneOldBackups(CLAUDE_DIR, 5);
+    // Analyze all files
+    console.log('');
+    const analysisSpinner = ora('Analyzing files...').start();
+    const analyses = await analyzeAllFiles(CLAUDE_DIR);
+    analysisSpinner.succeed(`Analyzed ${analyses.length} files`);
+    // Categorize files
+    const newFiles = analyses.filter(a => a.status === 'new');
+    const unchanged = analyses.filter(a => a.status === 'unchanged');
+    const modifiedByArchai = analyses.filter(a => a.status === 'modified_by_archai');
+    const modifiedByUser = analyses.filter(a => a.status === 'modified_by_user');
+    const conflicts = analyses.filter(a => a.status === 'conflict');
+    // Show summary
+    console.log('');
+    logger.section('File Analysis');
+    console.log('');
+    if (newFiles.length > 0)
+        console.log(chalk.green(`  New files: ${newFiles.length}`));
+    if (unchanged.length > 0)
+        console.log(chalk.gray(`  Unchanged: ${unchanged.length}`));
+    if (modifiedByArchai.length > 0)
+        console.log(chalk.cyan(`  Updated by archai: ${modifiedByArchai.length}`));
+    if (modifiedByUser.length > 0)
+        console.log(chalk.yellow(`  Modified by you: ${modifiedByUser.length}`));
+    if (conflicts.length > 0)
+        console.log(chalk.red(`  Conflicts: ${conflicts.length}`));
+    console.log('');
+    // Handle dry run
+    if (options.dryRun) {
+        await showDryRunSummary(analyses);
+        return;
+    }
+    // Handle files that need attention
+    const needsAttention = [...modifiedByUser, ...conflicts.filter(c => !c.canAutoMerge)];
+    if (needsAttention.length > 0 && !options.yes) {
+        // Interactive mode - ask user about each file
+        await handleConflictsInteractively(needsAttention);
+    }
+    else if (needsAttention.length > 0 && options.yes) {
+        // Non-interactive mode - skip user-modified files
+        logger.warn(`Skipping ${needsAttention.length} user-modified files (use interactive mode to resolve).`);
+    }
+    // Apply changes
+    await applyFileChanges(analyses, options, archaiVersion);
+}
+/**
+ * Handle fresh installation (no existing .claude directory).
+ */
+async function handleFreshInit(options, archaiVersion) {
+    // Detect project info
+    const spinner = ora('Detecting project information...').start();
+    const detected = await detectProject();
+    spinner.succeed('Project detected');
+    if (detected.languages.length > 0) {
+        logger.info(`Found: ${detected.languages.join(', ')}`);
+    }
+    let answers;
+    if (options.skipWizard || options.yes) {
+        // Non-interactive mode
+        answers = {
+            projectName: detected.name || 'my-project',
+            projectType: detected.languages.length > 0 ? 'web' : '',
+            isMonorepo: detected.isMonorepo,
+            permissionPreset: 'permissive',
+        };
+    }
+    else {
+        // Interactive wizard
+        answers = await runWizard(detected);
+    }
+    // Dry run mode
+    if (options.dryRun) {
+        showFreshDryRun(answers);
+        return;
+    }
+    // Initialize rollback context
+    const rollback = {
+        createdPaths: [],
+        modifiedFiles: new Map(),
+    };
+    try {
+        console.log('');
+        logger.section('Creating Agent System');
+        console.log('');
+        // Backup .gitignore if exists
+        if (await fs.pathExists('.gitignore')) {
+            const content = await fs.readFile('.gitignore', 'utf-8');
+            rollback.modifiedFiles.set('.gitignore', content);
+        }
+        // Create folder structure
+        const structureSpinner = ora('Creating folder structure...').start();
+        await scaffoldProject();
+        rollback.createdPaths.push(...FOLDERS.filter(f => !f.includes('/archived')));
+        structureSpinner.succeed('Created folder structure');
+        // Copy core agents
+        const agentsSpinner = ora('Installing core agents (14 agents)...').start();
+        await copyCoreAgents();
+        agentsSpinner.succeed('Installed core agents');
+        // Create config template — merge detected info with wizard answers
+        const configSpinner = ora('Creating configuration template...').start();
+        await createConfigTemplate({
+            projectName: answers.projectName,
+            projectType: answers.projectType,
+            isMonorepo: answers.isMonorepo,
+            languages: detected.languages.length > 0 ? detected.languages.join(', ') : undefined,
+            frameworks: detected.frameworks?.length > 0 ? detected.frameworks.join(', ') : undefined,
+            testFramework: detected.testFramework || undefined,
+            packageManager: detected.packageManager || undefined,
+            platform: detected.platform,
+            shell: detected.shell,
+        });
+        rollback.createdPaths.push('archai.config.md');
+        configSpinner.succeed('Created archai.config.md');
+        // Create CLAUDE.md (root-level agent guidelines)
+        const claudeMdSpinner = ora('Creating CLAUDE.md...').start();
+        await copyClaudeMd();
+        rollback.createdPaths.push('CLAUDE.md');
+        claudeMdSpinner.succeed('Created CLAUDE.md');
+        // Create project description template
+        const descSpinner = ora('Creating project description template...').start();
+        await createProjectDescription(answers);
+        descSpinner.succeed('Created project-description.md');
+        // Create permission settings
+        const packageManager = detected.packageManager || 'npm';
+        if (answers.permissionPreset !== 'skip') {
+            const permSpinner = ora('Creating permission settings...').start();
+            await createClaudeSettings({
+                preset: answers.permissionPreset,
+                packageManager,
+                customAllowCommands: answers.customAllowCommands,
+                customDenyCommands: answers.customDenyCommands,
+            });
+            rollback.createdPaths.push('.claude/settings.local.json');
+            const presetLabel = answers.permissionPreset.charAt(0).toUpperCase() + answers.permissionPreset.slice(1);
+            permSpinner.succeed(`Created .claude/settings.local.json (${presetLabel} mode)`);
+        }
+        else {
+            logger.info('Skipped permission settings (configure manually later)');
+        }
+        // Create version.json
+        const versionSpinner = ora('Creating version tracking...').start();
+        await createVersionTracking(archaiVersion);
+        versionSpinner.succeed('Created version.json');
+        // Final output
+        showSuccessMessage();
+        // Offer to run environment setup
+        await offerSetup(options);
+    }
+    catch (error) {
+        logger.error('Initialization failed. Rolling back changes...');
+        await performRollback(rollback);
+        const errorMessage = error instanceof Error ? error.message : 'Unknown error';
+        logger.debug('Init failed', { error: errorMessage });
+        throw error;
+    }
+}
+/**
+ * Offer to run environment setup after init completes.
+ */
+async function offerSetup(options) {
+    if (options.yes || options.skipWizard) {
+        // Non-interactive mode - auto-run setup with --yes
+        await setup({ yes: true });
+        return;
+    }
+    // Interactive mode - ask user
+    const { runSetup } = await inquirer.prompt([{
+            type: 'list',
+            name: 'runSetup',
+            message: 'Would you like to auto-configure environment integrations? (Git, MCP servers)',
+            choices: [
+                { name: 'Yes - run setup now', value: true },
+                { name: 'Skip - run archai setup later', value: false },
+            ],
+            default: true,
+        }]);
+    if (runSetup) {
+        await setup({});
+    }
+    else {
+        console.log('');
+        logger.info('You can run environment setup later with: archai setup');
+        console.log('');
+    }
+}
+/**
+ * Run the interactive wizard.
+ */
+async function runWizard(detected) {
+    console.log('');
+    logger.section('Project Setup');
+    console.log(chalk.gray('   (Press Enter to skip questions you\'re unsure about)'));
+    console.log('');
+    const mainAnswers = await inquirer.prompt([
+        {
+            type: 'input',
+            name: 'projectName',
+            message: '1. Project name:',
+            default: detected.name || 'my-project',
+        },
+        {
+            type: 'list',
+            name: 'projectType',
+            message: '2. What type of project is this?',
+            choices: [...PROJECT_TYPES, { name: 'Skip (decide later)', value: '' }],
+        },
+        {
+            type: 'confirm',
+            name: 'isMonorepo',
+            message: '3. Do you use a monorepo structure?',
+            default: detected.isMonorepo,
+        },
+    ]);
+    // Permission preset section
+    console.log('');
+    logger.section('Permissions');
+    console.log(chalk.gray('   Configure what commands Claude agents can execute.'));
+    console.log('');
+    const { permissionPreset } = await inquirer.prompt([{
+            type: 'list',
+            name: 'permissionPreset',
+            message: '4. Permission level:',
+            choices: [
+                { name: `${chalk.green('Permissive')} - Everything except irreversible actions`, value: 'permissive' },
+                { name: `${chalk.yellow('Strict')} - Only safe operations (no network, no push)`, value: 'strict' },
+                { name: `${chalk.cyan('Custom')} - Define your own commands`, value: 'custom' },
+                { name: `${chalk.gray('Skip')} - Configure manually later`, value: 'skip' },
+            ],
+            default: 'permissive',
+        }]);
+    let customAllowCommands;
+    let customDenyCommands;
+    if (permissionPreset === 'custom') {
+        console.log('');
+        console.log(chalk.gray('   Enter commands separated by commas. Use * as wildcard.'));
+        console.log(chalk.gray('   Example: npm *, git status*, tsc'));
+        console.log('');
+        const customAnswers = await inquirer.prompt([
+            {
+                type: 'input',
+                name: 'allowCommands',
+                message: 'Allowed commands:',
+                default: `${detected.packageManager || 'npm'} *, git status*, git diff*, git log*`,
+            },
+            {
+                type: 'input',
+                name: 'denyCommands',
+                message: 'Additional denied commands (dangerous ones are always blocked):',
+                default: '',
+            },
+        ]);
+        customAllowCommands = customAnswers.allowCommands
+            .split(',')
+            .map((c) => c.trim())
+            .filter((c) => c);
+        customDenyCommands = customAnswers.denyCommands
+            .split(',')
+            .map((c) => c.trim())
+            .filter((c) => c);
+    }
+    return {
+        ...mainAnswers,
+        permissionPreset,
+        customAllowCommands,
+        customDenyCommands,
+    };
+}
+/**
+ * Show dry run summary.
+ */
+async function showDryRunSummary(analyses) {
+    console.log('');
+    logger.section('Would Process');
+    console.log('');
+    const newFiles = analyses.filter(a => a.status === 'new');
+    const updates = analyses.filter(a => a.status === 'modified_by_archai');
+    const userModified = analyses.filter(a => a.status === 'modified_by_user');
+    const conflicts = analyses.filter(a => a.status === 'conflict');
+    if (newFiles.length > 0) {
+        console.log(chalk.green('  New files:'));
+        newFiles.forEach(f => console.log(chalk.gray(`    + ${f.path}`)));
+        console.log('');
+    }
+    if (updates.length > 0) {
+        console.log(chalk.cyan('  Would update:'));
+        updates.forEach(f => console.log(chalk.gray(`    ~ ${f.path}`)));
+        console.log('');
+    }
+    if (userModified.length > 0) {
+        console.log(chalk.yellow('  User-modified (would skip):'));
+        userModified.forEach(f => console.log(chalk.gray(`    ! ${f.path}`)));
+        console.log('');
+    }
+    if (conflicts.length > 0) {
+        console.log(chalk.red('  Conflicts (would need resolution):'));
+        conflicts.forEach(f => {
+            const auto = f.canAutoMerge ? chalk.gray(' (can auto-merge)') : '';
+            console.log(chalk.gray(`    ⚠ ${f.path}${auto}`));
+        });
+        console.log('');
+    }
+    logger.info('Dry run complete. No files were modified.');
+}
+/**
+ * Show dry run for fresh install.
+ */
+function showFreshDryRun(answers) {
+    console.log('');
+    logger.section('Would Create');
+    console.log('');
+    console.log(chalk.cyan('  Directories:'));
+    FOLDERS.forEach(f => console.log(chalk.gray(`    ${f}`)));
+    console.log('');
+    console.log(chalk.cyan('  Files:'));
+    console.log(chalk.gray('    .claude/agents/*.md (14 core agents)'));
+    console.log(chalk.gray('    .claude/version.json'));
+    console.log(chalk.gray('    CLAUDE.md'));
+    console.log(chalk.gray('    archai.config.md'));
+    console.log(chalk.gray('    .knowledge/context/project-description.md'));
+    console.log(chalk.gray('    PROMPTS.md'));
+    console.log(chalk.gray('    ARCHAI_README.md'));
+    if (answers.permissionPreset !== 'skip') {
+        console.log(chalk.gray('    .claude/settings.local.json'));
+    }
+    console.log('');
+    console.log(chalk.cyan('  Modifications:'));
+    console.log(chalk.gray('    .gitignore (append archai entries)'));
+    console.log('');
+    logger.info('Dry run complete. No files were created.');
+}
+/**
+ * Handle conflicts interactively.
+ */
+async function handleConflictsInteractively(files) {
+    console.log('');
+    logger.section('Files Requiring Attention');
+    console.log('');
+    for (const file of files) {
+        console.log(chalk.yellow(`  ${file.path}`));
+        console.log(chalk.gray(`    Status: ${file.status}`));
+        const { action } = await inquirer.prompt([{
+                type: 'list',
+                name: 'action',
+                message: `What would you like to do with ${file.path}?`,
+                choices: [
+                    { name: 'Keep my version', value: 'keep' },
+                    { name: 'Use new template', value: 'overwrite' },
+                    { name: 'Try to merge', value: 'merge' },
+                    { name: 'Skip', value: 'skip' },
+                ],
+            }]);
+        // Store the decision for later processing
+        file.userAction = action;
+        console.log('');
+    }
+}
+/**
+ * Apply file changes based on analysis.
+ */
+async function applyFileChanges(analyses, options, archaiVersion) {
+    const spinner = ora('Applying changes...').start();
+    let applied = 0;
+    let skipped = 0;
+    const templates = await getTemplateFiles();
+    const templateMap = new Map(templates.map(t => [t.relativePath, t]));
+    for (const analysis of analyses) {
+        const template = templateMap.get(analysis.path);
+        if (!template)
+            continue;
+        const localPath = analysis.path;
+        try {
+            // Handle based on status
+            switch (analysis.status) {
+                case 'new':
+                    // Copy new file from template
+                    await fs.ensureDir(path.dirname(localPath));
+                    await fs.copy(template.templatePath, localPath);
+                    applied++;
+                    break;
+                case 'modified_by_archai':
+                    // Update from template (user hasn't modified)
+                    await fs.copy(template.templatePath, localPath, { overwrite: true });
+                    applied++;
+                    break;
+                case 'conflict':
+                    if (analysis.canAutoMerge) {
+                        // Try auto-merge
+                        const result = await mergeFile(localPath, template.templatePath);
+                        if (result.success) {
+                            await applyMerge(localPath, result);
+                            applied++;
+                        }
+                        else {
+                            skipped++;
+                        }
+                    }
+                    else {
+                        const conflictAction = analysis.userAction;
+                        if (conflictAction === 'overwrite') {
+                            await fs.copy(template.templatePath, localPath, { overwrite: true });
+                            applied++;
+                        }
+                        else if (conflictAction === 'merge') {
+                            const result = await mergeFile(localPath, template.templatePath);
+                            if (result.success) {
+                                await applyMerge(localPath, result);
+                                applied++;
+                            }
+                            else {
+                                skipped++;
+                            }
+                        }
+                        else {
+                            skipped++;
+                        }
+                    }
+                    break;
+                case 'modified_by_user':
+                    // Skip unless user specified action
+                    const action = analysis.userAction;
+                    if (action === 'overwrite') {
+                        await fs.copy(template.templatePath, localPath, { overwrite: true });
+                        applied++;
+                    }
+                    else if (action === 'merge') {
+                        const result = await mergeFile(localPath, template.templatePath);
+                        if (result.success) {
+                            await applyMerge(localPath, result);
+                            applied++;
+                        }
+                        else {
+                            skipped++;
+                        }
+                    }
+                    else {
+                        skipped++;
+                    }
+                    break;
+                case 'unchanged':
+                case 'generated':
+                    // No action needed
+                    break;
+            }
+        }
+        catch (error) {
+            logger.debug(`Failed to process ${analysis.path}`, error);
+            skipped++;
+        }
+    }
+    spinner.succeed(`Applied ${applied} changes, skipped ${skipped}`);
+    // Update version.json
+    await updateVersionTracking(archaiVersion, analyses);
+    console.log('');
+    logger.success('Initialization complete!');
+    console.log('');
+}
+/**
+ * Create version tracking for fresh install.
+ */
+async function createVersionTracking(archaiVersion) {
+    const templates = await getTemplateFiles();
+    const fileHashes = [];
+    for (const template of templates) {
+        const localPath = template.relativePath;
+        if (await fs.pathExists(localPath)) {
+            const hash = await hashFile(localPath);
+            fileHashes.push({ path: template.relativePath, hash, isGenerated: false });
+        }
+    }
+    let versionFile = createVersionFile(archaiVersion);
+    versionFile = bulkUpdateFileHashes(versionFile, fileHashes);
+    versionFile.expectedFiles = templates.map(t => t.relativePath);
+    await saveVersionFile(CLAUDE_DIR, versionFile);
+}
+/**
+ * Update version tracking after init/update.
+ */
+async function updateVersionTracking(archaiVersion, analyses) {
+    let versionFile = await loadVersionFile(CLAUDE_DIR);
+    if (!versionFile) {
+        versionFile = createVersionFile(archaiVersion);
+    }
+    else {
+        versionFile.archai = archaiVersion;
+        versionFile.lastUpdated = new Date().toISOString();
+    }
+    // Update hashes for all processed files
+    const updates = [];
+    for (const analysis of analyses) {
+        const userAction = analysis.userAction;
+        const wasApplied = analysis.status === 'new' ||
+            analysis.status === 'modified_by_archai' ||
+            (analysis.status === 'conflict' && analysis.canAutoMerge) ||
+            (analysis.status === 'conflict' && (userAction === 'overwrite' || userAction === 'merge')) ||
+            (analysis.status === 'modified_by_user' && (userAction === 'overwrite' || userAction === 'merge'));
+        if (wasApplied) {
+            const hash = await hashFile(analysis.path);
+            updates.push({
+                path: analysis.path,
+                hash,
+                isGenerated: analysis.isGenerated,
+            });
+        }
+    }
+    versionFile = bulkUpdateFileHashes(versionFile, updates);
+    await saveVersionFile(CLAUDE_DIR, versionFile);
+}
+/**
+ * Show success message after initialization.
+ */
+function showSuccessMessage() {
+    console.log('');
+    logger.divider();
+    console.log('');
+    logger.success('archai initialized successfully!');
+    console.log('');
+    logger.section('Next Steps');
+    console.log('');
+    console.log(chalk.white('1. Fill in the project description:'));
+    console.log(chalk.cyan('   → .knowledge/context/project-description.md'));
+    console.log(chalk.gray('   (or run: archai setup-project)'));
+    console.log('');
+    console.log(chalk.white('2. Complete the configuration:'));
+    console.log(chalk.cyan('   → archai.config.md'));
+    console.log(chalk.gray('   (or run: archai setup-config)'));
+    console.log('');
+    console.log(chalk.white('3. Configure environment:'));
+    console.log(chalk.cyan('   → archai setup'));
+    console.log(chalk.gray('   (auto-configures Git settings, MCP servers)'));
+    console.log('');
+    console.log(chalk.white('4. Generate specialist agents:'));
+    console.log(chalk.cyan('   → archai generate'));
+    console.log('');
+    console.log(chalk.gray('   (This will use Claude Code to create project-specific specialists)'));
+    console.log('');
+    console.log(chalk.white('5. Read the usage guide:'));
+    console.log(chalk.cyan('   → ARCHAI_README.md'));
+    console.log('');
+    console.log(chalk.white('6. See prompt examples:'));
+    console.log(chalk.cyan('   → PROMPTS.md'));
+    console.log('');
+}
+/**
+ * Copy CLAUDE.md template to project root.
+ */
+async function copyClaudeMd() {
+    const templatePath = path.join(getTemplatesDir(), 'CLAUDE.md');
+    if (await fs.pathExists(templatePath)) {
+        await fs.copy(templatePath, 'CLAUDE.md');
+    }
+}
+async function performRollback(ctx) {
+    const rollbackSpinner = ora('Rolling back...').start();
+    // Restore modified files
+    for (const [filePath, content] of ctx.modifiedFiles) {
+        try {
+            await fs.writeFile(filePath, content);
+            logger.debug(`Restored: ${filePath}`);
+        }
+        catch (error) {
+            logger.debug(`Failed to restore ${filePath}`, error);
+        }
+    }
+    // Remove created paths (reverse order for proper cleanup)
+    for (const filePath of ctx.createdPaths.reverse()) {
+        try {
+            if (await fs.pathExists(filePath)) {
+                await fs.remove(filePath);
+                logger.debug(`Removed: ${filePath}`);
+            }
+        }
+        catch (error) {
+            logger.debug(`Failed to remove ${filePath}`, error);
+        }
+    }
+    // Try to clean up parent directories if empty
+    const parentDirs = ['.claude', '.knowledge', '.tasks', '.agents', '.supervisor'];
+    for (const dir of parentDirs) {
+        try {
+            if (await fs.pathExists(dir)) {
+                const contents = await fs.readdir(dir);
+                if (contents.length === 0 || contents.every(f => f === '.gitkeep')) {
+                    await fs.remove(dir);
+                    logger.debug(`Removed empty dir: ${dir}`);
+                }
+            }
+        }
+        catch (error) {
+            logger.debug(`Failed to clean up ${dir}`, error);
+        }
+    }
+    rollbackSpinner.succeed('Rolled back changes');
+}
+//# sourceMappingURL=init.js.map