pantheon-opencode 1.4.3 → 1.5.0-beta.2

package/src/pantheon/cost-command.ts

@@ -1,20 +1,20 @@
 /**
- * Cost Command (Wave 4, PR #46) — `pantheon_cost` structural tool: cost +
- * token visibility by agent, straight from opencode.db.
+ * Token Command — `pantheon_cost` structural tool: token visibility for
+ * delegation traffic, straight from opencode.db.
  *
- * Reads the opencode session database READ-ONLY (sum cost + tokens by
- * agent over the last N days → markdown table). Zero new dependencies:
+ * Reads the opencode session database READ-ONLY (sum tokens by agent and
+ * phase over the last N days → markdown table). Zero new dependencies:
  *   - primary path: node:sqlite (DatabaseSync, readOnly) — node ≥ 22.5;
- *   - fallback: spawn scripts/cost.mjs (node:sqlite, prints JSON) when the
- *     direct import is unavailable;
+ *   - CLI fallback: spawn scripts/cost.mjs with its explicit flag-based
+ *     interface when the direct import is unavailable;
  *   - missing/unreadable db → FRIENDLY error string, never a crash (tools
  *     return errors as TEXT).
  *
  * dbPath resolution: explicit option > env PANTHEON_COST_DB > the version-aware
  * default selected by PANTHEON_OPENCODE_VERSION (v1 or v2). An unset version
  * deliberately preserves V1 behavior. The tool is wired in
- * plugin.ts (usable by zeus and any agent with tool access — no routing change
- * needed).
+ * plugin.ts alongside the delegation toolset (usable by zeus and any agent
+ * with tool access — no routing change needed).
  *
  * @module cost-command
  */
@@ -25,16 +25,17 @@ import { join } from 'node:path'
 import { promisify } from 'node:util'
 import { z } from 'zod'
 
-import type { ToolContextLike } from './tool-context.ts'
+import type { ToolContextLike } from './delegation.ts'
 
 const execFileAsync = promisify(execFile)
 
