devflow-kit 0.8.1 → 1.0.0

package/dist/commands/init.js

@@ -3,125 +3,60 @@ import { promises as fs } from 'fs';
 import * as path from 'path';
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
-import * as readline from 'readline';
+import * as p from '@clack/prompts';
+import color from 'picocolors';
 import { getInstallationPaths } from '../utils/paths.js';
 import { getGitRoot } from '../utils/git.js';
+import { isClaudeCliAvailable } from '../utils/cli.js';
+import { installViaCli, installViaFileCopy } from '../utils/installer.js';
+import { installSettings, installManagedSettings, installClaudeignore, updateGitignore, createDocsStructure, } from '../utils/post-install.js';
+import { DEVFLOW_PLUGINS, LEGACY_SKILL_NAMES, LEGACY_COMMAND_NAMES, buildAssetMaps } from '../plugins.js';
+import { detectPlatform, detectShell, getProfilePath, getSafeDeleteInfo, hasSafeDelete } from '../utils/safe-delete.js';
+import { generateSafeDeleteBlock, isAlreadyInstalled, installToProfile } from '../utils/safe-delete-install.js';
+// Re-export pure functions for tests (canonical source is post-install.ts)
+export { substituteSettingsTemplate, computeGitignoreAppend, applyTeamsConfig, stripTeamsConfig, mergeDenyList } from '../utils/post-install.js';
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = dirname(__filename);
-function isNodeSystemError(error) {
-    return (error instanceof Error &&
-        'code' in error &&
-        typeof error.code === 'string');
-}
 /**
- * Prompt user for confirmation (async)
+ * Parse a comma-separated plugin selection string into normalized plugin names.
+ * Validates against known plugins; returns invalid names as errors.
  */
