oc-tweaks 0.1.0

package/src/__tests__/notify.test.ts

@@ -0,0 +1,318 @@
+// @ts-nocheck
+
+import { afterEach, describe, expect, test } from "bun:test"
+
+import { notifyPlugin } from "../plugins/notify"
+
+const originalBunFile = Bun.file
+const originalHome = Bun.env?.HOME
+
+function mockBunFile(mockData: Record<string, any>) {
+  ;(globalThis as any).Bun.file = (path: string) => ({
+    exists: async () => path in mockData,
+    json: async () => {
+      if (!(path in mockData)) throw new Error("ENOENT")
+      const data = mockData[path]
+      if (data instanceof Error) throw data
+      return data
+    },
+    text: async () => JSON.stringify(mockData[path] ?? ""),
+  })
+}
+
+function createShellMock(options?: {
+  availableCommands?: string[]
+  throwOnExecution?: boolean
+}) {
+  const available = new Set(options?.availableCommands ?? [])
+  const calls: Array<{ command: string; values: any[] }> = []
+
+  const $ = async (strings: TemplateStringsArray, ...values: any[]) => {
+    const segments = Array.from(strings)
+    const command = segments.reduce(
+      (acc, segment, index) =>
+        acc + segment + (index < values.length ? String(values[index]) : ""),
+      "",
+    )
+
+    calls.push({ command, values })
+
+    if (command.startsWith("which ")) {
+      const bin = String(values[0] ?? command.slice("which ".length).trim())
+      if (available.has(bin)) return { stdout: `${bin}\n` }
+      throw new Error(`missing ${bin}`)
+    }
+
+    if (options?.throwOnExecution) {
+      throw new Error("execution failed")
+    }
+
+    return { stdout: "" }
+  }
+
+  return { $, calls }
+}
+
+
+afterEach(() => {
+  ;(globalThis as any).Bun.file = originalBunFile
+  if (originalHome === undefined) {
+    delete (Bun.env as any).HOME
+  } else {
+    ;(Bun.env as any).HOME = originalHome
+  }
+})
+
+describe("notifyPlugin", () => {
+  test("returns empty hooks when notify.enabled is false", async () => {
+    const home = "/tmp/oc-notify-disabled"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({
+      [path]: {
+        notify: { enabled: false },
+      },
+    })
+
+    const { $ } = createShellMock({ availableCommands: ["notify-send"] })
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client: {} })
+
+    expect(hooks).toEqual({})
+  })
+
+  test("auto-detects notifier once and caches detection result", async () => {
+    const home = "/tmp/oc-notify-detect"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({ [path]: { notify: { enabled: true } } })
+
+    const { $, calls } = createShellMock({ availableCommands: ["notify-send"] })
+    const client = {
+      session: {
+        messages: async () => ({
+          data: [
+            { info: { role: "user" }, parts: [{ type: "text", text: "irrelevant" }] },
+            { info: { role: "assistant" }, parts: [{ type: "text", text: "**Done**   now" }] },
+          ],
+        }),
+      },
+    }
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client })
+    await hooks.event({ event: { type: "session.idle", properties: { sessionID: "s1" } } })
+    await hooks.event({ event: { type: "session.error", properties: {} } })
+
+    const whichCalls = calls.filter((entry) => entry.command.startsWith("which "))
+    const notifyCalls = calls.filter((entry) => entry.command.startsWith("notify-send "))
+
+    expect(whichCalls.length).toBe(4)
+    expect(notifyCalls.length).toBe(2)
+    expect(notifyCalls[0].command).toContain("notify-send oc: demo")
+    expect(notifyCalls[0].command).toContain("✓ Done now")
+  })
+
+  test("uses custom command and replaces $TITLE/$MESSAGE placeholders", async () => {
+    const home = "/tmp/oc-notify-custom"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({
+      [path]: {
+        notify: {
+          enabled: true,
+          command: "custom-bin --title $TITLE --message $MESSAGE",
+        },
+      },
+    })
+
+    const { $, calls } = createShellMock()
+    const client = {
+      session: {
+        messages: async () => ({
+          data: [{ info: { role: "assistant" }, parts: [{ type: "text", text: "Hello *world*" }] }],
+        }),
+      },
+    }
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client })
+    await hooks.event({ event: { type: "session.idle", properties: { sessionID: "s2" } } })
+
+    const whichCalls = calls.filter((entry) => entry.command.startsWith("which "))
+    const executeCalls = calls.filter((entry) => !entry.command.startsWith("which "))
+
+    expect(whichCalls.length).toBe(0)
+    expect(executeCalls.length).toBe(1)
+    expect(executeCalls[0].command).toContain("custom-bin --title oc: demo --message ✓ Hello world")
+    expect(executeCalls[0].command).not.toContain("$TITLE")
+    expect(executeCalls[0].command).not.toContain("$MESSAGE")
+  })
+
+  test("does not notify when notifyOnIdle/notifyOnError are false", async () => {
+    const home = "/tmp/oc-notify-switches"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({
+      [path]: {
+        notify: {
+          enabled: true,
+          notifyOnIdle: false,
+          notifyOnError: false,
+        },
+      },
+    })
+
+    const { $, calls } = createShellMock({ availableCommands: ["notify-send"] })
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client: {} })
+
+    await hooks.event({ event: { type: "session.idle", properties: { sessionID: "s3" } } })
+    await hooks.event({ event: { type: "session.error", properties: {} } })
+
+    const notifyCalls = calls.filter((entry) => !entry.command.startsWith("which "))
+    expect(notifyCalls.length).toBe(0)
+  })
+
+  test("falls back to client.tui.showToast when no shell notifier exists", async () => {
+    const home = "/tmp/oc-notify-tui"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({ [path]: { notify: { enabled: true } } })
+
+    const { $, calls } = createShellMock()
+    const toastCalls: any[] = []
+    const client = {
+      tui: {
+        showToast: (...args: any[]) => {
+          toastCalls.push(args)
+        },
+      },
+    }
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client })
+    await hooks.event({ event: { type: "session.error", properties: {} } })
+
+    const whichCalls = calls.filter((entry) => entry.command.startsWith("which "))
+    expect(whichCalls.length).toBe(4)
+    expect(toastCalls.length).toBe(1)
+  })
+
+  test("degrades silently when execution fails and does not throw", async () => {
+    const home = "/tmp/oc-notify-non-blocking"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({ [path]: { notify: { enabled: true } } })
+
+    const { $ } = createShellMock({
+      availableCommands: ["notify-send"],
+      throwOnExecution: true,
+    })
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client: {} })
+
+    await expect(
+      hooks.event({ event: { type: "session.error", properties: {} } }),
+    ).resolves.toBeUndefined()
+  })
+
+  test("keeps silent when no notifier is available", async () => {
+    const home = "/tmp/oc-notify-none"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({ [path]: { notify: { enabled: true } } })
+
+    const { $ } = createShellMock()
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client: {} })
+
+    await expect(
+      hooks.event({ event: { type: "session.error", properties: {} } }),
+    ).resolves.toBeUndefined()
+  })
+})
+
+  test("detects pwsh and uses wpf sender", async () => {
+    const home = "/tmp/oc-notify-wpf-detect"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({ [path]: { notify: { enabled: true } } })
+
+    const { $, calls } = createShellMock({ availableCommands: ["pwsh"] })
+    const client = {
+      session: {
+        messages: async () => ({
+          data: [{ info: { role: "assistant" }, parts: [{ type: "text", text: "Task done" }] }],
+        }),
+      },
+    }
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client })
+    await hooks.event({ event: { type: "session.idle", properties: { sessionID: "s4" } } })
+
+    const pwshCalls = calls.filter((entry) => entry.command.includes("pwsh"))
+    expect(pwshCalls.length).toBeGreaterThan(0)
+
+    const bun_e_calls = calls.filter((entry) => entry.command.includes("bun -e"))
+    expect(bun_e_calls.length).toBeGreaterThan(0)
+
+    const jsCode = String(bun_e_calls[0].values[0] ?? "")
+    expect(jsCode).toContain("PresentationFramework")
+    expect(jsCode).toContain("ShowActivated")
+  })
+
+  test("wpf notification script contains WS_EX_NOACTIVATE for non-focus behavior", async () => {
+    const home = "/tmp/oc-notify-wpf-noactivate"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({ [path]: { notify: { enabled: true } } })
+
+    const { $, calls } = createShellMock({ availableCommands: ["pwsh"] })
+    const client = {
+      session: {
+        messages: async () => ({
+          data: [{ info: { role: "assistant" }, parts: [{ type: "text", text: "Finished" }] }],
+        }),
+      },
+    }
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client })
+    await hooks.event({ event: { type: "session.idle", properties: { sessionID: "s5" } } })
+
+    const bun_e_calls = calls.filter((entry) => entry.command.includes("bun -e"))
+    expect(bun_e_calls.length).toBeGreaterThan(0)
+
+    const jsCode = String(bun_e_calls[0].values[0] ?? "")
+    expect(jsCode).toMatch(/WS_EX_NOACTIVATE|0x08000000|MakeGlobalWindow/)
+  })
+
+  test("wpf notification uses custom style from config", async () => {
+    const home = "/tmp/oc-notify-wpf-style"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+    mockBunFile({
+      [path]: {
+        notify: {
+          enabled: true,
+          style: {
+            backgroundColor: "#FF0000",
+            duration: 3000,
+          },
+        },
+      },
+    })
+
+    const { $, calls } = createShellMock({ availableCommands: ["pwsh"] })
+    const client = {
+      session: {
+        messages: async () => ({
+          data: [{ info: { role: "assistant" }, parts: [{ type: "text", text: "Complete" }] }],
+        }),
+      },
+    }
+
+    const hooks = await notifyPlugin({ $, directory: "/tmp/demo", client })
+    await hooks.event({ event: { type: "session.idle", properties: { sessionID: "s6" } } })
+
+    const bun_e_calls = calls.filter((entry) => entry.command.includes("bun -e"))
+    expect(bun_e_calls.length).toBeGreaterThan(0)
+
+    const jsCode = String(bun_e_calls[0].values[0] ?? "")
+    expect(jsCode).toContain("#FF0000")
+    expect(jsCode).toContain("3000")
+  })

