@uxmaltech/collab-cli 0.1.0

package/dist/stages/agent-skills-setup.js

@@ -0,0 +1,301 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.agentSkillsSetupStage = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const canon_resolver_1 = require("../lib/canon-resolver");
+const orchestrator_1 = require("../lib/orchestrator");
+const providers_1 = require("../lib/providers");
+/**
+ * Agent prompt files from collab-architecture/prompts/agents/.
+ * Each entry maps a skill name to its canon path.
+ */
+const AGENT_PROMPTS = [
+    {
+        name: 'phase-1-survey',
+        description: 'GOV-R-001 Phase 1 — Explore codebase, map files, check duplication, propose design.',
+        canonPath: 'prompts/agents/phase-1-survey.md',
+    },
+    {
+        name: 'phase-2-change-plan',
+        description: 'GOV-R-001 Phase 2 — Produce a detailed implementation plan for the change.',
+        canonPath: 'prompts/agents/phase-2-change-plan.md',
+    },
+    {
+        name: 'phase-3-implementation',
+        description: 'GOV-R-001 Phase 3 — Execute the implementation following the approved change plan.',
+        canonPath: 'prompts/agents/phase-3-implementation.md',
+    },
+    {
+        name: 'phase-4-repo-hygiene',
+        description: 'GOV-R-001 Phase 4 — Verify repo hygiene: tests, lint, docs, dead code.',
+        canonPath: 'prompts/agents/phase-4-repo-hygiene.md',
+    },
+    {
+        name: 'phase-5-canon-sync',
+        description: 'GOV-R-001 Phase 5 — Sync changes back to canonical architecture.',
+        canonPath: 'prompts/agents/phase-5-canon-sync.md',
+    },
+    {
+        name: 'architecture-reviewer',
+        description: 'Thematic agent — Reviews code against canonical rules and patterns.',
+        canonPath: 'prompts/agents/architecture-reviewer.md',
+    },
+    {
+        name: 'drift-detector',
+        description: 'Thematic agent — Detects drift between code and canonical architecture.',
+        canonPath: 'prompts/agents/drift-detector.md',
+    },
+    {
+        name: 'pattern-extractor',
+        description: 'Thematic agent — Extracts reusable patterns from implementation.',
+        canonPath: 'prompts/agents/pattern-extractor.md',
+    },
+];
+// ────────────────────────────────────────────────────────────────
+// Mode-aware architecture access preambles
+// ────────────────────────────────────────────────────────────────
+function buildArchitectureAccessBlock(mode, repoConfig, workspaceConfig) {
+    const lines = [];
+    if (mode === 'indexed') {
+        lines.push('## Architecture Access (MCP)', '', 'This project uses an MCP server for architecture retrieval.', '', '**MCP Tools (collab-architecture server):**', '- `context.scopes.list.v2` — List available scopes and collections', '- `context.vector.search.v2` — Semantic search across architecture docs', '- `context.graph.degree.search.v2` — Graph traversal for related concepts', '', '**Also consult local files:**', '- `docs/ai/` — Quick reference helpers (start here for fast context)', '- `docs/architecture/repo/` — Project-specific canons and decisions', '- `.agents/skills/` — Governance phase guidance');
+    }
+    else {
+        lines.push('## Architecture Access', '', 'Read architecture context from local files:');
+        if (repoConfig && workspaceConfig) {
+            lines.push('- `../../docs/architecture/uxmaltech/` — Institutional canon (collab-architecture)');
+        }
+        else {
+            lines.push('- `docs/architecture/uxmaltech/` — Institutional canon (collab-architecture)');
+        }
+        lines.push('- `docs/architecture/repo/` — Project-specific canons and decisions', '- `docs/ai/` — Quick reference helpers (start here for fast context)');
+    }
+    // Append workspace context when running inside a multi-repo workspace
+    if (repoConfig && workspaceConfig) {
+        const otherRepos = workspaceConfig.repos.filter((r) => r !== repoConfig.name);
+        lines.push('', '## Workspace Context', '', `This repo (\`${repoConfig.name}\`) is part of a multi-repo workspace.`);
+        if (otherRepos.length > 0) {
+            lines.push(`Other repos: ${otherRepos.map((r) => '`' + r + '`').join(', ')}`);
+            lines.push(`Access sibling repos via: ${otherRepos.map((r) => '`../../' + r + '/`').join(', ')}`);
+        }
+        if (repoConfig) {
+            lines.push('Shared canonical architecture: `../../docs/architecture/uxmaltech/`');
+        }
+    }
+    return lines.join('\n');
+}
+// ────────────────────────────────────────────────────────────────
+// Generator functions
+// ────────────────────────────────────────────────────────────────
+/**
+ * Generates Agent Skills Spec SKILL.md files for Claude, Codex, and Gemini.
+ * Format: .agents/skills/<name>/SKILL.md with YAML frontmatter.
+ */
+function generateAgentSkillsSpec(ctx, mode, repoConfig, workspaceConfig) {
+    const skillsBaseDir = node_path_1.default.join((0, orchestrator_1.getRepoBaseDir)(ctx), '.agents', 'skills');
+    const preamble = buildArchitectureAccessBlock(mode, repoConfig, workspaceConfig);
+    let written = 0;
+    for (const agent of AGENT_PROMPTS) {
+        const content = (0, canon_resolver_1.resolveCanonFile)(agent.canonPath);
+        if (!content) {
+            ctx.logger.debug(`Skipping skill ${agent.name}: prompt not found at ${agent.canonPath}`);
+            continue;
+        }
+        const skillDir = node_path_1.default.join(skillsBaseDir, agent.name);
+        const skillFile = node_path_1.default.join(skillDir, 'SKILL.md');
+        // Don't overwrite existing skill files
+        if (node_fs_1.default.existsSync(skillFile)) {
+            ctx.logger.debug(`Skill already exists, skipping: ${agent.name}`);
+            continue;
+        }
+        const skillContent = [
+            '---',
+            `name: ${agent.name}`,
+            `description: "${agent.description}"`,
+            '---',
+            '',
+            preamble,
+            '',
+            content,
+        ].join('\n');
+        ctx.executor.ensureDirectory(skillDir);
+        ctx.executor.writeFile(skillFile, skillContent, {
+            description: `write agent skill ${agent.name}`,
+        });
+        written++;
+    }
+    return written;
+}
+/**
+ * Generates GitHub Copilot instruction files.
+ * - .github/copilot-instructions.md — global instructions (mode-aware)
+ * - .github/instructions/<name>.instructions.md — per-agent instructions
+ */
+function generateCopilotInstructions(ctx, mode, repoConfig, workspaceConfig) {
+    const githubDir = node_path_1.default.join((0, orchestrator_1.getRepoBaseDir)(ctx), '.github');
+    const instructionsDir = node_path_1.default.join(githubDir, 'instructions');
+    const preamble = buildArchitectureAccessBlock(mode, repoConfig, workspaceConfig);
+    let written = 0;
+    // Global instructions file
+    const globalFile = node_path_1.default.join(githubDir, 'copilot-instructions.md');
+    if (!node_fs_1.default.existsSync(globalFile)) {
+        const globalContent = [
+            '# Copilot Instructions',
+            '',
+            'This project follows the Collab architectural governance process (GOV-R-001).',
+            'Use the per-agent instruction files in `.github/instructions/` for phase-specific guidance.',
+            '',
+            '## Governance Phases',
+            '',
+            '1. Survey — Map files, check duplication, propose design',
+            '2. Change Plan — Detailed implementation plan',
+            '3. Implementation — Execute the plan',
+            '4. Repo Hygiene — Tests, lint, docs, dead code',
+            '5. Canon Sync — Update canonical architecture',
+            '',
+            preamble,
+            '',
+        ].join('\n');
+        ctx.executor.ensureDirectory(githubDir);
+        ctx.executor.writeFile(globalFile, globalContent, {
+            description: 'write Copilot global instructions',
+        });
+        written++;
+    }
+    // Per-agent instruction files
+    for (const agent of AGENT_PROMPTS) {
+        const content = (0, canon_resolver_1.resolveCanonFile)(agent.canonPath);
+        if (!content) {
+            continue;
+        }
+        const instrFile = node_path_1.default.join(instructionsDir, `${agent.name}.instructions.md`);
+        if (node_fs_1.default.existsSync(instrFile)) {
+            ctx.logger.debug(`Copilot instruction already exists, skipping: ${agent.name}`);
+            continue;
+        }
+        const instrContent = [
+            '---',
+            'applyTo: "**"',
+            '---',
+            '',
+            preamble,
+            '',
+            content,
+        ].join('\n');
+        ctx.executor.ensureDirectory(instructionsDir);
+        ctx.executor.writeFile(instrFile, instrContent, {
+            description: `write Copilot instruction ${agent.name}`,
+        });
+        written++;
+    }
+    return written;
+}
+/**
+ * Generates a CLAUDE.md file at repo root with mode-aware architecture context.
+ */
+function generateClaudeMd(ctx, mode, repoConfig, workspaceConfig) {
+    const claudeFile = node_path_1.default.join((0, orchestrator_1.getRepoBaseDir)(ctx), 'CLAUDE.md');
+    if (node_fs_1.default.existsSync(claudeFile)) {
+        ctx.logger.debug('CLAUDE.md already exists, skipping.');
+        return false;
+    }
+    const accessBlock = buildArchitectureAccessBlock(mode, repoConfig, workspaceConfig);
+    const mcpConfigNote = mode === 'indexed'
+        ? [
+            '',
+            '## MCP Configuration',
+            '',
+            'MCP client config: `.collab/claude-mcp-config.json`',
+            'Merge this into your Claude Code MCP settings to enable architecture retrieval.',
+            '',
+        ].join('\n')
+        : '';
+    const content = [
+        '# Claude Code — Architecture Context',
+        '',
+        'This project follows the Collab architectural governance process (GOV-R-001).',
+        '',
+        accessBlock,
+        mcpConfigNote,
+        '## Agent Skills',
+        '',
+        'Agent skills are defined in `.agents/skills/` following the Agent Skills Spec.',
+        'Each skill maps to a GOV-R-001 governance phase or thematic agent.',
+        '',
+        '## Governance Workflow',
+        '',
+        'All changes must follow the five-phase governance process:',
+        '',
+        '1. **Survey** — Map files, check duplication, propose design',
+        '2. **Change Plan** — Detailed implementation plan with acceptance criteria',
+        '3. **Implementation** — Execute following the approved plan',
+        '4. **Repo Hygiene** — Verify tests, lint, docs, dead code removal',
+        '5. **Canon Sync** — Update canonical architecture documentation',
+        '',
+        '## Rules',
+        '',
+        '- Read `docs/architecture/uxmaltech/governance/` for full governance rules',
+        '- Check `docs/architecture/repo/` for project-specific decisions and conventions',
+        '- Use `docs/ai/00_brief.md` for a quick project overview',
+        '',
+    ].join('\n');
+    ctx.executor.writeFile(claudeFile, content, {
+        description: 'write CLAUDE.md architecture context',
+    });
+    return true;
+}
+// ────────────────────────────────────────────────────────────────
+// Stage export
+// ────────────────────────────────────────────────────────────────
+exports.agentSkillsSetupStage = {
+    id: 'agent-skills-setup',
+    title: 'Generate agent skill files',
+    recovery: [
+        'Ensure canons are available (run collab update-canons).',
+        'Run collab init --resume to retry agent skills setup.',
+    ],
+    run: (ctx) => {
+        const enabledProviders = (0, providers_1.getEnabledProviders)(ctx.config);
+        if (enabledProviders.length === 0) {
+            ctx.logger.info('No providers configured; skipping agent skills setup.');
+            return;
+        }
+        const mode = ctx.config.mode;
+        const repoConfig = ctx.options?._repoConfig;
+        const workspaceConfig = ctx.config.workspace;
+        const hasSkillsProvider = enabledProviders.some((p) => p !== 'copilot');
+        const hasCopilot = enabledProviders.includes('copilot');
+        const hasClaude = enabledProviders.includes('claude');
+        let totalWritten = 0;
+        // Agent Skills Spec for Claude, Codex, and Gemini
+        if (hasSkillsProvider) {
+            const count = generateAgentSkillsSpec(ctx, mode, repoConfig, workspaceConfig);
+            totalWritten += count;
+            if (count > 0) {
+                ctx.logger.info(`Agent Skills Spec: ${count} SKILL.md file(s) written to .agents/skills/.`);
+            }
+        }
+        // Copilot instructions
+        if (hasCopilot) {
+            const count = generateCopilotInstructions(ctx, mode, repoConfig, workspaceConfig);
+            totalWritten += count;
+            if (count > 0) {
+                ctx.logger.info(`Copilot instructions: ${count} file(s) written to .github/.`);
+            }
+        }
+        // CLAUDE.md for Claude provider
+        if (hasClaude) {
+            const wrote = generateClaudeMd(ctx, mode, repoConfig, workspaceConfig);
+            if (wrote) {
+                totalWritten++;
+                ctx.logger.info('CLAUDE.md written at repo root.');
+            }
+        }
+        if (totalWritten === 0) {
+            ctx.logger.info('All agent skill files already exist; nothing to write.');
+        }
+    },
+};

