pi-mega-compact 0.20.79 → 0.20.80

package/dist/extensions/dashboard-server/routes-rag-settings-helpers.js

@@ -62,6 +62,7 @@ export const SETTINGS = [
             boolDirect("MEGACOMPACT_AUTO_WIKI", "Auto Wiki", "Auto-categorizing wiki (k-means + TF-IDF)", true),
             boolDirect("MEGACOMPACT_WIKI_SEED_FROM_TURNS", "Wiki Seed from Turns", "Seed topic model from raw_transcript when chunks thin", true),
             boolDirect("MEGACOMPACT_TURNS_DB", "Turns DB", "Isolated turns.db store", true),
+            boolDirect("MEGACOMPACT_PROVIDER_MODEL_ANALYTICS", "Provider/Model Analytics", "Capture provider/model analytics in analytics.db", true),
             num("MEGACOMPACT_WIKI_SILHOUETTE_MIN", "Silhouette Minimum", "Full rebuild trigger threshold", 0.2, 0, 1),
             num("MEGACOMPACT_TURNS_RETENTION_DAYS", "Turn Retention", "Per-turn provenance retention window", 30, 1, 365, "days"),
             num("MEGACOMPACT_TURNS_KEEP_MIN", "Turns Keep Minimum", "Min turns kept per conversation during prune", 5, 1, 100),

package/dist/extensions/mega-config.js

@@ -160,6 +160,8 @@ export function loadConfig() {
         // turn path (S48 behavior). Mirrors src/config/turns.ts TURNS_DB_ENABLED.
         turnsDbEnabled: envBool("MEGACOMPACT_TURNS_DB", true),
         autoWikiEnabled: envBool("MEGACOMPACT_AUTO_WIKI", true),
+        // PMA: provider/model analytics (isolated analytics.db). Default ON.
+        providerModelAnalytics: envBool("MEGACOMPACT_PROVIDER_MODEL_ANALYTICS", true),
         crossRepoEnabled: envBool("MEGACOMPACT_CROSSREPO_ENABLED", true),
         crossRepoCosine: Number(process.env.MEGACOMPACT_CROSSREPO_COSINE ?? "0.90"),
         memoryAutoReview: envBool("MEGACOMPACT_MEMORY_AUTO_REVIEW", true),

package/dist/extensions/mega-events/analytics-handler.js

@@ -0,0 +1,169 @@
+import { createAnalyticsStore, closeAllAnalyticsDbs, } from "../../src/store/analytics/index.js";
+// ── Per-stateDir store cache (mirrors mega-turn-store.ts storeFor) ─────
+const stores = new Map();
+function storeFor(stateDir) {
+    let s = stores.get(stateDir);
+    if (!s) {
+        s = createAnalyticsStore({ stateDir });
+        stores.set(stateDir, s);
+    }
+    return s;
+}
+/** Close all cached analytics stores (test teardown / shutdown). */
+export function closeAnalyticsStores() {
+    closeAllAnalyticsDbs();
+    stores.clear();
+}
+const pmaTimings = new WeakMap();
+function getPma(rt) {
+    let s = pmaTimings.get(rt);
+    if (!s) {
+        s = { providerStart: 0, ttft: 0, correlationId: null };
+        pmaTimings.set(rt, s);
+    }
+    return s;
+}
+/** @internal Test-only accessor — production code uses getPma() in-module. */
+export function __pmaTimingForTest(rt) {
+    return getPma(rt);
+}
+function usageOf(msg) {
+    if (msg.role === "assistant" && msg.usage)
+        return msg.usage;
+    return null;
+}
+// ── Helpers ───────────────────────────────────────────────────────────
+/** Build a QualityNote with provider/model availability. */
+function qualityFor(provider, model) {
+    if (!provider || !model)
+        return { unavailable: true, note: "provider/model not captured" };
+    return {};
+}
+// ── Registration ──────────────────────────────────────────────────────
+/** Register the analytics event handlers. Flag-gated: OFF = complete no-op. */
+export function registerAnalyticsHandler(pi, runtime, config) {
+    if (!config.providerModelAnalytics)
+        return; // flag OFF — no DB, no handlers
+    // ── turn_start: stamp the request start + emit request_started ──────
+    pi.on("turn_start", async (event) => {
+        try {
+            const now = Date.now();
+            const corrId = `req_${runtime.rt.sessionId}_${event.turnIndex}`;
+            const pma = getPma(runtime);
+            pma.correlationId = corrId;
+            pma.providerStart = 0; // reset; stamped at before_provider_request
+            pma.ttft = 0;
+            const provider = runtime.currentModel?.provider;
+            const model = runtime.currentModel?.modelId;
+            const fact = {
+                id: `${corrId}_started`,
+                correlationId: corrId,
+                sessionId: runtime.rt.sessionId,
+                turnId: String(event.turnIndex),
+                eventKind: "request_started",
+                observedAt: now,
+                provider,
+                model,
+                source: "host_adapter",
+                quality: qualityFor(provider, model),
+            };
+            storeFor(runtime.currentStateDir).asWriter().appendRequestEvent(fact);
+        }
+        catch {
+            /* non-fatal: analytics never breaks the agent loop */
+        }
+    });
+    // ── before_provider_request: stamp provider start + emit provider_selected
+    pi.on("before_provider_request", async () => {
+        try {
+            const pma = getPma(runtime);
+            pma.providerStart = Date.now();
+            const corrId = pma.correlationId;
+            if (!corrId)
+                return;
+            const provider = runtime.currentModel?.provider;
+            const model = runtime.currentModel?.modelId;
+            const fact = {
+                id: `${corrId}_selected`,
+                correlationId: corrId,
+                sessionId: runtime.rt.sessionId,
+                eventKind: "provider_selected",
+                observedAt: pma.providerStart,
+                provider,
+                model,
+                source: "host_adapter",
+                quality: qualityFor(provider, model),
+            };
+            storeFor(runtime.currentStateDir).asWriter().appendRequestEvent(fact);
+        }
+        catch {
+            /* non-fatal */
+        }
+    });
+    // ── message_update: capture TTFT on first text token ────────────────
+    // Net-new seam — no existing handler registers message_update.
+    // Proven available in PMA-0 (agent-loop.js:201-227).
+    pi.on("message_update", async (event) => {
+        try {
+            const pma = getPma(runtime);
+            if (pma.ttft > 0)
+                return; // already captured this turn
+            if (pma.providerStart <= 0)
+                return; // no provider start stamp
+            const chunkType = event
+                .assistantMessageEvent?.type;
+            if (chunkType !== "text_start" && chunkType !== "text_delta")
+                return;
+            pma.ttft = Date.now() - pma.providerStart;
+        }
+        catch {
+            /* non-fatal */
+        }
+    });
+    // ── turn_end: emit terminal fact with tokens, latency, ttft, status ─
+    pi.on("turn_end", async (event) => {
+        try {
+            const pma = getPma(runtime);
+            const corrId = pma.correlationId;
+            if (!corrId)
+                return;
+            const now = Date.now();
+            const durationMs = runtime.perfTurnStart > 0 ? now - runtime.perfTurnStart : undefined;
+            const u = usageOf(event.message);
+            const stopReason = event.message.stopReason;
+            const provider = runtime.currentModel?.provider;
+            const model = runtime.currentModel?.modelId;
+            const isFailed = stopReason === "error" || stopReason === "aborted";
+            const eventKind = isFailed ? "request_failed" : "request_completed";
+            const fact = {
+                id: `${corrId}_${eventKind}`,
+                correlationId: corrId,
+                sessionId: runtime.rt.sessionId,
+                turnId: String(event.turnIndex),
+                eventKind,
+                observedAt: now,
+                provider,
+                model,
+                status: stopReason ?? undefined,
+                inputTokens: u?.input,
+                outputTokens: u?.output,
+                cacheReadTokens: u?.cacheRead,
+                cacheWriteTokens: u?.cacheWrite,
+                durationMs,
+                ttftMs: pma.ttft > 0 ? pma.ttft : undefined,
+                source: "host_adapter",
+                quality: {
+                    ...qualityFor(provider, model),
+                    ...(pma.ttft > 0 ? {} : { note: "TTFT not captured (no first-token event)" }),
+                },
+            };
+            storeFor(runtime.currentStateDir).asWriter().appendRequestEvent(fact);
+            // Reset per-turn state.
+            pma.correlationId = null;
+            pma.ttft = 0;
+        }
+        catch {
+            /* non-fatal */
+        }
+    });
+}

package/dist/extensions/mega-events/register.js

@@ -3,6 +3,7 @@ import { registerAgentHandlers } from "./agent-handlers.js";
 import { registerContextHandler } from "./context-handler.js";
 import { registerCompactHandlers } from "./compact-handlers.js";
 import { registerPerfHandler } from "./perf-handler.js";
+import { registerAnalyticsHandler } from "./analytics-handler.js";
 import { registerVectorCortexRender } from "../mega-context/vector-cortex.js";
 /**
  * DIAG accessor for the headless test harness: the most recently constructed
@@ -37,4 +38,6 @@ export function registerEventHandlers(pi, runtime, config) {
     registerContextHandler(pi, runtime, config);
     registerCompactHandlers(pi, runtime, config);
     registerPerfHandler(pi, runtime);
+    // PMA-2: analytics ingestion — flag-gated (OFF = no-op, no DB opened).
+    registerAnalyticsHandler(pi, runtime, config);
 }

package/dist/src/store/analytics/connection.js

@@ -0,0 +1,114 @@
+/**
+ * connection.ts — PMA-1 connection manager for analytics.db.
+ *
+ * Own module-level connection cache, deliberately SEPARATE from the main
+ * memory store (openStore) and the turns store (openTurnDb) so an analytics-DB
+ * failure can never touch the authoritative memory DB or the turns DB (PMA §3.1).
+ *
+ * Mirrors src/store/turns/connection.ts. PREVENT-PI-004: node:sqlite in-process,
+ * no network. PREVENT-002: parameterized path binding.
+ */
+import { existsSync, mkdirSync, statSync } from "node:fs";
+import { join } from "node:path";
+import { DatabaseSync as Db } from "node:sqlite";
+import { initAnalyticsSchema } from "./schema.js";
+export const ANALYTICS_DB_FILE = "analytics.db";
+/** Resolve the analytics DB path, honoring the env override. */
+export function analyticsDbPath(stateDir) {
+    const env = process.env.MEGACOMPACT_ANALYTICS_DB_PATH;
+    if (env && env.trim() !== "")
+        return env.trim();
+    return join(stateDir, ANALYTICS_DB_FILE);
+}
+// Module-private cache — separate from openStore's cache and turns' cache.
+const cache = new Map();
+/** File size helper (0 for in-memory). */
+function dbFileSize(dbPath) {
+    try {
+        return statSync(dbPath).size;
+    }
+    catch {
+        return 0;
+    }
+}
+/**
+ * Open (or reuse from cache) the analytics.db for `stateDir`.
+ * Sets PRAGMAs, initializes the schema, and caches the connection.
+ * In-memory mode (`:memory:`) is supported for tests.
+ */
+export function openAnalyticsDb(stateDir, options) {
+    const inMemory = options?.inMemory === true;
+    const resolvedPath = inMemory ? ":memory:" : (options?.dbPath ?? analyticsDbPath(stateDir));
+    const cacheKey = inMemory ? `:memory:${stateDir}` : resolvedPath;
+    const cached = cache.get(cacheKey);
+    if (cached) {
+        try {
+            cached.exec("SELECT 1");
+            return cached;
+        }
+        catch {
+            // Stale handle — evict and re-open.
+            cache.delete(cacheKey);
+        }
+    }
+    // Ensure the state dir exists for file-backed mode.
+    if (!inMemory && !existsSync(stateDir)) {
+        mkdirSync(stateDir, { recursive: true });
+    }
+    const db = inMemory ? new Db(":memory:") : new Db(resolvedPath);
+    db.exec("PRAGMA busy_timeout = 5000");
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    initAnalyticsSchema(db);
+    cache.set(cacheKey, db);
+    return db;
+}
+/** Close and evict the analytics DB for `stateDir` (idempotent). */
+export function closeAnalyticsDb(stateDir, options) {
+    const inMemory = options?.inMemory === true;
+    const resolvedPath = inMemory ? ":memory:" : (options?.dbPath ?? analyticsDbPath(stateDir));
+    const cacheKey = inMemory ? `:memory:${stateDir}` : resolvedPath;
+    const db = cache.get(cacheKey);
+    if (!db)
+        return;
+    try {
+        db.close();
+    }
+    catch {
+        /* already closed */
+    }
+    cache.delete(cacheKey);
+}
+/** Close ALL cached analytics DBs (test teardown / graceful shutdown). */
+export function closeAllAnalyticsDbs() {
+    for (const db of cache.values()) {
+        try {
+            db.close();
+        }
+        catch {
+            /* already closed */
+        }
+    }
+    cache.clear();
+}
+/** Report the file size of analytics.db for a state dir (0 if absent/in-memory). */
+export function analyticsDbSize(stateDir) {
+    return dbFileSize(analyticsDbPath(stateDir));
+}
+/**
+ * SAVEPOINT-based transaction wrapper (nests safely under an outer transaction).
+ * Uses a distinct savepoint name from the turns store (`turns_tx`) and the main
+ * store (`mc_tx`) to avoid collisions.
+ */
+export function withTx(db, fn) {
+    db.exec("SAVEPOINT analytics_tx");
+    try {
+        fn();
+        db.exec("RELEASE analytics_tx");
+    }
+    catch (e) {
+        db.exec("ROLLBACK TO analytics_tx");
+        db.exec("RELEASE analytics_tx");
+        throw e;
+    }
+}

package/dist/src/store/analytics/contract-compliance.test/_helpers.js

@@ -0,0 +1,39 @@
+let counter = 0;
+/** Create a valid RequestEventFact with sensible defaults + overrides. */
+export function makeRequestEvent(overrides = {}) {
+    return {
+        id: `evt_${++counter}`,
+        correlationId: "corr_test",
+        sessionId: "sess_test",
+        eventKind: "request_started",
+        observedAt: Date.now(),
+        provider: "anthropic",
+        model: "claude-sonnet-4",
+        source: "test",
+        quality: {},
+        ...overrides,
+    };
+}
+/** Create a valid MeasurementFact. */
+export function makeMeasurement(overrides = {}) {
+    return {
+        observedAt: Date.now(),
+        sampleKind: "cache_hit_pct",
+        value: 72.5,
+        unit: "percent",
+        source: "test",
+        quality: {},
+        ...overrides,
+    };
+}
+/** Create a valid IdentityObservation. */
+export function makeIdentity(overrides = {}) {
+    return {
+        observedAt: Date.now(),
+        provider: "anthropic",
+        model: "claude-sonnet-4",
+        source: "test",
+        metadata: { contextWindow: 200000 },
+        ...overrides,
+    };
+}

package/dist/src/store/analytics/index.js

@@ -0,0 +1,25 @@
+/**
+ * index.ts — Barrel for src/store/analytics/ (PMA-1).
+ *
+ * Hosts import types + the factory. SQL schemas + internals stay private.
+ *
+ * PREVENT-PI-004: no network. PREVENT-002: parameterized SQL only.
+ */
+export { SqliteAnalyticsStore } from "./sqlite-store.js";
+export { InMemoryAnalyticsStore } from "./memory-store.js";
+export { openAnalyticsDb, closeAnalyticsDb, closeAllAnalyticsDbs, analyticsDbPath, analyticsDbSize, ANALYTICS_DB_FILE, withTx, } from "./connection.js";
+export { initAnalyticsSchema, getAnalyticsSchemaVersion } from "./schema.js";
+import { SqliteAnalyticsStore } from "./sqlite-store.js";
+import { InMemoryAnalyticsStore } from "./memory-store.js";
+/**
+ * Factory: create an AnalyticsStore from options.
+ *
+ * - Default: SqliteAnalyticsStore backed by analytics.db in stateDir
+ * - inMemory: InMemoryAnalyticsStore (no file I/O)
+ */
+export function createAnalyticsStore(options) {
+    if (options.inMemory) {
+        return new InMemoryAnalyticsStore(options);
+    }
+    return new SqliteAnalyticsStore(options);
+}

package/dist/src/store/analytics/memory-store.js

@@ -0,0 +1,111 @@
+import { getAnalyticsSchemaVersion } from "./schema.js";
+export class InMemoryAnalyticsStore {
+    events = new Map();
+    measurements = [];
+    identities = [];
+    nextId = 1;
+    constructor(_options) {
+        // Options unused — the in-memory store doesn't open a DB.
+    }
+    allocId() {
+        return this.nextId++;
+    }
+    // ── AnalyticsReader ───────────────────────────────────────────────
+    status() {
+        const lastEvent = this.events.size > 0
+            ? Math.max(...[...this.events.values()].map((e) => e.observedAt))
+            : 0;
+        const lastMeas = this.measurements.length > 0
+            ? Math.max(...this.measurements.map((m) => m.observedAt))
+            : 0;
+        const lastId = this.identities.length > 0
+            ? Math.max(...this.identities.map((i) => i.observedAt))
+            : 0;
+        return {
+            enabled: true,
+            schemaVersion: getAnalyticsSchemaVersion(),
+            requestEventCount: this.events.size,
+            measurementCount: this.measurements.length,
+            identityCount: this.identities.length,
+            freshThrough: Math.max(lastEvent, lastMeas, lastId) || null,
+        };
+    }
+    // ── AnalyticsWriter ───────────────────────────────────────────────
+    appendRequestEvent(fact) {
+        if (this.events.has(fact.id)) {
+            return { status: "duplicate", id: fact.id };
+        }
+        this.events.set(fact.id, { ...fact });
+        return { status: "accepted", id: fact.id };
+    }
+    appendMeasurement(sample) {
+        const id = this.allocId();
+        this.measurements.push({ ...sample, id });
+        return { status: "accepted", id };
+    }
+    appendIdentity(observation) {
+        const id = this.allocId();
+        this.identities.push({ ...observation, id });
+        return { status: "accepted", id };
+    }
+    // ── AnalyticsAdmin ────────────────────────────────────────────────
+    prune(policy) {
+        const now = Date.now();
+        const eventCutoff = now - policy.maxEventAgeMs;
+        const measCutoff = now - policy.maxMeasurementAgeMs;
+        const beforeE = this.events.size;
+        const beforeM = this.measurements.length;
+        for (const [k, e] of this.events) {
+            if (e.observedAt < eventCutoff)
+                this.events.delete(k);
+        }
+        this.measurements = this.measurements.filter((m) => m.observedAt >= measCutoff);
+        return {
+            eventsRemoved: beforeE - this.events.size,
+            measurementsRemoved: beforeM - this.measurements.length,
+            identitiesRemoved: 0,
+            freedBytes: 0,
+        };
+    }
+    vacuum() {
+        return { ok: true, detail: "no-op for in-memory store" };
+    }
+    integrityCheck() {
+        return { ok: true, detail: "ok" };
+    }
+    backup() {
+        return { ok: false, detail: "Cannot backup an in-memory database" };
+    }
+    clear() {
+        this.events.clear();
+        this.measurements = [];
+        this.identities = [];
+        this.nextId = 1;
+    }
+    close() {
+        this.clear();
+    }
+    // ── Capability views ──────────────────────────────────────────────
+    asReader() {
+        return {
+            status: () => this.status(),
+        };
+    }
+    asWriter() {
+        return {
+            appendRequestEvent: (f) => this.appendRequestEvent(f),
+            appendMeasurement: (s) => this.appendMeasurement(s),
+            appendIdentity: (o) => this.appendIdentity(o),
+        };
+    }
+    asAdmin() {
+        return {
+            prune: (p) => this.prune(p),
+            vacuum: () => this.vacuum(),
+            integrityCheck: () => this.integrityCheck(),
+            backup: () => this.backup(),
+            clear: () => this.clear(),
+            close: () => this.close(),
+        };
+    }
+}

package/dist/src/store/analytics/schema.js

@@ -0,0 +1,108 @@
+const SCHEMA_VERSION = 1;
+/**
+ * Initialize the analytics.db schema. Safe to call on every open — every
+ * statement is CREATE IF NOT EXISTS.
+ */
+export function initAnalyticsSchema(db) {
+    // ── Lifecycle tables ──────────────────────────────────────────────
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS analytics_meta (
+			key   TEXT PRIMARY KEY,
+			value TEXT NOT NULL
+		)
+	`);
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS analytics_schema (
+			version    INTEGER PRIMARY KEY,
+			applied_at INTEGER NOT NULL,
+			digest     TEXT NOT NULL
+		)
+	`);
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS analytics_migrations (
+			id                TEXT PRIMARY KEY,
+			started_at        INTEGER NOT NULL,
+			completed_at      INTEGER,
+			source_fingerprint TEXT,
+			rows_copied       INTEGER,
+			status            TEXT NOT NULL,
+			detail            TEXT
+		)
+	`);
+    // ── Append-only fact tables ───────────────────────────────────────
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS request_events (
+			id                 TEXT PRIMARY KEY,
+			correlation_id     TEXT,
+			session_id         TEXT,
+			repo_id            TEXT,
+			turn_id            TEXT,
+			event_kind         TEXT NOT NULL CHECK(event_kind IN (
+				'request_started',
+				'provider_selected',
+				'first_token',
+				'request_completed',
+				'request_failed'
+			)),
+			observed_at        INTEGER NOT NULL,
+			provider           TEXT,
+			model              TEXT,
+			status             TEXT,
+			input_tokens       INTEGER,
+			output_tokens      INTEGER,
+			cache_read_tokens  INTEGER,
+			cache_write_tokens INTEGER,
+			duration_ms        REAL,
+			ttft_ms            REAL,
+			source             TEXT NOT NULL,
+			quality_json       TEXT NOT NULL
+		)
+	`);
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS measurement_samples (
+			id              INTEGER PRIMARY KEY AUTOINCREMENT,
+			observed_at     INTEGER NOT NULL,
+			sample_kind     TEXT NOT NULL,
+			provider        TEXT,
+			model           TEXT,
+			value           REAL NOT NULL,
+			unit            TEXT NOT NULL,
+			correlation_id  TEXT,
+			source          TEXT NOT NULL,
+			quality_json    TEXT NOT NULL
+		)
+	`);
+    db.exec(`
+		CREATE TABLE IF NOT EXISTS identity_observations (
+			id             INTEGER PRIMARY KEY AUTOINCREMENT,
+			observed_at    INTEGER NOT NULL,
+			provider       TEXT,
+			model          TEXT,
+			source         TEXT NOT NULL,
+			metadata_json  TEXT NOT NULL
+		)
+	`);
+    // ── Indexes (spec §6) ─────────────────────────────────────────────
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_request_events_observed_at ON request_events(observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_request_events_provider_observed ON request_events(provider, observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_request_events_model_observed ON request_events(model, observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_request_events_kind_observed ON request_events(event_kind, observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_request_events_correlation ON request_events(correlation_id, observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_measurement_samples_kind_observed ON measurement_samples(sample_kind, observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_measurement_samples_provider_model ON measurement_samples(provider, model, observed_at)`);
+    db.exec(`CREATE INDEX IF NOT EXISTS idx_identity_obs_provider_model ON identity_observations(provider, model, observed_at)`);
+    // ── Schema version stamp (insert-only, never overwrites) ─────────
+    const existing = db
+        .prepare("SELECT value FROM analytics_meta WHERE key = 'schema_version'")
+        .get();
+    if (!existing) {
+        db.prepare("INSERT INTO analytics_meta (key, value) VALUES ('schema_version', ?)")
+            .run(String(SCHEMA_VERSION));
+        db.prepare("INSERT INTO analytics_schema (version, applied_at, digest) VALUES (?, ?, ?)")
+            .run(SCHEMA_VERSION, Date.now(), "pma-1-initial");
+    }
+}
+/** The current analytics schema version. */
+export function getAnalyticsSchemaVersion() {
+    return SCHEMA_VERSION;
+}

