@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/guard/guard-hook.ts

@@ -1,27 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { createGuardEventHandler } from "./event-handler"
-import { createToolExecuteAfterHandler } from "./tool-execute-after"
-import { createToolExecuteBeforeHandler } from "./tool-execute-before"
-import type { GuardHookOptions, PendingTaskRef, SessionState } from "./types"
-
-export function createGuardHook(ctx: PluginInput, options?: GuardHookOptions) {
-  const sessions = new Map<string, SessionState>()
-  const pendingFilePaths = new Map<string, string>()
-  const pendingTaskRefs = new Map<string, PendingTaskRef>()
-  const autoCommit = options?.autoCommit ?? true
-
-  function getState(sessionID: string): SessionState {
-    let state = sessions.get(sessionID)
-    if (!state) {
-      state = { promptFailureCount: 0 }
-      sessions.set(sessionID, state)
-    }
-    return state
-  }
-
-  return {
-    handler: createGuardEventHandler({ ctx, options, sessions, getState }),
-    "tool.execute.before": createToolExecuteBeforeHandler({ ctx, pendingFilePaths, pendingTaskRefs }),
-    "tool.execute.after": createToolExecuteAfterHandler({ ctx, pendingFilePaths, pendingTaskRefs, autoCommit, getState }),
-  }
-}

package/src/hooks/guard/hook-name.ts

@@ -1 +0,0 @@
-export const HOOK_NAME = "guard"

package/src/hooks/guard/idle-event.ts

