@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/comment-checker/hook.ts

@@ -1,192 +0,0 @@
-import type { PendingCall } from "./types"
-import type { CommentCheckerConfig } from "../../config/schema"
-
-import z from "zod"
-
-const ApplyPatchMetadataSchema = z.object({
-  files: z.array(
-    z.object({
-      filePath: z.string(),
-      movePath: z.string().optional(),
-      before: z.string(),
-      after: z.string(),
-      type: z.string().optional(),
-    }),
-  ),
-})
-
-import {
-  initializeCommentCheckerCli,
-  getCommentCheckerCliPathPromise,
-  isCliPathUsable,
-  processWithCli,
-  processApplyPatchEditsWithCli,
-} from "./cli-runner"
-import {
-  registerPendingCall,
-  startPendingCallCleanup,
-  stopPendingCallCleanup,
-  takePendingCall,
-} from "./pending-calls"
-
-import * as fs from "fs"
-import { tmpdir } from "os"
-import { join } from "path"
-
-const DEBUG = process.env.COMMENT_CHECKER_DEBUG === "1"
-const DEBUG_FILE = join(tmpdir(), "comment-checker-debug.log")
-
-function debugLog(...args: unknown[]) {
-  if (DEBUG) {
-    const msg = `[${new Date().toISOString()}] [comment-checker:hook] ${args
-      .map((a) => (typeof a === "object" ? JSON.stringify(a, null, 2) : String(a)))
-      .join(" ")}\n`
-    fs.appendFileSync(DEBUG_FILE, msg)
-  }
-}
-
-export function createCommentCheckerHooks(config?: CommentCheckerConfig) {
-  debugLog("createCommentCheckerHooks called", { config })
-
-  startPendingCallCleanup()
-  initializeCommentCheckerCli(debugLog)
-
-  return {
-    "tool.execute.before": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { args: Record<string, unknown> },
-    ): Promise<void> => {
-      debugLog("tool.execute.before:", {
-        tool: input.tool,
-        callID: input.callID,
-        args: output.args,
-      })
-
-      const toolLower = input.tool.toLowerCase()
-      if (toolLower !== "write" && toolLower !== "edit" && toolLower !== "multiedit") {
-        debugLog("skipping non-write/edit tool:", toolLower)
-        return
-      }
-
-      const filePath = (output.args.filePath ??
-        output.args.file_path ??
-        output.args.path) as string | undefined
-      const content = output.args.content as string | undefined
-      const oldString = (output.args.oldString ?? output.args.old_string) as string | undefined
-      const newString = (output.args.newString ?? output.args.new_string) as string | undefined
-      const edits = output.args.edits as Array<{ old_string: string; new_string: string }> | undefined
-
-      debugLog("extracted filePath:", filePath)
-
-      if (!filePath) {
-        debugLog("no filePath found")
-        return
-      }
-
-      debugLog("registering pendingCall:", {
-        callID: input.callID,
-        filePath,
-        tool: toolLower,
-      })
-      registerPendingCall(input.callID, {
-        filePath,
-        content,
-        oldString: oldString as string | undefined,
-        newString: newString as string | undefined,
-        edits,
-        tool: toolLower as PendingCall["tool"],
-        sessionID: input.sessionID,
-        timestamp: Date.now(),
-      })
-    },
-
-    "tool.execute.after": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { title: string; output: string; metadata: unknown },
-    ): Promise<void> => {
-      debugLog("tool.execute.after:", { tool: input.tool, callID: input.callID })
-
-      const toolLower = input.tool.toLowerCase()
-
-      // Only skip if the output indicates a tool execution failure
-      const outputLower = (output.output ?? "").toLowerCase()
-      const isToolFailure =
-        outputLower.includes("error:") ||
-        outputLower.includes("failed to") ||
-        outputLower.includes("could not") ||
-        outputLower.startsWith("error")
-
-      if (isToolFailure) {
-        debugLog("skipping due to tool failure in output")
-        return
-      }
-
-
-      if (toolLower === "apply_patch") {
-        const parsed = ApplyPatchMetadataSchema.safeParse(output.metadata)
-        if (!parsed.success) {
-          debugLog("apply_patch metadata schema mismatch, skipping")
-          return
-        }
-
-        const edits = parsed.data.files
-          .filter((f) => f.type !== "delete")
-          .map((f) => ({
-            filePath: f.movePath ?? f.filePath,
-            before: f.before,
-            after: f.after,
-          }))
-
-        if (edits.length === 0) {
-          debugLog("apply_patch had no editable files, skipping")
-          return
-        }
-
-        try {
-          const cliPath = await getCommentCheckerCliPathPromise()
-          if (!isCliPathUsable(cliPath)) {
-            debugLog("CLI not available, skipping comment check")
-            return
-          }
-
-          debugLog("using CLI for apply_patch:", cliPath)
-          await processApplyPatchEditsWithCli(
-            input.sessionID,
-            edits,
-            output,
-            cliPath,
-            config?.custom_prompt,
-            debugLog,
-          )
-        } catch (err) {
-          debugLog("apply_patch comment check failed:", err)
-        }
-        return
-      }
-
-      const pendingCall = takePendingCall(input.callID)
-      if (!pendingCall) {
-        debugLog("no pendingCall found for:", input.callID)
-        return
-      }
-
-      debugLog("processing pendingCall:", pendingCall)
-
-      try {
-        const cliPath = await getCommentCheckerCliPathPromise()
-        if (!isCliPathUsable(cliPath)) {
-          debugLog("CLI not available, skipping comment check")
-          return
-        }
-
-        debugLog("using CLI:", cliPath)
-        await processWithCli(input, pendingCall, output, cliPath, config?.custom_prompt, debugLog)
-      } catch (err) {
-        debugLog("tool.execute.after failed:", err)
-      }
-    },
-    dispose: (): void => {
-      stopPendingCallCleanup()
-    },
-  }
-}