-/** One aggregated cost row (per agent). */
+/** One aggregated token row (per agent and phase). */
 export interface CostRow {
   agent: string
-  costUsd: number
+  phase: string
   tokensInput: number
   tokensOutput: number
+  tokensTotal: number
 }
 
 export interface CostCommandOptions {
@@ -44,7 +45,7 @@ export interface CostCommandOptions {
 
 export type OpenCodeVersion = 'v1' | 'v2'
 
-/** One cost tool: description + zod args shape + execute. */
+/** One cost tool: description + zod args shape + execute (delegation.ts shape). */
 export interface CostTool<Args extends z.ZodRawShape = typeof costArgs> {
   description: string
   args: Args
@@ -62,7 +63,7 @@ const costArgs = {
     .min(1)
     .max(365)
     .optional()
-    .describe('Number of days of cost history to include (default 7).'),
+    .describe('Number of days of delegation history to include (default 7).'),
 } satisfies z.ZodRawShape
 
 /** Return the safe, isolated state DB name for an OpenCode version. */
@@ -123,38 +124,46 @@ function assertCompatibleSchema(db: {
   }
 }
 
-/** Aggregate cost + tokens by agent via node:sqlite (read-only). */
+/** Aggregate tokens by agent and phase via node:sqlite (read-only). */
 async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRow[]> {
   const sqlite = await import('node:sqlite')
   const db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
   try {
     assertCompatibleSchema(db)
     const since = Date.now() - days * 86_400_000
-    const rows = db.prepare('SELECT data FROM message WHERE time_created >= ?').all(since)
-    return aggregateMessages(rows.map((row) => String(row.data)))
+    const rows = db
+      .prepare('SELECT data FROM message WHERE time_created >= ?')
+      .all(since) as Array<{ data?: unknown }>
+    // Rows without a data payload carry no cost info — skip them instead of
+    // coercing null/undefined into "null"/"undefined" strings.
+    return aggregateMessages(rows.flatMap((row) => (row?.data == null ? [] : [String(row.data)])))
   } finally {
     db.close()
   }
 }
 
-/** Fallback: delegate the same aggregation to scripts/cost.mjs (node:sqlite). */
+/** CLI fallback: delegate the same aggregation to scripts/cost.mjs. */
 async function queryWithScript(
   scriptPath: string,
   dbPath: string,
   days: number,
 ): Promise<CostRow[]> {
-  const { stdout } = await execFileAsync(process.execPath, [scriptPath, dbPath, String(days)], {
-    timeout: 15_000,
-    encoding: 'utf8',
-  })
+  const { stdout } = await execFileAsync(
+    process.execPath,
+    [scriptPath, '--db-path', dbPath, '--days', String(days)],
+    {
+      timeout: 15_000,
+      encoding: 'utf8',
+    },
+  )
   const parsed = JSON.parse(stdout) as { ok: boolean; rows?: CostRow[]; error?: string }
   if (!parsed.ok) throw new Error(parsed.error ?? 'cost.mjs failed')
   return parsed.rows ?? []
 }
 
-/** Parse message.data JSON rows and aggregate cost + tokens by assistant agent. */
+/** Parse message.data JSON rows and aggregate tokens by assistant agent/phase. */
 function aggregateMessages(dataValues: readonly string[]): CostRow[] {
-  const byAgent = new Map<string, CostRow>()
+  const byAgentAndPhase = new Map<string, CostRow>()
   for (const value of dataValues) {
     try {
       const outer = JSON.parse(value) as Record<string, unknown>
@@ -165,45 +174,57 @@ function aggregateMessages(dataValues: readonly string[]): CostRow[] {
       if (info.role !== 'assistant') continue
       const agent = typeof info.agent === 'string' && info.agent !== '' ? info.agent : null
       if (agent === null) continue
-      const costUsd = Number(info.cost) || 0
+      const metadata = info.metadata as Record<string, unknown> | undefined
+      const phase =
+        (typeof info.phase === 'string' && info.phase) ||
+        (typeof metadata?.phase === 'string' && metadata.phase) ||
+        'unknown'
       const tokens = (info.tokens ?? {}) as Record<string, unknown>
       const tokensInput = Number(tokens.input) || 0
       const tokensOutput = Number(tokens.output) || 0
-      const acc = byAgent.get(agent) ?? { agent, costUsd: 0, tokensInput: 0, tokensOutput: 0 }
-      acc.costUsd += costUsd
+      const key = `${agent}\u0000${phase}`
+      const acc = byAgentAndPhase.get(key) ?? {
+        agent,
+        phase,
+        tokensInput: 0,
+        tokensOutput: 0,
+        tokensTotal: 0,
+      }
       acc.tokensInput += tokensInput
       acc.tokensOutput += tokensOutput
-      byAgent.set(agent, acc)
+      acc.tokensTotal += tokensInput + tokensOutput
+      byAgentAndPhase.set(key, acc)
     } catch {
       // Skip malformed rows — a partial ledger never breaks the report.
     }
   }
-  return [...byAgent.values()].sort((a, b) => b.costUsd - a.costUsd)
+  return [...byAgentAndPhase.values()].sort((a, b) => b.tokensTotal - a.tokensTotal)
 }
 
 /** Render the aggregate as a markdown table with a total row. */
 function renderMarkdown(rows: readonly CostRow[], days: number): string {
   if (rows.length === 0) {
-    return `## Cost by agent (last ${days} days)\n\nNo cost records in the last ${days} days.`
+    return `## Token usage by agent and phase (last ${days} days)\n\nNo token records in the last ${days} days.`
   }
   const total = rows.reduce(
     (acc, r) => {
-      acc.costUsd += r.costUsd
       acc.tokensInput += r.tokensInput
       acc.tokensOutput += r.tokensOutput
+      acc.tokensTotal += r.tokensTotal
       return acc
     },
-    { costUsd: 0, tokensInput: 0, tokensOutput: 0 },
+    { tokensInput: 0, tokensOutput: 0, tokensTotal: 0 },
   )
   const lines = [
-    `## Cost by agent (last ${days} days)`,
+    `## Token usage by agent and phase (last ${days} days)`,
     '',
-    '| Agent | Cost (USD) | Tokens In | Tokens Out |',
-    '|-------|-----------:|----------:|-----------:|',
+    '| Agent | Phase | Tokens In | Tokens Out | Tokens Total |',
+    '|-------|-------|----------:|-----------:|-------------:|',
     ...rows.map(
-      (r) => `| ${r.agent} | $${r.costUsd.toFixed(6)} | ${r.tokensInput} | ${r.tokensOutput} |`,
+      (r) =>
+        `| ${r.agent} | ${r.phase} | ${r.tokensInput} | ${r.tokensOutput} | ${r.tokensTotal} |`,
     ),
-    `| **Total** | **$${total.costUsd.toFixed(6)}** | **${total.tokensInput}** | **${total.tokensOutput}** |`,
+    `| **Total** | — | **${total.tokensInput}** | **${total.tokensOutput}** | **${total.tokensTotal}** |`,
     '',
     `Source: opencode.db (read-only)`,
   ]
@@ -214,14 +235,14 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
   const scriptPath = new URL('../../scripts/cost.mjs', import.meta.url).pathname
 
   const execute = async (args: { days?: number }, _ctx: ToolContextLike): Promise<string> => {
-    const days = args.days ?? 7
+    const days = args?.days ?? 7
     try {
       const dbPath = findExistingDb(options?.dbPath)
       if (dbPath === undefined) {
         const expected = resolveCostDbPath(options)
         return (
           `pantheon_cost failed: opencode.db not found (expected at ${expected}). ` +
-          `No cost history is available until opencode has stored session data.`
+          `No token history is available until opencode has stored session data.`
         )
       }
       const rows = await queryWithNodeSqlite(dbPath, days).catch(async (err: unknown) => {
@@ -239,7 +260,7 @@ export function createCostCommand(options?: CostCommandOptions): CostCommand {
   return {
     pantheon_cost: {
       description:
-        'Report cost + token usage by agent over the last N days, read from opencode.db (read-only, no writes).',
+        'Report input, output, and total token usage by agent and phase over the last N days, read from opencode.db (read-only, no monetary values).',
       args: costArgs,
       execute,
     },