package/dist/stages/assistant-setup.js

@@ -0,0 +1,325 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assistantSetupStage = void 0;
+const node_child_process_1 = require("node:child_process");
+const cli_detection_1 = require("../lib/cli-detection");
+const credentials_1 = require("../lib/credentials");
+const errors_1 = require("../lib/errors");
+const model_listing_1 = require("../lib/model-listing");
+const model_registry_1 = require("../lib/model-registry");
+const prompt_1 = require("../lib/prompt");
+const providers_1 = require("../lib/providers");
+const config_1 = require("../lib/config");
+/**
+ * Resolves the effective API key for a provider from env var or stored credentials.
+ */
+function resolveEffectiveKey(provider, ctx) {
+    const envKey = process.env[providers_1.PROVIDER_DEFAULTS[provider].envVar];
+    if (envKey) {
+        return envKey;
+    }
+    return (0, credentials_1.loadApiKey)(ctx.config, provider);
+}
+async function configureApiKey(provider, ctx) {
+    const defaults = providers_1.PROVIDER_DEFAULTS[provider];
+    const isNonInteractive = Boolean(ctx.options?.yes);
+    const envVar = defaults.envVar;
+    if (process.env[envVar]) {
+        ctx.logger.info(`  \u2713 ${envVar} detected in environment`);
+        return { method: 'api-key', envVar };
+    }
+    // Env var is not set — prompt for API key or let user set it later
+    if (isNonInteractive) {
+        ctx.logger.warn(`${envVar} is not set in current environment. Set it before running collab commands, ` +
+            `or run collab init interactively to enter it directly.`);
+        return { method: 'api-key', envVar };
+    }
+    ctx.logger.info(`  ${envVar} is not set in current environment.`);
+    const apiKey = await (0, prompt_1.promptText)(`Enter API key for ${defaults.label} (or leave empty to use ${envVar} env var later)`);
+    if (apiKey) {
+        // Save the key securely to .collab/credentials.json
+        if (!ctx.executor.dryRun) {
+            (0, credentials_1.saveApiKey)(ctx.config, provider, apiKey);
+            ctx.logger.info(`  \u2713 API key saved to .collab/credentials.json`);
+        }
+        else {
+            ctx.logger.info(`  [dry-run] Would save API key to .collab/credentials.json`);
+        }
+    }
+    else {
+        ctx.logger.warn(`No API key provided. Set ${envVar} before running collab commands.`);
+    }
+    return { method: 'api-key', envVar };
+}
+/**
+ * Queries the provider API for available models, prints a summary,
+ * and persists results to the model registry.
+ * Returns the model list, or null if the query fails or is skipped.
+ */
+async function fetchAndShowModels(provider, apiKey, ctx) {
+    try {
+        const models = await (0, model_listing_1.listModels)(provider, apiKey);
+        if (models.length === 0) {
+            ctx.logger.warn(`  API key accepted but no generative models found.`);
+            return null;
+        }
+        ctx.logger.info(`  \u2713 API key validated \u2014 ${models.length} model(s) available:`);
+        for (const m of models) {
+            const label = m.name ? `${m.id}  (${m.name})` : m.id;
+            ctx.logger.info(`      ${label}`);
+        }
+        // Persist to model registry for future features
+        if (!ctx.executor.dryRun) {
+            (0, model_registry_1.saveProviderModels)(ctx.config, provider, models);
+        }
+        return models;
+    }
+    catch (err) {
+        const message = err instanceof Error ? err.message : String(err);
+        ctx.logger.warn(`  Could not query models: ${message}`);
+        ctx.logger.info(`  Falling back to default model list.`);
+        return null;
+    }
+}
+/**
+ * Selects a model — from the live API list when available, otherwise from hardcoded defaults.
+ */
+async function selectModel(provider, availableModels, isNonInteractive, cliConfiguredModel) {
+    const defaults = providers_1.PROVIDER_DEFAULTS[provider];
+    if (isNonInteractive) {
+        // Prefer CLI-configured model, then first hardcoded default
+        return cliConfiguredModel ?? defaults.models[0];
+    }
+    if (availableModels && availableModels.length > 0) {
+        const defaultSet = new Set(defaults.models);
+        const apiIds = new Set(availableModels.map((m) => m.id));
+        const byId = new Map(availableModels.map((m) => [m.id, m]));
+        const choices = [];
+        // If CLI has a configured model not in defaults, add it first
+        if (cliConfiguredModel && !defaultSet.has(cliConfiguredModel) && !apiIds.has(cliConfiguredModel)) {
+            choices.push({ value: cliConfiguredModel, label: `${cliConfiguredModel} (CLI configured)` });
+        }
+        // Defaults that are available in the API
+        for (const d of defaults.models) {
+            if (apiIds.has(d)) {
+                const m = byId.get(d);
+                choices.push({ value: m.id, label: m.name ? `${m.id} \u2014 ${m.name}` : m.id });
+            }
+        }
+        // CLI-configured model from the API list (move to front if found)
+        if (cliConfiguredModel && apiIds.has(cliConfiguredModel) && !defaultSet.has(cliConfiguredModel)) {
+            const m = byId.get(cliConfiguredModel);
+            const label = m.name ? `${m.id} \u2014 ${m.name} (CLI configured)` : `${m.id} (CLI configured)`;
+            // Insert at beginning
+            choices.unshift({ value: m.id, label });
+        }
+        // Remaining models from the API
+        const others = availableModels.filter((m) => !defaultSet.has(m.id) && m.id !== cliConfiguredModel);
+        for (const m of others) {
+            choices.push({ value: m.id, label: m.name ? `${m.id} \u2014 ${m.name}` : m.id });
+        }
+        if (choices.length > 0) {
+            const defaultChoice = cliConfiguredModel
+                ? choices.find((c) => c.value === cliConfiguredModel)?.value ?? choices[0].value
+                : choices[0].value;
+            return (0, prompt_1.promptChoice)(`Default model for ${defaults.label}:`, choices, defaultChoice);
+        }
+        return availableModels[0].id;
+    }
+    // Hardcoded fallback — include CLI-configured model if not already in defaults
+    const fallbackChoices = [...defaults.models];
+    if (cliConfiguredModel && !fallbackChoices.includes(cliConfiguredModel)) {
+        fallbackChoices.unshift(cliConfiguredModel);
+    }
+    const defaultValue = cliConfiguredModel ?? fallbackChoices[0];
+    return (0, prompt_1.promptChoice)(`Default model for ${defaults.label}:`, fallbackChoices.map((m) => ({
+        value: m,
+        label: m === cliConfiguredModel ? `${m} (CLI configured)` : m,
+    })), defaultValue);
+}
+/**
+ * Configures the Copilot (GitHub) provider.
+ * Copilot doesn't use API keys or models — it works via `gh` CLI and GitHub issues.
+ * Validates that `gh` is installed and authenticated.
+ */
+function configureCopilotProvider(ctx) {
+    ctx.logger.info(`\nConfiguring ${providers_1.PROVIDER_DEFAULTS.copilot.label}...`);
+    const cli = (0, cli_detection_1.detectProviderCli)('copilot');
+    if (!cli.available) {
+        // gh not installed or not authenticated
+        const ghExists = (() => {
+            try {
+                const whichCmd = process.platform === 'win32' ? 'where' : 'which';
+                (0, node_child_process_1.execSync)(`${whichCmd} gh`, {
+                    encoding: 'utf8',
+                    timeout: 3_000,
+                    stdio: ['ignore', 'pipe', 'ignore'],
+                });
+                return true;
+            }
+            catch {
+                return false;
+            }
+        })();
+        if (!ghExists) {
+            ctx.logger.warn('  gh CLI not found. Install it from https://cli.github.com/');
+            return { enabled: false, auth: { method: 'cli' } };
+        }
+        // gh exists but not authenticated
+        ctx.logger.warn('  gh CLI found but not authenticated. Run: gh auth login');
+        return { enabled: false, auth: { method: 'cli' } };
+    }
+    const ver = cli.version ? ` (${cli.version})` : '';
+    ctx.logger.info(`  \u2713 gh CLI detected${ver}`);
+    ctx.logger.info(`  \u2713 GitHub authentication verified`);
+    return {
+        enabled: true,
+        auth: { method: 'cli' },
+        cli: cli,
+    };
+}
+async function configureProvider(provider, ctx) {
+    const defaults = providers_1.PROVIDER_DEFAULTS[provider];
+    const isNonInteractive = Boolean(ctx.options?.yes);
+    ctx.logger.info(`\nConfiguring ${defaults.label}...`);
+    // Detect official CLI
+    const cli = (0, cli_detection_1.detectProviderCli)(provider);
+    if (cli.available) {
+        const ver = cli.version ? ` (${cli.version})` : '';
+        ctx.logger.info(`  \u2713 ${cli.command} CLI detected${ver}`);
+    }
+    // Determine auth method
+    let authMethod;
+    const hasEnvKey = Boolean(process.env[defaults.envVar]);
+    if (cli.available && !hasEnvKey) {
+        // CLI is available and no env var — offer CLI vs API key choice
+        if (isNonInteractive) {
+            // Non-interactive: default to CLI when detected and no env var
+            authMethod = 'cli';
+            ctx.logger.info(`  Using ${cli.command} CLI (no ${defaults.envVar} set).`);
+        }
+        else {
+            authMethod = await (0, prompt_1.promptChoice)(`Authentication for ${defaults.label}:`, [
+                { value: 'cli', label: `Use ${cli.command} CLI directly (no API key needed)` },
+                { value: 'api-key', label: `Enter API key (${defaults.envVar})` },
+            ], 'cli');
+        }
+    }
+    else if (cli.available && hasEnvKey) {
+        // Both CLI and env var available — let user pick
+        if (isNonInteractive) {
+            authMethod = 'api-key';
+        }
+        else {
+            authMethod = await (0, prompt_1.promptChoice)(`Authentication for ${defaults.label}:`, [
+                { value: 'cli', label: `Use ${cli.command} CLI directly (no API key needed)` },
+                { value: 'api-key', label: `API key via ${defaults.envVar} (detected)` },
+            ], 'api-key');
+        }
+    }
+    else {
+        // No CLI — API key is the only option
+        authMethod = 'api-key';
+    }
+    // Configure based on chosen method
+    let auth;
+    let availableModels = null;
+    if (authMethod === 'cli') {
+        auth = { method: 'cli' };
+        ctx.logger.info(`  \u2713 Will use ${cli.command} CLI for ${defaults.label}.`);
+        if (cli.configuredModel) {
+            ctx.logger.info(`  \u2713 CLI configured model: ${cli.configuredModel}`);
+        }
+    }
+    else {
+        auth = await configureApiKey(provider, ctx);
+        // Fetch and show models when we have an API key
+        const effectiveKey = resolveEffectiveKey(provider, ctx);
+        if (effectiveKey && !ctx.executor.dryRun) {
+            availableModels = await fetchAndShowModels(provider, effectiveKey, ctx);
+        }
+    }
+    // Model selection — prefer CLI-configured model when using CLI auth
+    const cliModel = authMethod === 'cli' ? cli.configuredModel : undefined;
+    const model = await selectModel(provider, availableModels, isNonInteractive, cliModel);
+    return {
+        enabled: true,
+        auth,
+        model,
+        cli: cli.available ? cli : undefined,
+    };
+}
+exports.assistantSetupStage = {
+    id: 'assistant-setup',
+    title: 'Configure AI assistant providers',
+    recovery: [
+        'Re-run collab init --resume to reconfigure providers.',
+        'Ensure required API keys are set (env var or collab init interactive).',
+    ],
+    run: async (ctx) => {
+        const isNonInteractive = Boolean(ctx.options?.yes);
+        const providersFlag = ctx.options?.providers;
+        // Determine which providers to configure
+        let selectedProviders;
+        if (providersFlag) {
+            // Explicit --providers flag
+            selectedProviders = (0, providers_1.parseProviderList)(providersFlag);
+        }
+        else if (isNonInteractive) {
+            // Auto-detect from environment variables
+            selectedProviders = await (0, providers_1.autoDetectProviders)();
+            if (selectedProviders.length === 0) {
+                ctx.logger.warn('No AI provider environment variables detected. ' +
+                    `Set one of: ${providers_1.PROVIDER_KEYS.map((k) => providers_1.PROVIDER_DEFAULTS[k].envVar).join(', ')} ` +
+                    'or use --providers to specify explicitly.');
+                ctx.logger.info('Skipping assistant-setup stage (no providers configured).');
+                return;
+            }
+            ctx.logger.info(`Auto-detected providers: ${selectedProviders.map((k) => providers_1.PROVIDER_DEFAULTS[k].label).join(', ')}`);
+        }
+        else {
+            // Interactive multi-select
+            selectedProviders = await (0, prompt_1.promptMultiSelect)('Select AI providers to configure:', providers_1.PROVIDER_KEYS.map((key) => ({
+                value: key,
+                label: providers_1.PROVIDER_DEFAULTS[key].label,
+                description: providers_1.PROVIDER_DEFAULTS[key].description,
+            })));
+        }
+        if (selectedProviders.length === 0) {
+            if (providersFlag) {
+                // Explicit --providers flag with empty/invalid list: error
+                throw new errors_1.CliError('At least one AI provider must be selected. ' +
+                    `Available providers: ${providers_1.PROVIDER_KEYS.join(', ')}`);
+            }
+            // Interactive with no selection: skip gracefully
+            ctx.logger.info('No providers selected. You can configure providers later with collab init --resume.');
+            return;
+        }
+        // Configure each selected provider
+        const providerConfigs = {};
+        for (const provider of selectedProviders) {
+            providerConfigs[provider] =
+                provider === 'copilot'
+                    ? configureCopilotProvider(ctx)
+                    : await configureProvider(provider, ctx);
+        }
+        // Mark unselected providers as disabled
+        for (const key of providers_1.PROVIDER_KEYS) {
+            if (!selectedProviders.includes(key)) {
+                providerConfigs[key] = { enabled: false, auth: { method: 'api-key' } };
+            }
+        }
+        // Persist to config
+        const assistants = { providers: providerConfigs };
+        ctx.config.assistants = assistants;
+        // Write updated config
+        ctx.executor.writeFile(ctx.config.configFile, `${(0, config_1.serializeUserConfig)(ctx.config)}\n`, { description: 'write assistant provider configuration' });
+        // Summary
+        const enabledNames = selectedProviders.map((k) => {
+            const cfg = providerConfigs[k];
+            const authTag = cfg.auth.method === 'cli' ? `${cfg.cli?.command ?? 'cli'} CLI` : `API key`;
+            return `${providers_1.PROVIDER_DEFAULTS[k].label} (${authTag}, model: ${cfg.model})`;
+        });
+        ctx.logger.result(`Configured providers: ${enabledNames.join(', ')}`);
+    },
+};