grov 0.1.0

package/dist/lib/llm-extractor.js

@@ -0,0 +1,408 @@
+// LLM-based extraction using OpenAI GPT-3.5-turbo for reasoning summaries
+// and Anthropic Claude Haiku for drift detection
+import OpenAI from 'openai';
+import Anthropic from '@anthropic-ai/sdk';
+import { debugLLM } from './debug.js';
+import { truncate } from './utils.js';
+let client = null;
+let anthropicClient = null;
+/**
+ * Initialize the OpenAI client
+ */
+function getClient() {
+    if (!client) {
+        const apiKey = process.env.OPENAI_API_KEY;
+        if (!apiKey) {
+            // SECURITY: Generic error to avoid confirming API key mechanism exists
+            throw new Error('LLM extraction unavailable');
+        }
+        client = new OpenAI({ apiKey });
+    }
+    return client;
+}
+/**
+ * Initialize the Anthropic client
+ */
+function getAnthropicClient() {
+    if (!anthropicClient) {
+        const apiKey = process.env.ANTHROPIC_API_KEY;
+        if (!apiKey) {
+            throw new Error('ANTHROPIC_API_KEY environment variable is required for drift detection');
+        }
+        anthropicClient = new Anthropic({ apiKey });
+    }
+    return anthropicClient;
+}
+/**
+ * Check if LLM extraction is available (OpenAI API key set)
+ */
+export function isLLMAvailable() {
+    return !!process.env.OPENAI_API_KEY;
+}
+/**
+ * Check if Anthropic API is available (for drift detection)
+ */
+export function isAnthropicAvailable() {
+    return !!process.env.ANTHROPIC_API_KEY;
+}
+/**
+ * Get the drift model to use (from env or default)
+ */
+export function getDriftModel() {
+    return process.env.GROV_DRIFT_MODEL || 'claude-haiku-4-5';
+}
+/**
+ * Extract structured reasoning from a parsed session using GPT-3.5-turbo
+ */
+export async function extractReasoning(session) {
+    const openai = getClient();
+    // Build session summary for the prompt
+    const sessionSummary = buildSessionSummary(session);
+    const response = await openai.chat.completions.create({
+        model: 'gpt-3.5-turbo',
+        max_tokens: 1024,
+        messages: [
+            {
+                role: 'system',
+                content: 'You are a helpful assistant that extracts structured information from coding sessions. Always respond with valid JSON only, no explanation.'
+            },
+            {
+                role: 'user',
+                content: `Analyze this Claude Code session and extract a structured reasoning summary.
+
+SESSION DATA:
+${sessionSummary}
+
+Extract the following as JSON:
+{
+  "task": "Brief description of what the user was trying to do (1 sentence)",
+  "goal": "The underlying goal or problem being solved",
+  "reasoning_trace": ["Key reasoning steps taken", "Decisions made and why", "What was investigated"],
+  "decisions": [{"choice": "What was decided", "reason": "Why this choice was made"}],
+  "constraints": ["Any constraints or requirements discovered"],
+  "status": "complete|partial|question|abandoned",
+  "tags": ["relevant", "domain", "tags"]
+}
+
+Status definitions:
+- "complete": Task was finished, implementation done
+- "partial": Work started but not finished
+- "question": Claude asked a question and is waiting for user response
+- "abandoned": User interrupted or moved to different topic
+
+Return ONLY valid JSON, no explanation.`
+            }
+        ]
+    });
+    // Parse the response
+    const content = response.choices[0]?.message?.content;
+    if (!content) {
+        throw new Error('No response from OpenAI');
+    }
+    try {
+        // SECURITY: Parse to plain object first, then sanitize prototype pollution
+        const rawParsed = JSON.parse(content);
+        // SECURITY: Prevent prototype pollution from LLM-generated JSON
+        // An attacker could manipulate LLM to return {"__proto__": {"isAdmin": true}}
+        const pollutionKeys = ['__proto__', 'constructor', 'prototype'];
+        for (const key of pollutionKeys) {
+            if (key in rawParsed) {
+                delete rawParsed[key];
+            }
+        }
+        const extracted = rawParsed;
+        // SECURITY: Validate types to prevent LLM injection attacks
+        const safeTask = typeof extracted.task === 'string' ? extracted.task : '';
+        const safeGoal = typeof extracted.goal === 'string' ? extracted.goal : '';
+        const safeTrace = Array.isArray(extracted.reasoning_trace)
+            ? extracted.reasoning_trace.filter((t) => typeof t === 'string')
+            : [];
+        const safeDecisions = Array.isArray(extracted.decisions)
+            ? extracted.decisions.filter((d) => d && typeof d === 'object' && typeof d.choice === 'string' && typeof d.reason === 'string')
+            : [];
+        const safeConstraints = Array.isArray(extracted.constraints)
+            ? extracted.constraints.filter((c) => typeof c === 'string')
+            : [];
+        const safeTags = Array.isArray(extracted.tags)
+            ? extracted.tags.filter((t) => typeof t === 'string')
+            : [];
+        // Fill defaults with validated values
+        return {
+            task: safeTask || session.userMessages[0]?.substring(0, 100) || 'Unknown task',
+            goal: safeGoal || safeTask || 'Unknown goal',
+            reasoning_trace: safeTrace,
+            files_touched: session.filesRead.concat(session.filesWritten),
+            decisions: safeDecisions,
+            constraints: safeConstraints,
+            status: validateStatus(extracted.status),
+            tags: safeTags
+        };
+    }
+    catch (parseError) {
+        // If JSON parsing fails, return basic extraction
+        debugLLM('Failed to parse LLM response, using fallback');
+        return createFallbackExtraction(session);
+    }
+}
+/**
+ * Classify just the task status (lighter weight than full extraction)
+ */
+export async function classifyTaskStatus(session) {
+    const openai = getClient();
+    // Get last few exchanges for classification
+    const lastMessages = session.userMessages.slice(-2).join('\n---\n');
+    const lastAssistant = session.assistantMessages.slice(-1)[0] || '';
+    const response = await openai.chat.completions.create({
+        model: 'gpt-3.5-turbo',
+        max_tokens: 50,
+        messages: [
+            {
+                role: 'system',
+                content: 'Classify conversation state. Return ONLY one word: complete, partial, question, or abandoned.'
+            },
+            {
+                role: 'user',
+                content: `Last user message(s):
+${lastMessages}
+
+Last assistant response (truncated):
+${lastAssistant.substring(0, 500)}
+
+Files written: ${session.filesWritten.length}
+Files read: ${session.filesRead.length}
+
+Classification:`
+            }
+        ]
+    });
+    const content = response.choices[0]?.message?.content;
+    if (!content) {
+        return 'partial';
+    }
+    return validateStatus(content.trim().toLowerCase());
+}
+/**
+ * Build a summary of the session for the LLM prompt
+ */
+function buildSessionSummary(session) {
+    const lines = [];
+    // User messages
+    lines.push('USER MESSAGES:');
+    session.userMessages.forEach((msg, i) => {
+        lines.push(`[${i + 1}] ${truncate(msg, 300)}`);
+    });
+    lines.push('');
+    // Files touched
+    lines.push('FILES READ:');
+    session.filesRead.slice(0, 10).forEach(f => lines.push(`  - ${f}`));
+    if (session.filesRead.length > 10) {
+        lines.push(`  ... and ${session.filesRead.length - 10} more`);
+    }
+    lines.push('');
+    lines.push('FILES WRITTEN/EDITED:');
+    session.filesWritten.forEach(f => lines.push(`  - ${f}`));
+    lines.push('');
+    // Tool usage summary
+    lines.push('TOOL USAGE:');
+    const toolCounts = session.toolCalls.reduce((acc, t) => {
+        acc[t.name] = (acc[t.name] || 0) + 1;
+        return acc;
+    }, {});
+    Object.entries(toolCounts).forEach(([name, count]) => {
+        lines.push(`  - ${name}: ${count}x`);
+    });
+    lines.push('');
+    // Last assistant message (often contains summary/conclusion)
+    const lastAssistant = session.assistantMessages[session.assistantMessages.length - 1];
+    if (lastAssistant) {
+        lines.push('LAST ASSISTANT MESSAGE:');
+        lines.push(truncate(lastAssistant, 500));
+    }
+    return lines.join('\n');
+}
+/**
+ * Create fallback extraction when LLM fails
+ */
+function createFallbackExtraction(session) {
+    const filesTouched = [...new Set([...session.filesRead, ...session.filesWritten])];
+    return {
+        task: session.userMessages[0]?.substring(0, 100) || 'Unknown task',
+        goal: session.userMessages[0]?.substring(0, 100) || 'Unknown goal',
+        reasoning_trace: generateBasicTrace(session),
+        files_touched: filesTouched,
+        decisions: [],
+        constraints: [],
+        status: session.filesWritten.length > 0 ? 'complete' : 'partial',
+        tags: generateTagsFromFiles(filesTouched)
+    };
+}
+/**
+ * Generate basic reasoning trace from tool usage
+ */
+function generateBasicTrace(session) {
+    const trace = [];
+    const toolCounts = session.toolCalls.reduce((acc, t) => {
+        acc[t.name] = (acc[t.name] || 0) + 1;
+        return acc;
+    }, {});
+    if (toolCounts['Read'])
+        trace.push(`Read ${toolCounts['Read']} files`);
+    if (toolCounts['Write'])
+        trace.push(`Wrote ${toolCounts['Write']} files`);
+    if (toolCounts['Edit'])
+        trace.push(`Edited ${toolCounts['Edit']} files`);
+    if (toolCounts['Grep'] || toolCounts['Glob'])
+        trace.push('Searched codebase');
+    if (toolCounts['Bash'])
+        trace.push(`Ran ${toolCounts['Bash']} commands`);
+    return trace;
+}
+/**
+ * Generate tags from file paths
+ */
+function generateTagsFromFiles(files) {
+    const tags = new Set();
+    for (const file of files) {
+        const parts = file.split('/');
+        for (const part of parts) {
+            if (part && !part.includes('.') && part !== 'src' && part !== 'lib') {
+                tags.add(part.toLowerCase());
+            }
+        }
+        // Common patterns
+        if (file.includes('auth'))
+            tags.add('auth');
+        if (file.includes('api'))
+            tags.add('api');
+        if (file.includes('test'))
+            tags.add('test');
+    }
+    return [...tags].slice(0, 10);
+}
+/**
+ * Validate and normalize status
+ */
+function validateStatus(status) {
+    const normalized = status?.toLowerCase().trim();
+    if (normalized === 'complete' || normalized === 'partial' ||
+        normalized === 'question' || normalized === 'abandoned') {
+        return normalized;
+    }
+    return 'partial'; // Default
+}
+/**
+ * Extract intent from a prompt using Claude Haiku
+ * Falls back to basic extraction if API unavailable
+ */
+export async function extractIntent(prompt) {
+    // Try LLM extraction if available
+    if (isAnthropicAvailable()) {
+        try {
+            return await extractIntentWithLLM(prompt);
+        }
+        catch (error) {
+            debugLLM('extractIntent LLM failed, using fallback: %O', error);
+            return extractIntentBasic(prompt);
+        }
+    }
+    // Fallback to basic extraction
+    return extractIntentBasic(prompt);
+}
+/**
+ * Extract intent using Claude Haiku
+ */
+async function extractIntentWithLLM(prompt) {
+    const anthropic = getAnthropicClient();
+    const model = getDriftModel();
+    const response = await anthropic.messages.create({
+        model,
+        max_tokens: 1024,
+        messages: [
+            {
+                role: 'user',
+                content: `Analyze this user prompt and extract the task intent. Return ONLY valid JSON, no explanation.
+
+USER PROMPT:
+${prompt}
+
+Extract as JSON:
+{
+  "goal": "The main objective the user wants to achieve (1 sentence)",
+  "expected_scope": ["List of files, directories, or components that should be touched"],
+  "constraints": ["Any constraints or requirements mentioned"],
+  "success_criteria": ["How to know when the task is complete"],
+  "keywords": ["Important technical terms from the prompt"]
+}
+
+Return ONLY valid JSON.`
+            }
+        ]
+    });
+    // Extract text content from response
+    const content = response.content[0];
+    if (content.type !== 'text') {
+        throw new Error('Unexpected response type from Anthropic');
+    }
+    const parsed = JSON.parse(content.text);
+    return {
+        goal: parsed.goal || prompt.substring(0, 100),
+        expected_scope: parsed.expected_scope || [],
+        constraints: parsed.constraints || [],
+        success_criteria: parsed.success_criteria || [],
+        keywords: parsed.keywords || extractKeywordsBasic(prompt)
+    };
+}
+/**
+ * Basic intent extraction without LLM
+ */
+function extractIntentBasic(prompt) {
+    return {
+        goal: prompt.substring(0, 200),
+        expected_scope: extractFilesFromPrompt(prompt),
+        constraints: [],
+        success_criteria: [],
+        keywords: extractKeywordsBasic(prompt)
+    };
+}
+/**
+ * Extract file paths from prompt text
+ */
+function extractFilesFromPrompt(prompt) {
+    const patterns = [
+        /(?:^|\s)(\/[\w\-\.\/]+\.\w+)/g,
+        /(?:^|\s)(\.\/[\w\-\.\/]+\.\w+)/g,
+        /(?:^|\s)([\w\-]+\/[\w\-\.\/]+\.\w+)/g,
+        /(?:^|\s|['"`])([\w\-]+\.\w{1,5})(?:\s|$|,|:|['"`])/g,
+    ];
+    const files = new Set();
+    for (const pattern of patterns) {
+        const matches = prompt.matchAll(pattern);
+        for (const match of matches) {
+            const file = match[1].trim();
+            if (file && !file.match(/^(http|https|ftp|mailto)/) && !file.match(/^\d+\.\d+/)) {
+                files.add(file);
+            }
+        }
+    }
+    return [...files];
+}
+/**
+ * Extract keywords from prompt (basic)
+ */
+function extractKeywordsBasic(prompt) {
+    const stopWords = new Set([
+        'the', 'a', 'an', 'is', 'are', 'was', 'were', 'be', 'been',
+        'to', 'for', 'and', 'or', 'in', 'on', 'at', 'of', 'with',
+        'this', 'that', 'it', 'i', 'you', 'we', 'they', 'my', 'your',
+        'can', 'could', 'would', 'should', 'will', 'do', 'does', 'did',
+        'have', 'has', 'had', 'not', 'but', 'if', 'then', 'when', 'where',
+        'how', 'what', 'why', 'which', 'who', 'all', 'some', 'any', 'no',
+        'from', 'by', 'as', 'so', 'too', 'also', 'just', 'only', 'now',
+        'please', 'help', 'me', 'make', 'get', 'add', 'fix', 'update', 'change'
+    ]);
+    const words = prompt.toLowerCase()
+        .replace(/[^\w\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !stopWords.has(w));
+    return [...new Set(words)].slice(0, 15);
+}

package/dist/lib/session-parser.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Claude's action extracted from session JSONL
+ */
+export interface ClaudeAction {
+    type: 'edit' | 'write' | 'bash' | 'read' | 'delete' | 'grep' | 'glob' | 'multiedit';
+    files: string[];
+    command?: string;
+    timestamp: number;
+}
+/**
+ * Find session JSONL path from session_id and project path.
+ *
+ * Claude Code stores sessions in:
+ *   ~/.claude/projects/<encoded-path>/<session_id>.jsonl
+ *
+ * The encoded path uses a specific encoding (not standard URL encoding).
+ */
+export declare function findSessionFile(sessionId: string, projectPath: string): string | null;
+/**
+ * Parse JSONL and extract ALL Claude's tool calls
+ */
+export declare function parseSessionActions(sessionPath: string): ClaudeAction[];
+/**
+ * Get only NEW actions since last check timestamp.
+ * This is the main function used by prompt-inject.
+ */
+export declare function getNewActions(sessionPath: string, lastCheckedTimestamp: number): ClaudeAction[];
+/**
+ * Get actions that MODIFY files (not reads).
+ * Use this for drift detection - reads are exploration, not drift.
+ */
+export declare function getModifyingActions(actions: ClaudeAction[]): ClaudeAction[];
+/**
+ * Extract all unique files touched by actions
+ */
+export declare function extractFilesFromActions(actions: ClaudeAction[]): string[];
+/**
+ * Extract unique folders from actions
+ */
+export declare function extractFoldersFromActions(actions: ClaudeAction[]): string[];
+/**
+ * Extract keywords from an action (for step storage)
+ */
+export declare function extractKeywordsFromAction(action: ClaudeAction): string[];