opencode-repos 0.3.0 → 0.3.2

package/oh-my-opencode/src/hooks/auto-update-checker/index.ts

@@ -1,260 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { getCachedVersion, getLocalDevVersion, findPluginEntry, getLatestVersion, updatePinnedVersion } from "./checker"
-import { invalidatePackage } from "./cache"
-import { PACKAGE_NAME } from "./constants"
-import { log } from "../../shared/logger"
-import { getConfigLoadErrors, clearConfigLoadErrors } from "../../shared/config-errors"
-import { runBunInstall } from "../../cli/config-manager"
-import type { AutoUpdateCheckerOptions } from "./types"
-
-const SISYPHUS_SPINNER = ["·", "•", "●", "○", "◌", "◦", " "]
-
-export function isPrereleaseVersion(version: string): boolean {
-  return version.includes("-")
-}
-
-export function isDistTag(version: string): boolean {
-  const startsWithDigit = /^\d/.test(version)
-  return !startsWithDigit
-}
-
-export function isPrereleaseOrDistTag(pinnedVersion: string | null): boolean {
-  if (!pinnedVersion) return false
-  return isPrereleaseVersion(pinnedVersion) || isDistTag(pinnedVersion)
-}
-
-export function extractChannel(version: string | null): string {
-  if (!version) return "latest"
-  
-  if (isDistTag(version)) {
-    return version
-  }
-  
-  if (isPrereleaseVersion(version)) {
-    const prereleasePart = version.split("-")[1]
-    if (prereleasePart) {
-      const channelMatch = prereleasePart.match(/^(alpha|beta|rc|canary|next)/)
-      if (channelMatch) {
-        return channelMatch[1]
-      }
-    }
-  }
-  
-  return "latest"
-}
-
-export function createAutoUpdateCheckerHook(ctx: PluginInput, options: AutoUpdateCheckerOptions = {}) {
-  const { showStartupToast = true, isSisyphusEnabled = false, autoUpdate = true } = options
-
-  const getToastMessage = (isUpdate: boolean, latestVersion?: string): string => {
-    if (isSisyphusEnabled) {
-      return isUpdate
-        ? `Sisyphus on steroids is steering OpenCode.\nv${latestVersion} available. Restart to apply.`
-        : `Sisyphus on steroids is steering OpenCode.`
-    }
-    return isUpdate
-      ? `OpenCode is now on Steroids. oMoMoMoMo...\nv${latestVersion} available. Restart OpenCode to apply.`
-      : `OpenCode is now on Steroids. oMoMoMoMo...`
-  }
-
-  let hasChecked = false
-
-  return {
-    event: ({ event }: { event: { type: string; properties?: unknown } }) => {
-      if (event.type !== "session.created") return
-      if (hasChecked) return
-
-      const props = event.properties as { info?: { parentID?: string } } | undefined
-      if (props?.info?.parentID) return
-
-      hasChecked = true
-
-      setTimeout(async () => {
-        const cachedVersion = getCachedVersion()
-        const localDevVersion = getLocalDevVersion(ctx.directory)
-        const displayVersion = localDevVersion ?? cachedVersion
-
-        await showConfigErrorsIfAny(ctx)
-
-        if (localDevVersion) {
-          if (showStartupToast) {
-            showLocalDevToast(ctx, displayVersion, isSisyphusEnabled).catch(() => {})
-          }
-          log("[auto-update-checker] Local development mode")
-          return
-        }
-
-        if (showStartupToast) {
-          showVersionToast(ctx, displayVersion, getToastMessage(false)).catch(() => {})
-        }
-
-        runBackgroundUpdateCheck(ctx, autoUpdate, getToastMessage).catch(err => {
-          log("[auto-update-checker] Background update check failed:", err)
-        })
-      }, 0)
-    },
-  }
-}
-
-async function runBackgroundUpdateCheck(
-  ctx: PluginInput,
-  autoUpdate: boolean,
-  getToastMessage: (isUpdate: boolean, latestVersion?: string) => string
-): Promise<void> {
-  const pluginInfo = findPluginEntry(ctx.directory)
-  if (!pluginInfo) {
-    log("[auto-update-checker] Plugin not found in config")
-    return
-  }
-
-  const cachedVersion = getCachedVersion()
-  const currentVersion = cachedVersion ?? pluginInfo.pinnedVersion
-  if (!currentVersion) {
-    log("[auto-update-checker] No version found (cached or pinned)")
-    return
-  }
-
-  const channel = extractChannel(pluginInfo.pinnedVersion ?? currentVersion)
-  const latestVersion = await getLatestVersion(channel)
-  if (!latestVersion) {
-    log("[auto-update-checker] Failed to fetch latest version for channel:", channel)
-    return
-  }
-
-  if (currentVersion === latestVersion) {
-    log("[auto-update-checker] Already on latest version for channel:", channel)
-    return
-  }
-
-  log(`[auto-update-checker] Update available (${channel}): ${currentVersion} → ${latestVersion}`)
-
-  if (!autoUpdate) {
-    await showUpdateAvailableToast(ctx, latestVersion, getToastMessage)
-    log("[auto-update-checker] Auto-update disabled, notification only")
-    return
-  }
-
-  if (pluginInfo.isPinned) {
-    const updated = updatePinnedVersion(pluginInfo.configPath, pluginInfo.entry, latestVersion)
-    if (!updated) {
-      await showUpdateAvailableToast(ctx, latestVersion, getToastMessage)
-      log("[auto-update-checker] Failed to update pinned version in config")
-      return
-    }
-    log(`[auto-update-checker] Config updated: ${pluginInfo.entry} → ${PACKAGE_NAME}@${latestVersion}`)
-  }
-
-  invalidatePackage(PACKAGE_NAME)
-
-  const installSuccess = await runBunInstallSafe()
-
-  if (installSuccess) {
-    await showAutoUpdatedToast(ctx, currentVersion, latestVersion)
-    log(`[auto-update-checker] Update installed: ${currentVersion} → ${latestVersion}`)
-  } else {
-    await showUpdateAvailableToast(ctx, latestVersion, getToastMessage)
-    log("[auto-update-checker] bun install failed; update not installed (falling back to notification-only)")
-  }
-}
-
-async function runBunInstallSafe(): Promise<boolean> {
-  try {
-    return await runBunInstall()
-  } catch (err) {
-    const errorMessage = err instanceof Error ? err.message : String(err)
-    log("[auto-update-checker] bun install error:", errorMessage)
-    return false
-  }
-}
-
-async function showConfigErrorsIfAny(ctx: PluginInput): Promise<void> {
-  const errors = getConfigLoadErrors()
-  if (errors.length === 0) return
-
-  const errorMessages = errors.map(e => `${e.path}: ${e.error}`).join("\n")
-  await ctx.client.tui
-    .showToast({
-      body: {
-        title: "Config Load Error",
-        message: `Failed to load config:\n${errorMessages}`,
-        variant: "error" as const,
-        duration: 10000,
-      },
-    })
-    .catch(() => {})
-
-  log(`[auto-update-checker] Config load errors shown: ${errors.length} error(s)`)
-  clearConfigLoadErrors()
-}
-
-async function showVersionToast(ctx: PluginInput, version: string | null, message: string): Promise<void> {
-  const displayVersion = version ?? "unknown"
-  await showSpinnerToast(ctx, displayVersion, message)
-  log(`[auto-update-checker] Startup toast shown: v${displayVersion}`)
-}
-
-async function showSpinnerToast(ctx: PluginInput, version: string, message: string): Promise<void> {
-  const totalDuration = 5000
-  const frameInterval = 100
-  const totalFrames = Math.floor(totalDuration / frameInterval)
-
-  for (let i = 0; i < totalFrames; i++) {
-    const spinner = SISYPHUS_SPINNER[i % SISYPHUS_SPINNER.length]
-    await ctx.client.tui
-      .showToast({
-        body: {
-          title: `${spinner} OhMyOpenCode ${version}`,
-          message,
-          variant: "info" as const,
-          duration: frameInterval + 50,
-        },
-      })
-      .catch(() => { })
-    await new Promise(resolve => setTimeout(resolve, frameInterval))
-  }
-}
-
-async function showUpdateAvailableToast(
-  ctx: PluginInput,
-  latestVersion: string,
-  getToastMessage: (isUpdate: boolean, latestVersion?: string) => string
-): Promise<void> {
-  await ctx.client.tui
-    .showToast({
-      body: {
-        title: `OhMyOpenCode ${latestVersion}`,
-        message: getToastMessage(true, latestVersion),
-        variant: "info" as const,
-        duration: 8000,
-      },
-    })
-    .catch(() => {})
-  log(`[auto-update-checker] Update available toast shown: v${latestVersion}`)
-}
-
-async function showAutoUpdatedToast(ctx: PluginInput, oldVersion: string, newVersion: string): Promise<void> {
-  await ctx.client.tui
-    .showToast({
-      body: {
-        title: `OhMyOpenCode Updated!`,
-        message: `v${oldVersion} → v${newVersion}\nRestart OpenCode to apply.`,
-        variant: "success" as const,
-        duration: 8000,
-      },
-    })
-    .catch(() => {})
-  log(`[auto-update-checker] Auto-updated toast shown: v${oldVersion} → v${newVersion}`)
-}
-
-async function showLocalDevToast(ctx: PluginInput, version: string | null, isSisyphusEnabled: boolean): Promise<void> {
-  const displayVersion = version ?? "dev"
-  const message = isSisyphusEnabled
-    ? "Sisyphus running in local development mode."
-    : "Running in local development mode. oMoMoMo..."
-  await showSpinnerToast(ctx, `${displayVersion} (dev)`, message)
-  log(`[auto-update-checker] Local dev toast shown: v${displayVersion}`)
-}
-
-export type { UpdateCheckResult, AutoUpdateCheckerOptions } from "./types"
-export { checkForUpdate } from "./checker"
-export { invalidatePackage, invalidateCache } from "./cache"

