@mesadev/agentblame 0.2.11 → 3.0.1

package/dist/lib/database.js

@@ -1,8 +1,8 @@
 "use strict";
 /**
- * SQLite Database Module
+ * SQLite Database Module v3
  *
- * Handles persistent storage of AI edits for attribution matching.
+ * Handles persistent storage of sessions, prompts, and tool calls.
  * Uses Bun's built-in SQLite for high-performance lookups.
  */
 var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
@@ -39,104 +39,102 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.setAgentBlameDir = setAgentBlameDir;
-exports.getAgentBlameDir = getAgentBlameDir;
+exports.setDatabasePath = setDatabasePath;
 exports.getDbPath = getDbPath;
 exports.getDatabase = getDatabase;
 exports.closeDatabase = closeDatabase;
 exports.initDatabase = initDatabase;
-exports.insertEdit = insertEdit;
-exports.findByExactHash = findByExactHash;
-exports.findByNormalizedHash = findByNormalizedHash;
-exports.findEditsByFile = findEditsByFile;
-exports.getEditLines = getEditLines;
-exports.findLineMatch = findLineMatch;
-exports.markEditAsMatched = markEditAsMatched;
-exports.markEditsAsMatched = markEditsAsMatched;
+exports.resetDatabase = resetDatabase;
+exports.generateSessionId = generateSessionId;
+exports.upsertSession = upsertSession;
+exports.getSession = getSession;
+exports.updateSessionFirstCommit = updateSessionFirstCommit;
+exports.getRecentSessions = getRecentSessions;
+exports.insertPrompt = insertPrompt;
+exports.hashPromptContent = hashPromptContent;
+exports.getPromptsForSession = getPromptsForSession;
+exports.getLatestPromptForSession = getLatestPromptForSession;
+exports.getConcatenatedPromptsForSession = getConcatenatedPromptsForSession;
+exports.getPromptsWithToolCounts = getPromptsWithToolCounts;
+exports.promptExists = promptExists;
+exports.insertToolCall = insertToolCall;
+exports.getToolCallsForSession = getToolCallsForSession;
+exports.getToolNamesForSession = getToolNamesForSession;
+exports.getToolCountsForSession = getToolCountsForSession;
+exports.getSessionDuration = getSessionDuration;
 exports.cleanupOldEntries = cleanupOldEntries;
-exports.getPendingEditCount = getPendingEditCount;
-exports.getRecentPendingEdits = getRecentPendingEdits;
+exports.getStats = getStats;
 const bun_sqlite_1 = require("bun:sqlite");
 const fs = __importStar(require("node:fs"));
 const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
 // =============================================================================
 // Database Schema
 // =============================================================================
 const SCHEMA = `
--- Main edits table (one row per AI edit operation)
-CREATE TABLE IF NOT EXISTS edits (
-    id INTEGER PRIMARY KEY AUTOINCREMENT,
-    timestamp TEXT NOT NULL,
-    provider TEXT NOT NULL,
-    file_path TEXT NOT NULL,
+-- Sessions: One per AI conversation
+CREATE TABLE IF NOT EXISTS sessions (
+    id TEXT PRIMARY KEY,
+    agent TEXT NOT NULL,
     model TEXT,
-    content TEXT NOT NULL,
+    conversation_id TEXT,
+    created_at TEXT NOT NULL,
+    first_commit_sha TEXT,
+    first_commit_at TEXT
+);
+
+-- Prompts: User messages that triggered AI actions
+CREATE TABLE IF NOT EXISTS prompts (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    session_id TEXT NOT NULL,
+    content TEXT,
     content_hash TEXT NOT NULL,
-    content_hash_normalized TEXT NOT NULL,
-    edit_type TEXT NOT NULL,
-    old_content TEXT,
-    status TEXT DEFAULT 'pending',
-    matched_commit TEXT,
-    matched_at TEXT,
-    session_id TEXT,
-    tool_use_id TEXT
+    timestamp TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
 );
 
--- Lines table (one row per line in an edit)
-CREATE TABLE IF NOT EXISTS lines (
+-- Tool Calls: What the AI did (minimal for counting per prompt)
+CREATE TABLE IF NOT EXISTS tool_calls (
     id INTEGER PRIMARY KEY AUTOINCREMENT,
-    edit_id INTEGER NOT NULL,
-    content TEXT NOT NULL,
-    hash TEXT NOT NULL,
-    hash_normalized TEXT NOT NULL,
-    line_number INTEGER,
-    context_before TEXT,
-    context_after TEXT,
-    FOREIGN KEY (edit_id) REFERENCES edits(id) ON DELETE CASCADE
+    session_id TEXT NOT NULL,
+    tool_name TEXT NOT NULL,
+    file_path TEXT,
+    timestamp TEXT NOT NULL,
+    FOREIGN KEY (session_id) REFERENCES sessions(id)
 );
 
--- Indexes for fast lookup
-CREATE INDEX IF NOT EXISTS idx_lines_hash ON lines(hash);
-CREATE INDEX IF NOT EXISTS idx_lines_hash_normalized ON lines(hash_normalized);
-CREATE INDEX IF NOT EXISTS idx_lines_line_number ON lines(line_number);
-CREATE INDEX IF NOT EXISTS idx_edits_status ON edits(status);
-CREATE INDEX IF NOT EXISTS idx_edits_file_path ON edits(file_path);
-CREATE INDEX IF NOT EXISTS idx_edits_content_hash ON edits(content_hash);
-CREATE INDEX IF NOT EXISTS idx_edits_session_id ON edits(session_id);
+-- Indexes
+CREATE INDEX IF NOT EXISTS idx_sessions_agent ON sessions(agent, conversation_id);
+CREATE INDEX IF NOT EXISTS idx_prompts_session ON prompts(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_session ON tool_calls(session_id);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_file ON tool_calls(file_path);
+CREATE INDEX IF NOT EXISTS idx_tool_calls_timestamp ON tool_calls(timestamp);
 `;
 // =============================================================================
 // Database Connection
 // =============================================================================
 let dbInstance = null;
