opencode-top 3.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 OpenCode Monitor Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,35 @@
+# OCMonitor
+
+Monitor OpenCode AI coding sessions with a modern TUI.
+
+## Install
+
+```bash
+npm install
+npm run build
+```
+
+## Usage
+
+```bash
+npm run start live     # Live monitoring dashboard
+npm run start sessions # List all sessions
+```
+
+### Keyboard shortcuts (live mode)
+
+- `j/k` or arrows: Navigate
+- `e` or enter: Expand/collapse
+- `h/l`: Resize panes
+- `r`: Refresh
+- `q`: Quit
+
+## Structure
+
+```
+src/
+├── core/       # Domain models & business logic
+├── data/       # SQLite loader, pricing data
+├── ui/         # Ink components (React TUI)
+└── cli.ts      # Entry point
+```

package/bin/octop.js

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(__dirname, "..");
+
+// Use tsx to run the TypeScript source
+const { register } = await import("tsx/esm/api");
+register();
+
+await import(join(pkgRoot, "src", "cli.ts"));

package/bin/octop.mjs

@@ -0,0 +1,13 @@
+#!/usr/bin/env node
+import { createRequire } from "module";
+import { fileURLToPath } from "url";
+import { dirname, join } from "path";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(__dirname, "..");
+
+// Use tsx to run the TypeScript source
+const { register } = await import("tsx/esm/api");
+register();
+
+await import(join(pkgRoot, "src", "cli.ts"));

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "opencode-top",
+  "version": "3.0.0",
+  "description": "Monitor OpenCode AI coding sessions - Token usage, costs, and agent analytics",
+  "type": "module",
+  "bin": {
+    "opencode-top": "./bin/octop.js"
+  },
+  "scripts": {
+    "build": "node build.mjs",
+    "dev": "tsc --watch",
+    "start": "node --import tsx src/cli.ts",
+    "lint": "biome check src",
+    "format": "biome format src --write",
+    "test": "vitest",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "better-sqlite3": "^11.7.0",
+    "commander": "^12.1.0",
+    "decimal.js": "^10.4.3",
+    "ink": "^5.0.1",
+    "ink-text-input": "^6.0.0",
+    "react": "^18.3.1",
+    "zod": "^3.24.1"
+  },
+  "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
+    "@types/better-sqlite3": "^7.6.11",
+    "@types/node": "^22.10.5",
+    "@types/react": "^18.3.3",
+    "esbuild": "^0.27.4",
+    "tsx": "^4.19.2",
+    "typescript": "^5.7.2",
+    "vitest": "^2.1.8"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "keywords": [
+    "opencode",
+    "ai",
+    "monitoring",
+    "tui",
+    "cli"
+  ],
+  "license": "MIT"
+}

package/src/cli.ts

