grov 0.1.0

package/dist/lib/session-parser.js

@@ -0,0 +1,256 @@
+// Session JSONL parser for anti-drift system
+// Parses Claude Code session files to extract Claude's ACTIONS (tool calls)
+//
+// CRITICAL: We monitor Claude's ACTIONS, NOT user prompts.
+// User can explore freely. We check what CLAUDE DOES.
+import { existsSync, readFileSync, readdirSync } from 'fs';
+import { homedir } from 'os';
+import { join, dirname } from 'path';
+import { debugInject } from './debug.js';
+// ============================================
+// MAIN FUNCTIONS
+// ============================================
+/**
+ * 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 function findSessionFile(sessionId, projectPath) {
+    const claudeProjectsDir = join(homedir(), '.claude', 'projects');
+    if (!existsSync(claudeProjectsDir)) {
+        debugInject('Claude projects dir not found: %s', claudeProjectsDir);
+        return null;
+    }
+    // Try to find the project folder
+    // Claude Code uses a specific encoding for the path
+    // We'll search for folders that might contain our session
+    const projectFolders = readdirSync(claudeProjectsDir, { withFileTypes: true })
+        .filter(d => d.isDirectory())
+        .map(d => d.name);
+    // First, try URL-encoded path
+    const urlEncoded = encodeURIComponent(projectPath);
+    if (projectFolders.includes(urlEncoded)) {
+        const sessionPath = join(claudeProjectsDir, urlEncoded, `${sessionId}.jsonl`);
+        if (existsSync(sessionPath)) {
+            debugInject('Found session via URL encoding: %s', sessionPath);
+            return sessionPath;
+        }
+    }
+    // Try custom Claude encoding (%2F for /, etc.)
+    const customEncoded = projectPath
+        .replace(/\//g, '%2F')
+        .replace(/:/g, '%3A');
+    if (projectFolders.includes(customEncoded)) {
+        const sessionPath = join(claudeProjectsDir, customEncoded, `${sessionId}.jsonl`);
+        if (existsSync(sessionPath)) {
+            debugInject('Found session via custom encoding: %s', sessionPath);
+            return sessionPath;
+        }
+    }
+    // Search in all project folders for the session
+    for (const folder of projectFolders) {
+        const sessionPath = join(claudeProjectsDir, folder, `${sessionId}.jsonl`);
+        if (existsSync(sessionPath)) {
+            debugInject('Found session by scanning: %s', sessionPath);
+            return sessionPath;
+        }
+    }
+    debugInject('Session file not found for: %s in %s', sessionId, projectPath);
+    return null;
+}
+/**
+ * Parse JSONL and extract ALL Claude's tool calls
+ */
+export function parseSessionActions(sessionPath) {
+    if (!existsSync(sessionPath)) {
+        debugInject('Session file does not exist: %s', sessionPath);
+        return [];
+    }
+    const content = readFileSync(sessionPath, 'utf-8');
+    const lines = content.trim().split('\n').filter(Boolean);
+    const actions = [];
+    for (const line of lines) {
+        try {
+            const entry = JSON.parse(line);
+            // Only process assistant messages (Claude's responses)
+            if (entry.type !== 'assistant')
+                continue;
+            const timestamp = new Date(entry.timestamp).getTime();
+            // Extract tool calls from content array
+            for (const block of entry.message?.content || []) {
+                if (block.type !== 'tool_use')
+                    continue;
+                const action = parseToolCall(block, timestamp);
+                if (action) {
+                    actions.push(action);
+                }
+            }
+        }
+        catch {
+            // Skip malformed lines silently
+            continue;
+        }
+    }
+    debugInject('Parsed %d actions from session', actions.length);
+    return actions;
+}
+/**
+ * Get only NEW actions since last check timestamp.
+ * This is the main function used by prompt-inject.
+ */
+export function getNewActions(sessionPath, lastCheckedTimestamp) {
+    const allActions = parseSessionActions(sessionPath);
+    const newActions = allActions.filter(a => a.timestamp > lastCheckedTimestamp);
+    debugInject('Found %d new actions since %d', newActions.length, lastCheckedTimestamp);
+    return newActions;
+}
+/**
+ * Get actions that MODIFY files (not reads).
+ * Use this for drift detection - reads are exploration, not drift.
+ */
+export function getModifyingActions(actions) {
+    return actions.filter(a => a.type !== 'read' && a.type !== 'grep' && a.type !== 'glob');
+}
+/**
+ * Extract all unique files touched by actions
+ */
+export function extractFilesFromActions(actions) {
+    const files = new Set();
+    for (const action of actions) {
+        for (const file of action.files) {
+            files.add(file);
+        }
+    }
+    return [...files];
+}
+/**
+ * Extract unique folders from actions
+ */
+export function extractFoldersFromActions(actions) {
+    const folders = new Set();
+    for (const action of actions) {
+        for (const file of action.files) {
+            const folder = dirname(file);
+            if (folder && folder !== '.') {
+                folders.add(folder);
+            }
+        }
+    }
+    return [...folders];
+}
+// ============================================
+// HELPERS
+// ============================================
+/**
+ * Parse a single tool call block into ClaudeAction
+ */
+function parseToolCall(block, timestamp) {
+    const name = block.name?.toLowerCase();
+    const input = block.input || {};
+    switch (name) {
+        case 'edit':
+            return {
+                type: 'edit',
+                files: [input.file_path].filter(Boolean),
+                timestamp
+            };
+        case 'multiedit':
+            return {
+                type: 'multiedit',
+                files: [input.file_path].filter(Boolean),
+                timestamp
+            };
+        case 'write':
+            return {
+                type: 'write',
+                files: [input.file_path].filter(Boolean),
+                timestamp
+            };
+        case 'bash':
+            return {
+                type: 'bash',
+                files: extractFilesFromCommand(input.command || ''),
+                command: input.command,
+                timestamp
+            };
+        case 'read':
+            return {
+                type: 'read',
+                files: [input.file_path].filter(Boolean),
+                timestamp
+            };
+        case 'grep':
+            return {
+                type: 'grep',
+                files: [input.path].filter(Boolean),
+                timestamp
+            };
+        case 'glob':
+            return {
+                type: 'glob',
+                files: [input.path].filter(Boolean),
+                timestamp
+            };
+        default:
+            // Ignore other tools (Task, WebFetch, etc.)
+            return null;
+    }
+}
+/**
+ * Extract file paths from a bash command.
+ * Basic extraction - not perfect but catches common patterns.
+ */
+function extractFilesFromCommand(command) {
+    if (!command)
+        return [];
+    const files = [];
+    const patterns = [
+        // Absolute paths: /path/to/file.ts
+        /(?:^|\s)(\/[\w\-\.\/]+\.\w+)/g,
+        // Relative paths with ./: ./src/file.ts
+        /(?:^|\s)(\.\/[\w\-\.\/]+\.\w+)/g,
+        // Relative paths: src/file.ts
+        /(?:^|\s)([\w\-]+\/[\w\-\.\/]+\.\w+)/g,
+    ];
+    for (const pattern of patterns) {
+        for (const match of command.matchAll(pattern)) {
+            const file = match[1];
+            // Filter out common non-files
+            if (file && !file.startsWith('http') && !file.match(/^\d+\.\d+/)) {
+                files.push(file);
+            }
+        }
+    }
+    return [...new Set(files)];
+}
+/**
+ * Extract keywords from an action (for step storage)
+ */
+export function extractKeywordsFromAction(action) {
+    const keywords = [];
+    // Extract from file names
+    for (const file of action.files) {
+        const fileName = file.split('/').pop() || '';
+        const baseName = fileName.replace(/\.\w+$/, '');
+        // Split camelCase and kebab-case
+        const parts = baseName
+            .replace(/([a-z])([A-Z])/g, '$1 $2')
+            .replace(/[-_]/g, ' ')
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(p => p.length > 2);
+        keywords.push(...parts);
+    }
+    // Extract from bash command
+    if (action.command) {
+        const commandParts = action.command
+            .toLowerCase()
+            .split(/\s+/)
+            .filter(p => p.length > 3 && !p.startsWith('-'));
+        keywords.push(...commandParts.slice(0, 5));
+    }
+    return [...new Set(keywords)];
+}

