opencode-overclock 0.3.0 → 0.5.0

package/src/platform/session/busy.ts

@@ -0,0 +1,33 @@
+import type { BusyTracker } from "../../core/types.ts"
+
+export type { BusyTracker } from "../../core/types.ts"
+
+/**
+ * Session busy tracking via `session.status` (doc-preferred; `session.idle` deprecated).
+ * Resilient to aborts, errors, and deletions so sessions do not deadlock in busy state.
+ */
+export function createBusyTracker(): BusyTracker {
+  const busy = new Set<string>()
+  return {
+    onEvent(event: unknown) {
+      if (!event || typeof event !== "object") return
+      const ev = event as { type?: unknown; properties?: unknown }
+      if (typeof ev.type !== "string") return
+
+      const p = (ev.properties ?? {}) as { sessionID?: string; status?: { type?: string } }
+      if (!p.sessionID) return
+
+      if (ev.type === "session.status") {
+        p.status?.type === "idle" ? busy.delete(p.sessionID) : busy.add(p.sessionID)
+      } else if (
+        ev.type === "session.idle" ||
+        ev.type === "session.deleted" ||
+        ev.type === "session.error" ||
+        ev.type === "session.aborted"
+      ) {
+        busy.delete(p.sessionID)
+      }
+    },
+    isBusy: (id) => (id ? busy.has(id) : false),
+  }
+}

package/src/platform/session/inject.ts

@@ -0,0 +1,89 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+import { toast } from "./notify.ts"
+
+export { toast, type ToastVariant } from "./notify.ts"
+
+type Client = PluginInput["client"]
+export type ModelRef = { providerID: string; modelID: string }
+export type SessionContext = {
+  model?: ModelRef
+  agent?: string
+}
+
+export interface InjectOptions {
+  noReply?: boolean
+}
+
+/**
+ * Session's active context = model of last assistant message and most recent agent name.
+ * Without model, promptAsync falls back to config default model -> injected turns
+ * run on the wrong model (and pile up QUEUED behind a hung default).
+ * Preserving agent ensures turns continue under the active persona.
+ */
+export async function sessionContext(client: Client, sessionID: string): Promise<SessionContext> {
+  try {
+    const res = await client.session.messages({ path: { id: sessionID } })
+    const msgs = res.data ?? []
+    let model: ModelRef | undefined
+    let agent: string | undefined
+
+    for (let i = msgs.length - 1; i >= 0; i--) {
+      const info = msgs[i]?.info as
+        { role?: string; modelID?: string; providerID?: string; agent?: string } | undefined
+      if (!model && info?.role === "assistant" && info.modelID && info.providerID) {
+        model = { providerID: info.providerID, modelID: info.modelID }
+      }
+      if (!agent && info?.agent) {
+        agent = info.agent
+      }
+      if (model && agent) break
+    }
+    return { model, agent }
+  } catch (e) {
+    console.warn(`[overclock] sessionContext lookup failed (${sessionID}): ${e}`)
+    return {}
+  }
+}
+
+/**
+ * Session's active model = model of last assistant message.
+ */
+export async function sessionModel(client: Client, sessionID: string): Promise<ModelRef | undefined> {
+  const ctx = await sessionContext(client, sessionID)
+  return ctx.model
+}
+
+/**
+ * Re-entry: push text into session as user prompt, on the session's own model and agent.
+ * promptAsync = fire-and-forget, server queues if busy. Failure -> warn, never throw.
+ */
+export async function inject(
+  client: Client,
+  sessionID: string,
+  text: string,
+  options?: InjectOptions,
+): Promise<boolean> {
+  try {
+    const ctx = await sessionContext(client, sessionID)
+    const res = await (client.session.promptAsync as any)({
+      path: { id: sessionID },
+      throwOnError: true,
+      body: {
+        parts: [{ type: "text", text }],
+        ...(ctx.model ? { model: ctx.model } : {}),
+        ...(ctx.agent ? { agent: ctx.agent } : {}),
+        ...(options?.noReply ? { noReply: true } : {}),
+      },
+    })
+    if (res && typeof res === "object" && "error" in res && (res as any).error) {
+      console.warn(
+        `[overclock] inject failed (session ${sessionID}): ${JSON.stringify((res as any).error)}`,
+      )
+      return false
+    }
+    return true
+  } catch (e) {
+    console.warn(`[overclock] inject failed (session ${sessionID}): ${e}`)
+    return false
+  }
+}

