@zik000/archai 0.1.4 → 0.2.0

package/dist/commands/init.js

@@ -1,6 +1,8 @@
 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';
@@ -8,6 +10,12 @@ import { createProjectDescription } from '../scaffold/create-project-description
 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, } 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';
 const PROJECT_TYPES = [
     { name: 'Web Application (frontend/backend/fullstack)', value: 'web' },
     { name: 'Mobile Application', value: 'mobile' },
@@ -17,25 +25,144 @@ const PROJECT_TYPES = [
     { name: 'DevOps / Infrastructure', value: 'devops' },
     { name: 'Other', value: 'other' },
 ];
-const PACKAGE_MANAGERS = [
-    { name: 'npm', value: 'npm' },
-    { name: 'pnpm', value: 'pnpm' },
-    { name: 'yarn', value: 'yarn' },
-    { name: 'bun', value: 'bun' },
-    { name: 'pip (Python)', value: 'pip' },
-    { name: 'cargo (Rust)', value: 'cargo' },
-    { name: 'go mod (Go)', value: 'go' },
-    { name: 'Other / None', 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();
-    // Check for existing setup
-    const hasExisting = await checkExistingSetup();
-    if (hasExisting && !options.force) {
+    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('Use --force to overwrite existing configuration.');
+        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();
@@ -44,98 +171,413 @@ export async function init(options) {
         logger.info(`Found: ${detected.languages.join(', ')}`);
     }
     let answers;
-    if (options.skipWizard) {
-        // Only use detected values, don't assume defaults
-        // This allows TODO placeholders to appear for undetected fields
+    if (options.skipWizard || options.yes) {
+        // Non-interactive mode
         answers = {
             projectName: detected.name || 'my-project',
-            projectType: detected.languages.length > 0 ? 'web' : '', // Only assume web if we detected languages
-            languages: detected.languages.join(', ') || '',
-            frameworks: detected.frameworks?.join(', ') || '',
-            testFramework: detected.testFramework || '',
+            projectType: detected.languages.length > 0 ? 'web' : '',
             isMonorepo: detected.isMonorepo,
-            packageManager: detected.packageManager || '',
+            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('Project Setup');
-        console.log(chalk.gray('   (Press Enter to skip questions you\'re unsure about)'));
+        logger.section('Creating Agent System');
         console.log('');
-        answers = 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: 'input',
-                name: 'languages',
-                message: '3. Primary programming language(s):',
-                default: detected.languages.join(', ') || '',
-            },
+        // 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 (10 agents)...').start();
+        await copyCoreAgents();
+        agentsSpinner.succeed('Installed core agents');
+        // Create config template
+        const configSpinner = ora('Creating configuration template...').start();
+        await createConfigTemplate(answers);
+        rollback.createdPaths.push('archai.config.md');
+        configSpinner.succeed('Created archai.config.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();
+    }
+    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;
+    }
+}
+/**
+ * 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: 'frameworks',
-                message: '4. Main frameworks/libraries (skip if unsure):',
-                default: detected.frameworks?.join(', ') || '',
+                name: 'allowCommands',
+                message: 'Allowed commands:',
+                default: `${detected.packageManager || 'npm'} *, git status*, git diff*, git log*`,
             },
             {
                 type: 'input',
-                name: 'testFramework',
-                message: '5. Testing framework (skip if unsure):',
-                default: detected.testFramework || '',
-            },
-            {
-                type: 'confirm',
-                name: 'isMonorepo',
-                message: '6. Do you use a monorepo structure?',
-                default: detected.isMonorepo,
-            },
-            {
-                type: 'list',
-                name: 'packageManager',
-                message: '7. What\'s your package manager / build tool?',
-                choices: [...PACKAGE_MANAGERS, { name: 'Skip (decide later)', value: '' }],
-                default: detected.packageManager || 'npm',
+                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 (10 core agents)'));
+    console.log(chalk.gray('    .claude/version.json'));
+    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('Creating Agent System');
-    console.log('');
-    // Create folder structure
-    const structureSpinner = ora('Creating folder structure...').start();
-    await scaffoldProject();
-    structureSpinner.succeed('Created folder structure');
-    // Copy core agents
-    const agentsSpinner = ora('Installing core agents (10 agents)...').start();
-    await copyCoreAgents();
-    agentsSpinner.succeed('Installed core agents');
-    // Create config template
-    const configSpinner = ora('Creating configuration template...').start();
-    await createConfigTemplate(answers);
-    configSpinner.succeed('Created archai.config.md');
-    // Create project description template
-    const descSpinner = ora('Creating project description template...').start();
-    await createProjectDescription(answers);
-    descSpinner.succeed('Created project-description.md');
-    // Create default permission settings (permissive preset)
-    const permSpinner = ora('Creating permission settings...').start();
-    await createClaudeSettings({
-        preset: 'permissive',
-        packageManager: answers.packageManager || 'npm',
-    });
-    permSpinner.succeed('Created .claude/settings.local.json (permissive mode)');
-    // Final output
+    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('');
@@ -163,8 +605,46 @@ export async function init(options) {
     console.log(chalk.cyan('   → PROMPTS.md'));
     console.log('');
 }
-async function checkExistingSetup() {
-    const fs = await import('fs-extra');
-    return fs.pathExists('.claude/agents');
+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