lattice-orchestrator 0.7.0

package/dist/routes/walkthrough.routes.js

@@ -0,0 +1,688 @@
+/**
+ * Walkthrough Routes - API for generating AI-narrated code walkthroughs
+ *
+ * Two generation modes:
+ * 1. Inline (legacy): POST /generate - Single LLM call, fast but annotations don't work
+ * 2. Agentic: POST /spawn - Spawns hidden Claude session with walkthrough skill
+ */
+import { Router } from 'express';
+import path from 'path';
+import os from 'os';
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { WalkthroughService, validateWalkthrough, fixLinkedPhraseLines } from '../services/walkthrough-service.js';
+import { SessionInfoService } from '../services/sessions/session-info-service.js';
+import { buildWalkthroughSkillPrompt, buildWalkthroughInitialPrompt, formatPrecomputedDataFile } from '../services/walkthrough-skill-prompt.js';
+import { createLogger } from '../services/infrastructure/logger.js';
+import { asStreamingId, asClaudeSessionId } from '../types/index.js';
+const logger = createLogger('WalkthroughRoutes');
+// Directory for walkthrough output files
+const WALKTHROUGH_DIR = path.join(os.homedir(), '.claudia', 'walkthroughs');
+// Track active walkthrough generations (scopeId -> generation info)
+const activeWalkthroughGenerations = new Map();
+export function createWalkthroughRoutes(deps) {
+    const { historyReader, processManager, streamManager, conversationStatusManager } = deps;
+    const router = Router();
+    const walkthroughService = new WalkthroughService(historyReader);
+    // Ensure walkthrough directory exists
+    if (!existsSync(WALKTHROUGH_DIR)) {
+        mkdirSync(WALKTHROUGH_DIR, { recursive: true });
+    }
+    /**
+     * GET /api/walkthrough/list
+     *
+     * List all generated walkthroughs across all sessions.
+     * Returns metadata about each walkthrough including session info.
+     *
+     * IMPORTANT: This must be defined BEFORE /:sessionId/* routes to avoid
+     * "list" being interpreted as a sessionId.
+     */
+    router.get('/list', async (_req, res, next) => {
+        try {
+            const walkthroughs = await listAllWalkthroughs(historyReader);
+            res.json({ walkthroughs });
+        }
+        catch (error) {
+            logger.error('Failed to list walkthroughs', {
+                error: error instanceof Error ? error.message : String(error),
+            });
+            next(error);
+        }
+    });
+    /**
+     * POST /api/walkthrough/:sessionId/spawn
+     *
+     * Spawn a hidden Claude session to generate a walkthrough.
+     * The session runs with the walkthrough skill and writes output to a file.
+     *
+     * Request body:
+     *   - scopeId: string - Identifier for this walkthrough scope
+     *   - editIndices: number[] - Which edit calls to include
+     *   - writeIndices: number[] - Which write calls to include
+     *
+     * Response:
+     *   - streamingId: string - ID of the spawned session
+     *   - outputPath: string - Where the walkthrough will be written
+     */
+    router.post('/:sessionId/spawn', async (req, res, next) => {
+        const { sessionId } = req.params;
+        const { scopeId, editIndices, writeIndices } = req.body || {};
+        if (!scopeId) {
+            return res.status(400).json({ error: 'scopeId is required' });
+        }
+        // Check if already generating
+        const existing = activeWalkthroughGenerations.get(scopeId);
+        if (existing) {
+            logger.info('Walkthrough generation already in progress', {
+                scopeId,
+                streamingId: existing.streamingId,
+                elapsedMs: Date.now() - existing.startedAt,
+            });
+            return res.json({
+                status: 'in_progress',
+                streamingId: existing.streamingId,
+                outputPath: getOutputPath(sessionId, scopeId),
+            });
+        }
+        try {
+            // Find the session JSONL file path
+            const sessionJsonlPath = await historyReader.getSessionFilePath(sessionId);
+            if (!sessionJsonlPath) {
+                return res.status(404).json({ error: 'Session file not found' });
+            }
+            const outputPath = getOutputPath(sessionId, scopeId);
+            const workingDirectory = path.dirname(sessionJsonlPath);
+            // Pre-compute file change data, filtered by scope if provided
+            const scope = (editIndices?.length || writeIndices?.length)
+                ? { editIndices, writeIndices }
+                : undefined;
+            logger.info('Pre-computing walkthrough data', { sessionId, hasScope: !!scope });
+            const precomputedData = await walkthroughService.precomputeWalkthroughData(sessionId, scope);
+            // Write full pre-computed data to a file the model can read
+            const precomputedDataPath = path.join(WALKTHROUGH_DIR, `${sessionId}-${scopeId}-data.md`);
+            const dataFileContent = formatPrecomputedDataFile(precomputedData);
+            writeFileSync(precomputedDataPath, dataFileContent);
+            logger.info('Wrote pre-computed data file', {
+                path: precomputedDataPath,
+                sizeBytes: dataFileContent.length,
+                fileCount: precomputedData.files.length,
+            });
+            // Build the skill context with pre-computed data
+            const context = {
+                targetSessionId: sessionId,
+                scopeId,
+                editIndices: editIndices || [],
+                writeIndices: writeIndices || [],
+                outputPath,
+                sessionJsonlPath,
+                precomputedData,
+                precomputedDataPath,
+            };
+            const systemPrompt = buildWalkthroughSkillPrompt(context);
+            const initialPrompt = buildWalkthroughInitialPrompt(context);
+            logger.info('Spawning walkthrough generation session', {
+                targetSessionId: sessionId,
+                scopeId,
+                editCount: context.editIndices.length,
+                writeCount: context.writeIndices.length,
+                outputPath,
+                sessionJsonlPath,
+                workingDirectory,
+            });
+            // Spawn a hidden Claude session with Opus for quality walkthroughs
+            const result = await processManager.startConversation({
+                workingDirectory,
+                initialPrompt,
+                systemPrompt,
+                model: 'claude-opus-4-5-20251101',
+                permissionMode: 'bypassPermissions', // Let it read/write freely
+            });
+            // Track this generation
+            const streamingId = asStreamingId(result.streamingId);
+            const claudeSessionId = asClaudeSessionId(result.systemInit.session_id);
+            logger.info('Walkthrough session spawned successfully', {
+                streamingId,
+                claudeSessionId,
+                scopeId,
+                targetSessionId: sessionId,
+            });
+            // Mark session as archived immediately so it doesn't appear in sidebar
+            // Walkthrough generations are internal - users access them via the walkthrough UI
+            const sessionInfo = SessionInfoService.getInstance();
+            try {
+                await sessionInfo.updateSessionInfo(claudeSessionId, { archived: true });
+                logger.debug('Walkthrough session marked as archived (hidden from sidebar)', { claudeSessionId });
+            }
+            catch (e) {
+                logger.warn('Failed to archive walkthrough session', { claudeSessionId, error: e });
+            }
+            // Register with conversation status manager for tracking (but won't show in sidebar due to archived: true)
+            conversationStatusManager.registerActiveSession(streamingId, claudeSessionId, {
+                initialPrompt: `[Walkthrough] Generating for scope: ${scopeId}`,
+                workingDirectory: result.systemInit.cwd,
+                model: result.systemInit.model,
+            });
+            activeWalkthroughGenerations.set(scopeId, {
+                streamingId,
+                targetSessionId: sessionId,
+                scopeId,
+                startedAt: Date.now(),
+            });
+            // Listen for session completion to broadcast event
+            const handleProcessEnd = () => {
+                const generation = activeWalkthroughGenerations.get(scopeId);
+                if (generation?.streamingId === streamingId) {
+                    activeWalkthroughGenerations.delete(scopeId);
+                    const durationMs = Date.now() - generation.startedAt;
+                    logger.info('Walkthrough generation completed', {
+                        scopeId,
+                        targetSessionId: sessionId,
+                        durationMs,
+                    });
+                    // Validate the generated walkthrough
+                    let validationPassed = false;
+                    let validationErrors = [];
+                    let validationWarnings = [];
+                    if (existsSync(outputPath)) {
+                        try {
+                            const content = readFileSync(outputPath, 'utf-8');
+                            const walkthrough = JSON.parse(content);
+                            const validation = validateWalkthrough(walkthrough);
+                            validationPassed = validation.passed;
+                            validationErrors = validation.errors;
+                            validationWarnings = validation.warnings;
+                            logger.info('Post-generation validation', {
+                                scopeId,
+                                targetSessionId: sessionId,
+                                passed: validationPassed,
+                                errorCount: validationErrors.length,
+                                warningCount: validationWarnings.length,
+                                errors: validationErrors,
+                            });
+                        }
+                        catch (parseError) {
+                            validationErrors = ['Failed to parse generated walkthrough JSON'];
+                            logger.error('Failed to parse generated walkthrough', {
+                                scopeId,
+                                targetSessionId: sessionId,
+                                error: parseError instanceof Error ? parseError.message : String(parseError),
+                            });
+                        }
+                    }
+                    else {
+                        validationErrors = ['Output file not created'];
+                        logger.warn('Walkthrough output file not created', { scopeId, outputPath });
+                    }
+                    // Broadcast completion event with validation results
+                    streamManager.broadcast(streamingId, {
+                        type: validationPassed ? 'walkthrough_complete' : 'walkthrough_validation_failed',
+                        targetSessionId: sessionId,
+                        scopeId,
+                        outputPath,
+                        validation: {
+                            passed: validationPassed,
+                            errors: validationErrors,
+                            warnings: validationWarnings,
+                        },
+                        durationMs,
+                        timestamp: new Date().toISOString(),
+                    });
+                }
+            };
+            // Set up cleanup when process ends
+            logger.info('Setting up process-end listener', { streamingId, scopeId });
+            processManager.on('process-end', ({ streamingId: endedId }) => {
+                logger.info('process-end event received', { endedId, expectedId: streamingId, matches: endedId === streamingId });
+                if (endedId === streamingId) {
+                    handleProcessEnd();
+                }
+            });
+            res.json({
+                status: 'started',
+                streamingId,
+                outputPath,
+            });
+        }
+        catch (error) {
+            logger.error('Failed to spawn walkthrough generation', {
+                sessionId,
+                scopeId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            next(error);
+        }
+    });
+    /**
+     * GET /api/walkthrough/:sessionId/status/:scopeId
+     *
+     * Check the status of a walkthrough generation.
+     * File-first: if output exists, it's complete (handles server restarts)
+     */
+    router.get('/:sessionId/status/:scopeId', async (req, res) => {
+        const { sessionId, scopeId } = req.params;
+        const outputPath = getOutputPath(sessionId, scopeId);
+        // File-first: if output exists, it's complete regardless of in-memory state
+        // This handles server restarts during generation
+        if (existsSync(outputPath)) {
+            // Clean up stale in-memory tracking if present
+            if (activeWalkthroughGenerations.has(scopeId)) {
+                logger.info('Cleaning up stale generation tracking (file exists)', { scopeId });
+                activeWalkthroughGenerations.delete(scopeId);
+            }
+            // Include validation results so frontend can show warnings/errors
+            let validation = { passed: true, errors: [], warnings: [] };
+            try {
+                const content = readFileSync(outputPath, 'utf-8');
+                const walkthrough = JSON.parse(content);
+                validation = validateWalkthrough(walkthrough);
+            }
+            catch (error) {
+                validation = { passed: false, errors: ['Failed to parse walkthrough'], warnings: [] };
+            }
+            return res.json({
+                status: validation.passed ? 'complete' : 'complete_with_errors',
+                outputPath,
+                validation,
+            });
+        }
+        // Check in-memory tracking for in-progress generations
+        const generation = activeWalkthroughGenerations.get(scopeId);
+        if (generation) {
+            // Verify the session is still running
+            const isRunning = processManager.isSessionActive(generation.streamingId);
+            logger.debug('Checking generation status', {
+                scopeId,
+                streamingId: generation.streamingId,
+                isRunning,
+                elapsedMs: Date.now() - generation.startedAt,
+            });
+            if (!isRunning) {
+                // Session ended without writing file - clean up
+                logger.warn('Generation session ended without output', {
+                    scopeId,
+                    streamingId: generation.streamingId,
+                    elapsedMs: Date.now() - generation.startedAt,
+                });
+                activeWalkthroughGenerations.delete(scopeId);
+                return res.json({
+                    status: 'not_started',
+                    outputPath,
+                });
+            }
+            return res.json({
+                status: 'in_progress',
+                streamingId: generation.streamingId,
+                elapsedMs: Date.now() - generation.startedAt,
+                outputPath,
+            });
+        }
+        return res.json({
+            status: 'not_started',
+            outputPath,
+        });
+    });
+    /**
+     * GET /api/walkthrough/:sessionId/result/:scopeId
+     *
+     * Get the generated walkthrough (reads from output file).
+     * Automatically injects computed diffs from the database for the full diff view.
+     * Optionally validates the walkthrough and includes validation results.
+     */
+    router.get('/:sessionId/result/:scopeId', async (req, res) => {
+        const { sessionId, scopeId } = req.params;
+        const includeValidation = req.query.validate === 'true';
+        const outputPath = getOutputPath(sessionId, scopeId);
+        if (!existsSync(outputPath)) {
+            return res.status(404).json({ error: 'Walkthrough not found' });
+        }
+        try {
+            const content = readFileSync(outputPath, 'utf-8');
+            let walkthrough = JSON.parse(content);
+            // Fix linkedPhrase line numbers (LLMs often produce off-by-one errors)
+            walkthrough = fixLinkedPhraseLines(walkthrough);
+            // Inject computed diffs from database for full diff view
+            walkthrough = injectComputedDiffs(walkthrough, sessionId);
+            if (includeValidation) {
+                const validation = validateWalkthrough(walkthrough);
+                return res.json({ walkthrough, validation });
+            }
+            res.json(walkthrough);
+        }
+        catch (error) {
+            logger.error('Failed to read walkthrough file', {
+                sessionId,
+                scopeId,
+                outputPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            res.status(500).json({ error: 'Failed to read walkthrough file' });
+        }
+    });
+    /**
+     * GET /api/walkthrough/:sessionId/validate/:scopeId
+     *
+     * Validate an existing walkthrough against quality requirements.
+     */
+    router.get('/:sessionId/validate/:scopeId', async (req, res) => {
+        const { sessionId, scopeId } = req.params;
+        const outputPath = getOutputPath(sessionId, scopeId);
+        if (!existsSync(outputPath)) {
+            return res.status(404).json({ error: 'Walkthrough not found' });
+        }
+        try {
+            const content = readFileSync(outputPath, 'utf-8');
+            const walkthrough = JSON.parse(content);
+            const validation = validateWalkthrough(walkthrough);
+            logger.info('Validated walkthrough', {
+                sessionId,
+                scopeId,
+                passed: validation.passed,
+                errorCount: validation.errors.length,
+                warningCount: validation.warnings.length,
+            });
+            res.json(validation);
+        }
+        catch (error) {
+            logger.error('Failed to validate walkthrough', {
+                sessionId,
+                scopeId,
+                outputPath,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            res.status(500).json({ error: 'Failed to validate walkthrough' });
+        }
+    });
+    /**
+     * POST /api/walkthrough/:sessionId/generate (LEGACY)
+     *
+     * Generate a walkthrough with a single LLM call.
+     * Kept for backwards compatibility but annotations don't work reliably.
+     */
+    router.post('/:sessionId/generate', async (req, res, next) => {
+        const { sessionId } = req.params;
+        const { scopeId, editIndices, writeIndices } = req.body || {};
+        try {
+            logger.info('Generating walkthrough (inline mode)', { sessionId, scopeId, editCount: editIndices?.length, writeCount: writeIndices?.length });
+            const walkthrough = await walkthroughService.generateWalkthrough(sessionId, { editIndices, writeIndices });
+            res.json(walkthrough);
+        }
+        catch (error) {
+            logger.error('Failed to generate walkthrough', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            next(error);
+        }
+    });
+    /**
+     * GET /api/walkthrough/:sessionId/scope
+     *
+     * Analyze the session and suggest conceptual groupings for walkthroughs.
+     * Uses Haiku for fast analysis (~2-3s). Results are cached.
+     *
+     * Query params:
+     *   refresh=true - Force re-analysis, ignore cache
+     *
+     * Response includes:
+     *   cachedAt: ISO timestamp when analysis was generated (if from cache)
+     *   cachedAtTurn: Turn count when analysis was generated (if from cache)
+     *   currentTurnCount: Current session turn count
+     *   isStale: true if session has more turns than when cached
+     */
+    router.get('/:sessionId/scope', async (req, res, next) => {
+        const { sessionId } = req.params;
+        // Express may parse query as boolean or string depending on qs settings
+        const forceRefresh = req.query.refresh === 'true' || req.query.refresh === true;
+        const sessionInfoService = SessionInfoService.getInstance();
+        try {
+            // Get current session turn count
+            const details = await historyReader.fetchConversationDirect(sessionId);
+            const currentTurnCount = details?.messages?.filter((m) => m.type === 'user').length || 0;
+            // Check cache
+            const cached = sessionInfoService.getWalkthroughScopeCache(sessionId);
+            // Return cached if not forcing refresh
+            if (!forceRefresh && cached) {
+                const isStale = currentTurnCount > cached.turnCount;
+                logger.info('Returning cached walkthrough scope', {
+                    sessionId,
+                    cachedAtTurn: cached.turnCount,
+                    currentTurnCount,
+                    isStale
+                });
+                return res.json({
+                    ...cached.analysis,
+                    cachedAt: cached.generatedAt,
+                    cachedAtTurn: cached.turnCount,
+                    currentTurnCount,
+                    isStale,
+                });
+            }
+            // Extract previous groupings for stability (skip 'complete-session')
+            let previousGroupings;
+            if (cached?.analysis) {
+                const cachedAnalysis = cached.analysis;
+                if (cachedAnalysis.options) {
+                    previousGroupings = cachedAnalysis.options
+                        .filter(o => o.id !== 'complete-session')
+                        .map(o => ({
+                        id: o.id,
+                        title: o.title,
+                        description: o.description,
+                        editIndices: o.editIndices || [],
+                        writeIndices: o.writeIndices || [],
+                    }));
+                }
+            }
+            logger.info('Analyzing walkthrough scope', {
+                sessionId,
+                forceRefresh,
+                previousGroupingCount: previousGroupings?.length || 0,
+            });
+            const analysis = await walkthroughService.analyzeScope(sessionId, previousGroupings);
+            // Cache the result
+            sessionInfoService.setWalkthroughScopeCache(sessionId, currentTurnCount, analysis);
+            res.json({
+                ...analysis,
+                cachedAt: new Date().toISOString(),
+                cachedAtTurn: currentTurnCount,
+                currentTurnCount,
+                isStale: false,
+            });
+        }
+        catch (error) {
+            logger.error('Failed to analyze walkthrough scope', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            next(error);
+        }
+    });
+    /**
+     * GET /api/walkthrough/:sessionId/preview
+     *
+     * Quick preview - stats about the session's changes.
+     */
+    router.get('/:sessionId/preview', async (req, res, next) => {
+        const { sessionId } = req.params;
+        try {
+            const details = await historyReader.fetchConversationDirect(sessionId);
+            if (!details || !details.messages) {
+                return res.status(404).json({ error: 'Session not found' });
+            }
+            const messages = details.messages;
+            // Count edits and writes
+            let editCount = 0;
+            let writeCount = 0;
+            const filesModified = new Set();
+            for (const msg of messages) {
+                if (msg.type === 'assistant') {
+                    const content = msg.message.content;
+                    if (Array.isArray(content)) {
+                        for (const block of content) {
+                            if (block.type === 'tool_use') {
+                                if (block.name === 'Edit' && block.input) {
+                                    editCount++;
+                                    filesModified.add(block.input.file_path);
+                                }
+                                else if (block.name === 'Write' && block.input) {
+                                    writeCount++;
+                                    filesModified.add(block.input.file_path);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            // Get first user message as title
+            let userRequest = '';
+            for (const msg of messages) {
+                if (msg.type === 'user') {
+                    const content = msg.message.content;
+                    if (typeof content === 'string') {
+                        userRequest = content.slice(0, 200);
+                        break;
+                    }
+                }
+            }
+            res.json({
+                sessionId,
+                editCount,
+                writeCount,
+                totalChanges: editCount + writeCount,
+                filesModified: Array.from(filesModified).map((f) => f.replace(/^\/home\/jason\/(claudia|cui-custom)\//, '')),
+                userRequest,
+                canGenerate: editCount + writeCount > 0,
+            });
+        }
+        catch (error) {
+            logger.error('Failed to preview walkthrough', {
+                sessionId,
+                error: error instanceof Error ? error.message : String(error),
+            });
+            next(error);
+        }
+    });
+    return router;
+}
+async function listAllWalkthroughs(historyReader) {
+    const { readdirSync, statSync } = await import('fs');
+    const sessionInfo = SessionInfoService.getInstance();
+    if (!existsSync(WALKTHROUGH_DIR)) {
+        return [];
+    }
+    const files = readdirSync(WALKTHROUGH_DIR).filter(f => f.endsWith('.json') && !f.includes('-data'));
+    const walkthroughs = [];
+    for (const file of files) {
+        try {
+            const filePath = path.join(WALKTHROUGH_DIR, file);
+            const stat = statSync(filePath);
+            const content = readFileSync(filePath, 'utf-8');
+            const walkthrough = JSON.parse(content);
+            // Parse filename: {sessionId}-{scopeId}.json
+            const baseName = file.replace('.json', '');
+            // Session IDs are UUIDs (36 chars), scope IDs follow
+            const sessionId = baseName.slice(0, 36);
+            const scopeId = baseName.slice(37); // Skip the hyphen after UUID
+            // Get session info for context (both are async)
+            const session = await sessionInfo.getSessionInfo(sessionId);
+            const insights = await sessionInfo.getInsights(sessionId);
+            walkthroughs.push({
+                sessionId,
+                scopeId,
+                title: walkthrough.title || scopeId,
+                summary: walkthrough.summary || '',
+                generatedAt: stat.mtime.toISOString(),
+                fileSizeKb: Math.round(stat.size / 1024),
+                sectionCount: walkthrough.sections?.length || 0,
+                sessionPurpose: insights?.purpose || undefined,
+                sessionName: session?.custom_name || undefined,
+                url: `/session/${sessionId}/walkthrough?scope=${encodeURIComponent(scopeId)}`,
+            });
+        }
+        catch (error) {
+            logger.warn('Failed to parse walkthrough file', { file, error });
+        }
+    }
+    // Sort by generation date, newest first
+    walkthroughs.sort((a, b) => new Date(b.generatedAt).getTime() - new Date(a.generatedAt).getTime());
+    return walkthroughs;
+}
+/**
+ * Get the output file path for a walkthrough
+ */
+function getOutputPath(sessionId, scopeId) {
+    const safeScope = scopeId.replace(/[^a-zA-Z0-9_-]/g, '_');
+    return path.join(WALKTHROUGH_DIR, `${sessionId}-${safeScope}.json`);
+}
+/**
+ * Compute file diffs from the turn_file_changes table.
+ * Returns a map of file path -> computed diff data.
+ */
+function computeFileDiffs(sessionId) {
+    const sessionInfo = SessionInfoService.getInstance();
+    const fileChanges = sessionInfo.getFileChanges(sessionId);
+    const diffsByFile = new Map();
+    for (const change of fileChanges) {
+        const relativePath = change.filePath
+            .replace(/^\/home\/jason\/(claudia|cui-custom)\//, '')
+            .replace(/^\/home\/jason\//, '~/');
+        if (!diffsByFile.has(change.filePath)) {
+            diffsByFile.set(change.filePath, {
+                file: change.filePath,
+                relativePath,
+                allBefore: '',
+                allAfter: '',
+                linesAdded: 0,
+                linesRemoved: 0,
+                editCount: 0,
+                writeCount: 0,
+            });
+        }
+        const diff = diffsByFile.get(change.filePath);
+        // Accumulate before/after content
+        if (change.oldString) {
+            diff.allBefore += (diff.allBefore ? '\n// ---\n' : '') + change.oldString;
+        }
+        diff.allAfter += (diff.allAfter ? '\n// ---\n' : '') + change.newString;
+        // Count changes
+        if (change.toolName === 'Edit') {
+            diff.editCount++;
+        }
+        else {
+            diff.writeCount++;
+        }
+        // Compute line stats
+        const newLines = (change.newString.match(/\n/g) || []).length + 1;
+        const oldLines = change.oldString ? (change.oldString.match(/\n/g) || []).length + 1 : 0;
+        if (change.toolName === 'Write') {
+            diff.linesAdded += newLines;
+        }
+        else {
+            diff.linesAdded += Math.max(0, newLines - oldLines);
+            diff.linesRemoved += Math.max(0, oldLines - newLines);
+        }
+    }
+    return diffsByFile;
+}
+/**
+ * Inject computed diffs into a walkthrough response.
+ * Adds `computedDiffs` field with aggregated file change data.
+ */
+function injectComputedDiffs(walkthrough, sessionId) {
+    const diffs = computeFileDiffs(sessionId);
+    // Convert to array for JSON
+    const computedDiffs = Array.from(diffs.values()).map(d => ({
+        file: d.relativePath,
+        fullPath: d.file,
+        allBefore: d.allBefore,
+        allAfter: d.allAfter,
+        linesAdded: d.linesAdded,
+        linesRemoved: d.linesRemoved,
+        editCount: d.editCount,
+        writeCount: d.writeCount,
+    }));
+    return {
+        ...walkthrough,
+        computedDiffs,
+    };
+}
+//# sourceMappingURL=walkthrough.routes.js.map