opencode-mem-agents 0.3.1 → 0.3.2

package/dist/worker/repository.js

@@ -0,0 +1,535 @@
+import Database from "better-sqlite3";
+import { prepareTracePayload, safeParseJson, safeSerialize, sanitizeFtsQuery, sanitizeText, toEpochMs, } from "./utils.js";
+const SEARCH_ORDER_SQL = {
+    created_desc: "o.created_at_epoch DESC, o.id DESC",
+    created_asc: "o.created_at_epoch ASC, o.id ASC",
+    id_desc: "o.id DESC",
+    id_asc: "o.id ASC",
+};
+export class WorkerRepository {
+    db;
+    traceRetentionMs;
+    traceMaxPayloadChars;
+    insertObs;
+    insertObsIgnoreCapture;
+    getObsByCaptureKey;
+    getObsByIds;
+    getObsByIdInProject;
+    getLatestObsInProject;
+    findTimelineAnchorByQuery;
+    getTimelineBeforeRows;
+    getTimelineAfterRows;
+    insertIoEvent;
+    deleteStaleIoEvents;
+    getRecentTraceEvents;
+    getTraceEventsByTraceId;
+    traceWritesSincePrune = 0;
+    constructor(dbPath, traceRetentionDays = 7, traceMaxPayloadChars = 4000) {
+        this.db = new Database(dbPath);
+        this.db.pragma("journal_mode = WAL");
+        this.db.pragma("foreign_keys = ON");
+        this.traceRetentionMs = traceRetentionDays * 24 * 60 * 60 * 1000;
+        this.traceMaxPayloadChars = traceMaxPayloadChars;
+        this.initializeSchema();
+        this.insertObs = this.db.prepare(`
+      INSERT INTO observations
+        (session_id, project, type, title, text, facts, narrative, concepts,
+         files_read, files_modified, agent, workflow_id, task_id, phase, signal,
+         capture_key, source, created_at, created_at_epoch)
+      VALUES
+        (@session_id, @project, @type, @title, @text, @facts, @narrative, @concepts,
+         @files_read, @files_modified, @agent, @workflow_id, @task_id, @phase, @signal,
+         @capture_key, @source, @created_at, @created_at_epoch)
+    `);
+        this.insertObsIgnoreCapture = this.db.prepare(`
+      INSERT OR IGNORE INTO observations
+        (session_id, project, type, title, text, facts, narrative, concepts,
+         files_read, files_modified, agent, workflow_id, task_id, phase, signal,
+         capture_key, source, created_at, created_at_epoch)
+      VALUES
+        (@session_id, @project, @type, @title, @text, @facts, @narrative, @concepts,
+         @files_read, @files_modified, @agent, @workflow_id, @task_id, @phase, @signal,
+         @capture_key, @source, @created_at, @created_at_epoch)
+    `);
+        this.getObsByCaptureKey = this.db.prepare(`
+      SELECT id FROM observations WHERE capture_key = ? ORDER BY id DESC LIMIT 1
+    `);
+        this.getObsByIds = this.db.prepare(`
+      SELECT * FROM observations WHERE id IN (SELECT value FROM json_each(?))
+      ORDER BY created_at_epoch DESC
+    `);
+        this.getObsByIdInProject = this.db.prepare(`
+      SELECT *
+      FROM observations
+      WHERE (? = '' OR project = ?)
+        AND id = ?
+      LIMIT 1
+    `);
+        this.getLatestObsInProject = this.db.prepare(`
+      SELECT *
+      FROM observations
+      WHERE (? = '' OR project = ?)
+      ORDER BY created_at_epoch DESC, id DESC
+      LIMIT 1
+    `);
+        this.findTimelineAnchorByQuery = this.db.prepare(`
+      SELECT o.id
+      FROM observations o
+      JOIN observations_fts fts ON o.id = fts.rowid
+      WHERE observations_fts MATCH ?
+        AND (? = '' OR o.project = ?)
+      ORDER BY rank
+      LIMIT 1
+    `);
+        this.getTimelineBeforeRows = this.db.prepare(`
+      SELECT *
+      FROM observations
+      WHERE (? = '' OR project = ?)
+        AND (
+          created_at_epoch < ?
+          OR (created_at_epoch = ? AND id < ?)
+        )
+      ORDER BY created_at_epoch DESC, id DESC
+      LIMIT ?
+    `);
+        this.getTimelineAfterRows = this.db.prepare(`
+      SELECT *
+      FROM observations
+      WHERE (? = '' OR project = ?)
+        AND (
+          created_at_epoch > ?
+          OR (created_at_epoch = ? AND id > ?)
+        )
+      ORDER BY created_at_epoch ASC, id ASC
+      LIMIT ?
+    `);
+        this.insertIoEvent = this.db.prepare(`
+      INSERT INTO io_events
+        (trace_id, direction, method, path, status, payload_json, duration_ms, created_at_epoch)
+      VALUES
+        (?, ?, ?, ?, ?, ?, ?, ?)
+    `);
+        this.deleteStaleIoEvents = this.db.prepare(`
+      DELETE FROM io_events
+      WHERE created_at_epoch < ?
+    `);
+        this.getRecentTraceEvents = this.db.prepare(`
+      SELECT id, trace_id, direction, method, path, status, payload_json, duration_ms, created_at_epoch
+      FROM io_events
+      ORDER BY created_at_epoch DESC
+      LIMIT ?
+    `);
+        this.getTraceEventsByTraceId = this.db.prepare(`
+      SELECT id, trace_id, direction, method, path, status, payload_json, duration_ms, created_at_epoch
+      FROM io_events
+      WHERE trace_id = ?
+      ORDER BY created_at_epoch DESC
+      LIMIT ?
+    `);
+        this.pruneStaleTraces();
+    }
+    close() {
+        this.db.close();
+    }
+    logTrace(traceId, direction, method, path, status, payload, durationMs = 0) {
+        try {
+            this.insertIoEvent.run(traceId, direction, method, path, status, prepareTracePayload(payload, this.traceMaxPayloadChars), Math.max(0, Math.floor(durationMs)), Date.now());
+            this.traceWritesSincePrune += 1;
+            if (this.traceWritesSincePrune >= 100) {
+                this.traceWritesSincePrune = 0;
+                this.pruneStaleTraces();
+            }
+        }
+        catch {
+            // best effort only
+        }
+    }
+    search(input) {
+        const filters = [];
+        const values = [];
+        const sanitizedQuery = input.query ? sanitizeFtsQuery(input.query) : "";
+        const hasFtsQuery = Boolean(sanitizedQuery);
+        if (input.project) {
+            filters.push("o.project = ?");
+            values.push(input.project);
+        }
+        if (input.type) {
+            filters.push("o.type = ?");
+            values.push(input.type);
+        }
+        if (input.signal) {
+            filters.push("o.signal = ?");
+            values.push(input.signal);
+        }
+        if (input.agent) {
+            filters.push("o.agent = ?");
+            values.push(input.agent);
+        }
+        const dateStartEpoch = toEpochMs(input.dateStart);
+        const dateEndEpoch = toEpochMs(input.dateEnd);
+        if (dateStartEpoch !== undefined) {
+            filters.push("o.created_at_epoch >= ?");
+            values.push(dateStartEpoch);
+        }
+        if (dateEndEpoch !== undefined) {
+            filters.push("o.created_at_epoch <= ?");
+            values.push(dateEndEpoch);
+        }
+        if (input.since_id > 0) {
+            filters.push("o.id > ?");
+            values.push(input.since_id);
+        }
+        const whereClauses = [...filters];
+        let fromClause = "observations o";
+        if (hasFtsQuery) {
+            fromClause += " JOIN observations_fts fts ON o.id = fts.rowid";
+            whereClauses.unshift("observations_fts MATCH ?");
+            values.unshift(sanitizedQuery);
+        }
+        const whereSql = whereClauses.length > 0 ? `WHERE ${whereClauses.join(" AND ")}` : "";
+        const orderSql = SEARCH_ORDER_SQL[input.orderBy] ?? SEARCH_ORDER_SQL.created_desc;
+        const rowSql = `
+      SELECT o.*
+      FROM ${fromClause}
+      ${whereSql}
+      ORDER BY ${orderSql}
+      LIMIT ?
+      OFFSET ?
+    `;
+        const countSql = `
+      SELECT COUNT(*) AS count
+      FROM ${fromClause}
+      ${whereSql}
+    `;
+        const observations = this.db.prepare(rowSql).all(...values, input.limit, input.offset);
+        const count = this.db.prepare(countSql).get(...values);
+        return {
+            observations,
+            totalResults: count?.count ?? observations.length,
+        };
+    }
+    timeline(input) {
+        const anchor = this.resolveTimelineAnchor(input);
+        if (!anchor) {
+            return {
+                anchorId: -1,
+                observations: [],
+                depthBefore: input.depth_before,
+                depthAfter: input.depth_after,
+            };
+        }
+        const project = input.project ?? "";
+        const before = this.getTimelineBeforeRows.all(project, project, anchor.created_at_epoch, anchor.created_at_epoch, anchor.id, input.depth_before);
+        const after = this.getTimelineAfterRows.all(project, project, anchor.created_at_epoch, anchor.created_at_epoch, anchor.id, input.depth_after);
+        return {
+            anchorId: anchor.id,
+            observations: [...before.reverse(), anchor, ...after],
+            depthBefore: input.depth_before,
+            depthAfter: input.depth_after,
+        };
+    }
+    getByIds(ids, project) {
+        if (!project) {
+            return this.getObsByIds.all(JSON.stringify(ids));
+        }
+        const sql = `
+      SELECT *
+      FROM observations
+      WHERE id IN (SELECT value FROM json_each(?))
+        AND project = ?
+      ORDER BY created_at_epoch DESC
+    `;
+        return this.db.prepare(sql).all(JSON.stringify(ids), project);
+    }
+    saveMemory(input) {
+        const now = Date.now();
+        const type = input.type ?? "discovery";
+        const agentName = input.agent ?? input.metadata?.agent?.agentName ?? "";
+        const workflowId = input.workflow_id ?? input.metadata?.agent?.workflowId ?? "";
+        const taskId = input.task_id ?? input.metadata?.agent?.taskId ?? "";
+        const phase = input.phase ?? input.metadata?.agent?.phase ?? "";
+        const signal = input.signal ?? input.metadata?.signal ?? "medium";
+        const result = this.insertObs.run({
+            session_id: input.sessionId ?? "",
+            project: input.project ?? "",
+            type,
+            title: sanitizeText(input.title ?? "", 500),
+            text: sanitizeText(input.text, 8192),
+            facts: JSON.stringify(input.facts),
+            narrative: sanitizeText(input.narrative ?? "", 4096),
+            concepts: JSON.stringify(input.concepts),
+            files_read: JSON.stringify(input.files_read),
+            files_modified: JSON.stringify(input.files_modified),
+            agent: agentName,
+            workflow_id: workflowId,
+            task_id: taskId,
+            phase,
+            signal,
+            capture_key: "",
+            source: "memory_save",
+            created_at: new Date(now).toISOString(),
+            created_at_epoch: now,
+        });
+        return {
+            id: Number(result.lastInsertRowid),
+            status: "saved",
+        };
+    }
+    saveToolResult(input) {
+        const now = input.metadata?.timestamp ?? Date.now();
+        const toolName = sanitizeText(input.tool ?? "unknown", 100);
+        const argsString = typeof input.args === "string" ? input.args : safeSerialize(input.args ?? {}, 200);
+        const captureKey = input.sessionId && input.callId
+            ? `${input.sessionId}:${input.callId}:${toolName}`
+            : "";
+        const result = this.insertObsIgnoreCapture.run({
+            session_id: input.sessionId ?? "",
+            project: input.project ?? "",
+            type: "change",
+            title: sanitizeText(`[tool] ${toolName}`, 500),
+            text: sanitizeText(input.output ?? "", 8192),
+            facts: "[]",
+            narrative: sanitizeText(`Tool ${toolName} called with: ${argsString}`, 4096),
+            concepts: "[]",
+            files_read: "[]",
+            files_modified: JSON.stringify(input.files_modified),
+            agent: input.metadata?.agent?.agentName ?? "",
+            workflow_id: input.metadata?.agent?.workflowId ?? "",
+            task_id: input.metadata?.agent?.taskId ?? "",
+            phase: input.metadata?.agent?.phase ?? "",
+            signal: input.metadata?.signal ?? "medium",
+            capture_key: captureKey,
+            source: "tool_result",
+            created_at: new Date(now).toISOString(),
+            created_at_epoch: now,
+        });
+        if (result.changes > 0) {
+            return {
+                id: Number(result.lastInsertRowid),
+                status: "captured",
+            };
+        }
+        if (captureKey) {
+            const existing = this.getObsByCaptureKey.get(captureKey);
+            if (existing?.id) {
+                return {
+                    id: existing.id,
+                    status: "duplicate",
+                };
+            }
+        }
+        return {
+            id: 0,
+            status: "duplicate",
+        };
+    }
+    getContextRows(input) {
+        const where = [];
+        const values = [];
+        if (input.project) {
+            where.push("project = ?");
+            values.push(input.project);
+        }
+        if (input.agent) {
+            where.push("agent = ?");
+            values.push(input.agent);
+        }
+        if (input.sessionId) {
+            where.push("session_id = ?");
+            values.push(input.sessionId);
+        }
+        const whereSql = where.length > 0 ? `WHERE ${where.join(" AND ")}` : "";
+        const sql = `
+      SELECT *
+      FROM observations
+      ${whereSql}
+      ORDER BY created_at_epoch DESC
+      LIMIT ?
+    `;
+        return this.db.prepare(sql).all(...values, input.limit);
+    }
+    getActivityRows(input) {
+        const where = ["id > ?"];
+        const values = [input.since_id];
+        if (input.project) {
+            where.push("project = ?");
+            values.push(input.project);
+        }
+        const sql = `
+      SELECT *
+      FROM observations
+      WHERE ${where.join(" AND ")}
+      ORDER BY created_at_epoch DESC
+      LIMIT ?
+    `;
+        return this.db.prepare(sql).all(...values, input.limit);
+    }
+    getTraces(input) {
+        const rows = input.trace_id
+            ? this.getTraceEventsByTraceId.all(input.trace_id, input.limit)
+            : this.getRecentTraceEvents.all(input.limit);
+        return rows
+            .map((row) => ({
+            id: row.id,
+            trace_id: row.trace_id,
+            direction: row.direction,
+            method: row.method,
+            path: row.path,
+            status: row.status,
+            payload: safeParseJson(row.payload_json, row.payload_json),
+            duration_ms: row.duration_ms,
+            created_at_epoch: row.created_at_epoch,
+        }))
+            .reverse();
+    }
+    initializeSchema() {
+        this.db.exec(`
+      CREATE TABLE IF NOT EXISTS observations (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT DEFAULT '',
+        project TEXT NOT NULL DEFAULT '',
+        type TEXT NOT NULL DEFAULT 'discovery',
+        title TEXT DEFAULT '',
+        text TEXT DEFAULT '',
+        facts TEXT DEFAULT '[]',
+        narrative TEXT DEFAULT '',
+        concepts TEXT DEFAULT '[]',
+        files_read TEXT DEFAULT '[]',
+        files_modified TEXT DEFAULT '[]',
+        agent TEXT DEFAULT '',
+        workflow_id TEXT DEFAULT '',
+        task_id TEXT DEFAULT '',
+        phase TEXT DEFAULT '',
+        signal TEXT DEFAULT 'medium',
+        capture_key TEXT DEFAULT '',
+        source TEXT DEFAULT '',
+        created_at TEXT NOT NULL,
+        created_at_epoch INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_obs_project ON observations(project);
+      CREATE INDEX IF NOT EXISTS idx_obs_type ON observations(type);
+      CREATE INDEX IF NOT EXISTS idx_obs_created ON observations(created_at_epoch DESC);
+      CREATE INDEX IF NOT EXISTS idx_obs_session ON observations(session_id);
+      CREATE INDEX IF NOT EXISTS idx_obs_workflow ON observations(workflow_id);
+      CREATE INDEX IF NOT EXISTS idx_obs_agent ON observations(agent);
+      CREATE INDEX IF NOT EXISTS idx_obs_signal ON observations(signal);
+      CREATE INDEX IF NOT EXISTS idx_obs_since ON observations(id);
+      CREATE UNIQUE INDEX IF NOT EXISTS idx_obs_capture_key ON observations(capture_key)
+        WHERE capture_key <> '';
+
+      CREATE TABLE IF NOT EXISTS io_events (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        trace_id TEXT NOT NULL,
+        direction TEXT NOT NULL,
+        method TEXT NOT NULL DEFAULT '',
+        path TEXT NOT NULL DEFAULT '',
+        status INTEGER NOT NULL DEFAULT 0,
+        payload_json TEXT NOT NULL DEFAULT '{}',
+        duration_ms INTEGER NOT NULL DEFAULT 0,
+        created_at_epoch INTEGER NOT NULL
+      );
+
+      CREATE INDEX IF NOT EXISTS idx_io_created ON io_events(created_at_epoch DESC);
+      CREATE INDEX IF NOT EXISTS idx_io_trace ON io_events(trace_id, created_at_epoch DESC);
+    `);
+        this.ensureColumn("observations", "capture_key", "TEXT DEFAULT ''");
+        this.ensureColumn("observations", "source", "TEXT DEFAULT ''");
+        try {
+            this.db.exec(`
+        CREATE VIRTUAL TABLE observations_fts USING fts5(
+          title, text, narrative, facts, concepts,
+          content='observations',
+          content_rowid='id'
+        );
+      `);
+        }
+        catch {
+            // already exists
+        }
+        const triggers = [
+            `CREATE TRIGGER IF NOT EXISTS obs_fts_ai AFTER INSERT ON observations BEGIN
+        INSERT INTO observations_fts(rowid, title, text, narrative, facts, concepts)
+        VALUES (new.id, new.title, new.text, new.narrative, new.facts, new.concepts);
+      END`,
+            `CREATE TRIGGER IF NOT EXISTS obs_fts_ad AFTER DELETE ON observations BEGIN
+        INSERT INTO observations_fts(observations_fts, rowid, title, text, narrative, facts, concepts)
+        VALUES('delete', old.id, old.title, old.text, old.narrative, old.facts, old.concepts);
+      END`,
+            `CREATE TRIGGER IF NOT EXISTS obs_fts_au AFTER UPDATE ON observations BEGIN
+        INSERT INTO observations_fts(observations_fts, rowid, title, text, narrative, facts, concepts)
+        VALUES('delete', old.id, old.title, old.text, old.narrative, old.facts, old.concepts);
+        INSERT INTO observations_fts(rowid, title, text, narrative, facts, concepts)
+        VALUES (new.id, new.title, new.text, new.narrative, new.facts, new.concepts);
+      END`,
+        ];
+        for (const trigger of triggers) {
+            try {
+                this.db.exec(trigger);
+            }
+            catch {
+                // ignore existing trigger errors
+            }
+        }
+        this.rebuildFtsIfOutOfSync();
+    }
+    ensureColumn(tableName, columnName, columnSpec) {
+        const columns = this.db.prepare(`PRAGMA table_info(${tableName})`).all();
+        const hasColumn = columns.some((column) => column.name === columnName);
+        if (!hasColumn) {
+            this.db.exec(`ALTER TABLE ${tableName} ADD COLUMN ${columnName} ${columnSpec}`);
+        }
+    }
+    resolveTimelineAnchor(input) {
+        const project = input.project ?? "";
+        if (input.anchor && input.anchor > 0) {
+            const anchorById = this.getObsByIdInProject.get(project, project, input.anchor);
+            if (anchorById)
+                return anchorById;
+        }
+        if (input.query) {
+            const sanitized = sanitizeFtsQuery(input.query);
+            if (sanitized) {
+                try {
+                    const match = this.findTimelineAnchorByQuery.get(sanitized, project, project);
+                    if (match?.id) {
+                        const byQuery = this.getObsByIdInProject.get(project, project, match.id);
+                        if (byQuery)
+                            return byQuery;
+                    }
+                }
+                catch {
+                    // ignore malformed FTS input
+                }
+            }
+        }
+        const latest = this.getLatestObsInProject.get(project, project);
+        return latest ?? null;
+    }
+    pruneStaleTraces() {
+        const cutoff = Date.now() - this.traceRetentionMs;
+        try {
+            this.deleteStaleIoEvents.run(cutoff);
+        }
+        catch {
+            // best effort only
+        }
+    }
+    rebuildFtsIfOutOfSync() {
+        try {
+            const counts = this.db.prepare(`
+        SELECT
+          (SELECT COUNT(*) FROM observations) AS obs_count,
+          (SELECT COUNT(*) FROM observations_fts) AS fts_count
+      `).get();
+            if (!counts)
+                return;
+            if ((counts.obs_count ?? 0) === (counts.fts_count ?? -1))
+                return;
+            this.db.exec(`INSERT INTO observations_fts(observations_fts) VALUES ('rebuild')`);
+        }
+        catch {
+            // if FTS is unavailable, fallback search behavior still works for non-query filters
+        }
+    }
+}