package/oh-my-opencode/src/hooks/auto-update-checker/types.ts

@@ -1,29 +0,0 @@
-export interface NpmDistTags {
-  latest: string
-  [key: string]: string
-}
-
-export interface OpencodeConfig {
-  plugin?: string[]
-  [key: string]: unknown
-}
-
-export interface PackageJson {
-  version: string
-  name?: string
-  [key: string]: unknown
-}
-
-export interface UpdateCheckResult {
-  needsUpdate: boolean
-  currentVersion: string | null
-  latestVersion: string | null
-  isLocalDev: boolean
-  isPinned: boolean
-}
-
-export interface AutoUpdateCheckerOptions {
-  showStartupToast?: boolean
-  isSisyphusEnabled?: boolean
-  autoUpdate?: boolean
-}

package/oh-my-opencode/src/hooks/background-compaction/index.ts

@@ -1,87 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-
-interface CompactingInput {
-  sessionID: string
-}
-
-interface CompactingOutput {
-  context: string[]
-  prompt?: string
-}
-
-/**
- * Background agent compaction hook - preserves task state during context compaction.
- * 
- * When OpenCode compacts session context to save tokens, this hook injects
- * information about running and recently completed background tasks so the
- * agent doesn't lose awareness of delegated work.
- */
-export function createBackgroundCompactionHook(manager: BackgroundManager) {
-  return {
-    "experimental.session.compacting": async (
-      input: CompactingInput,
-      output: CompactingOutput
-    ): Promise<void> => {
-      const { sessionID } = input
-
-      // Get running tasks for this session
-      const running = manager.getRunningTasks()
-        .filter(t => t.parentSessionID === sessionID)
-        .map(t => ({
-          id: t.id,
-          agent: t.agent,
-          description: t.description,
-          startedAt: t.startedAt,
-        }))
-
-      // Get recently completed tasks (still in memory within 5-min retention)
-      const completed = manager.getCompletedTasks()
-        .filter(t => t.parentSessionID === sessionID)
-        .slice(-10) // Last 10 completed
-        .map(t => ({
-          id: t.id,
-          agent: t.agent,
-          description: t.description,
-          status: t.status,
-        }))
-
-      // Early exit if nothing to preserve
-      if (running.length === 0 && completed.length === 0) return
-
-      const sections: string[] = ["<background-tasks>"]
-
-      // Running tasks section
-      if (running.length > 0) {
-        sections.push("## Running Background Tasks")
-        sections.push("")
-        for (const t of running) {
-          const elapsed = t.startedAt 
-            ? Math.floor((Date.now() - t.startedAt.getTime()) / 1000)
-            : 0
-          sections.push(`- **\`${t.id}\`** (${t.agent}): ${t.description} [${elapsed}s elapsed]`)
-        }
-        sections.push("")
-        sections.push("> **Note:** You WILL be notified when tasks complete.")
-        sections.push("> Do NOT poll - continue productive work.")
-        sections.push("")
-      }
-
-      // Completed tasks section
-      if (completed.length > 0) {
-        sections.push("## Recently Completed Tasks")
-        sections.push("")
-        for (const t of completed) {
-          const statusEmoji = t.status === "completed" ? "✅" : t.status === "error" ? "❌" : "⏱️"
-          sections.push(`- ${statusEmoji} **\`${t.id}\`**: ${t.description}`)
-        }
-        sections.push("")
-      }
-
-      sections.push("## Retrieval")
-      sections.push('Use `background_output(task_id="<id>")` to retrieve task results.')
-      sections.push("</background-tasks>")
-
-      output.context.push(sections.join("\n"))
-    }
-  }
-}