package/src/__tests__/utils.test.ts

@@ -0,0 +1,164 @@
+// @ts-nocheck
+
+import { describe, test, expect, beforeEach, afterEach } from "bun:test"
+
+import { safeHook } from "../utils/safe-hook"
+import { loadJsonConfig, loadOcTweaksConfig } from "../utils/config"
+
+const originalBunFile = Bun.file
+const originalHome = Bun.env?.HOME
+
+function mockBunFile(mockData: Record<string, any>) {
+  ;(globalThis as any).Bun.file = (path: string) => ({
+    exists: async () => path in mockData,
+    json: async () => {
+      if (!(path in mockData)) throw new Error("ENOENT")
+      const data = mockData[path]
+      if (data instanceof Error) throw data
+      return data
+    },
+    text: async () => JSON.stringify(mockData[path] ?? ""),
+  })
+}
+
+afterEach(() => {
+  ;(globalThis as any).Bun.file = originalBunFile
+  if (originalHome === undefined) {
+    delete (Bun.env as any).HOME
+  } else {
+    ;(Bun.env as any).HOME = originalHome
+  }
+})
+
+describe("safeHook", () => {
+  function createWarnSpy() {
+    const calls: any[] = []
+    const originalWarn = console.warn
+    console.warn = (...args: any[]) => {
+      calls.push(args)
+    }
+    return {
+      calls,
+      restore: () => {
+        console.warn = originalWarn
+      },
+    }
+  }
+
+  let warnSpy: ReturnType<typeof createWarnSpy>
+
+  beforeEach(() => {
+    warnSpy = createWarnSpy()
+  })
+
+  afterEach(() => {
+    warnSpy.restore()
+  })
+
+  test("returns original function result", async () => {
+    const wrapped = safeHook("add", (value: number) => value + 1)
+    const result = await Promise.resolve(wrapped(1))
+
+    expect(result).toBe(2)
+    expect(warnSpy.calls.length).toBe(0)
+  })
+
+  test("swallows errors silently (now uses logger, not console.warn)", async () => {
+    const error = new Error("boom")
+    const wrapped = safeHook("fail", () => {
+      throw error
+    })
+
+    // Should not throw, and should not call console.warn (logger is used instead)
+    await expect(Promise.resolve(wrapped())).resolves.toBeUndefined()
+    expect(warnSpy.calls.length).toBe(0)
+  })
+
+  test("works with async functions", async () => {
+    const wrapped = safeHook("async", async (value: number) => value * 2)
+    const result = await wrapped(3)
+
+    expect(result).toBe(6)
+    expect(warnSpy.calls.length).toBe(0)
+  })
+})
+
+describe("loadJsonConfig", () => {
+  test("returns defaults when file is missing", async () => {
+    mockBunFile({})
+    const defaults = { a: 1, b: true }
+
+    const result = await loadJsonConfig("/tmp/missing.json", defaults)
+
+    expect(result).toEqual(defaults)
+  })
+
+  test("merges defaults with parsed config", async () => {
+    const path = "/tmp/config.json"
+    mockBunFile({
+      [path]: {
+        b: false,
+        c: "extra",
+      },
+    })
+    const defaults = { a: 1, b: true }
+
+    const result = await loadJsonConfig(path, defaults)
+
+    expect(result).toEqual({ a: 1, b: false, c: "extra" })
+  })
+
+  test("returns defaults when json parsing fails", async () => {
+    const path = "/tmp/bad.json"
+    mockBunFile({
+      [path]: new Error("invalid json"),
+    })
+    const defaults = { enabled: true }
+
+    const result = await loadJsonConfig(path, defaults)
+
+    expect(result).toEqual(defaults)
+  })
+})
+
+describe("loadOcTweaksConfig", () => {
+  test("loads config from default path", async () => {
+    const home = "/tmp/oc-home"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+
+    mockBunFile({
+      [path]: {
+        notify: {
+          enabled: false,
+          notifyOnIdle: true,
+        },
+      },
+    })
+
+    const result = await loadOcTweaksConfig()
+
+    expect(result.notify.enabled).toBe(false)
+    expect(result.notify.notifyOnIdle).toBe(true)
+    expect(result.compaction).toEqual({})
+  })
+
+  test("string \"false\" is not treated as disabled", async () => {
+    const home = "/tmp/oc-home-2"
+    ;(Bun.env as any).HOME = home
+    const path = `${home}/.config/opencode/oc-tweaks.json`
+
+    mockBunFile({
+      [path]: {
+        notify: {
+          enabled: "false",
+        },
+      },
+    })
+
+    const result = await loadOcTweaksConfig()
+
+    expect(result.notify.enabled).toBe("false")
+    expect(result.notify.enabled === false).toBe(false)
+  })
+})

