opencode-memory-plugin 0.1.0

package/dist/storage/store.js

@@ -0,0 +1,1025 @@
+import { and, desc, eq, inArray, lte, gte, sql } from "drizzle-orm";
+import { deletionLog, observations, pendingMessages, sessionSummaries, toolUsageStats, userPrompts, } from "./schema";
+import { createSortableId, parseJsonValue, sanitizeFtsQuery, serializeJson } from "../utils";
+/**
+ * Provides project-scoped persistence and retrieval operations for the memory plugin.
+ */
+export class MemoryStore {
+    database;
+    scope;
+    now;
+    constructor(database, scope, now) {
+        this.database = database;
+        this.scope = scope;
+        this.now = now;
+    }
+    /**
+     * Closes the underlying SQLite connection.
+     *
+     * @returns Nothing.
+     */
+    close() {
+        this.database.sqlite.close();
+    }
+    /**
+     * Persists a compressed observation.
+     *
+     * @param observation - Observation to save.
+     * @returns A promise that resolves after insertion.
+     */
+    async saveObservation(observation) {
+        this.database.db.insert(observations).values({
+            id: observation.id,
+            projectId: observation.projectId,
+            projectRoot: observation.projectRoot,
+            sessionId: observation.sessionId,
+            type: observation.type,
+            title: observation.title,
+            subtitle: observation.subtitle,
+            narrative: observation.narrative,
+            facts: serializeJson(observation.facts),
+            concepts: serializeJson(observation.concepts),
+            filesInvolved: serializeJson(observation.filesInvolved),
+            rawTokenCount: observation.rawTokenCount,
+            compressedTokenCount: observation.compressedTokenCount,
+            toolName: observation.toolName,
+            modelUsed: observation.modelUsed,
+            quality: observation.quality,
+            rawFallback: observation.rawFallback,
+            createdAt: observation.createdAt,
+        }).run();
+    }
+    /**
+     * Retrieves a single observation by identifier.
+     *
+     * @param id - Observation identifier.
+     * @returns The observation or null.
+     */
+    async getObservation(id) {
+        const row = this.database.db
+            .select()
+            .from(observations)
+            .where(and(eq(observations.id, id), eq(observations.projectId, this.scope.projectId)))
+            .get();
+        return row ? mapObservation(row) : null;
+    }
+    /**
+     * Retrieves multiple observations in a single query.
+     *
+     * @param ids - Observation identifiers.
+     * @returns Matching observations.
+     */
+    async getObservationsBatch(ids) {
+        if (!ids.length) {
+            return [];
+        }
+        const rows = this.database.db
+            .select()
+            .from(observations)
+            .where(and(inArray(observations.id, ids), eq(observations.projectId, this.scope.projectId)))
+            .orderBy(desc(observations.createdAt))
+            .all();
+        return rows.map(mapObservation);
+    }
+    /**
+     * Retrieves the most recent observations for the current project.
+     *
+     * @param limit - Maximum number of rows.
+     * @returns Recent observations ordered from newest to oldest.
+     */
+    async getRecentObservations(limit) {
+        const rows = this.database.db
+            .select()
+            .from(observations)
+            .where(eq(observations.projectId, this.scope.projectId))
+            .orderBy(desc(observations.createdAt))
+            .limit(limit)
+            .all();
+        return rows.map(mapObservation);
+    }
+    /**
+     * Retrieves all observations recorded for a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns Observations ordered from oldest to newest.
+     */
+    async getSessionObservations(sessionId) {
+        const rows = this.database.db
+            .select()
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), eq(observations.sessionId, sessionId)))
+            .orderBy(observations.createdAt)
+            .all();
+        return rows.map(mapObservation);
+    }
+    /**
+     * Returns the total number of stored observations for the current project.
+     *
+     * @returns Observation count.
+     */
+    async countObservations() {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(eq(observations.projectId, this.scope.projectId))
+            .get();
+        return row?.value ?? 0;
+    }
+    /**
+     * Adds a pending raw tool result to the crash-safe queue.
+     *
+     * @param pendingMessage - Pending message payload.
+     * @returns A promise that resolves after insertion.
+     */
+    async enqueuePending(pendingMessage) {
+        this.database.db.insert(pendingMessages).values({
+            id: pendingMessage.id,
+            projectId: pendingMessage.projectId,
+            projectRoot: pendingMessage.projectRoot,
+            sessionId: pendingMessage.sessionId,
+            toolName: pendingMessage.toolName,
+            title: pendingMessage.title,
+            rawContent: pendingMessage.rawContent,
+            rawMetadata: pendingMessage.rawMetadata ? serializeJson(pendingMessage.rawMetadata) : null,
+            status: pendingMessage.status,
+            retryCount: pendingMessage.retryCount,
+            errorMessage: pendingMessage.errorMessage,
+            createdAt: pendingMessage.createdAt,
+            processedAt: pendingMessage.processedAt,
+        }).run();
+    }
+    /**
+     * Fetches pending messages by status.
+     *
+     * @param statuses - Accepted queue statuses.
+     * @param limit - Maximum number of rows.
+     * @returns Matching pending messages.
+     */
+    async getPendingMessages(statuses, limit) {
+        const rows = this.database.db
+            .select()
+            .from(pendingMessages)
+            .where(and(eq(pendingMessages.projectId, this.scope.projectId), inArray(pendingMessages.status, statuses)))
+            .orderBy(pendingMessages.createdAt)
+            .limit(limit)
+            .all();
+        return rows.map(mapPendingMessage);
+    }
+    /**
+     * Finds queue items that were left in processing state past the orphan threshold.
+     *
+     * @param orphanThresholdMs - Threshold in milliseconds.
+     * @returns Orphaned pending messages.
+     */
+    async getOrphanedMessages(orphanThresholdMs) {
+        const cutoff = this.now() - orphanThresholdMs;
+        const rows = this.database.db
+            .select()
+            .from(pendingMessages)
+            .where(and(eq(pendingMessages.projectId, this.scope.projectId), eq(pendingMessages.status, "processing"), lte(pendingMessages.createdAt, cutoff)))
+            .orderBy(pendingMessages.createdAt)
+            .all();
+        return rows.map(mapPendingMessage);
+    }
+    /**
+     * Updates the status for a queued message.
+     *
+     * @param id - Pending message identifier.
+     * @param status - Next queue status.
+     * @param retryCount - Updated retry count.
+     * @param errorMessage - Optional error message.
+     * @returns A promise that resolves after the update.
+     */
+    async updatePendingStatus(id, status, retryCount, errorMessage) {
+        this.database.db
+            .update(pendingMessages)
+            .set({
+            status,
+            retryCount,
+            errorMessage,
+            processedAt: status === "processed" ? this.now() : null,
+        })
+            .where(and(eq(pendingMessages.id, id), eq(pendingMessages.projectId, this.scope.projectId)))
+            .run();
+    }
+    /**
+     * Counts queued items for a specific session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns Queue size for that session.
+     */
+    async countPendingForSession(sessionId) {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(pendingMessages)
+            .where(and(eq(pendingMessages.projectId, this.scope.projectId), eq(pendingMessages.sessionId, sessionId), inArray(pendingMessages.status, ["pending", "processing"])))
+            .get();
+        return row?.value ?? 0;
+    }
+    /**
+     * Saves or replaces a session summary.
+     *
+     * @param summary - Summary payload.
+     * @returns A promise that resolves after persistence.
+     */
+    async saveSessionSummary(summary) {
+        this.database.db
+            .insert(sessionSummaries)
+            .values({
+            id: summary.id,
+            projectId: summary.projectId,
+            projectRoot: summary.projectRoot,
+            sessionId: summary.sessionId,
+            requested: summary.requested,
+            investigated: summary.investigated,
+            learned: summary.learned,
+            completed: summary.completed,
+            nextSteps: summary.nextSteps,
+            observationCount: summary.observationCount,
+            modelUsed: summary.modelUsed,
+            createdAt: summary.createdAt,
+        })
+            .onConflictDoUpdate({
+            target: [sessionSummaries.projectId, sessionSummaries.sessionId],
+            set: {
+                requested: summary.requested,
+                investigated: summary.investigated,
+                learned: summary.learned,
+                completed: summary.completed,
+                nextSteps: summary.nextSteps,
+                observationCount: summary.observationCount,
+                modelUsed: summary.modelUsed,
+                createdAt: summary.createdAt,
+            },
+        })
+            .run();
+    }
+    /**
+     * Retrieves the latest summary for a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns The stored summary or null.
+     */
+    async getSessionSummary(sessionId) {
+        const row = this.database.db
+            .select()
+            .from(sessionSummaries)
+            .where(and(eq(sessionSummaries.projectId, this.scope.projectId), eq(sessionSummaries.sessionId, sessionId)))
+            .get();
+        return row ? mapSessionSummary(row) : null;
+    }
+    /**
+     * Retrieves the most recent summaries for the current project.
+     *
+     * @param limit - Maximum number of summaries.
+     * @returns Recent summaries ordered from newest to oldest.
+     */
+    async getRecentSummaries(limit) {
+        const rows = this.database.db
+            .select()
+            .from(sessionSummaries)
+            .where(eq(sessionSummaries.projectId, this.scope.projectId))
+            .orderBy(desc(sessionSummaries.createdAt))
+            .limit(limit)
+            .all();
+        return rows.map(mapSessionSummary);
+    }
+    /**
+     * Stores a user prompt for later summarization and retrieval.
+     *
+     * @param prompt - Prompt payload.
+     * @returns A promise that resolves after insertion.
+     */
+    async saveUserPrompt(prompt) {
+        this.database.db
+            .insert(userPrompts)
+            .values({
+            id: prompt.id,
+            projectId: prompt.projectId,
+            projectRoot: prompt.projectRoot,
+            sessionId: prompt.sessionId,
+            messageId: prompt.messageId,
+            content: prompt.content,
+            createdAt: prompt.createdAt,
+        })
+            .onConflictDoNothing({ target: userPrompts.messageId })
+            .run();
+    }
+    /**
+     * Returns prompts associated with a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns Session prompts ordered from oldest to newest.
+     */
+    async getSessionUserPrompts(sessionId) {
+        const rows = this.database.db
+            .select()
+            .from(userPrompts)
+            .where(and(eq(userPrompts.projectId, this.scope.projectId), eq(userPrompts.sessionId, sessionId)))
+            .orderBy(userPrompts.createdAt)
+            .all();
+        return rows.map(mapUserPrompt);
+    }
+    /**
+     * Searches observations through the FTS5 index.
+     *
+     * @param query - User-entered search text.
+     * @param limit - Maximum number of results.
+     * @param typeFilter - Optional observation type filter.
+     * @returns Compact search results.
+     */
+    async searchFTS(query, limit, typeFilter) {
+        const match = sanitizeFtsQuery(query);
+        if (!match) {
+            return [];
+        }
+        const sqlText = `
+      SELECT
+        o.id,
+        o.title,
+        o.subtitle,
+        o.type,
+        o.created_at,
+        o.tool_name,
+        o.quality
+      FROM observations_fts f
+      JOIN observations o ON o.rowid = f.rowid
+      WHERE observations_fts MATCH ?
+        AND o.project_id = ?
+        ${typeFilter ? "AND o.type = ?" : ""}
+      ORDER BY bm25(observations_fts), o.created_at DESC
+      LIMIT ?
+    `;
+        const parameters = typeFilter
+            ? [match, this.scope.projectId, typeFilter, limit]
+            : [match, this.scope.projectId, limit];
+        const rows = this.database.sqlite.query(sqlText).all(...parameters);
+        return rows.map((row) => ({
+            id: row.id,
+            title: row.title,
+            subtitle: row.subtitle,
+            type: row.type,
+            createdAt: row.created_at,
+            toolName: row.tool_name,
+            quality: row.quality,
+        }));
+    }
+    /**
+     * Retrieves a timeline page for the current project.
+     *
+     * @param query - Timeline filters and pagination options.
+     * @returns Timeline page with the next cursor.
+     */
+    async getTimeline(query) {
+        const conditions = [eq(observations.projectId, this.scope.projectId)];
+        if (query.before) {
+            conditions.push(lte(observations.createdAt, query.before));
+        }
+        if (query.after) {
+            conditions.push(sql `${observations.createdAt} >= ${query.after}`);
+        }
+        if (query.sessionId) {
+            conditions.push(eq(observations.sessionId, query.sessionId));
+        }
+        const rows = this.database.db
+            .select()
+            .from(observations)
+            .where(and(...conditions))
+            .orderBy(desc(observations.createdAt))
+            .limit(query.limit + 1)
+            .all()
+            .map(mapObservation);
+        const hasMore = rows.length > query.limit;
+        const observationsPage = hasMore ? rows.slice(0, query.limit) : rows;
+        const lastObservation = observationsPage.at(-1) ?? null;
+        return {
+            observations: observationsPage,
+            nextCursor: hasMore && lastObservation ? String(lastObservation.createdAt - 1) : null,
+        };
+    }
+    /**
+     * Determines whether a session has new activity after its current summary.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns True when a summary refresh is needed.
+     */
+    async hasSessionActivityAfterSummary(sessionId) {
+        const summary = await this.getSessionSummary(sessionId);
+        if (!summary) {
+            const observationCount = await this.countSessionObservations(sessionId);
+            const promptCount = await this.countSessionPrompts(sessionId);
+            return observationCount > 0 || promptCount > 0;
+        }
+        const lastObservation = this.getLastTimestamp(this.database.sqlite, "observations", sessionId, this.scope.projectId);
+        const lastPrompt = this.getLastTimestamp(this.database.sqlite, "user_prompts", sessionId, this.scope.projectId);
+        const lastActivity = Math.max(lastObservation, lastPrompt);
+        return lastActivity > summary.createdAt;
+    }
+    /**
+     * Counts observations for a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns Observation count.
+     */
+    async countSessionObservations(sessionId) {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), eq(observations.sessionId, sessionId)))
+            .get();
+        return row?.value ?? 0;
+    }
+    /**
+     * Counts prompts for a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns Prompt count.
+     */
+    async countSessionPrompts(sessionId) {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(userPrompts)
+            .where(and(eq(userPrompts.projectId, this.scope.projectId), eq(userPrompts.sessionId, sessionId)))
+            .get();
+        return row?.value ?? 0;
+    }
+    /**
+     * Deletes a set of observations by identifier.
+     *
+     * @param ids - Observation identifiers.
+     * @returns Number of deleted observations.
+     */
+    async deleteObservations(ids) {
+        if (!ids.length) {
+            return 0;
+        }
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), inArray(observations.id, ids)))
+            .get();
+        const count = row?.value ?? 0;
+        if (!count) {
+            return 0;
+        }
+        this.database.db
+            .delete(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), inArray(observations.id, ids)))
+            .run();
+        return count;
+    }
+    /**
+     * Deletes observations that match an FTS query.
+     *
+     * @param ftsQuery - Raw user query.
+     * @returns Number of deleted observations.
+     */
+    async deleteByQuery(ftsQuery) {
+        const match = sanitizeFtsQuery(ftsQuery);
+        if (!match) {
+            return 0;
+        }
+        const rows = this.database.sqlite
+            .query(`
+          SELECT o.id
+          FROM observations_fts f
+          JOIN observations o ON o.rowid = f.rowid
+          WHERE observations_fts MATCH ?
+            AND o.project_id = ?
+        `)
+            .all(match, this.scope.projectId);
+        return this.deleteObservations(rows.map((row) => row.id));
+    }
+    /**
+     * Deletes all observations and summary for a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @returns Number of deleted observations.
+     */
+    async deleteBySession(sessionId) {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), eq(observations.sessionId, sessionId)))
+            .get();
+        const count = row?.value ?? 0;
+        this.database.db
+            .delete(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), eq(observations.sessionId, sessionId)))
+            .run();
+        this.database.db
+            .delete(sessionSummaries)
+            .where(and(eq(sessionSummaries.projectId, this.scope.projectId), eq(sessionSummaries.sessionId, sessionId)))
+            .run();
+        return count;
+    }
+    /**
+     * Deletes observations created before or at a given date.
+     *
+     * @param date - Cutoff date.
+     * @returns Number of deleted observations.
+     */
+    async deleteBefore(date) {
+        const cutoff = date.getTime();
+        if (!Number.isFinite(cutoff)) {
+            return 0;
+        }
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), lte(observations.createdAt, cutoff)))
+            .get();
+        const count = row?.value ?? 0;
+        if (!count) {
+            return 0;
+        }
+        this.database.db
+            .delete(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), lte(observations.createdAt, cutoff)))
+            .run();
+        return count;
+    }
+    /**
+     * Stores a deletion audit log entry.
+     *
+     * @param criteria - JSON criteria description.
+     * @param count - Deleted observation count.
+     * @param initiator - Operation initiator.
+     * @returns A promise that resolves after insertion.
+     */
+    async logDeletion(criteria, count, initiator) {
+        this.database.db.insert(deletionLog).values({
+            id: this.createId(),
+            projectId: this.scope.projectId,
+            projectRoot: this.scope.projectRoot,
+            timestamp: this.now(),
+            criteria,
+            count,
+            initiator,
+        }).run();
+    }
+    /**
+     * Increments tool usage counters for a session.
+     *
+     * @param sessionId - OpenCode session identifier.
+     * @param toolName - Tool name.
+     * @returns A promise that resolves after update.
+     */
+    async incrementToolUsage(sessionId, toolName) {
+        const existing = this.database.db
+            .select({ id: toolUsageStats.id, callCount: toolUsageStats.callCount })
+            .from(toolUsageStats)
+            .where(and(eq(toolUsageStats.projectId, this.scope.projectId), eq(toolUsageStats.sessionId, sessionId), eq(toolUsageStats.toolName, toolName)))
+            .get();
+        if (!existing) {
+            this.database.db.insert(toolUsageStats).values({
+                id: this.createId(),
+                projectId: this.scope.projectId,
+                projectRoot: this.scope.projectRoot,
+                sessionId,
+                toolName,
+                callCount: 1,
+                createdAt: this.now(),
+            }).run();
+            return;
+        }
+        this.database.db
+            .update(toolUsageStats)
+            .set({
+            callCount: existing.callCount + 1,
+            createdAt: this.now(),
+        })
+            .where(eq(toolUsageStats.id, existing.id))
+            .run();
+    }
+    /**
+     * Retrieves tool usage stats from the last N days.
+     *
+     * @param days - Lookback window in days.
+     * @returns Matching tool usage rows.
+     */
+    async getToolUsageStats(days) {
+        const cutoff = this.now() - Math.max(1, days) * 86_400_000;
+        const rows = this.database.db
+            .select()
+            .from(toolUsageStats)
+            .where(and(eq(toolUsageStats.projectId, this.scope.projectId), gte(toolUsageStats.createdAt, cutoff)))
+            .orderBy(desc(toolUsageStats.createdAt))
+            .all();
+        return rows.map(mapToolUsageStat);
+    }
+    /**
+     * Returns observation quality distribution counts.
+     *
+     * @returns Quality counts by bucket.
+     */
+    async getQualityDistribution() {
+        const rows = this.database.sqlite
+            .query(`
+          SELECT quality, COUNT(*) AS value
+          FROM observations
+          WHERE project_id = ?
+          GROUP BY quality
+        `)
+            .all(this.scope.projectId);
+        const distribution = {
+            high: 0,
+            medium: 0,
+            low: 0,
+        };
+        for (const row of rows) {
+            if (row.quality === "high" || row.quality === "medium" || row.quality === "low") {
+                distribution[row.quality] = row.value;
+            }
+        }
+        return distribution;
+    }
+    /**
+     * Returns success metrics for a compression model.
+     *
+     * @param modelName - Model identifier.
+     * @returns Total, success and rate values.
+     */
+    async getModelSuccessRate(modelName) {
+        const totalRow = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), eq(observations.modelUsed, modelName)))
+            .get();
+        const successRow = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), eq(observations.modelUsed, modelName), inArray(observations.quality, ["high", "medium"])))
+            .get();
+        const total = totalRow?.value ?? 0;
+        const success = successRow?.value ?? 0;
+        return {
+            total,
+            success,
+            rate: total > 0 ? success / total : 0,
+        };
+    }
+    /**
+     * Searches observations within a date range.
+     *
+     * @param from - Range start.
+     * @param to - Range end.
+     * @param limit - Maximum number of rows.
+     * @returns Matching observations.
+     */
+    async searchByDateRange(from, to, limit) {
+        const fromTimestamp = from.getTime();
+        const toTimestamp = to.getTime();
+        if (!Number.isFinite(fromTimestamp) || !Number.isFinite(toTimestamp)) {
+            return [];
+        }
+        const start = Math.min(fromTimestamp, toTimestamp);
+        const end = Math.max(fromTimestamp, toTimestamp);
+        const rows = this.database.db
+            .select()
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), gte(observations.createdAt, start), lte(observations.createdAt, end)))
+            .orderBy(desc(observations.createdAt))
+            .limit(Math.max(1, limit))
+            .all();
+        return rows.map(mapObservation);
+    }
+    /**
+     * Searches observations by matching file paths against the FTS index.
+     *
+     * @param filePaths - File path patterns.
+     * @returns Matching observations.
+     */
+    async searchByFiles(filePaths) {
+        const matches = filePaths
+            .map((filePath) => sanitizeFtsQuery(filePath))
+            .filter(Boolean);
+        if (!matches.length) {
+            return [];
+        }
+        const matchQuery = matches.map((value) => `(${value})`).join(" OR ");
+        const rows = this.database.sqlite
+            .query(`
+          SELECT o.id
+          FROM observations_fts f
+          JOIN observations o ON o.rowid = f.rowid
+          WHERE observations_fts MATCH ?
+            AND o.project_id = ?
+          ORDER BY bm25(observations_fts), o.created_at DESC
+          LIMIT 200
+        `)
+            .all(matchQuery, this.scope.projectId);
+        return this.getObservationsBatch(rows.map((row) => row.id));
+    }
+    /**
+     * Returns the number of summaries for the current project.
+     *
+     * @returns Summary count.
+     */
+    async countSessionSummaries() {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(sessionSummaries)
+            .where(eq(sessionSummaries.projectId, this.scope.projectId))
+            .get();
+        return row?.value ?? 0;
+    }
+    /**
+     * Returns pending queue counts grouped by status.
+     *
+     * @returns Status count object.
+     */
+    async getPendingStatusCounts() {
+        const rows = this.database.sqlite
+            .query(`
+          SELECT status, COUNT(*) AS value
+          FROM pending_messages
+          WHERE project_id = ?
+          GROUP BY status
+        `)
+            .all(this.scope.projectId);
+        const counts = {
+            pending: 0,
+            processing: 0,
+            processed: 0,
+            failed: 0,
+        };
+        for (const row of rows) {
+            if (row.status in counts) {
+                counts[row.status] = row.value;
+            }
+        }
+        return counts;
+    }
+    /**
+     * Counts observations since a timestamp.
+     *
+     * @param timestamp - Lower bound timestamp.
+     * @returns Observation count.
+     */
+    async countObservationsSince(timestamp) {
+        const row = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), gte(observations.createdAt, timestamp)))
+            .get();
+        return row?.value ?? 0;
+    }
+    /**
+     * Calculates compression ratio and last compression timestamp.
+     *
+     * @returns Compression summary values.
+     */
+    async getCompressionStats() {
+        const row = this.database.sqlite
+            .query(`
+          SELECT
+            AVG(CASE WHEN compressed_token_count > 0 THEN CAST(raw_token_count AS REAL) / compressed_token_count END) AS average_ratio,
+            MAX(created_at) AS last_compressed_at
+          FROM observations
+          WHERE project_id = ?
+        `)
+            .get(this.scope.projectId);
+        return {
+            averageRatio: row?.average_ratio ?? 0,
+            lastCompressedAt: row?.last_compressed_at ?? null,
+        };
+    }
+    /**
+     * Returns deletion log totals for a lookback window.
+     *
+     * @param days - Lookback in days.
+     * @returns Operation and deletion totals.
+     */
+    async getDeletionStats(days) {
+        const cutoff = this.now() - Math.max(1, days) * 86_400_000;
+        const row = this.database.sqlite
+            .query(`
+          SELECT COUNT(*) AS operations, COALESCE(SUM(count), 0) AS removed
+          FROM deletion_log
+          WHERE project_id = ?
+            AND timestamp >= ?
+        `)
+            .get(this.scope.projectId, cutoff);
+        return {
+            operations: row?.operations ?? 0,
+            removed: row?.removed ?? 0,
+        };
+    }
+    /**
+     * Returns the current SQLite database size in bytes.
+     *
+     * @returns Database file size estimate.
+     */
+    async getDatabaseSizeBytes() {
+        const row = this.database.sqlite
+            .query("SELECT page_count AS page_count, page_size AS page_size FROM pragma_page_count(), pragma_page_size()")
+            .get();
+        if (!row) {
+            return 0;
+        }
+        return row.page_count * row.page_size;
+    }
+    /**
+     * Returns deletion log entries from the last N days.
+     *
+     * @param days - Lookback window in days.
+     * @returns Matching deletion entries.
+     */
+    async getDeletionLog(days) {
+        const cutoff = this.now() - Math.max(1, days) * 86_400_000;
+        const rows = this.database.db
+            .select()
+            .from(deletionLog)
+            .where(and(eq(deletionLog.projectId, this.scope.projectId), gte(deletionLog.timestamp, cutoff)))
+            .orderBy(desc(deletionLog.timestamp))
+            .all();
+        return rows.map(mapDeletionLogEntry);
+    }
+    /**
+     * Deletes data older than the configured retention windows.
+     *
+     * @param retentionDays - Number of days to keep observations and prompts.
+     * @returns A promise that resolves after cleanup.
+     */
+    async cleanupOldData(retentionDays) {
+        const now = this.now();
+        const retentionCutoff = now - retentionDays * 86_400_000;
+        const pendingCutoff = now - 7 * 86_400_000;
+        const summaryCutoff = now - retentionDays * 2 * 86_400_000;
+        const observationDeleteRow = this.database.db
+            .select({ value: sql `count(*)` })
+            .from(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), lte(observations.createdAt, retentionCutoff)))
+            .get();
+        const observationDeleteCount = observationDeleteRow?.value ?? 0;
+        this.database.db
+            .delete(observations)
+            .where(and(eq(observations.projectId, this.scope.projectId), lte(observations.createdAt, retentionCutoff)))
+            .run();
+        if (observationDeleteCount > 0) {
+            await this.logDeletion(JSON.stringify({ type: "retention", target: "observations", before: retentionCutoff }), observationDeleteCount, "retention_cleanup");
+        }
+        this.database.db
+            .delete(userPrompts)
+            .where(and(eq(userPrompts.projectId, this.scope.projectId), lte(userPrompts.createdAt, retentionCutoff)))
+            .run();
+        this.database.db
+            .delete(sessionSummaries)
+            .where(and(eq(sessionSummaries.projectId, this.scope.projectId), lte(sessionSummaries.createdAt, summaryCutoff)))
+            .run();
+        this.database.db
+            .delete(pendingMessages)
+            .where(and(eq(pendingMessages.projectId, this.scope.projectId), inArray(pendingMessages.status, ["processed", "failed"]), lte(pendingMessages.createdAt, pendingCutoff)))
+            .run();
+        this.database.sqlite.exec("VACUUM");
+    }
+    /**
+     * Creates a new project-scoped record identifier.
+     *
+     * @returns A sortable identifier.
+     */
+    createId() {
+        return createSortableId(this.now);
+    }
+    /**
+     * Returns the last activity timestamp for a table and session.
+     *
+     * @param sqlite - SQLite client.
+     * @param tableName - Table to inspect.
+     * @param sessionId - OpenCode session identifier.
+     * @param projectId - Current project identifier.
+     * @returns The last timestamp or zero.
+     */
+    getLastTimestamp(sqlite, tableName, sessionId, projectId) {
+        const row = sqlite
+            .query(`SELECT MAX(created_at) AS value FROM ${tableName} WHERE project_id = ? AND session_id = ?`)
+            .get(projectId, sessionId);
+        return row?.value ?? 0;
+    }
+}
+/**
+ * Maps an observation row into the runtime shape.
+ *
+ * @param row - Database row.
+ * @returns Normalized observation.
+ */
+export function mapObservation(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        projectRoot: row.projectRoot,
+        sessionId: row.sessionId,
+        type: row.type,
+        title: row.title,
+        subtitle: row.subtitle ?? null,
+        narrative: row.narrative,
+        facts: parseJsonValue(row.facts, []),
+        concepts: parseJsonValue(row.concepts, []),
+        filesInvolved: parseJsonValue(row.filesInvolved, []),
+        rawTokenCount: row.rawTokenCount,
+        compressedTokenCount: row.compressedTokenCount,
+        toolName: row.toolName ?? null,
+        modelUsed: row.modelUsed ?? null,
+        quality: row.quality ?? "high",
+        rawFallback: row.rawFallback ?? null,
+        createdAt: row.createdAt,
+    };
+}
+/**
+ * Maps a pending queue row into the runtime shape.
+ *
+ * @param row - Database row.
+ * @returns Normalized pending message.
+ */
+export function mapPendingMessage(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        projectRoot: row.projectRoot,
+        sessionId: row.sessionId,
+        toolName: row.toolName,
+        title: row.title ?? null,
+        rawContent: row.rawContent,
+        rawMetadata: parseJsonValue(row.rawMetadata, null),
+        status: row.status,
+        retryCount: row.retryCount,
+        errorMessage: row.errorMessage ?? null,
+        createdAt: row.createdAt,
+        processedAt: row.processedAt ?? null,
+    };
+}
+/**
+ * Maps a summary row into the runtime shape.
+ *
+ * @param row - Database row.
+ * @returns Normalized session summary.
+ */
+export function mapSessionSummary(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        projectRoot: row.projectRoot,
+        sessionId: row.sessionId,
+        requested: row.requested ?? null,
+        investigated: row.investigated ?? null,
+        learned: row.learned ?? null,
+        completed: row.completed ?? null,
+        nextSteps: row.nextSteps ?? null,
+        observationCount: row.observationCount,
+        modelUsed: row.modelUsed ?? null,
+        createdAt: row.createdAt,
+    };
+}
+/**
+ * Maps a prompt row into the runtime shape.
+ *
+ * @param row - Database row.
+ * @returns Normalized user prompt.
+ */
+export function mapUserPrompt(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        projectRoot: row.projectRoot,
+        sessionId: row.sessionId,
+        messageId: row.messageId,
+        content: row.content,
+        createdAt: row.createdAt,
+    };
+}
+/**
+ * Maps a deletion log row into the runtime shape.
+ *
+ * @param row - Database row.
+ * @returns Normalized deletion log entry.
+ */
+export function mapDeletionLogEntry(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        projectRoot: row.projectRoot,
+        timestamp: row.timestamp,
+        criteria: row.criteria,
+        count: row.count,
+        initiator: row.initiator,
+    };
+}
+/**
+ * Maps a tool usage stats row into the runtime shape.
+ *
+ * @param row - Database row.
+ * @returns Normalized tool usage stats entry.
+ */
+export function mapToolUsageStat(row) {
+    return {
+        id: row.id,
+        projectId: row.projectId,
+        projectRoot: row.projectRoot,
+        sessionId: row.sessionId,
+        toolName: row.toolName,
+        callCount: row.callCount,
+        createdAt: row.createdAt,
+    };
+}
+//# sourceMappingURL=store.js.map