@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/keyword-detector/ultrawork/source-detector.ts

@@ -1,65 +0,0 @@
-/**
- * Agent/model detection utilities for ultrawork message routing.
- *
- * Routing logic:
- * 1. Planner agents (strategist, plan) → planner.ts
- * 2. GPT 5.4 models → gpt5.4.ts
- * 3. Gemini models → gemini.ts
- * 4. Everything else (Claude, etc.) → default.ts
- */
-
-import { isGptModel, isGeminiModel } from "../../../agents/types"
-
-/**
- * Checks if agent is a planner-type agent.
- * Planners don't need ultrawork injection (they ARE the planner).
- */
-export function isPlannerAgent(agentName?: string): boolean {
-  if (!agentName) return false
-  const lowerName = agentName.toLowerCase()
-  if (lowerName.includes("strategist") || lowerName.includes("planner")) return true
-
-  const normalized = lowerName.replace(/[_-]+/g, " ")
-  return /\bplan\b/.test(normalized)
-}
-
-/**
- * Checks if agent is a non-OMO agent (e.g., OpenCode's built-in Builder/Plan).
- * Non-OMO agents should not receive keyword injection (search-mode, analyze-mode, etc.).
- */
-export function isNonOmoAgent(agentName?: string): boolean {
-  if (!agentName) return false
-  const lowerName = agentName.toLowerCase()
-  return lowerName.includes("builder") || lowerName === "plan"
-}
-
-export { isGptModel, isGeminiModel }
-
-/** Ultrawork message source type */
-export type UltraworkSource = "planner" | "gpt" | "gemini" | "default"
-
-/**
- * Determines which ultrawork message source to use.
- */
-export function getUltraworkSource(
-  agentName?: string,
-  modelID?: string
-): UltraworkSource {
-  // Priority 1: Planner agents
-  if (isPlannerAgent(agentName)) {
-    return "planner"
-  }
-
-  // Priority 2: GPT models
-  if (modelID && isGptModel(modelID)) {
-    return "gpt"
-  }
-
-
-  // Priority 3: Gemini models
-  if (modelID && isGeminiModel(modelID)) {
-    return "gemini"
-  }
-  // Default: Claude and other models
-  return "default"
-}

package/src/hooks/legacy-plugin-toast/auto-migrate-runner.ts

@@ -1,2 +0,0 @@
-export { autoMigrateLegacyPluginEntry } from "./auto-migrate"
-export type { MigrationResult } from "./auto-migrate"

package/src/hooks/legacy-plugin-toast/auto-migrate.ts

@@ -1,64 +0,0 @@
-import { existsSync, readFileSync } from "node:fs"
-import { join } from "node:path"
-
-import { parseJsoncSafe } from "../../shared/jsonc-parser"
-import { getOpenCodeConfigPaths } from "../../shared/opencode-config-dir"
-import { PLUGIN_NAME } from "../../shared/plugin-identity"
-import { isCanonicalEntry, isLegacyEntry, toCanonicalEntry } from "../../shared/plugin-entry-migrator"
-import { migrateLegacyPluginEntry } from "./plugin-entry-migrator"
-
-export interface MigrationResult {
-  migrated: boolean
-  from: string | null
-  to: string | null
-  configPath: string | null
-}
-
-interface OpenCodeConfig {
-  plugin?: string[]
-}
-
-function detectOpenCodeConfigPath(overrideConfigDir?: string): string | null {
-  if (overrideConfigDir) {
-    const jsoncPath = join(overrideConfigDir, "opencode.jsonc")
-    const jsonPath = join(overrideConfigDir, "opencode.json")
-    if (existsSync(jsoncPath)) return jsoncPath
-    if (existsSync(jsonPath)) return jsonPath
-    return null
-  }
-
-  const paths = getOpenCodeConfigPaths({ binary: "opencode", version: null })
-  if (existsSync(paths.configJsonc)) return paths.configJsonc
-  if (existsSync(paths.configJson)) return paths.configJson
-  return null
-}
-
-export function autoMigrateLegacyPluginEntry(overrideConfigDir?: string): MigrationResult {
-  const configPath = detectOpenCodeConfigPath(overrideConfigDir)
-  if (!configPath) return { migrated: false, from: null, to: null, configPath: null }
-
-  try {
-    const content = readFileSync(configPath, "utf-8")
-    const parseResult = parseJsoncSafe<OpenCodeConfig>(content)
-    if (!parseResult.data?.plugin) return { migrated: false, from: null, to: null, configPath }
-
-    const plugins = parseResult.data.plugin
-    const legacyEntries = plugins.filter(isLegacyEntry)
-    if (legacyEntries.length === 0) return { migrated: false, from: null, to: null, configPath }
-
-    const hasCanonical = plugins.some(isCanonicalEntry)
-    const from = legacyEntries[0]
-    const to = toCanonicalEntry(from)
-    const migrated = migrateLegacyPluginEntry(configPath)
-    if (!migrated) return { migrated: false, from: null, to: null, configPath }
-
-    return {
-      migrated: true,
-      from,
-      to: hasCanonical ? PLUGIN_NAME : to,
-      configPath,
-    }
-  } catch {
-    return { migrated: false, from: null, to: null, configPath }
-  }
-}

