@rejacky/opencode-insights 0.1.4 → 0.1.5

package/README.md

@@ -12,45 +12,64 @@ opencode plugin @rejacky/opencode-insights --global
 
 Restart OpenCode after installing the plugin.
 
+On startup, the plugin creates a user-local `opencode-insights` command shim in:
+
+```text
+~/.local/bin
+```
+
+Make sure that directory is on your `PATH`, then run the CLI directly:
+
+```bash
+opencode-insights doctor
+```
+
 ## Uninstall
 
 Remove this plugin from `opencode.json` / `opencode.jsonc`, remove it from `tui.json`, and delete the local Insights database files:
 
 ```bash
-npx opencode-insights uninstall
+opencode-insights uninstall
 ```
 
 Preview the cleanup without changing files:
 
 ```bash
-npx opencode-insights uninstall --dry-run
+opencode-insights uninstall --dry-run
 ```
 
 Keep captured data while removing only the plugin config entries:
 
 ```bash
-npx opencode-insights uninstall --keep-data
+opencode-insights uninstall --keep-data
 ```
 
 Use a custom OpenCode config directory or data location:
 
 ```bash
-npx opencode-insights uninstall --config-dir ~/.config/opencode --data-dir ~/.opencode-insights
+opencode-insights uninstall --config-dir ~/.config/opencode --data-dir ~/.opencode-insights
 ```
 
-After uninstalling, restart OpenCode. If you also want to remove the npm package from your OpenCode config/package directory, run:
+After uninstalling, restart OpenCode. Packages installed with `opencode plugin ... --global` are stored under OpenCode's package cache. On macOS/Linux this is typically:
 
-```bash
-cd ~/.config/opencode
-npm rm @rejacky/opencode-insights
+```text
+~/.cache/opencode/packages
+```
+
+For this machine, that expands to:
+
+```text
+/Users/zyao/.cache/opencode/packages
 ```
 
+The `uninstall` command removes plugin config entries and local Insights data; it does not remove cached OpenCode package directories automatically.
+
 ## What You Get
 
 - Live TPS, average TPS, and average TTFT in the OpenCode session prompt zone.
 - Subagent status (running, done, failed, elapsed time, and token/context usage) in the sidebar.
 - Local capture of OpenCode hook/event data without redaction.
-- A local web viewer for sessions, messages, hooks, request context, system/messages transforms, and assistant responses.
+- A local web viewer for reconstructed sessions, user turns, hidden request context, system/messages transforms, and assistant thinking/response sequences.
 - Native OpenCode footer components (project directory and version) remain visible — the plugin does not override `sidebar_footer` or `home_prompt_right` slots.
 
 ## Open The Viewer
@@ -58,13 +77,13 @@ npm rm @rejacky/opencode-insights
 Start the local web viewer and open it in your browser:
 
 ```bash
-npx opencode-insights open --limit 5000 --port 8765
+opencode-insights open --limit 5000 --port 8765
 ```
 
 Or run the server only:
 
 ```bash
-npx opencode-insights serve --limit 5000 --port 8765
+opencode-insights serve --limit 5000 --port 8765
 ```
 
 Then open:
@@ -75,59 +94,66 @@ http://127.0.0.1:8765/
 
 The viewer shows:
 
-- `MSG` rows for user messages.
-- `HOOK` rows for OpenCode plugin hooks.
-- `Summary`, `Request`, `Response`, and `Raw` tabs.
-- Expandable/collapsible JSON trees with `Expand All` and `Collapse All`.
+- Project/session filters with subagent sessions nested under their parent session.
+- User-message rows only, with each row showing visible assistant steps and hidden context count.
+- A `Summary` view with the agent thinking/response sequence.
+- Collapsed hidden-context previews that expand to plain text system prompt or hidden prompt-like content.
+- A dark/light theme switcher.
 
 ## Common Commands
 
 List recent raw captures:
 
 ```bash
-npx opencode-insights recent --limit 20
+opencode-insights recent --limit 20
 ```
 
 List reconstructed sessions:
 
 ```bash
-npx opencode-insights sessions --limit 5000
+opencode-insights sessions --limit 5000
 ```
 
 Print one reconstructed session:
 
 ```bash
