@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

package/src/hooks/compaction-context-injector/recovery.ts

@@ -1,163 +0,0 @@
-import {
-  resolveRegisteredAgentName,
-  updateSessionAgent,
-} from "../../features/claude-code-session-state"
-import {
-  getCompactionAgentConfigCheckpoint,
-} from "../../shared/compaction-agent-config-checkpoint"
-import { createInternalAgentTextPart } from "../../shared/internal-initiator-marker"
-import { log } from "../../shared/logger"
-import { setSessionModel } from "../../shared/session-model-state"
-import { setSessionTools } from "../../shared/session-tools-store"
-import {
-  createExpectedRecoveryPromptConfig,
-  isPromptConfigRecovered,
-} from "./recovery-prompt-config"
-import { validateCheckpointModel } from "./validated-model"
-import {
-  resolveLatestSessionPromptConfig,
-  resolveSessionPromptConfig,
-} from "./session-prompt-config-resolver"
-import { AGENT_RECOVERY_PROMPT, NO_TEXT_TAIL_THRESHOLD, RECOVERY_COOLDOWN_MS, RECENT_COMPACTION_WINDOW_MS } from "./constants"
-import type { CompactionContextClient } from "./types"
-import type { TailMonitorState } from "./tail-monitor"
-
-export function createRecoveryLogic(
-  ctx: CompactionContextClient | undefined,
-  getTailState: (sessionID: string) => TailMonitorState,
-) {
-  const recoverCheckpointedAgentConfig = async (
-    sessionID: string,
-    reason: "session.compacted" | "no-text-tail",
-  ): Promise<boolean> => {
-    if (!ctx) {
-      return false
-    }
-
-    const checkpoint = getCompactionAgentConfigCheckpoint(sessionID)
-    if (!checkpoint?.agent) {
-      return false
-    }
-
-    const tailState = getTailState(sessionID)
-    const now = Date.now()
-    if (tailState.lastRecoveryAt && now - tailState.lastRecoveryAt < RECOVERY_COOLDOWN_MS) {
-      return false
-    }
-
-    const currentPromptConfig = await resolveSessionPromptConfig(ctx, sessionID)
-    const validatedCheckpointModel = validateCheckpointModel(
-      checkpoint.model,
-      currentPromptConfig.model,
-    )
-    const { model: checkpointModel, ...checkpointWithoutModel } = checkpoint
-    const checkpointWithAgent = {
-      ...checkpointWithoutModel,
-      agent: checkpoint.agent,
-      ...(validatedCheckpointModel ? { model: validatedCheckpointModel } : {}),
-    }
-
-    if (checkpointModel && !validatedCheckpointModel) {
-      log(`[compaction-context-injector] Ignoring checkpoint model that disagrees with current prompt config`, {
-        sessionID,
-        checkpointModel,
-        currentModel: currentPromptConfig.model,
-      })
-    }
-
-    const expectedPromptConfig = createExpectedRecoveryPromptConfig(
-      checkpointWithAgent,
-      currentPromptConfig,
-    )
-    const launchAgent = resolveRegisteredAgentName(expectedPromptConfig.agent)
-    const model = expectedPromptConfig.model
-    const tools = expectedPromptConfig.tools
-
-    if (reason === "session.compacted") {
-      const latestPromptConfig = await resolveLatestSessionPromptConfig(ctx, sessionID)
-      if (isPromptConfigRecovered(latestPromptConfig, expectedPromptConfig)) {
-        return false
-      }
-    }
-
-    try {
-      await ctx.client.session.promptAsync({
-        path: { id: sessionID },
-        body: {
-          noReply: true,
-          agent: launchAgent ?? expectedPromptConfig.agent,
-          ...(model ? { model } : {}),
-          ...(tools ? { tools } : {}),
-          parts: [createInternalAgentTextPart(AGENT_RECOVERY_PROMPT)],
-        },
-        query: { directory: ctx.directory },
-      })
-
-      const recoveredPromptConfig = await resolveLatestSessionPromptConfig(ctx, sessionID)
-      if (!isPromptConfigRecovered(recoveredPromptConfig, expectedPromptConfig)) {
-        log(`[compaction-context-injector] Re-injected agent config but recovery is still incomplete`, {
-          sessionID,
-          reason,
-          agent: expectedPromptConfig.agent,
-          model,
-          hasTools: !!tools,
-          recoveredPromptConfig,
-        })
-        return false
-      }
-
-      updateSessionAgent(sessionID, expectedPromptConfig.agent)
-      if (model) {
-        setSessionModel(sessionID, model)
-      }
-      if (tools) {
-        setSessionTools(sessionID, tools)
-      }
-
-      tailState.lastRecoveryAt = now
-      tailState.consecutiveNoTextMessages = 0
-
-      log(`[compaction-context-injector] Re-injected checkpointed agent config`, {
-        sessionID,
-        reason,
-        agent: expectedPromptConfig.agent,
-        model,
-      })
-
-      return true
-    } catch (error) {
-      log(`[compaction-context-injector] Failed to re-inject checkpointed agent config`, {
-        sessionID,
-        reason,
-        error: String(error),
-      })
-      return false
-    }
-  }
-
-  const maybeWarnAboutNoTextTail = async (sessionID: string): Promise<void> => {
-    const tailState = getTailState(sessionID)
-    if (tailState.consecutiveNoTextMessages < NO_TEXT_TAIL_THRESHOLD) {
-      return
-    }
-
-    const recentlyCompacted =
-      tailState.lastCompactedAt !== undefined &&
-      Date.now() - tailState.lastCompactedAt < RECENT_COMPACTION_WINDOW_MS
-
-    log(`[compaction-context-injector] Detected consecutive assistant messages with no text`, {
-      sessionID,
-      consecutiveNoTextMessages: tailState.consecutiveNoTextMessages,
-      recentlyCompacted,
-    })
-
-    if (recentlyCompacted) {
-      await recoverCheckpointedAgentConfig(sessionID, "no-text-tail")
-    }
-  }
-
-  return {
-    recoverCheckpointedAgentConfig,
-    maybeWarnAboutNoTextTail,
-  }
-}