package/src/hooks/legacy-plugin-toast/hook.ts

@@ -1,68 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-
-import { checkForLegacyPluginEntry } from "../../shared/legacy-plugin-warning"
-import { log } from "../../shared/logger"
-import { LEGACY_PLUGIN_NAME, PLUGIN_NAME, PUBLISHED_PACKAGE_NAME } from "../../shared/plugin-identity"
-import { autoMigrateLegacyPluginEntry } from "./auto-migrate-runner"
-
-type LegacyPluginToastDeps = {
-  checkForLegacyPluginEntry?: typeof checkForLegacyPluginEntry
-  log?: typeof log
-  autoMigrateLegacyPluginEntry?: typeof autoMigrateLegacyPluginEntry
-}
-
-export function createLegacyPluginToastHook(ctx: PluginInput, deps: LegacyPluginToastDeps = {}) {
-  let fired = false
-  const checkForLegacyPluginEntryFn = deps.checkForLegacyPluginEntry ?? checkForLegacyPluginEntry
-  const logFn = deps.log ?? log
-  const autoMigrateLegacyPluginEntryFn = deps.autoMigrateLegacyPluginEntry ?? autoMigrateLegacyPluginEntry
-
-  return {
-    event: async ({ event }: { event: { type: string; properties?: unknown } }) => {
-      if (event.type !== "session.created" || fired) return
-
-      const props = event.properties as { info?: { parentID?: string } } | undefined
-      if (props?.info?.parentID) return
-
-      fired = true
-
-      const result = checkForLegacyPluginEntryFn()
-      if (!result.hasLegacyEntry) return
-
-      const migration = autoMigrateLegacyPluginEntryFn()
-
-      if (migration.migrated) {
-        logFn("[legacy-plugin-toast] Auto-migrated opencode.json plugin entry", {
-          from: migration.from,
-          to: migration.to,
-        })
-
-        await ctx.client.tui
-          .showToast({
-            body: {
-              title: "Plugin Entry Migrated",
-              message: `"${migration.from}" has been renamed to "${migration.to}" in your opencode.json.\nNo action needed.`,
-              variant: "success" as const,
-              duration: 8000,
-            },
-          })
-          .catch(() => {})
-      } else {
-        logFn("[legacy-plugin-toast] Legacy entry detected but migration failed", {
-          legacyEntries: result.legacyEntries,
-        })
-
-        await ctx.client.tui
-          .showToast({
-            body: {
-              title: "Legacy Plugin Name Detected",
-               message: `Update your opencode.json: "${LEGACY_PLUGIN_NAME}" has been renamed to "${PLUGIN_NAME}".\nRun: bunx ${PUBLISHED_PACKAGE_NAME} install`,
-              variant: "warning" as const,
-              duration: 10000,
-            },
-          })
-          .catch(() => {})
-      }
-    },
-  }
-}

package/src/hooks/legacy-plugin-toast/index.ts

@@ -1 +0,0 @@
-export { createLegacyPluginToastHook } from "./hook"

