@rejacky/opencode-insights 0.1.4 → 0.1.6

package/README.md

@@ -12,45 +12,89 @@ 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
+```
+
+## Update
+
+`opencode plugin` does not re-install or upgrade already-cached packages. To update to the latest version, clear the cached copy and reinstall:
+
+```bash
+rm -rf ~/.cache/opencode/packages/node_modules/@rejacky/opencode-insights
+opencode plugin @rejacky/opencode-insights --global
+```
+
+Then restart OpenCode.
+
+You can also run the latest published version directly via `npx` without reinstalling:
+
+```bash
+npx -y -p @rejacky/opencode-insights opencode-insights doctor
+```
+
+## Preview
+
+![opencode-insights TUI](assets/tui.png)
+
+Inspect captured sessions with the web viewer:
+
+```bash
+opencode-insights open
+```
+
+OpenCode Insights viewer listening at http://127.0.0.1:8765
+
+![opencode-insights web viewer](assets/insights.png)
+
 ## 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
 ```
 
+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 +102,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 +119,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, confirm `~/.local/bin` is on `PATH`, or run the installed binary directly from OpenCode's package cache:
+
+```bash
+~/.cache/opencode/packages/node_modules/.bin/opencode-insights doctor
 ```
 
-If the command is not available through `npx`, run the installed binary directly from your OpenCode config directory:
+You can also run the published package through npm without relying on the OpenCode cache:
 
 ```bash
-./node_modules/.bin/opencode-insights doctor
+npx -y -p @rejacky/opencode-insights opencode-insights doctor
 ```
 
 ## Storage
@@ -144,7 +195,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 +205,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
       }
     ]
   ]
@@ -164,71 +218,3 @@ You can override storage in `opencode.json` or `opencode.jsonc`:
 This plugin intentionally does not redact anything. It stores data locally exactly as OpenCode exposes it to plugin hooks and events.
 
 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.
-
-To enable them, pass `experimental: true` in the plugin options:
-
-```json
-{
-  "plugin": [
-    [
-      "@rejacky/opencode-insights",
-      {
-        "experimental": true
-      }
-    ]
-  ]
-}
-```
-
-## Captured Hooks
-
-The viewer labels OpenCode hook records as `HOOK` because they are not raw HTTP requests.
-
-Common hook rows:
-
-- `HOOK title`: OpenCode title-generation model call, usually only on the first turn.
-- `HOOK build`: Main assistant response model-call hook.
-- `HOOK messages.transform`: Final conversation messages OpenCode prepared before model execution.
-- `HOOK system.transform`: System prompt strings OpenCode prepared before model execution.
-
-Hook payload meaning:
-
-- `payload.input`: Context OpenCode passed into the plugin hook.
-- `payload.output`: Value returned by the hook, such as model settings or transformed messages.
-- `headers.output.headers`: Headers returned by the headers hook.
-- Response text is captured from OpenCode event stream rows such as `message.part.delta` and `message.part.updated`.
-
-The plugin reconstructs a logical LLM request from hooks and events. It does not capture the final provider HTTP body unless OpenCode exposes a lower-level transport hook in the future.
-
-## SQLite Queries
-
-Count captured rows:
-
-```bash
-sqlite3 ~/.opencode-insights/insights.sqlite \
-  "select kind, count(*) from captures group by kind order by kind;"
-```
-
-Find text in captured payloads:
-
-```bash
-sqlite3 ~/.opencode-insights/insights.sqlite "
-select datetime(timestamp/1000,'unixepoch','localtime') as time,
-       kind,
-       session_id,
-       message_id,
-       substr(payload_json, 1, 1200) as preview
-from captures
-where payload_json like '%search text%'
-order by timestamp desc
-limit 20;
-"
-```
-
-## Development
-
-Development and publish notes live in [DEVELOPMENT.md](./DEVELOPMENT.md).

package/dist/{capture-DkASdFpu.d.ts → capture-Dy799i3Z.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,32 @@ 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 function extractEventType(payload: Record<string, unknown>): string | null;
 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, extractEventType as f, normalizeChatMessageCapture as g, normalizeChatParamsCapture as h, normalizeEventCapture as i, normalizeExperimentalChatMessagesTransformCapture as j, normalizeExperimentalChatSystemTransformCapture as k, normalizeToolCapture as l, resolveRetentionDays as m, normalizeChatHeadersCapture as n, openDatabase as o, resolveCapturePath as r };

package/dist/{chunk-Q5ROKOOJ.js → chunk-XCHFXQIL.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,45 +153,168 @@ 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;
+}
+function extractEventType(payload) {
+  const event = isRecord(payload.event) ? payload.event : {};
+  return typeof event.type === "string" ? event.type : null;
+}
 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,
+        event_type 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.db.run(`create index if not exists captures_kind_type_ts_idx on captures(kind, event_type, timestamp)`);
+    const existingColumns = db.all("select name from pragma_table_info('captures') where name = 'event_type'");
+    if (existingColumns.length === 0) {
+      try {
+        db.run(`alter table captures add column event_type text`);
+      } catch {
+      }
+    }
+    try {
+      db.run(`update captures set event_type = json_extract(payload_json, '$.event.type') where kind = 'event' and event_type is null`);
+    } catch {
     }
+    try {
+      db.run(`pragma journal_mode = wal`);
+    } catch {
+    }
+    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;
+    }
+    const eventType = record.kind === "event" ? extractEventType(record.payload) : null;
+    this.db.run(
       `insert into captures (
-        id, kind, timestamp, session_id, message_id, provider_id, model_id, payload_json
-      ) values (?, ?, ?, ?, ?, ?, ?, ?)`,
+        id, kind, timestamp, session_id, message_id, provider_id, model_id, event_type, payload_json
+      ) values (?, ?, ?, ?, ?, ?, ?, ?, ?)`,
       record.id,
       record.kind,
       record.timestamp,
@@ -195,49 +322,37 @@ var SqliteCaptureStore = class {
       record.messageID ?? null,
       record.providerID ?? null,
       record.modelID ?? null,
+      eventType,
       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 +366,9 @@ export {
   normalizeEventCapture,
   normalizeToolCapture,
   JsonlCaptureStore,
+  openDatabase,
+  extractEventType,
   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-Dy799i3Z.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;
 };