package/oh-my-opencode/src/hooks/background-notification/index.ts

@@ -1,28 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-
-interface Event {
-  type: string
-  properties?: Record<string, unknown>
-}
-
-interface EventInput {
-  event: Event
-}
-
-/**
- * Background notification hook - handles event routing to BackgroundManager.
- * 
- * Notifications are now delivered directly via session.prompt({ noReply }) 
- * from the manager, so this hook only needs to handle event routing.
- */
-export function createBackgroundNotificationHook(manager: BackgroundManager) {
-  const eventHandler = async ({ event }: EventInput) => {
-    manager.handleEvent(event)
-  }
-
-  return {
-    event: eventHandler,
-  }
-}
-
-export type { BackgroundNotificationHookConfig } from "./types"

package/oh-my-opencode/src/hooks/background-notification/types.ts

@@ -1,5 +0,0 @@
-import type { BackgroundTask } from "../../features/background-agent"
-
-export interface BackgroundNotificationHookConfig {
-  formatNotification?: (tasks: BackgroundTask[]) => string
-}

package/oh-my-opencode/src/hooks/claude-code-hooks/AGENTS.md

@@ -1,70 +0,0 @@
-# CLAUDE CODE HOOKS COMPATIBILITY LAYER
-
-## OVERVIEW
-
-Full Claude Code settings.json hook compatibility. Executes user-defined hooks at 5 lifecycle events: PreToolUse, PostToolUse, UserPromptSubmit, Stop, PreCompact.
-
-## STRUCTURE
-
-```
-claude-code-hooks/
-├── index.ts              # Main factory (401 lines) - createClaudeCodeHooksHook()
-├── config.ts             # Loads ~/.claude/settings.json
-├── config-loader.ts      # Extended config from multiple sources
-├── pre-tool-use.ts       # PreToolUse hook executor (172 lines)
-├── post-tool-use.ts      # PostToolUse hook executor (199 lines)
-├── user-prompt-submit.ts # UserPromptSubmit hook executor
-├── stop.ts               # Stop hook executor (session idle)
-├── pre-compact.ts        # PreCompact hook executor (context compaction)
-├── transcript.ts         # Tool use recording (252 lines)
-├── tool-input-cache.ts   # Caches tool inputs between pre/post
-├── types.ts              # Hook types, context interfaces
-├── todo.ts               # Todo JSON parsing fix
-└── plugin-config.ts      # Plugin config access
-```
-
-## HOOK LIFECYCLE
-
-| Event | When | Can Block | Context Fields |
-|-------|------|-----------|----------------|
-| **PreToolUse** | Before tool | Yes | sessionId, toolName, toolInput, cwd |
-| **PostToolUse** | After tool | Warn only | + toolOutput, transcriptPath |
-| **UserPromptSubmit** | On user message | Yes | sessionId, prompt, parts, cwd |
-| **Stop** | Session idle | inject_prompt | sessionId, parentSessionId |
-| **PreCompact** | Before summarize | No | sessionId, cwd |
-
-## CONFIG SOURCES
-
-Priority (highest first):
-1. `.claude/settings.json` (project)
-2. `~/.claude/settings.json` (user)
-
-```json
-{
-  "hooks": {
-    "PreToolUse": [{ "matcher": "Edit", "command": "./check.sh" }],
-    "PostToolUse": [{ "command": "post-hook.sh $TOOL_NAME" }]
-  }
-}
-```
-
-## HOOK EXECUTION
-
-1. User-defined hooks loaded from settings.json
-2. Matchers filter by tool name (supports wildcards)
-3. Commands executed via subprocess with environment:
-   - `$SESSION_ID`, `$TOOL_NAME`, `$TOOL_INPUT`, `$CWD`
-4. Exit codes: 0=pass, 1=warn, 2=block
-
-## KEY PATTERNS
-
-- **Session tracking**: `Map<sessionID, state>` for first-message, error, interrupt
-- **Input caching**: Tool inputs cached pre→post via `tool-input-cache.ts`
-- **Transcript recording**: All tool uses logged for debugging
-- **Todowrite fix**: Parses string todos to array (line 174-196)
-
-## ANTI-PATTERNS
-
-- **Heavy PreToolUse logic**: Runs before EVERY tool call
-- **Blocking non-critical**: Use warnings in PostToolUse instead
-- **Missing error handling**: Always wrap subprocess calls

