@uxmaltech/collab-cli 0.1.0

package/dist/stages/domain-gen.js

@@ -0,0 +1,363 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildFileOnlyDomainPipeline = buildFileOnlyDomainPipeline;
+exports.buildIndexedDomainPipeline = buildIndexedDomainPipeline;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const ai_client_1 = require("../lib/ai-client");
+const canon_resolver_1 = require("../lib/canon-resolver");
+const domain_gen_1 = require("../lib/domain-gen");
+const errors_1 = require("../lib/errors");
+const github_auth_1 = require("../lib/github-auth");
+const mcp_client_1 = require("../lib/mcp-client");
+const providers_1 = require("../lib/providers");
+const repo_scanner_1 = require("../lib/repo-scanner");
+const service_health_1 = require("../lib/service-health");
+// ────────────────────────────────────────────────────────────────
+// Helper: collect markdown files recursively
+// ────────────────────────────────────────────────────────────────
+/** Recursively collects all `.md` file paths under the given directory. */
+function collectMarkdownFiles(dir) {
+    if (!node_fs_1.default.existsSync(dir)) {
+        return [];
+    }
+    const results = [];
+    for (const entry of node_fs_1.default.readdirSync(dir, { withFileTypes: true })) {
+        const full = node_path_1.default.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            results.push(...collectMarkdownFiles(full));
+        }
+        else if (entry.isFile() && entry.name.endsWith('.md')) {
+            results.push(full);
+        }
+    }
+    return results;
+}
+// ────────────────────────────────────────────────────────────────
+// Shared stage: domain-analysis (used by both file-only & indexed)
+// ────────────────────────────────────────────────────────────────
+/** Builds the AI-driven domain analysis stage shared by both pipelines. */
+function buildDomainAnalysisStage() {
+    return {
+        id: 'domain-analysis',
+        title: 'Analyze repository and generate domain definition',
+        recovery: [
+            'Ensure an AI provider is configured (OPENAI_API_KEY, claude CLI, etc.).',
+            'Run collab init --repo <package> --resume to retry analysis.',
+        ],
+        run: async (ctx) => {
+            const repoPath = ctx.options?._repoPath;
+            if (!repoPath) {
+                throw new errors_1.CliError('No repo path provided for domain analysis.');
+            }
+            // Resume support: check for cached result from a previous run
+            const cacheFile = node_path_1.default.join(ctx.config.collabDir, 'domain-gen-result.json');
+            if (node_fs_1.default.existsSync(cacheFile)) {
+                try {
+                    const cached = JSON.parse(node_fs_1.default.readFileSync(cacheFile, 'utf8'));
+                    if (cached.domainName && cached.domainSlug) {
+                        ctx.logger.info(`Resuming with cached domain result: "${cached.domainName}".`);
+                        if (ctx.options) {
+                            ctx.options._domainResult = cached;
+                        }
+                        return;
+                    }
+                }
+                catch {
+                    // Cache is corrupt; re-run analysis
+                }
+            }
+            if (ctx.executor.dryRun) {
+                ctx.logger.info(`[dry-run] Would analyze ${node_path_1.default.basename(repoPath)} and generate domain definition.`);
+                return;
+            }
+            // 1. Scan the target repository
+            ctx.logger.info(`Scanning repository at ${repoPath}...`);
+            const repoCtx = (0, repo_scanner_1.scanRepository)(repoPath);
+            ctx.logger.info(`Detected: ${repoCtx.language}${repoCtx.framework ? ` / ${repoCtx.framework}` : ''}, ` +
+                `${repoCtx.totalSourceFiles} source files.`);
+            // 2. Build prompt
+            const prompt = (0, domain_gen_1.buildDomainGenPrompt)(repoCtx);
+            // 3. Get AI client — honour --providers CLI flag, fall back to config
+            const cliProvidersRaw = ctx.options?.providers;
+            const cliProviders = typeof cliProvidersRaw === 'string'
+                ? cliProvidersRaw.split(',').map((s) => s.trim()).filter(Boolean)
+                : Array.isArray(cliProvidersRaw) ? cliProvidersRaw : [];
+            const configuredProviders = (0, providers_1.getEnabledProviders)(ctx.config);
+            const providers = cliProviders.length > 0 ? cliProviders : configuredProviders;
+            const client = (0, ai_client_1.createFirstAvailableClient)(providers, ctx.config, ctx.logger);
+            if (!client) {
+                throw new errors_1.CliError('No AI provider available for domain analysis. ' +
+                    'Set OPENAI_API_KEY, configure claude CLI, install another supported provider, ' +
+                    'or pass --providers to select a specific provider.');
+            }
+            // 4. Call AI
+            ctx.logger.info('Generating domain definition via AI...');
+            const messages = [
+                { role: 'system', content: prompt.system },
+                { role: 'user', content: prompt.user },
+            ];
+            const rawResponse = await client.complete(messages, {
+                maxTokens: 8192,
+                temperature: 0.2,
+            });
+            // 5. Parse response
+            const result = (0, domain_gen_1.parseDomainGenerationResponse)(rawResponse);
+            ctx.logger.info(`Domain "${result.domainName}" generated: ` +
+                `${result.principles.length} principles, ${result.rules.length} rules, ` +
+                `${result.patterns.length} patterns, ${result.technologies.length} technologies.`);
+            // Store result for subsequent stages (in-memory + file for resume)
+            if (ctx.options) {
+                ctx.options._domainResult = result;
+            }
+            ctx.executor.writeFile(cacheFile, JSON.stringify(result, null, 2), {
+                description: 'cache domain generation result for resume support',
+            });
+        },
+    };
+}
+// ────────────────────────────────────────────────────────────────
+// File-only stages
+// ────────────────────────────────────────────────────────────────
+/** Builds the stage that writes domain files to the local repository. */
+function buildDomainFileWriteLocalStage() {
+    return {
+        id: 'domain-file-write-local',
+        title: 'Write domain files to local repo',
+        recovery: [
+            'Verify write permissions for the target repo directory.',
+            'Run collab init --repo <package> --resume to retry.',
+        ],
+        run: (ctx) => {
+            const repoPath = ctx.options?._repoPath;
+            const result = ctx.options?._domainResult;
+            if (!result) {
+                ctx.logger.info('No domain analysis result available; skipping file write.');
+                return;
+            }
+            const targetDir = node_path_1.default.join(repoPath, 'docs', 'architecture', 'repo', 'domains', result.domainSlug);
+            if (ctx.executor.dryRun) {
+                ctx.logger.info(`[dry-run] Would write domain files to ${targetDir}`);
+                return;
+            }
+            const count = (0, domain_gen_1.writeDomainFiles)(targetDir, result, ctx.executor);
+            ctx.logger.info(`Domain files written: ${count} file(s) to ${targetDir}`);
+        },
+    };
+}
+// ────────────────────────────────────────────────────────────────
+// Indexed stages
+// ────────────────────────────────────────────────────────────────
+/** Builds the stage that syncs the business canon repository before writing. */
+function buildDomainCanonSyncStage() {
+    return {
+        id: 'domain-canon-sync',
+        title: 'Sync business canon repository',
+        recovery: [
+            'Ensure GitHub access is configured.',
+            'Run collab init --repo <package> --resume to retry.',
+        ],
+        run: (ctx) => {
+            if (!(0, canon_resolver_1.isBusinessCanonConfigured)(ctx.config)) {
+                throw new errors_1.CliError('Business canon is not configured. Use --business-canon owner/repo to set it, or use --mode file-only.');
+            }
+            if (ctx.executor.dryRun) {
+                ctx.logger.info('[dry-run] Would sync business canon repository.');
+                return;
+            }
+            const auth = (0, github_auth_1.loadGitHubAuth)(ctx.config.collabDir);
+            const token = auth?.token;
+            const ok = (0, canon_resolver_1.syncBusinessCanon)(ctx.config, (msg) => ctx.logger.info(msg), token);
+            if (!ok) {
+                throw new errors_1.CliError('Failed to sync business canon repository.');
+            }
+        },
+    };
+}
+/** Builds the stage that writes domain files to the business canon repository. */
+function buildDomainFileWriteCanonStage() {
+    return {
+        id: 'domain-file-write-canon',
+        title: 'Write domain files to business canon',
+        recovery: [
+            'Verify write permissions for the business canon directory.',
+            'Run collab init --repo <package> --resume to retry.',
+        ],
+        run: (ctx) => {
+            const result = ctx.options?._domainResult;
+            if (!result) {
+                ctx.logger.info('No domain analysis result available; skipping file write.');
+                return;
+            }
+            const canonDir = (0, canon_resolver_1.getBusinessCanonDir)(ctx.config);
+            const targetDir = node_path_1.default.join(canonDir, 'domains', result.domainSlug);
+            if (ctx.executor.dryRun) {
+                ctx.logger.info(`[dry-run] Would write domain files to ${targetDir}`);
+                return;
+            }
+            const count = (0, domain_gen_1.writeDomainFiles)(targetDir, result, ctx.executor);
+            ctx.logger.info(`Domain files written: ${count} file(s) to ${targetDir}`);
+        },
+    };
+}
+/** Builds the stage that appends domain vertices and edges to the graph seed. */
+function buildDomainGraphUpdateStage() {
+    return {
+        id: 'domain-graph-update',
+        title: 'Update graph seed with domain vertices',
+        recovery: [
+            'Verify write permissions for the business canon graph/seed directory.',
+            'Run collab init --repo <package> --resume to retry.',
+        ],
+        run: (ctx) => {
+            const result = ctx.options?._domainResult;
+            if (!result) {
+                ctx.logger.info('No domain analysis result available; skipping graph update.');
+                return;
+            }
+            const canonDir = (0, canon_resolver_1.getBusinessCanonDir)(ctx.config);
+            const dataPath = node_path_1.default.join(canonDir, 'graph', 'seed', 'data.ngql');
+            if (ctx.executor.dryRun) {
+                ctx.logger.info(`[dry-run] Would append graph seed data to ${dataPath}`);
+                return;
+            }
+            const nextIds = (0, domain_gen_1.findNextIds)(dataPath);
+            const nGql = (0, domain_gen_1.generateDomainGraphSeed)(result, nextIds);
+            (0, domain_gen_1.appendGraphSeed)(dataPath, nGql, ctx.executor);
+            const techCount = result.technologies.length;
+            const patCount = result.patterns.length;
+            ctx.logger.info(`Graph seed updated: 1 domain + ${techCount} technology + ${patCount} pattern vertices, ` +
+                `${techCount + patCount} edges.`);
+        },
+    };
+}
+/** Builds the stage that commits and pushes domain changes to the business canon. */
+function buildDomainCanonPushStage() {
+    return {
+        id: 'domain-canon-push',
+        title: 'Commit and push domain to business canon',
+        recovery: [
+            'Ensure GitHub access is configured with push permissions.',
+            'Run collab init --repo <package> --resume to retry.',
+        ],
+        run: (ctx) => {
+            const result = ctx.options?._domainResult;
+            const repoPath = ctx.options?._repoPath;
+            if (!result) {
+                ctx.logger.info('No domain analysis result available; skipping push.');
+                return;
+            }
+            const canonDir = (0, canon_resolver_1.getBusinessCanonDir)(ctx.config);
+            const repoName = repoPath ? node_path_1.default.basename(repoPath) : 'unknown';
+            if (ctx.executor.dryRun) {
+                ctx.logger.info(`[dry-run] Would commit and push domain "${result.domainName}" to business canon.`);
+                return;
+            }
+            // Stage files
+            ctx.executor.run('git', ['-C', canonDir, 'add', `domains/${result.domainSlug}/`]);
+            ctx.executor.run('git', ['-C', canonDir, 'add', 'graph/seed/data.ngql']);
+            // Commit
+            const commitMsg = `feat(domain): add ${result.domainName} from ${repoName}`;
+            ctx.executor.run('git', ['-C', canonDir, 'commit', '-m', commitMsg]);
+            // Push — use token auth via http.extraHeader to avoid leaking secrets in logs
+            const auth = (0, github_auth_1.loadGitHubAuth)(ctx.config.collabDir);
+            if (auth?.token) {
+                const canon = ctx.config.canons.business;
+                const remoteUrl = `https://github.com/${canon.repo}.git`;
+                const branch = canon.branch || 'main';
+                ctx.executor.run('git', [
+                    '-C', canonDir,
+                    '-c', `http.${remoteUrl}.extraHeader=Authorization: Bearer ${auth.token}`,
+                    'push', remoteUrl, branch,
+                ], { verboseOnly: true });
+            }
+            else {
+                ctx.executor.run('git', ['-C', canonDir, 'push']);
+            }
+            ctx.logger.info(`Domain "${result.domainName}" committed and pushed to business canon.`);
+        },
+    };
+}
+/** Builds the stage that ingests domain files into MCP via HTTP. */
+function buildDomainIngestStage() {
+    return {
+        id: 'domain-ingest',
+        title: 'Ingest domain files into MCP',
+        recovery: [
+            'Ensure MCP service is running and accessible.',
+            'Run collab init --repo <package> --resume to retry ingestion.',
+        ],
+        run: async (ctx) => {
+            const result = ctx.options?._domainResult;
+            if (!result) {
+                ctx.logger.info('No domain analysis result available; skipping ingestion.');
+                return;
+            }
+            if (ctx.executor.dryRun) {
+                ctx.logger.info('[dry-run] Would ingest domain files into MCP via HTTP.');
+                return;
+            }
+            const canonDir = (0, canon_resolver_1.getBusinessCanonDir)(ctx.config);
+            const domainDir = node_path_1.default.join(canonDir, 'domains', result.domainSlug);
+            const baseUrl = (0, mcp_client_1.getMcpBaseUrl)(ctx.config);
+            const env = (0, service_health_1.loadRuntimeEnv)(ctx.config);
+            const apiKey = (0, mcp_client_1.resolveMcpApiKey)(env);
+            const timeoutMs = (0, mcp_client_1.resolveMcpHttpTimeoutMs)(env);
+            // Collect and ingest domain .md files
+            const mdFiles = collectMarkdownFiles(domainDir);
+            if (mdFiles.length > 0) {
+                const configuredRepo = ctx.config.canons.business.repo;
+                const repoSlug = configuredRepo.replace(/\.git$/, '').replace(/^https?:\/\/github\.com\//i, '');
+                const scope = repoSlug.split('/').pop() ?? repoSlug;
+                const org = repoSlug.includes('/') ? repoSlug.split('/')[0] : scope;
+                const documents = mdFiles.map((f) => ({
+                    path: node_path_1.default.relative(canonDir, f),
+                    content: node_fs_1.default.readFileSync(f, 'utf8'),
+                }));
+                ctx.logger.info(`Ingesting ${documents.length} domain file(s) via HTTP...`);
+                const ingestResult = await (0, mcp_client_1.ingestDocuments)(baseUrl, {
+                    context: 'technical',
+                    scope,
+                    organization: org,
+                    repo: repoSlug.includes('/') ? repoSlug : `${org}/${repoSlug}`,
+                    documents,
+                }, apiKey, timeoutMs);
+                ctx.logger.info(`Domain ingested: ${ingestResult.vector.ingested_files} files, ` +
+                    `${ingestResult.vector.total_points} vectors, ` +
+                    `${ingestResult.graph.nodes_created} graph nodes.`);
+            }
+            // Trigger graph re-seed
+            ctx.logger.info('Triggering graph re-seed...');
+            const seedResult = await (0, mcp_client_1.triggerGraphSeed)(baseUrl, apiKey, timeoutMs);
+            ctx.logger.info(`Graph re-seed complete: ${seedResult.nodes_created} nodes, ${seedResult.edges_created} edges.`);
+        },
+    };
+}
+// ────────────────────────────────────────────────────────────────
+// Pipeline builders
+// ────────────────────────────────────────────────────────────────
+/**
+ * Builds the file-only domain generation pipeline (2 stages).
+ */
+function buildFileOnlyDomainPipeline() {
+    return [
+        buildDomainAnalysisStage(),
+        buildDomainFileWriteLocalStage(),
+    ];
+}
+/**
+ * Builds the indexed domain generation pipeline (6 stages).
+ */
+function buildIndexedDomainPipeline() {
+    return [
+        buildDomainCanonSyncStage(),
+        buildDomainAnalysisStage(),
+        buildDomainFileWriteCanonStage(),
+        buildDomainGraphUpdateStage(),
+        buildDomainCanonPushStage(),
+        buildDomainIngestStage(),
+    ];
+}

package/dist/stages/graph-seed.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.graphSeedStage = void 0;
+const mcp_client_1 = require("../lib/mcp-client");
+const service_health_1 = require("../lib/service-health");
+exports.graphSeedStage = {
+    id: 'graph-seed',
+    title: 'Seed NebulaGraph knowledge graph',
+    recovery: [
+        'Ensure MCP service is running and accessible.',
+        'Run collab init --resume to retry graph seeding.',
+    ],
+    run: async (ctx) => {
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would seed NebulaGraph with canonical knowledge graph via HTTP.');
+            return;
+        }
+        ctx.logger.info('Seeding NebulaGraph with canonical architecture graph via HTTP...');
+        const baseUrl = (0, mcp_client_1.getMcpBaseUrl)(ctx.config);
+        const env = (0, service_health_1.loadRuntimeEnv)(ctx.config);
+        const apiKey = (0, mcp_client_1.resolveMcpApiKey)(env);
+        const timeoutMs = (0, mcp_client_1.resolveMcpHttpTimeoutMs)(env);
+        const result = await (0, mcp_client_1.triggerGraphSeed)(baseUrl, apiKey, timeoutMs);
+        ctx.logger.info(`NebulaGraph seeding complete: ${result.nodes_created} nodes, ${result.edges_created} edges.`);
+    },
+};

