sdd-mcp-server 3.3.0 → 3.5.0

package/dist/cli/install-skills.js

@@ -1,6 +1,7 @@
 #!/usr/bin/env node
 import * as fs from 'fs';
 import * as path from 'path';
+import { createInterface } from 'readline/promises';
 import { SkillManager } from '../skills/SkillManager.js';
 import { RulesManager } from '../rules/RulesManager.js';
 import { ContextManager } from '../contexts/ContextManager.js';
@@ -8,7 +9,11 @@ import { AgentManager } from '../agents/AgentManager.js';
 import { HookLoader } from '../hooks/HookLoader.js';
 import { generateCodexAgentsMd } from './tool-support/codex.js';
 import { createAntigravitySymlinks } from './tool-support/antigravity.js';
-import { getDistCliDir, findTemplate } from './utils/find-package-root.js';
+import { getDistCliDir } from './utils/find-package-root.js';
+import { CliUsageError, InstallCancelledError, getTargetPolicy, isInstallTarget, resolveInstallPaths, resolveInstallTarget, } from './install-target.js';
+import { installClaudeCodeTarget } from './tool-support/claude-code.js';
+import { installCodexTarget } from './tool-support/codex.js';
+import { updateGeneratedIgnores } from './utils/gitignore-manager.js';
 /**
  * CLI for installing SDD components to a project
  */