package/oh-my-opencode/src/hooks/claude-code-hooks/config-loader.ts

@@ -1,107 +0,0 @@
-import { existsSync } from "fs"
-import { homedir } from "os"
-import { join } from "path"
-import type { ClaudeHookEvent } from "./types"
-import { log } from "../../shared/logger"
-
-export interface DisabledHooksConfig {
-  Stop?: string[]
-  PreToolUse?: string[]
-  PostToolUse?: string[]
-  UserPromptSubmit?: string[]
-  PreCompact?: string[]
-}
-
-export interface PluginExtendedConfig {
-  disabledHooks?: DisabledHooksConfig
-}
-
-const USER_CONFIG_PATH = join(homedir(), ".config", "opencode", "opencode-cc-plugin.json")
-
-function getProjectConfigPath(): string {
-  return join(process.cwd(), ".opencode", "opencode-cc-plugin.json")
-}
-
-async function loadConfigFromPath(path: string): Promise<PluginExtendedConfig | null> {
-  if (!existsSync(path)) {
-    return null
-  }
-
-  try {
-    const content = await Bun.file(path).text()
-    return JSON.parse(content) as PluginExtendedConfig
-  } catch (error) {
-    log("Failed to load config", { path, error })
-    return null
-  }
-}
-
-function mergeDisabledHooks(
-  base: DisabledHooksConfig | undefined,
-  override: DisabledHooksConfig | undefined
-): DisabledHooksConfig {
-  if (!override) return base ?? {}
-  if (!base) return override
-
-  return {
-    Stop: override.Stop ?? base.Stop,
-    PreToolUse: override.PreToolUse ?? base.PreToolUse,
-    PostToolUse: override.PostToolUse ?? base.PostToolUse,
-    UserPromptSubmit: override.UserPromptSubmit ?? base.UserPromptSubmit,
-    PreCompact: override.PreCompact ?? base.PreCompact,
-  }
-}
-
-export async function loadPluginExtendedConfig(): Promise<PluginExtendedConfig> {
-  const userConfig = await loadConfigFromPath(USER_CONFIG_PATH)
-  const projectConfig = await loadConfigFromPath(getProjectConfigPath())
-
-  const merged: PluginExtendedConfig = {
-    disabledHooks: mergeDisabledHooks(
-      userConfig?.disabledHooks,
-      projectConfig?.disabledHooks
-    ),
-  }
-
-  if (userConfig || projectConfig) {
-    log("Plugin extended config loaded", {
-      userConfigExists: userConfig !== null,
-      projectConfigExists: projectConfig !== null,
-      mergedDisabledHooks: merged.disabledHooks,
-    })
-  }
-
-  return merged
-}
-
-const regexCache = new Map<string, RegExp>()
-
-function getRegex(pattern: string): RegExp {
-  let regex = regexCache.get(pattern)
-  if (!regex) {
-    try {
-      regex = new RegExp(pattern)
-      regexCache.set(pattern, regex)
-    } catch {
-      regex = new RegExp(pattern.replace(/[.*+?^${}()|[\]\\]/g, "\\$&"))
-      regexCache.set(pattern, regex)
-    }
-  }
-  return regex
-}
-
-export function isHookCommandDisabled(
-  eventType: ClaudeHookEvent,
-  command: string,
-  config: PluginExtendedConfig | null
-): boolean {
-  if (!config?.disabledHooks) return false
-
-  const patterns = config.disabledHooks[eventType]
-  if (!patterns || patterns.length === 0) return false
-
-  return patterns.some((pattern) => {
-    const regex = getRegex(pattern)
-    return regex.test(command)
-  })
-}