package/src/hooks/legacy-plugin-toast/plugin-entry-migrator.ts

@@ -1 +0,0 @@
-export { migrateLegacyPluginEntry } from "../../shared/migrate-legacy-plugin-entry"

package/src/hooks/model-fallback/chat-message-fallback-handler.ts

@@ -1,74 +0,0 @@
-import { log } from "../../shared/logger"
-import { getTaskToastManager } from "../../features/task-toast-manager"
-import type { ChatMessageHandlerOutput, ChatMessageInput } from "../../plugin/chat-message"
-
-export async function applyFallbackToChatMessage(params: {
-  input: ChatMessageInput
-  output: ChatMessageHandlerOutput
-  fallback: { providerID: string; modelID: string; variant?: string }
-  toast?: (input: {
-    title: string
-    message: string
-    variant?: "info" | "success" | "warning" | "error"
-    duration?: number
-  }) => void | Promise<void>
-  onApplied?: (input: {
-    sessionID: string
-    providerID: string
-    modelID: string
-    variant?: string
-  }) => void | Promise<void>
-  lastToastKey: Map<string, string>
-}): Promise<void> {
-  const { input, output, fallback, toast, onApplied, lastToastKey } = params
-  const { sessionID } = input
-  if (!sessionID) return
-
-  output.message["model"] = {
-    providerID: fallback.providerID,
-    modelID: fallback.modelID,
-  }
-  if (fallback.variant !== undefined) {
-    output.message["variant"] = fallback.variant
-  } else {
-    delete output.message["variant"]
-  }
-
-  if (toast) {
-    const key = `${sessionID}:${fallback.providerID}/${fallback.modelID}:${fallback.variant ?? ""}`
-    if (lastToastKey.get(sessionID) !== key) {
-      lastToastKey.set(sessionID, key)
-      const variantLabel = fallback.variant ? ` (${fallback.variant})` : ""
-      await Promise.resolve(
-        toast({
-          title: "Model fallback",
-          message: `Using ${fallback.providerID}/${fallback.modelID}${variantLabel}`,
-          variant: "warning",
-          duration: 5000,
-        }),
-      )
-    }
-  }
-
-  if (onApplied) {
-    await Promise.resolve(
-      onApplied({
-        sessionID,
-        providerID: fallback.providerID,
-        modelID: fallback.modelID,
-        variant: fallback.variant,
-      }),
-    )
-  }
-
-  const toastManager = getTaskToastManager()
-  if (toastManager) {
-    const variantLabel = fallback.variant ? ` (${fallback.variant})` : ""
-    toastManager.updateTaskModelBySession(sessionID, {
-      model: `${fallback.providerID}/${fallback.modelID}${variantLabel}`,
-      type: "runtime-fallback",
-    })
-  }
-
-  log("[model-fallback] Applied fallback model: " + JSON.stringify(fallback))
-}

package/src/hooks/model-fallback/hook.ts