@@ -1,341 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  getPlanProgress,
-  getTaskSessionState,
-  readBoulderState,
-  readCurrentTopLevelTask,
-} from "../../features/boulder-state"
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import { getLastAgentFromSession } from "./session-last-agent"
-import { isSessionInBoulderLineage } from "./boulder-session-lineage"
-import { getAgentConfigKey } from "../../shared/agent-display-names"
-import { log } from "../../shared/logger"
-import { injectBoulderContinuation } from "./boulder-continuation-injector"
-import { HOOK_NAME } from "./hook-name"
-import { resolveActiveBoulderSession } from "./resolve-active-boulder-session"
-import type { GuardHookOptions, SessionState } from "./types"
-
-const CONTINUATION_COOLDOWN_MS = 5000
-const FAILURE_BACKOFF_MS = 5 * 60 * 1000
-const MAX_CONSECUTIVE_PROMPT_FAILURES = 10
-const RETRY_DELAY_MS = CONTINUATION_COOLDOWN_MS + 1000
-
-function hasRunningBackgroundTasks(sessionID: string, options?: GuardHookOptions): boolean {
-  const backgroundManager = options?.backgroundManager
-  return backgroundManager
-    ? backgroundManager.getTasksByParentSession(sessionID).some((task: { status: string }) => task.status === "running")
-    : false
-}
-
-async function injectContinuation(input: {
-  ctx: PluginInput
-  sessionID: string
-  sessionState: SessionState
-  options?: GuardHookOptions
-  planName: string
-  progress: { total: number; completed: number }
-  agent?: string
-  worktreePath?: string
-}): Promise<void> {
-  const remaining = input.progress.total - input.progress.completed
-  if (input.sessionState.isInjectingContinuation) {
-    scheduleRetry({
-      ctx: input.ctx,
-      sessionID: input.sessionID,
-      sessionState: input.sessionState,
-      options: input.options,
-    })
-    return
-  }
-
-  input.sessionState.isInjectingContinuation = true
-
-  try {
-    const currentBoulder = readBoulderState(input.ctx.directory)
-    const currentTask = currentBoulder
-      ? readCurrentTopLevelTask(currentBoulder.active_plan)
-      : null
-    const preferredTaskSession = currentTask
-      ? getTaskSessionState(input.ctx.directory, currentTask.key)
-      : null
-
-    if (!currentBoulder) {
-      return
-    }
-
-    const canContinueSession = await canContinueTrackedBoulderSession({
-      client: input.ctx.client,
-      sessionID: input.sessionID,
-      sessionOrigin: currentBoulder.session_origins?.[input.sessionID],
-      boulderSessionIDs: currentBoulder.session_ids,
-      requiredAgent: currentBoulder.agent,
-    })
-    if (!canContinueSession) {
-      log(`[${HOOK_NAME}] Skipped: tracked descendant agent does not match boulder agent`, {
-        sessionID: input.sessionID,
-        requiredAgent: currentBoulder.agent ?? "guard",
-      })
-      return
-    }
-
-    const result = await injectBoulderContinuation({
-      ctx: input.ctx,
-      sessionID: input.sessionID,
-      planName: input.planName,
-      remaining,
-      total: input.progress.total,
-      agent: input.agent,
-      worktreePath: input.worktreePath,
-      preferredTaskSessionId: preferredTaskSession?.session_id,
-      preferredTaskTitle: preferredTaskSession?.task_title,
-      backgroundManager: input.options?.backgroundManager,
-      sessionState: input.sessionState,
-    })
-
-    if (result === "injected") {
-      if (input.sessionState.pendingRetryTimer) {
-        clearTimeout(input.sessionState.pendingRetryTimer)
-        input.sessionState.pendingRetryTimer = undefined
-      }
-      input.sessionState.lastContinuationInjectedAt = Date.now()
-      return
-    }
-
-    if (result === "skipped_background_tasks") {
-      scheduleRetry({
-        ctx: input.ctx,
-        sessionID: input.sessionID,
-        sessionState: input.sessionState,
-        options: input.options,
-      })
-      return
-    }
-
-    if (result === "failed") {
-      scheduleRetry({
-        ctx: input.ctx,
-        sessionID: input.sessionID,
-        sessionState: input.sessionState,
-        options: input.options,
-      })
-    }
-  } catch (error) {
-    log(`[${HOOK_NAME}] Failed to inject boulder continuation`, { sessionID: input.sessionID, error })
-    input.sessionState.promptFailureCount += 1
-    input.sessionState.lastFailureAt = Date.now()
-    scheduleRetry({
-      ctx: input.ctx,
-      sessionID: input.sessionID,
-      sessionState: input.sessionState,
-      options: input.options,
-    })
-  } finally {
-    input.sessionState.isInjectingContinuation = false
-  }
-}
-
-function scheduleRetry(input: {
-  ctx: PluginInput
-  sessionID: string
-  sessionState: SessionState
-  options?: GuardHookOptions
-}): void {
-  const { ctx, sessionID, sessionState, options } = input
-  if (sessionState.pendingRetryTimer) {
-    return
-  }
-
-  sessionState.pendingRetryTimer = setTimeout(async () => {
-    sessionState.pendingRetryTimer = undefined
-
-    if (sessionState.promptFailureCount >= MAX_CONSECUTIVE_PROMPT_FAILURES) return
-    if (sessionState.waitingForFinalWaveApproval) return
-
-    const now = Date.now()
-    if (
-      sessionState.lastContinuationInjectedAt
-      && now - sessionState.lastContinuationInjectedAt < CONTINUATION_COOLDOWN_MS
-    ) {
-      return
-    }
-
-    const currentBoulder = readBoulderState(ctx.directory)
-    if (!currentBoulder) return
-    if (!currentBoulder.session_ids?.includes(sessionID)) return
-
-    const currentProgress = getPlanProgress(currentBoulder.active_plan)
-    if (currentProgress.isComplete) return
-    if (options?.isContinuationStopped?.(sessionID)) return
-    const canContinueSession = await canContinueTrackedBoulderSession({
-      client: ctx.client,
-      sessionID,
-      sessionOrigin: currentBoulder.session_origins?.[sessionID],
-      boulderSessionIDs: currentBoulder.session_ids,
-      requiredAgent: currentBoulder.agent,
-    })
-    if (!canContinueSession) return
-    if (hasRunningBackgroundTasks(sessionID, options)) {
-      scheduleRetry({ ctx, sessionID, sessionState, options })
-      return
-    }
-
-    await injectContinuation({
-      ctx,
-      sessionID,
-      sessionState,
-      options,
-      planName: currentBoulder.plan_name,
-      progress: currentProgress,
-      agent: currentBoulder.agent,
-      worktreePath: currentBoulder.worktree_path,
-    })
-  }, RETRY_DELAY_MS)
-}
-
-export async function handleGuardSessionIdle(input: {
-  ctx: PluginInput
-  options?: GuardHookOptions
-  getState: (sessionID: string) => SessionState
-  sessionID: string
-}): Promise<void> {
-  const { ctx, options, getState, sessionID } = input
-
-  log(`[${HOOK_NAME}] session.idle`, { sessionID })
-
-  const activeBoulderSession = await resolveActiveBoulderSession({
-    client: ctx.client,
-    directory: ctx.directory,
-    sessionID,
-  })
-  if (!activeBoulderSession) {
-    log(`[${HOOK_NAME}] Skipped: session not registered in active boulder`, { sessionID })
-    return
-  }
-
-  const { boulderState, progress, appendedSession } = activeBoulderSession
-  if (progress.isComplete) {
-    log(`[${HOOK_NAME}] Boulder complete`, { sessionID, plan: boulderState.plan_name })
-    return
-  }
-
-  if (appendedSession) {
-    log(`[${HOOK_NAME}] Appended subagent session to boulder during idle`, {
-      sessionID,
-      plan: boulderState.plan_name,
-    })
-  }
-
-  const canContinueSession = await canContinueTrackedBoulderSession({
-    client: ctx.client,
-    sessionID,
-    sessionOrigin: boulderState.session_origins?.[sessionID],
-    boulderSessionIDs: boulderState.session_ids,
-    requiredAgent: boulderState.agent,
-  })
-  if (!canContinueSession) {
-    log(`[${HOOK_NAME}] Skipped: tracked descendant agent does not match boulder agent`, {
-      sessionID,
-      requiredAgent: boulderState.agent ?? "guard",
-    })
-    return
-  }
-
-  const sessionState = getState(sessionID)
-  const now = Date.now()
-
-  if (sessionState.waitingForFinalWaveApproval) {
-    log(`[${HOOK_NAME}] Skipped: waiting for explicit final-wave approval`, { sessionID })
-    return
-  }
-
-  if (sessionState.lastEventWasAbortError) {
-    sessionState.lastEventWasAbortError = false
-    log(`[${HOOK_NAME}] Skipped: abort error immediately before idle`, { sessionID })
-    return
-  }
-
-  if (sessionState.promptFailureCount >= MAX_CONSECUTIVE_PROMPT_FAILURES) {
-    const timeSinceLastFailure =
-      sessionState.lastFailureAt !== undefined ? now - sessionState.lastFailureAt : Number.POSITIVE_INFINITY
-    if (timeSinceLastFailure < FAILURE_BACKOFF_MS) {
-      log(`[${HOOK_NAME}] Skipped: continuation in backoff after repeated failures`, {
-        sessionID,
-        promptFailureCount: sessionState.promptFailureCount,
-        backoffRemaining: FAILURE_BACKOFF_MS - timeSinceLastFailure,
-      })
-      return
-    }
-
-    sessionState.promptFailureCount = 0
-    sessionState.lastFailureAt = undefined
-  }
-
-  if (hasRunningBackgroundTasks(sessionID, options)) {
-    scheduleRetry({ ctx, sessionID, sessionState, options })
-    log(`[${HOOK_NAME}] Skipped: background tasks running`, { sessionID })
-    return
-  }
-
-  if (options?.isContinuationStopped?.(sessionID)) {
-    log(`[${HOOK_NAME}] Skipped: continuation stopped for session`, { sessionID })
-    return
-  }
-
-  if (sessionState.lastContinuationInjectedAt && now - sessionState.lastContinuationInjectedAt < CONTINUATION_COOLDOWN_MS) {
-    scheduleRetry({ ctx, sessionID, sessionState, options })
-    log(`[${HOOK_NAME}] Skipped: continuation cooldown active`, {
-      sessionID,
-      cooldownRemaining: CONTINUATION_COOLDOWN_MS - (now - sessionState.lastContinuationInjectedAt),
-      pendingRetry: !!sessionState.pendingRetryTimer,
-    })
-    return
-  }
-
-  await injectContinuation({
-    ctx,
-    sessionID,
-    sessionState,
-    options,
-    planName: boulderState.plan_name,
-    progress,
-    agent: boulderState.agent,
-    worktreePath: boulderState.worktree_path,
-  })
-}
-
-async function canContinueTrackedBoulderSession(input: {
-  client: PluginInput["client"]
-  sessionID: string
-  sessionOrigin?: "direct" | "appended"
-  boulderSessionIDs: string[]
-  requiredAgent?: string
-}): Promise<boolean> {
-  const ancestorSessionIDs = input.boulderSessionIDs.filter((trackedSessionID) => trackedSessionID !== input.sessionID)
-  if (ancestorSessionIDs.length === 0) {
-    return true
-  }
-
-  const isTrackedDescendant = await isSessionInBoulderLineage({
-    client: input.client,
-    sessionID: input.sessionID,
-    boulderSessionIDs: ancestorSessionIDs,
-  })
-  if (input.sessionOrigin === "direct") {
-    return true
-  }
-
-  if (!isTrackedDescendant) {
-    return false
-  }
-
-  const sessionAgent = await getLastAgentFromSession(input.sessionID, input.client)
-    ?? getSessionAgent(input.sessionID)
-  if (!sessionAgent) {
-    return false
-  }
-
-  const requiredAgentKey = getAgentConfigKey(input.requiredAgent ?? "guard")
-  const sessionAgentKey = getAgentConfigKey(sessionAgent)
-  return sessionAgentKey === requiredAgentKey
-    || (requiredAgentKey === getAgentConfigKey("guard") && sessionAgentKey === getAgentConfigKey("bob"))
-}