package/src/hooks/comment-checker/index.ts

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

package/src/hooks/comment-checker/pending-calls.ts

@@ -1,45 +0,0 @@
-import type { PendingCall } from "./types"
-
-const pendingCalls = new Map<string, PendingCall>()
-const PENDING_CALL_TTL = 60_000
-
-let cleanupIntervalStarted = false
-let cleanupInterval: ReturnType<typeof setInterval> | undefined
-
-function cleanupOldPendingCalls(): void {
-  const now = Date.now()
-  for (const [callID, call] of pendingCalls) {
-    if (now - call.timestamp > PENDING_CALL_TTL) {
-      pendingCalls.delete(callID)
-    }
-  }
-}
-
-export function startPendingCallCleanup(): void {
-  if (cleanupIntervalStarted) return
-  cleanupIntervalStarted = true
-  cleanupInterval = setInterval(cleanupOldPendingCalls, 10_000)
-  if (typeof cleanupInterval === "object" && "unref" in cleanupInterval) {
-    cleanupInterval.unref()
-  }
-}
-
-export function stopPendingCallCleanup(): void {
-  pendingCalls.clear()
-  if (cleanupInterval) {
-    clearInterval(cleanupInterval)
-    cleanupInterval = undefined
-  }
-  cleanupIntervalStarted = false
-}
-
-export function registerPendingCall(callID: string, pendingCall: PendingCall): void {
-  pendingCalls.set(callID, pendingCall)
-}
-
-export function takePendingCall(callID: string): PendingCall | undefined {
-  const pendingCall = pendingCalls.get(callID)
-  if (!pendingCall) return undefined
-  pendingCalls.delete(callID)
-  return pendingCall
-}

package/src/hooks/comment-checker/types.ts