package/dist/stages/repo-analysis-fileonly.js

@@ -0,0 +1,111 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repoAnalysisFileOnlyStage = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ai_client_1 = require("../lib/ai-client");
+const canon_resolver_1 = require("../lib/canon-resolver");
+const orchestrator_1 = require("../lib/orchestrator");
+const providers_1 = require("../lib/providers");
+const repo_analysis_helpers_1 = require("../lib/repo-analysis-helpers");
+const repo_scanner_1 = require("../lib/repo-scanner");
+/**
+ * Checks if copilot is the only enabled provider.
+ * Copilot doesn't support AI completion — skip analysis in that case.
+ */
+function onlyCopilotEnabled(providers) {
+    return providers.length === 1 && providers[0] === 'copilot';
+}
+exports.repoAnalysisFileOnlyStage = {
+    id: 'repo-analysis-fileonly',
+    title: 'AI-powered repository analysis',
+    recovery: [
+        'Ensure AI provider API keys are set, or configure a CLI provider (codex, claude, gemini).',
+        'Run collab init --resume to retry repository analysis.',
+    ],
+    run: async (ctx) => {
+        if (ctx.options?.skipAnalysis) {
+            ctx.logger.info('Skipping repository analysis by user choice.');
+            return;
+        }
+        const enabledProviders = (0, providers_1.getEnabledProviders)(ctx.config);
+        if (enabledProviders.length === 0 || onlyCopilotEnabled(enabledProviders)) {
+            ctx.logger.info('No AI-capable providers enabled; skipping repository analysis.');
+            // Still scan repo for basic AI helper files
+            const repoCtx = (0, repo_scanner_1.scanRepository)((0, orchestrator_1.getRepoBaseDir)(ctx));
+            (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, {});
+            return;
+        }
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would analyze repository and generate architecture files.');
+            return;
+        }
+        const client = (0, ai_client_1.createFirstAvailableClient)(enabledProviders, ctx.config, ctx.logger);
+        if (!client) {
+            ctx.logger.warn('No AI provider credentials or CLI available; generating basic AI helpers only.');
+            const repoCtx = (0, repo_scanner_1.scanRepository)((0, orchestrator_1.getRepoBaseDir)(ctx));
+            (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, {});
+            return;
+        }
+        // Load system prompt from canons (should already exist from canon-sync stage)
+        if (!(0, canon_resolver_1.isCanonsAvailable)()) {
+            ctx.logger.info('Canons not installed. Downloading collab-architecture...');
+            const ok = (0, canon_resolver_1.syncCanons)((msg) => ctx.logger.info(msg));
+            if (!ok || !(0, canon_resolver_1.isCanonsAvailable)()) {
+                ctx.logger.warn('Failed to download canons. Skipping repository analysis.');
+                return;
+            }
+        }
+        const systemPrompt = (0, canon_resolver_1.resolveCanonFile)('prompts/init/system-prompt.md');
+        if (!systemPrompt) {
+            ctx.logger.warn('System prompt not found in canons. Run "collab update-canons" to refresh. Skipping analysis.');
+            return;
+        }
+        ctx.logger.info('Scanning repository structure...');
+        const repoCtx = (0, repo_scanner_1.scanRepository)((0, orchestrator_1.getRepoBaseDir)(ctx));
+        ctx.logger.info(`Repository: ${repoCtx.name} (${repoCtx.language}${repoCtx.framework ? ` / ${repoCtx.framework}` : ''}, ${repoCtx.totalSourceFiles} source files)`);
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: (0, repo_analysis_helpers_1.buildUserMessage)(repoCtx) },
+        ];
+        // Write debug prompt
+        const promptDebugPath = node_path_1.default.join(ctx.config.collabDir, `init-prompt-${client.provider}-cli.md`);
+        const promptContent = [
+            `# Init Prompt — ${client.provider} CLI`,
+            `<!-- Generated: ${new Date().toISOString()} -->`,
+            '',
+            '## System Prompt',
+            '',
+            messages[0].content,
+            '',
+            '## User Prompt',
+            '',
+            messages[1].content,
+            '',
+        ].join('\n');
+        ctx.executor.ensureDirectory(node_path_1.default.dirname(promptDebugPath));
+        ctx.executor.writeFile(promptDebugPath, promptContent, {
+            description: `write init prompt debug file for ${client.provider}`,
+        });
+        ctx.logger.info('Analyzing repository with AI provider...');
+        const response = await client.complete(messages, { maxTokens: 8192 });
+        let analysis;
+        try {
+            const jsonStr = (0, repo_analysis_helpers_1.extractJson)(response);
+            analysis = JSON.parse(jsonStr);
+        }
+        catch (err) {
+            ctx.logger.warn(`Failed to parse AI analysis response: ${String(err)}`);
+            ctx.logger.debug(`Raw response (first 500 chars): ${response.slice(0, 500)}`);
+            // Still generate AI helpers with empty analysis
+            (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, {});
+            return;
+        }
+        // File-only mode writes to repoDir (docs/architecture/repo/)
+        (0, repo_analysis_helpers_1.writeAnalysisResults)(ctx, ctx.config.repoDir, analysis);
+        // Generate docs/ai/ helper files
+        (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, analysis);
+    },
+};