package/src/platform/session/notify.ts

@@ -0,0 +1,20 @@
+import type { PluginInput } from "@opencode-ai/plugin"
+
+type Client = PluginInput["client"]
+
+export type ToastVariant = "info" | "success" | "warning" | "error"
+
+/**
+ * TUI toast notification, best-effort (swallows errors in headless/no-TUI environments).
+ */
+export async function toast(
+  client: Client,
+  message: string,
+  variant: ToastVariant = "info",
+): Promise<void> {
+  try {
+    await client.tui.showToast({ body: { message, variant } })
+  } catch {
+    // no TUI attached or client lacks tui surface
+  }
+}

package/src/platform/storage/state.ts

@@ -0,0 +1,99 @@
+import { mkdir, copyFile } from "node:fs/promises"
+import { writeFileSync, renameSync, unlinkSync, mkdirSync } from "node:fs"
+import { dirname } from "node:path"
+import { shellQuote } from "../process/exec.ts"
+
+export { shellQuote }
+
+/** State root: <project>/.opencode/overclock/[sub]. Pure -- creates nothing. */
+export function stateDir(directory: string, sub?: string): string {
+  return `${directory}/.opencode/overclock${sub ? `/${sub}` : ""}`
+}
+
+/** State root: <project>/.opencode/overclock/[sub]. Creates if missing. */
+export async function ensureStateDir(directory: string, sub?: string): Promise<string> {
+  const dir = stateDir(directory, 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 (e) {
+    console.warn(`[overclock] failed to parse JSON at ${path}: ${e}`)
+    try {
+      await copyFile(path, `${path}.corrupt.${Date.now()}`)
+    } catch {}
+    return fallback
+  }
+}
+
+/**
+ * Serializes the value formatted with 2 spaces and atomically writes to the destination path.
+ */
+export async function writeJson(path: string, value: unknown): Promise<void> {
+  const tmpPath = `${path}.${process.pid}.${Date.now()}.${Math.random().toString(36).slice(2, 8)}.tmp`
+  const content = JSON.stringify(value, null, 2)
+  try {
+    writeFileSync(tmpPath, content)
+    renameSync(tmpPath, path)
+  } catch (err: any) {
+    if (err?.code === "ENOENT") {
+      mkdirSync(dirname(path), { recursive: true })
+      writeFileSync(tmpPath, content)
+      renameSync(tmpPath, path)
+      return
+    }
+    try {
+      unlinkSync(tmpPath)
+    } catch {}
+    throw err
+  }
+}
+
+/** A typed state file accessor. */
+export interface Store<T> {
+  readonly file: string
+  path(directory: string): string
+  read(directory: string): Promise<T>
+  readMaybe(directory: string): Promise<T | undefined>
+  write(directory: string, value: T): Promise<void>
+}
+
+/** Factory for typed state file stores. */
+export function defineStore<T>(file: string, fallback: () => T): Store<T> {
+  const path = (directory: string) => `${stateDir(directory)}/${file}`
+  return {
+    file,
+    path,
+    read: (directory) => readJson<T>(path(directory), fallback()),
+    readMaybe: async (directory) => {
+      const target = path(directory)
+      try {
+        if (!(await Bun.file(target).exists())) return undefined
+      } catch {
+        return undefined
+      }
+      return readJson<T>(target, fallback())
+    },
+    write: async (directory, value) => {
+      await ensureStateDir(directory)
+      await writeJson(path(directory), value)
+    },
+  }
+}

package/src/platform/storage/store.ts

@@ -0,0 +1,61 @@
+import { defineStore } from "./state.ts"
+
+// ---------------------------------------------------------------- tasks
+
+export interface TaskMirrorEntry {
+  id: string
+  description: string
+  status: "running" | "exited" | "killed"
+  exitCode: number | null
+  startedAt: number
+}
+
+export const taskStore = defineStore<TaskMirrorEntry[]>("tasks.json", () => [])
+
+// ---------------------------------------------------------------- usage
+
+export interface UsageTokens {
+  input: number
+  output: number
+  reasoning: number
+  cacheRead: number
+  cacheWrite: number
+}
+
+export interface DayBucket {
+  cost: number
+  tokens: UsageTokens
+  messages: number
+  /** message ids already counted, so a replayed event cannot double-bill */
+  seen: string[]
+}
+
+export interface UsageState {
+  days: Record<string, DayBucket>
+}
+
+/** What the TUI needs off a day bucket. `seen` is write-side bookkeeping. */
+export type DayBucketView = Omit<DayBucket, "seen">
+
+export interface UsageStateView {
+  days?: Record<string, DayBucketView | undefined>
+}
+
+export const usageStore = defineStore<UsageState>("usage.json", () => ({ days: {} }))
+
+// ---------------------------------------------------------------- schedules
+
+export interface ScheduleEntry {
+  id: string
+  spec: string
+  prompt: string
+  target: "current" | "new-session"
+  /** creator; also the inject target when target=current */
+  sessionID: string
+  createdAt: string
+}
+
+/** The TUI lists schedules; it has no business reading the prompt or the session id. */
+export type ScheduleEntryView = Pick<ScheduleEntry, "id" | "spec">
+
+export const scheduleStore = defineStore<ScheduleEntry[]>("schedules.json", () => [])

package/src/summary.ts

@@ -0,0 +1 @@
+export { summarise } from "./core/summary.ts"

package/src/tools.ts

@@ -1,244 +1,8 @@
-import type { ConfigIssue, FeatureModule, OverclockConfig } from "./types.ts"
-
-/**
- * Tool ids opencode registers itself (observed on 1.18.4 via `/experimental/tool/ids`).
- *
- * Only used to warn: a tool registered under one of these *replaces* the built-in in the final
- * tool map, and a name that differs only by case (`Task` vs `task`) is worse still -- the host
- * offers both, and a consumer that matches case-insensitively sees a duplicate. Drift in this
- * list only makes the warning less complete, never wrong.
- */
-export const HOST_TOOL_IDS: readonly string[] = [
-  "apply_patch",
-  "bash",
-  "edit",
-  "glob",
-  "grep",
-  "invalid",
-  "question",
-  "read",
-  "skill",
-  "task",
-  "todowrite",
-  "webfetch",
-  "websearch",
-  "write",
-]
-
-export interface KnownAllowlist {
-  /** every name the list permits */
-  names: readonly string[]
-  /**
-   * declared tool name -> the name from this list it is offered under. Only for names that
-   * mean the same operation; nothing is invented, so this table stays short.
-   */
-  aliases: Readonly<Record<string, string>>
-  /**
-   * Tools with no honest alias in this list, and why. Recorded rather than left blank so the
-   * absence is a decision someone made, not an oversight -- a test requires every tool to be
-   * in `aliases` or here, and the reason is shown when such a tool gets withheld.
-   */
-  unaliased: Readonly<Record<string, string>>
-}
-
-/**
- * Named allowlists, usable anywhere a tool name is accepted in `toolAllowlist`.
- *
- * `claude-code` is Claude Code's registered tool set. opencode's own ids are snake_case and
- * disjoint from it, so every name here is free for this plugin to use.
- *
- * `aliases` only covers tools where a name in the list denotes the same operation, so nothing
- * here is a guess: background tasks and cron already exist in this vocabulary. Anything else is
- * listed in `unaliased` with the reason, because picking an unrelated name on a user's behalf
- * would mislead the model about what the tool does. Map those yourself with `toolNames`.
- *
- * Adding a tool: give it an alias or an `unaliased` reason in the same commit. A test fails
- * otherwise, so the decision surfaces in CI rather than as a rejected request mid-session.
- */
-export const KNOWN_ALLOWLISTS: Readonly<Record<string, KnownAllowlist>> = {
-  "claude-code": {
-    names: [
-      "Read",
-      "Write",
-      "Edit",
-      "MultiEdit",
-      "NotebookEdit",
-      "Glob",
-      "Grep",
-      "Bash",
-      "Agent",
-      "Task",
-      "Workflow",
-      "TodoWrite",
-      "TaskCreate",
-      "TaskGet",
-      "TaskList",
-      "TaskUpdate",
-      "TaskStop",
-      "TaskOutput",
-      "TeamCreate",
-      "TeamDelete",
-      "SendMessage",
-      "EnterPlanMode",
-      "ExitPlanMode",
-      "EnterWorktree",
-      "ExitWorktree",
-      "ListMcpResourcesTool",
-      "WaitForMcpServers",
-      "ToolSearch",
-      "Skill",
-      "CronCreate",
-      "CronDelete",
-      "CronList",
-      "ScheduleWakeup",
-      "AskUserQuestion",
-      "StructuredOutput",
-      "ValidationResult",
-      "ReportFindings",
-      "LSP",
-    ],
-    aliases: {
-      task_run: "TaskCreate",
-      task_status: "TaskList",
-      task_output: "TaskOutput",
-      task_kill: "TaskStop",
-      schedule_create: "CronCreate",
-      schedule_list: "CronList",
-      schedule_delete: "CronDelete",
-    },
-    unaliased: {
-      bash_unsandboxed: "the only fitting name is `Bash`, which is also an opencode built-in",
-      checkpoint_list: "no name in this list denotes session checkpoints",
-      checkpoint_revert: "no name in this list denotes session checkpoints",
-      checkpoint_restore: "no name in this list denotes session checkpoints",
-      usage_report: "no name in this list denotes cost/token telemetry",
-    },
-  },
-}
-
-export interface ToolPolicy {
-  /** declared name -> model-visible name */
-  rename: Record<string, string>
-  /** declared names withheld from the model entirely (no allowed name to use) */
-  withheld: Set<string>
-}
-
-export const EMPTY_POLICY: ToolPolicy = { rename: {}, withheld: new Set() }
-
-/** Entries like "claude-code" name a bundled list; a literal tool id would not look like this. */
-function looksLikeListName(entry: string): boolean {
-  return /^[a-z0-9]+(-[a-z0-9]+)+$/.test(entry)
-}
-
-/**
- * Expand `toolAllowlist` into the names it permits plus the aliases any named list brings.
- * Entries are either a known list name or a literal tool name, so extending a bundled list is
- * `["claude-code", "MyExtraTool"]` -- no separate key, no re-listing what the bundle covers.
- */
-export function resolveAllowlist(value: unknown): {
-  names?: string[]
-  aliases: Record<string, string>
-  /** declared tool -> why no bundled list offered a name for it */
-  unaliased: Record<string, string>
-  issues: ConfigIssue[]
-} {
-  const aliases: Record<string, string> = {}
-  const unaliased: Record<string, string> = {}
-  if (value === undefined) return { aliases, unaliased, issues: [] }
-
-  const entries = typeof value === "string" ? [value] : value
-  if (!Array.isArray(entries) || !entries.every((v) => typeof v === "string")) {
-    return {
-      aliases,
-      unaliased,
-      issues: [
-        {
-          path: "toolAllowlist",
-          message: `must be a name or an array of names (a known list is ${Object.keys(KNOWN_ALLOWLISTS).join(", ")}), got ${Array.isArray(value) ? "array with non-strings" : typeof value}`,
-        },
-      ],
-    }
-  }
-
-  const names: string[] = []
-  const issues: ConfigIssue[] = []
-  for (const entry of entries as string[]) {
-    const known = KNOWN_ALLOWLISTS[entry]
-    if (known) {
-      names.push(...known.names)
-      Object.assign(aliases, known.aliases)
-      Object.assign(unaliased, known.unaliased)
-      continue
-    }
-    // A typo'd list name would otherwise pass as a literal tool name, withhold everything, and
-    // suggest the typo itself as a free name. Cheap to catch, confusing to debug.
-    if (looksLikeListName(entry)) {
-      issues.push({
-        path: "toolAllowlist",
-        message: `"${entry}" looks like a known list but is not one (known: ${Object.keys(KNOWN_ALLOWLISTS).join(", ")}) -- treating it as a literal tool name`,
-      })
-    }
-    names.push(entry)
-  }
-  return { names, aliases, unaliased, issues }
-}
-
-/**
- * Fold the allowlist's aliases + explicit renames into one policy, and report what a human
- * needs to act on. Every check here exists because the failure it catches is otherwise
- * invisible until a request comes back rejected:
- * - a tool with no permitted name is withheld, and the still-free names are listed so picking
- *   one is a single config line;
- * - a name that collides with a host built-in (or its case-twin) is called out, since that
- *   replaces the built-in or reads as a duplicate.
- */
-export function resolveToolPolicy(
-  config: Pick<OverclockConfig, "toolNames" | "toolAllowlist">,
-  features: readonly FeatureModule[],
-): { policy: ToolPolicy; issues: ConfigIssue[] } {
-  const { names: allowlist, aliases, unaliased, issues } = resolveAllowlist(config.toolAllowlist)
-
-  // Explicit names win: a bundled list is a starting point, not a straitjacket.
-  const rename: Record<string, string> = { ...aliases, ...(config.toolNames ?? {}) }
-
-  const final = new Map<string, string>() // declared -> model-visible
-  for (const name of features.flatMap((f) => f.tools ?? [])) {
-    final.set(name, rename[name] ?? name)
-  }
-
-  for (const [name, visible] of final) {
-    const twin = HOST_TOOL_IDS.find((id) => id.toLowerCase() === visible.toLowerCase())
-    if (!twin) continue
-    issues.push({
-      path: `tool "${name}"`,
-      message:
-        twin === visible
-          ? `"${visible}" is an opencode built-in -- registering it replaces that built-in`
-          : `"${visible}" differs from opencode's built-in "${twin}" only by case; anything matching case-insensitively sees one name twice`,
-    })
-  }
-
-  const withheld = new Set<string>()
-  if (allowlist) {
-    const allowed = new Set(allowlist)
-    const taken = new Set([...final.values()].filter((v) => allowed.has(v)))
-    const builtin = new Set(HOST_TOOL_IDS.map((id) => id.toLowerCase()))
-    // Suggesting a name that would immediately earn a built-in collision warning is worse than
-    // suggesting nothing, so case-twins of opencode's own ids are not offered.
-    const free = allowlist.filter((n) => !taken.has(n) && !builtin.has(n.toLowerCase()))
-    for (const [name, visible] of final) {
-      if (allowed.has(visible)) continue
-      withheld.add(name)
-      const why = unaliased[name] ? ` (${unaliased[name]})` : ""
-      issues.push({
-        path: `tool "${name}"`,
-        message:
-          `"${visible}" is not in toolAllowlist${why} -- withheld from the model. ` +
-          `Pick a name for it via toolNames (free: ${free.slice(0, 4).join(", ") || "none left"}), ` +
-          `or add one to toolAllowlist`,
-      })
-    }
-  }
-
-  return { policy: { rename, withheld }, issues }
-}
+export {
+  applyToolPolicy,
+  EMPTY_POLICY,
+  HOST_TOOL_IDS,
+  renameInText,
+  resolveToolPolicy,
+  type ToolPolicy,
+} from "./core/policy.ts"