-let currentAgentBlameDir = null;
+let currentDbPath = null;
 /**
- * Set the agentblame directory for database operations.
- * Must be called before using any database functions.
+ * Set the database path directly.
  */
-function setAgentBlameDir(dir) {
-    if (currentAgentBlameDir !== dir) {
-        // Close existing connection if switching directories
+function setDatabasePath(dbPath) {
+    if (currentDbPath !== dbPath) {
         if (dbInstance) {
             dbInstance.close();
             dbInstance = null;
         }
-        currentAgentBlameDir = dir;
+        currentDbPath = dbPath;
     }
 }
-/**
- * Get the current agentblame directory.
- */
-function getAgentBlameDir() {
-    return currentAgentBlameDir;
-}
 /**
  * Get the database file path
  */
 function getDbPath() {
-    if (!currentAgentBlameDir) {
-        throw new Error("agentblame directory not set. Call setAgentBlameDir() first.");
+    if (!currentDbPath) {
+        throw new Error("Database path not set. Call setDatabasePath() first.");
     }
-    return path.join(currentAgentBlameDir, "agentblame.db");
+    return currentDbPath;
 }
 /**
  * Initialize and return the database connection
@@ -147,19 +145,13 @@ function getDatabase() {
     }
     const dbPath = getDbPath();
     const dbDir = path.dirname(dbPath);
-    // Ensure directory exists
     if (!fs.existsSync(dbDir)) {
         fs.mkdirSync(dbDir, { recursive: true });
     }
-    // Create database connection
     dbInstance = new bun_sqlite_1.Database(dbPath);
-    // Enable foreign keys and WAL mode for better performance
     dbInstance.exec("PRAGMA foreign_keys = ON");
     dbInstance.exec("PRAGMA journal_mode = WAL");
-    // Set busy timeout to handle concurrent writes from async hooks
-    // Without this, concurrent capture processes get SQLITE_BUSY and fail silently
     dbInstance.exec("PRAGMA busy_timeout = 5000");
-    // Create tables and indexes
     dbInstance.exec(SCHEMA);
     return dbInstance;
 }
@@ -173,332 +165,320 @@ function closeDatabase() {
     }
 }
 /**
- * Initialize database (creates file and schema if needed)
- * Call this during install to ensure DB is ready
+ * Initialize database
  */
 function initDatabase() {
     const db = getDatabase();
-    // Database is initialized by getDatabase()
-    // Just verify it's working
     db.exec("SELECT 1");
 }
 /**
- * Insert a new AI edit into the database.
- * Uses an explicit transaction to ensure atomicity - either all data
- * is written (edit + lines) or none. This is especially important
- * when running async hooks where the process could be interrupted.
+ * Reset database (drop and recreate tables)
  */
-function insertEdit(params) {
+function resetDatabase() {
     const db = getDatabase();
-    const editStmt = db.prepare(`
-    INSERT INTO edits (
-      timestamp, provider, file_path, model, content,
-      content_hash, content_hash_normalized, edit_type, old_content,
-      session_id, tool_use_id
-    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
-  `);
-    const lineStmt = db.prepare(`
-    INSERT INTO lines (edit_id, content, hash, hash_normalized, line_number, context_before, context_after)
-    VALUES (?, ?, ?, ?, ?, ?, ?)
-  `);
-    // Wrap in transaction for atomicity
-    db.exec("BEGIN TRANSACTION");
-    try {
-        const result = editStmt.run(params.timestamp, params.provider, params.filePath, params.model, params.content, params.contentHash, params.contentHashNormalized, params.editType, params.oldContent || null, params.sessionId || null, params.toolUseId || null);
-        const editId = Number(result.lastInsertRowid);
-        // Insert lines with line numbers and context
-        for (const line of params.lines) {
-            lineStmt.run(editId, line.content, line.hash, line.hashNormalized, line.lineNumber || null, line.contextBefore || null, line.contextAfter || null);
-        }
-        db.exec("COMMIT");
-        return editId;
-    }
-    catch (err) {
-        db.exec("ROLLBACK");
-        throw err;
-    }
+    db.exec("DROP TABLE IF EXISTS tool_calls");
+    db.exec("DROP TABLE IF EXISTS prompts");
+    db.exec("DROP TABLE IF EXISTS sessions");
+    db.exec(SCHEMA);
 }
 // =============================================================================
-// Query Operations (used by process.ts for matching)
+// Session ID Generation
 // =============================================================================
 /**
- * Find a line match by exact hash
- * Returns the edit and line if found, with same-file matches preferred
+ * Generate a stable session ID from agent and conversation ID
+ */
+function generateSessionId(agent, conversationId) {
+    const hash = (0, node_crypto_1.createHash)("sha256");
+    hash.update(`${agent}:${conversationId}`);
+    return hash.digest("hex").substring(0, 16);
+}
+/**
+ * Upsert a session
  */
-function findByExactHash(hash, filePath) {
+function upsertSession(params) {
     const db = getDatabase();
-    // First try same-file match
-    const sameFileStmt = db.prepare(`
-    SELECT
-      l.id as line_id, l.edit_id, l.content as line_content,
-      l.hash, l.hash_normalized, l.line_number, l.context_before, l.context_after,
-      e.*
-    FROM lines l
-    JOIN edits e ON l.edit_id = e.id
-    WHERE l.hash = ? AND (
-      e.file_path = ? OR
-      e.file_path LIKE ? OR
-      ? LIKE '%' || substr(e.file_path, instr(e.file_path, '/') + 1)
-    )
-    ORDER BY e.timestamp DESC
-    LIMIT 1
+    const stmt = db.prepare(`
+    INSERT INTO sessions (id, agent, model, conversation_id, created_at)
+    VALUES (?, ?, ?, ?, ?)
+    ON CONFLICT(id) DO UPDATE SET
+      model = COALESCE(excluded.model, sessions.model)
   `);
-    const fileName = filePath.split("/").pop() || "";
-    let row = sameFileStmt.get(hash, filePath, `%${fileName}`, filePath);
-    // If no same-file match, try any match
-    if (!row) {
-        const anyStmt = db.prepare(`
-      SELECT
-        l.id as line_id, l.edit_id, l.content as line_content,
-        l.hash, l.hash_normalized, l.line_number, l.context_before, l.context_after,
-        e.*
-      FROM lines l
-      JOIN edits e ON l.edit_id = e.id
-      WHERE l.hash = ?
-      ORDER BY e.timestamp DESC
-      LIMIT 1
-    `);
-        row = anyStmt.get(hash);
-    }
-    if (!row)
-        return null;
-    return {
-        edit: rowToEdit(row),
-        line: {
-            id: row.line_id,
-            editId: row.edit_id,
-            content: row.line_content,
-            hash: row.hash,
-            hashNormalized: row.hash_normalized,
-            lineNumber: row.line_number,
-            contextBefore: row.context_before,
-            contextAfter: row.context_after,
-        },
-        matchType: "exact_hash",
-        confidence: 1.0,
-    };
+    stmt.run(params.id, params.agent, params.model ?? null, params.conversationId ?? null, new Date().toISOString());
 }
 /**
- * Find a line match by normalized hash
+ * Get a session by ID
  */
-function findByNormalizedHash(hashNormalized, filePath) {
+function getSession(sessionId) {
     const db = getDatabase();
-    const fileName = filePath.split("/").pop() || "";
-    // First try same-file match
-    const sameFileStmt = db.prepare(`
-    SELECT
-      l.id as line_id, l.edit_id, l.content as line_content,
-      l.hash, l.hash_normalized, l.line_number, l.context_before, l.context_after,
-      e.*
-    FROM lines l
-    JOIN edits e ON l.edit_id = e.id
-    WHERE l.hash_normalized = ? AND (
-      e.file_path = ? OR
-      e.file_path LIKE ? OR
-      ? LIKE '%' || substr(e.file_path, instr(e.file_path, '/') + 1)
-    )
-    ORDER BY e.timestamp DESC
-    LIMIT 1
-  `);
-    let row = sameFileStmt.get(hashNormalized, filePath, `%${fileName}`, filePath);
-    if (!row) {
-        const anyStmt = db.prepare(`
-      SELECT
-        l.id as line_id, l.edit_id, l.content as line_content,
-        l.hash, l.hash_normalized, l.line_number, l.context_before, l.context_after,
-        e.*
-      FROM lines l
-      JOIN edits e ON l.edit_id = e.id
-      WHERE l.hash_normalized = ?
-      ORDER BY e.timestamp DESC
-      LIMIT 1
-    `);
-        row = anyStmt.get(hashNormalized);
-    }
+    const stmt = db.prepare("SELECT * FROM sessions WHERE id = ?");
+    const row = stmt.get(sessionId);
     if (!row)
         return null;
-    return {
-        edit: rowToEdit(row),
-        line: {
-            id: row.line_id,
-            editId: row.edit_id,
-            content: row.line_content,
-            hash: row.hash,
-            hashNormalized: row.hash_normalized,
-            lineNumber: row.line_number,
-            contextBefore: row.context_before,
-            contextAfter: row.context_after,
-        },
-        matchType: "normalized_hash",
-        confidence: 0.95,
-    };
+    return rowToSession(row);
 }
 /**
- * Find edits for a specific file (used for substring matching fallback)
+ * Update session with first commit info
  */
-function findEditsByFile(filePath) {
+function updateSessionFirstCommit(sessionId, commitSha) {
     const db = getDatabase();
-    const fileName = filePath.split("/").pop() || "";
     const stmt = db.prepare(`
-    SELECT * FROM edits
-    WHERE file_path = ? OR
-          file_path LIKE ? OR
-          ? LIKE '%' || substr(file_path, instr(file_path, '/') + 1)
-    ORDER BY timestamp DESC
+    UPDATE sessions
+    SET first_commit_sha = COALESCE(first_commit_sha, ?),
+        first_commit_at = COALESCE(first_commit_at, ?)
+    WHERE id = ?
   `);
-    const rows = stmt.all(filePath, `%${fileName}`, filePath);
-    return rows.map(rowToEdit);
+    stmt.run(commitSha, new Date().toISOString(), sessionId);
 }
 /**
- * Get lines for a specific edit
+ * Get recent sessions
  */
-function getEditLines(editId) {
+function getRecentSessions(limit = 5) {
     const db = getDatabase();
-    const stmt = db.prepare(`SELECT * FROM lines WHERE edit_id = ?`);
-    const rows = stmt.all(editId);
-    return rows.map(row => ({
-        id: row.id,
-        editId: row.edit_id,
-        content: row.content,
-        hash: row.hash,
-        hashNormalized: row.hash_normalized,
-        lineNumber: row.line_number,
-        contextBefore: row.context_before,
-        contextAfter: row.context_after,
-    }));
+    const stmt = db.prepare(`SELECT * FROM sessions ORDER BY created_at DESC LIMIT ?`);
+    const rows = stmt.all(limit);
+    return rows.map(rowToSession);
 }
 /**
- * Find a line match using exact matching only:
- * 1. Exact hash match (confidence: 1.0)
- * 2. Normalized hash match (confidence: 0.95) - handles formatter whitespace changes
- *
- * No substring/fuzzy matching - if hash doesn't match, it's human code.
- * Philosophy: "If user modified AI code, it's human code"
+ * Insert a new prompt
+ */
+function insertPrompt(params) {
+    const db = getDatabase();
+    const stmt = db.prepare(`
+    INSERT INTO prompts (session_id, content, content_hash, timestamp)
+    VALUES (?, ?, ?, ?)
+  `);
+    const result = stmt.run(params.sessionId, params.content, params.contentHash, params.timestamp ?? new Date().toISOString());
+    return Number(result.lastInsertRowid);
+}
+/**
+ * Generate a hash for prompt content (for deduplication)
  */
-function findLineMatch(lineContent, lineHash, lineHashNormalized, filePath) {
-    // Strategy 1: Exact hash - perfect match
-    let match = findByExactHash(lineHash, filePath);
-    if (match)
-        return match;
-    // Strategy 2: Normalized hash - handles whitespace changes from formatters
-    match = findByNormalizedHash(lineHashNormalized, filePath);
-    if (match)
-        return match;
-    // No match = human code (either written by human or modified from AI)
-    return null;
+function hashPromptContent(content) {
+    return (0, node_crypto_1.createHash)('sha256').update(content).digest('hex').substring(0, 16);
 }
-// =============================================================================
-// Update Operations
-// =============================================================================
 /**
- * Mark an edit as matched to a commit
+ * Get prompts for a session
  */
-function markEditAsMatched(editId, commitSha) {
+function getPromptsForSession(sessionId) {
     const db = getDatabase();
-    const stmt = db.prepare(`
-    UPDATE edits
-    SET status = 'matched', matched_commit = ?, matched_at = ?
-    WHERE id = ?
-  `);
-    stmt.run(commitSha, new Date().toISOString(), editId);
+    const stmt = db.prepare("SELECT * FROM prompts WHERE session_id = ? ORDER BY timestamp ASC");
+    const rows = stmt.all(sessionId);
+    return rows.map(rowToPrompt);
 }
 /**
- * Mark multiple edits as matched
+ * Get the most recent prompt for a session
  */
-function markEditsAsMatched(editIds, commitSha) {
+function getLatestPromptForSession(sessionId) {
     const db = getDatabase();
-    const timestamp = new Date().toISOString();
     const stmt = db.prepare(`
-    UPDATE edits
-    SET status = 'matched', matched_commit = ?, matched_at = ?
-    WHERE id = ?
+    SELECT * FROM prompts WHERE session_id = ? ORDER BY timestamp DESC LIMIT 1
   `);
-    db.exec("BEGIN TRANSACTION");
-    try {
-        for (const editId of editIds) {
-            stmt.run(commitSha, timestamp, editId);
+    const row = stmt.get(sessionId);
+    return row ? rowToPrompt(row) : null;
+}
+/**
+ * Get all prompts for a session concatenated into one string
+ * Useful for displaying the full conversation context in CLI
+ */
+function getConcatenatedPromptsForSession(sessionId) {
+    const prompts = getPromptsForSession(sessionId);
+    if (prompts.length === 0)
+        return null;
+    if (prompts.length === 1) {
+        return prompts[0].content ?? "[content not stored]";
+    }
+    // Concatenate with separator showing it's multiple prompts
+    return prompts
+        .map((p, i) => `[${i + 1}] ${p.content ?? '[not stored]'}`)
+        .join(" → ");
+}
+/**
+ * Get all prompts for a session with their associated tool call summaries
+ * Tool calls are grouped by the prompt that triggered them (based on timestamps)
+ * Used for git notes and analytics
+ */
+function getPromptsWithToolCounts(sessionId) {
+    const prompts = getPromptsForSession(sessionId);
+    if (prompts.length === 0)
+        return null;
+    const toolCalls = getToolCallsForSession(sessionId);
+    const result = [];
+    for (let i = 0; i < prompts.length; i++) {
+        const prompt = prompts[i];
+        const promptTime = new Date(prompt.timestamp).getTime();
+        const nextPromptTime = i < prompts.length - 1
+            ? new Date(prompts[i + 1].timestamp).getTime()
+            : Infinity;
+        // Find tool calls between this prompt and the next
+        const toolsForPrompt = toolCalls.filter((tc) => {
+            const tcTime = new Date(tc.timestamp).getTime();
+            return tcTime >= promptTime && tcTime < nextPromptTime;
+        });
+        // Count tools
+        const tools = {};
+        for (const tool of toolsForPrompt) {
+            tools[tool.toolName] = (tools[tool.toolName] || 0) + 1;
         }
-        db.exec("COMMIT");
+        // Calculate duration until next prompt (or last tool call)
+        let duration;
+        if (i < prompts.length - 1) {
+            duration = Math.round((nextPromptTime - promptTime) / 1000);
+        }
+        else if (toolsForPrompt.length > 0) {
+            // Last prompt: duration until last tool call
+            const lastToolTime = new Date(toolsForPrompt[toolsForPrompt.length - 1].timestamp).getTime();
+            duration = Math.round((lastToolTime - promptTime) / 1000);
+        }
+        result.push({
+            id: prompt.id,
+            timestamp: prompt.timestamp,
+            content: prompt.content,
+            tools: Object.keys(tools).length > 0 ? tools : undefined,
+            duration,
+        });
     }
-    catch (err) {
-        db.exec("ROLLBACK");
-        throw err;
+    return result;
+}
+/**
+ * Check if a prompt already exists (by hash)
+ */
+function promptExists(sessionId, contentHash) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT 1 FROM prompts WHERE session_id = ? AND content_hash = ? LIMIT 1`);
+    const result = stmt.get(sessionId, contentHash);
+    if (process.env.AGENTBLAME_DEBUG) {
+        console.error(`[agentblame] promptExists query result:`, result, `type:`, typeof result);
     }
+    return result !== undefined && result !== null;
 }
-// =============================================================================
-// Cleanup Operations
-// =============================================================================
 /**
- * Clean up old entries
- * - Removes matched entries older than maxAgeDays
- * - Removes unmatched entries older than expireDays
+ * Insert a new tool call
  */
-function cleanupOldEntries(maxAgeDays = 7, expireDays = 30) {
+function insertToolCall(params) {
     const db = getDatabase();
-    // Count before
-    const beforeCount = db.prepare("SELECT COUNT(*) as count FROM edits").get().count;
-    // Delete old matched entries
-    db.prepare(`
-    DELETE FROM edits
-    WHERE status = 'matched'
-    AND datetime(matched_at) < datetime('now', '-' || ? || ' days')
-  `).run(maxAgeDays);
-    // Delete old unmatched entries
-    db.prepare(`
-    DELETE FROM edits
-    WHERE (status IS NULL OR status = 'pending')
-    AND datetime(timestamp) < datetime('now', '-' || ? || ' days')
-  `).run(expireDays);
-    // Count after
-    const afterCount = db.prepare("SELECT COUNT(*) as count FROM edits").get().count;
-    return {
-        removed: beforeCount - afterCount,
-        kept: afterCount,
-    };
+    const stmt = db.prepare(`
+    INSERT INTO tool_calls (session_id, tool_name, file_path, timestamp)
+    VALUES (?, ?, ?, ?)
+  `);
+    const result = stmt.run(params.sessionId, params.toolName, params.filePath ?? null, params.timestamp ?? new Date().toISOString());
+    return Number(result.lastInsertRowid);
 }
 /**
- * Get count of pending edits
+ * Get tool calls for a session
  */
-function getPendingEditCount() {
+function getToolCallsForSession(sessionId) {
     const db = getDatabase();
-    const result = db.prepare(`
-    SELECT COUNT(*) as count FROM edits
-    WHERE status IS NULL OR status = 'pending'
-  `).get();
-    return result.count;
+    const stmt = db.prepare("SELECT * FROM tool_calls WHERE session_id = ? ORDER BY timestamp ASC");
+    const rows = stmt.all(sessionId);
+    return rows.map(rowToToolCall);
 }
 /**
- * Get recent pending edits for status display
+ * Get unique tool names used in a session
  */
-function getRecentPendingEdits(limit = 5) {
+function getToolNamesForSession(sessionId) {
+    const db = getDatabase();
+    const stmt = db.prepare(`SELECT DISTINCT tool_name FROM tool_calls WHERE session_id = ? ORDER BY tool_name`);
+    const rows = stmt.all(sessionId);
+    return rows.map((r) => r.tool_name);
+}
+/**
+ * Get tool call counts for a session
+ * Returns a map of tool_name -> count
+ */
+function getToolCountsForSession(sessionId) {
     const db = getDatabase();
     const stmt = db.prepare(`
-    SELECT * FROM edits
-    WHERE status IS NULL OR status = 'pending'
-    ORDER BY timestamp DESC
-    LIMIT ?
+    SELECT tool_name, COUNT(*) as count
+    FROM tool_calls
+    WHERE session_id = ?
+    GROUP BY tool_name
   `);
-    const rows = stmt.all(limit);
-    return rows.map(rowToEdit);
+    const rows = stmt.all(sessionId);
+    const counts = {};
+    for (const row of rows) {
+        counts[row.tool_name] = row.count;
+    }
+    return counts;
+}
+/**
+ * Get session duration in seconds (last tool call - session start)
+ * Returns null if no tool calls
+ */
+function getSessionDuration(sessionId) {
+    const db = getDatabase();
+    // Get session start time
+    const session = db.prepare("SELECT created_at FROM sessions WHERE id = ?").get(sessionId);
+    if (!session)
+        return null;
+    // Get last tool call time
+    const lastToolCall = db.prepare(`
+    SELECT MAX(timestamp) as last_ts
+    FROM tool_calls
+    WHERE session_id = ?
+  `).get(sessionId);
+    if (!lastToolCall?.last_ts)
+        return null;
+    const startTime = new Date(session.created_at).getTime();
+    const endTime = new Date(lastToolCall.last_ts).getTime();
+    return Math.round((endTime - startTime) / 1000);
+}
+// =============================================================================
+// Cleanup Operations
+// =============================================================================
+/**
+ * Clean up old entries (sessions without commits older than maxAgeDays)
+ */
+function cleanupOldEntries(maxAgeDays = 30) {
+    const db = getDatabase();
+    const beforeCount = db.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+    db.prepare(`
+    DELETE FROM sessions
+    WHERE first_commit_sha IS NULL
+    AND datetime(created_at) < datetime('now', '-' || ? || ' days')
+  `).run(maxAgeDays);
+    const afterCount = db.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+    return { removed: beforeCount - afterCount, kept: afterCount };
+}
+/**
+ * Get stats for status display
+ */
+function getStats() {
+    const db = getDatabase();
+    const sessions = db.prepare("SELECT COUNT(*) as count FROM sessions").get().count;
+    const prompts = db.prepare("SELECT COUNT(*) as count FROM prompts").get().count;
+    const toolCalls = db.prepare("SELECT COUNT(*) as count FROM tool_calls").get().count;
+    return { sessions, prompts, toolCalls };
 }
 // =============================================================================
 // Helpers
 // =============================================================================
-function rowToEdit(row) {
+function rowToSession(row) {
     return {
         id: row.id,
-        timestamp: row.timestamp,
-        provider: row.provider,
-        filePath: row.file_path,
+        agent: row.agent,
         model: row.model,
+        conversationId: row.conversation_id,
+        createdAt: row.created_at,
+        firstCommitSha: row.first_commit_sha,
+        firstCommitAt: row.first_commit_at,
+    };
+}
+function rowToPrompt(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
         content: row.content,
         contentHash: row.content_hash,
-        contentHashNormalized: row.content_hash_normalized,
-        editType: row.edit_type,
-        oldContent: row.old_content,
-        status: row.status,
-        matchedCommit: row.matched_commit,
-        matchedAt: row.matched_at,
+        timestamp: row.timestamp,
+    };
+}
+function rowToToolCall(row) {
+    return {
+        id: row.id,
+        sessionId: row.session_id,
+        toolName: row.tool_name,
+        filePath: row.file_path,
+        timestamp: row.timestamp,
     };
 }
 //# sourceMappingURL=database.js.map