package/src/hooks/compaction-context-injector/session-id.ts

@@ -1,8 +0,0 @@
-export function isCompactionAgent(agent: string | undefined): boolean {
-  return agent?.trim().toLowerCase() === "compaction"
-}
-
-export function resolveSessionID(props?: Record<string, unknown>): string | undefined {
-  return (props?.sessionID ??
-    (props?.info as { id?: string } | undefined)?.id) as string | undefined
-}

package/src/hooks/compaction-context-injector/session-prompt-config-resolver.ts

@@ -1,120 +0,0 @@
-import { getSessionAgent } from "../../features/claude-code-session-state"
-import type { CompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint"
-import { log } from "../../shared/logger"
-import { normalizeSDKResponse } from "../../shared/normalize-sdk-response"
-import { normalizePromptTools } from "../../shared/prompt-tools"
-import { getSessionModel } from "../../shared/session-model-state"
-import { getSessionTools } from "../../shared/session-tools-store"
-import { isCompactionAgent } from "./session-id"
-import { resolveValidatedModel } from "./validated-model"
-
-type SessionMessage = {
-  info?: {
-    agent?: string
-    model?: {
-      providerID?: string
-      modelID?: string
-    }
-    providerID?: string
-    modelID?: string
-    tools?: Record<string, boolean | "allow" | "deny" | "ask">
-  }
-}
-
-type ResolverContext = {
-  client: {
-    session: {
-      messages: (input: { path: { id: string } }) => Promise<unknown>
-    }
-  }
-  directory: string
-}
-
-export async function resolveSessionPromptConfig(
-  ctx: ResolverContext,
-  sessionID: string,
-): Promise<CompactionAgentConfigCheckpoint> {
-  const storedModel = getSessionModel(sessionID)
-  const promptConfig: CompactionAgentConfigCheckpoint = {
-    agent: getSessionAgent(sessionID),
-    tools: getSessionTools(sessionID),
-  }
-
-  try {
-    const response = await ctx.client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SessionMessage[], {
-      preferResponseOnMissingData: true,
-    })
-
-    for (let index = messages.length - 1; index >= 0; index--) {
-      const info = messages[index].info
-
-      if (!promptConfig.agent && info?.agent && !isCompactionAgent(info.agent)) {
-        promptConfig.agent = info.agent
-      }
-
-      if (!promptConfig.model) {
-        const model = resolveValidatedModel(info)
-        if (model) {
-          promptConfig.model = model
-        }
-      }
-
-      if (!promptConfig.tools) {
-        const tools = normalizePromptTools(info?.tools)
-        if (tools) {
-          promptConfig.tools = tools
-        }
-      }
-
-      if (promptConfig.agent && promptConfig.model && promptConfig.tools) {
-        break
-      }
-    }
-  } catch (error) {
-    log("[compaction-context-injector] Failed to resolve prompt config from messages", {
-      sessionID,
-      directory: ctx.directory,
-      error: String(error),
-    })
-  }
-
-  if (!promptConfig.model && storedModel) {
-    promptConfig.model = storedModel
-  }
-
-  return promptConfig
-}
-
-export async function resolveLatestSessionPromptConfig(
-  ctx: ResolverContext,
-  sessionID: string,
-): Promise<CompactionAgentConfigCheckpoint> {
-  try {
-    const response = await ctx.client.session.messages({ path: { id: sessionID } })
-    const messages = normalizeSDKResponse(response, [] as SessionMessage[], {
-      preferResponseOnMissingData: true,
-    })
-    const latestInfo = messages.at(-1)?.info
-
-    if (!latestInfo) {
-      return {}
-    }
-
-    const model = resolveValidatedModel(latestInfo)
-    const tools = normalizePromptTools(latestInfo.tools)
-
-    return {
-      ...(latestInfo.agent ? { agent: latestInfo.agent } : {}),
-      ...(model ? { model } : {}),
-      ...(tools ? { tools } : {}),
-    }
-  } catch (error) {
-    log("[compaction-context-injector] Failed to resolve latest prompt config", {
-      sessionID,
-      directory: ctx.directory,
-      error: String(error),
-    })
-    return {}
-  }
-}

