pantheon-opencode 1.5.0-beta.1 → 1.5.0-beta.10

package/src/pantheon/cost-command.ts

@@ -1,14 +1,11 @@
 /**
- * Cost Command (Wave 4, PR #46) — `pantheon_cost` structural tool: cost +
- * token visibility for delegation traffic, 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:
- *   - primary path: node:sqlite (DatabaseSync, readOnly) — node ≥ 22.5;
- *   - fallback: spawn scripts/cost.mjs (node:sqlite, prints JSON) when the
- *     direct import is unavailable;
- *   - missing/unreadable db → FRIENDLY error string, never a crash (tools
- *     return errors as TEXT).
+ * Reads the opencode session database READ-ONLY (sum tokens by agent and
+ * phase over the last N days → markdown table). Zero new dependencies:
+ *   - only path: node:sqlite (DatabaseSync, readOnly) — node ≥ 22.5;
+ *   - missing/unreadable db → a diagnostic contract status 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
@@ -19,31 +16,47 @@
  * @module cost-command
  */
 import { execFile } from 'node:child_process'
-import { existsSync } from 'node:fs'
+import { accessSync, constants, existsSync, statSync } from 'node:fs'
 import { homedir } from 'node:os'
-import { join } from 'node:path'
-import { promisify } from 'node:util'
+import { delimiter, dirname, join } from 'node:path'
+import { fileURLToPath } from 'node:url'
 import { z } from 'zod'
 
 import type { ToolContextLike } from './delegation.ts'
+import type { NativeTaskStatus } from './native-task-status.ts'
 
-const execFileAsync = promisify(execFile)
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = dirname(__filename)
 
-/** 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 {
   /** Explicit db path (testability / unusual installs). Default: resolved candidates. */
   dbPath?: string
+  /** Injectable loader for tests; production always loads node:sqlite. */
+  sqliteLoader?: () => Promise<SqliteModule>
+  /** Injectable CLI-fallback process boundary (tests / unusual runtimes). */
+  cliFallback?: CliFallbackDeps
 }
 
 export type OpenCodeVersion = 'v1' | 'v2'
 
