@spences10/pi-context 0.0.2 → 0.0.4

package/dist/store.js

@@ -4,65 +4,11 @@ import { existsSync, mkdirSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { dirname, join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
-export const DEFAULT_CONTEXT_MAX_BYTES = 24 * 1024;
-export const DEFAULT_CONTEXT_MAX_LINES = 300;
-const DEFAULT_PREVIEW_LINES = 80;
-const DEFAULT_PREVIEW_BYTES = 8 * 1024;
-const SCHEMA = `
-PRAGMA foreign_keys = ON;
-PRAGMA journal_mode = WAL;
-PRAGMA busy_timeout = 5000;
-
-CREATE TABLE IF NOT EXISTS context_sources (
-  id TEXT PRIMARY KEY,
-  session_id TEXT,
-  project_path TEXT,
-  tool_name TEXT NOT NULL,
-  input_summary TEXT,
-  created_at INTEGER NOT NULL,
-  byte_count INTEGER NOT NULL,
-  line_count INTEGER NOT NULL,
-  content_hash TEXT NOT NULL,
-  preview_byte_count INTEGER NOT NULL DEFAULT 0,
-  returned_byte_count INTEGER NOT NULL DEFAULT 0
-);
-
-CREATE TABLE IF NOT EXISTS context_chunks (
-  id TEXT PRIMARY KEY,
-  source_id TEXT NOT NULL REFERENCES context_sources(id) ON DELETE CASCADE,
-  ordinal INTEGER NOT NULL,
-  title TEXT,
-  content TEXT NOT NULL,
-  byte_count INTEGER NOT NULL
-);
-
-CREATE VIRTUAL TABLE IF NOT EXISTS context_chunks_fts USING fts5(
-  title,
-  content,
-  content='context_chunks',
-  content_rowid='rowid'
-);
-
-CREATE TRIGGER IF NOT EXISTS context_chunks_ai AFTER INSERT ON context_chunks BEGIN
-  INSERT INTO context_chunks_fts(rowid, title, content) VALUES (new.rowid, new.title, new.content);
-END;
-
-CREATE TRIGGER IF NOT EXISTS context_chunks_ad AFTER DELETE ON context_chunks BEGIN
-  INSERT INTO context_chunks_fts(context_chunks_fts, rowid, title, content)
-  VALUES('delete', old.rowid, old.title, old.content);
-END;
-
-CREATE TRIGGER IF NOT EXISTS context_chunks_au AFTER UPDATE ON context_chunks BEGIN
-  INSERT INTO context_chunks_fts(context_chunks_fts, rowid, title, content)
-  VALUES('delete', old.rowid, old.title, old.content);
-  INSERT INTO context_chunks_fts(rowid, title, content) VALUES (new.rowid, new.title, new.content);
-END;
-
-CREATE INDEX IF NOT EXISTS idx_context_sources_created ON context_sources(created_at);
-CREATE INDEX IF NOT EXISTS idx_context_sources_session ON context_sources(session_id);
-CREATE INDEX IF NOT EXISTS idx_context_sources_project ON context_sources(project_path);
-CREATE INDEX IF NOT EXISTS idx_context_chunks_source ON context_chunks(source_id, ordinal);
-`;
+import { parse_context_retention_policy } from './policy.js';
+import { apply_schema } from './schema.js';
+import { DEFAULT_CONTEXT_MAX_BYTES, DEFAULT_CONTEXT_MAX_LINES, chunk_text, count_lines, escape_fts5_query, make_preview, should_index_text, summarize_source, } from './text.js';
+export { DEFAULT_CONTEXT_RETENTION_DAYS, parse_context_retention_policy, } from './policy.js';
+export { DEFAULT_CONTEXT_MAX_BYTES, DEFAULT_CONTEXT_MAX_LINES, count_lines, escape_fts5_query, make_preview, should_index_text, } from './text.js';
 let global_options = {};
 let global_enabled = false;
 let global_store = null;
@@ -75,9 +21,12 @@ export function default_context_db_path() {
 }
 export function set_context_sidecar_enabled(enabled, options = {}) {
     global_enabled = enabled;
-    global_options = { ...global_options, ...options };
-    if (!enabled)
+    if (!enabled) {
+        global_options = {};
         global_store = null;
+        return;
+    }
+    global_options = { ...global_options, ...options };
 }
 export function is_context_sidecar_enabled() {
     return global_enabled;
@@ -88,6 +37,9 @@ export function get_context_store(options = {}) {
     if (!global_store || global_store.db_path !== db_path) {
         global_store = new ContextStore({ ...merged, db_path });
     }
+    else {
+        global_store.configure(merged);
+    }
     return global_store;
 }
 export function maybe_store_context_output(input, options = {}) {
@@ -95,177 +47,6 @@ export function maybe_store_context_output(input, options = {}) {
         return null;
     return get_context_store(options).store(input);
 }
-export function count_lines(text) {
-    if (!text)
-        return 0;
-    return text.split('\n').length;
-}
-export function should_index_text(text, options = {}) {
-    const max_bytes = options.max_bytes ?? DEFAULT_CONTEXT_MAX_BYTES;
-    const max_lines = options.max_lines ?? DEFAULT_CONTEXT_MAX_LINES;
-    return (Buffer.byteLength(text, 'utf8') > max_bytes ||
-        count_lines(text) > max_lines);
-}
-export function escape_fts5_query(query) {
-    const trimmed = query.trim();
-    if (!trimmed)
-        return '""';
-    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
-        return trimmed.replace(/"(.*)"/s, (_match, inner) => `"${inner.replace(/"/g, '""')}"`);
-    }
-    const tokens = trimmed
-        .split(/\s+/)
-        .map((token) => token.trim())
-        .filter(Boolean)
-        .map((token) => {
-        const is_prefix = token.endsWith('*');
-        const base = is_prefix ? token.slice(0, -1) : token;
-        const safe = base
-            .replace(/["'(){}[\]^:./\\+-]/g, ' ')
-            .trim()
-            .replace(/\s+/g, ' ');
-        if (!safe)
-            return '';
-        const quoted = `"${safe.replace(/"/g, '""')}"`;
-        return is_prefix ? `${quoted}*` : quoted;
-    })
-        .filter(Boolean);
-    return tokens.length > 0 ? tokens.join(' ') : '""';
-}
-export function make_preview(text, max_lines = DEFAULT_PREVIEW_LINES, max_bytes = DEFAULT_PREVIEW_BYTES) {
-    const lines = text.split('\n');
-    let preview;
-    if (lines.length <= max_lines) {
-        preview = text;
-    }
-    else {
-        const head_count = Math.ceil(max_lines / 2);
-        const tail_count = Math.floor(max_lines / 2);
-        const omitted = lines.length - head_count - tail_count;
-        preview = [
-            ...lines.slice(0, head_count),
-            ``,
-            `[... ${omitted} lines omitted; indexed in context sidecar ...]`,
-            ``,
-            ...lines.slice(-tail_count),
-        ].join('\n');
-    }
-    return take_utf8_bytes(preview, max_bytes);
-}
-function take_utf8_bytes(text, max_bytes) {
-    if (Buffer.byteLength(text, 'utf8') <= max_bytes)
-        return text;
-    let bytes = 0;
-    let output = '';
-    for (const char of text) {
-        const char_bytes = Buffer.byteLength(char, 'utf8');
-        if (bytes + char_bytes > max_bytes)
-            break;
-        bytes += char_bytes;
-        output += char;
-    }
-    return `${output}\n[... preview truncated at ${format_bytes(max_bytes)} ...]`;
-}
-function chunk_text(text, source_id) {
-    const paragraphs = text.split(/\n{2,}/);
-    const chunks = [];
-    let current = '';
-    const target_bytes = 4096;
-    for (const paragraph of paragraphs) {
-        if (Buffer.byteLength(paragraph, 'utf8') > target_bytes) {
-            if (current)
-                chunks.push(current);
-            chunks.push(...split_large_chunk(paragraph, target_bytes));
-            current = '';
-            continue;
-        }
-        const next = current ? `${current}\n\n${paragraph}` : paragraph;
-        if (Buffer.byteLength(next, 'utf8') > target_bytes && current) {
-            chunks.push(current);
-            current = paragraph;
-        }
-        else {
-            current = next;
-        }
-    }
-    if (current)
-        chunks.push(current);
-    if (chunks.length === 0)
-        chunks.push(text);
-    return chunks.map((content, index) => ({
-        id: `${source_id}_${String(index + 1).padStart(4, '0')}`,
-        source_id,
-        ordinal: index + 1,
-        title: first_non_empty_line(content),
-        content,
-        byte_count: Buffer.byteLength(content, 'utf8'),
-    }));
-}
-function split_large_chunk(text, target_bytes) {
-    const chunks = [];
-    let current = '';
-    for (const line of text.split('\n')) {
-        const next = current ? `${current}\n${line}` : line;
-        if (Buffer.byteLength(next, 'utf8') <= target_bytes) {
-            current = next;
-            continue;
-        }
-        if (current)
-            chunks.push(current);
-        if (Buffer.byteLength(line, 'utf8') <= target_bytes) {
-            current = line;
-            continue;
-        }
-        let rest = line;
-        while (Buffer.byteLength(rest, 'utf8') > target_bytes) {
-            const [head, tail] = split_utf8_at_byte(rest, target_bytes);
-            chunks.push(head);
-            rest = tail;
-        }
-        current = rest;
-    }
-    if (current)
-        chunks.push(current);
-    return chunks;
-}
-function split_utf8_at_byte(text, max_bytes) {
-    let bytes = 0;
-    let index = 0;
-    for (const char of text) {
-        const char_bytes = Buffer.byteLength(char, 'utf8');
-        if (bytes + char_bytes > max_bytes)
-            break;
-        bytes += char_bytes;
-        index += char.length;
-    }
-    return [text.slice(0, index), text.slice(index)];
-}
-function first_non_empty_line(text) {
-    const line = text
-        .split('\n')
-        .map((value) => value.trim())
-        .find(Boolean);
-    return line ? line.slice(0, 120) : null;
-}
-function format_bytes(bytes) {
-    if (bytes < 1024)
-        return `${bytes} B`;
-    if (bytes < 1024 * 1024)
-        return `${(bytes / 1024).toFixed(1)} KiB`;
-    return `${(bytes / 1024 / 1024).toFixed(1)} MiB`;
-}
-function summarize_source(result, tool_name) {
-    return [
-        `[context-sidecar] Large ${tool_name} output indexed locally`,
-        ``,
-        `Source: ${result.source_id}`,
-        `Size: ${format_bytes(result.bytes)}, ${result.lines} lines, ${result.chunk_count} chunks`,
-        `Use context_search query:"..." source_id:"${result.source_id}" to inspect it.`,
-        `Use context_get source_id:"${result.source_id}" for exact chunks.`,
-        ``,
-        result.preview,
-    ].join('\n');
-}
 export class ContextStore {
     db_path;
     db;
@@ -285,7 +66,69 @@ export class ContextStore {
         this.db = new DatabaseSync(this.db_path, {
             enableForeignKeyConstraints: true,
         });
-        this.db.exec(SCHEMA);
+        apply_schema(this.db);
+    }
+    configure(options = {}) {
+        if (options.project_path !== undefined)
+            this.project_path = options.project_path;
+        if (options.session_id !== undefined)
+            this.session_id = options.session_id;
+        if (options.max_bytes !== undefined)
+            this.max_bytes = options.max_bytes;
+        if (options.max_lines !== undefined)
+            this.max_lines = options.max_lines;
+    }
+    scoped_filter(alias, options = {}) {
+        const where = [];
+        const params = [];
+        if (options.session_id === null) {
+            where.push(`${alias}.session_id IS NULL`);
+        }
+        else if (options.session_id !== undefined) {
+            where.push(`${alias}.session_id = ?`);
+            params.push(options.session_id);
+        }
+        else if (!options.global && this.session_id) {
+            where.push(`${alias}.session_id = ?`);
+            params.push(this.session_id);
+        }
+        if (options.project_path === null) {
+            where.push(`${alias}.project_path IS NULL`);
+        }
+        else if (options.project_path !== undefined) {
+            where.push(`${alias}.project_path = ?`);
+            params.push(options.project_path);
+        }
+        else if (!options.global &&
+            where.length === 0 &&
+            this.project_path) {
+            where.push(`${alias}.project_path = ?`);
+            params.push(this.project_path);
+        }
+        return { where, params };
+    }
+    find_duplicate_source(content_hash, scope) {
+        const scoped = this.scoped_filter('context_sources', scope);
+        const filters = [
+            'context_sources.content_hash = ?',
+            ...scoped.where,
+        ];
+        const params = [
+            content_hash,
+            ...scoped.params,
+        ];
+        const row = this.db
+            .prepare(`
+				SELECT context_sources.id, COUNT(context_chunks.id) as chunk_count
+				FROM context_sources
+				LEFT JOIN context_chunks ON context_chunks.source_id = context_sources.id
+				WHERE ${filters.join(' AND ')}
+				GROUP BY context_sources.id
+				ORDER BY context_sources.created_at DESC
+				LIMIT 1
+			`)
+            .get(...params);
+        return row ?? null;
     }
     store(input) {
         const redaction = redact_text(input.text);
@@ -298,13 +141,39 @@ export class ContextStore {
             return null;
         const bytes = Buffer.byteLength(text, 'utf8');
         const lines = count_lines(text);
-        const source_id = `ctx_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
         const created_at = Date.now();
         const content_hash = createHash('sha256')
             .update(text)
             .digest('hex');
-        const chunks = chunk_text(text, source_id);
+        const session_id = input.session_id ?? this.session_id;
+        const project_path = input.project_path ?? this.project_path;
         const preview = make_preview(text);
+        const duplicate = this.find_duplicate_source(content_hash, {
+            session_id,
+            project_path,
+        });
+        if (duplicate) {
+            const provisional = {
+                source_id: duplicate.id,
+                bytes,
+                lines,
+                preview,
+                receipt: '',
+                chunk_count: duplicate.chunk_count,
+                returned_bytes: 0,
+                project_path,
+                session_id,
+                deduped: true,
+            };
+            const receipt = summarize_source(provisional, input.tool_name);
+            const returned_bytes = Buffer.byteLength(receipt, 'utf8');
+            this.db
+                .prepare('UPDATE context_sources SET returned_byte_count = returned_byte_count + ? WHERE id = ?')
+                .run(returned_bytes, duplicate.id);
+            return { ...provisional, receipt, returned_bytes };
+        }
+        const source_id = `ctx_${Date.now().toString(36)}_${randomUUID().slice(0, 8)}`;
+        const chunks = chunk_text(text, source_id);
         const preview_bytes = Buffer.byteLength(preview, 'utf8');
         const insert = this.db.prepare(`
 			INSERT INTO context_sources (
@@ -321,7 +190,7 @@ export class ContextStore {
 		`);
         this.db.exec('BEGIN');
         try {
-            insert.run(source_id, input.session_id ?? this.session_id, input.project_path ?? this.project_path, input.tool_name, input.input_summary ?? null, created_at, bytes, lines, content_hash, preview_bytes);
+            insert.run(source_id, session_id, project_path, input.tool_name, input.input_summary ?? null, created_at, bytes, lines, content_hash, preview_bytes);
             for (const chunk of chunks) {
                 insert_chunk.run(chunk.id, chunk.source_id, chunk.ordinal, chunk.title, chunk.content, chunk.byte_count);
             }
@@ -333,6 +202,8 @@ export class ContextStore {
                 receipt: '',
                 chunk_count: chunks.length,
                 returned_bytes: 0,
+                project_path,
+                session_id,
             };
             const receipt = summarize_source(provisional, input.tool_name);
             const returned_bytes = Buffer.byteLength(receipt, 'utf8');
@@ -345,11 +216,80 @@ export class ContextStore {
             throw error;
         }
     }
+    list(options = {}) {
+        const limit = Math.max(1, Math.min(options.limit ?? 10, 50));
+        const offset = Math.max(0, options.offset ?? 0);
+        const scoped = this.scoped_filter('context_sources', options);
+        const filters = [...scoped.where];
+        const params = [...scoped.params];
+        if (options.source_id) {
+            filters.push('context_sources.id = ?');
+            params.push(options.source_id);
+        }
+        if (options.tool_name) {
+            filters.push('context_sources.tool_name = ?');
+            params.push(options.tool_name);
+        }
+        if (options.newer_than_days !== undefined) {
+            filters.push('context_sources.created_at >= ?');
+            params.push(Date.now() - options.newer_than_days * 24 * 60 * 60 * 1000);
+        }
+        if (options.older_than_days !== undefined) {
+            filters.push('context_sources.created_at < ?');
+            params.push(Date.now() - options.older_than_days * 24 * 60 * 60 * 1000);
+        }
+        params.push(limit, offset);
+        const where_clause = filters.length
+            ? `WHERE ${filters.join(' AND ')}`
+            : '';
+        const stmt = this.db.prepare(`
+			SELECT
+				context_sources.id as source_id,
+				context_sources.created_at,
+				context_sources.project_path,
+				context_sources.session_id,
+				context_sources.tool_name,
+				context_sources.input_summary,
+				context_sources.byte_count,
+				context_sources.line_count,
+				COUNT(context_chunks.id) as chunk_count,
+				(
+					SELECT title FROM context_chunks first_chunk
+					WHERE first_chunk.source_id = context_sources.id
+					ORDER BY ordinal LIMIT 1
+				) as first_chunk_title,
+				(
+					SELECT substr(content, 1, 240) FROM context_chunks first_chunk
+					WHERE first_chunk.source_id = context_sources.id
+					ORDER BY ordinal LIMIT 1
+				) as preview
+			FROM context_sources
+			LEFT JOIN context_chunks ON context_chunks.source_id = context_sources.id
+			${where_clause}
+			GROUP BY context_sources.id
+			ORDER BY context_sources.created_at DESC
+			LIMIT ? OFFSET ?
+		`);
+        return stmt.all(...params).map((row) => ({
+            source_id: row.source_id,
+            created_at: row.created_at,
+            project_path: row.project_path,
+            session_id: row.session_id,
+            tool_name: row.tool_name,
+            input_summary: row.input_summary,
+            bytes: row.byte_count,
+            lines: row.line_count,
+            chunk_count: row.chunk_count,
+            first_chunk_title: row.first_chunk_title,
+            preview: row.preview,
+        }));
+    }
     search(query, options = {}) {
         const limit = Math.max(1, Math.min(options.limit ?? 5, 25));
         const match = escape_fts5_query(query);
-        const filters = [];
-        const params = [match];
+        const scoped = this.scoped_filter('context_sources', options);
+        const filters = [...scoped.where];
+        const params = [match, ...scoped.params];
         if (options.source_id) {
             filters.push('context_sources.id = ?');
             params.push(options.source_id);
@@ -394,41 +334,74 @@ export class ContextStore {
             rank: row.rank,
         }));
     }
-    get(source_id, chunk_id) {
-        const stmt = chunk_id
-            ? this.db.prepare(`
-				SELECT id, source_id, ordinal, title, content, byte_count
-				FROM context_chunks WHERE source_id = ? AND id = ? ORDER BY ordinal
-			`)
-            : this.db.prepare(`
-				SELECT id, source_id, ordinal, title, content, byte_count
-				FROM context_chunks WHERE source_id = ? ORDER BY ordinal
-			`);
-        const params = chunk_id ? [source_id, chunk_id] : [source_id];
+    get(source_id, chunk_id, options = {}) {
+        const scoped = this.scoped_filter('context_sources', options);
+        const filters = ['context_chunks.source_id = ?', ...scoped.where];
+        const params = [
+            source_id,
+            ...scoped.params,
+        ];
+        if (chunk_id) {
+            filters.push('context_chunks.id = ?');
+            params.push(chunk_id);
+        }
+        const stmt = this.db.prepare(`
+			SELECT
+				context_chunks.id,
+				context_chunks.source_id,
+				context_chunks.ordinal,
+				context_chunks.title,
+				context_chunks.content,
+				context_chunks.byte_count
+			FROM context_chunks
+			JOIN context_sources ON context_sources.id = context_chunks.source_id
+			WHERE ${filters.join(' AND ')}
+			ORDER BY context_chunks.ordinal
+		`);
         return stmt.all(...params);
     }
-    stats() {
+    count_stats(options) {
+        const scoped = this.scoped_filter('context_sources', options);
+        const where_clause = scoped.where.length
+            ? `WHERE ${scoped.where.join(' AND ')}`
+            : '';
         const source = this.db
             .prepare(`
-			SELECT
-				COUNT(*) as sources,
-				COALESCE(SUM(byte_count), 0) as bytes_stored,
-				COALESCE(SUM(returned_byte_count), 0) as bytes_returned
-			FROM context_sources
-		`)
-            .get();
+				SELECT
+					COUNT(*) as sources,
+					COALESCE(SUM(byte_count), 0) as bytes_stored,
+					COALESCE(SUM(returned_byte_count), 0) as bytes_returned,
+					MIN(created_at) as oldest_created_at,
+					MAX(created_at) as newest_created_at
+				FROM context_sources
+				${where_clause}
+			`)
+            .get(...scoped.params);
         const chunks = this.db
-            .prepare('SELECT COUNT(*) as chunks FROM context_chunks')
-            .get();
+            .prepare(`
+				SELECT COUNT(context_chunks.id) as chunks
+				FROM context_chunks
+				JOIN context_sources ON context_sources.id = context_chunks.source_id
+				${where_clause}
+			`)
+            .get(...scoped.params);
+        return { ...source, chunks: chunks.chunks };
+    }
+    stats(options = { global: true }) {
+        const source = this.count_stats(options);
+        const global = options.global
+            ? source
+            : this.count_stats({ global: true });
         const bytes_saved = source.bytes_stored - source.bytes_returned;
         const reduction_pct = source.bytes_stored > 0
             ? Math.round((bytes_saved / source.bytes_stored) * 1000) / 10
             : 0;
         const db_bytes = file_size(this.db_path);
         const wal_bytes = file_size(`${this.db_path}-wal`);
+        const policy = parse_context_retention_policy();
         return {
             sources: source.sources,
-            chunks: chunks.chunks,
+            chunks: source.chunks,
             bytes_stored: source.bytes_stored,
             bytes_returned: source.bytes_returned,
             bytes_saved,
@@ -436,21 +409,105 @@ export class ContextStore {
             db_bytes,
             wal_bytes,
             total_bytes: db_bytes + wal_bytes,
+            oldest_created_at: source.oldest_created_at,
+            newest_created_at: source.newest_created_at,
+            retention_days: policy.retention_days,
+            purge_on_shutdown: policy.purge_on_shutdown,
+            max_mb: policy.max_mb,
+            scope_project_path: options.global === true
+                ? null
+                : (options.project_path ?? null),
+            scope_session_id: options.global === true ? null : (options.session_id ?? null),
+            global_sources: global.sources,
+            global_chunks: global.chunks,
+            global_bytes_stored: global.bytes_stored,
+            global_oldest_created_at: global.oldest_created_at,
+            global_newest_created_at: global.newest_created_at,
+        };
+    }
+    cleanup(policy = parse_context_retention_policy()) {
+        let age_deleted = 0;
+        if (policy.retention_days !== null) {
+            age_deleted = this.purge({
+                older_than_days: policy.retention_days,
+            });
+        }
+        const size_deleted = policy.max_bytes
+            ? this.purge_to_max_stored_bytes(policy.max_bytes)
+            : 0;
+        return {
+            deleted: age_deleted + size_deleted,
+            age_deleted,
+            size_deleted,
+            policy,
         };
     }
+    purge_to_max_stored_bytes(max_bytes) {
+        const total_row = this.db
+            .prepare('SELECT COALESCE(SUM(byte_count), 0) as bytes FROM context_sources')
+            .get();
+        let total = total_row.bytes;
+        if (total <= max_bytes)
+            return 0;
+        const rows = this.db
+            .prepare('SELECT id, byte_count FROM context_sources ORDER BY created_at ASC')
+            .all();
+        const delete_source = this.db.prepare('DELETE FROM context_sources WHERE id = ?');
+        let deleted = 0;
+        for (const row of rows) {
+            if (total <= max_bytes)
+                break;
+            const result = delete_source.run(row.id);
+            if (Number(result.changes ?? 0) > 0) {
+                deleted += 1;
+                total -= row.byte_count;
+            }
+        }
+        return deleted;
+    }
     purge(options = {}) {
+        return this.purge_with_details(options).deleted;
+    }
+    purge_with_details(options = {}) {
+        const filters = [];
+        const params = [];
         if (options.source_id) {
-            const result = this.db
-                .prepare('DELETE FROM context_sources WHERE id = ?')
-                .run(options.source_id);
-            return Number(result.changes ?? 0);
+            filters.push('id = ?');
+            params.push(options.source_id);
+        }
+        if (options.project_path === null) {
+            filters.push('project_path IS NULL');
+        }
+        else if (options.project_path !== undefined) {
+            filters.push('project_path = ?');
+            params.push(options.project_path);
+        }
+        if (options.session_id === null) {
+            filters.push('session_id IS NULL');
+        }
+        else if (options.session_id !== undefined) {
+            filters.push('session_id = ?');
+            params.push(options.session_id);
+        }
+        const days = options.older_than_days;
+        if (days !== undefined) {
+            const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
+            filters.push('created_at < ?');
+            params.push(cutoff);
+        }
+        if (filters.length === 0) {
+            return { deleted: 0 };
         }
-        const days = options.older_than_days ?? 14;
-        const cutoff = Date.now() - days * 24 * 60 * 60 * 1000;
         const result = this.db
-            .prepare('DELETE FROM context_sources WHERE created_at < ?')
-            .run(cutoff);
-        return Number(result.changes ?? 0);
+            .prepare(`DELETE FROM context_sources WHERE ${filters.join(' AND ')}`)
+            .run(...params);
+        return {
+            deleted: Number(result.changes ?? 0),
+            source_id: options.source_id,
+            project_path: options.project_path,
+            session_id: options.session_id,
+            older_than_days: options.older_than_days,
+        };
     }
     close() {
         this.db.close();