package/dist/lib/store.d.ts

@@ -0,0 +1,248 @@
+import Database from 'better-sqlite3';
+import type { ClaudeAction } from './session-parser.js';
+export type TaskStatus = 'complete' | 'question' | 'partial' | 'abandoned';
+export interface Task {
+    id: string;
+    project_path: string;
+    user?: string;
+    original_query: string;
+    goal?: string;
+    reasoning_trace: string[];
+    files_touched: string[];
+    status: TaskStatus;
+    linked_commit?: string;
+    parent_task_id?: string;
+    turn_number?: number;
+    tags: string[];
+    created_at: string;
+}
+export interface CreateTaskInput {
+    project_path: string;
+    user?: string;
+    original_query: string;
+    goal?: string;
+    reasoning_trace?: string[];
+    files_touched?: string[];
+    status: TaskStatus;
+    linked_commit?: string;
+    parent_task_id?: string;
+    turn_number?: number;
+    tags?: string[];
+}
+export type SessionStatus = 'active' | 'completed' | 'abandoned';
+export interface SessionState {
+    session_id: string;
+    user_id?: string;
+    project_path: string;
+    original_goal?: string;
+    actions_taken: string[];
+    files_explored: string[];
+    current_intent?: string;
+    drift_warnings: string[];
+    start_time: string;
+    last_update: string;
+    status: SessionStatus;
+    expected_scope: string[];
+    constraints: string[];
+    success_criteria: string[];
+    keywords: string[];
+    last_drift_score?: number;
+    escalation_count: number;
+    pending_recovery_plan?: RecoveryPlan;
+    drift_history: DriftEvent[];
+    last_checked_at: number;
+}
+export interface RecoveryPlan {
+    steps: Array<{
+        file?: string;
+        action: string;
+    }>;
+}
+export interface DriftEvent {
+    timestamp: string;
+    score: number;
+    level: string;
+    prompt_summary: string;
+}
+export interface CreateSessionStateInput {
+    session_id: string;
+    user_id?: string;
+    project_path: string;
+    original_goal?: string;
+    expected_scope?: string[];
+    constraints?: string[];
+    success_criteria?: string[];
+    keywords?: string[];
+}
+export type ChangeType = 'read' | 'write' | 'edit' | 'create' | 'delete';
+export interface FileReasoning {
+    id: string;
+    task_id?: string;
+    file_path: string;
+    anchor?: string;
+    line_start?: number;
+    line_end?: number;
+    code_hash?: string;
+    change_type?: ChangeType;
+    reasoning: string;
+    created_at: string;
+}
+export interface CreateFileReasoningInput {
+    task_id?: string;
+    file_path: string;
+    anchor?: string;
+    line_start?: number;
+    line_end?: number;
+    code_hash?: string;
+    change_type?: ChangeType;
+    reasoning: string;
+}
+/**
+ * Initialize the database connection and create tables
+ */
+export declare function initDatabase(): Database.Database;
+/**
+ * Close the database connection
+ */
+export declare function closeDatabase(): void;
+/**
+ * Create a new task
+ */
+export declare function createTask(input: CreateTaskInput): Task;
+/**
+ * Get tasks for a project
+ */
+export declare function getTasksForProject(projectPath: string, options?: {
+    status?: TaskStatus;
+    limit?: number;
+}): Task[];
+export declare function getTasksByFiles(projectPath: string, files: string[], options?: {
+    status?: TaskStatus;
+    limit?: number;
+}): Task[];
+/**
+ * Get a task by ID
+ */
+export declare function getTaskById(id: string): Task | null;
+/**
+ * Update a task's status
+ */
+export declare function updateTaskStatus(id: string, status: TaskStatus): void;
+/**
+ * Get task count for a project
+ */
+export declare function getTaskCount(projectPath: string): number;
+/**
+ * Create a new session state.
+ * FIXED: Uses INSERT OR IGNORE to handle race conditions safely.
+ */
+export declare function createSessionState(input: CreateSessionStateInput): SessionState;
+/**
+ * Get a session state by ID
+ */
+export declare function getSessionState(sessionId: string): SessionState | null;
+/**
+ * Update a session state.
+ * SECURITY: Uses transaction for atomic updates to prevent race conditions.
+ */
+export declare function updateSessionState(sessionId: string, updates: Partial<Omit<SessionState, 'session_id' | 'start_time'>>): void;
+/**
+ * Delete a session state
+ */
+export declare function deleteSessionState(sessionId: string): void;
+/**
+ * Get active sessions for a project
+ */
+export declare function getActiveSessionsForProject(projectPath: string): SessionState[];
+/**
+ * Correction level types for drift detection
+ */
+export type CorrectionLevel = 'nudge' | 'correct' | 'intervene' | 'halt';
+/**
+ * Update session drift metrics after a prompt check
+ */
+export declare function updateSessionDrift(sessionId: string, driftScore: number, correctionLevel: CorrectionLevel | null, promptSummary: string, recoveryPlan?: RecoveryPlan): void;
+/**
+ * Check if a session should be flagged for review
+ * Returns true if: status=drifted OR warnings>=3 OR avg_score<6
+ */
+export declare function shouldFlagForReview(sessionId: string): boolean;
+/**
+ * Get drift summary for a session (used by capture)
+ */
+export declare function getDriftSummary(sessionId: string): {
+    totalEvents: number;
+    resolved: boolean;
+    finalScore: number | null;
+    hadHalt: boolean;
+};
+/**
+ * Create a new file reasoning entry
+ */
+export declare function createFileReasoning(input: CreateFileReasoningInput): FileReasoning;
+/**
+ * Get file reasoning entries for a task
+ */
+export declare function getFileReasoningForTask(taskId: string): FileReasoning[];
+/**
+ * Get file reasoning entries by file path
+ */
+export declare function getFileReasoningByPath(filePath: string, limit?: number): FileReasoning[];
+/**
+ * Get file reasoning entries matching a pattern (for files in a project).
+ * SECURITY: Uses escaped LIKE patterns to prevent injection.
+ */
+export declare function getFileReasoningByPathPattern(pathPattern: string, limit?: number): FileReasoning[];
+/**
+ * Get the database path
+ */
+export declare function getDatabasePath(): string;
+/**
+ * Step record - a single Claude action stored in DB
+ */
+export interface StepRecord {
+    id: string;
+    session_id: string;
+    action_type: string;
+    files: string[];
+    folders: string[];
+    command?: string;
+    reasoning?: string;
+    drift_score: number;
+    is_key_decision: boolean;
+    keywords: string[];
+    timestamp: number;
+}
+/**
+ * Save a Claude action as a step
+ */
+export declare function saveStep(sessionId: string, action: ClaudeAction, driftScore: number, isKeyDecision?: boolean, keywords?: string[]): void;
+/**
+ * Get recent steps for a session (most recent first)
+ */
+export declare function getRecentSteps(sessionId: string, limit?: number): StepRecord[];
+/**
+ * Update last_checked_at timestamp for a session
+ */
+export declare function updateLastChecked(sessionId: string, timestamp: number): void;
+/**
+ * Get steps that touched specific files
+ */
+export declare function getStepsByFiles(sessionId: string, files: string[], limit?: number): StepRecord[];
+/**
+ * Get steps that touched specific folders
+ */
+export declare function getStepsByFolders(sessionId: string, folders: string[], limit?: number): StepRecord[];
+/**
+ * Get steps matching keywords
+ */
+export declare function getStepsByKeywords(sessionId: string, keywords: string[], limit?: number): StepRecord[];
+/**
+ * Get key decision steps
+ */
+export declare function getKeyDecisionSteps(sessionId: string, limit?: number): StepRecord[];
+/**
+ * Combined retrieval: runs all 4 queries and deduplicates
+ * Priority: key decisions > files > folders > keywords
+ */
+export declare function getRelevantSteps(sessionId: string, currentFiles: string[], currentFolders: string[], keywords: string[], limit?: number): StepRecord[];