@@ -1,201 +0,0 @@
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-import { AGENT_MODEL_REQUIREMENTS } from "../../shared/model-requirements"
-import { readConnectedProvidersCache, readProviderModelsCache } from "../../shared/connected-providers-cache"
-import { selectFallbackProvider } from "../../shared/model-error-classifier"
-import { transformModelForProvider } from "../../shared/provider-model-id-transform"
-import { log } from "../../shared/logger"
-import type { ChatMessageInput, ChatMessageHandlerOutput } from "../../plugin/chat-message"
-import { applyFallbackToChatMessage } from "./chat-message-fallback-handler"
-import { getNextReachableFallback } from "./next-fallback"
-
-type FallbackToast = (input: {
-  title: string
-  message: string
-  variant?: "info" | "success" | "warning" | "error"
-  duration?: number
-}) => void | Promise<void>
-
-type FallbackCallback = (input: {
-  sessionID: string
-  providerID: string
-  modelID: string
-  variant?: string
-}) => void | Promise<void>
-
-export type ModelFallbackState = {
-  providerID: string
-  modelID: string
-  fallbackChain: FallbackEntry[]
-  attemptCount: number
-  pending: boolean
-}
-
-/**
- * Map of sessionID -> pending model fallback state
- * When a model error occurs, we store the fallback info here.
- * The next chat.message call will use this to switch to the fallback model.
- */
-const pendingModelFallbacks = new Map<string, ModelFallbackState>()
-const lastToastKey = new Map<string, string>()
-const sessionFallbackChains = new Map<string, FallbackEntry[]>()
-
-export function setSessionFallbackChain(sessionID: string, fallbackChain: FallbackEntry[] | undefined): void {
-  if (!sessionID) return
-  if (!fallbackChain) {
-    sessionFallbackChains.set(sessionID, [])
-    return
-  }
-  if (fallbackChain.length === 0) {
-    sessionFallbackChains.set(sessionID, [])
-    return
-  }
-  sessionFallbackChains.set(sessionID, fallbackChain)
-}
-
-export function clearSessionFallbackChain(sessionID: string): void {
-  sessionFallbackChains.delete(sessionID)
-}
-
-/**
- * Sets a pending model fallback for a session.
- * Called when a model error is detected in session.error handler.
- */
-export function setPendingModelFallback(
-  sessionID: string,
-  agentName: string,
-  currentProviderID: string,
-  currentModelID: string,
-): boolean {
-  const agentKey = getAgentConfigKey(agentName)
-  const requirements = AGENT_MODEL_REQUIREMENTS[agentKey]
-  const hasSessionFallback = sessionFallbackChains.has(sessionID)
-  const sessionFallback = sessionFallbackChains.get(sessionID)
-  const fallbackChain = hasSessionFallback
-    ? sessionFallback
-    : requirements?.fallbackChain
-
-  if (!fallbackChain || fallbackChain.length === 0) {
-    log("[model-fallback] No fallback chain for agent: " + agentName + " (key: " + agentKey + ")")
-    return false
-  }
-
-  const existing = pendingModelFallbacks.get(sessionID)
-
-  if (existing) {
-    if (existing.pending) {
-      log("[model-fallback] Pending fallback already armed for session: " + sessionID)
-      return false
-    }
-
-    // Preserve progression across repeated session.error retries in same session.
-    // We only mark the next turn as pending fallback application.
-    existing.providerID = currentProviderID
-    existing.modelID = currentModelID
-    existing.pending = true
-    if (existing.attemptCount >= existing.fallbackChain.length) {
-      log("[model-fallback] Fallback chain exhausted for session: " + sessionID)
-      return false
-    }
-    log("[model-fallback] Re-armed pending fallback for session: " + sessionID)
-    return true
-  }
-
-  const state: ModelFallbackState = {
-    providerID: currentProviderID,
-    modelID: currentModelID,
-    fallbackChain,
-    attemptCount: 0,
-    pending: true,
-  }
-
-  pendingModelFallbacks.set(sessionID, state)
-  log("[model-fallback] Set pending fallback for session: " + sessionID + ", agent: " + agentName)
-  return true
-}
-
-/**
- * Gets the next fallback model for a session.
- * Increments attemptCount each time called.
- */
-export function getNextFallback(
-  sessionID: string,
-): { providerID: string; modelID: string; variant?: string } | null {
-  const state = pendingModelFallbacks.get(sessionID)
-  if (!state) return null
-
-  if (!state.pending) return null
-
-  const fallback = getNextReachableFallback(sessionID, state)
-  if (fallback) {
-    return fallback
-  }
-
-  log("[model-fallback] No more fallbacks for session: " + sessionID)
-  pendingModelFallbacks.delete(sessionID)
-  return null
-}
-
-/**
- * Clears the pending fallback for a session.
- * Called after fallback is successfully applied.
- */
-export function clearPendingModelFallback(sessionID: string): void {
-  pendingModelFallbacks.delete(sessionID)
-  lastToastKey.delete(sessionID)
-}
-
-/**
- * Checks if there's a pending fallback for a session.
- */
-export function hasPendingModelFallback(sessionID: string): boolean {
-  const state = pendingModelFallbacks.get(sessionID)
-  return state?.pending === true
-}
-
-/**
- * Gets the current fallback state for a session (for debugging).
- */
-export function getFallbackState(sessionID: string): ModelFallbackState | undefined {
-  return pendingModelFallbacks.get(sessionID)
-}
-
-/**
- * Creates a chat.message hook that applies model fallbacks when pending.
- */
-export function createModelFallbackHook(args?: { toast?: FallbackToast; onApplied?: FallbackCallback }) {
-  const toast = args?.toast
-  const onApplied = args?.onApplied
-
-  return {
-    "chat.message": async (
-      input: ChatMessageInput,
-      output: ChatMessageHandlerOutput,
-    ): Promise<void> => {
-      const { sessionID } = input
-      if (!sessionID) return
-
-      const fallback = getNextFallback(sessionID)
-      if (!fallback) return
-
-      await applyFallbackToChatMessage({
-        input,
-        output,
-        fallback,
-        toast,
-        onApplied,
-        lastToastKey,
-      })
-    },
-  }
-}
-
-/**
- * Resets all module-global state for testing.
- * Clears pending fallbacks, toast keys, and session chains.
- */
-export function _resetForTesting(): void {
-  pendingModelFallbacks.clear()
-  lastToastKey.clear()
-  sessionFallbackChains.clear()
-}