@@ -1,33 +0,0 @@
-export type CommentType = "line" | "block" | "docstring"
-
-export interface CommentInfo {
-  text: string
-  lineNumber: number
-  filePath: string
-  commentType: CommentType
-  isDocstring: boolean
-  metadata?: Record<string, string>
-}
-
-export interface PendingCall {
-  filePath: string
-  content?: string
-  oldString?: string
-  newString?: string
-  edits?: Array<{ old_string: string; new_string: string }>
-  tool: "write" | "edit" | "multiedit"
-  sessionID: string
-  timestamp: number
-}
-
-export interface FileComments {
-  filePath: string
-  comments: CommentInfo[]
-}
-
-export interface FilterResult {
-  shouldSkip: boolean
-  reason?: string
-}
-
-export type CommentFilter = (comment: CommentInfo) => FilterResult

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

@@ -1,56 +0,0 @@
-import {
-  createSystemDirective,
-  SystemDirectiveTypes,
-} from "../../shared/system-directive"
-
-export const COMPACTION_CONTEXT_PROMPT = `${createSystemDirective(SystemDirectiveTypes.COMPACTION_CONTEXT)}
-
-When summarizing this session, you MUST include the following sections in your summary:
-
-## 1. User Requests (As-Is)
-- List all original user requests exactly as they were stated
-- Preserve the user's exact wording and intent
-
-## 2. Final Goal
-- What the user ultimately wanted to achieve
-- The end result or deliverable expected
-
-## 3. Work Completed
-- What has been done so far
-- Files created/modified
-- Features implemented
-- Problems solved
-
-## 4. Remaining Tasks
-- What still needs to be done
-- Pending items from the original request
-- Follow-up tasks identified during the work
-
-## 5. Active Working Context (For Seamless Continuation)
-- **Files**: Paths of files currently being edited or frequently referenced
-- **Code in Progress**: Key code snippets, function signatures, or data structures under active development
-- **External References**: Documentation URLs, library APIs, or external resources being consulted
-- **State & Variables**: Important variable names, configuration values, or runtime state relevant to ongoing work
-
-## 6. Explicit Constraints (Verbatim Only)
-- Include ONLY constraints explicitly stated by the user or in existing AGENTS.md context
-- Quote constraints verbatim (do not paraphrase)
-- Do NOT invent, add, or modify constraints
-- If no explicit constraints exist, write "None"
-
-## 7. Agent Verification State (Critical for Reviewers)
-- **Current Agent**: What agent is running (critic, strategist, researcher, etc.)
-- **Verification Progress**: Files already verified/validated
-- **Pending Verifications**: Files still needing verification
-- **Previous Rejections**: If reviewer agent, what was rejected and why
-- **Acceptance Status**: Current state of review process
-
-This section is CRITICAL for reviewer agents (critic, strategist) to maintain continuity.
-
-## 8. Delegated Agent Sessions
-- List ALL background agent tasks spawned during this session
-- For each: agent name, category, status, description, and **session_id**
-- **RESUME, DON'T RESTART.** Each listed session retains full context. After compaction, use \`session_id\` to continue existing agent sessions instead of spawning new ones. This saves tokens, preserves learned context, and prevents duplicate work.
-
-This context is critical for maintaining continuity after compaction.
-`

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

@@ -1,5 +0,0 @@
-export const HOOK_NAME = "compaction-context-injector"
-export const AGENT_RECOVERY_PROMPT = "[restore checkpointed session agent configuration after compaction]"
-export const NO_TEXT_TAIL_THRESHOLD = 5
-export const RECOVERY_COOLDOWN_MS = 60_000
-export const RECENT_COMPACTION_WINDOW_MS = 10 * 60 * 1000

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