package/dist/src/store/analytics/sqlite-store/admin.js

@@ -0,0 +1,84 @@
+/**
+ * admin.ts — AnalyticsAdmin delegate bodies for the SQLite backend.
+ * Destructive/maintenance operations: prune, vacuum, integrityCheck, backup, clear, close.
+ */
+import { copyFileSync, existsSync } from "node:fs";
+import { withTx } from "../connection.js";
+import { analyticsDbPath } from "../connection.js";
+export function prune(ctx, policy) {
+    const now = Date.now();
+    const eventCutoff = now - policy.maxEventAgeMs;
+    const measCutoff = now - policy.maxMeasurementAgeMs;
+    const delEvents = ctx.db
+        .prepare("DELETE FROM request_events WHERE observed_at < ?")
+        .run(eventCutoff);
+    const delMeas = ctx.db
+        .prepare("DELETE FROM measurement_samples WHERE observed_at < ?")
+        .run(measCutoff);
+    // Identity observations are not age-pruned (they're low-volume snapshots).
+    if (policy.vacuumAfterPrune) {
+        try {
+            ctx.db.exec("VACUUM");
+        }
+        catch {
+            /* non-fatal */
+        }
+    }
+    return {
+        eventsRemoved: delEvents.changes ?? 0,
+        measurementsRemoved: delMeas.changes ?? 0,
+        identitiesRemoved: 0,
+        freedBytes: 0,
+    };
+}
+export function vacuum(ctx) {
+    try {
+        ctx.db.exec("VACUUM");
+        return { ok: true, detail: "VACUUM completed" };
+    }
+    catch (e) {
+        return { ok: false, detail: String(e) };
+    }
+}
+export function integrityCheck(ctx) {
+    try {
+        const row = ctx.db.prepare("PRAGMA integrity_check").get();
+        const result = row?.integrity_check ?? "ok";
+        return { ok: result === "ok", detail: result };
+    }
+    catch (e) {
+        return { ok: false, detail: String(e) };
+    }
+}
+export function backup(ctx) {
+    if (ctx.opts.inMemory) {
+        return { ok: false, detail: "Cannot backup an in-memory database" };
+    }
+    try {
+        // WAL-safe checkpoint before copy.
+        ctx.db.exec("PRAGMA wal_checkpoint(TRUNCATE)");
+        const src = analyticsDbPath(ctx.stateDir);
+        if (!existsSync(src))
+            return { ok: false, detail: "analytics.db not found" };
+        const dest = `${src}.bak-${Date.now()}`;
+        copyFileSync(src, dest);
+        return { ok: true, path: dest, detail: `Backup written to ${dest}` };
+    }
+    catch (e) {
+        return { ok: false, detail: String(e) };
+    }
+}
+export function clear(ctx) {
+    withTx(ctx.db, () => {
+        ctx.db.exec("DELETE FROM request_events");
+        ctx.db.exec("DELETE FROM measurement_samples");
+        ctx.db.exec("DELETE FROM identity_observations");
+        // Reset AUTOINCREMENT sequences for measurement_samples + identity_observations.
+        try {
+            ctx.db.exec("DELETE FROM sqlite_sequence WHERE name IN ('measurement_samples', 'identity_observations')");
+        }
+        catch {
+            /* non-fatal: sqlite_sequence may not exist yet */
+        }
+    });
+}