package/src/hooks/model-fallback/next-fallback.ts

@@ -1,84 +0,0 @@
-import type { FallbackEntry } from "../../shared/model-requirements"
-import { readConnectedProvidersCache, readProviderModelsCache } from "../../shared/connected-providers-cache"
-import { selectFallbackProvider } from "../../shared/model-error-classifier"
-import { transformModelForProvider } from "../../shared/provider-model-id-transform"
-import { log } from "../../shared/logger"
-import type { ModelFallbackState } from "./hook"
-
-function canonicalizeModelID(modelID: string): string {
-  return modelID
-    .toLowerCase()
-    .replace(/\./g, "-")
-}
-
-function createReachabilityChecker(state: ModelFallbackState): (entry: FallbackEntry) => boolean {
-  const providerModelsCache = readProviderModelsCache()
-  const connectedProviders = providerModelsCache?.connected ?? readConnectedProvidersCache()
-  const connectedSet = connectedProviders
-    ? new Set(connectedProviders.map((provider) => provider.toLowerCase()))
-    : null
-
-  return (entry: FallbackEntry): boolean => {
-    if (!connectedSet) return true
-
-    if (entry.providers.some((provider) => connectedSet.has(provider.toLowerCase()))) {
-      return true
-    }
-
-    return connectedSet.has(state.providerID.toLowerCase())
-  }
-}
-
-export function getNextReachableFallback(
-  sessionID: string,
-  state: ModelFallbackState,
-): {
-  providerID: string
-  modelID: string
-  variant?: string
-  reasoningEffort?: string
-  temperature?: number
-  top_p?: number
-  maxTokens?: number
-  thinking?: { type: "enabled" | "disabled"; budgetTokens?: number }
-} | null {
-  const isReachable = createReachabilityChecker(state)
-
-  while (state.attemptCount < state.fallbackChain.length) {
-    const attemptCount = state.attemptCount
-    const fallback = state.fallbackChain[attemptCount]
-    state.attemptCount++
-
-    if (!isReachable(fallback)) {
-      log("[model-fallback] Skipping unreachable fallback for session: " + sessionID + ", attempt: " + attemptCount + ", model: " + fallback.model)
-      continue
-    }
-
-    const providerID = selectFallbackProvider(fallback.providers, state.providerID)
-    const modelID = transformModelForProvider(providerID, fallback.model)
-    const isNoOpFallback =
-      providerID.toLowerCase() === state.providerID.toLowerCase()
-      && canonicalizeModelID(modelID) === canonicalizeModelID(state.modelID)
-
-    if (isNoOpFallback) {
-      log("[model-fallback] Skipping no-op fallback for session: " + sessionID + ", attempt: " + attemptCount + ", model: " + fallback.model)
-      continue
-    }
-
-    state.pending = false
-    log("[model-fallback] Using fallback for session: " + sessionID + ", attempt: " + attemptCount + ", model: " + fallback.model)
-
-    return {
-      providerID,
-      modelID,
-      variant: fallback.variant,
-      reasoningEffort: fallback.reasoningEffort,
-      temperature: fallback.temperature,
-      top_p: fallback.top_p,
-      maxTokens: fallback.maxTokens,
-      thinking: fallback.thinking,
-    }
-  }
-
-  return null
-}