package/src/hooks/compaction-context-injector/tail-monitor.ts

@@ -1,52 +0,0 @@
-const MEANINGFUL_ASSISTANT_PART_TYPES = new Set([
-  "reasoning",
-  "tool",
-  "tool_use",
-])
-
-export type TailMonitorState = {
-  currentMessageID?: string
-  currentHasOutput: boolean
-  consecutiveNoTextMessages: number
-  lastCompactedAt?: number
-  lastRecoveryAt?: number
-}
-
-export function finalizeTrackedAssistantMessage(
-  state: TailMonitorState,
-): number {
-  if (!state.currentMessageID) {
-    return state.consecutiveNoTextMessages
-  }
-
-  state.consecutiveNoTextMessages = state.currentHasOutput
-    ? 0
-    : state.consecutiveNoTextMessages + 1
-  state.currentMessageID = undefined
-  state.currentHasOutput = false
-
-  return state.consecutiveNoTextMessages
-}
-
-export function shouldTreatAssistantPartAsOutput(part: {
-  type?: string
-  text?: string
-}): boolean {
-  if (part.type === "text") {
-    return !!part.text?.trim()
-  }
-
-  return typeof part.type === "string" && MEANINGFUL_ASSISTANT_PART_TYPES.has(part.type)
-}
-
-export function trackAssistantOutput(
-  state: TailMonitorState,
-  messageID?: string,
-): void {
-  if (messageID && !state.currentMessageID) {
-    state.currentMessageID = messageID
-  }
-
-  state.currentHasOutput = true
-  state.consecutiveNoTextMessages = 0
-}

package/src/hooks/compaction-context-injector/types.ts

@@ -1,25 +0,0 @@
-export interface CompactionContextInjector {
-  capture: (sessionID: string) => Promise<void>
-  inject: (sessionID?: string) => string
-  event: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
-}
-
-export type CompactionContextClient = {
-  client: {
-    session: {
-      messages: (input: { path: { id: string } }) => Promise<unknown>
-      promptAsync: (input: {
-        path: { id: string }
-        body: {
-          noReply?: boolean
-          agent?: string
-          model?: { providerID: string; modelID: string }
-          tools?: Record<string, boolean>
-          parts: Array<{ type: "text"; text: string }>
-        }
-        query?: { directory: string }
-      }) => Promise<unknown>
-    }
-  }
-  directory: string
-}

package/src/hooks/compaction-context-injector/validated-model.ts