@@ -1,164 +0,0 @@
-import type { BackgroundManager } from "../../features/background-agent"
-import {
-  clearCompactionAgentConfigCheckpoint,
-  setCompactionAgentConfigCheckpoint,
-} from "../../shared/compaction-agent-config-checkpoint"
-import { log } from "../../shared/logger"
-import { COMPACTION_CONTEXT_PROMPT } from "./compaction-context-prompt"
-import { resolveSessionPromptConfig } from "./session-prompt-config-resolver"
-import { finalizeTrackedAssistantMessage, shouldTreatAssistantPartAsOutput, trackAssistantOutput, type TailMonitorState } from "./tail-monitor"
-import { resolveSessionID } from "./session-id"
-import type { CompactionContextClient, CompactionContextInjector } from "./types"
-import { createRecoveryLogic } from "./recovery"
-
-export function createCompactionContextInjector(options?: {
-  ctx?: CompactionContextClient
-  backgroundManager?: BackgroundManager
-}): CompactionContextInjector {
-  const ctx = options?.ctx
-  const backgroundManager = options?.backgroundManager
-  const tailStates = new Map<string, TailMonitorState>()
-
-  const getTailState = (sessionID: string): TailMonitorState => {
-    const existing = tailStates.get(sessionID)
-    if (existing) {
-      return existing
-    }
-
-    const created: TailMonitorState = {
-      currentHasOutput: false,
-      consecutiveNoTextMessages: 0,
-    }
-    tailStates.set(sessionID, created)
-    return created
-  }
-
-  const { recoverCheckpointedAgentConfig, maybeWarnAboutNoTextTail } = createRecoveryLogic(ctx, getTailState)
-
-  const capture = async (sessionID: string): Promise<void> => {
-    if (!ctx || !sessionID) {
-      return
-    }
-
-    const promptConfig = await resolveSessionPromptConfig(ctx, sessionID)
-    if (!promptConfig.agent && !promptConfig.model && !promptConfig.tools) {
-      return
-    }
-
-    setCompactionAgentConfigCheckpoint(sessionID, promptConfig)
-    log(`[compaction-context-injector] Captured agent checkpoint before compaction`, {
-      sessionID,
-      agent: promptConfig.agent,
-      model: promptConfig.model,
-      hasTools: !!promptConfig.tools,
-    })
-  }
-
-  const inject = (sessionID?: string): string => {
-    let prompt = COMPACTION_CONTEXT_PROMPT
-
-    if (backgroundManager && sessionID) {
-      const history = backgroundManager.taskHistory.formatForCompaction(sessionID)
-      if (history) {
-        prompt += `\n### Active/Recent Delegated Sessions\n${history}\n`
-      }
-    }
-
-    return prompt
-  }
-
-  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) {
-        clearCompactionAgentConfigCheckpoint(sessionID)
-        tailStates.delete(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "session.idle") {
-      const sessionID = resolveSessionID(props)
-      if (!sessionID) {
-        return
-      }
-
-      const noTextCount = finalizeTrackedAssistantMessage(getTailState(sessionID))
-      if (noTextCount > 0) {
-        await maybeWarnAboutNoTextTail(sessionID)
-      }
-      return
-    }
-
-    if (event.type === "session.compacted") {
-      const sessionID = resolveSessionID(props)
-      if (!sessionID) {
-        return
-      }
-
-      const tailState = getTailState(sessionID)
-      finalizeTrackedAssistantMessage(tailState)
-      tailState.lastCompactedAt = Date.now()
-      await maybeWarnAboutNoTextTail(sessionID)
-      await recoverCheckpointedAgentConfig(sessionID, "session.compacted")
-      return
-    }
-
-    if (event.type === "message.updated") {
-      const info = props?.info as {
-        id?: string
-        role?: string
-        sessionID?: string
-      } | undefined
-
-      if (!info?.sessionID || info.role !== "assistant" || !info.id) {
-        return
-      }
-
-      const tailState = getTailState(info.sessionID)
-      if (tailState.currentMessageID && tailState.currentMessageID !== info.id) {
-        finalizeTrackedAssistantMessage(tailState)
-        await maybeWarnAboutNoTextTail(info.sessionID)
-      }
-
-      if (tailState.currentMessageID !== info.id) {
-        tailState.currentMessageID = info.id
-        tailState.currentHasOutput = false
-      }
-      return
-    }
-
-    if (event.type === "message.part.delta") {
-      const sessionID = props?.sessionID as string | undefined
-      const messageID = props?.messageID as string | undefined
-      const field = props?.field as string | undefined
-      const delta = props?.delta as string | undefined
-
-      if (!sessionID || field !== "text" || !delta?.trim()) {
-        return
-      }
-
-      trackAssistantOutput(getTailState(sessionID), messageID)
-      return
-    }
-
-    if (event.type === "message.part.updated") {
-      const part = props?.part as {
-        messageID?: string
-        sessionID?: string
-        type?: string
-        text?: string
-      } | undefined
-
-      if (!part?.sessionID || !shouldTreatAssistantPartAsOutput(part)) {
-        return
-      }
-
-      trackAssistantOutput(getTailState(part.sessionID), part.messageID)
-    }
-  }
-
-  return { capture, inject, event }
-}

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

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

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