package/src/hooks/guard/index.ts

@@ -1,3 +0,0 @@
-export { HOOK_NAME } from "./hook-name"
-export { createGuardHook } from "./guard-hook"
-export type { GuardHookOptions } from "./types"

package/src/hooks/guard/is-abort-error.ts

@@ -1,20 +0,0 @@
-export function isAbortError(error: unknown): boolean {
-  if (!error) return false
-
-  if (typeof error === "object") {
-    const errObj = error as Record<string, unknown>
-    const name = errObj.name as string | undefined
-    const message = (errObj.message as string | undefined)?.toLowerCase() ?? ""
-
-    if (name === "MessageAbortedError" || name === "AbortError") return true
-    if (name === "DOMException" && message.includes("abort")) return true
-    if (message.includes("aborted") || message.includes("cancelled") || message.includes("interrupted")) return true
-  }
-
-  if (typeof error === "string") {
-    const lower = error.toLowerCase()
-    return lower.includes("abort") || lower.includes("cancel") || lower.includes("interrupt")
-  }
-
-  return false
-}

package/src/hooks/guard/recent-model-resolver.ts

@@ -1,89 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  findNearestMessageWithFields,
-  findNearestMessageWithFieldsFromSDK,
-} from "../../features/hook-message-injector"
-import { getMessageDir, isSqliteBackend, normalizePromptTools, normalizeSDKResponse } from "../../shared"
-import type { ModelInfo } from "./types"
-
-type PromptContext = {
-  model?: ModelInfo
-  tools?: Record<string, boolean>
-}
-
-export async function resolveRecentPromptContextForSession(
-  ctx: PluginInput,
-  sessionID: string
-): Promise<PromptContext> {
-  try {
-    const messagesResp = await ctx.client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(messagesResp, [] as Array<{
-      id?: string
-      info?: {
-        model?: ModelInfo
-        modelID?: string
-        providerID?: string
-        tools?: Record<string, boolean | "allow" | "deny" | "ask">
-        time?: { created?: number }
-      }
-    }>).sort((left, right) => {
-      const leftTime = left.info?.time?.created ?? Number.NEGATIVE_INFINITY
-      const rightTime = right.info?.time?.created ?? Number.NEGATIVE_INFINITY
-      if (leftTime !== rightTime) return rightTime - leftTime
-      const leftId = typeof left.id === "string" ? left.id : ""
-      const rightId = typeof right.id === "string" ? right.id : ""
-      return rightId.localeCompare(leftId)
-    })
-
-    for (const message of messages) {
-      const info = message.info
-      const model = info?.model
-      const tools = normalizePromptTools(info?.tools)
-      if (model?.providerID && model?.modelID) {
-        return {
-          model: {
-            providerID: model.providerID,
-            modelID: model.modelID,
-            ...(model.variant ? { variant: model.variant } : {}),
-          },
-          tools,
-        }
-      }
-
-      if (info?.providerID && info?.modelID) {
-        return { model: { providerID: info.providerID, modelID: info.modelID }, tools }
-      }
-    }
-  } catch {
-    // ignore - fallback to message storage
-  }
-
-  let currentMessage = null
-  if (isSqliteBackend()) {
-    currentMessage = await findNearestMessageWithFieldsFromSDK(ctx.client, sessionID)
-  } else {
-    const messageDir = getMessageDir(sessionID)
-    currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-  }
-  const model = currentMessage?.model
-  const tools = normalizePromptTools(currentMessage?.tools)
-  if (!model?.providerID || !model?.modelID) {
-    return { tools }
-  }
-  return {
-    model: {
-      providerID: model.providerID,
-      modelID: model.modelID,
-      ...(model.variant ? { variant: model.variant } : {}),
-    },
-    tools,
-  }
-}
-
-export async function resolveRecentModelForSession(
-  ctx: PluginInput,
-  sessionID: string
-): Promise<ModelInfo | undefined> {
-  const context = await resolveRecentPromptContextForSession(ctx, sessionID)
-  return context.model
-}

