@devobsessed/code-captain 0.0.5 → 0.0.8

package/bin/install.js

@@ -24,9 +24,7 @@ class CodeCaptainInstaller {
             baseUrl: 'https://raw.githubusercontent.com/devobsessed/code-captain/main',
             version: 'main',
             // Default to local source when running from npm package
-            localSource: process.env.CC_LOCAL_SOURCE || (isNpmPackage ? packageRoot : null),
-            versionFile: '.code-captain/.version',
-            manifestFile: '.code-captain/.manifest.json'
+            localSource: process.env.CC_LOCAL_SOURCE || (isNpmPackage ? packageRoot : null)
         };
 
         this.ides = {
@@ -36,29 +34,32 @@ class CodeCaptainInstaller {
                 details: 'Uses .code-captain/ structure + .cursor/rules/cc.mdc'
             },
             copilot: {
-                name: 'VS Code with GitHub Copilot',
-                description: 'Visual Studio Code with GitHub Copilot extension',
+                name: 'Copilot',
+                description: 'Visual Studio Code with Copilot extension',
                 details: 'Uses .github/chatmodes/ + .github/prompts/ + .code-captain/docs/'
             },
             windsurf: {
                 name: 'Windsurf',
                 description: 'Codeium\'s AI-powered development environment',
-                details: 'Uses windsurf/rules/ for custom workflows'
+                details: 'Uses .windsurf/rules/ and .windsurf/workflows/ for custom workflows'
             },
             claude: {
                 name: 'Claude Code',
                 description: 'Direct integration with Claude for development workflows',
-                details: 'Uses .code-captain/claude/ structure with agents and commands'
+                details: 'Uses .claude/ for agents and commands (+ .code-captain/ for shared docs)'
             }
         };
     }
 
     // Display welcome banner