+interface SqliteDatabase {
+  prepare(sql: string): { get(): unknown; all(...args: unknown[]): unknown[] }
+  close(): void
+}
+
+export interface SqliteModule {
+  DatabaseSync: new (path: string, options: { readOnly: boolean }) => SqliteDatabase
+}
+
 /** One cost tool: description + zod args shape + execute (delegation.ts shape). */
 export interface CostTool<Args extends z.ZodRawShape = typeof costArgs> {
   description: string
@@ -123,9 +136,12 @@ function assertCompatibleSchema(db: {
   }
 }
 
-/** Aggregate cost + tokens by agent via node:sqlite (read-only). */
-async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRow[]> {
-  const sqlite = await import('node:sqlite')
+/** Aggregate tokens by agent and phase via node:sqlite (read-only). */
+async function queryWithNodeSqlite(
+  dbPath: string,
+  days: number,
+  sqlite: SqliteModule,
+): Promise<CostRow[]> {
   const db = new sqlite.DatabaseSync(dbPath, { readOnly: true })
   try {
     assertCompatibleSchema(db)
@@ -141,24 +157,9 @@ async function queryWithNodeSqlite(dbPath: string, days: number): Promise<CostRo
   }
 }
 
-/** Fallback: delegate the same aggregation to scripts/cost.mjs (node:sqlite). */
-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 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>
@@ -169,81 +170,363 @@ 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)`,
   ]
   return lines.join('\n')
 }
 
+// ─── CLI fallback: resolve a REAL Node, not the plugin runtime ──────────
+//
+// Under Bun (the runtime that motivates this fallback), process.execPath IS
+// the Bun binary, which has no node:sqlite — so spawning it could never work.
+// Resolve a genuine Node instead: PANTHEON_NODE → `node` on PATH → clear error.
+
+/** First Node release exposing the built-in `node:sqlite` module. */
+const NODE_SQLITE_MIN_VERSION = '22.5'
+
+/** Minimal injectable child-process boundary (tests / unusual runtimes). */
+export type ExecFileLike = (
+  file: string,
+  args: readonly string[],
+) => Promise<{ stdout: string; stderr?: string }>
+
+/** Injectables so the fallback never depends on the real machine in tests. */
+export interface CliFallbackDeps {
+  /** Environment for PANTHEON_NODE / PATH lookup. Default: process.env. */
+  env?: NodeJS.ProcessEnv
+  /** Child-process boundary. Default: node:child_process.execFile. */
+  execFile?: ExecFileLike
+  /** Executable predicate used by the PANTHEON_NODE / PATH lookups. */
+  isExecutable?: (path: string) => boolean
+}
+
+/** A real Node executable located for the CLI fallback. */
+export interface ResolvedNode {
+  path: string
+  source: 'env' | 'path'
+}
+
+type ExecFailure = Error & { stdout?: string; stderr?: string }
+
+function defaultIsExecutable(path: string): boolean {
+  try {
+    accessSync(path, constants.X_OK)
+    return statSync(path).isFile()
+  } catch {
+    return false
+  }
+}
+
+function defaultExecFile(
+  file: string,
+  args: readonly string[],
+): Promise<{ stdout: string; stderr: string }> {
+  return new Promise((resolve, reject) => {
+    execFile(file, [...args], { encoding: 'utf8' }, (error, stdout, stderr) => {
+      if (error) {
+        // execFile's callback error does not always carry the captured output;
+        // attach it so callers can surface cost.mjs's structured {ok:false}.
+        const failure = error as ExecFailure
+        if (typeof failure.stdout !== 'string') failure.stdout = stdout
+        if (typeof failure.stderr !== 'string') failure.stderr = stderr
+        reject(failure)
+        return
+      }
+      resolve({ stdout, stderr })
+    })
+  })
+}
+
+/** Scan PATH (no shell) for a `node` executable. */
+export function resolveNodeFromPath(
+  env: NodeJS.ProcessEnv,
+  isExecutable: (path: string) => boolean = defaultIsExecutable,
+): string | undefined {
+  const pathValue = env.PATH ?? env.Path ?? ''
+  if (pathValue === '') return undefined
+  const isWindows = process.platform === 'win32'
+  const extensions = isWindows
+    ? (env.PATHEXT ?? '.EXE;.CMD;.BAT;.COM').split(';').filter((ext) => ext !== '')
+    : ['']
+  for (const dir of pathValue.split(delimiter)) {
+    if (dir === '') continue
+    for (const ext of extensions) {
+      const candidate = join(dir, `node${ext}`)
+      if (isExecutable(candidate)) return candidate
+    }
+  }
+  return undefined
+}
+
+/**
+ * Resolve a REAL Node.js binary for the CLI fallback.
+ *
+ * Order: PANTHEON_NODE (must exist and be executable — an explicit override
+ * that is unusable fails fast instead of being silently ignored) → `node`
+ * from PATH. Returns undefined only when neither source is available.
+ */
+export function resolveNodeExecutable(
+  env: NodeJS.ProcessEnv = process.env,
+  isExecutable: (path: string) => boolean = defaultIsExecutable,
+): ResolvedNode | undefined {
+  const explicit = env.PANTHEON_NODE
+  if (explicit !== undefined && explicit.trim() !== '') {
+    if (isExecutable(explicit)) return { path: explicit, source: 'env' }
+    throw new Error(
+      `PANTHEON_NODE is set to "${explicit}" but that is not an existing executable file`,
+    )
+  }
+  const fromPath = resolveNodeFromPath(env, isExecutable)
+  return fromPath === undefined ? undefined : { path: fromPath, source: 'path' }
+}
+
+function execErrorMessage(err: unknown): string {
+  if (err instanceof Error) {
+    const failure = err as ExecFailure
+    const stderr = typeof failure.stderr === 'string' ? failure.stderr.trim() : ''
+    if (stderr !== '') return stderr
+    return failure.message
+  }
+  return String(err)
+}
+
+function tryParseJson(text: string): unknown {
+  try {
+    return JSON.parse(text)
+  } catch {
+    return undefined
+  }
+}
+
+function truncateForError(text: string): string {
+  const trimmed = text.trim()
+  return trimmed.length > 200 ? `${trimmed.slice(0, 200)}…` : trimmed
+}
+
+/** Probe the resolved binary for built-in node:sqlite support. */
+async function assertNodeSqliteSupport(
+  nodePath: string,
+  execFileAsync: ExecFileLike,
+): Promise<void> {
+  try {
+    await execFileAsync(nodePath, ['-e', "require('node:sqlite')"])
+  } catch (err: unknown) {
+    throw new Error(
+      `resolved Node binary "${nodePath}" does not support node:sqlite (Node.js >= ${NODE_SQLITE_MIN_VERSION} required): ${execErrorMessage(err)}`,
+    )
+  }
+}
+
+/** Pull the structured failure message cost.mjs prints to stdout (exit 1). */
+function extractScriptFailure(err: unknown): string {
+  const failure = err as { stdout?: unknown; stderr?: unknown }
+  const stdout = typeof failure.stdout === 'string' ? failure.stdout : ''
+  const parsed = tryParseJson(stdout)
+  if (parsed !== null && typeof parsed === 'object') {
+    const record = parsed as { ok?: unknown; error?: unknown }
+    if (record.ok === false && typeof record.error === 'string' && record.error !== '') {
+      return record.error
+    }
+  }
+  const stderr = typeof failure.stderr === 'string' ? failure.stderr.trim() : ''
+  if (stderr !== '') return stderr
+  return execErrorMessage(err)
+}
+
+/**
+ * Spawn `node scripts/cost.mjs` as a CLI fallback when node:sqlite is
+ * unavailable in the plugin process (e.g. Bun runtime). Returns CostRow[] by
+ * parsing the JSON the script writes to stdout.
+ *
+ * Resolves a REAL Node binary (PANTHEON_NODE → PATH): process.execPath under
+ * Bun is the Bun binary, which cannot run node:sqlite. The resolved binary is
+ * probed for node:sqlite support and the script is always run read-only with
+ * an argument array (never a shell).
+ */
+export async function queryWithCliFallback(
+  dbPath: string,
+  days: number,
+  deps?: CliFallbackDeps,
+): Promise<CostRow[]> {
+  const env = deps?.env ?? process.env
+  const execFileAsync = deps?.execFile ?? defaultExecFile
+  const isExecutable = deps?.isExecutable ?? defaultIsExecutable
+
+  const costScript = join(__dirname, '..', '..', 'scripts', 'cost.mjs')
+  if (!existsSync(costScript)) {
+    throw new Error(`CLI fallback script not found: ${costScript}`)
+  }
+
+  const node = resolveNodeExecutable(env, isExecutable)
+  if (node === undefined) {
+    throw new Error(
+      `no Node.js executable found for the node:sqlite CLI fallback: set PANTHEON_NODE to a Node.js >= ${NODE_SQLITE_MIN_VERSION} binary or put "node" on PATH`,
+    )
+  }
+
+  await assertNodeSqliteSupport(node.path, execFileAsync)
+
+  let stdout: string
+  try {
+    ;({ stdout } = await execFileAsync(node.path, [
+      costScript,
+      '--db-path',
+      dbPath,
+      '--days',
+      String(days),
+    ]))
+  } catch (err: unknown) {
+    // cost.mjs sets exitCode=1 (execFile rejects) and writes {ok:false,error}
+    // to stdout before exiting — surface that structured failure.
+    throw new Error(`CLI fallback failed: ${extractScriptFailure(err)}`)
+  }
+
+  const parsed = tryParseJson(stdout)
+  if (parsed === null || typeof parsed !== 'object') {
+    throw new Error(`CLI fallback returned non-JSON output: ${truncateForError(stdout)}`)
+  }
+  const record = parsed as { ok?: unknown; rows?: unknown; error?: unknown }
+  if (record.ok !== true) {
+    const detail =
+      typeof record.error === 'string' && record.error !== ''
+        ? record.error
+        : 'unexpected response shape from scripts/cost.mjs'
+    throw new Error(`CLI fallback failed: ${detail}`)
+  }
+  if (!Array.isArray(record.rows)) {
+    throw new Error('CLI fallback failed: scripts/cost.mjs response is missing the rows array')
+  }
+  return record.rows as CostRow[]
+}
+
 export function createCostCommand(options?: CostCommandOptions): CostCommand {
-  const scriptPath = new URL('../../scripts/cost.mjs', import.meta.url).pathname
+  const loadSqlite =
+    options?.sqliteLoader ?? (async () => (await import('node:sqlite')) as SqliteModule)
+
+  const failure = (status: NativeTaskStatus, detail: string): string =>
+    `status: ${status}\npantheon_cost failed: ${detail}`
+
+  const diagnostic = (err: unknown): string => {
+    if (err instanceof Error) {
+      const stderr = (err as Error & { stderr?: unknown }).stderr
+      const suffix =
+        typeof stderr === 'string' && stderr.trim() !== '' ? `; stderr: ${stderr.trim()}` : ''
+      return `${err.message}${suffix}`
+    }
+    return String(err)
+  }
+
+  const statusForError = (err: unknown): NativeTaskStatus => {
+    const detail = diagnostic(err).toLowerCase()
+    if (
+      detail.includes('not found') ||
+      detail.includes('unknown builtin') ||
+      detail.includes('no such built-in') ||
+      detail.includes('cannot find module')
+    ) {
+      return 'UNSUPPORTED'
+    }
+    if (
+      detail.includes('not a database') ||
+      detail.includes('malformed') ||
+      detail.includes('corrupt') ||
+      detail.includes('incompatible opencode.db schema')
+    ) {
+      return 'CORRUPT_DATA'
+    }
+    return 'UNAVAILABLE'
+  }
 
   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.`
+        return failure(
+          'UNAVAILABLE',
+          `opencode.db not found (expected at ${expected}). No token history is available until opencode has stored session data.`,
         )
       }