package/src/hooks/non-interactive-env/constants.ts

@@ -1,70 +0,0 @@
-export const HOOK_NAME = "non-interactive-env"
-
-export const NON_INTERACTIVE_ENV: Record<string, string> = {
-  CI: "true",
-  DEBIAN_FRONTEND: "noninteractive",
-  GIT_TERMINAL_PROMPT: "0",
-  GCM_INTERACTIVE: "never",
-  HOMEBREW_NO_AUTO_UPDATE: "1",
-  // Block interactive editors - git rebase, commit, etc.
-  GIT_EDITOR: ":",
-  EDITOR: ":",
-  VISUAL: "",
-  GIT_SEQUENCE_EDITOR: ":",
-  GIT_MERGE_AUTOEDIT: "no",
-  // Block pagers
-  GIT_PAGER: "cat",
-  PAGER: "cat",
-  // NPM non-interactive
-  npm_config_yes: "true",
-  // Pip non-interactive
-  PIP_NO_INPUT: "1",
-  // Yarn non-interactive
-  YARN_ENABLE_IMMUTABLE_INSTALLS: "false",
-}
-
-/**
- * Shell command guidance for non-interactive environments.
- * These patterns should be followed to avoid hanging on user input.
- */
-export const SHELL_COMMAND_PATTERNS = {
-  // Package managers - always use non-interactive flags
-  npm: {
-    bad: ["npm init", "npm install (prompts)"],
-    good: ["npm init -y", "npm install --yes"],
-  },
-  apt: {
-    bad: ["apt-get install pkg"],
-    good: ["apt-get install -y pkg", "DEBIAN_FRONTEND=noninteractive apt-get install pkg"],
-  },
-  pip: {
-    bad: ["pip install pkg (with prompts)"],
-    good: ["pip install --no-input pkg", "PIP_NO_INPUT=1 pip install pkg"],
-  },
-  // Git operations - always provide messages/flags
-  git: {
-    bad: ["git commit", "git merge branch", "git add -p", "git rebase -i"],
-    good: ["git commit -m 'msg'", "git merge --no-edit branch", "git add .", "git rebase --no-edit"],
-  },
-  // System commands - force flags
-  system: {
-    bad: ["rm file (prompts)", "cp a b (prompts)", "ssh host"],
-    good: ["rm -f file", "cp -f a b", "ssh -o BatchMode=yes host", "unzip -o file.zip"],
-  },
-  // Banned commands - will always hang
-  banned: [
-    "vim", "nano", "vi", "emacs",           // Editors
-    "less", "more", "man",                   // Pagers
-    "python (REPL)", "node (REPL)",          // REPLs without -c/-e
-    "git add -p", "git rebase -i",           // Interactive git modes
-  ],
-  // Workarounds for scripts that require input
-  workarounds: {
-    yesPipe: "yes | ./script.sh",
-    heredoc: `./script.sh <<EOF
-option1
-option2
-EOF`,
-    expectAlternative: "Use environment variables or config files instead of expect",
-  },
-} as const

package/src/hooks/non-interactive-env/detector.ts

@@ -1,19 +0,0 @@
-export function isNonInteractive(): boolean {
-  if (process.env.CI === "true" || process.env.CI === "1") {
-    return true
-  }
-
-  if (process.env.OPENCODE_RUN === "true" || process.env.OPENCODE_NON_INTERACTIVE === "true") {
-    return true
-  }
-
-  if (process.env.GITHUB_ACTIONS === "true") {
-    return true
-  }
-
-  if (process.stdout.isTTY !== true) {
-    return true
-  }
-
-  return false
-}

package/src/hooks/non-interactive-env/index.ts

@@ -1,5 +0,0 @@
-export * from "./constants"
-export * from "./detector"
-export * from "./types"
-
-export { createNonInteractiveEnvHook } from "./non-interactive-env-hook"