package/src/bun-test.d.ts

@@ -0,0 +1,12 @@
+/// <reference types="bun-types" />
+
+declare const Bun: any
+
+declare module "bun:test" {
+  export const describe: (...args: any[]) => any
+  export const test: (...args: any[]) => any
+  export const expect: any
+  export const mock: any
+  export const beforeEach: any
+  export const afterEach: any
+}

package/src/cli/init.ts

@@ -0,0 +1,44 @@
+#!/usr/bin/env bun
+
+import { mkdir } from "node:fs/promises"
+import { dirname } from "node:path"
+declare const Bun: any
+
+export const DEFAULT_CONFIG = {
+  notify: { enabled: true },
+  compaction: { enabled: true },
+  backgroundSubagent: { enabled: true },
+  leaderboard: { enabled: false },
+  logging: { enabled: false, maxLines: 200 }
+}
+
+export async function initConfig(): Promise<{ created: boolean; path: string }> {
+  const home = Bun.env?.HOME ?? ((globalThis as any)?.process?.env?.HOME ?? "") ?? ""
+  const configPath = `${home}/.config/opencode/oc-tweaks.json`
+
+  const file = Bun.file(configPath)
+  if (await file.exists()) {
+    return { created: false, path: configPath }
+  }
+
+  const json = JSON.stringify(DEFAULT_CONFIG, null, 2)
+  await mkdir(dirname(configPath), { recursive: true })
+  await Bun.write(configPath, json + "\n")
+
+  return { created: true, path: configPath }
+}
+
+// Only run when executed directly
+const isMain = typeof Bun !== "undefined" && 
+  Bun.main === import.meta.path
+
+if (isMain) {
+  const result = await initConfig()
+  if (result.created) {
+    console.log(`Created: ${result.path}`)
+    console.log("All plugins configured. Edit the file to customize.")
+  } else {
+    console.log(`Config already exists: ${result.path}`)
+    console.log("Nothing changed. Edit the file manually to update your configuration.")
+  }
+}