@@ -0,0 +1,60 @@
+#!/usr/bin/env node
+import React from "react";
+import { render } from "ink";
+import { program } from "commander";
+import { App } from "./ui/App";
+import { loadSessions, getDbPath } from "./data/sqlite";
+import { groupSessionsToWorkflows } from "./core/agents";
+import { getWorkflowCostSingle, getSessionDuration } from "./core/session";
+import { getPricing } from "./data/pricing";
+
+const pkg = { version: "3.0.0", name: "ocmonitor" };
+
+program
+  .name(pkg.name)
+  .version(pkg.version)
+  .description("Monitor OpenCode AI coding sessions");
+
+program
+  .command("live")
+  .description("Start live monitoring dashboard")
+  .option("-i, --interval <ms>", "Refresh interval in milliseconds", "2000")
+  .action((options) => {
+    const refreshInterval = Number.parseInt(options.interval, 10);
+    render(React.createElement(App, { refreshInterval }));
+  });
+
+program
+  .command("sessions")
+  .description("List all sessions")
+  .option("-l, --limit <n>", "Limit number of sessions", "50")
+  .action((options) => {
+    const limit = Number.parseInt(options.limit, 10);
+    try {
+      const sessions = loadSessions(getDbPath());
+      const workflows = groupSessionsToWorkflows(sessions);
+
+      const shown = workflows.slice(0, limit);
+      console.log(`\nOCMonitor — ${shown.length}/${workflows.length} workflows\n`);
+      console.log(`${"Title".padEnd(40)} ${"Project".padEnd(20)} ${"Cost".padEnd(10)} Dur`);
+      console.log("─".repeat(80));
+
+      for (const workflow of shown) {
+        const { mainSession } = workflow;
+        const pricing = getPricing(mainSession.interactions[0]?.modelId ?? "");
+        const cost = getWorkflowCostSingle(workflow, pricing);
+        const dur = getSessionDuration(mainSession);
+        const title = (mainSession.title ?? "Untitled").slice(0, 38).padEnd(40);
+        const project = (mainSession.projectName ?? "—").slice(0, 18).padEnd(20);
+        const costStr = `$${cost.toFixed(3)}`.padEnd(10);
+        const durStr = dur > 0 ? `${Math.floor(dur / 60000)}m${Math.floor((dur % 60000) / 1000)}s` : "—";
+        console.log(`${title} ${project} ${costStr} ${durStr}`);
+      }
+      console.log();
+    } catch (e) {
+      console.error("Error:", e instanceof Error ? e.message : e);
+      process.exit(1);
+    }
+  });
+
+program.parse();

package/src/core/agents.ts

@@ -0,0 +1,78 @@
+import type { Session, Workflow, AgentNode } from "./types";
+
+export class AgentRegistry {
+  private mainAgents = new Set(["plan", "build"]);
+  private subAgents = new Set(["explore"]);
+
+  isMainAgent(agent: string | null): boolean {
+    if (!agent) return true;
+    return this.mainAgents.has(agent);
+  }
+
+  isSubAgent(agent: string | null): boolean {
+    if (!agent) return false;
+    return this.subAgents.has(agent);
+  }
+
+  addMainAgent(agent: string): void {
+    this.mainAgents.add(agent);
+  }
+
+  addSubAgent(agent: string): void {
+    this.subAgents.add(agent);
+  }
+}
+
+function buildAgentNode(
+  session: Session,
+  sessionMap: Map<string, Session>,
+  depth: number
+): AgentNode {
+  // Find all direct children of this session
+  const children: AgentNode[] = [];
+  for (const [, s] of sessionMap) {
+    if (s.parentId === session.id) {
+      children.push(buildAgentNode(s, sessionMap, depth + 1));
+    }
+  }
+  // Sort children by timeCreated
+  children.sort(
+    (a, b) => (a.session.timeCreated ?? 0) - (b.session.timeCreated ?? 0)
+  );
+  return { session, children, depth };
+}
+
+function collectAllDescendants(node: AgentNode): Session[] {
+  const result: Session[] = [];
+  for (const child of node.children) {
+    result.push(child.session);
+    result.push(...collectAllDescendants(child));
+  }
+  return result;
+}
+
+export function groupSessionsToWorkflows(
+  sessions: Session[],
+  _registry?: AgentRegistry
+): Workflow[] {
+  const sessionMap = new Map<string, Session>(sessions.map((s) => [s.id, s]));
+
+  // Find root sessions (no parentId)
+  const roots = sessions.filter((s) => s.parentId === null);
+
+  const workflows: Workflow[] = [];
+
+  for (const root of roots) {
+    const agentTree = buildAgentNode(root, sessionMap, 0);
+    const subAgentSessions = collectAllDescendants(agentTree);
+
+    workflows.push({
+      id: root.id,
+      mainSession: root,
+      subAgentSessions,
+      agentTree,
+    });
+  }
+
+  return workflows;
+}

package/src/core/session.ts

