opencode-overclock 0.3.0 → 0.4.0

package/src/features/usage.ts

@@ -1,27 +1,9 @@
-import { tool } from "@opencode-ai/plugin"
 import type { FeatureModule } from "../types.ts"
 import { ensureStateDir, readJson, writeJson } from "../lib/state.ts"
+import { usageStore, type DayBucket, type UsageState, type UsageTokens } from "../lib/mirror.ts"
 
-const z = tool.schema
-
-export interface UsageTokens {
-  input: number
-  output: number
-  reasoning: number
-  cacheRead: number
-  cacheWrite: number
-}
-
-export interface DayBucket {
-  cost: number
-  tokens: UsageTokens
-  messages: number
-  seen: string[]
-}
-
-export interface UsageState {
-  days: Record<string, DayBucket>
-}
+// Declared in platform/storage/store.ts so the TUI can inspect usage data without importing this feature module.
+export type { UsageTokens, DayBucket, UsageState } from "../lib/mirror.ts"
 
 export interface SessionUsage {
   sessionID: string
@@ -99,27 +81,23 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
     pruneOldDays(state, Date.now())
   }
 
+  function extractTokens(t: any): UsageTokens {
+    return {
+      input: t?.input ?? 0,
+      output: t?.output ?? 0,
+      reasoning: t?.reasoning ?? 0,
+      cacheRead: t?.cache?.read ?? 0,
+      cacheWrite: t?.cache?.write ?? 0,
+    }
+  }
+
   function onEvent(event: { type: string; properties?: unknown }): void {
     try {
       if (event.type !== "message.updated") return
-      const info = (event.properties as { info?: unknown } | undefined)?.info as
-        | {
-            id?: string
-            role?: string
-            sessionID?: string
-            time?: { created?: number; completed?: number }
-            cost?: number
-            tokens?: {
-              input?: number
-              output?: number
-              reasoning?: number
-              cache?: { read?: number; write?: number }
-            }
-          }
-        | undefined
-      if (!info || info.role !== "assistant") return
-      if (!info.time?.completed) return
+      const info = (event.properties as any)?.info
+      if (!info || info.role !== "assistant" || !info.time?.completed) return
       if (typeof info.id !== "string" || typeof info.sessionID !== "string") return
+
       const created = info.time.created ?? info.time.completed
       const day = dayKey(created)
       const bucket = state.days[day] ?? emptyBucket()
@@ -128,20 +106,15 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
       bucket.seen.push(info.id)
 
       const cost = info.cost ?? 0
-      const t = info.tokens ?? {}
-      const input = t.input ?? 0
-      const output = t.output ?? 0
-      const reasoning = t.reasoning ?? 0
-      const cacheRead = t.cache?.read ?? 0
-      const cacheWrite = t.cache?.write ?? 0
+      const tok = extractTokens(info.tokens)
 
       bucket.cost += cost
       bucket.messages += 1
-      bucket.tokens.input += input
-      bucket.tokens.output += output
-      bucket.tokens.reasoning += reasoning
-      bucket.tokens.cacheRead += cacheRead
-      bucket.tokens.cacheWrite += cacheWrite
+      bucket.tokens.input += tok.input
+      bucket.tokens.output += tok.output
+      bucket.tokens.reasoning += tok.reasoning
+      bucket.tokens.cacheRead += tok.cacheRead
+      bucket.tokens.cacheWrite += tok.cacheWrite
 
       const sess = sessions.get(info.sessionID) ?? {
         sessionID: info.sessionID,
@@ -149,8 +122,8 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
         tokens: { input: 0, output: 0 },
       }
       sess.cost += cost
-      sess.tokens.input += input
-      sess.tokens.output += output
+      sess.tokens.input += tok.input
+      sess.tokens.output += tok.output
       sessions.set(info.sessionID, sess)
 
       scheduleFlush()
@@ -236,11 +209,11 @@ export function createUsageTracker(opts: UsageTrackerOpts): UsageTracker {
  */
 export const usage: FeatureModule = {
   name: "usage",
-  tools: ["usage_report"],
+  tools: [],
   defaultEnabled: true,
   async init(ctx) {
     const dir = await ensureStateDir(ctx.directory)
-    const tracker = createUsageTracker({ statePath: `${dir}/usage.json` })
+    const tracker = createUsageTracker({ statePath: usageStore.path(ctx.directory) })
     await tracker.load()
 
     return {
@@ -254,18 +227,6 @@ export const usage: FeatureModule = {
           console.warn(`[overclock] usage: event handling failed: ${e}`)
         }
       },
-      tool: {
-        usage_report: tool({
-          description:
-            "Report cost/token usage for the last N days (default 7) plus today's per-session breakdown.",
-          args: {
-            days: z.number().optional().describe("number of days to report, default 7"),
-          },
-          async execute(args) {
-            return tracker.report(args.days ?? 7)
-          },
-        }),
-      },
     }
   },
 }

package/src/index.ts

@@ -1,85 +1,114 @@
-import type { Hooks, Plugin } from "@opencode-ai/plugin"
+import type { Hooks } from "@opencode-ai/plugin"
 import { features } from "./features/index.ts"
-import { loadConfig } from "./config.ts"
-import { mergeHooks } from "./merge.ts"
+import { mergeHooks } from "./core/lifecycle.ts"
+import { resolveToolPolicy } from "./core/policy.ts"
+import { summarise } from "./core/summary.ts"
+import { createHybridPlugin, type HybridPlugin } from "./core/bridge.ts"
+import type { FeatureModule, OverclockOptions, SharedDeps } from "./core/types.ts"
 import { missingSurfaces } from "./lib/probe.ts"
 import { toast } from "./lib/inject.ts"
 import { firstRun } from "./lib/state.ts"
-import { validateConfig, summarise } from "./validate.ts"
 import { createBusyTracker } from "./lib/busy.ts"
-import { EMPTY_POLICY, resolveToolPolicy, type ToolPolicy } from "./tools.ts"
-import type { FeatureModule, SharedDeps } from "./types.ts"
+import { createV2Host } from "./v2/host.ts"
+
+function featureOptions(
+  options: OverclockOptions,
+  feature: FeatureModule,
+): Record<string, unknown> | null {
+  const setting = options[feature.name] ?? options.features?.[feature.name] ?? feature.defaultEnabled
+  if (setting === false) return null
+  return typeof setting === "object" && setting !== null ? (setting as Record<string, unknown>) : {}
+}
 
 /**
- * Entry. Load config -> probe surfaces -> init enabled modules -> merge hooks.
- * Module crash or missing SDK surface (upstream drift) -> skip module, plugin survive.
+ * Entry. Read options -> probe surfaces -> init enabled modules -> merge hooks.
+ * Employs createHybridPlugin so the plugin is runnable on both V1 and V2 OpenCode harnesses.
  */
-export const Overclock: Plugin = async (ctx) => {
-  const config = await loadConfig(ctx.directory)
+export const Overclock: HybridPlugin<OverclockOptions> = createHybridPlugin<OverclockOptions>({
+  id: "overclock",
+
+  /** V1 lifecycle: tools, execution interception, event bus hooks */
+  server: async (ctx, pluginOptions) => {
+    const options = (pluginOptions ?? {}) as OverclockOptions
+    const { policy, issues } = resolveToolPolicy(options, features)
+
+    const shared: SharedDeps = {
+      busy: createBusyTracker(),
+      toolName: (declared) => policy.rename[declared] ?? declared,
+    }
+    const parts: Partial<Hooks>[] = [{ event: async ({ event }) => shared.busy.onEvent(event) }]
+    const skipped: string[] = []
+    const enabled: FeatureModule[] = []
+
+    for (const feature of features) {
+      const opts = featureOptions(options, feature)
+      if (opts === null) continue
 
-  // Collected now, reported once the tool policy is known so a single pass covers both.
-  const issues = validateConfig(config, features)
+      const missing = missingSurfaces(ctx.client, feature.requires ?? [])
+      if (missing.length) {
+        console.warn(
+          `[overclock] ${feature.name} disabled: client lacks ${missing.join(", ")} (upstream drift?)`,
+        )
+        skipped.push(feature.name)
+        continue
+      }
 
-  // Resolved after the init loop, against the modules that actually loaded -- warning about a
-  // tool belonging to a disabled feature would be noise. Modules only call `toolName` at
-  // runtime (a hook or timer, long after init), so reading it through this binding is safe.
-  let policy: ToolPolicy = EMPTY_POLICY
-  const shared: SharedDeps = {
-    busy: createBusyTracker(),
-    toolName: (declared) => policy.rename[declared] ?? declared,
-  }
-  // First part, so the tracker is current before any module's own event hook reads it.
-  const parts: Partial<Hooks>[] = [{ event: async ({ event }) => shared.busy.onEvent(event) }]
-  const skipped: string[] = []
-  const enabled: FeatureModule[] = []
+      try {
+        parts.push(await feature.init(ctx, opts, shared))
+        enabled.push(feature)
+      } catch (e) {
+        console.warn(`[overclock] feature ${feature.name} failed init: ${e}`)
+      }
+    }
 
-  for (const feature of features) {
-    const setting = config.features?.[feature.name] ?? feature.defaultEnabled
-    if (setting === false) continue
-    const missing = missingSurfaces(ctx.client, feature.requires ?? [])
-    if (missing.length) {
-      console.warn(
-        `[overclock] ${feature.name} disabled: client lacks ${missing.join(", ")} (upstream drift?)`,
+    if (Array.isArray(options.plugins) && options.plugins.length > 0) {
+      const v2Host = createV2Host(ctx, options)
+      const loadedV2 = await v2Host.loadPlugins(options.plugins)
+      if (loadedV2.length > 0) {
+        console.warn(`[overclock] loaded ${loadedV2.length} v2 plugin(s): ${loadedV2.join(", ")}`)
+      }
+      parts.push(v2Host.createHooks())
+    }
+
+    for (const issue of issues) {
+      console.warn(`[overclock] config: ${issue.path ? `${issue.path}: ` : ""}${issue.message}`)
+    }
+    if (issues.length) {
+      void toast(
+        ctx.client,
+        `overclock: ${issues.length} config issue${issues.length > 1 ? "s" : ""} (see logs)`,
+        "warning",
       )
-      skipped.push(feature.name)
-      continue
     }
-    const options = typeof setting === "object" ? setting : {}
-    try {
-      parts.push(await feature.init(ctx, options, shared))
-      enabled.push(feature)
-    } catch (e) {
-      console.warn(`[overclock] feature ${feature.name} failed init: ${e}`)
+
+    const summary = summarise(enabled, skipped, policy)
+    console.warn(`[overclock] ${summary}`)
+    if (await firstRun(ctx.directory)) {
+      void toast(ctx.client, `overclock active: ${summary}`, "info")
     }
-  }
 
-  const resolved = resolveToolPolicy(config, enabled)
-  policy = resolved.policy
-  issues.push(...resolved.issues)
+    if (skipped.length) {
+      void toast(ctx.client, `overclock: ${skipped.join(", ")} disabled (SDK drift)`, "warning")
+    }
+    return mergeHooks(parts, policy)
+  },
 
-  // A mistyped key is otherwise a silent no-op -- the feature runs with defaults and the
-  // user believes their setting took effect. Warn, never throw: bad config degrades to
-  // defaults rather than taking the plugin down.
-  for (const issue of issues) {
-    console.warn(`[overclock] config: ${issue.path ? `${issue.path}: ` : ""}${issue.message}`)
-  }
-  if (issues.length) {
-    void toast(
-      ctx.client,
-      `overclock: ${issues.length} config issue${issues.length > 1 ? "s" : ""} (see logs)`,
-      "warning",
-    )
-  }
+  /** V2 lifecycle: domain transforms (agents, commands, catalog, aisdk) */
+  setup: async (v2Context, pluginOptions) => {
+    const options = (pluginOptions ?? {}) as OverclockOptions
 
-  // Say what was added. This plugin grants the agent background shell execution and
-  // recurring scheduling; that should not be discovered by accident. Log every start
-  // (stderr, invisible unless you look), toast only on a project's first run.
-  console.warn(`[overclock] ${summarise(enabled, skipped, policy)}`)
-  if (await firstRun(ctx.directory)) {
-    void toast(ctx.client, `overclock active: ${summarise(enabled, skipped, policy)}`, "info")
-  }
+    for (const feature of features) {
+      if (!feature.setup) continue
+      const opts = featureOptions(options, feature)
+      if (opts === null) continue
 
-  if (skipped.length)
-    void toast(ctx.client, `overclock: ${skipped.join(", ")} disabled (SDK drift)`, "warning")
-  return mergeHooks(parts, policy)
-}
+      try {
+        await feature.setup(v2Context, opts)
+      } catch (e) {
+        console.warn(`[overclock] feature ${feature.name} failed v2 setup: ${e}`)
+      }
+    }
+  },
+})
+
+export default Overclock

package/src/lib/busy.ts

@@ -1,25 +1 @@
-/**
- * Session busy tracking via `session.status` (doc-preferred; `session.idle` deprecated).
- * Unknown/never-firing statuses degrade gracefully: empty set = nothing reported busy.
- */
-export interface BusyTracker {
-  /** feed bus events */
-  onEvent(event: { type: string; properties?: unknown }): void
-  isBusy(sessionID: string): boolean
-}
-
-export function createBusyTracker(): BusyTracker {
-  const busy = new Set<string>()
-  return {
-    onEvent(event) {
-      const p = (event.properties ?? {}) as { sessionID?: string; status?: { type?: string } }
-      if (!p.sessionID) return
-      if (event.type === "session.status") {
-        p.status?.type === "idle" ? busy.delete(p.sessionID) : busy.add(p.sessionID)
-      } else if (event.type === "session.idle" || event.type === "session.deleted") {
-        busy.delete(p.sessionID)
-      }
-    },
-    isBusy: (id) => busy.has(id),
-  }
-}
+export { createBusyTracker, type BusyTracker } from "../platform/session/busy.ts"

package/src/lib/exec.ts

@@ -0,0 +1,7 @@
+export {
+  NON_INTERACTIVE_ENV,
+  execBash,
+  shellQuote,
+  type ExecBashOptions,
+  type ExecBashResult,
+} from "../platform/process/exec.ts"

package/src/lib/inject.ts

@@ -1,56 +1,10 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-type Client = PluginInput["client"]
-type ModelRef = { providerID: string; modelID: string }
-
-/**
- * Session's active model = model of last assistant message.
- * Without this, promptAsync falls back to config default model -> injected turns
- * run on the wrong model (and pile up QUEUED behind a hung default).
- */
-export async function sessionModel(client: Client, sessionID: string): Promise<ModelRef | undefined> {
-  try {
-    const res = await client.session.messages({ path: { id: sessionID } })
-    const msgs = res.data ?? []
-    for (let i = msgs.length - 1; i >= 0; i--) {
-      const info = msgs[i]?.info
-      if (info?.role === "assistant" && info.modelID) {
-        return { providerID: info.providerID, modelID: info.modelID }
-      }
-    }
-  } catch (e) {
-    console.warn(`[overclock] sessionModel lookup failed (${sessionID}): ${e}`)
-  }
-  return undefined
-}
-
-/**
- * Re-entry: push text into session as user prompt, on the session's own model.
- * promptAsync = fire-and-forget, server queues if busy. Failure -> warn, never throw.
- */
-export async function inject(client: Client, sessionID: string, text: string): Promise<boolean> {
-  try {
-    const model = await sessionModel(client, sessionID)
-    await client.session.promptAsync({
-      path: { id: sessionID },
-      body: { parts: [{ type: "text", text }], ...(model ? { model } : {}) },
-    })
-    return true
-  } catch (e) {
-    console.warn(`[overclock] inject failed (session ${sessionID}): ${e}`)
-    return false
-  }
-}
-
-/** TUI toast, best-effort (headless server -> no TUI, swallow). */
-export async function toast(
-  client: Client,
-  message: string,
-  variant: "info" | "success" | "warning" | "error" = "info",
-): Promise<void> {
-  try {
-    await client.tui.showToast({ body: { message, variant } })
-  } catch {
-    // no TUI attached
-  }
-}
+export {
+  inject,
+  sessionContext,
+  sessionModel,
+  toast,
+  type InjectOptions,
+  type ModelRef,
+  type SessionContext,
+  type ToastVariant,
+} from "../platform/session/inject.ts"

package/src/lib/mirror.ts

@@ -0,0 +1,13 @@
+export {
+  scheduleStore,
+  taskStore,
+  usageStore,
+  type DayBucket,
+  type DayBucketView,
+  type ScheduleEntry,
+  type ScheduleEntryView,
+  type TaskMirrorEntry,
+  type UsageState,
+  type UsageStateView,
+  type UsageTokens,
+} from "../platform/storage/store.ts"

package/src/lib/probe.ts

@@ -1,15 +1 @@
-/**
- * Runtime surface probe (doc: "probe for the surfaces we depend on ... instead of
- * failing silently when upstream moves"). Dot-paths resolved against the SDK client;
- * leaf must be a function.
- */
-export function missingSurfaces(client: unknown, paths: string[]): string[] {
-  return paths.filter((path) => {
-    let node: unknown = client
-    for (const key of path.split(".")) {
-      if (node == null || typeof node !== "object") return true
-      node = (node as Record<string, unknown>)[key]
-    }
-    return typeof node !== "function"
-  })
-}
+export { missingSurfaces } from "../platform/probe.ts"

package/src/lib/state.ts

@@ -1,39 +1,10 @@
-import { mkdir } from "node:fs/promises"
-
-/** State root: <project>/.opencode/overclock/[sub]. Creates if missing. */
-export async function ensureStateDir(directory: string, sub?: string): Promise<string> {
-  const dir = `${directory}/.opencode/overclock${sub ? `/${sub}` : ""}`
-  await mkdir(dir, { recursive: true })
-  return dir
-}
-
-/**
- * True once per project, then never again. Marker lives beside the other state, so
- * deleting .opencode/overclock/ re-arms the first-run notice.
- */
-export async function firstRun(directory: string): Promise<boolean> {
-  const dir = await ensureStateDir(directory)
-  const marker = Bun.file(`${dir}/.installed`)
-  if (await marker.exists()) return false
-  await Bun.write(marker, new Date().toISOString())
-  return true
-}
-
-export async function readJson<T>(path: string, fallback: T): Promise<T> {
-  const file = Bun.file(path)
-  if (!(await file.exists())) return fallback
-  try {
-    return (await file.json()) as T
-  } catch {
-    return fallback
-  }
-}
-
-export async function writeJson(path: string, value: unknown): Promise<void> {
-  await Bun.write(path, JSON.stringify(value, null, 2))
-}
-
-/** POSIX single-quote escape. */
-export function shellQuote(s: string): string {
-  return `'${s.replace(/'/g, `'\\''`)}'`
-}
+export {
+  defineStore,
+  ensureStateDir,
+  firstRun,
+  readJson,
+  shellQuote,
+  stateDir,
+  writeJson,
+  type Store,
+} from "../platform/storage/state.ts"

package/src/lib/tmux.ts

@@ -0,0 +1 @@
+export { isInsideTmux, spawnTaskPane, type TmuxPane } from "../platform/process/tmux.ts"