package/dist/stages/repo-analysis.js

@@ -0,0 +1,112 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.repoAnalysisStage = void 0;
+const node_path_1 = __importDefault(require("node:path"));
+const ai_client_1 = require("../lib/ai-client");
+const canon_resolver_1 = require("../lib/canon-resolver");
+const orchestrator_1 = require("../lib/orchestrator");
+const providers_1 = require("../lib/providers");
+const repo_analysis_helpers_1 = require("../lib/repo-analysis-helpers");
+const repo_scanner_1 = require("../lib/repo-scanner");
+/**
+ * Checks if copilot is the only enabled provider.
+ */
+function onlyCopilotEnabled(providers) {
+    return providers.length === 1 && providers[0] === 'copilot';
+}
+exports.repoAnalysisStage = {
+    id: 'repo-analysis',
+    title: 'AI-powered repository analysis',
+    recovery: [
+        'Ensure AI provider API keys are set in environment, or configure a CLI provider (codex, claude, gemini).',
+        'Run collab init --resume to retry repository analysis.',
+    ],
+    run: async (ctx) => {
+        if (ctx.options?.skipAnalysis) {
+            ctx.logger.info('Skipping repository analysis by user choice.');
+            return;
+        }
+        const enabledProviders = (0, providers_1.getEnabledProviders)(ctx.config);
+        if (enabledProviders.length === 0 || onlyCopilotEnabled(enabledProviders)) {
+            ctx.logger.info('No AI-capable providers enabled; skipping repository analysis.');
+            // Still generate basic AI helper files
+            const repoCtx = (0, repo_scanner_1.scanRepository)((0, orchestrator_1.getRepoBaseDir)(ctx));
+            (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, {});
+            return;
+        }
+        // In dry-run mode, just show what would happen
+        if (ctx.executor.dryRun) {
+            ctx.logger.info('[dry-run] Would analyze repository and generate architecture files.');
+            return;
+        }
+        const client = (0, ai_client_1.createFirstAvailableClient)(enabledProviders, ctx.config, ctx.logger);
+        if (!client) {
+            ctx.logger.warn('No AI provider credentials or CLI available; generating basic AI helpers only.');
+            const repoCtx = (0, repo_scanner_1.scanRepository)((0, orchestrator_1.getRepoBaseDir)(ctx));
+            (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, {});
+            return;
+        }
+        // Load system prompt from canons — auto-clone if missing
+        if (!(0, canon_resolver_1.isCanonsAvailable)()) {
+            ctx.logger.info('Canons not installed. Downloading collab-architecture...');
+            const ok = (0, canon_resolver_1.syncCanons)((msg) => ctx.logger.info(msg));
+            if (!ok || !(0, canon_resolver_1.isCanonsAvailable)()) {
+                ctx.logger.warn('Failed to download canons. Skipping repository analysis.');
+                return;
+            }
+        }
+        const systemPrompt = (0, canon_resolver_1.resolveCanonFile)('prompts/init/system-prompt.md');
+        if (!systemPrompt) {
+            ctx.logger.warn('System prompt not found in canons (prompts/init/system-prompt.md). Run "collab update-canons" to refresh. Skipping repository analysis.');
+            return;
+        }
+        ctx.logger.info('Scanning repository structure...');
+        const repoCtx = (0, repo_scanner_1.scanRepository)((0, orchestrator_1.getRepoBaseDir)(ctx));
+        ctx.logger.info(`Repository: ${repoCtx.name} (${repoCtx.language}${repoCtx.framework ? ` / ${repoCtx.framework}` : ''}, ${repoCtx.totalSourceFiles} source files)`);
+        const messages = [
+            { role: 'system', content: systemPrompt },
+            { role: 'user', content: (0, repo_analysis_helpers_1.buildUserMessage)(repoCtx) },
+        ];
+        // Write the init prompt to .collab/ for debugging and tracking
+        const promptDebugPath = node_path_1.default.join(ctx.config.workspaceDir, '.collab', `init-prompt-${client.provider}-cli.md`);
+        const promptContent = [
+            `# Init Prompt — ${client.provider} CLI`,
+            `<!-- Generated: ${new Date().toISOString()} -->`,
+            '',
+            '## System Prompt',
+            '',
+            messages[0].content,
+            '',
+            '## User Prompt',
+            '',
+            messages[1].content,
+            '',
+        ].join('\n');
+        ctx.executor.ensureDirectory(node_path_1.default.dirname(promptDebugPath));
+        ctx.executor.writeFile(promptDebugPath, promptContent, {
+            description: `write init prompt debug file for ${client.provider}`,
+        });
+        ctx.logger.info('Analyzing repository with AI provider...');
+        const response = await client.complete(messages, { maxTokens: 8192 });
+        // Parse the response
+        let analysis;
+        try {
+            const jsonStr = (0, repo_analysis_helpers_1.extractJson)(response);
+            analysis = JSON.parse(jsonStr);
+        }
+        catch (err) {
+            ctx.logger.warn(`Failed to parse AI analysis response: ${String(err)}`);
+            ctx.logger.debug(`Raw response (first 500 chars): ${response.slice(0, 500)}`);
+            // Still generate AI helpers with empty analysis
+            (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, {});
+            return;
+        }
+        // Indexed mode writes to repoDir (docs/architecture/repo/)
+        (0, repo_analysis_helpers_1.writeAnalysisResults)(ctx, ctx.config.repoDir, analysis);
+        // Generate docs/ai/ helper files
+        (0, repo_analysis_helpers_1.generateAiHelpers)(ctx, repoCtx, analysis);
+    },
+};