package/src/hooks/guard/resolve-active-boulder-session.ts

@@ -1,29 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { getPlanProgress, readBoulderState } from "../../features/boulder-state"
-import type { BoulderState, PlanProgress } from "../../features/boulder-state"
-
-export async function resolveActiveBoulderSession(input: {
-  client: PluginInput["client"]
-  directory: string
-  sessionID: string
-}): Promise<{
-  boulderState: BoulderState
-  progress: PlanProgress
-  appendedSession: boolean
-} | null> {
-  const boulderState = readBoulderState(input.directory)
-  if (!boulderState) {
-    return null
-  }
-
-  if (!boulderState.session_ids.includes(input.sessionID)) {
-    return null
-  }
-
-  const progress = getPlanProgress(boulderState.active_plan)
-  if (progress.isComplete) {
-    return { boulderState, progress, appendedSession: false }
-  }
-
-  return { boulderState, progress, appendedSession: false }
-}

package/src/hooks/guard/session-last-agent.ts

@@ -1,153 +0,0 @@
-import { readFileSync, readdirSync } from "node:fs"
-import { join } from "node:path"
-
-import { getMessageDir, isSqliteBackend, normalizeSDKResponse } from "../../shared"
-import { hasCompactionPartInStorage, isCompactionMessage } from "../../shared/compaction-marker"
-
-type SessionLastAgentDeps = {
-  getMessageDir: typeof getMessageDir
-  isSqliteBackend: typeof isSqliteBackend
-  normalizeSDKResponse: typeof normalizeSDKResponse
-  hasCompactionPartInStorage: typeof hasCompactionPartInStorage
-  isCompactionMessage: typeof isCompactionMessage
-}
-
-const defaultSessionLastAgentDeps: SessionLastAgentDeps = {
-  getMessageDir,
-  isSqliteBackend,
-  normalizeSDKResponse,
-  hasCompactionPartInStorage,
-  isCompactionMessage,
-}
-
-type SessionMessagesClient = {
-  session: {
-    messages: (input: { path: { id: string } }) => Promise<unknown>
-  }
-}
-
-function getLastAgentFromMessageDir(messageDir: string): string | null {
-  try {
-    const messages = readdirSync(messageDir)
-      .filter((fileName) => fileName.endsWith(".json"))
-      .map((fileName) => {
-        try {
-          const content = readFileSync(join(messageDir, fileName), "utf-8")
-          const parsed = JSON.parse(content) as { id?: string; agent?: unknown; time?: { created?: unknown } }
-          return {
-            fileName,
-            id: parsed.id,
-            agent: parsed.agent,
-            createdAt: typeof parsed.time?.created === "number" ? parsed.time.created : Number.NEGATIVE_INFINITY,
-          }
-        } catch {
-          return null
-        }
-      })
-      .filter((message): message is { fileName: string; id: string | undefined; agent: unknown; createdAt: number } => message !== null)
-      .sort((left, right) => (right?.createdAt ?? 0) - (left?.createdAt ?? 0) || (right?.fileName ?? "").localeCompare(left?.fileName ?? ""))
-
-    for (const message of messages) {
-      if (!message) continue
-      if (isCompactionMessage({ agent: message.agent }) || hasCompactionPartInStorage(message?.id)) {
-        continue
-      }
-
-      if (typeof message.agent === "string") {
-        return message.agent.toLowerCase()
-      }
-    }
-  } catch {
-    return null
-  }
-
-  return null
-}
-
-export async function getLastAgentFromSession(
-  sessionID: string,
-  client?: SessionMessagesClient,
-  deps: Partial<SessionLastAgentDeps> = {},
-): Promise<string | null> {
-  const resolvedDeps: SessionLastAgentDeps = {
-    ...defaultSessionLastAgentDeps,
-    ...deps,
-  }
-
-  if (resolvedDeps.isSqliteBackend() && client) {
-    try {
-      const response = await client.session.messages({ path: { id: sessionID } })
-      const messages = resolvedDeps.normalizeSDKResponse(response, [] as Array<{
-        id?: string
-        info?: { agent?: string; time?: { created?: number } }
-        parts?: Array<{ type?: string }>
-      }>, {
-        preferResponseOnMissingData: true,
-      }).sort((left, right) => {
-        const leftTime = (left as { info?: { time?: { created?: number } } }).info?.time?.created ?? Number.NEGATIVE_INFINITY
-        const rightTime = (right as { info?: { time?: { created?: number } } }).info?.time?.created ?? Number.NEGATIVE_INFINITY
-        if (leftTime !== rightTime) {
-          return rightTime - leftTime
-        }
-
-        const leftId = typeof left.id === "string" ? left.id : ""
-        const rightId = typeof right.id === "string" ? right.id : ""
-        return rightId.localeCompare(leftId)
-      })
-
-      for (const message of messages) {
-        if (resolvedDeps.isCompactionMessage(message)) {
-          continue
-        }
-
-        const agent = message.info?.agent
-        if (typeof agent === "string") {
-          return agent.toLowerCase()
-        }
-      }
-    } catch {
-      return null
-    }
-
-    return null
-  }
-
-  const messageDir = resolvedDeps.getMessageDir(sessionID)
-  if (!messageDir) return null
-
-  try {
-    const messages = readdirSync(messageDir)
-      .filter((fileName) => fileName.endsWith(".json"))
-      .map((fileName) => {
-        try {
-          const content = readFileSync(join(messageDir, fileName), "utf-8")
-          const parsed = JSON.parse(content) as { id?: string; agent?: unknown; time?: { created?: unknown } }
-          return {
-            fileName,
-            id: parsed.id,
-            agent: parsed.agent,
-            createdAt: typeof parsed.time?.created === "number" ? parsed.time.created : Number.NEGATIVE_INFINITY,
-          }
-        } catch {
-          return null
-        }
-      })
-      .filter((message): message is { fileName: string; id: string | undefined; agent: unknown; createdAt: number } => message !== null)
-      .sort((left, right) => (right?.createdAt ?? 0) - (left?.createdAt ?? 0) || (right?.fileName ?? "").localeCompare(left?.fileName ?? ""))
-
-    for (const message of messages) {
-      if (!message) continue
-      if (resolvedDeps.isCompactionMessage({ agent: message.agent }) || resolvedDeps.hasCompactionPartInStorage(message?.id)) {
-        continue
-      }
-
-      if (typeof message.agent === "string") {
-        return message.agent.toLowerCase()
-      }
-    }
-  } catch {
-    return null
-  }
-
-  return null
-}