-npx opencode-insights show ses_xxx --limit 10000
+opencode-insights show ses_xxx --limit 10000
 ```
 
 Export one session to JSON:
 
 ```bash
-npx opencode-insights export ses_xxx --limit 10000 --output ./session.json
+opencode-insights export ses_xxx --limit 10000 --output ./session.json
 ```
 
 Check DB path, table health, row counts, and SQLite readability:
 
 ```bash
-npx opencode-insights doctor
+opencode-insights doctor
 ```
 
 Compact the local SQLite DB after heavy testing:
 
 ```bash
-npx opencode-insights vacuum
+opencode-insights vacuum
 ```
 
 Remove plugin config entries and delete local captured data:
 
 ```bash
-npx opencode-insights uninstall
+opencode-insights uninstall
 ```
 
-If the command is not available through `npx`, run the installed binary directly from your OpenCode config directory:
+If the command is not available, confirm `~/.local/bin` is on `PATH`, or run the installed binary directly from OpenCode's package cache:
 
 ```bash
-./node_modules/.bin/opencode-insights doctor
+~/.cache/opencode/packages/node_modules/.bin/opencode-insights doctor
+```
+
+You can also run the published package through npm without relying on the OpenCode cache:
+
+```bash
+npx -y -p @rejacky/opencode-insights opencode-insights doctor
 ```
 
 ## Storage
@@ -144,7 +170,9 @@ If SQLite is unavailable in the plugin runtime, the fallback path is:
 ~/.opencode-insights/insights.sqlite.jsonl
 ```
 