package/src/index.ts

@@ -0,0 +1,4 @@
+export { backgroundSubagentPlugin } from "./plugins/background-subagent"
+export { compactionPlugin } from "./plugins/compaction"
+export { leaderboardPlugin } from "./plugins/leaderboard"
+export { notifyPlugin } from "./plugins/notify"

package/src/plugins/background-subagent.ts

@@ -0,0 +1,59 @@
+import type { Plugin } from "@opencode-ai/plugin"
+
+import { loadOcTweaksConfig, safeHook } from "../utils"
+
+const SUB_AGENT_DISPATCH_PROMPT = `
+## Sub-Agent Dispatch Policy
+
+When calling \`task()\` to dispatch sub-agents, you should default to \`run_in_background=true\`.
+This keeps the main conversation responsive while sub-agents work in the background.
+
+Only use \`run_in_background=false\` when ALL of these conditions are met:
+1. The next step cannot easily proceed without the sub-agent's result
+2. There is NO other useful work to do while waiting
+3. The user is explicitly waiting for that specific result
+
+When in doubt → background. Use \`background_output()\` to collect results later.
+`
+
+const VIOLATION_WARNING = `💡 [Reminder] Consider using background mode for better responsiveness.
+You used foreground mode (run_in_background=false). Check the three conditions in the system prompt.
+If not all three are met, consider run_in_background=true + background_output() for next time.`
+
+export const backgroundSubagentPlugin: Plugin = async () => {
+  const config = await loadOcTweaksConfig()
+  if (!config || config.backgroundSubagent?.enabled !== true) return {}
+
+  const foregroundCalls = new Set<string>()
+
+  return {
+    "experimental.chat.system.transform": safeHook(
+      "background-subagent:system.transform",
+      async (_input: unknown, output: { system: string[] }) => {
+        output.system.push(SUB_AGENT_DISPATCH_PROMPT)
+      },
+    ),
+
+    "tool.execute.before": safeHook(
+      "background-subagent:tool.execute.before",
+      async (
+        input: { tool: string; callID: string },
+        output: { args?: { run_in_background?: boolean } },
+      ) => {
+        if (input.tool !== "task") return
+        if (!output.args?.run_in_background) {
+          foregroundCalls.add(input.callID)
+        }
+      },
+    ),
+
+    "tool.execute.after": safeHook(
+      "background-subagent:tool.execute.after",
+      async (input: { callID: string }, output: { output: string }) => {
+        if (!foregroundCalls.has(input.callID)) return
+        foregroundCalls.delete(input.callID)
+        output.output += `\n\n${VIOLATION_WARNING}`
+      },
+    ),
+  }
+}

package/src/plugins/compaction.ts

@@ -0,0 +1,28 @@
+import type { Plugin } from "@opencode-ai/plugin";
+
+import { loadOcTweaksConfig, safeHook } from "../utils";
+
+const LANGUAGE_PREFERENCE_PROMPT = `
+## Language Preference
+
+Important: Write the compaction summary in the user's preferred language(for example, if user prefers Chinese, then the compaction should be in Chinese as well).
+All section titles, descriptions, analysis, and next-step suggestions should use the user's language.
+Keep technical terms (filenames, variable names, commands, code snippets) in their original form.
+`;
+
+export const compactionPlugin: Plugin = async () => {
+  const config = await loadOcTweaksConfig();
+  if (!config || config.compaction?.enabled !== true) return {};
+
+  return {
+    "experimental.session.compacting": safeHook(
+      "compaction",
+      async (
+        _input: { sessionID: string },
+        output: { context: string[]; prompt?: string },
+      ) => {
+        output.context.push(LANGUAGE_PREFERENCE_PROMPT);
+      },
+    ),
+  };
+};