-      const rows = await queryWithNodeSqlite(dbPath, days).catch(async (err: unknown) => {
-        if (err instanceof Error && err.message.startsWith('incompatible opencode.db schema'))
-          throw err
-        return queryWithScript(scriptPath, dbPath, days)
-      })
-      return renderMarkdown(rows, days)
+      let sqlite: SqliteModule | undefined
+      try {
+        sqlite = await loadSqlite()
+      } catch (loadErr: unknown) {
+        // node:sqlite unavailable (e.g. Bun runtime) — fall back to CLI.
+        const status = statusForError(loadErr)
+        if (status === 'UNSUPPORTED') {
+          try {
+            const rows = await queryWithCliFallback(dbPath, days, options?.cliFallback)
+            return `status: OK\n${renderMarkdown(rows, days)}`
+          } catch (cliErr: unknown) {
+            return failure(statusForError(cliErr), diagnostic(cliErr))
+          }
+        }
+        throw loadErr
+      }
+      const rows = await queryWithNodeSqlite(dbPath, days, sqlite)
+      return `status: OK\n${renderMarkdown(rows, days)}`
     } catch (err: unknown) {
-      const reason = err instanceof Error ? err.message : String(err)
-      return `pantheon_cost failed: ${reason}`
+      return failure(statusForError(err), diagnostic(err))
     }
   }
 
   return {
     pantheon_cost: {
       description:
-        'Report delegation 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,
     },