@@ -1,77 +0,0 @@
-import { stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
-import type { CompactionAgentConfigCheckpoint } from "../../shared/compaction-agent-config-checkpoint"
-
-export type RecoveryPromptConfig = CompactionAgentConfigCheckpoint & {
-  agent: string
-}
-
-function isCompactionAgent(agent: string | undefined): boolean {
-  return agent?.trim().toLowerCase() === "compaction"
-}
-
-function matchesExpectedModel(
-  actualModel: CompactionAgentConfigCheckpoint["model"],
-  expectedModel: CompactionAgentConfigCheckpoint["model"],
-): boolean {
-  if (!expectedModel) {
-    return true
-  }
-
-  return (
-    actualModel?.providerID === expectedModel.providerID &&
-    actualModel.modelID === expectedModel.modelID
-  )
-}
-
-function matchesExpectedTools(
-  actualTools: CompactionAgentConfigCheckpoint["tools"],
-  expectedTools: CompactionAgentConfigCheckpoint["tools"],
-): boolean {
-  if (!expectedTools) {
-    return true
-  }
-
-  if (!actualTools) {
-    return false
-  }
-
-  const expectedEntries = Object.entries(expectedTools)
-  if (expectedEntries.length !== Object.keys(actualTools).length) {
-    return false
-  }
-
-  return expectedEntries.every(
-    ([toolName, isAllowed]) => actualTools[toolName] === isAllowed,
-  )
-}
-
-export function createExpectedRecoveryPromptConfig(
-  checkpoint: Pick<RecoveryPromptConfig, "agent"> & CompactionAgentConfigCheckpoint,
-  currentPromptConfig: CompactionAgentConfigCheckpoint,
-): RecoveryPromptConfig {
-  const model = checkpoint.model ?? currentPromptConfig.model
-  const tools = checkpoint.tools ?? currentPromptConfig.tools
-
-  return {
-    agent: checkpoint.agent,
-    ...(model ? { model } : {}),
-    ...(tools ? { tools } : {}),
-  }
-}
-
-export function isPromptConfigRecovered(
-  actualPromptConfig: CompactionAgentConfigCheckpoint,
-  expectedPromptConfig: RecoveryPromptConfig,
-): boolean {
-  const actualAgent = actualPromptConfig.agent
-  const agentMatches =
-    typeof actualAgent === "string" &&
-    !isCompactionAgent(actualAgent) &&
-    stripInvisibleAgentCharacters(actualAgent).toLowerCase() === stripInvisibleAgentCharacters(expectedPromptConfig.agent).toLowerCase()
-
-  return (
-    agentMatches &&
-    matchesExpectedModel(actualPromptConfig.model, expectedPromptConfig.model) &&
-    matchesExpectedTools(actualPromptConfig.tools, expectedPromptConfig.tools)
-  )
-}