package/dist/worker/routes.d.ts

@@ -0,0 +1,31 @@
+import type { WorkerConfig } from "./config.js";
+import { WorkerRepository } from "./repository.js";
+export type RouteResult = {
+    kind: "json";
+    status: number;
+    body: Record<string, unknown>;
+} | {
+    kind: "text";
+    status: number;
+    body: string;
+} | {
+    kind: "html";
+    status: number;
+    body: string;
+};
+export interface RouteContext {
+    config: WorkerConfig;
+    startedAt: number;
+    version: string;
+    repo: WorkerRepository;
+}
+export declare function handleDashboard(): RouteResult;
+export declare function handleHealth(ctx: RouteContext): RouteResult;
+export declare function handleSearch(ctx: RouteContext, paramsRaw: Record<string, string>): RouteResult;
+export declare function handleTimeline(ctx: RouteContext, paramsRaw: Record<string, string>): RouteResult;
+export declare function handleObservationsBatch(ctx: RouteContext, bodyRaw: unknown): RouteResult;
+export declare function handleMemorySave(ctx: RouteContext, bodyRaw: unknown): RouteResult;
+export declare function handleToolResult(ctx: RouteContext, bodyRaw: unknown): RouteResult;
+export declare function handleContextSession(ctx: RouteContext, paramsRaw: Record<string, string>): RouteResult;
+export declare function handleActivity(ctx: RouteContext, paramsRaw: Record<string, string>): RouteResult;
+export declare function handleTraces(ctx: RouteContext, paramsRaw: Record<string, string>): RouteResult;