-    showWelcome() {
+    async showWelcome() {
+        const version = await this.getPackageVersion();
         const banner = boxen(
-            chalk.bold.green('Code Captain 2.0') + '\n' +
-            chalk.gray('Unified AI Development Agent System') + '\n\n' +
-            chalk.blue('🚀 Interactive Installation Wizard'),
+            chalk.bold.green(`Code Captain ${version}`) + '\n' +
+            chalk.gray('AI Development Agent System') + '\n' +
+            chalk.dim('brought to you by DevObsessed') + '\n' +
+            chalk.dim.blue('https://www.devobsessed.com/') + '\n\n' +
+            chalk.blue('⚓ Interactive Installation Wizard'),
             {
                 padding: 1,
                 margin: 1,
@@ -116,7 +117,7 @@ class CodeCaptainInstaller {
             'Code Captain Core': ['.code-captain/'],
             'Cursor Integration': ['.cursor/rules/cc.mdc', '.cursor/rules/'],
             'Copilot Integration': ['.github/chatmodes/', '.github/prompts/'],
-            'Windsurf Integration': ['windsurf/rules/', 'windsurf/workflows/'],
+            'Windsurf Integration': ['.windsurf/rules/', '.windsurf/workflows/'],
             'Claude Integration': ['.code-captain/claude/', 'claude-code/', '.claude/'],
             'Legacy Structure': ['cursor/', 'copilot/', 'windsurf/']
         };
@@ -153,13 +154,24 @@ class CodeCaptainInstaller {
     async calculateFileHash(filePath) {
         try {
             const crypto = await import('crypto');
-            const content = await fs.readFile(filePath, 'utf8');
+            const content = await fs.readFile(filePath); // Buffer
             return crypto.default.createHash('sha256').update(content).digest('hex');
         } catch (error) {
             return null;
         }
     }
 
+    // Fetch with timeout using AbortController
+    async fetchWithTimeout(url, init = {}, timeoutMs = 15000) {
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), timeoutMs);
+        try {
+            return await fetch(url, { ...init, signal: controller.signal });
+        } finally {
+            clearTimeout(timer);
+        }
+    }
+
     // Get remote manifest with file versions/hashes
     async getRemoteManifest() {
         try {
@@ -169,20 +181,24 @@ class CodeCaptainInstaller {
                 const localManifestPath = path.join(this.config.localSource, 'manifest.json');
                 if (await fs.pathExists(localManifestPath)) {
                     const content = await fs.readFile(localManifestPath, 'utf8');
-                    return JSON.parse(content);
+                    const manifest = JSON.parse(content);
+                    return { manifest, isFallback: false };
                 }
             } else {
-                const response = await fetch(manifestUrl);
+                const response = await this.fetchWithTimeout(manifestUrl, {}, 15000);
                 if (response.ok) {
-                    return await response.json();
+                    const manifest = await response.json();
+                    return { manifest, isFallback: false };
                 }
             }
 
             // Fallback: generate manifest from current commit
-            return await this.generateFallbackManifest();
+            const fallbackManifest = await this.generateFallbackManifest();
+            return { manifest: fallbackManifest, isFallback: true };
         } catch (error) {
             console.warn(chalk.yellow('Warning: Could not fetch remote manifest, using fallback'));
-            return await this.generateFallbackManifest();
+            const fallbackManifest = await this.generateFallbackManifest();
+            return { manifest: fallbackManifest, isFallback: true };
         }
     }
 
@@ -197,47 +213,43 @@ class CodeCaptainInstaller {
         };
     }
 
-    // Get local manifest if it exists
-    async getLocalManifest() {
-        try {
-            if (await fs.pathExists(this.config.manifestFile)) {
-                const content = await fs.readFile(this.config.manifestFile, 'utf8');
-                return JSON.parse(content);
-            }
-        } catch (error) {
-            console.warn(chalk.yellow('Warning: Could not read local manifest'));
-        }
-        return null;
-    }
 
-    // Compare manifests and detect changes
+
+    // Compare current files with remote manifest to detect changes
     async detectChanges(selectedIDE) {
         const spinner = ora('Analyzing file changes...').start();
 
         try {
-            const [remoteManifest, localManifest] = await Promise.all([
-                this.getRemoteManifest(),
-                this.getLocalManifest()
-            ]);
+            const { manifest: remoteManifest, isFallback: manifestIsFallback } = await this.getRemoteManifest();
+            const files = this.getIDEFiles(selectedIDE);
 
-            if (!localManifest) {
-                spinner.succeed('No previous manifest found - treating as fresh installation');
+            // Check if this looks like a first install (no existing files)
+            const existingFiles = [];
+            for (const file of files) {
+                if (await fs.pathExists(file.target)) {
+                    existingFiles.push(file.target);
+                }
+            }
 
-                // Get proper version information for first install
-                const currentVersion = this.config.localSource ? await this.getPackageVersion() : 'unknown';
-                const availableVersion = remoteManifest.version;
+            if (existingFiles.length === 0) {
+                if (manifestIsFallback) {
+                    spinner.succeed('No existing files found - treating as fresh installation (offline mode)');
+                } else {
+                    spinner.succeed('No existing files found - treating as fresh installation');
+                }
 
+                const availableVersion = remoteManifest.version;
                 return {
                     isFirstInstall: true,
-                    localVersion: currentVersion,
                     remoteVersion: availableVersion,
                     changes: [],
                     newFiles: [],
-                    recommendations: ['Full installation recommended (no change tracking available)']
+                    recommendations: ['Full installation recommended'],
+                    manifestIsFallback
                 };
             }
 
-            const files = this.getIDEFiles(selectedIDE);
+            // Analyze existing files for changes
             const changes = [];
             const newFiles = [];
             let filesAnalyzed = 0;
@@ -283,7 +295,6 @@ class CodeCaptainInstaller {
                         changes.push({
                             file: remotePath,
                             component: file.component,
-                            localVersion: localManifest.files?.[remotePath]?.version || 'unknown',
                             remoteVersion: remoteFileInfo.version || 'latest',
                             reason: 'File content has changed',
                             localHash: localFileHash.substring(0, 8),
@@ -291,30 +302,39 @@ class CodeCaptainInstaller {
                         });
                     }
                 } else {
-                    // No remote file info - treat as new in remote
-                    newFiles.push({
-                        file: remotePath,
-                        component: file.component,
-                        reason: 'New file in remote repository'
-                    });
+                    // No remote file info - check if we're in fallback mode
+                    if (manifestIsFallback) {
+                        // In fallback mode, we can't determine if files are new
+                        // Skip these files from change detection
+                        continue;
+                    } else {
+                        // Not in fallback mode - truly new file in remote
+                        newFiles.push({
+                            file: remotePath,
+                            component: file.component,
+                            reason: 'New file in remote repository'
+                        });
+                    }
                 }
             }
 
-            const recommendations = this.generateUpdateRecommendations(changes, newFiles);
+            const recommendations = this.generateUpdateRecommendations(changes, newFiles, manifestIsFallback);
 
-            spinner.succeed(`Found ${changes.length} updated files, ${newFiles.length} new files`);
+            if (manifestIsFallback) {
+                spinner.succeed(`Found ${changes.length} updated files, ${newFiles.length} new files (offline mode - limited change detection)`);
+            } else {
+                spinner.succeed(`Found ${changes.length} updated files, ${newFiles.length} new files`);
+            }
 
-            // Get proper version information
-            const currentVersion = this.config.localSource ? await this.getPackageVersion() : 'unknown';
             const availableVersion = remoteManifest.version;
 
             return {
                 isFirstInstall: false,
-                localVersion: currentVersion,
                 remoteVersion: availableVersion,
                 changes,
                 newFiles,
-                recommendations
+                recommendations,
+                manifestIsFallback
             };
 
         } catch (error) {
@@ -324,13 +344,14 @@ class CodeCaptainInstaller {
                 changes: [],
                 newFiles: [],
                 recommendations: ['Unable to detect changes - consider full update'],
+                manifestIsFallback: true, // Assume fallback mode on error
                 error: error.message
             };
         }
     }
 
     // Generate smart update recommendations
-    generateUpdateRecommendations(changes, newFiles) {
+    generateUpdateRecommendations(changes, newFiles, manifestIsFallback = false) {
         const recommendations = [];
         const changedComponents = new Set();
 
@@ -341,61 +362,38 @@ class CodeCaptainInstaller {
             }
         });
 
-        if (changedComponents.size === 0) {
-            recommendations.push('✅ All files are up to date!');
-        } else {
-            recommendations.push(`📦 Recommended updates: ${Array.from(changedComponents).join(', ')}`);
+        if (manifestIsFallback) {
+            recommendations.push('⚠️  Operating in offline/fallback mode - limited change detection');
+            recommendations.push('📶 Consider checking internet connection for full update analysis');
 
-            // Specific recommendations
-            if (changedComponents.has('commands')) {
-                recommendations.push('🚀 Commands updated - new features or bug fixes available');
-            }
-            if (changedComponents.has('rules')) {
-                recommendations.push('⚙️ Rules updated - improved AI agent behavior');
+            if (changedComponents.size === 0) {
+                recommendations.push('📦 No local file changes detected - full reinstall recommended for latest updates');
+            } else {
+                recommendations.push(`📦 Local changes detected in: ${Array.from(changedComponents).join(', ')}`);
             }
-            if (changedComponents.has('docs')) {
-                recommendations.push('📚 Documentation updated - check for new best practices');
+        } else {
+            if (changedComponents.size === 0) {
+                recommendations.push('✅ All files are up to date!');
+            } else {
+                recommendations.push(`📦 Recommended updates: ${Array.from(changedComponents).join(', ')}`);
+
+                // Specific recommendations
+                if (changedComponents.has('commands')) {
+                    recommendations.push('🚀 Commands updated - new features or bug fixes available');
+                }
+                if (changedComponents.has('rules')) {
+                    recommendations.push('⚙️ Rules updated - improved AI agent behavior');
+                }
+                if (changedComponents.has('docs')) {
+                    recommendations.push('📚 Documentation updated - check for new best practices');
+                }
             }
         }
 
         return recommendations;
     }
 
-    // Save manifest after successful installation
-    async saveManifest(remoteManifest, installedFiles) {
-        try {
-            const manifest = {
-                ...remoteManifest,
-                installedAt: new Date().toISOString(),
-                files: {}
-            };
-
-            // Calculate actual hashes of installed files
-            for (const file of installedFiles) {
-                const localHash = await this.calculateFileHash(file.target);
 
-                if (localHash) {
-                    // Use remote file info as base, but update with actual installed hash
-                    const remoteFileInfo = remoteManifest.files?.[file.source] || {};
-
-                    manifest.files[file.source] = {
-                        ...remoteFileInfo,
-                        hash: `sha256:${localHash}`,
-                        installedAt: new Date().toISOString(),
-                        actualSize: (await fs.stat(file.target).catch(() => ({ size: 0 }))).size
-                    };
-                }
-            }
-
-            await fs.ensureDir(path.dirname(this.config.manifestFile));
-            await fs.writeFile(this.config.manifestFile, JSON.stringify(manifest, null, 2));
-
-            return true;
-        } catch (error) {
-            console.warn(chalk.yellow(`Warning: Could not save manifest: ${error.message}`));
-            return false;
-        }
-    }
 
     // Auto-detect IDE preference
     detectIDE() {
@@ -412,7 +410,7 @@ class CodeCaptainInstaller {
         }
 
         // Check for Windsurf
-        if (fs.pathExistsSync('windsurf') || this.commandExists('windsurf')) {
+        if (fs.pathExistsSync('.windsurf') || this.commandExists('windsurf')) {
             detections.push('windsurf');
         }
 
@@ -485,10 +483,16 @@ class CodeCaptainInstaller {
         console.log('\n' + chalk.bold.blue('🔍 Change Analysis'));
         console.log(chalk.gray('═'.repeat(50)));
 
+        // Show fallback mode warning if applicable
+        if (changeInfo.manifestIsFallback) {
+            console.log(chalk.yellow('⚠️  Operating in offline/fallback mode - limited change detection capabilities'));
+            console.log(chalk.gray('   Remote manifest unavailable - cannot detect all new files or verify latest versions'));
+        }
+
         // Show version information
-        if (changeInfo.localVersion && changeInfo.remoteVersion) {
-            console.log(chalk.blue('Current version:'), changeInfo.localVersion);
-            console.log(chalk.blue('Available version:'), changeInfo.remoteVersion);
+        if (changeInfo.remoteVersion) {
+            const versionLabel = changeInfo.manifestIsFallback ? 'Local/fallback version:' : 'Available version:';
+            console.log(chalk.blue(versionLabel), changeInfo.remoteVersion);
         }
 
         // Show what's changed
@@ -602,16 +606,14 @@ class CodeCaptainInstaller {
             case 'cursor':
                 return [
                     ...baseChoices,
-                    { name: 'Cursor Rules (.cursor/rules/cc.mdc)', value: 'rules', checked: true },
-                    { name: 'GitHub Integration', value: 'github', checked: true },
-                    { name: 'Azure DevOps Integration', value: 'azure', checked: true }
+                    { name: 'Cursor Rules (.cursor/rules/cc.mdc)', value: 'rules', checked: true }
                 ];
 
             case 'copilot':
                 return [
                     ...baseChoices,
-                    { name: 'GitHub Copilot Chatmodes', value: 'chatmodes', checked: true },
-                    { name: 'GitHub Copilot Prompts', value: 'prompts', checked: true }
+                    { name: 'Copilot Chatmodes', value: 'chatmodes', checked: true },
+                    { name: 'Copilot Prompts', value: 'prompts', checked: true }
                 ];
 
             case 'windsurf':
@@ -656,7 +658,10 @@ class CodeCaptainInstaller {
             // Show change summary
             const { changeInfo } = installOptions;
             if (changeInfo && (changeInfo.changes.length > 0 || changeInfo.newFiles.length > 0)) {
-                console.log(chalk.blue('Files to update:'), `${changeInfo.changes.length} changed, ${changeInfo.newFiles.length} new`);
+                const modeIndicator = changeInfo.manifestIsFallback ? ' (offline mode)' : '';
+                console.log(chalk.blue('Files to update:'), `${changeInfo.changes.length} changed, ${changeInfo.newFiles.length} new${modeIndicator}`);
+            } else if (changeInfo && changeInfo.manifestIsFallback) {
+                console.log(chalk.blue('Installation mode:'), 'Offline/fallback mode - limited change detection');
             }
         } else {
             console.log(chalk.blue('Installation type:'), 'Full installation (new setup)');
@@ -674,29 +679,50 @@ class CodeCaptainInstaller {
         return confirmed;
     }
 
-    // Create backup of existing file
-    async createBackup(targetPath, shouldBackup = true) {
+    // Create directory-level backup of target directories
+    async createDirectoryBackups(files, shouldBackup = true) {
         if (!shouldBackup) {
-            return null;
+            return [];
         }
 
-        if (await fs.pathExists(targetPath)) {
-            const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
-            const backupPath = `${targetPath}.backup.${timestamp}`;
+        // Extract unique target directories from file list
+        const targetDirs = new Set();
+        files.forEach(file => {
+            const targetPath = file.target;
+            const normalizedTarget = path.normalize(targetPath);
+            const segments = normalizedTarget.split(path.sep).filter(Boolean);
+            const rootDir = segments[0]; // e.g., ".code-captain", ".cursor", ".github"
+            if (rootDir && rootDir.startsWith('.')) {
+                targetDirs.add(rootDir);
+            }
+        });
+
+        const backupPaths = [];
 
-            try {
-                await fs.copy(targetPath, backupPath);
-                return backupPath;
-            } catch (error) {
-                console.warn(chalk.yellow(`Warning: Could not backup ${targetPath}: ${error.message}`));
-                return null;
+        for (const dir of targetDirs) {
+            if (await fs.pathExists(dir)) {
+                const backupPath = `${dir}.backup`;
+
+                try {
+                    // Remove existing backup if it exists
+                    if (await fs.pathExists(backupPath)) {
+                        await fs.remove(backupPath);
+                    }
+
+                    // Create directory backup
+                    await fs.copy(dir, backupPath);
+                    backupPaths.push(backupPath);
+                } catch (error) {
+                    console.warn(chalk.yellow(`Warning: Could not backup ${dir}: ${error.message}`));
+                }
             }
         }
-        return null;
+
+        return backupPaths;
     }
 
     // Download file from URL or local source
-    async downloadFile(relativePath, targetPath, shouldBackup = true) {
+    async downloadFile(relativePath, targetPath) {
         try {
             let content;
 
@@ -707,7 +733,7 @@ class CodeCaptainInstaller {
             } else {
                 // Remote download mode
                 const url = `${this.config.baseUrl}/${relativePath}`;
-                const response = await fetch(url);
+                const response = await this.fetchWithTimeout(url, {}, 20000);
 
                 if (!response.ok) {
                     throw new Error(`HTTP ${response.status}: ${response.statusText}`);
@@ -719,9 +745,6 @@ class CodeCaptainInstaller {
             // Ensure target directory exists
             await fs.ensureDir(path.dirname(targetPath));
 
-            // Create backup if file exists
-            await this.createBackup(targetPath, shouldBackup);
-
             // Write file
             await fs.writeFile(targetPath, content);
 
@@ -768,38 +791,7 @@ class CodeCaptainInstaller {
                     });
                 }
 
-                // GitHub integration
-                if (includeAll || selectedComponents.includes('github')) {
-                    const githubFiles = [
-                        'integrations/github/create-github-issues.md',
-                        'integrations/github/sync-github-issues.md',
-                        'integrations/github/sync.md'
-                    ];
-
-                    githubFiles.forEach(file => {
-                        files.push({
-                            source: `cursor/${file}`,
-                            target: `.code-captain/${file}`,
-                            component: 'github'
-                        });
-                    });
-                }
-
-                // Azure DevOps integration
-                if (includeAll || selectedComponents.includes('azure')) {
-                    const azureFiles = [
-                        'integrations/azure-devops/create-azure-work-items.md',
-                        'integrations/azure-devops/sync-azure-work-items.md'
-                    ];
 
-                    azureFiles.forEach(file => {
-                        files.push({
-                            source: `cursor/${file}`,
-                            target: `.code-captain/${file}`,
-                            component: 'azure'
-                        });
-                    });
-                }
 
                 // Documentation
                 if (includeAll || selectedComponents.includes('docs')) {
@@ -853,7 +845,7 @@ class CodeCaptainInstaller {
                 // Rules
                 if (includeAll || selectedComponents.includes('rules')) {
                     files.push(
-                        { source: 'windsurf/rules/cc.md', target: 'windsurf/rules/cc.md', component: 'rules' }
+                        { source: 'windsurf/rules/cc.md', target: '.windsurf/rules/cc.md', component: 'rules' }
                     );
                 }
 
@@ -867,7 +859,7 @@ class CodeCaptainInstaller {
                     windsurfWorkflows.forEach(workflow => {
                         files.push({
                             source: `windsurf/workflows/${workflow}`,
-                            target: `windsurf/workflows/${workflow}`,
+                            target: `.windsurf/workflows/${workflow}`,
                             component: 'workflows'
                         });
                     });
@@ -879,14 +871,14 @@ class CodeCaptainInstaller {
                 // Claude agents
                 if (includeAll || selectedComponents.includes('agents')) {
                     const claudeAgents = [
-                        'code-captain.md', 'spec-generator.md', 'spec-orchestrator.md',
+                        'code-captain.md', 'spec-generator.md',
                         'story-creator.md', 'tech-spec.md'
                     ];
 
                     claudeAgents.forEach(agent => {
                         files.push({
                             source: `claude-code/agents/${agent}`,
-                            target: `.code-captain/claude/agents/${agent}`,
+                            target: `.claude/agents/${agent}`,
                             component: 'agents'
                         });
                     });
@@ -901,7 +893,7 @@ class CodeCaptainInstaller {
                     claudeCommands.forEach(command => {
                         files.push({
                             source: `claude-code/commands/${command}`,
-                            target: `.code-captain/claude/commands/${command}`,
+                            target: `.claude/commands/${command}`,
                             component: 'claude-commands'
                         });
                     });
@@ -920,31 +912,35 @@ class CodeCaptainInstaller {
         const spinner = ora(`Installing ${this.ides[selectedIDE].name} integration...`).start();
 
         try {
-            let completed = 0;
-            const backupPaths = [];
+            // Create directory-level backups upfront if requested
+            const shouldBackup = installOptions.createBackups !== false; // Default to true if not specified
+            const backupPaths = await this.createDirectoryBackups(files, shouldBackup);
+
+            if (backupPaths.length > 0) {
+                spinner.text = `Created ${backupPaths.length} directory backup(s), installing files...`;
+            }
 
+            // Install all files
+            let completed = 0;
             for (const file of files) {
-                const shouldBackup = installOptions.createBackups !== false; // Default to true if not specified
-                await this.downloadFile(file.source, file.target, shouldBackup);
+                await this.downloadFile(file.source, file.target);
                 completed++;
                 spinner.text = `Installing files... (${completed}/${files.length})`;
             }
 
-            // Save manifest for future change detection
-            if (installOptions.changeInfo) {
-                const remoteManifest = await this.getRemoteManifest();
-                await this.saveManifest(remoteManifest, files);
-            }
+
 
             spinner.succeed(`${this.ides[selectedIDE].name} integration installed successfully!`);
 
             return {
                 totalFiles: files.length,
                 targetDir: selectedIDE === 'copilot' ? '.github + .code-captain/docs' :
-                    selectedIDE === 'windsurf' ? 'windsurf' :
-                        selectedIDE === 'claude' ? '.code-captain/claude' : '.code-captain (+ .cursor/rules)',
+                    selectedIDE === 'windsurf' ? '.windsurf' :
+                        selectedIDE === 'claude' ? '.claude' : '.code-captain (+ .cursor/rules)',
                 components: installOptions.installAll ? 'All components' : installOptions.selectedComponents.join(', '),
-                changesDetected: installOptions.changeInfo && (installOptions.changeInfo.changes.length > 0 || installOptions.changeInfo.newFiles.length > 0)
+                changesDetected: installOptions.changeInfo && (installOptions.changeInfo.changes.length > 0 || installOptions.changeInfo.newFiles.length > 0),
+                backupsCreated: backupPaths.length > 0,
+                backupPaths: backupPaths
             };
         } catch (error) {
             spinner.fail('Installation failed');
@@ -983,7 +979,7 @@ class CodeCaptainInstaller {
 
             case 'copilot':
                 console.log(chalk.blue('1.') + ' Restart VS Code to load chatmodes from ' + chalk.cyan('.github/chatmodes/'));
-                console.log(chalk.blue('2.') + ' Open GitHub Copilot Chat in VS Code');
+                console.log(chalk.blue('2.') + ' Open Copilot Chat in VS Code');
                 console.log(chalk.blue('3.') + ' Type ' + chalk.cyan('@Code Captain') + ' to access the chatmode');
                 console.log(chalk.blue('4.') + ' Use prompts from ' + chalk.cyan('.github/prompts/') + ' for workflows');
                 break;
@@ -995,9 +991,9 @@ class CodeCaptainInstaller {
                 break;
 
             case 'claude':
-                console.log(chalk.blue('1.') + ' Claude agents and commands are installed in ' + chalk.cyan('.code-captain/claude/'));
-                console.log(chalk.blue('2.') + ' Reference the agents in ' + chalk.cyan('.code-captain/claude/agents/') + ' for specialized workflows');
-                console.log(chalk.blue('3.') + ' Use command templates from ' + chalk.cyan('.code-captain/claude/commands/'));
+                console.log(chalk.blue('1.') + ' Claude agents and commands are installed in ' + chalk.cyan('.claude/'));
+                console.log(chalk.blue('2.') + ' Reference the agents in ' + chalk.cyan('.claude/agents/') + ' for specialized workflows');
+                console.log(chalk.blue('3.') + ' Use command templates from ' + chalk.cyan('.claude/commands/'));
                 console.log(chalk.blue('4.') + ' Import agent contexts directly into Claude conversations');
                 break;
         }
@@ -1006,10 +1002,13 @@ class CodeCaptainInstaller {
         console.log(chalk.gray('Documentation: https://github.com/devobsessed/code-captain'));
 
         // Show backup information if backups were created
-        if (installResult.totalFiles > 0) {
+        if (installResult.backupsCreated) {
             console.log('\n' + chalk.yellow('💾 Backup Information:'));
-            console.log(chalk.gray('Existing files were backed up with timestamps (e.g., filename.backup.2024-01-01T12-00-00-000Z)'));
-            console.log(chalk.gray('You can safely delete backup files once you\'re satisfied with the installation.'));
+            console.log(chalk.gray('The following directories were backed up:'));
+            installResult.backupPaths.forEach(backupPath => {
+                console.log(chalk.gray(`  • ${backupPath}/`));
+            });
+            console.log(chalk.gray('You can safely delete these backup directories once you\'re satisfied with the installation.'));
         }
     }
 
@@ -1034,7 +1033,7 @@ class CodeCaptainInstaller {
     async run() {
         try {
             // Show welcome
-            this.showWelcome();
+            await this.showWelcome();
 
             // Check compatibility
             const systemInfo = await this.checkCompatibility();