@plusplusoneplusplus/coc 1.0.0

package/dist/server/wiki/generate-handler.js

@@ -0,0 +1,699 @@
+"use strict";
+/**
+ * Wiki Generate Handler
+ *
+ * Server-side handler for per-wiki phase regeneration.
+ * Adapted from deep-wiki's generate-handler for multi-wiki CoC server.
+ *
+ * Uses a per-wiki Map for generation state (not module singleton).
+ * Delegates actual generation to deep-wiki's public API via dynamic imports.
+ *
+ * Routes (flat — registered in wiki-routes.ts):
+ *   POST /api/wikis/:wikiId/admin/generate          — Start generation (SSE)
+ *   POST /api/wikis/:wikiId/admin/generate/cancel    — Cancel running generation
+ *   GET  /api/wikis/:wikiId/admin/generate/status    — Get phase cache status
+ *   POST /api/wikis/:wikiId/admin/generate/component/:id — Regenerate single component
+ *
+ * Cross-platform compatible (Linux/Mac/Windows).
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleStartGenerate = handleStartGenerate;
+exports.handleCancelGenerate = handleCancelGenerate;
+exports.handleGetGenerateStatus = handleGetGenerateStatus;
+exports.handleComponentRegenerate = handleComponentRegenerate;
+exports.collectCacheMetadata = collectCacheMetadata;
+exports.getGenerationState = getGenerationState;
+exports.resetGenerationState = resetGenerationState;
+exports.resetAllGenerationStates = resetAllGenerationStates;
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+const ask_handler_1 = require("./ask-handler");
+const router_1 = require("../shared/router");
+// ============================================================================
+// Dynamic Import Helper
+// ============================================================================
+// Deep-wiki modules are loaded dynamically to avoid a hard compile-time
+// dependency (coc does not list deep-wiki in its package.json dependencies).
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+async function importDeepWiki(subpath) {
+    // Use Function constructor to prevent TypeScript from resolving the module
+    // specifier at compile time.  At runtime the monorepo workspace link makes
+    // `@plusplusoneplusplus/deep-wiki` resolvable.
+    const modulePath = `@plusplusoneplusplus/deep-wiki/dist/${subpath}`;
+    return Promise.resolve(`${modulePath}`).then(s => __importStar(require(s)));
+}
+// Per-wiki generation state — replaces module-level singleton
+const generationStates = new Map();
+// ============================================================================
+// Start Generation
+// ============================================================================
+/**
+ * POST /api/wikis/:wikiId/admin/generate — Start phase generation with SSE streaming.
+ */
+async function handleStartGenerate(req, res, wikiId, wikiProvider) {
+    const wiki = wikiProvider.get(wikiId);
+    if (!wiki) {
+        (0, router_1.sendJson)(res, { error: `Wiki not found: ${wikiId}` }, 404);
+        return;
+    }
+    // Check if generation is already running for this wiki
+    const existingState = generationStates.get(wikiId);
+    if (existingState?.running) {
+        (0, router_1.sendJson)(res, { error: 'Generation already in progress for this wiki' }, 409);
+        return;
+    }
+    if (!wiki.registration.repoPath) {
+        (0, router_1.send400)(res, 'No repository path configured for this wiki.');
+        return;
+    }
+    // Parse request body
+    const body = await (0, ask_handler_1.readBody)(req);
+    let request;
+    try {
+        request = JSON.parse(body);
+    }
+    catch {
+        (0, router_1.send400)(res, 'Request body must be valid JSON');
+        return;
+    }
+    const startPhase = request.startPhase !== undefined ? request.startPhase : 1;
+    const endPhase = request.endPhase !== undefined ? request.endPhase : 5;
+    if (!Number.isInteger(startPhase) || startPhase < 1 || startPhase > 5) {
+        (0, router_1.send400)(res, `Invalid startPhase: ${startPhase}. Must be 1-5.`);
+        return;
+    }
+    if (!Number.isInteger(endPhase) || endPhase < 1 || endPhase > 5) {
+        (0, router_1.send400)(res, `Invalid endPhase: ${endPhase}. Must be 1-5.`);
+        return;
+    }
+    if (endPhase < startPhase) {
+        (0, router_1.send400)(res, `endPhase (${endPhase}) must be >= startPhase (${startPhase}).`);
+        return;
+    }
+    // Set up SSE response (no redundant CORS — router handles it)
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    // Initialize per-wiki generation state
+    const state = {
+        running: true,
+        currentPhase: startPhase,
+        cancelled: false,
+        startTime: Date.now(),
+    };
+    generationStates.set(wikiId, state);
+    const isCancelled = () => state.cancelled;
+    try {
+        await runGeneration(res, wiki, startPhase, endPhase, !!request.force, isCancelled, state);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, ask_handler_1.sendSSE)(res, { type: 'error', message });
+        (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: message });
+    }
+    finally {
+        generationStates.delete(wikiId);
+        res.end();
+    }
+}
+// ============================================================================
+// Generation Execution (delegates to deep-wiki phases)
+// ============================================================================
+async function runGeneration(res, wiki, startPhase, endPhase, force, isCancelled, state) {
+    const repoPath = path.resolve(wiki.registration.repoPath);
+    const outputDir = wiki.registration.wikiDir;
+    const totalStartTime = Date.now();
+    const options = {
+        output: outputDir,
+        depth: 'normal',
+        force,
+        useCache: !force,
+        verbose: false,
+        phase: startPhase,
+        endPhase,
+    };
+    // Dynamically import deep-wiki internals (no compile-time dependency)
+    const phases = await importDeepWiki('commands/phases');
+    const { runPhase1, runPhase2Consolidation, runPhase3Analysis, runPhase4Writing, runPhase5Website } = phases;
+    const cacheModule = await importDeepWiki('cache');
+    const { getCachedGraphAny, getCachedGraph, getCachedAnalyses, getCachedConsolidationAny, getCachedConsolidation } = cacheModule;
+    const { UsageTracker } = await importDeepWiki('usage-tracker');
+    const { checkAIAvailability } = await importDeepWiki('ai-invoker');
+    // Check AI availability for phases 1-4
+    if (endPhase <= 4 || startPhase <= 4) {
+        const availability = await checkAIAvailability();
+        if (!availability.available) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', message: `Copilot SDK not available: ${availability.reason || 'Unknown'}` });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'AI service unavailable' });
+            return;
+        }
+    }
+    const usageTracker = new UsageTracker();
+    let graph;
+    let analyses;
+    let reanalyzedComponentIds;
+    // Phase 1: Discovery
+    if (startPhase <= 1 && endPhase >= 1) {
+        if (isCancelled()) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Cancelled' });
+            return;
+        }
+        state.currentPhase = 1;
+        (0, ask_handler_1.sendSSE)(res, { type: 'status', phase: 1, state: 'running', message: 'Starting discovery...' });
+        const phaseStart = Date.now();
+        try {
+            const result = await runPhase1(repoPath, options, isCancelled);
+            if (result.exitCode !== undefined) {
+                (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 1, message: `Discovery failed (exit code ${result.exitCode})` });
+                (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 1 failed' });
+                return;
+            }
+            graph = result.graph;
+            if (result.tokenUsage)
+                usageTracker.addUsage('discovery', result.tokenUsage);
+            (0, ask_handler_1.sendSSE)(res, { type: 'phase-complete', phase: 1, success: true, duration: Date.now() - phaseStart, message: `Discovered ${graph.components.length} components` });
+        }
+        catch (error) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 1, message: error instanceof Error ? error.message : String(error) });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 1 failed' });
+            return;
+        }
+    }
+    else if (startPhase > 1) {
+        const cached = getCachedGraphAny(outputDir) ?? await getCachedGraph(repoPath, outputDir);
+        if (!cached) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', message: 'No cached component graph found. Run Discovery first.' });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Missing prerequisite: Discovery' });
+            return;
+        }
+        graph = cached.graph;
+        (0, ask_handler_1.sendSSE)(res, { type: 'log', phase: startPhase, message: `Loaded cached component graph (${graph.components.length} components)` });
+    }
+    if (!graph) {
+        (0, ask_handler_1.sendSSE)(res, { type: 'error', message: 'No component graph available' });
+        (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'No component graph' });
+        return;
+    }
+    // Phase 2: Consolidation
+    if (startPhase <= 2 && endPhase >= 2) {
+        if (isCancelled()) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Cancelled' });
+            return;
+        }
+        state.currentPhase = 2;
+        (0, ask_handler_1.sendSSE)(res, { type: 'status', phase: 2, state: 'running', message: 'Starting consolidation...' });
+        const phaseStart = Date.now();
+        try {
+            const result = await runPhase2Consolidation(repoPath, graph, options, usageTracker);
+            graph = result.graph;
+            (0, ask_handler_1.sendSSE)(res, { type: 'phase-complete', phase: 2, success: true, duration: Date.now() - phaseStart, message: `Consolidated to ${graph.components.length} components` });
+        }
+        catch (error) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 2, message: error instanceof Error ? error.message : String(error) });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 2 failed' });
+            return;
+        }
+    }
+    else if (startPhase > 2 && graph.components.length > 0) {
+        // When skipping Phase 2, load the consolidated graph from cache so
+        // downstream phases operate on the reduced component set.
+        const consolidatedCache = getCachedConsolidationAny(outputDir, graph.components.length)
+            ?? await getCachedConsolidation(repoPath, outputDir, graph.components.length);
+        if (consolidatedCache) {
+            const prevCount = graph.components.length;
+            graph = consolidatedCache.graph;
+            (0, ask_handler_1.sendSSE)(res, { type: 'log', phase: startPhase, message: `Loaded consolidated graph (${prevCount} → ${graph.components.length} components)` });
+        }
+    }
+    // Phase 3: Analysis
+    if (startPhase <= 3 && endPhase >= 3) {
+        if (isCancelled()) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Cancelled' });
+            return;
+        }
+        state.currentPhase = 3;
+        (0, ask_handler_1.sendSSE)(res, { type: 'status', phase: 3, state: 'running', message: 'Starting analysis...' });
+        const phaseStart = Date.now();
+        try {
+            const result = await runPhase3Analysis(repoPath, graph, options, isCancelled, usageTracker);
+            if (result.exitCode !== undefined) {
+                (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 3, message: `Analysis failed (exit code ${result.exitCode})` });
+                (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 3 failed' });
+                return;
+            }
+            analyses = result.analyses;
+            reanalyzedComponentIds = result.reanalyzedComponentIds;
+            (0, ask_handler_1.sendSSE)(res, { type: 'phase-complete', phase: 3, success: true, duration: Date.now() - phaseStart, message: `Analyzed ${analyses.length} components` });
+        }
+        catch (error) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 3, message: error instanceof Error ? error.message : String(error) });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 3 failed' });
+            return;
+        }
+    }
+    else if (startPhase > 3 && endPhase >= 4) {
+        const cached = getCachedAnalyses(outputDir);
+        if (!cached || cached.length === 0) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', message: 'No cached analyses found. Run Analysis first.' });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Missing prerequisite: Analysis' });
+            return;
+        }
+        // Filter to only analyses whose component IDs exist in the current
+        // (possibly consolidated) graph — stale files from pre-consolidation
+        // runs may still be on disk.
+        const graphIds = new Set(graph.components.map((m) => m.id));
+        analyses = graphIds.size > 0
+            ? cached.filter((a) => graphIds.has(a.componentId))
+            : cached;
+        (0, ask_handler_1.sendSSE)(res, { type: 'log', phase: startPhase, message: `Loaded ${analyses.length} cached analyses` });
+    }
+    // Phase 4: Writing
+    if (startPhase <= 4 && endPhase >= 4) {
+        if (isCancelled()) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Cancelled' });
+            return;
+        }
+        if (!analyses) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', message: 'No analyses available for writing phase' });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Missing analyses' });
+            return;
+        }
+        state.currentPhase = 4;
+        (0, ask_handler_1.sendSSE)(res, { type: 'status', phase: 4, state: 'running', message: 'Starting article writing...' });
+        const phaseStart = Date.now();
+        try {
+            const result = await runPhase4Writing(repoPath, graph, analyses, options, isCancelled, usageTracker, reanalyzedComponentIds);
+            if (result.exitCode !== undefined) {
+                (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 4, message: `Writing failed (exit code ${result.exitCode})` });
+                (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 4 failed' });
+                return;
+            }
+            (0, ask_handler_1.sendSSE)(res, { type: 'phase-complete', phase: 4, success: true, duration: Date.now() - phaseStart, message: `Wrote ${result.articlesWritten} articles` });
+        }
+        catch (error) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 4, message: error instanceof Error ? error.message : String(error) });
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Phase 4 failed' });
+            return;
+        }
+    }
+    // Phase 5: Website
+    if (startPhase <= 5 && endPhase >= 5) {
+        if (isCancelled()) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, error: 'Cancelled' });
+            return;
+        }
+        state.currentPhase = 5;
+        (0, ask_handler_1.sendSSE)(res, { type: 'status', phase: 5, state: 'running', message: 'Building website...' });
+        if (graph) {
+            const graphOutputFile = path.join(path.resolve(outputDir), 'component-graph.json');
+            try {
+                fs.mkdirSync(path.resolve(outputDir), { recursive: true });
+                fs.writeFileSync(graphOutputFile, JSON.stringify(graph, null, 2), 'utf-8');
+            }
+            catch { /* non-fatal */ }
+        }
+        const phaseStart = Date.now();
+        try {
+            const result = runPhase5Website(options);
+            if (result.success) {
+                (0, ask_handler_1.sendSSE)(res, { type: 'phase-complete', phase: 5, success: true, duration: Date.now() - phaseStart, message: 'Website generated' });
+            }
+            else {
+                (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 5, message: 'Website generation failed' });
+            }
+        }
+        catch (error) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'error', phase: 5, message: error instanceof Error ? error.message : String(error) });
+        }
+    }
+    // Post-generation: Reload wiki data
+    if (endPhase >= 4) {
+        try {
+            wiki.wikiData.reload();
+            (0, ask_handler_1.sendSSE)(res, { type: 'log', message: 'Wiki data reloaded' });
+        }
+        catch (error) {
+            (0, ask_handler_1.sendSSE)(res, { type: 'log', message: `Warning: Failed to reload wiki data: ${error instanceof Error ? error.message : String(error)}` });
+        }
+    }
+    (0, ask_handler_1.sendSSE)(res, { type: 'done', success: true, duration: Date.now() - totalStartTime });
+}
+// ============================================================================
+// Cancel Generation
+// ============================================================================
+/**
+ * POST /api/wikis/:wikiId/admin/generate/cancel — Cancel running generation.
+ */
+function handleCancelGenerate(res, wikiId) {
+    const state = generationStates.get(wikiId);
+    if (!state?.running) {
+        (0, router_1.sendJson)(res, { success: false, error: 'No generation in progress for this wiki' });
+        return;
+    }
+    state.cancelled = true;
+    (0, router_1.sendJson)(res, { success: true });
+}
+// ============================================================================
+// Generation Status
+// ============================================================================
+/**
+ * GET /api/wikis/:wikiId/admin/generate/status — Get phase cache status.
+ */
+function handleGetGenerateStatus(res, wikiId, wikiProvider) {
+    const wiki = wikiProvider.get(wikiId);
+    if (!wiki) {
+        (0, router_1.sendJson)(res, { error: `Wiki not found: ${wikiId}` }, 404);
+        return;
+    }
+    try {
+        const outputDir = wiki.registration.wikiDir;
+        const available = !!wiki.registration.repoPath;
+        const phases = {};
+        if (available) {
+            phases['1'] = checkCacheFileStatus(path.join(path.resolve(outputDir), '.wiki-cache', 'component-graph.json'));
+            phases['2'] = checkCacheFileStatus(path.join(path.resolve(outputDir), '.wiki-cache', 'consolidated-graph.json'));
+            phases['3'] = checkCacheFileStatus(path.join(path.resolve(outputDir), '.wiki-cache', 'analyses', '_metadata.json'));
+            phases['4'] = checkCacheFileStatus(path.join(path.resolve(outputDir), '.wiki-cache', 'articles', '_metadata.json'));
+            // Per-component article status
+            try {
+                const components = {};
+                const graph = wiki.wikiData.graph;
+                const articlesDir = path.join(path.resolve(outputDir), '.wiki-cache', 'articles');
+                for (const mod of graph.components) {
+                    components[mod.id] = getComponentArticleCacheStatus(articlesDir, mod.id, mod.domain);
+                }
+                phases['4'].components = components;
+            }
+            catch { /* ignore */ }
+            phases['5'] = checkWebsiteCacheStatus(outputDir);
+        }
+        const metadata = collectCacheMetadata(wiki, path.resolve(outputDir));
+        const state = generationStates.get(wikiId);
+        (0, router_1.sendJson)(res, {
+            running: state?.running ?? false,
+            currentPhase: state?.currentPhase,
+            phases,
+            repoPath: wiki.registration.repoPath,
+            available,
+            metadata,
+        });
+    }
+    catch (error) {
+        (0, router_1.send500)(res, `Failed to get generation status: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+// ============================================================================
+// Single-Component Article Regeneration
+// ============================================================================
+/**
+ * POST /api/wikis/:wikiId/admin/generate/component/:componentId
+ */
+async function handleComponentRegenerate(req, res, wikiId, componentId, wikiProvider) {
+    const wiki = wikiProvider.get(wikiId);
+    if (!wiki) {
+        (0, router_1.sendJson)(res, { error: `Wiki not found: ${wikiId}` }, 404);
+        return;
+    }
+    if (!wiki.registration.repoPath) {
+        (0, router_1.sendJson)(res, { error: 'No repository path configured.' }, 503);
+        return;
+    }
+    const existingState = generationStates.get(wikiId);
+    if (existingState?.running) {
+        (0, router_1.sendJson)(res, { error: 'A generation is already in progress for this wiki' }, 409);
+        return;
+    }
+    const graph = wiki.wikiData.graph;
+    const componentInfo = graph.components.find((m) => m.id === componentId);
+    if (!componentInfo) {
+        (0, router_1.send404)(res, `Component not found: ${componentId}`);
+        return;
+    }
+    // Parse optional body
+    const body = await (0, ask_handler_1.readBody)(req);
+    let force = false;
+    try {
+        if (body.trim()) {
+            const parsed = JSON.parse(body);
+            force = !!parsed.force;
+        }
+    }
+    catch { /* use defaults */ }
+    // Load analysis
+    const cacheModule = await importDeepWiki('cache');
+    const analysis = cacheModule.getCachedAnalysis(componentId, wiki.registration.wikiDir);
+    const detail = wiki.wikiData.getComponentDetail(componentId);
+    const componentAnalysis = analysis || detail?.analysis;
+    if (!componentAnalysis) {
+        (0, router_1.sendJson)(res, { error: `No analysis cached for component "${componentId}". Run Phase 3 (Analysis) first.` }, 412);
+        return;
+    }
+    // SSE setup
+    res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        'Connection': 'keep-alive',
+        'X-Accel-Buffering': 'no',
+    });
+    const state = { running: true, currentPhase: 4, cancelled: false, startTime: Date.now() };
+    generationStates.set(wikiId, state);
+    try {
+        await runComponentRegeneration(res, wiki, componentId, componentInfo, componentAnalysis, graph, force);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        (0, ask_handler_1.sendSSE)(res, { type: 'error', message });
+        (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, componentId, error: message });
+    }
+    finally {
+        generationStates.delete(wikiId);
+        res.end();
+    }
+}
+async function runComponentRegeneration(res, wiki, componentId, componentInfo, analysis, graph, _force) {
+    const repoPath = path.resolve(wiki.registration.repoPath);
+    const outputDir = wiki.registration.wikiDir;
+    const startTime = Date.now();
+    const componentName = componentInfo.name || componentId;
+    (0, ask_handler_1.sendSSE)(res, { type: 'status', state: 'running', componentId, message: `Generating article for ${componentName}...` });
+    const { checkAIAvailability } = await importDeepWiki('ai-invoker');
+    const availability = await checkAIAvailability();
+    if (!availability.available) {
+        (0, ask_handler_1.sendSSE)(res, { type: 'error', message: `Copilot SDK not available: ${availability.reason || 'Unknown'}` });
+        (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, componentId, error: 'AI service unavailable' });
+        return;
+    }
+    const { buildComponentArticlePrompt } = await importDeepWiki('writing/prompts');
+    const prompt = buildComponentArticlePrompt(analysis, graph, 'normal');
+    (0, ask_handler_1.sendSSE)(res, { type: 'log', message: 'Sending to AI model...' });
+    const { createWritingInvoker } = await importDeepWiki('ai-invoker');
+    const invoker = createWritingInvoker({ repoPath });
+    const aiResult = await invoker(prompt);
+    if (!aiResult.success || !aiResult.response) {
+        const errMsg = aiResult.error || 'AI returned empty response';
+        (0, ask_handler_1.sendSSE)(res, { type: 'error', message: errMsg });
+        (0, ask_handler_1.sendSSE)(res, { type: 'done', success: false, componentId, error: errMsg });
+        return;
+    }
+    (0, ask_handler_1.sendSSE)(res, { type: 'log', message: 'Article generated, saving...' });
+    const { normalizeComponentId } = await importDeepWiki('schemas');
+    const { saveArticle } = await importDeepWiki('cache/article-cache');
+    const { getFolderHeadHash } = await importDeepWiki('cache/git-utils');
+    const { getArticleFilePath, normalizeLineEndings } = await importDeepWiki('writing/file-writer');
+    const domainId = componentInfo.domain;
+    const article = {
+        type: 'component',
+        slug: normalizeComponentId(componentId),
+        title: componentName,
+        content: aiResult.response,
+        componentId,
+        domainId,
+    };
+    const gitHash = await getFolderHeadHash(repoPath) || 'unknown';
+    saveArticle(componentId, article, outputDir, gitHash);
+    const resolvedDir = path.resolve(outputDir);
+    const filePath = getArticleFilePath(article, resolvedDir);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, normalizeLineEndings(article.content), 'utf-8');
+    // Reload wiki data
+    try {
+        wiki.wikiData.reload();
+        (0, ask_handler_1.sendSSE)(res, { type: 'log', message: 'Wiki data reloaded' });
+    }
+    catch (error) {
+        (0, ask_handler_1.sendSSE)(res, { type: 'log', message: `Warning: Failed to reload wiki data: ${error instanceof Error ? error.message : String(error)}` });
+    }
+    (0, ask_handler_1.sendSSE)(res, { type: 'done', success: true, componentId, duration: Date.now() - startTime, message: 'Article regenerated' });
+}
+function collectCacheMetadata(wiki, outputDir) {
+    const stats = {
+        components: 0,
+        categories: 0,
+        themes: 0,
+        domains: 0,
+        analyses: 0,
+        articles: 0,
+    };
+    try {
+        const graph = wiki.wikiData.graph;
+        if (graph) {
+            stats.components = Array.isArray(graph.components) ? graph.components.length : 0;
+            stats.categories = Array.isArray(graph.categories) ? graph.categories.length : 0;
+            stats.themes = Array.isArray(graph.themes) ? graph.themes.length : 0;
+            stats.domains = Array.isArray(graph.domains) ? graph.domains.length : 0;
+            if (graph.project) {
+                if (graph.project.name)
+                    stats.projectName = graph.project.name;
+                if (graph.project.language)
+                    stats.projectLanguage = graph.project.language;
+            }
+        }
+    }
+    catch { /* graph may not be loaded */ }
+    try {
+        const analysesDir = path.join(outputDir, '.wiki-cache', 'analyses');
+        if (fs.existsSync(analysesDir) && fs.statSync(analysesDir).isDirectory()) {
+            const graphComponentIds = new Set(Array.isArray(wiki.wikiData?.graph?.components)
+                ? wiki.wikiData.graph.components.map((m) => m.id)
+                : []);
+            const analysisFiles = fs.readdirSync(analysesDir)
+                .filter(f => f.endsWith('.json') && f !== '_metadata.json');
+            if (graphComponentIds.size > 0) {
+                stats.analyses = analysisFiles
+                    .filter(f => graphComponentIds.has(f.slice(0, -5))).length;
+            }
+            else {
+                stats.analyses = analysisFiles.length;
+            }
+        }
+    }
+    catch { /* ignore */ }
+    try {
+        const articlesDir = path.join(outputDir, '.wiki-cache', 'articles');
+        if (fs.existsSync(articlesDir) && fs.statSync(articlesDir).isDirectory()) {
+            stats.articles = countArticleFiles(articlesDir);
+        }
+    }
+    catch { /* ignore */ }
+    return stats;
+}
+function countArticleFiles(dir) {
+    let count = 0;
+    try {
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name.endsWith('.json') && !entry.name.startsWith('_')) {
+                count++;
+            }
+            else if (entry.isDirectory()) {
+                count += countArticleFiles(path.join(dir, entry.name));
+            }
+        }
+    }
+    catch { /* ignore */ }
+    return count;
+}
+// ============================================================================
+// Cache Status Helpers
+// ============================================================================
+function checkCacheFileStatus(filePath) {
+    try {
+        if (fs.existsSync(filePath)) {
+            const content = fs.readFileSync(filePath, 'utf-8');
+            const parsed = JSON.parse(content);
+            const timestamp = parsed?.metadata?.timestamp || parsed?.timestamp;
+            if (timestamp) {
+                return { cached: true, timestamp: new Date(timestamp).toISOString() };
+            }
+            return { cached: true };
+        }
+        return { cached: false };
+    }
+    catch {
+        return { cached: false };
+    }
+}
+function checkWebsiteCacheStatus(outputDir) {
+    try {
+        const indexPath = path.join(path.resolve(outputDir), 'index.html');
+        if (fs.existsSync(indexPath)) {
+            const stat = fs.statSync(indexPath);
+            return { cached: true, timestamp: stat.mtime.toISOString() };
+        }
+        return { cached: false };
+    }
+    catch {
+        return { cached: false };
+    }
+}
+function getComponentArticleCacheStatus(articlesDir, componentId, domainId) {
+    const pathsToTry = domainId
+        ? [path.join(articlesDir, domainId, `${componentId}.json`), path.join(articlesDir, `${componentId}.json`)]
+        : [path.join(articlesDir, `${componentId}.json`)];
+    for (const cachePath of pathsToTry) {
+        try {
+            if (fs.existsSync(cachePath)) {
+                const content = fs.readFileSync(cachePath, 'utf-8');
+                const parsed = JSON.parse(content);
+                if (parsed.article && parsed.article.slug) {
+                    const timestamp = parsed.timestamp ? new Date(parsed.timestamp).toISOString() : undefined;
+                    return { cached: true, timestamp };
+                }
+            }
+        }
+        catch { /* skip */ }
+    }
+    return { cached: false };
+}
+// ============================================================================
+// Testing Utilities
+// ============================================================================
+/** Get per-wiki generation state (for testing). */
+function getGenerationState(wikiId) {
+    return generationStates.get(wikiId) ?? null;
+}
+/** Reset per-wiki generation state (for testing). */
+function resetGenerationState(wikiId) {
+    generationStates.delete(wikiId);
+}
+/** Reset all generation states (for testing). */
+function resetAllGenerationStates() {
+    generationStates.clear();
+}
+//# sourceMappingURL=generate-handler.js.map