-async function promptUser(question) {
-    const rl = readline.createInterface({
-        input: process.stdin,
-        output: process.stdout
-    });
-    return new Promise((resolve) => {
-        rl.question(question, (answer) => {
-            rl.close();
-            resolve(answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes');
-        });
+export function parsePluginSelection(input, validPlugins) {
+    const selected = input.split(',').map(p => {
+        const trimmed = p.trim();
+        return trimmed.startsWith('devflow-') ? trimmed : `devflow-${trimmed}`;
     });
+    const validNames = validPlugins.map(p => p.name);
+    const invalid = selected.filter(p => !validNames.includes(p));
+    return { selected, invalid };
 }
 /**
- * DevFlow commands with user-friendly descriptions.
- * Used for displaying available commands in init output.
- */
-const DEVFLOW_COMMANDS = [
-    { name: '/catch-up', description: 'Get up to speed on project state' },
-    { name: '/brainstorm', description: 'Explore design decisions' },
-    { name: '/design', description: 'Create implementation plan' },
-    { name: '/plan', description: 'Triage issues from discussion' },
-    { name: '/breakdown', description: 'Break down tasks quickly' },
-    { name: '/implement', description: 'Interactive implementation' },
-    { name: '/code-review', description: 'Comprehensive code review' },
-    { name: '/commit', description: 'Smart atomic commits' },
-    { name: '/pull-request', description: 'Create PR with description' },
-    { name: '/release', description: 'Automated releases' },
-    { name: '/devlog', description: 'Document session progress' },
-    { name: '/debug', description: 'Systematic debugging' },
-    { name: '/resolve-comments', description: 'Address PR feedback' },
-];
-/**
- * DevFlow skills with descriptions.
- * Displayed only in verbose mode to show auto-activating capabilities.
- */
-const DEVFLOW_SKILLS = [
-    { name: 'pattern-check', description: 'Architectural pattern validation' },
-    { name: 'test-design', description: 'Test quality enforcement' },
-    { name: 'code-smell', description: 'Anti-pattern detection' },
-    { name: 'research', description: 'Pre-implementation planning (auto)' },
-    { name: 'debug', description: 'Systematic debugging (auto)' },
-    { name: 'input-validation', description: 'Boundary validation' },
-    { name: 'error-handling', description: 'Result type consistency' },
-];
-/**
- * Render clean, minimal output for default (non-verbose) mode.
- * Shows only essential information: version, available commands, and docs link.
- *
- * @param version - The DevFlow version string to display
+ * Build the list of configuration extras available for the given scope/git context.
+ * Pure function — no I/O, no side effects.
  */
-function renderCleanOutput(version) {
-    console.log(`\n✓ DevFlow v${version} installed\n`);
-    console.log('Commands available:');
-    // Calculate max command name length for alignment
-    const maxLen = Math.max(...DEVFLOW_COMMANDS.map(c => c.name.length));
-    for (const cmd of DEVFLOW_COMMANDS) {
-        const padding = ' '.repeat(maxLen - cmd.name.length + 2);
-        console.log(`  ${cmd.name}${padding}${cmd.description}`);
-    }
-    console.log('\nRun any command in Claude Code to get started.');
-    console.log('\nDocs: https://github.com/dean0x/devflow');
-}
-/**
- * Render detailed output for verbose mode.
- * Shows full installation details including paths, merge instructions, and skills.
- *
- * @param version - The DevFlow version string to display
- * @param scope - Installation scope ('user' for user-wide, 'local' for project-only)
- * @param claudeDir - Path to the Claude Code directory
- * @param devflowDir - Path to the DevFlow directory
- * @param settingsExists - Whether existing settings.json was preserved
- * @param claudeMdExists - Whether existing CLAUDE.md was preserved
- */
-function renderVerboseOutput(version, scope, claudeDir, devflowDir, settingsExists, claudeMdExists) {
-    console.log(`\n✅ DevFlow v${version} installed!\n`);
-    console.log(`📍 Installation scope: ${scope}`);
-    console.log(`   Claude dir: ${claudeDir}`);
-    console.log(`   DevFlow dir: ${devflowDir}\n`);
-    // Show manual merge instructions if needed
-    if (settingsExists || claudeMdExists) {
-        console.log('📝 Manual merge recommended:\n');
-        if (settingsExists) {
-            console.log('   Settings: Review settings.devflow.json and merge desired config into settings.json');
-            console.log('             Key setting: statusLine configuration for DevFlow statusline\n');
-        }
-        if (claudeMdExists) {
-            console.log('   Instructions: Review CLAUDE.devflow.md and adopt desired practices');
-            console.log("                 This contains DevFlow's recommended development patterns\n");
-        }
+export function buildExtrasOptions(scope, gitRoot) {
+    const options = [
+        { value: 'settings', label: 'Settings & Working Memory', hint: 'Model defaults, session memory hooks, status line' },
+    ];
+    if (gitRoot) {
+        options.push({ value: 'claudeignore', label: '.claudeignore', hint: 'Exclude secrets, deps, build artifacts from Claude context' });
     }
-    console.log('Available commands:');
-    for (const cmd of DEVFLOW_COMMANDS) {
-        console.log(`  ${cmd.name.padEnd(18)}${cmd.description}`);
+    if (scope === 'local' && gitRoot) {
+        options.push({ value: 'gitignore', label: '.gitignore entries', hint: 'Add .claude/ and .devflow/ to .gitignore' });
     }
-    console.log('\nInstalled skills (auto-activate):');
-    for (const skill of DEVFLOW_SKILLS) {
-        console.log(`  ${skill.name.padEnd(18)}${skill.description}`);
+    if (scope === 'local') {
+        options.push({ value: 'docs', label: '.docs/ directory', hint: 'Review reports, dev logs, status tracking for this project' });
     }
-    console.log('\nNote: debug exists as both command (manual) and skill (auto)');
-    console.log('Docs: https://github.com/dean0x/devflow');
+    options.push({ value: 'safe-delete', label: 'Safe-delete (rm → trash)', hint: 'Override rm to use trash CLI — prevents accidental deletion' });
+    return options;
 }
 export const initCommand = new Command('init')
     .description('Initialize DevFlow for Claude Code')
-    .option('--skip-docs', 'Skip creating .docs/ structure')
-    .option('--scope <type>', 'Installation scope: user (user-wide) or local (project-only)', /^(user|local)$/i)
+    .option('--scope <type>', 'Installation scope: user or local (project-only)', /^(user|local)$/i)
     .option('--verbose', 'Show detailed installation output')
+    .option('--plugin <names>', 'Install specific plugin(s), comma-separated (e.g., implement,code-review)')
+    .option('--teams', 'Enable Agent Teams (peer debate, adversarial review)')
+    .option('--no-teams', 'Disable Agent Teams (use parallel subagents instead)')
     .action(async (options) => {
     // Get package version
     const packageJsonPath = path.resolve(__dirname, '../../package.json');
@@ -134,68 +69,109 @@ export const initCommand = new Command('init')
         version = 'unknown';
     }
     const verbose = options.verbose ?? false;
-    if (verbose) {
-        console.log(`🚀 DevFlow v${version}\n`);
-    }
+    // Start the CLI flow
+    p.intro(color.bgCyan(color.black(` DevFlow v${version} `)));
     // Determine installation scope
-    let scope = 'user'; // Default to user for backwards compatibility
+    let scope = 'user';
     if (options.scope) {
         const normalizedScope = options.scope.toLowerCase();
-        // Runtime validation (Commander regex already validates, but be defensive)
         if (normalizedScope !== 'user' && normalizedScope !== 'local') {
-            console.error('❌ Invalid scope. Use "user" or "local"\n');
+            p.log.error('Invalid scope. Use "user" or "local"');
             process.exit(1);
         }
         scope = normalizedScope;
     }
+    else if (!process.stdin.isTTY) {
+        p.log.info('Non-interactive mode detected, using scope: user');
+        scope = 'user';
+    }
     else {
-        // Check if running in interactive terminal (TTY)
-        if (!process.stdin.isTTY) {
-            // Non-interactive environment (CI/CD, scripts) - use default
-            if (verbose) {
-                console.log('📦 Non-interactive environment detected, using default scope: user');
-                console.log('   To specify scope in CI/CD, use: devflow init --scope <user|local>\n');
-            }
-            scope = 'user';
+        const selected = await p.select({
+            message: 'Installation scope',
+            options: [
+                { value: 'user', label: 'User', hint: 'all projects (~/.claude/)' },
+                { value: 'local', label: 'Local', hint: 'this project only (./.claude/)' },
+            ],
+        });
+        if (p.isCancel(selected)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
         }
-        else {
-            // Interactive prompt for scope
-            if (verbose) {
-                console.log('📦 Installation Scope:\n');
-                console.log('  user  - Install for all projects (user-wide)');
-                console.log('            └─ ~/.claude/ and ~/.devflow/');
-                console.log('  local - Install for current project only');
-                console.log('            └─ <git-root>/.claude/ and <git-root>/.devflow/\n');
-            }
-            const rl = readline.createInterface({
-                input: process.stdin,
-                output: process.stdout
-            });
-            const prompt = verbose
-                ? 'Choose scope (user/local) [user]: '
-                : 'Install scope - user (all projects) or local (this project only) [user]: ';
-            const answer = await new Promise((resolve) => {
-                rl.question(prompt, (input) => {
-                    rl.close();
-                    resolve(input.trim().toLowerCase() || 'user');
-                });
-            });
-            if (answer === 'local' || answer === 'l') {
-                scope = 'local';
-            }
-            else if (answer === 'user' || answer === 'u' || answer === '') {
-                scope = 'user';
-            }
-            else {
-                console.error('❌ Invalid scope. Use "user" or "local"\n');
-                process.exit(1);
-            }
-            if (verbose) {
-                console.log();
-            }
+        scope = selected;
+    }
+    // Select plugins to install
+    let selectedPlugins = [];
+    if (options.plugin) {
+        const { selected, invalid } = parsePluginSelection(options.plugin, DEVFLOW_PLUGINS);
+        selectedPlugins = selected;
+        if (invalid.length > 0) {
+            p.log.error(`Unknown plugin(s): ${invalid.join(', ')}`);
+            p.log.info(`Valid plugins: ${DEVFLOW_PLUGINS.map(pl => pl.name).join(', ')}`);
+            process.exit(1);
+        }
+    }
+    else if (process.stdin.isTTY) {
+        const choices = DEVFLOW_PLUGINS
+            .filter(pl => pl.name !== 'devflow-core-skills')
+            .map(pl => ({
+            value: pl.name,
+            label: pl.name.replace('devflow-', ''),
+            hint: pl.description + (pl.optional ? ' (optional)' : ''),
+        }));
+        const preSelected = DEVFLOW_PLUGINS
+            .filter(pl => !pl.optional && pl.name !== 'devflow-core-skills')
+            .map(pl => pl.name);
+        const pluginSelection = await p.multiselect({
+            message: 'Select plugins to install',
+            options: choices,
+            initialValues: preSelected,
+            required: true,
+        });
+        if (p.isCancel(pluginSelection)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
         }
+        selectedPlugins = pluginSelection;
     }
-    // Get installation paths with proper validation
+    // Agent Teams variant selection
+    let teamsEnabled;
+    if (options.teams !== undefined) {
+        teamsEnabled = options.teams;
+    }
+    else if (!process.stdin.isTTY) {
+        teamsEnabled = false;
+    }
+    else {
+        const teamsChoice = await p.confirm({
+            message: 'Enable Agent Teams? (peer debate in review, exploration, debugging)',
+            initialValue: false,
+        });
+        if (p.isCancel(teamsChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        teamsEnabled = teamsChoice;
+    }
+    // Security deny list placement (user scope + TTY only)
+    let securityMode = 'user';
+    if (scope === 'user' && process.stdin.isTTY) {
+        const securityChoice = await p.select({
+            message: 'How should DevFlow install the security deny list?',
+            options: [
+                { value: 'managed', label: 'Managed settings (Recommended)', hint: 'Cannot be overridden, requires admin' },
+                { value: 'user', label: 'User settings', hint: 'Included in settings.json, editable' },
+            ],
+        });
+        if (p.isCancel(securityChoice)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        securityMode = securityChoice;
+    }
+    // Start spinner immediately after prompts — covers path resolution + git detection
+    const s = p.spinner();
+    s.start('Resolving paths');
+    // Get installation paths
     let claudeDir;
     let devflowDir;
     let gitRoot = null;
@@ -203,468 +179,228 @@ export const initCommand = new Command('init')
         const paths = await getInstallationPaths(scope);
         claudeDir = paths.claudeDir;
         devflowDir = paths.devflowDir;
-        // Cache git root for later use (already computed in getInstallationPaths for local scope)
-        gitRoot = await getGitRoot();
-        if (verbose) {
-            console.log(`📍 Installation scope: ${scope}`);
-            console.log(`   Claude dir: ${claudeDir}`);
-            console.log(`   DevFlow dir: ${devflowDir}\n`);
-        }
+        gitRoot = paths.gitRoot ?? await getGitRoot();
     }
     catch (error) {
-        console.error('❌ Path configuration error:', error instanceof Error ? error.message : error);
+        s.stop('Path resolution failed');
+        p.log.error(`Path configuration error: ${error instanceof Error ? error.message : error}`);
         process.exit(1);
     }
-    // Check for Claude Code (only for user scope)
-    if (scope === 'user') {
+    // Validate target directory
+    s.message('Validating target directory');
+    if (scope === 'local') {
         try {
-            await fs.access(claudeDir);
+            await fs.mkdir(claudeDir, { recursive: true });
         }
-        catch {
-            console.error(`❌ Claude Code not detected at ${claudeDir}`);
-            console.error('   Install from: https://claude.com/claude-code');
-            console.error('   Or set CLAUDE_CODE_DIR if installed elsewhere\n');
+        catch (error) {
+            s.stop('Installation failed');
+            p.log.error(`Failed to create ${claudeDir}: ${error}`);
             process.exit(1);
         }
-        if (verbose) {
-            console.log('✓ Claude Code detected');
-        }
     }
     else {
-        // Local scope - create .claude directory if it doesn't exist
         try {
-            await fs.mkdir(claudeDir, { recursive: true });
-            if (verbose) {
-                console.log('✓ Local .claude directory ready');
-            }
+            await fs.access(claudeDir);
         }
-        catch (error) {
-            console.error(`❌ Failed to create ${claudeDir}:`, error);
+        catch {
+            s.stop('Installation failed');
+            p.log.error(`Claude Code not detected at ${claudeDir}`);
+            p.log.info('Install from: https://claude.ai/download');
             process.exit(1);
         }
     }
-    // Get the root directory of the devflow package
+    // Resolve plugins and deduplication maps
+    s.message('Installing components');
     const rootDir = path.resolve(__dirname, '../..');
-    const claudeSourceDir = path.join(rootDir, 'src', 'claude');
-    try {
-        // DevFlow namespace directories (single source of truth)
-        const devflowDirectories = [
-            {
-                target: path.join(claudeDir, 'commands', 'devflow'),
-                source: path.join(claudeSourceDir, 'commands', 'devflow'),
-                name: 'commands'
-            },
-            {
-                target: path.join(claudeDir, 'agents', 'devflow'),
-                source: path.join(claudeSourceDir, 'agents', 'devflow'),
-                name: 'agents'
-            },
-            {
-                target: path.join(claudeDir, 'skills'),
-                source: path.join(claudeSourceDir, 'skills', 'devflow'),
-                name: 'skills'
-            },
-            {
-                target: path.join(devflowDir, 'scripts'),
-                source: path.join(claudeSourceDir, 'scripts'),
-                name: 'scripts'
-            }
-        ];
-        // Clean old DevFlow files before installing
-        for (const dir of devflowDirectories) {
-            if (dir.name === 'skills') {
-                // Special handling for skills: clean old nested structure and individual skills
-                // Remove old devflow/ subdirectory if it exists (migration from old structure)
-                const oldSkillsDir = path.join(claudeDir, 'skills', 'devflow');
-                try {
-                    await fs.rm(oldSkillsDir, { recursive: true, force: true });
-                }
-                catch (e) {
-                    // Directory might not exist
-                }
-                // Remove individual skill directories that we're about to reinstall
-                try {
-                    const skillEntries = await fs.readdir(dir.source, { withFileTypes: true });
-                    for (const entry of skillEntries) {
-                        if (entry.isDirectory()) {
-                            const skillTarget = path.join(dir.target, entry.name);
-                            try {
-                                await fs.rm(skillTarget, { recursive: true, force: true });
-                            }
-                            catch (e) {
-                                // Skill might not exist
-                            }
-                        }
-                    }
-                }
-                catch (e) {
-                    // Source directory might not exist
-                }
-            }
-            else {
-                // For other components (commands, agents, scripts), clean the entire directory
-                try {
-                    await fs.rm(dir.target, { recursive: true, force: true });
-                }
-                catch (e) {
-                    // Directory might not exist on first install
-                }
-            }
-        }
-        // Install all DevFlow components
-        for (const dir of devflowDirectories) {
-            await fs.mkdir(dir.target, { recursive: true });
-            await copyDirectory(dir.source, dir.target);
-        }
-        // Make scripts executable
-        const scriptsDir = devflowDirectories.find(d => d.name === 'scripts').target;
-        const scripts = await fs.readdir(scriptsDir);
-        for (const script of scripts) {
-            await fs.chmod(path.join(scriptsDir, script), 0o755);
-        }
-        if (verbose) {
-            console.log('✓ Installing components... (commands, agents, skills, scripts)');
+    const pluginsDir = path.join(rootDir, 'plugins');
+    let pluginsToInstall = selectedPlugins.length > 0
+        ? DEVFLOW_PLUGINS.filter(p => selectedPlugins.includes(p.name))
+        : DEVFLOW_PLUGINS.filter(p => !p.optional);
+    const coreSkillsPlugin = DEVFLOW_PLUGINS.find(p => p.name === 'devflow-core-skills');
+    if (pluginsToInstall.length > 0 && coreSkillsPlugin && !pluginsToInstall.includes(coreSkillsPlugin)) {
+        pluginsToInstall = [coreSkillsPlugin, ...pluginsToInstall];
+    }
+    const { skillsMap, agentsMap } = buildAssetMaps(pluginsToInstall);
+    // Install: try native CLI first, fall back to file copy
+    const cliAvailable = isClaudeCliAvailable();
+    const usedNativeCli = cliAvailable && installViaCli(pluginsToInstall, scope, s);
+    if (!usedNativeCli) {
+        if (cliAvailable && verbose) {
+            p.log.warn('Claude CLI installation failed, falling back to manual copy');
         }
-        // Install settings.json - never override existing files (atomic operation)
-        const settingsPath = path.join(claudeDir, 'settings.json');
-        const devflowSettingsPath = path.join(claudeDir, 'settings.devflow.json');
-        const sourceSettingsPath = path.join(claudeSourceDir, 'settings.json');
-        // Read template and replace ~ with actual home directory
-        const settingsTemplate = await fs.readFile(sourceSettingsPath, 'utf-8');
-        const settingsContent = settingsTemplate.replace(/~\/\.devflow\/scripts\/statusline\.sh/g, path.join(devflowDir, 'scripts', 'statusline.sh'));
-        let settingsExists = false;
         try {
-            // Atomic exclusive create - fails if file already exists
-            await fs.writeFile(settingsPath, settingsContent, { encoding: 'utf-8', flag: 'wx' });
-            if (verbose) {
-                console.log('✓ Settings configured');
-            }
+            await installViaFileCopy({
+                plugins: pluginsToInstall,
+                claudeDir,
+                pluginsDir,
+                rootDir,
+                devflowDir,
+                skillsMap,
+                agentsMap,
+                isPartialInstall: !!options.plugin,
+                teamsEnabled,
+                spinner: s,
+            });
         }
         catch (error) {
-            if (isNodeSystemError(error) && error.code === 'EEXIST') {
-                // Existing settings.json found - install as settings.devflow.json
-                settingsExists = true;
-                await fs.writeFile(devflowSettingsPath, settingsContent, 'utf-8');
-                if (verbose) {
-                    console.log('⚠️  Existing settings.json preserved → DevFlow config: settings.devflow.json');
-                }
-            }
-            else {
-                throw error;
-            }
+            s.stop('Installation failed');
+            p.log.error(`${error}`);
+            process.exit(1);
         }
-        // Install CLAUDE.md - never override existing files (atomic operation)
-        const claudeMdPath = path.join(claudeDir, 'CLAUDE.md');
-        const devflowClaudeMdPath = path.join(claudeDir, 'CLAUDE.devflow.md');
-        const sourceClaudeMdPath = path.join(claudeSourceDir, 'CLAUDE.md');
-        let claudeMdExists = false;
+    }
+    s.stop('Plugins installed');
+    // Clean up stale skills from previous installations
+    const skillsDir = path.join(claudeDir, 'skills');
+    let staleRemoved = 0;
+    for (const legacy of LEGACY_SKILL_NAMES) {
+        const legacyPath = path.join(skillsDir, legacy);
         try {
-            // Atomic exclusive create - fails if file already exists
-            const content = await fs.readFile(sourceClaudeMdPath, 'utf-8');
-            await fs.writeFile(claudeMdPath, content, { encoding: 'utf-8', flag: 'wx' });
-            if (verbose) {
-                console.log('✓ CLAUDE.md configured');
-            }
+            await fs.rm(legacyPath, { recursive: true });
+            staleRemoved++;
         }
-        catch (error) {
-            if (isNodeSystemError(error) && error.code === 'EEXIST') {
-                // Existing CLAUDE.md found - install as CLAUDE.devflow.md
-                claudeMdExists = true;
-                await fs.copyFile(sourceClaudeMdPath, devflowClaudeMdPath);
-                if (verbose) {
-                    console.log('⚠️  Existing CLAUDE.md preserved → DevFlow guide: CLAUDE.devflow.md');
-                }
+        catch {
+            // Doesn't exist — expected for most entries
+        }
+    }
+    if (staleRemoved > 0 && verbose) {
+        p.log.info(`Cleaned up ${staleRemoved} legacy skill(s)`);
+    }
+    // Clean up stale commands from previous installations (e.g., /review → /code-review)
+    const commandsDir = path.join(claudeDir, 'commands', 'devflow');
+    let staleCommandsRemoved = 0;
+    for (const legacy of LEGACY_COMMAND_NAMES) {
+        for (const suffix of ['.md', '-teams.md']) {
+            const legacyPath = path.join(commandsDir, `${legacy}${suffix}`);
+            try {
+                await fs.rm(legacyPath);
+                staleCommandsRemoved++;
             }
-            else {
-                throw error;
+            catch {
+                // Doesn't exist — expected for most entries
             }
         }
-        // Create .claudeignore in git repository root
-        let claudeignoreCreated = false;
-        try {
-            // Use cached git root (already computed and validated earlier)
-            if (!gitRoot) {
-                throw new Error('Not in a git repository');
+    }
+    if (staleCommandsRemoved > 0 && verbose) {
+        p.log.info(`Cleaned up ${staleCommandsRemoved} legacy command(s)`);
+    }
+    // === Configuration extras ===
+    const extrasOptions = buildExtrasOptions(scope, gitRoot);
+    let selectedExtras;
+    if (process.stdin.isTTY) {
+        const extrasSelection = await p.multiselect({
+            message: 'Configure extras',
+            options: extrasOptions,
+            initialValues: extrasOptions.map(o => o.value),
+            required: false,
+        });
+        if (p.isCancel(extrasSelection)) {
+            p.cancel('Installation cancelled.');
+            process.exit(0);
+        }
+        selectedExtras = extrasSelection;
+    }
+    else {
+        selectedExtras = extrasOptions.map(o => o.value);
+    }
+    // Settings may trigger its own TTY sub-prompt — run outside spinner
+    if (selectedExtras.includes('settings')) {
+        // Attempt managed settings write if user chose managed mode
+        let effectiveSecurityMode = securityMode;
+        if (securityMode === 'managed') {
+            const managed = await installManagedSettings(rootDir, verbose);
+            if (!managed) {
+                p.log.warn('Managed settings write failed — falling back to user settings');
+                effectiveSecurityMode = 'user';
             }
-            const claudeignorePath = path.join(gitRoot, '.claudeignore');
-            // Atomic exclusive create - only create if doesn't exist
-            const claudeignoreContent = `# DevFlow .claudeignore - Protects against sensitive files and context pollution
-# Generated by DevFlow - Edit as needed for your project
-
-# === SECURITY: Sensitive Files ===
-# Environment and secrets
-.env
-.env.*
-.env.local
-.env.*.local
-*.env
-.envrc
-
-# Credentials and keys
-*.key
-*.pem
-*.p12
-*.pfx
-*.cer
-*.crt
-*.der
-id_rsa
-id_dsa
-id_ecdsa
-id_ed25519
-*.ppk
-*_rsa
-*_dsa
-*secret*
-*password*
-*credential*
-credentials.json
-secrets.json
-secrets.yaml
-secrets.yml
-
-# Cloud provider credentials
-.aws/credentials
-.aws/config
-.gcp/credentials.json
-.azure/credentials
-
-# Package manager credentials
-.npmrc
-.pypirc
-.gem/credentials
-pip.conf
-
-# Database
-*.sql
-*.db
-*.sqlite
-*.sqlite3
-
-# === DEPENDENCIES & BUILD ===
-# Node.js
-node_modules/
-npm-debug.log*
-yarn-debug.log*
-yarn-error.log*
-pnpm-debug.log*
-.pnpm-store/
-
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-.Python
-env/
-venv/
-ENV/
-.venv/
-pip-log.txt
-pip-delete-this-directory.txt
-.eggs/
-*.egg-info/
-dist/
-build/
-*.whl
-
-# Ruby
-vendor/bundle/
-.bundle/
-
-# Go
-vendor/
-go.sum
-
-# Rust
-target/
-Cargo.lock
-
-# Java
-target/
-*.class
-*.jar
-*.war
-
-# PHP
-vendor/
-composer.lock
-
-# === BUILD ARTIFACTS ===
-dist/
-build/
-out/
-.next/
-.nuxt/
-.output/
-.vite/
-.cache/
-.parcel-cache/
-.turbo/
-*.tsbuildinfo
-
-# === LOGS & TEMP FILES ===
-logs/
-*.log
-*.tmp
-*.temp
-*.swp
-*.swo
-*~
-.DS_Store
-Thumbs.db
-*.bak
-*.orig
-*.rej
-.cache
-
-# === VERSION CONTROL ===
-.git/
-.svn/
-.hg/
-.gitignore
-
-# === IDE & EDITORS ===
-.vscode/
-.idea/
-*.sublime-*
-*.code-workspace
-.project
-.classpath
-.settings/
-
-# === TEST COVERAGE ===
-coverage/
-.nyc_output/
-htmlcov/
-.coverage
-.pytest_cache/
-.tox/
-
-# === OS-SPECIFIC ===
-.DS_Store
-.AppleDouble
-.LSOverride
-Thumbs.db
-ehthumbs.db
-Desktop.ini
-
-# === MEDIA & LARGE FILES ===
-*.mp4
-*.avi
-*.mov
-*.wmv
-*.flv
-*.mp3
-*.wav
-*.zip
-*.tar.gz
-*.rar
-*.7z
-*.dmg
-*.iso
-
-# === DOCUMENTATION BUILD ===
-site/
-_site/
-.docusaurus/
-.vuepress/dist/
-
-# === LOCK FILES (usually not needed for AI context) ===
-package-lock.json
-yarn.lock
-pnpm-lock.yaml
-Gemfile.lock
-poetry.lock
-Pipfile.lock
-`;
-            // Atomic exclusive create - fails if file already exists
-            await fs.writeFile(claudeignorePath, claudeignoreContent, { encoding: 'utf-8', flag: 'wx' });
-            claudeignoreCreated = true;
         }
-        catch (error) {
-            // Not a git repository or other error - skip .claudeignore creation
+        await installSettings(claudeDir, rootDir, devflowDir, verbose, teamsEnabled, effectiveSecurityMode);
+    }
+    const fileExtras = selectedExtras.filter(e => e !== 'settings' && e !== 'safe-delete');
+    if (fileExtras.length > 0) {
+        const sExtras = p.spinner();
+        sExtras.start('Configuring extras');
+        if (selectedExtras.includes('claudeignore') && gitRoot) {
+            await installClaudeignore(gitRoot, rootDir, verbose);
         }
-        if (claudeignoreCreated && verbose) {
-            console.log('✓ .claudeignore created');
+        if (selectedExtras.includes('gitignore') && gitRoot) {
+            await updateGitignore(gitRoot, verbose);
         }
-        // For local scope, update .gitignore to exclude .claude/ and .devflow/
-        if (scope === 'local' && gitRoot) {
-            try {
-                const gitignorePath = path.join(gitRoot, '.gitignore');
-                const entriesToAdd = ['.claude/', '.devflow/'];
-                let gitignoreContent = '';
-                try {
-                    gitignoreContent = await fs.readFile(gitignorePath, 'utf-8');
-                }
-                catch {
-                    // .gitignore doesn't exist, will create it
-                }
-                const linesToAdd = [];
-                for (const entry of entriesToAdd) {
-                    // Check if entry already exists (exact match or pattern)
-                    if (!gitignoreContent.split('\n').some(line => line.trim() === entry)) {
-                        linesToAdd.push(entry);
-                    }
+        if (selectedExtras.includes('docs')) {
+            await createDocsStructure(verbose);
+        }
+        sExtras.stop('Extras configured');
+    }
+    // Summary output
+    if (usedNativeCli) {
+        p.log.success('Installed via Claude plugin system');
+    }
+    else if (!cliAvailable) {
+        p.log.info('Installed via file copy (Claude CLI not available)');
+    }
+    const installedCommands = pluginsToInstall.flatMap(p => p.commands).filter(c => c.length > 0);
+    if (installedCommands.length > 0) {
+        const commandsNote = installedCommands
+            .map(cmd => color.cyan(cmd))
+            .join('  ');
+        p.note(commandsNote, 'Available commands');
+    }
+    // Safe-delete auto-install (gated by extras selection)
+    if (selectedExtras.includes('safe-delete')) {
+        const platform = detectPlatform();
+        const shell = detectShell();
+        const safeDeleteInfo = getSafeDeleteInfo(platform);
+        const safeDeleteAvailable = hasSafeDelete(platform);
+        const profilePath = getProfilePath(shell);
+        if (process.stdin.isTTY && profilePath) {
+            if (!safeDeleteAvailable && safeDeleteInfo.installHint) {
+                p.log.info(`Install ${color.cyan(safeDeleteInfo.command ?? 'trash')} first: ${color.dim(safeDeleteInfo.installHint)}`);
+                p.log.info(`Then re-run ${color.cyan('devflow init')} to auto-configure safe-delete.`);
+            }
+            else if (safeDeleteAvailable) {
+                const alreadyInstalled = await isAlreadyInstalled(profilePath);
+                if (alreadyInstalled) {
+                    p.log.info(`Safe-delete already configured in ${color.dim(profilePath)}`);
                 }
-                if (linesToAdd.length > 0) {
-                    const newContent = gitignoreContent
-                        ? `${gitignoreContent.trimEnd()}\n\n# DevFlow local scope installation\n${linesToAdd.join('\n')}\n`
-                        : `# DevFlow local scope installation\n${linesToAdd.join('\n')}\n`;
-                    await fs.writeFile(gitignorePath, newContent, 'utf-8');
-                    if (verbose) {
-                        console.log('✓ .gitignore updated (excluded .claude/ and .devflow/)');
+                else {
+                    const trashCmd = safeDeleteInfo.command;
+                    const block = generateSafeDeleteBlock(shell, process.platform, trashCmd);
+                    if (block) {
+                        const confirm = await p.confirm({
+                            message: `Install safe-delete to ${profilePath}? (overrides rm to use ${trashCmd ?? 'recycle bin'})`,
+                            initialValue: true,
+                        });
+                        if (!p.isCancel(confirm) && confirm) {
+                            await installToProfile(profilePath, block);
+                            p.log.success(`Safe-delete installed to ${color.dim(profilePath)}`);
+                            p.log.info('Restart your shell or run: ' + color.cyan(`source ${profilePath}`));
+                        }
                     }
                 }
             }
-            catch (error) {
-                if (verbose) {
-                    console.warn('⚠️  Could not update .gitignore:', error instanceof Error ? error.message : error);
-                }
-            }
         }
-        // Offer to install project documentation structure
-        let docsCreated = false;
-        if (!options.skipDocs) {
-            const docsDir = path.join(process.cwd(), '.docs');
-            try {
-                await fs.mkdir(path.join(docsDir, 'status', 'compact'), { recursive: true });
-                await fs.mkdir(path.join(docsDir, 'reviews'), { recursive: true });
-                await fs.mkdir(path.join(docsDir, 'audits', 'standalone'), { recursive: true });
-                await fs.mkdir(path.join(docsDir, 'releases'), { recursive: true });
-                docsCreated = true;
+        else if (!process.stdin.isTTY) {
+            if (safeDeleteAvailable && safeDeleteInfo.command) {
+                p.log.info(`Safe-delete available (${safeDeleteInfo.command}). Run interactively to auto-install.`);
             }
-            catch (error) {
-                // .docs/ structure may already exist
+            else if (safeDeleteInfo.installHint) {
+                p.log.info(`Protect against accidental ${color.red('rm -rf')}: ${color.cyan(safeDeleteInfo.installHint)}`);
             }
         }
-        if (docsCreated && verbose) {
-            console.log('✓ .docs/ structure ready');
-        }
-        // Render output based on verbose flag
-        if (verbose) {
-            renderVerboseOutput(version, scope, claudeDir, devflowDir, settingsExists, claudeMdExists);
-        }
-        else {
-            renderCleanOutput(version);
-        }
     }
-    catch (error) {
-        console.error('❌ Installation failed:', error);
-        process.exit(1);
+    // Verbose mode: show details
+    if (verbose) {
+        const pluginsList = pluginsToInstall
+            .map(plugin => `${color.yellow(plugin.name.padEnd(24))}${color.dim(plugin.description)}`)
+            .join('\n');
+        p.note(pluginsList, 'Installed plugins');
+        p.log.info(`Scope: ${scope}`);
+        p.log.info(`Claude dir: ${claudeDir}`);
+        p.log.info(`DevFlow dir: ${devflowDir}`);
+        const totalSkillDeclarations = pluginsToInstall.reduce((sum, p) => sum + p.skills.length, 0);
+        const totalAgentDeclarations = pluginsToInstall.reduce((sum, p) => sum + p.agents.length, 0);
+        p.log.info(`Deduplication: ${skillsMap.size} unique skills (from ${totalSkillDeclarations} declarations)`);
+        p.log.info(`Deduplication: ${agentsMap.size} unique agents (from ${totalAgentDeclarations} declarations)`);
     }
+    p.outro(color.green('Ready! Run any command in Claude Code to get started.'));
 });
-async function copyDirectory(src, dest) {
-    await fs.mkdir(dest, { recursive: true });
-    const entries = await fs.readdir(src, { withFileTypes: true });
-    for (const entry of entries) {
-        const srcPath = path.join(src, entry.name);
-        const destPath = path.join(dest, entry.name);
-        if (entry.isDirectory()) {
-            await copyDirectory(srcPath, destPath);
-        }
-        else {
-            await fs.copyFile(srcPath, destPath);
-        }
-    }
-}
 //# sourceMappingURL=init.js.map