@@ -19,12 +24,13 @@ export class InstallSkillsCLI {
     agentManager;
     hookLoader;
     steeringPath;
+    promptIO;
     /**
      * Create CLI instance
      * @param skillsPath - Optional path to skills directory (for testing)
      * @param steeringPath - Optional path to steering directory (for testing)
      */
-    constructor(skillsPath, steeringPath) {
+    constructor(skillsPath, steeringPath, promptIO) {
         // If no path provided, determine from package location
         const resolvedSkillsPath = skillsPath || this.getDefaultPath('skills');
         const resolvedSteeringPath = steeringPath || this.getDefaultPath('steering');
@@ -38,6 +44,7 @@ export class InstallSkillsCLI {
         this.agentManager = new AgentManager(resolvedAgentsPath);
         this.hookLoader = new HookLoader(resolvedHooksPath);
         this.steeringPath = resolvedSteeringPath;
+        this.promptIO = promptIO ?? createProcessTargetPromptIO();
     }
     /**
      * Get the default path for a component type based on package location
@@ -99,40 +106,44 @@ export class InstallSkillsCLI {
             codex: false,
             antigravity: false,
             allTools: false,
+            installProfile: 'lean',
+            pathOverrides: {},
         };
         for (let i = 0; i < args.length; i++) {
             const arg = args[i];
             switch (arg) {
                 case '--path':
-                    if (i + 1 < args.length) {
-                        options.targetPath = args[++i];
-                    }
+                    options.targetPath = requireOptionValue(args, ++i, '--path');
+                    options.pathOverrides.skills = options.targetPath;
                     break;
                 case '--steering-path':
-                    if (i + 1 < args.length) {
-                        options.steeringPath = args[++i];
-                    }
+                    options.steeringPath = requireOptionValue(args, ++i, '--steering-path');
+                    options.pathOverrides.steering = options.steeringPath;
                     break;
                 case '--rules-path':
-                    if (i + 1 < args.length) {
-                        options.rulesPath = args[++i];
-                    }
+                    options.rulesPath = requireOptionValue(args, ++i, '--rules-path');
+                    options.pathOverrides.rules = options.rulesPath;
                     break;
                 case '--contexts-path':
-                    if (i + 1 < args.length) {
-                        options.contextsPath = args[++i];
-                    }
+                    options.contextsPath = requireOptionValue(args, ++i, '--contexts-path');
+                    options.pathOverrides.contexts = options.contextsPath;
                     break;
                 case '--agents-path':
-                    if (i + 1 < args.length) {
-                        options.agentsPath = args[++i];
-                    }
+                    options.agentsPath = requireOptionValue(args, ++i, '--agents-path');
+                    options.pathOverrides.agents = options.agentsPath;
                     break;
                 case '--hooks-path':
-                    if (i + 1 < args.length) {
-                        options.hooksPath = args[++i];
+                    options.hooksPath = requireOptionValue(args, ++i, '--hooks-path');
+                    options.pathOverrides.hooks = options.hooksPath;
+                    break;
+                case '--target': {
+                    const target = requireOptionValue(args, ++i, '--target');
+                    if (!isInstallTarget(target)) {
+                        throw new CliUsageError(`Unsupported target "${target}". Choose codex or claude-code.`);
                     }
+                    options.target = target;
                     break;
+                }
                 case '--list':
                 case '-l':
                     options.listOnly = true;
@@ -165,8 +176,18 @@ export class InstallSkillsCLI {
                     options.hooksOnly = true;
                     options.components.push('hooks');
                     break;
+                case '--profile':
+                    {
+                        const profile = requireOptionValue(args, ++i, '--profile');
+                        if (profile !== 'lean' && profile !== 'full') {
+                            throw new CliUsageError(`Unsupported profile "${profile}". Choose lean or full.`);
+                        }
+                        options.installProfile = profile;
+                    }
+                    break;
                 case '--all':
                     // Install all component types
+                    options.installProfile = 'full';
                     options.components = ['skills', 'steering', 'rules', 'contexts', 'agents', 'hooks'];
                     break;
                 case '--codex':
@@ -198,7 +219,7 @@ export class InstallSkillsCLI {
         await this.installSkills(options.targetPath);
     }
     /**
-     * Run unified install (all components)
+     * Run a target-aware component install
      * @param options - CLI options
      */
     async runUnified(options) {
@@ -210,89 +231,109 @@ export class InstallSkillsCLI {
             await this.listAll();
             return;
         }
+        const resolvedTarget = await resolveInstallTarget({
+            target: options.target,
+            legacyCodex: options.codex,
+            profile: options.installProfile,
+        }, this.promptIO);
+        const policy = getTargetPolicy(resolvedTarget.target);
+        const paths = resolveInstallPaths(policy, options.pathOverrides ?? legacyPathOverrides(options));
         // If specific components requested, install only those
         const hasSpecificComponents = options.components.length > 0;
         const componentsToInstall = hasSpecificComponents
             ? options.components
-            : ['skills', 'steering', 'rules', 'contexts', 'agents', 'hooks'];
-        console.log('\n🚀 SDD Component Installer\n');
-        for (const component of componentsToInstall) {
-            switch (component) {
-                case 'skills':
-                    await this.installSkills(options.targetPath);
-                    break;
-                case 'steering':
-                    await this.installSteering(options.steeringPath);
-                    break;
-                case 'rules':
-                    await this.installRules(options.rulesPath);
-                    break;
-                case 'contexts':
-                    await this.installContexts(options.contextsPath);
-                    break;
-                case 'agents':
-                    await this.installAgents(options.agentsPath);
-                    break;
-                case 'hooks':
-                    await this.installHooks(options.hooksPath);
-                    break;
-            }
+            : this.getDefaultComponents(options.installProfile);
+        console.log(`\n🚀 SDD Component Installer (${options.installProfile} profile, ${resolvedTarget.target})\n`);
+        const projectRoot = process.cwd();
+        const request = {
+            projectRoot,
+            paths,
+            components: componentsToInstall,
+            sources: {
+                skillManager: this.skillManager,
+                rulesManager: this.rulesManager,
+                contextManager: this.contextManager,
+                agentManager: this.agentManager,
+                hookLoader: this.hookLoader,
+                steeringSource: this.steeringPath,
+            },
+        };
+        const report = resolvedTarget.target === 'codex'
+            ? await installCodexTarget(request)
+            : await installClaudeCodeTarget(request);
+        try {
+            const ignore = await updateGeneratedIgnores(projectRoot, policy.ignoreEntries);
+            console.log(`  .gitignore: ${ignore.status}`);
+        }
+        catch (error) {
+            report.failed.push({
+                component: 'root',
+                name: '.gitignore',
+                path: path.join(projectRoot, '.gitignore'),
+                error: error instanceof Error ? error.message : String(error),
+            });
         }
-        // Generate CLAUDE.md in project root
-        this.generateClaudeMd();
         // Multi-tool support: Codex CLI
-        if (options.codex || options.allTools) {
-            const projectRoot = process.cwd();
-            await generateCodexAgentsMd(projectRoot, {
+        if (options.allTools && resolvedTarget.target !== 'codex') {
+            const failures = await generateCodexAgentsMd(projectRoot, {
                 skillManager: this.skillManager,
                 rulesManager: this.rulesManager,
                 agentManager: this.agentManager,
                 listSteering: () => this.listSteering(),
             }, {
-                skillsPath: options.targetPath,
-                rulesPath: options.rulesPath,
-                agentsPath: options.agentsPath,
-                steeringPath: options.steeringPath,
+                skillsPath: paths.skills,
+                rulesPath: paths.rules,
+                agentsPath: paths.agents,
+                steeringPath: paths.steering,
             }, {
                 skills: componentsToInstall.includes('skills'),
                 rules: componentsToInstall.includes('rules'),
                 agents: componentsToInstall.includes('agents'),
                 steering: componentsToInstall.includes('steering'),
             });
+            for (const failure of failures) {
+                report.failed.push({
+                    component: 'root',
+                    name: `codex/${failure.name}`,
+                    path: failure.path,
+                    error: failure.error,
+                });
+            }
         }
         // Multi-tool support: Google Antigravity
         if (options.antigravity || options.allTools) {
-            const projectRoot = process.cwd();
-            await createAntigravitySymlinks(projectRoot, {
-                skillsPath: options.targetPath,
-                rulesPath: options.rulesPath,
+            const failures = await createAntigravitySymlinks(projectRoot, {
+                skillsPath: paths.skills,
+                rulesPath: paths.rules,
             });
+            for (const failure of failures) {
+                report.failed.push({
+                    component: 'root',
+                    name: failure.name === '.agent' ? failure.name : `.agent/${failure.name}`,
+                    path: failure.path,
+                    error: failure.error,
+                });
+            }
         }
-        console.log('\n✨ Installation complete!\n');
-    }
-    /**
-     * Generate CLAUDE.md in the user's project root from the template
-     */
-    generateClaudeMd() {
-        const targetPath = path.resolve(process.cwd(), 'CLAUDE.md');
-        // Don't overwrite if user already has one
-        if (fs.existsSync(targetPath)) {
-            console.log('  ⏭️  CLAUDE.md already exists, skipping');
-            return;
-        }
-        // Find the template
-        const templatePath = findTemplate('CLAUDE.md');
-        if (!templatePath) {
-            console.log('  ⚠️  CLAUDE.md template not found, skipping');
+        console.log(`\nTarget: ${resolvedTarget.target} (${resolvedTarget.source})`);
+        console.log(`Installed: ${report.installed.length}`);
+        console.log(`Skipped: ${report.skipped.length}`);
+        console.log(`Failed: ${report.failed.length}`);
+        if (report.failed.length > 0) {
+            for (const failure of report.failed) {
+                console.error(`  ${failure.component}/${failure.name} (${failure.path}): ${failure.error}`);
+            }
+            process.exitCode = 1;
+            console.error('\nInstallation incomplete.\n');
             return;
         }
-        try {
-            fs.copyFileSync(templatePath, targetPath);
-            console.log('  ✅ Created CLAUDE.md in project root');
-        }
-        catch (error) {
-            console.error('  ❌ Failed to create CLAUDE.md:', error.message);
+        console.log('\n✨ Installation complete!\n');
+    }
+    getDefaultComponents(profile) {
+        if (profile === 'full') {
+            return ['skills', 'steering', 'rules', 'contexts', 'agents', 'hooks'];
         }
+        return ['skills', 'steering', 'hooks'];
     }
     /**
      * List available skills
@@ -426,7 +467,7 @@ export class InstallSkillsCLI {
             }
             console.log(`\n  Total: ${hooks.length} hooks\n`);
         }
-        console.log('Run "npx sdd-mcp-server install" to install all components.\n');
+        console.log('Run "npx sdd-mcp-server install --profile full" to install all components.\n');
     }
     /**
      * Install skills to target directory
@@ -440,49 +481,6 @@ export class InstallSkillsCLI {
             console.log('   Use /sdd-requirements, /sdd-design, etc. in Claude Code.\n');
         }
     }
-    /**
-     * Install steering documents to target directory
-     */
-    async installSteering(targetPath) {
-        console.log(`\nInstalling steering documents to: ${targetPath}\n`);
-        const result = await this.installSteeringFiles(targetPath);
-        this.logInstallResult(result, 'steering documents');
-        if (result.installed.length > 0) {
-            console.log('Steering documents installed successfully!');
-            console.log('   These provide project-wide guidance for AI interactions.\n');
-        }
-    }
-    /**
-     * Copy steering files to target directory
-     */
-    async installSteeringFiles(targetPath) {
-        const installed = [];
-        const failed = [];
-        try {
-            await fs.promises.mkdir(targetPath, { recursive: true });
-            const entries = await fs.promises.readdir(this.steeringPath);
-            for (const entry of entries) {
-                if (!entry.endsWith('.md'))
-                    continue;
-                try {
-                    const sourceFile = path.join(this.steeringPath, entry);
-                    const destFile = path.join(targetPath, entry);
-                    await fs.promises.copyFile(sourceFile, destFile);
-                    installed.push(entry);
-                }
-                catch (error) {
-                    failed.push({
-                        name: entry,
-                        error: error instanceof Error ? error.message : String(error),
-                    });
-                }
-            }
-        }
-        catch (error) {
-            console.error(`Failed to read steering directory: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return { installed, failed };
-    }
     /**
      * Log installation results with consistent formatting
      */
@@ -502,38 +500,6 @@ export class InstallSkillsCLI {
             console.log('');
         }
     }
-    /**
-     * Install rules to target directory
-     */
-    async installRules(targetPath) {
-        console.log(`Installing rules to: ${targetPath}\n`);
-        const result = await this.rulesManager.installComponents(targetPath);
-        this.logInstallResult(result, 'rules');
-    }
-    /**
-     * Install contexts to target directory
-     */
-    async installContexts(targetPath) {
-        console.log(`Installing contexts to: ${targetPath}\n`);
-        const result = await this.contextManager.installComponents(targetPath);
-        this.logInstallResult(result, 'contexts');
-    }
-    /**
-     * Install agents to target directory
-     */
-    async installAgents(targetPath) {
-        console.log(`Installing agents to: ${targetPath}\n`);
-        const result = await this.agentManager.installComponents(targetPath);
-        this.logInstallResult(result, 'agents');
-    }
-    /**
-     * Install hooks to target directory
-     */
-    async installHooks(targetPath) {
-        console.log(`Installing hooks to: ${targetPath}\n`);
-        const result = await this.hookLoader.installComponents(targetPath);
-        this.logInstallResult(result, 'hooks');
-    }
     /**
      * Get help text
      * @returns Help message
@@ -574,27 +540,31 @@ SDD Unified Installer
 
 Usage: npx sdd-mcp-server install [options]
 
-Installs SDD components (skills, steering, rules, contexts, agents, hooks) to your project.
+Installs SDD components to your project. The default lean profile installs skills,
+steering, and hooks only to reduce always-on context and token usage.
 
 Component Options (install specific types):
-  --skills              Install skills only (to .claude/skills)
+  --target <target>     Primary agent target: codex or claude-code
+  --skills              Install skills only (to the selected target)
   --steering            Install steering documents only (to .spec/steering)
-  --rules               Install rules only (to .claude/rules)
-  --contexts            Install contexts only (to .claude/contexts)
-  --agents              Install agents only (to .claude/agents)
-  --hooks               Install hooks only (to .claude/hooks)
-  --all                 Install all component types (default behavior)
+  --rules               Install rules only (to the selected target)
+  --contexts            Install contexts only (to the selected target)
+  --agents              Install agents only (to the selected target)
+  --hooks               Install hooks only (to the selected target)
+  --all                 Install all component types
+  --profile <profile>   Install profile when no component flags are provided:
+                        lean (default) or full
 
 Path Options (customize installation targets):
-  --path <dir>          Target for skills (default: .claude/skills)
+  --path <dir>          Override the selected target's skills path
   --steering-path <dir> Target for steering (default: .spec/steering)
-  --rules-path <dir>    Target for rules (default: .claude/rules)
-  --contexts-path <dir> Target for contexts (default: .claude/contexts)
-  --agents-path <dir>   Target for agents (default: .claude/agents)
-  --hooks-path <dir>    Target for hooks (default: .claude/hooks)
+  --rules-path <dir>    Override the selected target's rules path
+  --contexts-path <dir> Override the selected target's contexts path
+  --agents-path <dir>   Override the selected target's agents path
+  --hooks-path <dir>    Override the selected target's hooks path
 
 Multi-Tool Support:
-  --codex               Also generate AGENTS.md for OpenAI Codex CLI
+  --codex               Deprecated alias for --target codex
   --antigravity         Also create .agent/ symlinks for Google Antigravity
   --all-tools           Enable all tool integrations (codex + antigravity)
 
@@ -603,12 +573,14 @@ Other Options:
   --help, -h            Show this help message
 
 Examples:
-  npx sdd-mcp-server install                     # Install all components
+  npx sdd-mcp-server install                     # Lean install for lower token usage
   npx sdd-mcp-server install --skills --rules    # Install skills and rules only
   npx sdd-mcp-server install --list              # List available components
-  npx sdd-mcp-server install --codex             # Claude + Codex CLI support
-  npx sdd-mcp-server install --antigravity       # Claude + Antigravity support
-  npx sdd-mcp-server install --all-tools         # Claude + all tool integrations
+  npx sdd-mcp-server install --profile full       # Prompt for Codex or Claude Code
+  npx sdd-mcp-server install --target codex       # Native Codex files
+  npx sdd-mcp-server install --target claude-code # Native Claude Code files
+  npx sdd-mcp-server install --antigravity       # Add Antigravity support
+  npx sdd-mcp-server install --all-tools         # Add all tool integrations
 
 Component Types:
   Skills    - Workflow guidance for SDD phases (/sdd-requirements, /sdd-design, etc.)
@@ -618,7 +590,7 @@ Component Types:
   Agents    - Specialized AI personas (planner, architect, reviewer)
   Hooks     - Event-driven automation (pre-tool-use, post-tool-use, etc.)
 
-After installation, use skills in Claude Code:
+After installation, use skills in the selected agent:
   /sdd-requirements <feature-name>
   /sdd-design <feature-name>
   /sdd-tasks <feature-name>
@@ -626,6 +598,11 @@ After installation, use skills in Claude Code:
   /sdd-review [file-path]
   /sdd-security-check [scope]
   /sdd-test-gen [file-path]
+
+Model Routing:
+  Codex high-level roles: gpt-5.6-sol (xhigh); default implementation/TDD: gpt-5.6-luna (max)
+  Codex supported models: gpt-5.6-sol, gpt-5.6-luna, gpt-5.6-terra
+  Claude Code high-level roles: opus; implementation/TDD: sonnet
 `;
     }
 }
@@ -641,6 +618,11 @@ export async function mainInstall() {
     const options = cli.parseArgs(process.argv.slice(2));
     await cli.runUnified(options);
 }
+export function cliExitCode(error) {
+    if (error instanceof InstallCancelledError)
+        return 130;
+    return 1;
+}
 // ESM main module detection: check if this file is the entry point
 // Use path matching instead of import.meta.url for Jest compatibility
 const isMainModule = process.argv[1] && (process.argv[1].endsWith('/install-skills.js') ||
@@ -650,7 +632,82 @@ const isMainModule = process.argv[1] && (process.argv[1].endsWith('/install-skil
 if (isMainModule) {
     main().catch((error) => {
         console.error('Error:', error.message);
-        process.exit(1);
+        process.exit(cliExitCode(error));
     });
 }
+function requireOptionValue(args, index, option) {
+    const value = args[index];
+    if (!value || value.startsWith('--')) {
+        throw new CliUsageError(`${option} requires a value`);
+    }
+    return value;
+}
+function legacyPathOverrides(options) {
+    const defaults = getTargetPolicy('claude-code').defaultPaths;
+    return {
+        ...(options.targetPath !== defaults.skills ? { skills: options.targetPath } : {}),
+        ...(options.steeringPath !== defaults.steering ? { steering: options.steeringPath } : {}),
+        ...(options.rulesPath !== defaults.rules ? { rules: options.rulesPath } : {}),
+        ...(options.contextsPath !== defaults.contexts ? { contexts: options.contextsPath } : {}),
+        ...(options.agentsPath !== defaults.agents ? { agents: options.agentsPath } : {}),
+        ...(options.hooksPath !== defaults.hooks ? { hooks: options.hooksPath } : {}),
+    };
+}
+function createProcessTargetPromptIO() {
+    return {
+        isInteractive: () => Boolean(process.stdin.isTTY && process.stdout.isTTY),
+        writeNotice: message => console.warn(message),
+        async chooseTarget() {
+            const prompt = createInterface({ input: process.stdin, output: process.stdout });
+            let cancelled = false;
+            try {
+                while (!cancelled) {
+                    const answer = await new Promise(resolve => {
+                        let settled = false;
+                        const cleanup = () => {
+                            prompt.off('line', onLine);
+                            prompt.off('close', onClose);
+                            prompt.off('SIGINT', onSigint);
+                        };
+                        const settle = (value) => {
+                            if (settled)
+                                return;
+                            settled = true;
+                            cleanup();
+                            resolve(value);
+                        };
+                        const onLine = (line) => settle(line);
+                        const onClose = () => settle(null);
+                        const onSigint = () => {
+                            settle(null);
+                            prompt.close();
+                        };
+                        prompt.once('line', onLine);
+                        prompt.once('close', onClose);
+                        prompt.once('SIGINT', onSigint);
+                        prompt.question('Choose the primary LLM agent target:\n  1) Codex\n  2) Claude Code\nSelection: ').then(settle).catch(() => settle(null));
+                    });
+                    if (answer === null) {
+                        cancelled = true;
+                        continue;
+                    }
+                    const normalized = answer.trim().toLowerCase();
+                    if (normalized === '1' || normalized === 'codex')
+                        return 'codex';
+                    if (normalized === '2' || normalized === 'claude' || normalized === 'claude-code') {
+                        return 'claude-code';
+                    }
+                    console.warn('Choose 1 (Codex) or 2 (Claude Code).');
+                }
+                return null;
+            }
+            catch {
+                return null;
+            }
+            finally {
+                prompt.close();
+            }
+        },
+    };
+}
 //# sourceMappingURL=install-skills.js.map