@@ -1,47 +0,0 @@
-import type { CompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint"
-import { isCompactionAgent } from "./session-id"
-
-type PromptConfigInfo = {
-  agent?: string
-  model?: {
-    providerID?: string
-    modelID?: string
-  }
-  providerID?: string
-  modelID?: string
-}
-
-export function resolveValidatedModel(
-  info: PromptConfigInfo | undefined,
-): CompactionAgentConfigCheckpoint["model"] | undefined {
-  if (isCompactionAgent(info?.agent)) {
-    return undefined
-  }
-
-  const providerID = info?.model?.providerID ?? info?.providerID
-  const modelID = info?.model?.modelID ?? info?.modelID
-
-  if (!providerID || !modelID) {
-    return undefined
-  }
-
-  return { providerID, modelID }
-}
-
-export function validateCheckpointModel(
-  checkpointModel: CompactionAgentConfigCheckpoint["model"],
-  currentModel: CompactionAgentConfigCheckpoint["model"],
-): CompactionAgentConfigCheckpoint["model"] | undefined {
-  if (!checkpointModel) {
-    return undefined
-  }
-
-  if (!currentModel) {
-    return checkpointModel
-  }
-
-  return checkpointModel.providerID === currentModel.providerID &&
-    checkpointModel.modelID === currentModel.modelID
-    ? checkpointModel
-    : undefined
-}

package/src/hooks/compaction-todo-preserver/hook.ts

@@ -1,127 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-
-interface TodoSnapshot {
-  id: string
-  content: string
-  status: "pending" | "in_progress" | "completed" | "cancelled"
-  priority?: "low" | "medium" | "high"
-}
-
-type TodoWriter = (input: { sessionID: string; todos: TodoSnapshot[] }) => Promise<void>
-
-const HOOK_NAME = "compaction-todo-preserver"
-
-function extractTodos(response: unknown): TodoSnapshot[] {
-  const payload = response as { data?: unknown }
-  if (Array.isArray(payload?.data)) {
-    return payload.data as TodoSnapshot[]
-  }
-  if (Array.isArray(response)) {
-    return response as TodoSnapshot[]
-  }
-  return []
-}
-
-async function resolveTodoWriter(): Promise<TodoWriter | null> {
-  try {
-    const loader = "opencode/session/todo"
-    const mod = (await import(loader)) as {
-      Todo?: { update?: TodoWriter }
-    }
-    const update = mod.Todo?.update
-    if (typeof update === "function") {
-      return update
-    }
-  } catch (err) {
-    log(`[${HOOK_NAME}] Failed to resolve Todo.update`, { error: String(err) })
-  }
-  return null
-}
-
-function resolveSessionID(props?: Record<string, unknown>): string | undefined {
-  return (props?.sessionID ??
-    (props?.info as { id?: string } | undefined)?.id) as string | undefined
-}
-
-export interface CompactionTodoPreserver {
-  capture: (sessionID: string) => Promise<void>
-  event: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
-}
-
-export function createCompactionTodoPreserverHook(
-  ctx: PluginInput,
-): CompactionTodoPreserver {
-  const snapshots = new Map<string, TodoSnapshot[]>()
-
-  const capture = async (sessionID: string): Promise<void> => {
-    if (!sessionID) return
-    try {
-      const response = await ctx.client.session.todo({ path: { id: sessionID } })
-      const todos = extractTodos(response)
-      if (todos.length === 0) return
-      snapshots.set(sessionID, todos)
-      log(`[${HOOK_NAME}] Captured todo snapshot`, { sessionID, count: todos.length })
-    } catch (err) {
-      log(`[${HOOK_NAME}] Failed to capture todos`, { sessionID, error: String(err) })
-    }
-  }
-
-  const restore = async (sessionID: string): Promise<void> => {
-    const snapshot = snapshots.get(sessionID)
-    if (!snapshot || snapshot.length === 0) return
-
-    let hasCurrent = false
-    let currentTodos: TodoSnapshot[] = []
-    try {
-      const response = await ctx.client.session.todo({ path: { id: sessionID } })
-      currentTodos = extractTodos(response)
-      hasCurrent = true
-    } catch (err) {
-      log(`[${HOOK_NAME}] Failed to fetch todos post-compaction`, { sessionID, error: String(err) })
-    }
-
-    if (hasCurrent && currentTodos.length > 0) {
-      snapshots.delete(sessionID)
-      log(`[${HOOK_NAME}] Skipped restore (todos already present)`, { sessionID, count: currentTodos.length })
-      return
-    }
-
-    const writer = await resolveTodoWriter()
-    if (!writer) {
-      log(`[${HOOK_NAME}] Skipped restore (Todo.update unavailable)`, { sessionID })
-      return
-    }
-
-    try {
-      await writer({ sessionID, todos: snapshot })
-      log(`[${HOOK_NAME}] Restored todos after compaction`, { sessionID, count: snapshot.length })
-    } catch (err) {
-      log(`[${HOOK_NAME}] Failed to restore todos`, { sessionID, error: String(err) })
-    } finally {
-      snapshots.delete(sessionID)
-    }
-  }
-
-  const event = async ({ event }: { event: { type: string; properties?: unknown } }): Promise<void> => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionID = resolveSessionID(props)
-      if (sessionID) {
-        snapshots.delete(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = resolveSessionID(props)
-      if (sessionID) {
-        await restore(sessionID)
-      }
-      return
-    }
-  }
-
-  return { capture, event }
-}

package/src/hooks/compaction-todo-preserver/index.ts

@@ -1,2 +0,0 @@
-export type { CompactionTodoPreserver } from "./hook"
-export { createCompactionTodoPreserverHook } from "./hook"

package/src/hooks/context-window-monitor.ts

@@ -1,113 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import {
-  resolveActualContextLimit,
-  type ContextLimitModelCacheState,
-} from "../shared/context-limit-resolver"
-import { createSystemDirective, SystemDirectiveTypes } from "../shared/system-directive"
-
-const CONTEXT_WARNING_THRESHOLD = 0.70
-
-function createContextReminder(actualLimit: number): string {
-  const limitTokens = actualLimit.toLocaleString()
-
-  return `${createSystemDirective(SystemDirectiveTypes.CONTEXT_WINDOW_MONITOR)}
-
-You are using a ${limitTokens}-token context window.
-You still have context remaining - do NOT rush or skip tasks.
-Complete your work thoroughly and methodically.`
-}
-
-interface TokenInfo {
-  input: number
-  output: number
-  reasoning: number
-  cache: { read: number; write: number }
-}
-
-interface CachedTokenState {
-  providerID: string
-  modelID: string
-  tokens: TokenInfo
-}
-
-export function createContextWindowMonitorHook(
-  _ctx: PluginInput,
-  modelCacheState?: ContextLimitModelCacheState,
-) {
-  const remindedSessions = new Set<string>()
-  const tokenCache = new Map<string, CachedTokenState>()
-
-  const toolExecuteAfter = async (
-    input: { tool: string; sessionID: string; callID: string },
-    output: { title: string; output: string; metadata: unknown }
-  ) => {
-    const { sessionID } = input
-
-    if (remindedSessions.has(sessionID)) return
-
-    const cached = tokenCache.get(sessionID)
-    if (!cached) return
-
-    const actualLimit = resolveActualContextLimit(
-      cached.providerID,
-      cached.modelID,
-      modelCacheState,
-    )
-
-    if (!actualLimit) return
-
-    const lastTokens = cached.tokens
-    const totalInputTokens = (lastTokens?.input ?? 0) + (lastTokens?.cache?.read ?? 0)
-
-    const actualUsagePercentage = totalInputTokens / actualLimit
-
-    if (actualUsagePercentage < CONTEXT_WARNING_THRESHOLD) return
-
-    remindedSessions.add(sessionID)
-
-    const usedPct = (actualUsagePercentage * 100).toFixed(1)
-    const remainingPct = ((1 - actualUsagePercentage) * 100).toFixed(1)
-    const usedTokens = totalInputTokens.toLocaleString()
-    const limitTokens = actualLimit.toLocaleString()
-
-    output.output += `\n\n${createContextReminder(actualLimit)}
-[Context Status: ${usedPct}% used (${usedTokens}/${limitTokens} tokens), ${remainingPct}% remaining]`
-  }
-
-  const eventHandler = async ({ event }: { event: { type: string; properties?: unknown } }) => {
-    const props = event.properties as Record<string, unknown> | undefined
-
-    if (event.type === "session.deleted") {
-      const sessionInfo = props?.info as { id?: string } | undefined
-      if (sessionInfo?.id) {
-        remindedSessions.delete(sessionInfo.id)
-        tokenCache.delete(sessionInfo.id)
-      }
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as {
-        role?: string
-        sessionID?: string
-        providerID?: string
-        modelID?: string
-        finish?: boolean
-        tokens?: TokenInfo
-      } | undefined
-
-      if (!info || info.role !== "assistant" || !info.finish) return
-      if (!info.sessionID || !info.providerID || !info.tokens) return
-
-      tokenCache.set(info.sessionID, {
-        providerID: info.providerID,
-        modelID: info.modelID ?? "",
-        tokens: info.tokens,
-      })
-    }
-  }
-
-  return {
-    "tool.execute.after": toolExecuteAfter,
-    event: eventHandler,
-  }
-}