-You can override storage in `opencode.json` or `opencode.jsonc`:
+The database keeps one day of captures by default and auto-cleans older rows on startup and after new captures. Set `retentionDays` to another number of days, or `0` to disable auto-cleaning.
+
+You can override storage and retention in `opencode.json` or `opencode.jsonc`:
 
 ```json
 {
@@ -152,7 +180,8 @@ You can override storage in `opencode.json` or `opencode.jsonc`:
     [
       "@rejacky/opencode-insights",
       {
-        "dbPath": "/absolute/path/to/insights.sqlite"
+        "dbPath": "/absolute/path/to/insights.sqlite",
+        "retentionDays": 1
       }
     ]
   ]
@@ -165,24 +194,9 @@ This plugin intentionally does not redact anything. It stores data locally exact
 
 Captured data can include prompts, system messages, provider metadata, API keys exposed inside hook payloads, tool arguments, headers, reasoning text, and response events. Use it only on machines where local full-fidelity capture is acceptable.
 
-## Experimental Features
-
-The request-interception hooks (`chat.headers`, `experimental.chat.messages.transform`, `experimental.chat.system.transform`) are disabled by default. They capture additional request context (HTTP headers, transformed messages, system prompts) but are not yet mature.
+## Request Context Capture
 
-To enable them, pass `experimental: true` in the plugin options:
-
-```json
-{
-  "plugin": [
-    [
-      "@rejacky/opencode-insights",
-      {
-        "experimental": true
-      }
-    ]
-  ]
-}
-```
+Request-context capture is enabled by default. The plugin records OpenCode's `chat.headers`, `experimental.chat.messages.transform`, and `experimental.chat.system.transform` hooks so the viewer can show provider headers, transformed conversation messages, and system prompt content when OpenCode exposes them. The `experimental.chat.*` names are OpenCode hook names; no `experimental` plugin option is required.
 
 ## Captured Hooks
 

package/dist/{capture-DkASdFpu.d.ts → capture-B6sM1QQA.d.ts}

@@ -17,9 +17,7 @@ type CaptureStore = {
 type InsightsOptions = {
     dataDir?: unknown;
     dbPath?: unknown;
-    /** Enable experimental request capture (chat.headers, messages/system transforms).
-     *  Disabled by default — these hooks intercept request data and are not yet mature. */
-    experimental?: boolean;
+    retentionDays?: unknown;
 };
 declare function defaultDataDir(): string;
 declare function resolveCapturePath(options?: InsightsOptions): string;
@@ -32,20 +30,31 @@ declare function normalizeEventCapture(event: unknown, timestamp?: number): Capt
 declare function normalizeToolCapture(kind: "tool.execute.before" | "tool.execute.after", input: unknown, output: unknown, timestamp?: number): CaptureRecord;
 declare class JsonlCaptureStore implements CaptureStore {
     private readonly path;
-    constructor(path: string);
+    private readonly retentionMs;
+    constructor(path: string, retentionMs?: number | undefined);
     initialize(): Promise<void>;
     append(record: CaptureRecord): Promise<void>;
+    private pruneExpired;
 }
+interface SqliteDb {
+    all(sql: string, ...params: unknown[]): Record<string, unknown>[];
+    run(sql: string, ...params: unknown[]): void;
+    sync(): void;
+    close(): void;
+}
+declare function openDatabase(path: string): Promise<SqliteDb | undefined>;
 declare class SqliteCaptureStore implements CaptureStore {
     private readonly path;
+    private readonly retentionMs;
     private db;
-    private unavailable;
-    constructor(path: string);
+    private fallbackStore;
+    constructor(path: string, retentionMs?: number | undefined);
     initialize(): Promise<void>;
     append(record: CaptureRecord): Promise<void>;
     close(): Promise<void>;
-    private database;
+    private pruneExpired;
 }
 declare function createCaptureStore(options?: InsightsOptions): CaptureStore;
+declare function resolveRetentionDays(value: unknown): number;
 
-export { type CaptureRecord as C, type InsightsOptions as I, JsonlCaptureStore as J, SqliteCaptureStore as S, type CaptureKind as a, type CaptureStore as b, createCaptureStore as c, defaultDataDir as d, normalizeChatMessageCapture as e, normalizeChatParamsCapture as f, normalizeEventCapture as g, normalizeExperimentalChatMessagesTransformCapture as h, normalizeExperimentalChatSystemTransformCapture as i, normalizeToolCapture as j, normalizeChatHeadersCapture as n, resolveCapturePath as r };
+export { type CaptureRecord as C, type InsightsOptions as I, JsonlCaptureStore as J, SqliteCaptureStore as S, type CaptureKind as a, type CaptureStore as b, type SqliteDb as c, createCaptureStore as d, defaultDataDir as e, normalizeChatMessageCapture as f, normalizeChatParamsCapture as g, normalizeEventCapture as h, normalizeExperimentalChatMessagesTransformCapture as i, normalizeExperimentalChatSystemTransformCapture as j, normalizeToolCapture as k, resolveRetentionDays as l, normalizeChatHeadersCapture as n, openDatabase as o, resolveCapturePath as r };

package/dist/{chunk-Q5ROKOOJ.js → chunk-PBX4AJCR.js}

@@ -1,7 +1,10 @@
 // src/capture.ts
-import { mkdir, appendFile, writeFile } from "fs/promises";
+import { mkdir, appendFile, readFile, writeFile } from "fs/promises";
+import { existsSync } from "fs";
 import { dirname, join } from "path";
 import { homedir } from "os";
+var DEFAULT_RETENTION_DAYS = 1;
+var DAY_MS = 24 * 60 * 60 * 1e3;
 var sequence = 0;
 function nextID(timestamp) {
   sequence += 1;
@@ -100,13 +103,14 @@ function normalizeChatHeadersCapture(input, output, timestamp = Date.now()) {
   });
 }
 function normalizeExperimentalChatMessagesTransformCapture(input, output, timestamp = Date.now()) {
+  const inputRecord = isRecord(input) ? input : {};
   const latestUserMessage = latestUserTransformedMessage(output);
   const info = infoFromTransformedMessage(latestUserMessage);
   return captureRecord({
     id: nextID(timestamp),
     kind: "experimental.chat.messages.transform",
     timestamp,
-    sessionID: sessionIDFrom(info),
+    sessionID: sessionIDFrom(inputRecord),
     messageID: messageIDFrom(info) ?? optionalString(info?.id),
     payload: { input, output }
   });
@@ -149,42 +153,143 @@ function normalizeToolCapture(kind, input, output, timestamp = Date.now()) {
   });
 }
 var JsonlCaptureStore = class {
-  constructor(path) {
+  constructor(path, retentionMs = retentionMsFromDays(DEFAULT_RETENTION_DAYS)) {
     this.path = path;
+    this.retentionMs = retentionMs;
   }
   path;
+  retentionMs;
   async initialize() {
     await mkdir(dirname(this.path), { recursive: true });
     await writeFile(this.path, "", { flag: "a" });
+    await this.pruneExpired();
   }
   async append(record) {
     await mkdir(dirname(this.path), { recursive: true });
     await appendFile(this.path, `${JSON.stringify(record)}
 `, "utf8");
+    await this.pruneExpired();
+  }
+  async pruneExpired(now = Date.now()) {
+    const cutoff = retentionCutoff(now, this.retentionMs);
+    if (cutoff === void 0 || !existsSync(this.path)) return;
+    try {
+      const lines = (await readFile(this.path, "utf8")).split(/\r?\n/);
+      const kept = lines.filter((line) => {
+        const trimmed = line.trim();
+        if (!trimmed) return false;
+        try {
+          const record = JSON.parse(trimmed);
+          return typeof record.timestamp !== "number" || record.timestamp >= cutoff;
+        } catch {
+          return true;
+        }
+      });
+      await writeFile(this.path, kept.length ? `${kept.join("\n")}
+` : "", "utf8");
+    } catch {
+    }
   }
 };
+async function openDatabase(path) {
+  try {
+    const mod = await import("bun:sqlite").catch(() => void 0);
+    if (mod) {
+      const db = new mod.Database(path);
+      return {
+        all(sql, ...params) {
+          return db.query(sql).all(...params);
+        },
+        run(sql, ...params) {
+          db.run(sql, ...params);
+        },
+        sync() {
+        },
+        close() {
+          db.close();
+        }
+      };
+    }
+  } catch {
+  }
+  try {
+    const mod = await import("better-sqlite3").catch(() => void 0);
+    const Database = mod?.default;
+    if (Database) {
+      const db = new Database(path);
+      return {
+        all(sql, ...params) {
+          return db.prepare(sql).all(...params);
+        },
+        run(sql, ...params) {
+          db.prepare(sql).run(...params);
+        },
+        sync() {
+        },
+        close() {
+          db.close();
+        }
+      };
+    }
+  } catch {
+  }
+  return void 0;
+}
 var SqliteCaptureStore = class {
-  constructor(path) {
+  constructor(path, retentionMs = retentionMsFromDays(DEFAULT_RETENTION_DAYS)) {
     this.path = path;
+    this.retentionMs = retentionMs;
   }
   path;
+  retentionMs;
   db;
-  unavailable = false;
+  fallbackStore;
   async initialize() {
-    const db = await this.database();
+    await mkdir(dirname(this.path), { recursive: true });
+    const db = await openDatabase(this.path);
     if (!db) {
       const fallbackPath = this.path.endsWith(".sqlite") ? `${this.path}.jsonl` : this.path;
-      await new JsonlCaptureStore(fallbackPath).initialize();
+      this.fallbackStore = new JsonlCaptureStore(fallbackPath, this.retentionMs);
+      await this.fallbackStore.initialize();
+      return;
     }
+    this.db = db;
+    this.db.run(
+      `create table if not exists captures (
+        id text primary key,
+        kind text not null,
+        timestamp integer not null,
+        session_id text,
+        message_id text,
+        provider_id text,
+        model_id text,
+        payload_json text not null
+      )`
+    );
+    this.db.run(`create index if not exists captures_timestamp_idx on captures(timestamp)`);
+    this.db.run(`create index if not exists captures_session_idx on captures(session_id)`);
+    this.db.run(`create index if not exists captures_kind_timestamp_idx on captures(kind, timestamp)`);
+    this.pruneExpired();
+    this.db.sync();
   }
   async append(record) {
-    const db = await this.database();
-    if (!db) {
-      const fallbackPath = this.path.endsWith(".sqlite") ? `${this.path}.jsonl` : this.path;
-      await new JsonlCaptureStore(fallbackPath).append(record);
+    if (this.fallbackStore) {
+      await this.fallbackStore.append(record);
       return;
     }
-    db.run(
+    if (!this.db) {
+      await mkdir(dirname(this.path), { recursive: true });
+      const db = await openDatabase(this.path);
+      if (!db) {
+        const fallbackPath = this.path.endsWith(".sqlite") ? `${this.path}.jsonl` : this.path;
+        this.fallbackStore = new JsonlCaptureStore(fallbackPath, this.retentionMs);
+        await this.fallbackStore.initialize();
+        await this.fallbackStore.append(record);
+        return;
+      }
+      this.db = db;
+    }
+    this.db.run(
       `insert into captures (
         id, kind, timestamp, session_id, message_id, provider_id, model_id, payload_json
       ) values (?, ?, ?, ?, ?, ?, ?, ?)`,
@@ -197,47 +302,34 @@ var SqliteCaptureStore = class {
       record.modelID ?? null,
       JSON.stringify(record.payload)
     );
+    this.pruneExpired();
+    this.db.sync();
   }
   async close() {
-    this.db?.close?.();
+    this.db?.close();
     this.db = void 0;
+    this.fallbackStore = void 0;
   }
-  async database() {
-    if (this.db) return this.db;
-    if (this.unavailable) return void 0;
-    try {
-      await mkdir(dirname(this.path), { recursive: true });
-      const mod = await import("bun:sqlite").catch(() => void 0);
-      if (!mod) {
-        this.unavailable = true;
-        return void 0;
-      }
-      const db = new mod.Database(this.path);
-      initializeSchema(db);
-      this.db = db;
-      return db;
-    } catch {
-      this.unavailable = true;
-      return void 0;
-    }
+  pruneExpired(now = Date.now()) {
+    const cutoff = retentionCutoff(now, this.retentionMs);
+    if (cutoff === void 0) return;
+    this.db?.run("delete from captures where timestamp < ?", cutoff);
   }
 };
-function initializeSchema(db) {
-  db.run(`create table if not exists captures (
-    id text primary key,
-    kind text not null,
-    timestamp integer not null,
-    session_id text,
-    message_id text,
-    provider_id text,
-    model_id text,
-    payload_json text not null
-  )`);
-  db.run(`create index if not exists captures_timestamp_idx on captures(timestamp)`);
-  db.run(`create index if not exists captures_session_idx on captures(session_id)`);
-}
 function createCaptureStore(options = {}) {
-  return new SqliteCaptureStore(resolveCapturePath(options));
+  return new SqliteCaptureStore(resolveCapturePath(options), retentionMsFromDays(resolveRetentionDays(options.retentionDays)));
+}
+function resolveRetentionDays(value) {
+  if (value === void 0 || value === null || value === "") return DEFAULT_RETENTION_DAYS;
+  const numeric = typeof value === "number" ? value : typeof value === "string" ? Number.parseFloat(value) : Number.NaN;
+  if (!Number.isFinite(numeric) || numeric < 0) return DEFAULT_RETENTION_DAYS;
+  return numeric;
+}
+function retentionMsFromDays(days) {
+  return days <= 0 ? void 0 : days * DAY_MS;
+}
+function retentionCutoff(now, retentionMs) {
+  return retentionMs === void 0 ? void 0 : now - retentionMs;
 }
 
 export {
@@ -251,6 +343,8 @@ export {
   normalizeEventCapture,
   normalizeToolCapture,
   JsonlCaptureStore,
+  openDatabase,
   SqliteCaptureStore,
-  createCaptureStore
+  createCaptureStore,
+  resolveRetentionDays
 };

package/dist/cli.d.ts

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { C as CaptureRecord } from './capture-DkASdFpu.js';
+import { C as CaptureRecord } from './capture-B6sM1QQA.js';
 
 type HistoryMessage = {
     id: string;
@@ -22,6 +22,7 @@ type HistoryRequest = {
     modelID?: string | undefined;
     summary: string;
     payload: Record<string, unknown>;
+    system?: HistoryRequestHeaders | undefined;
     headers?: HistoryRequestHeaders | undefined;
     response?: HistoryResponse | undefined;
 };
@@ -46,8 +47,12 @@ type HistoryResponse = {
 };
 type HistorySession = {
     id: string;
+    parentID?: string | undefined;
     title?: string | undefined;
     updatedAt?: number | undefined;
+    cwd?: string | undefined;
+    root?: string | undefined;
+    project?: string | undefined;
     messages: HistoryMessage[];
     requests: HistoryRequest[];
 };
@@ -67,6 +72,7 @@ type CliOptions = {
     port?: number | undefined;
     output?: string | undefined;
     configDir?: string | undefined;
+    retentionDays?: number | undefined;
     dryRun: boolean;
     keepData: boolean;
 };