@@ -0,0 +1,315 @@
+import Decimal from "decimal.js";
+import { TokenUsage } from "./types";
+import type { Session, Workflow, ToolUsage, ModelPricing, OverviewStats } from "./types";
+import type { MessagePart } from "./types";
+
+export function getSessionTokens(session: Session): TokenUsage {
+  return session.interactions.reduce((acc, i) => acc.add(i.tokens), new TokenUsage());
+}
+
+export function getSessionCost(session: Session, pricing: Map<string, ModelPricing>): Decimal {
+  return session.interactions.reduce((acc, i) => {
+    const p = pricing.get(i.modelId);
+    if (!p) return acc;
+    return acc.plus(i.tokens.calculateCost(p));
+  }, new Decimal(0));
+}
+
+export function getSessionCostSingle(session: Session, pricing: ModelPricing): Decimal {
+  return session.interactions.reduce((acc, i) => {
+    return acc.plus(i.tokens.calculateCost(pricing));
+  }, new Decimal(0));
+}
+
+export function getSessionDuration(session: Session): number {
+  const interactions = session.interactions;
+  if (interactions.length === 0) return 0;
+
+  // Use real time.completed when available
+  const times: number[] = [];
+  for (const i of interactions) {
+    if (i.time.created !== null) times.push(i.time.created);
+    if (i.time.completed !== null) times.push(i.time.completed);
+  }
+
+  if (times.length === 0) return 0;
+  return Math.max(...times) - Math.min(...times);
+}
+
+export function getWorkflowTokens(workflow: Workflow): TokenUsage {
+  const main = getSessionTokens(workflow.mainSession);
+  const subs = workflow.subAgentSessions.reduce(
+    (acc, s) => acc.add(getSessionTokens(s)),
+    new TokenUsage()
+  );
+  return main.add(subs);
+}
+
+export function getWorkflowCost(workflow: Workflow, pricing: Map<string, ModelPricing>): Decimal {
+  const main = getSessionCost(workflow.mainSession, pricing);
+  const subs = workflow.subAgentSessions.reduce(
+    (acc, s) => acc.plus(getSessionCost(s, pricing)),
+    new Decimal(0)
+  );
+  return main.plus(subs);
+}
+
+export function getWorkflowCostSingle(workflow: Workflow, pricing: ModelPricing): Decimal {
+  const main = getSessionCostSingle(workflow.mainSession, pricing);
+  const subs = workflow.subAgentSessions.reduce(
+    (acc, s) => acc.plus(getSessionCostSingle(s, pricing)),
+    new Decimal(0)
+  );
+  return main.plus(subs);
+}
+
+export function getToolUsage(session: Session): ToolUsage[] {
+  const tools = new Map<
+    string,
+    { calls: number; successes: number; failures: number; totalDurationMs: number; recentErrors: string[] }
+  >();
+
+  for (const interaction of session.interactions) {
+    for (const part of interaction.parts) {
+      if (part.type !== "tool") continue;
+
+      const existing = tools.get(part.toolName) ?? {
+        calls: 0,
+        successes: 0,
+        failures: 0,
+        totalDurationMs: 0,
+        recentErrors: [],
+      };
+
+      existing.calls++;
+      if (part.status === "completed") {
+        existing.successes++;
+      } else if (part.status === "error") {
+        existing.failures++;
+        // Keep last 3 errors
+        if (existing.recentErrors.length < 3) {
+          existing.recentErrors.push(part.output?.slice(0, 200) ?? "unknown error");
+        }
+      }
+
+      const durationMs = part.timeEnd > 0 && part.timeStart > 0 ? part.timeEnd - part.timeStart : 0;
+      existing.totalDurationMs += durationMs;
+
+      tools.set(part.toolName, existing);
+    }
+  }
+
+  return Array.from(tools.entries()).map(([name, stats]) => ({
+    name,
+    calls: stats.calls,
+    successes: stats.successes,
+    failures: stats.failures,
+    totalDurationMs: stats.totalDurationMs,
+    avgDurationMs: stats.calls > 0 ? stats.totalDurationMs / stats.calls : 0,
+    recentErrors: stats.recentErrors,
+  }));
+}
+
+export function getWorkflowToolUsage(workflow: Workflow): ToolUsage[] {
+  const allSessions = [workflow.mainSession, ...workflow.subAgentSessions];
+  const merged = new Map<
+    string,
+    { calls: number; successes: number; failures: number; totalDurationMs: number; recentErrors: string[] }
+  >();
+
+  for (const session of allSessions) {
+    const usage = getToolUsage(session);
+    for (const tool of usage) {
+      const existing = merged.get(tool.name) ?? {
+        calls: 0,
+        successes: 0,
+        failures: 0,
+        totalDurationMs: 0,
+        recentErrors: [],
+      };
+      existing.calls += tool.calls;
+      existing.successes += tool.successes;
+      existing.failures += tool.failures;
+      existing.totalDurationMs += tool.totalDurationMs;
+      for (const err of tool.recentErrors) {
+        if (existing.recentErrors.length < 3) existing.recentErrors.push(err);
+      }
+      merged.set(tool.name, existing);
+    }
+  }
+
+  return Array.from(merged.entries()).map(([name, stats]) => ({
+    name,
+    calls: stats.calls,
+    successes: stats.successes,
+    failures: stats.failures,
+    totalDurationMs: stats.totalDurationMs,
+    avgDurationMs: stats.calls > 0 ? stats.totalDurationMs / stats.calls : 0,
+    recentErrors: stats.recentErrors,
+  }));
+}
+
+export function getOutputRate(session: Session): number {
+  const rates = session.interactions
+    .map((i) => i.outputRate)
+    .filter((r) => r > 0)
+    .sort((a, b) => a - b);
+
+  if (rates.length === 0) return 0;
+
+  const mid = Math.floor(rates.length / 2);
+  return rates.length % 2 !== 0 ? rates[mid] : (rates[mid - 1] + rates[mid]) / 2;
+}
+
+export function computeOverviewStats(
+  workflows: Workflow[],
+  pricing: Map<string, ModelPricing>
+): OverviewStats {
+  const totalTokens = { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, reasoning: 0 };
+  let totalCost = new Decimal(0);
+  const modelBreakdown = new Map<string, { cost: Decimal; tokens: number; calls: number }>();
+  const projectBreakdown = new Map<string, { cost: Decimal; sessions: number }>();
+  const agentBreakdown = new Map<string, { cost: Decimal; calls: number }>();
+  const agentToolErrors = new Map<string, { calls: number; errors: number }>();
+  const toolCallCounts = new Map<string, { calls: number; errors: number; totalDurationMs: number }>();
+  const weeklyTokenMap = new Map<string, number>();
+  const weeklySessionMap = new Map<string, number>();
+  const hourlyActivity = new Array(24).fill(0);
+
+  const now = Date.now();
+  const sevenDaysAgo = now - 7 * 86_400_000;
+
+  for (const workflow of workflows) {
+    const allSessions = [workflow.mainSession, ...workflow.subAgentSessions];
+
+    for (const session of allSessions) {
+      const projName = session.projectName ?? "Unknown";
+      const projEntry = projectBreakdown.get(projName) ?? { cost: new Decimal(0), sessions: 0 };
+      projEntry.sessions++;
+
+      // Weekly session count
+      const sessionTs = session.timeCreated;
+      if (sessionTs && sessionTs >= sevenDaysAgo) {
+        const day = new Date(sessionTs).toISOString().slice(5, 10); // MM-DD
+        weeklySessionMap.set(day, (weeklySessionMap.get(day) ?? 0) + 1);
+      }
+
+      for (const interaction of session.interactions) {
+        const p = pricing.get(interaction.modelId);
+        const cost = p ? interaction.tokens.calculateCost(p) : new Decimal(0);
+
+        totalCost = totalCost.plus(cost);
+        projEntry.cost = projEntry.cost.plus(cost);
+
+        totalTokens.input += interaction.tokens.input;
+        totalTokens.output += interaction.tokens.output;
+        totalTokens.cacheRead += interaction.tokens.cacheRead;
+        totalTokens.cacheWrite += interaction.tokens.cacheWrite;
+        totalTokens.reasoning += interaction.tokens.reasoning;
+
+        // Model breakdown
+        const modelEntry = modelBreakdown.get(interaction.modelId) ?? {
+          cost: new Decimal(0),
+          tokens: 0,
+          calls: 0,
+        };
+        modelEntry.cost = modelEntry.cost.plus(cost);
+        modelEntry.tokens += interaction.tokens.total;
+        modelEntry.calls++;
+        modelBreakdown.set(interaction.modelId, modelEntry);
+
+        // Agent breakdown
+        const agentKey = interaction.agent ?? "main";
+        const agentEntry = agentBreakdown.get(agentKey) ?? { cost: new Decimal(0), calls: 0 };
+        agentEntry.cost = agentEntry.cost.plus(cost);
+        agentEntry.calls++;
+        agentBreakdown.set(agentKey, agentEntry);
+
+        // Hourly activity
+        const ts = interaction.time.created;
+        if (ts) {
+          hourlyActivity[new Date(ts).getHours()]++;
+
+          // Weekly token trend
+          if (ts >= sevenDaysAgo) {
+            const day = new Date(ts).toISOString().slice(5, 10);
+            weeklyTokenMap.set(day, (weeklyTokenMap.get(day) ?? 0) + interaction.tokens.total);
+          }
+        }
+
+        // Tool stats: per-tool call counts and agent tool errors
+        for (const part of interaction.parts) {
+          if (part.type !== "tool") continue;
+
+          const isError = part.status === "error";
+          const dur = part.timeEnd > 0 && part.timeStart > 0 ? part.timeEnd - part.timeStart : 0;
+
+          // Tool call counts
+          const toolEntry = toolCallCounts.get(part.toolName) ?? { calls: 0, errors: 0, totalDurationMs: 0 };
+          toolEntry.calls++;
+          if (isError) toolEntry.errors++;
+          toolEntry.totalDurationMs += dur;
+          toolCallCounts.set(part.toolName, toolEntry);
+
+          // Agent tool errors
+          const agentToolEntry = agentToolErrors.get(agentKey) ?? { calls: 0, errors: 0 };
+          agentToolEntry.calls++;
+          if (isError) agentToolEntry.errors++;
+          agentToolErrors.set(agentKey, agentToolEntry);
+        }
+      }
+
+      projectBreakdown.set(projName, projEntry);
+    }
+  }
+
+  // Build 7-day arrays (last 7 days, MM-DD labels)
+  const today = new Date();
+  const weeklyTokens: { date: string; tokens: number }[] = [];
+  const weeklySessions: { date: string; sessions: number }[] = [];
+  for (let i = 6; i >= 0; i--) {
+    const d = new Date(today);
+    d.setDate(d.getDate() - i);
+    const day = d.toISOString().slice(5, 10);
+    weeklyTokens.push({ date: day, tokens: weeklyTokenMap.get(day) ?? 0 });
+    weeklySessions.push({ date: day, sessions: weeklySessionMap.get(day) ?? 0 });
+  }
+
+  return {
+    totalCost,
+    totalTokens: new TokenUsage(
+      totalTokens.input,
+      totalTokens.output,
+      totalTokens.cacheRead,
+      totalTokens.cacheWrite,
+      totalTokens.reasoning
+    ),
+    modelBreakdown,
+    projectBreakdown,
+    agentBreakdown,
+    agentToolErrors,
+    toolCallCounts,
+    weeklyTokens,
+    weeklySessions,
+    hourlyActivity,
+  };
+}
+
+/** Build spark series (8 levels) from numeric array */
+export function buildSparkSeries(values: number[]): string {
+  if (values.length === 0) return "";
+  const max = Math.max(...values);
+  if (max === 0) return "▁".repeat(values.length);
+  const chars = ["▁", "▂", "▃", "▄", "▅", "▆", "▇", "█"];
+  return values
+    .map((v) => {
+      const idx = Math.min(7, Math.floor((v / max) * 8));
+      return chars[idx];
+    })
+    .join("");
+}
+
+/** All parts across all interactions in a session */
+export function getAllParts(session: Session): MessagePart[] {
+  return session.interactions.flatMap((i) => i.parts);
+}