opencode-overclock 0.3.0 → 0.5.0

package/src/tui.ts

@@ -1,7 +1,14 @@
 import type { TuiPlugin, TuiPluginModule } from "@opencode-ai/plugin/tui"
 import { registerBuddy } from "./buddy/tui.ts"
-
-const STATE_SUBDIR = ".opencode/overclock"
+import { createUi } from "./lib/ui.ts"
+import {
+  scheduleStore,
+  taskStore,
+  usageStore,
+  type ScheduleEntryView,
+  type TaskMirrorEntry,
+  type UsageStateView,
+} from "./lib/mirror.ts"
 
 export interface TuiOptions {
   notifyIdle?: boolean
@@ -11,44 +18,16 @@ export interface TuiOptions {
   buddy?: boolean
 }
 
-/**
- * The buddy toggles from the same overclock.json as the server features, so one
- * config file governs both surfaces. `features.buddy: false` disables; missing
- * file or unreadable config = default on.
- */
-export async function buddyEnabledInConfig(directory: string): Promise<boolean> {
-  try {
-    const file = Bun.file(`${directory}/.opencode/overclock.json`)
-    if (!(await file.exists())) return true
-    const config = (await file.json()) as { features?: Record<string, unknown> }
-    return config.features?.["buddy"] !== false
-  } catch {
-    return true
-  }
-}
-
-export interface TaskMirrorEntry {
-  id: string
-  description: string
-  status: "running" | "exited" | "killed"
-  exitCode: number | null
-  startedAt: number
-}
-
-export interface UsageDayBucket {
-  cost: number
-  tokens: { input: number; output: number; reasoning: number; cacheRead: number; cacheWrite: number }
-  messages: number
-}
-
-export interface UsageStateShape {
-  days: Record<string, UsageDayBucket>
-}
+/** Read views the summary formatters accept. Re-exported for tests and downstream typing. */
+export type { TaskMirrorEntry, ScheduleEntryView, UsageStateView }
 
-export interface ScheduleMirrorEntry {
-  id: string
-  spec: string
-  target: string
+/** Check if buddy feature is enabled via plugin options. */
+export function isBuddyEnabled(options?: TuiOptions): boolean {
+  if (!options) return true
+  if (options.buddy === false) return false
+  const features = (options as { features?: Record<string, unknown> }).features
+  if (features?.buddy === false) return false
+  return true
 }
 
 /** Local YYYY-MM-DD from an epoch-ms timestamp (mirrors usage.ts, kept local to stay decoupled). */
@@ -75,7 +54,7 @@ export function formatTasksSummary(entries: TaskMirrorEntry[] | undefined | null
 
 /** Pure: format the /oc-usage toast summary from a parsed usage.json, for a given "now". */
 export function formatUsageSummary(
-  state: UsageStateShape | undefined | null,
+  state: UsageStateView | undefined | null,
   now: number = Date.now(),
 ): string {
   if (!state) return "no data yet"
@@ -86,169 +65,61 @@ export function formatUsageSummary(
 }
 
 /** Pure: format the /oc-schedules toast summary from a parsed schedules.json. */
-export function formatSchedulesSummary(schedules: ScheduleMirrorEntry[] | undefined | null): string {
+export function formatSchedulesSummary(schedules: ScheduleEntryView[] | undefined | null): string {
   if (!schedules) return "no data yet"
   if (!schedules.length) return "no schedules"
   const list = schedules.map((s) => `${s.id} (${s.spec})`).join(", ")
   return `${schedules.length} schedule${schedules.length === 1 ? "" : "s"}: ${list}`
 }
 
-async function readState<T>(directory: string, file: string): Promise<T | undefined> {
-  try {
-    const f = Bun.file(`${directory}/${STATE_SUBDIR}/${file}`)
-    if (!(await f.exists())) return undefined
-    return (await f.json()) as T
-  } catch {
-    return undefined
-  }
-}
-
 const tui: TuiPlugin = async (api, options) => {
   const opts = (options ?? {}) as TuiOptions
-  const notifyIdle = opts.notifyIdle !== false
-  const notifyPermission = opts.notifyPermission !== false
-  const notifyQuestion = opts.notifyQuestion !== false
-  const notifyError = opts.notifyError !== false
-
-  const unsubs: Array<() => void> = []
-
-  try {
-    if (notifyIdle) {
-      unsubs.push(
-        api.event.on("session.status", (event) => {
-          if (event.properties.status.type !== "idle") return
-          void api.attention.notify({
-            title: "opencode",
-            message: "turn complete",
-            sound: { name: "done", when: "blurred" },
-            notification: { when: "blurred" },
-          })
-        }),
-      )
-    }
-  } catch (e) {
-    console.warn(`[overclock-tui] session.status subscription failed: ${e}`)
-  }
-
-  try {
-    if (notifyPermission) {
-      unsubs.push(
-        api.event.on("permission.asked", () => {
-          void api.attention.notify({
-            title: "opencode",
-            message: "needs permission",
-            sound: { name: "permission", when: "blurred" },
-            notification: { when: "blurred" },
-          })
-        }),
-      )
-    }
-  } catch (e) {
-    console.warn(`[overclock-tui] permission.asked subscription failed: ${e}`)
-  }
-
-  try {
-    if (notifyQuestion) {
-      unsubs.push(
-        api.event.on("question.asked", () => {
-          void api.attention.notify({
-            title: "opencode",
-            message: "asking a question",
-            sound: { name: "question", when: "blurred" },
-            notification: { when: "blurred" },
-          })
-        }),
-      )
-    }
-  } catch (e) {
-    console.warn(`[overclock-tui] question.asked subscription failed: ${e}`)
-  }
-
-  try {
-    if (notifyError) {
-      unsubs.push(
-        api.event.on("session.error", () => {
-          void api.attention.notify({
-            title: "opencode",
-            message: "session error",
-            sound: { name: "error", when: "blurred" },
-            notification: { when: "blurred" },
-          })
-        }),
-      )
-    }
-  } catch (e) {
-    console.warn(`[overclock-tui] session.error subscription failed: ${e}`)
-  }
-
-  try {
-    for (const unsub of unsubs) api.lifecycle.onDispose(async () => unsub())
-  } catch (e) {
-    console.warn(`[overclock-tui] lifecycle registration failed: ${e}`)
+  const ui = createUi(api)
+
+  if (opts.notifyIdle !== false) {
+    ui.on("session.status", (event) => {
+      if (event.properties?.status?.type === "idle") {
+        ui.notify({ message: "turn complete", sound: "done" })
+      }
+    })
   }
 
-  try {
-    const unregister = api.command?.register(() => [
-      {
-        title: "Overclock: Tasks",
-        value: "overclock.tasks",
-        slash: { name: "oc-tasks" },
-        onSelect: async () => {
-          const entries = await readState<TaskMirrorEntry[]>(api.state.path.directory, "tasks.json")
-          api.ui.toast({ message: formatTasksSummary(entries) })
-        },
-      },
-    ])
-    if (unregister) api.lifecycle.onDispose(async () => unregister())
-  } catch (e) {
-    console.warn(`[overclock-tui] /oc-tasks command registration failed: ${e}`)
+  if (opts.notifyPermission !== false) {
+    ui.on("permission.asked", () => ui.notify({ message: "needs permission", sound: "permission" }))
   }
 
-  try {
-    const unregister = api.command?.register(() => [
-      {
-        title: "Overclock: Usage",
-        value: "overclock.usage",
-        slash: { name: "oc-usage" },
-        onSelect: async () => {
-          const state = await readState<UsageStateShape>(api.state.path.directory, "usage.json")
-          api.ui.toast({ message: formatUsageSummary(state) })
-        },
-      },
-    ])
-    if (unregister) api.lifecycle.onDispose(async () => unregister())
-  } catch (e) {
-    console.warn(`[overclock-tui] /oc-usage command registration failed: ${e}`)
+  if (opts.notifyQuestion !== false) {
+    ui.on("question.asked", () => ui.notify({ message: "asking a question", sound: "question" }))
   }
 
-  try {
-    const unregister = api.command?.register(() => [
-      {
-        title: "Overclock: Schedules",
-        value: "overclock.schedules",
-        slash: { name: "oc-schedules" },
-        onSelect: async () => {
-          const schedules = await readState<ScheduleMirrorEntry[]>(
-            api.state.path.directory,
-            "schedules.json",
-          )
-          api.ui.toast({ message: formatSchedulesSummary(schedules) })
-        },
-      },
-    ])
-    if (unregister) api.lifecycle.onDispose(async () => unregister())
-  } catch (e) {
-    console.warn(`[overclock-tui] /oc-schedules command registration failed: ${e}`)
+  if (opts.notifyError !== false) {
+    ui.on("session.error", () => ui.notify({ message: "session error", sound: "error" }))
   }
 
-  // ASCII pet beside the prompt. Anything here failing (missing @opentui/solid,
-  // slot API drift) must degrade to "no buddy", never take the notifications down.
-  try {
-    if (opts.buddy !== false && (await buddyEnabledInConfig(api.state.path.directory))) {
-      await registerBuddy(api)
+  ui.command({
+    title: "Overclock: Tasks",
+    slash: "oc-tasks",
+    run: async () => ui.toast(formatTasksSummary(await ui.readOptional(taskStore))),
+  })
+
+  ui.command({
+    title: "Overclock: Usage",
+    slash: "oc-usage",
+    run: async () => ui.toast(formatUsageSummary(await ui.readOptional(usageStore))),
+  })
+
+  ui.command({
+    title: "Overclock: Schedules",
+    slash: "oc-schedules",
+    run: async () => ui.toast(formatSchedulesSummary(await ui.readOptional(scheduleStore))),
+  })
+
+  if (isBuddyEnabled(opts)) {
+    try {
+      await registerBuddy(ui)
+    } catch (e) {
+      console.warn(`[overclock-tui] buddy disabled: ${e}`)
     }
-  } catch (e) {
-    console.warn(`[overclock-tui] buddy disabled: ${e}`)
   }
 }
 

package/src/types.ts

@@ -1,73 +1 @@
-import type { Hooks, PluginInput } from "@opencode-ai/plugin"
-import type { BusyTracker } from "./lib/busy.ts"
-
-/**
- * Singletons built once by the entry and handed to every module.
- * Derived from the event bus, so they must have exactly one subscription -- a per-module
- * copy would be N subscriptions maintaining N identical copies of the same state.
- */
-export interface SharedDeps {
-  /** live per-session busy/idle state; the entry owns the subscription that feeds it */
-  busy: BusyTracker
-  /**
-   * Declared tool name -> the name the model was actually offered (see `toolNames` config).
-   * Needed wherever a module names one of its own tools in text the model reads: under a
-   * remap the declared name is not a tool the model has.
-   */
-  toolName(declared: string): string
-}
-
-/** Per-feature config from .opencode/overclock.json. `false` = off, object = options. */
-export type FeatureConfig = boolean | Record<string, unknown>
-
-/** A problem found in overclock.json. Lives here so config consumers need not import validate. */
-export interface ConfigIssue {
-  /** dotted location in overclock.json, e.g. "features.tasks.killOnExit" */
-  path: string
-  message: string
-}
-
-/** Option value kinds a module declares, so a typo in overclock.json can be caught. */
-export type OptionType = "boolean" | "number" | "string" | "array" | "object"
-
-export interface OverclockConfig {
-  features?: Record<string, FeatureConfig>
-  /**
-   * Model-visible tool ids: declared name -> replacement. The key of the `tool` hook map is
-   * literally the name sent to the provider, so this is the whole remap. Exists for hosts
-   * behind a proxy that whitelists tool names and rejects unknown ones.
-   *
-   * A replacement that collides with a built-in tool *overrides* that built-in in the final
-   * tool map -- borrow a name you do not mind losing. Permission ids are deliberately not
-   * remapped: they key the user's opencode permission config, not the wire format.
-   */
-  toolNames?: Record<string, string>
-  /**
-   * The only tool names the model may be offered. Entries are literal names or the name of a
-   * bundled list (see KNOWN_ALLOWLISTS), so extending one is `["claude-code", "MyExtraTool"]`.
-   * A bundled list also supplies default aliases for this plugin's tools; `toolNames` overrides
-   * those per tool.
-   *
-   * Any tool whose final name is not permitted is withheld from the model rather than offered
-   * and rejected -- a single unrecognised name can fail a whole request, so a loud gap at
-   * startup beats a session that cannot reach the provider.
-   */
-  toolAllowlist?: string[] | string
-}
-
-/**
- * One feature = one module.
- * init returns partial Hooks. Same hook from many modules -> composed in registry order.
- */
-export interface FeatureModule {
-  name: string
-  /** on by default? */
-  defaultEnabled: boolean
-  /** SDK client surfaces (dot-paths) the module needs. Missing -> module skipped + warn. */
-  requires?: string[]
-  /** Tool names registered. Declared, not derived -- feeds the first-run summary. */
-  tools?: string[]
-  /** Accepted option keys -> expected type. Anything else in config is a typo. */
-  options?: Record<string, OptionType>
-  init(ctx: PluginInput, options: Record<string, unknown>, shared: SharedDeps): Promise<Partial<Hooks>>
-}
+export * from "./core/types.ts"