package/oh-my-opencode/src/hooks/claude-code-hooks/config.ts

@@ -1,103 +0,0 @@
-import { join } from "path"
-import { existsSync } from "fs"
-import { getClaudeConfigDir } from "../../shared"
-import type { ClaudeHooksConfig, HookMatcher, HookCommand } from "./types"
-
-interface RawHookMatcher {
-  matcher?: string
-  pattern?: string
-  hooks: HookCommand[]
-}
-
-interface RawClaudeHooksConfig {
-  PreToolUse?: RawHookMatcher[]
-  PostToolUse?: RawHookMatcher[]
-  UserPromptSubmit?: RawHookMatcher[]
-  Stop?: RawHookMatcher[]
-  PreCompact?: RawHookMatcher[]
-}
-
-function normalizeHookMatcher(raw: RawHookMatcher): HookMatcher {
-  return {
-    matcher: raw.matcher ?? raw.pattern ?? "*",
-    hooks: raw.hooks,
-  }
-}
-
-function normalizeHooksConfig(raw: RawClaudeHooksConfig): ClaudeHooksConfig {
-  const result: ClaudeHooksConfig = {}
-  const eventTypes: (keyof RawClaudeHooksConfig)[] = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "Stop",
-    "PreCompact",
-  ]
-
-  for (const eventType of eventTypes) {
-    if (raw[eventType]) {
-      result[eventType] = raw[eventType].map(normalizeHookMatcher)
-    }
-  }
-
-  return result
-}
-
-export function getClaudeSettingsPaths(customPath?: string): string[] {
-  const claudeConfigDir = getClaudeConfigDir()
-  const paths = [
-    join(claudeConfigDir, "settings.json"),
-    join(process.cwd(), ".claude", "settings.json"),
-    join(process.cwd(), ".claude", "settings.local.json"),
-  ]
-
-  if (customPath && existsSync(customPath)) {
-    paths.unshift(customPath)
-  }
-
-  return paths
-}
-
-function mergeHooksConfig(
-  base: ClaudeHooksConfig,
-  override: ClaudeHooksConfig
-): ClaudeHooksConfig {
-  const result: ClaudeHooksConfig = { ...base }
-  const eventTypes: (keyof ClaudeHooksConfig)[] = [
-    "PreToolUse",
-    "PostToolUse",
-    "UserPromptSubmit",
-    "Stop",
-    "PreCompact",
-  ]
-  for (const eventType of eventTypes) {
-    if (override[eventType]) {
-      result[eventType] = [...(base[eventType] || []), ...override[eventType]]
-    }
-  }
-  return result
-}
-
-export async function loadClaudeHooksConfig(
-  customSettingsPath?: string
-): Promise<ClaudeHooksConfig | null> {
-  const paths = getClaudeSettingsPaths(customSettingsPath)
-  let mergedConfig: ClaudeHooksConfig = {}
-
-  for (const settingsPath of paths) {
-    if (existsSync(settingsPath)) {
-      try {
-        const content = await Bun.file(settingsPath).text()
-        const settings = JSON.parse(content) as { hooks?: RawClaudeHooksConfig }
-        if (settings.hooks) {
-          const normalizedHooks = normalizeHooksConfig(settings.hooks)
-          mergedConfig = mergeHooksConfig(mergedConfig, normalizedHooks)
-        }
-      } catch {
-        continue
-      }
-    }
-  }
-
-  return Object.keys(mergedConfig).length > 0 ? mergedConfig : null
-}