akm-cli 0.9.0-beta.33 → 0.9.0-beta.34

package/CHANGELOG.md

@@ -6,6 +6,21 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [0.9.0-beta.34] — 2026-06-21
+
+### Fixed
+
+- **`akm extract --type opencode` reads opencode's SQLite session store.** opencode
+  migrated session storage from per-file JSON (`storage/session/<projectId>/<id>.json`
+  + `storage/message/<id>/*.json`) to a single Drizzle-managed database at
+  `<base>/opencode.db` (tables `session`/`message`/`part`; message text lives in
+  `part` rows with `data` JSON `type:"text"`). The legacy JSON layout went stale
+  ~2026-02, so extract discovered 0 sessions on current opencode and the
+  `session.idle` extract hook had nothing to read. `OpenCodeProvider` now prefers
+  `opencode.db` when present (read-only, via the cross-driver `openDatabase` seam)
+  and falls back to the JSON layout. Verified end-to-end through the plugin's
+  `session.idle` hook.
+
 ## [0.9.0-beta.33] — 2026-06-21
 
 ### Fixed

package/dist/integrations/harnesses/opencode/session-log.js

@@ -4,6 +4,7 @@
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { openDatabase } from "../../../storage/database.js";
 import { extractInlineRefMentions } from "../../session-logs/inline-refs.js";
 function getOpenCodeBaseDir() {
     if (process.platform === "darwin") {
@@ -12,28 +13,48 @@ function getOpenCodeBaseDir() {
     return path.join(os.homedir(), ".local", "share", "opencode");
 }
 /**
- * Opencode storage layout (observed 2026-05):
- *   <base>/storage/session/<projectId>/<sessionId>.json    — metadata
- *   <base>/storage/message/<sessionId>/<messageId>.json    — one per message
+ * Opencode storage layouts:
+ *
+ *   SQLite (current, observed 2026-06): `<base>/opencode.db` — a Drizzle-managed
+ *   database with `session` / `message` / `part` tables. Message text lives in
+ *   `part` rows (`data` JSON, `type: "text"`); `message.data` holds role/timing.
+ *   This is the layout current opencode builds write; it is preferred whenever
+ *   `opencode.db` exists.
+ *
+ *   JSON files (legacy, observed 2026-05): `<base>/storage/session/<projectId>/
+ *   <sessionId>.json` (metadata) + `<base>/storage/message/<sessionId>/
+ *   <messageId>.json` (one per message). Read only when `opencode.db` is absent.
  *
  * Older builds wrote logs directly into `<base>/log/` and `<base>/*.log`;
  * those are still scanned by {@link OpenCodeProvider.readEvents} for
  * backward compatibility with the existing failure-pattern aggregator.
  */
+/** Filename of opencode's SQLite session store, relative to its base dir. */
+const OPENCODE_DB_FILENAME = "opencode.db";
 export class OpenCodeProvider {
     name = "opencode";
     #baseDir = getOpenCodeBaseDir();
     isAvailable() {
         return fs.existsSync(this.#baseDir);
     }
+    /** Absolute path to opencode's SQLite store under `base`. */
+    #dbPath(base) {
+        return path.join(base, OPENCODE_DB_FILENAME);
+    }
     /**
-     * Directory holding opencode's per-project session metadata files
-     * (`<base>/storage/session`). Returns `[]` when it does not exist on this
-     * machine. See {@link SessionLogHarness.watchRoots}.
+     * Directories/files opencode writes session data under. Returns the base dir
+     * when the SQLite store (`opencode.db`) exists, the legacy JSON session root
+     * (`<base>/storage/session`) when present, or both during a migration overlap.
+     * Empty when neither exists. See {@link SessionLogHarness.watchRoots}.
      */
     watchRoots() {
+        const roots = [];
+        if (fs.existsSync(this.#dbPath(this.#baseDir)))
+            roots.push(this.#baseDir);
         const sessionRoot = path.join(this.#baseDir, "storage", "session");
-        return fs.existsSync(sessionRoot) ? [sessionRoot] : [];
+        if (fs.existsSync(sessionRoot))
+            roots.push(sessionRoot);
+        return roots;
     }
     *readEvents(input) {
         // Legacy behavior: stream raw log lines from the top-level dir and `log/`
@@ -91,6 +112,9 @@ export class OpenCodeProvider {
     listSessions(input = {}) {
         const base = input.location ?? this.#baseDir;
         const sinceMs = input.sinceMs ?? 0;
+        const dbPath = this.#dbPath(base);
+        if (fs.existsSync(dbPath))
+            return this.#listSessionsFromDb(dbPath, sinceMs);
         const sessionRoot = path.join(base, "storage", "session");
         if (!fs.existsSync(sessionRoot))
             return [];
@@ -151,6 +175,8 @@ export class OpenCodeProvider {
         return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
     }
     readSession(ref) {
+        if (path.basename(ref.filePath) === OPENCODE_DB_FILENAME)
+            return this.#readSessionFromDb(ref);
         let meta = {};
         try {
             meta = JSON.parse(fs.readFileSync(ref.filePath, "utf8"));
@@ -208,6 +234,141 @@ export class OpenCodeProvider {
             inlineRefs,
         };
     }
+    /**
+     * List sessions from the SQLite store. `filePath` on each summary is the
+     * `opencode.db` path so {@link readSession} can route back to the DB reader.
+     * Returns `[]` (never throws) when the DB is unreadable or lacks the expected
+     * schema — callers treat a missing harness as "no sessions".
+     */
+    #listSessionsFromDb(dbPath, sinceMs) {
+        let db;
+        try {
+            db = openDatabase(dbPath, { readonly: true, create: false });
+        }
+        catch {
+            return [];
+        }
+        try {
+            const rows = db
+                .prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC")
+                .all(sinceMs);
+            return rows.map((r) => {
+                const startedAt = typeof r.time_created === "number" ? r.time_created : undefined;
+                const endedAt = typeof r.time_updated === "number" ? r.time_updated : undefined;
+                const title = typeof r.title === "string" && r.title.length > 0 ? r.title : undefined;
+                const projectHint = typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined;
+                return {
+                    harness: this.name,
+                    sessionId: r.id,
+                    filePath: dbPath,
+                    ...(startedAt !== undefined ? { startedAt } : {}),
+                    ...(endedAt !== undefined ? { endedAt } : {}),
+                    ...(projectHint ? { projectHint } : {}),
+                    ...(title ? { title } : {}),
+                };
+            });
+        }
+        catch {
+            // Missing `session` table / unexpected schema — treat as no sessions.
+            return [];
+        }
+        finally {
+            db.close();
+        }
+    }
+    /**
+     * Read one session from the SQLite store. Message text lives in `part` rows
+     * (`type: "text"`); `message.data` carries role + timing. One event per
+     * message, text-parts concatenated in time order. Returns empty events
+     * (never throws) when the DB is unreadable.
+     */
+    #readSessionFromDb(ref) {
+        const emptyRef = { harness: this.name, sessionId: ref.sessionId, filePath: ref.filePath };
+        let db;
+        try {
+            db = openDatabase(ref.filePath, { readonly: true, create: false });
+        }
+        catch {
+            return { ref: emptyRef, events: [], inlineRefs: [] };
+        }
+        try {
+            const meta = db
+                .prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?")
+                .get(ref.sessionId);
+            const startedAt = typeof meta?.time_created === "number" ? meta.time_created : undefined;
+            const endedAt = typeof meta?.time_updated === "number" ? meta.time_updated : undefined;
+            const title = typeof meta?.title === "string" && meta.title.length > 0 ? meta.title : undefined;
+            const projectHint = typeof meta?.directory === "string" && meta.directory.length > 0 ? meta.directory : undefined;
+            const messages = db
+                .prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+                .all(ref.sessionId);
+            const parts = db
+                .prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC")
+                .all(ref.sessionId);
+            // Group text-part bodies by their parent message.
+            const textByMessage = new Map();
+            for (const part of parts) {
+                let parsed;
+                try {
+                    parsed = JSON.parse(part.data);
+                }
+                catch {
+                    continue;
+                }
+                if (parsed?.type !== "text")
+                    continue;
+                const text = parsed.text;
+                if (typeof text !== "string" || text.length < 1)
+                    continue;
+                const bucket = textByMessage.get(part.message_id) ?? [];
+                bucket.push(text);
+                textByMessage.set(part.message_id, bucket);
+            }
+            const events = [];
+            const inlineRefs = [];
+            for (const message of messages) {
+                let mdata = {};
+                try {
+                    mdata = JSON.parse(message.data);
+                }
+                catch {
+                    // role/timing unavailable — fall through with defaults
+                }
+                const role = typeof mdata.role === "string" ? mdata.role : "unknown";
+                const mtime = mdata.time?.created;
+                const ts = typeof mtime === "number"
+                    ? mtime
+                    : typeof message.time_created === "number"
+                        ? message.time_created
+                        : undefined;
+                const text = (textByMessage.get(message.id) ?? []).join("\n").trim();
+                if (text.length < 1)
+                    continue;
+                events.push({ harness: this.name, text, ts, sessionId: ref.sessionId, role, filePath: ref.filePath });
+                inlineRefs.push(...extractInlineRefMentions(text, ts));
+            }
+            events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+            return {
+                ref: {
+                    harness: this.name,
+                    sessionId: ref.sessionId,
+                    filePath: ref.filePath,
+                    ...(startedAt !== undefined ? { startedAt } : {}),
+                    ...(endedAt !== undefined ? { endedAt } : {}),
+                    ...(projectHint ? { projectHint } : {}),
+                    ...(title ? { title } : {}),
+                },
+                events,
+                inlineRefs,
+            };
+        }
+        catch {
+            return { ref: emptyRef, events: [], inlineRefs: [] };
+        }
+        finally {
+            db.close();
+        }
+    }
     /**
      * Derive opencode base dir from a session metadata file path so a caller
      * passing a custom `--location` can still find the message dir.

package/dist/scripts/migrate-storage.js

@@ -10934,9 +10934,17 @@ class OpenCodeProvider {
   isAvailable() {
     return fs10.existsSync(this.#baseDir);
   }
+  #dbPath(base) {
+    return path9.join(base, OPENCODE_DB_FILENAME);
+  }
   watchRoots() {
+    const roots = [];
+    if (fs10.existsSync(this.#dbPath(this.#baseDir)))
+      roots.push(this.#baseDir);
     const sessionRoot = path9.join(this.#baseDir, "storage", "session");
-    return fs10.existsSync(sessionRoot) ? [sessionRoot] : [];
+    if (fs10.existsSync(sessionRoot))
+      roots.push(sessionRoot);
+    return roots;
   }
   *readEvents(input) {
     const candidates = [this.#baseDir, path9.join(this.#baseDir, "log")];
@@ -10985,6 +10993,9 @@ class OpenCodeProvider {
   listSessions(input = {}) {
     const base = input.location ?? this.#baseDir;
     const sinceMs = input.sinceMs ?? 0;
+    const dbPath = this.#dbPath(base);
+    if (fs10.existsSync(dbPath))
+      return this.#listSessionsFromDb(dbPath, sinceMs);
     const sessionRoot = path9.join(base, "storage", "session");
     if (!fs10.existsSync(sessionRoot))
       return [];
@@ -11039,6 +11050,8 @@ class OpenCodeProvider {
     return summaries.sort((a, b) => (b.endedAt ?? 0) - (a.endedAt ?? 0));
   }
   readSession(ref) {
+    if (path9.basename(ref.filePath) === OPENCODE_DB_FILENAME)
+      return this.#readSessionFromDb(ref);
     let meta = {};
     try {
       meta = JSON.parse(fs10.readFileSync(ref.filePath, "utf8"));
@@ -11088,6 +11101,106 @@ class OpenCodeProvider {
       inlineRefs
     };
   }
+  #listSessionsFromDb(dbPath, sinceMs) {
+    let db;
+    try {
+      db = openDatabase(dbPath, { readonly: true, create: false });
+    } catch {
+      return [];
+    }
+    try {
+      const rows = db.prepare("SELECT id, title, directory, time_created, time_updated FROM session WHERE time_updated >= ? ORDER BY time_updated DESC").all(sinceMs);
+      return rows.map((r) => {
+        const startedAt = typeof r.time_created === "number" ? r.time_created : undefined;
+        const endedAt = typeof r.time_updated === "number" ? r.time_updated : undefined;
+        const title = typeof r.title === "string" && r.title.length > 0 ? r.title : undefined;
+        const projectHint = typeof r.directory === "string" && r.directory.length > 0 ? r.directory : undefined;
+        return {
+          harness: this.name,
+          sessionId: r.id,
+          filePath: dbPath,
+          ...startedAt !== undefined ? { startedAt } : {},
+          ...endedAt !== undefined ? { endedAt } : {},
+          ...projectHint ? { projectHint } : {},
+          ...title ? { title } : {}
+        };
+      });
+    } catch {
+      return [];
+    } finally {
+      db.close();
+    }
+  }
+  #readSessionFromDb(ref) {
+    const emptyRef = { harness: this.name, sessionId: ref.sessionId, filePath: ref.filePath };
+    let db;
+    try {
+      db = openDatabase(ref.filePath, { readonly: true, create: false });
+    } catch {
+      return { ref: emptyRef, events: [], inlineRefs: [] };
+    }
+    try {
+      const meta = db.prepare("SELECT title, directory, time_created, time_updated FROM session WHERE id = ?").get(ref.sessionId);
+      const startedAt = typeof meta?.time_created === "number" ? meta.time_created : undefined;
+      const endedAt = typeof meta?.time_updated === "number" ? meta.time_updated : undefined;
+      const title = typeof meta?.title === "string" && meta.title.length > 0 ? meta.title : undefined;
+      const projectHint = typeof meta?.directory === "string" && meta.directory.length > 0 ? meta.directory : undefined;
+      const messages = db.prepare("SELECT id, data, time_created FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(ref.sessionId);
+      const parts = db.prepare("SELECT message_id, data FROM part WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(ref.sessionId);
+      const textByMessage = new Map;
+      for (const part of parts) {
+        let parsed;
+        try {
+          parsed = JSON.parse(part.data);
+        } catch {
+          continue;
+        }
+        if (parsed?.type !== "text")
+          continue;
+        const text = parsed.text;
+        if (typeof text !== "string" || text.length < 1)
+          continue;
+        const bucket = textByMessage.get(part.message_id) ?? [];
+        bucket.push(text);
+        textByMessage.set(part.message_id, bucket);
+      }
+      const events = [];
+      const inlineRefs = [];
+      for (const message of messages) {
+        let mdata = {};
+        try {
+          mdata = JSON.parse(message.data);
+        } catch {}
+        const role = typeof mdata.role === "string" ? mdata.role : "unknown";
+        const mtime = mdata.time?.created;
+        const ts = typeof mtime === "number" ? mtime : typeof message.time_created === "number" ? message.time_created : undefined;
+        const text = (textByMessage.get(message.id) ?? []).join(`
+`).trim();
+        if (text.length < 1)
+          continue;
+        events.push({ harness: this.name, text, ts, sessionId: ref.sessionId, role, filePath: ref.filePath });
+        inlineRefs.push(...extractInlineRefMentions(text, ts));
+      }
+      events.sort((a, b) => (a.ts ?? 0) - (b.ts ?? 0));
+      return {
+        ref: {
+          harness: this.name,
+          sessionId: ref.sessionId,
+          filePath: ref.filePath,
+          ...startedAt !== undefined ? { startedAt } : {},
+          ...endedAt !== undefined ? { endedAt } : {},
+          ...projectHint ? { projectHint } : {},
+          ...title ? { title } : {}
+        },
+        events,
+        inlineRefs
+      };
+    } catch {
+      return { ref: emptyRef, events: [], inlineRefs: [] };
+    } finally {
+      db.close();
+    }
+  }
   #inferBaseFromSessionPath(filePath) {
     const dir = path9.dirname(filePath);
     const parts = dir.split(path9.sep);
@@ -11135,7 +11248,9 @@ class OpenCodeProvider {
     };
   }
 }
+var OPENCODE_DB_FILENAME = "opencode.db";
 var init_session_log2 = __esm(() => {
+  init_database();
   init_inline_refs();
 });
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.9.0-beta.33",
+  "version": "0.9.0-beta.34",
   "type": "module",
   "description": "akm (Agent Knowledge Management) — A package manager for AI agent skills, commands, tools, and knowledge. Works with Claude Code, OpenCode, Cursor, and any AI coding assistant.",
   "keywords": [