@tonycasey/lisa 2.12.0 → 2.25.2

package/dist/lib/infrastructure/services/SessionCaptureService.js

@@ -8,10 +8,30 @@ const fs_1 = __importDefault(require("fs"));
 const path_1 = __importDefault(require("path"));
 const child_process_1 = require("child_process");
 const domain_1 = require("../../domain");
+const ITaskType_1 = require("../../domain/interfaces/types/ITaskType");
 /**
  * Minimum messages required for capture.
  */
 const MIN_MESSAGES_FOR_CAPTURE = 3;
+/**
+ * Maximum heuristic detection caps.
+ */
+const MAX_DECISIONS = 3;
+const MAX_ERRORS = 2;
+const MAX_CORRELATIONS = 3;
+/**
+ * User confirmation patterns for decision detection.
+ */
+const CONFIRMATION_PATTERN = /^(yes|ok|sounds good|let'?s go with|do that|go ahead|approved?|agreed?)\b/i;
+/**
+ * Assistant option-presenting language for decision context.
+ */
+const OPTION_PRESENTING_PATTERN = /\b(option|approach|alternative|should we|we could|either|or we|recommend|suggest)\b/i;
+/**
+ * Error patterns in message content.
+ */
+const STACK_TRACE_PATTERN = /^\s+at\s+/m;
+const ERROR_TYPE_PATTERN = /\b(Error|TypeError|ReferenceError|SyntaxError|RangeError):\s+/;
 /**
  * Service for capturing session work from Claude Code transcripts.
  *
@@ -19,8 +39,9 @@ const MIN_MESSAGES_FOR_CAPTURE = 3;
  * This is the full implementation that replaces the session-stop-worker.
  */
 class SessionCaptureService {
-    constructor(logger) {
+    constructor(logger, transcriptEnricher) {
         this.logger = logger;
+        this.transcriptEnricher = transcriptEnricher;
     }
     /**
      * Capture work from the current session.
@@ -51,10 +72,36 @@ class SessionCaptureService {
             // 4. Build facts from work summary
             const facts = this.buildFacts(work, sessionId);
             const complexity = this.rateComplexity(work);
+            // 5. Optionally enrich with LLM extraction
+            let enrichedFacts = [];
+            let enrichedSummary;
+            if (this.transcriptEnricher) {
+                try {
+                    const snippet = this.getTranscriptSnippet(foundPath);
+                    const enrichment = await this.transcriptEnricher.enrich(work, snippet);
+                    if (enrichment.facts.length > 0) {
+                        enrichedFacts = enrichment.facts.map(f => {
+                            // Filter out any pre-existing metadata tags before appending canonical ones
+                            const baseTags = f.tags.filter(t => !t.startsWith('type:') && !t.startsWith('confidence:') && !t.startsWith('source:'));
+                            const tags = [...baseTags, `type:${f.type}`, `confidence:${f.confidence}`, 'source:llm-extracted'];
+                            return `${f.text} [${tags.join(', ')}]`;
+                        });
+                    }
+                    if (enrichment.summary && enrichment.summary.length > 0) {
+                        enrichedSummary = enrichment.summary;
+                    }
+                }
+                catch (error) {
+                    this.logger?.warn('LLM enrichment failed, using pattern-based extraction only', {
+                        error: error instanceof Error ? error.message : String(error),
+                    });
+                }
+            }
             return {
-                facts,
+                facts: [...facts, ...enrichedFacts],
                 complexity,
-                summary: work.summary || undefined,
+                summary: enrichedSummary ?? work.summary ?? undefined,
+                work,
             };
         }
         catch (error) {
@@ -116,49 +163,58 @@ class SessionCaptureService {
     /**
      * Find all transcript candidates from standard Claude Code locations.
      *
-     * Searches:
-     * - ~/.claude/projects/<project>/transcript.jsonl
-     * - ~/.claude/transcript.jsonl
+     * Claude Code stores session transcripts as UUID-named JSONL files:
+     *   ~/.claude/projects/<project-folder>/<session-uuid>.jsonl
+     *
+     * The project folder is derived from the working directory path with
+     * path separators replaced by dashes (e.g. C:\dev\lisa → C--dev-lisa).
      *
      * @returns Array of candidates with path and modification time
      */
     findTranscriptCandidates() {
         const candidates = [];
         const homeDir = process.env.HOME || process.env.USERPROFILE || '';
-        const possibleDirs = [
-            path_1.default.join(homeDir, '.claude', 'projects'),
-            path_1.default.join(homeDir, '.claude'),
-        ];
-        for (const dir of possibleDirs) {
-            if (!fs_1.default.existsSync(dir))
-                continue;
-            // Check direct transcript in this directory
-            const directPath = path_1.default.join(dir, 'transcript.jsonl');
-            if (fs_1.default.existsSync(directPath)) {
+        const projectsDir = path_1.default.join(homeDir, '.claude', 'projects');
+        // Derive project folder name from CWD
+        // Claude Code convention: C:\dev\lisa → C--dev-lisa
+        const cwd = process.cwd();
+        const projectFolderName = cwd.replace(/[:\\/]/g, '-');
+        const projectDir = path_1.default.join(projectsDir, projectFolderName);
+        // Search UUID-named session transcripts in ~/.claude/projects/
+        if (fs_1.default.existsSync(projectsDir)) {
+            const dirsToSearch = [];
+            if (fs_1.default.existsSync(projectDir)) {
+                dirsToSearch.push(projectDir);
+            }
+            else {
+                // Fallback: scan all project folders if derived name doesn't match
+                this.logger?.debug('Project dir not found, scanning all projects', {
+                    expected: projectFolderName,
+                });
                 try {
-                    const stats = fs_1.default.statSync(directPath);
-                    candidates.push({
-                        path: directPath,
-                        mtime: stats.mtimeMs,
-                    });
+                    const entries = fs_1.default.readdirSync(projectsDir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        if (entry.isDirectory()) {
+                            dirsToSearch.push(path_1.default.join(projectsDir, entry.name));
+                        }
+                    }
                 }
                 catch {
-                    // Skip if can't stat
+                    // Ignore permission errors
                 }
             }
-            // Check subdirectories (project folders)
-            try {
-                const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
-                for (const entry of entries) {
-                    if (entry.isDirectory()) {
-                        const subPath = path_1.default.join(dir, entry.name, 'transcript.jsonl');
-                        if (fs_1.default.existsSync(subPath)) {
+            // UUID pattern: 8-4-4-4-12 hex chars
+            const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}\.jsonl$/i;
+            for (const dir of dirsToSearch) {
+                try {
+                    const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+                    for (const entry of entries) {
+                        // Match UUID-named .jsonl files (session transcripts, not subagent files)
+                        if (entry.isFile() && uuidPattern.test(entry.name)) {
+                            const filePath = path_1.default.join(dir, entry.name);
                             try {
-                                const stats = fs_1.default.statSync(subPath);
-                                candidates.push({
-                                    path: subPath,
-                                    mtime: stats.mtimeMs,
-                                });
+                                const stats = fs_1.default.statSync(filePath);
+                                candidates.push({ path: filePath, mtime: stats.mtimeMs });
                             }
                             catch {
                                 // Skip if can't stat
@@ -166,15 +222,33 @@ class SessionCaptureService {
                         }
                     }
                 }
+                catch {
+                    // Ignore permission errors on directory listing
+                }
             }
-            catch {
-                // Ignore permission errors on directory listing
+        }
+        // Legacy fallback: check for transcript.jsonl (older Claude Code versions)
+        if (candidates.length === 0) {
+            const legacyPaths = [
+                path_1.default.join(projectsDir, projectFolderName, 'transcript.jsonl'),
+                path_1.default.join(homeDir, '.claude', 'transcript.jsonl'),
+            ];
+            for (const legacyPath of legacyPaths) {
+                if (fs_1.default.existsSync(legacyPath)) {
+                    try {
+                        const stats = fs_1.default.statSync(legacyPath);
+                        candidates.push({ path: legacyPath, mtime: stats.mtimeMs });
+                    }
+                    catch {
+                        // Skip if can't stat
+                    }
+                }
             }
         }
         return candidates;
     }
     /**
-     * Parse transcript file to extract work summary.
+     * Parse transcript file to extract work summary including heuristic detections.
      */
     parseTranscript(transcriptPath) {
         const content = fs_1.default.readFileSync(transcriptPath, 'utf8');
@@ -185,29 +259,38 @@ class SessionCaptureService {
         const filesCreated = [];
         const filesModified = [];
         let summaryText = '';
+        const parsedMessages = [];
         for (const line of lines) {
             try {
                 const msg = JSON.parse(line);
                 // Track message types
                 if (msg.type === 'user' || msg.message?.role === 'user') {
                     userPrompts++;
+                    const text = this.extractMessageText(msg);
+                    parsedMessages.push({ role: 'user', text });
                 }
                 else if (msg.type === 'assistant' || msg.message?.role === 'assistant') {
                     assistantResponses++;
+                    const text = this.extractMessageText(msg);
+                    parsedMessages.push({ role: 'assistant', text });
                     // Extract summary from last assistant message
-                    const content = msg.message?.content;
-                    if (typeof content === 'string') {
-                        summaryText = content.slice(0, 500);
-                    }
-                    else if (Array.isArray(content)) {
-                        const textBlock = content.find(c => c.type === 'text');
-                        if (textBlock?.text) {
-                            summaryText = textBlock.text.slice(0, 500);
-                        }
+                    if (text) {
+                        summaryText = text.slice(0, 500);
                     }
                 }
-                else if (msg.type === 'tool_use' || msg.type === 'tool_result') {
+                else if (msg.type === 'tool_use') {
+                    toolCalls++;
+                    const toolName = this.extractToolName(msg);
+                    parsedMessages.push({ role: 'tool_use', text: '', toolName });
+                }
+                else if (msg.type === 'tool_result') {
                     toolCalls++;
+                    const isError = this.extractToolError(msg);
+                    const text = this.extractMessageText(msg);
+                    parsedMessages.push({ role: 'tool_result', text, isError });
+                }
+                else {
+                    parsedMessages.push({ role: 'other', text: '' });
                 }
                 // Track file operations from summary
                 if (msg.summary) {
@@ -225,17 +308,29 @@ class SessionCaptureService {
             }
             catch {
                 // Skip malformed lines
+                parsedMessages.push({ role: 'other', text: '' });
             }
         }
+        const uniqueFilesCreated = [...new Set(filesCreated)];
+        const uniqueFilesModified = [...new Set(filesModified)];
+        // Run heuristic detectors
+        const detectedDecisions = this.detectDecisions(parsedMessages);
+        const detectedErrors = this.detectErrors(parsedMessages);
+        const filePromptCorrelations = this.correlateFilePrompts(parsedMessages, uniqueFilesCreated, uniqueFilesModified);
+        const detectedTaskType = this.detectTaskType(parsedMessages);
         return {
             messageCount: lines.length,
             userPrompts,
             assistantResponses,
             toolCalls,
-            filesCreated: [...new Set(filesCreated)],
-            filesModified: [...new Set(filesModified)],
-            duration: 0, // TODO: Could calculate from timestamps
+            filesCreated: uniqueFilesCreated,
+            filesModified: uniqueFilesModified,
+            duration: 0,
             summary: summaryText,
+            detectedDecisions: detectedDecisions.length > 0 ? detectedDecisions : undefined,
+            detectedErrors: detectedErrors.length > 0 ? detectedErrors : undefined,
+            filePromptCorrelations: filePromptCorrelations.length > 0 ? filePromptCorrelations : undefined,
+            detectedTaskType,
         };
     }
     /**
@@ -262,7 +357,7 @@ class SessionCaptureService {
         return work.messageCount >= 5;
     }
     /**
-     * Build facts from work summary.
+     * Build facts from work summary including heuristic-detected facts.
      */
     buildFacts(work, sessionId) {
         const facts = [];
@@ -292,6 +387,24 @@ class SessionCaptureService {
                 facts.push(`Session summary${sessionTag}: ${shortSummary}...`);
             }
         }
+        // Add heuristic-detected decision facts
+        if (work.detectedDecisions) {
+            for (const decision of work.detectedDecisions) {
+                facts.push(`DECISION: ${decision.text} [source:session-capture, confidence:medium, type:decision]`);
+            }
+        }
+        // Add heuristic-detected error facts
+        if (work.detectedErrors) {
+            for (const error of work.detectedErrors) {
+                facts.push(`ERROR: ${error.text} [source:session-capture, confidence:medium, type:error]`);
+            }
+        }
+        // Add file-prompt correlation facts
+        if (work.filePromptCorrelations) {
+            for (const corr of work.filePromptCorrelations) {
+                facts.push(`FILE-CONTEXT: ${corr.filePath} — triggered by: ${corr.triggerSnippet} [source:session-capture, confidence:medium, type:correlation, file:${corr.filePath}]`);
+            }
+        }
         return facts;
     }
     /**
@@ -309,6 +422,316 @@ class SessionCaptureService {
         }
         return 'low';
     }
+    // ============================================================
+    // Heuristic Detection Methods
+    // ============================================================
+    /**
+     * Detect user decisions from confirmation patterns.
+     *
+     * Scans for user messages matching confirmation patterns (yes, ok, sounds good, etc.)
+     * preceded by assistant messages that present options or recommendations.
+     */
+    detectDecisions(messages) {
+        const decisions = [];
+        for (let i = 0; i < messages.length; i++) {
+            if (decisions.length >= MAX_DECISIONS)
+                break;
+            const msg = messages[i];
+            if (msg.role !== 'user')
+                continue;
+            if (!CONFIRMATION_PATTERN.test(msg.text.trim()))
+                continue;
+            // Look backward within 3 messages for an assistant message with options
+            for (let j = i - 1; j >= Math.max(0, i - 3); j--) {
+                const prev = messages[j];
+                if (prev.role !== 'assistant')
+                    continue;
+                if (!OPTION_PRESENTING_PATTERN.test(prev.text))
+                    continue;
+                // Extract decision topic from the assistant's message (first sentence or first 120 chars)
+                const topic = this.extractDecisionTopic(prev.text);
+                if (topic) {
+                    decisions.push({
+                        text: topic,
+                        userMessage: msg.text.slice(0, 100),
+                        confidence: 0.6,
+                    });
+                }
+                break;
+            }
+        }
+        return decisions;
+    }
+    /**
+     * Detect errors from stack traces, error types, tool failures, and retry patterns.
+     */
+    detectErrors(messages) {
+        const errors = [];
+        // 1. Detect stack traces and Error: patterns in message content
+        for (const msg of messages) {
+            if (errors.length >= MAX_ERRORS)
+                break;
+            if (!msg.text)
+                continue;
+            if (STACK_TRACE_PATTERN.test(msg.text)) {
+                const errorLine = this.extractErrorLine(msg.text);
+                if (errorLine) {
+                    errors.push({
+                        text: errorLine,
+                        errorType: 'stack-trace',
+                        context: msg.text.slice(0, 200),
+                    });
+                }
+            }
+            else if (ERROR_TYPE_PATTERN.test(msg.text)) {
+                const match = msg.text.match(ERROR_TYPE_PATTERN);
+                if (match) {
+                    const matchIndex = msg.text.indexOf(match[0]);
+                    const errorText = msg.text.slice(matchIndex, matchIndex + 150).split('\n')[0];
+                    errors.push({
+                        text: errorText.trim(),
+                        errorType: 'stack-trace',
+                    });
+                }
+            }
+        }
+        // 2. Detect tool failures
+        if (errors.length < MAX_ERRORS) {
+            for (const msg of messages) {
+                if (errors.length >= MAX_ERRORS)
+                    break;
+                if (msg.role === 'tool_result' && msg.isError) {
+                    errors.push({
+                        text: `Tool failure: ${msg.text.slice(0, 100)}`,
+                        errorType: 'tool-failure',
+                    });
+                }
+            }
+        }
+        // 3. Detect retry patterns (same tool_use name >2 times in sequence)
+        if (errors.length < MAX_ERRORS) {
+            let consecutiveCount = 0;
+            let lastToolName = '';
+            for (const msg of messages) {
+                if (msg.role === 'tool_use' && msg.toolName) {
+                    if (msg.toolName === lastToolName) {
+                        consecutiveCount++;
+                    }
+                    else {
+                        consecutiveCount = 1;
+                        lastToolName = msg.toolName;
+                    }
+                    if (consecutiveCount > 2 && errors.length < MAX_ERRORS) {
+                        errors.push({
+                            text: `Retry pattern detected: tool "${lastToolName}" called ${consecutiveCount}+ times consecutively`,
+                            errorType: 'retry-pattern',
+                        });
+                        break;
+                    }
+                }
+                else if (msg.role !== 'tool_result') {
+                    // Reset on non-tool messages (but tool_result follows tool_use so skip that)
+                    consecutiveCount = 0;
+                    lastToolName = '';
+                }
+            }
+        }
+        return errors;
+    }
+    /**
+     * Correlate file changes with preceding user prompts.
+     *
+     * For each changed file, find preceding user prompt (within 3-message window)
+     * whose text mentions the file name or related keywords.
+     */
+    correlateFilePrompts(messages, filesCreated, filesModified) {
+        const correlations = [];
+        const allFiles = [...filesCreated, ...filesModified];
+        const matchedFiles = new Set();
+        // Find assistant messages that mention each file (tool responses),
+        // then search backward within 3-message window for the triggering user prompt.
+        const MESSAGE_WINDOW = 3;
+        for (const filePath of allFiles) {
+            if (correlations.length >= MAX_CORRELATIONS)
+                break;
+            if (matchedFiles.has(filePath))
+                continue;
+            const fileName = path_1.default.basename(filePath);
+            const fileNameNoExt = fileName.replace(/\.[^.]+$/, '');
+            const fileNameLower = fileName.toLowerCase();
+            const fileNameNoExtLower = fileNameNoExt.toLowerCase();
+            const hasStem = fileNameNoExtLower.length > 0;
+            // Find the last assistant message mentioning this file (tool response)
+            let fileMessageIndex = -1;
+            for (let i = messages.length - 1; i >= 0; i--) {
+                if (messages[i].role === 'assistant' && messages[i].text) {
+                    const textLower = messages[i].text.toLowerCase();
+                    if (textLower.includes(fileNameLower) || (hasStem && textLower.includes(fileNameNoExtLower))) {
+                        fileMessageIndex = i;
+                        break;
+                    }
+                }
+            }
+            // Search backward from file message within 3-message window for user prompt
+            const searchStart = fileMessageIndex >= 0 ? fileMessageIndex : messages.length - 1;
+            let messagesChecked = 0;
+            for (let j = searchStart; j >= 0 && messagesChecked < MESSAGE_WINDOW; j--) {
+                messagesChecked++;
+                if (messages[j].role !== 'user' || !messages[j].text)
+                    continue;
+                const textLower = messages[j].text.toLowerCase();
+                if (textLower.includes(fileNameLower) || (hasStem && textLower.includes(fileNameNoExtLower))) {
+                    correlations.push({
+                        filePath,
+                        triggerSnippet: messages[j].text.slice(0, 100),
+                    });
+                    matchedFiles.add(filePath);
+                    break;
+                }
+            }
+        }
+        return correlations;
+    }
+    /**
+     * Detect the dominant task type from user prompts using DETECTION_SIGNALS.
+     */
+    detectTaskType(messages) {
+        const scores = Object.keys(ITaskType_1.DETECTION_SIGNALS).reduce((acc, key) => ({ ...acc, [key]: 0 }), {});
+        for (const msg of messages) {
+            if (msg.role !== 'user' || !msg.text)
+                continue;
+            const textLower = msg.text.toLowerCase();
+            for (const [taskType, signals] of Object.entries(ITaskType_1.DETECTION_SIGNALS)) {
+                for (const signal of signals) {
+                    if (textLower.includes(signal.toLowerCase())) {
+                        scores[taskType]++;
+                    }
+                }
+            }
+        }
+        // Find dominant type
+        let maxScore = 0;
+        let dominant;
+        for (const [taskType, score] of Object.entries(scores)) {
+            if (score > maxScore) {
+                maxScore = score;
+                dominant = taskType;
+            }
+        }
+        // Only return if there's a meaningful signal
+        return maxScore > 0 ? dominant : undefined;
+    }
+    // ============================================================
+    // Helper Methods
+    // ============================================================
+    /**
+     * Extract text content from a transcript message.
+     */
+    extractMessageText(msg) {
+        const content = msg.message?.content;
+        if (typeof content === 'string') {
+            return content;
+        }
+        if (Array.isArray(content)) {
+            const textBlocks = content
+                .map(block => block.text)
+                .filter((text) => typeof text === 'string' && text.length > 0);
+            if (textBlocks.length > 0) {
+                return textBlocks.join('\n');
+            }
+        }
+        return '';
+    }
+    /**
+     * Extract tool name from a transcript message.
+     */
+    extractToolName(msg) {
+        const content = msg.message?.content;
+        if (Array.isArray(content)) {
+            const toolBlock = content.find(c => c.name);
+            if (toolBlock?.name)
+                return toolBlock.name;
+        }
+        return undefined;
+    }
+    /**
+     * Check if a tool_result message indicates an error.
+     */
+    extractToolError(msg) {
+        const content = msg.message?.content;
+        if (Array.isArray(content)) {
+            return content.some(c => c.is_error === true);
+        }
+        return false;
+    }
+    /**
+     * Extract the first Error: line from text containing a stack trace.
+     */
+    extractErrorLine(text) {
+        const lines = text.split('\n');
+        for (const line of lines) {
+            if (ERROR_TYPE_PATTERN.test(line)) {
+                return line.trim().slice(0, 150);
+            }
+        }
+        // Fallback: use first line
+        return lines[0] ? lines[0].trim().slice(0, 150) : null;
+    }
+    /**
+     * Extract a decision topic from an assistant's message.
+     * Takes the first sentence or first 120 characters.
+     */
+    extractDecisionTopic(text) {
+        if (!text)
+            return null;
+        // Try to get first sentence
+        const sentenceMatch = text.match(/^[^.!?]+[.!?]/);
+        if (sentenceMatch && sentenceMatch[0].length <= 120) {
+            return sentenceMatch[0].trim();
+        }
+        // Fallback: first 120 chars
+        return text.slice(0, 120).trim();
+    }
+    /**
+     * Extract a snippet of conversation text from the transcript for LLM analysis.
+     * Concatenates user and assistant text content, truncated to a reasonable length.
+     */
+    getTranscriptSnippet(transcriptPath, maxLength = 4000) {
+        const content = fs_1.default.readFileSync(transcriptPath, 'utf8');
+        const lines = content.trim().split('\n').filter(line => line.trim());
+        const parts = [];
+        let totalLength = 0;
+        for (const line of lines) {
+            try {
+                const msg = JSON.parse(line);
+                const role = msg.message?.role ?? msg.type;
+                if (role === 'user' || role === 'assistant') {
+                    const msgContent = msg.message?.content;
+                    let text = '';
+                    if (typeof msgContent === 'string') {
+                        text = msgContent;
+                    }
+                    else if (Array.isArray(msgContent)) {
+                        const textBlock = msgContent.find(c => c.type === 'text');
+                        if (textBlock?.text) {
+                            text = textBlock.text;
+                        }
+                    }
+                    if (text) {
+                        const part = `[${role}] ${text.slice(0, 500)}`;
+                        parts.push(part);
+                        totalLength += part.length;
+                    }
+                }
+            }
+            catch {
+                // Skip malformed lines
+            }
+            if (totalLength >= maxLength)
+                break;
+        }
+        return parts.join('\n\n').slice(0, maxLength);
+    }
     /**
      * Detect repository name from git.
      */