@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

package/src/hooks/guard/types.ts

@@ -1,45 +0,0 @@
-import type { AgentOverrides } from "../../config"
-import type { BackgroundManager } from "../../features/background-agent"
-import type { TopLevelTaskRef } from "../../features/boulder-state"
-
-export type ModelInfo = { providerID: string; modelID: string; variant?: string }
-
-export interface GuardHookOptions {
-  directory: string
-  backgroundManager?: BackgroundManager
-  isContinuationStopped?: (sessionID: string) => boolean
-  agentOverrides?: AgentOverrides
-  /** Enable auto-commit after each atomic task completion (default: true) */
-  autoCommit?: boolean
-}
-
-export interface ToolExecuteAfterInput {
-  tool: string
-  sessionID?: string
-  callID?: string
-}
-
-export interface ToolExecuteAfterOutput {
-  title: string
-  output: string
-  metadata: Record<string, unknown>
-}
-
-export type TrackedTopLevelTaskRef = Pick<TopLevelTaskRef, "key" | "label" | "title">
-
-export type PendingTaskRef =
-  | { kind: "track"; task: TrackedTopLevelTaskRef }
-  | { kind: "skip"; reason: "explicit_resume" }
-  | { kind: "skip"; reason: "ambiguous_task_key"; task: TrackedTopLevelTaskRef }
-
-export interface SessionState {
-  lastEventWasAbortError?: boolean
-  lastContinuationInjectedAt?: number
-  isInjectingContinuation?: boolean
-  promptFailureCount: number
-  lastFailureAt?: number
-  pendingRetryTimer?: ReturnType<typeof setTimeout>
-  waitingForFinalWaveApproval?: boolean
-  pendingFinalWaveTaskCount?: number
-  approvedFinalWaveTaskCount?: number
-}

package/src/hooks/guard/verification-reminders.ts

@@ -1,197 +0,0 @@
-import { VERIFICATION_REMINDER } from "./system-reminder-templates"
-
-function buildReuseHint(sessionId: string): string {
-  return `
-**PREFERRED REUSE SESSION FOR THE CURRENT TOP-LEVEL PLAN TASK**
-
-- Reuse \`${sessionId}\` first if verification fails or the result needs follow-up.
-- Start a fresh subagent session only when reuse is unavailable or would cross task boundaries.
-`
-}
-
-export function buildCompletionGate(planName: string, sessionId: string): string {
-  return `
-**COMPLETION GATE - DO NOT PROCEED UNTIL THIS IS DONE**
-
-Your completion will NOT be recorded until you complete ALL of the following:
-
-1. **Edit** the plan file \`.bob/plans/${planName}.md\`:
-   - Change \`- [ ]\` to \`- [x]\` for the completed task
-   - Use \`Edit\` tool to modify the checkbox
-
-2. **Read** the plan file AGAIN:
-   \`\`\`
-   Read(".bob/plans/${planName}.md")
-   \`\`\`
-   - Verify the checkbox count changed (more \`- [x]\` than before)
-
-3. **DO NOT call \`task()\` again** until you have completed steps 1 and 2 above.
-
-If anything fails while closing this out, resume the same session immediately:
-\`\`\`typescript
-task(session_id="${sessionId}", load_skills=[], prompt="fix: checkbox not recorded correctly")
-\`\`\`
-
-**Your completion is NOT tracked until the checkbox is marked in the plan file.**
-
-**VERIFICATION_REMINDER**
-${buildReuseHint(sessionId)}`
-}
-
-function buildVerificationReminder(sessionId: string): string {
-  return `**VERIFICATION_REMINDER**
-
-${VERIFICATION_REMINDER}
-
----
-
-**If ANY verification fails, use this immediately:**
-\`\`\`
-task(session_id="${sessionId}", load_skills=[], prompt="fix: [describe the specific failure]")
-\`\`\`
-
-${buildReuseHint(sessionId)}`
-}
-
-export function buildOrchestratorReminder(
-  planName: string,
-  progress: { total: number; completed: number },
-  sessionId: string,
-  autoCommit: boolean = true,
-  includeCompletionGate: boolean = true
-): string {
-  const remaining = progress.total - progress.completed
-
-  const commitStep = autoCommit
-    ? `
-**STEP 7: COMMIT ATOMIC UNIT**
-
-- Stage ONLY the verified changes
-- Commit with clear message describing what was done
-`
-    : ""
-
-  const nextStepNumber = autoCommit ? 8 : 7
-
-  return `
----
-
-**BOULDER STATE:** Plan: \`${planName}\` | ${progress.completed}/${progress.total} done | ${remaining} remaining
-
----
-
-${includeCompletionGate ? `${buildCompletionGate(planName, sessionId)}
-
-` : ""}${buildVerificationReminder(sessionId)}
-
-**STEP 5: READ SUBAGENT NOTEPAD (LEARNINGS, ISSUES, PROBLEMS)**
-
-The subagent was instructed to record findings in notepad files. Read them NOW:
-\`\`\`
-Glob(".bob/notepads/${planName}/*.md")
-\`\`\`
-Then \`Read\` each file found - especially:
-- **learnings.md**: Patterns, conventions, successful approaches discovered
-- **issues.md**: Problems, blockers, gotchas encountered during work
-- **problems.md**: Unresolved issues, technical debt flagged
-
-**USE this information to:**
-- Inform your next delegation (avoid known pitfalls)
-- Adjust your plan if blockers were discovered
-- Propagate learnings to subsequent subagents
-
-**STEP 6: CHECK BOULDER STATE DIRECTLY (EVERY TIME - NO EXCEPTIONS)**
-
-Do NOT rely on cached progress. Read the plan file NOW:
-\`\`\`
-Read(".bob/plans/${planName}.md")
-\`\`\`
-Count exactly: how many \`- [ ]\` remain? How many \`- [x]\` completed?
-This is YOUR ground truth. Use it to decide what comes next.
-
-${commitStep}
-**STEP ${nextStepNumber}: PROCEED TO NEXT TASK**
-
-- Read the plan file AGAIN to identify the next \`- [ ]\` task
-- Start immediately - DO NOT STOP
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-**${remaining} tasks remain. Keep bouldering.**`
-}
-
-export function buildFinalWaveApprovalReminder(
-  planName: string,
-  progress: { total: number; completed: number },
-  sessionId: string
-): string {
-  const remaining = progress.total - progress.completed
-
-  return `
----
-
-**BOULDER STATE:** Plan: \
-\`${planName}\` | ${progress.completed}/${progress.total} done | ${remaining} remaining
-
----
-
-${buildVerificationReminder(sessionId)}
-
-**FINAL WAVE APPROVAL GATE**
-
-The last Final Verification Wave result just passed.
-This is the ONLY point where approval-style user interaction is required.
-
-1. Read \
-\`.bob/plans/${planName}.md\` again and confirm every remaining unchecked **top-level** task belongs to F1-F4.
-   Ignore nested checkboxes under Acceptance Criteria, Evidence, or Final Checklist sections.
-2. Consolidate the F1-F4 verdicts into a short summary for the user.
-3. Tell the user all final reviewers approved.
-4. Ask for explicit user approval before editing any remaining final-wave checkboxes or marking the plan complete.
-5. Wait for the user's explicit approval. Do NOT auto-continue. Do NOT call \
-\`task()\` again unless the user rejects and requests fixes.
-
-If the user rejects or requests changes:
-- delegate the required fix
-- re-run the affected final-wave reviewer
-- present the updated results again
-- wait again for explicit user approval
-
-**DO NOT mark the final-wave checkbox complete until the user explicitly says okay.**`
-}
-
-export function buildStandaloneVerificationReminder(sessionId: string): string {
-  return `
----
-
-${buildVerificationReminder(sessionId)}
-
-**STEP 5: CHECK YOUR PROGRESS DIRECTLY (EVERY TIME - NO EXCEPTIONS)**
-
-Do NOT rely on memory or cached state. Run \`todoread\` NOW to see exact current state.
-Count pending vs completed tasks. This is your ground truth for what comes next.
-
-**STEP 6: UPDATE TODO STATUS (IMMEDIATELY)**
-
-RIGHT NOW - Do not delay. Verification passed → Mark IMMEDIATELY.
-
-1. Run \`todoread\` to see your todo list
-2. Mark the completed task as \`completed\` using \`todowrite\`
-
-**DO THIS BEFORE ANYTHING ELSE. Unmarked = Untracked = Lost progress.**
-
-**STEP 7: EXECUTE QA TASKS (IF ANY)**
-
-If QA tasks exist in your todo list:
-- Execute them BEFORE proceeding
-- Mark each QA task complete after successful verification
-
-**STEP 8: PROCEED TO NEXT PENDING TASK**
-
-- Run \`todoread\` AGAIN to identify the next \`pending\` task
-- Start immediately - DO NOT STOP
-
-━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
-
-**NO TODO = NO TRACKING = INCOMPLETE WORK. Use todowrite aggressively.**`
-}

package/src/hooks/guard/write-edit-tool-policy.ts

@@ -1,5 +0,0 @@
-const WRITE_EDIT_TOOLS = ["Write", "Edit", "write", "edit"]
-
-export function isWriteOrEditToolName(toolName: string): boolean {
-  return WRITE_EDIT_TOOLS.includes(toolName)
-}

package/src/hooks/hashline-edit-diff-enhancer/hook.ts

@@ -1,106 +0,0 @@
-import { log } from "../../shared"
-import { generateUnifiedDiff, countLineDiffs } from "../../tools/hashline-edit/diff-utils"
-
-interface HashlineEditDiffEnhancerConfig {
-	hashline_edit?: { enabled: boolean }
-}
-
-type BeforeInput = { tool: string; sessionID: string; callID: string }
-type BeforeOutput = { args: Record<string, unknown> }
-type AfterInput = { tool: string; sessionID: string; callID: string }
-type AfterOutput = { title: string; output: string; metadata: Record<string, unknown> }
-
-const STALE_TIMEOUT_MS = 5 * 60 * 1000
-
-const pendingCaptures = new Map<string, { content: string; filePath: string; storedAt: number }>()
-
-function makeKey(sessionID: string, callID: string): string {
-	return `${sessionID}:${callID}`
-}
-
-function cleanupStaleEntries(): void {
-	const now = Date.now()
-	for (const [key, entry] of pendingCaptures) {
-		if (now - entry.storedAt > STALE_TIMEOUT_MS) {
-			pendingCaptures.delete(key)
-		}
-	}
-}
-
-function isWriteTool(toolName: string): boolean {
-	return toolName.toLowerCase() === "write"
-}
-
-function extractFilePath(args: Record<string, unknown>): string | undefined {
-	const path = args.path ?? args.filePath ?? args.file_path
-	return typeof path === "string" ? path : undefined
-}
-
-async function captureOldContent(filePath: string): Promise<string> {
-	try {
-		const file = Bun.file(filePath)
-		if (await file.exists()) {
-			return await file.text()
-		}
-	} catch {
-		log("[hashline-edit-diff-enhancer] failed to read old content", { filePath })
-	}
-	return ""
-}
-
-export function createHashlineEditDiffEnhancerHook(config: HashlineEditDiffEnhancerConfig) {
-	const enabled = config.hashline_edit?.enabled ?? false
-
-	return {
-		"tool.execute.before": async (input: BeforeInput, output: BeforeOutput) => {
-			if (!enabled || !isWriteTool(input.tool)) return
-
-			const filePath = extractFilePath(output.args)
-			if (!filePath) return
-
-			cleanupStaleEntries()
-			const oldContent = await captureOldContent(filePath)
-			pendingCaptures.set(makeKey(input.sessionID, input.callID), {
-				content: oldContent,
-				filePath,
-				storedAt: Date.now(),
-			})
-		},
-
-		"tool.execute.after": async (input: AfterInput, output: AfterOutput) => {
-			if (!enabled || !isWriteTool(input.tool)) return
-
-			const key = makeKey(input.sessionID, input.callID)
-			const captured = pendingCaptures.get(key)
-			if (!captured) return
-			pendingCaptures.delete(key)
-
-			const { content: oldContent, filePath } = captured
-
-			let newContent: string
-			try {
-				newContent = await Bun.file(filePath).text()
-			} catch {
-				log("[hashline-edit-diff-enhancer] failed to read new content", { filePath })
-				return
-			}
-
-			const { additions, deletions } = countLineDiffs(oldContent, newContent)
-			const unifiedDiff = generateUnifiedDiff(oldContent, newContent, filePath)
-			
-			output.metadata.filediff = {
-				file: filePath,
-				path: filePath,
-				before: oldContent,
-				after: newContent,
-				additions,
-				deletions,
-			}
-			
-			// TUI reads metadata.diff (unified diff string), not filediff object
-			output.metadata.diff = unifiedDiff
-
-			output.title = filePath
-		},
-	}
-}

package/src/hooks/hashline-read-enhancer/hook.ts

@@ -1,193 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { computeLineHash } from "../../tools/hashline-edit/hash-computation"
-
-const WRITE_SUCCESS_MARKER = "File written successfully."
-
-interface HashlineReadEnhancerConfig {
-  hashline_edit?: { enabled: boolean }
-}
-
-const COLON_READ_LINE_PATTERN = /^\s*(\d+): ?(.*)$/
-const PIPE_READ_LINE_PATTERN = /^\s*(\d+)\| ?(.*)$/
-const CONTENT_OPEN_TAG = "<content>"
-const CONTENT_CLOSE_TAG = "</content>"
-const FILE_OPEN_TAG = "<file>"
-const FILE_CLOSE_TAG = "</file>"
-const OPENCODE_LINE_TRUNCATION_SUFFIX = "... (line truncated to 2000 chars)"
-
-function isReadTool(toolName: string): boolean {
-  return toolName.toLowerCase() === "read"
-}
-
-function isWriteTool(toolName: string): boolean {
-  return toolName.toLowerCase() === "write"
-}
-
-function shouldProcess(config: HashlineReadEnhancerConfig): boolean {
-  return config.hashline_edit?.enabled ?? false
-}
-
-function isTextFile(output: string): boolean {
-  const firstLine = output.split("\n")[0] ?? ""
-  return COLON_READ_LINE_PATTERN.test(firstLine) || PIPE_READ_LINE_PATTERN.test(firstLine)
-}
-
-function parseReadLine(line: string): { lineNumber: number; content: string } | null {
-  const colonMatch = COLON_READ_LINE_PATTERN.exec(line)
-  if (colonMatch) {
-    return {
-      lineNumber: Number.parseInt(colonMatch[1], 10),
-      content: colonMatch[2],
-    }
-  }
-
-  const pipeMatch = PIPE_READ_LINE_PATTERN.exec(line)
-  if (pipeMatch) {
-    return {
-      lineNumber: Number.parseInt(pipeMatch[1], 10),
-      content: pipeMatch[2],
-    }
-  }
-
-  return null
-}
-
-function transformLine(line: string): string {
-  const parsed = parseReadLine(line)
-  if (!parsed) {
-    return line
-  }
-  if (parsed.content.endsWith(OPENCODE_LINE_TRUNCATION_SUFFIX)) {
-    return line
-  }
-  const hash = computeLineHash(parsed.lineNumber, parsed.content)
-  return `${parsed.lineNumber}#${hash}|${parsed.content}`
-}
-
-function transformOutput(output: string): string {
-  if (!output) {
-    return output
-  }
-
-  const lines = output.split("\n")
-  const contentStart = lines.findIndex(
-    (line) => line === CONTENT_OPEN_TAG || line.startsWith(CONTENT_OPEN_TAG)
-  )
-  const contentEnd = lines.indexOf(CONTENT_CLOSE_TAG)
-  const fileStart = lines.findIndex((line) => line === FILE_OPEN_TAG || line.startsWith(FILE_OPEN_TAG))
-  const fileEnd = lines.indexOf(FILE_CLOSE_TAG)
-
-  const blockStart = contentStart !== -1 ? contentStart : fileStart
-  const blockEnd = contentStart !== -1 ? contentEnd : fileEnd
-  const openTag = contentStart !== -1 ? CONTENT_OPEN_TAG : FILE_OPEN_TAG
-
-  if (blockStart !== -1 && blockEnd !== -1 && blockEnd > blockStart) {
-    const openLine = lines[blockStart] ?? ""
-    const inlineFirst = openLine.startsWith(openTag) && openLine !== openTag
-      ? openLine.slice(openTag.length)
-      : null
-    const fileLines = inlineFirst !== null
-      ? [inlineFirst, ...lines.slice(blockStart + 1, blockEnd)]
-      : lines.slice(blockStart + 1, blockEnd)
-    if (!isTextFile(fileLines[0] ?? "")) {
-      return output
-    }
-
-    const result: string[] = []
-    for (const line of fileLines) {
-      if (!parseReadLine(line)) {
-        result.push(...fileLines.slice(result.length))
-        break
-      }
-      result.push(transformLine(line))
-    }
-
-    const prefixLines = inlineFirst !== null
-      ? [...lines.slice(0, blockStart), openTag]
-      : lines.slice(0, blockStart + 1)
-
-    return [...prefixLines, ...result, ...lines.slice(blockEnd)].join("\n")
-  }
-
-  if (!isTextFile(lines[0] ?? "")) {
-    return output
-  }
-
-  const result: string[] = []
-  for (const line of lines) {
-    if (!parseReadLine(line)) {
-      result.push(...lines.slice(result.length))
-      break
-    }
-    result.push(transformLine(line))
-  }
-
-  return result.join("\n")
-}
-
-function extractFilePath(metadata: unknown): string | undefined {
-  if (!metadata || typeof metadata !== "object") {
-    return undefined
-  }
-
-  const objectMeta = metadata as Record<string, unknown>
-  const candidates = [objectMeta.filepath, objectMeta.filePath, objectMeta.path, objectMeta.file]
-  for (const candidate of candidates) {
-    if (typeof candidate === "string" && candidate.length > 0) {
-      return candidate
-    }
-  }
-
-  return undefined
-}
-
-async function appendWriteHashlineOutput(output: { output: string; metadata: unknown }): Promise<void> {
-  if (output.output.startsWith(WRITE_SUCCESS_MARKER)) {
-    return
-  }
-
-  const outputLower = output.output.toLowerCase()
-  if (outputLower.startsWith("error") || outputLower.includes("failed")) {
-    return
-  }
-
-  const filePath = extractFilePath(output.metadata)
-  if (!filePath) {
-    return
-  }
-
-  const file = Bun.file(filePath)
-  if (!(await file.exists())) {
-    return
-  }
-
-  const content = await file.text()
-  const lineCount = content === "" ? 0 : content.split("\n").length
-  output.output = `${WRITE_SUCCESS_MARKER} ${lineCount} lines written.`
-}
-
-export function createHashlineReadEnhancerHook(
-  _ctx: PluginInput,
-  config: HashlineReadEnhancerConfig
-) {
-  return {
-    "tool.execute.after": async (
-      input: { tool: string; sessionID: string; callID: string },
-      output: { title: string; output: string; metadata: unknown }
-    ) => {
-      if (!isReadTool(input.tool)) {
-        if (isWriteTool(input.tool) && typeof output.output === "string" && shouldProcess(config)) {
-          await appendWriteHashlineOutput(output)
-        }
-        return
-      }
-      if (typeof output.output !== "string") {
-        return
-      }
-      if (!shouldProcess(config)) {
-        return
-      }
-      output.output = transformOutput(output.output)
-    },
-  }
-}

package/src/hooks/hashline-read-enhancer/index.ts

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

package/src/hooks/index.ts

@@ -1,56 +0,0 @@
-export { createTodoContinuationEnforcer, type TodoContinuationEnforcer } from "./todo-continuation-enforcer";
-export { createContextWindowMonitorHook } from "./context-window-monitor";
-export { createSessionNotification } from "./session-notification";
-export { sendSessionNotification, playSessionNotificationSound, detectPlatform, getDefaultSoundPath } from "./session-notification-sender";
-export { buildWindowsToastScript, escapeAppleScriptText, escapePowerShellSingleQuotedText } from "./session-notification-formatting";
-export { hasIncompleteTodos } from "./session-todo-status";
-export { createIdleNotificationScheduler } from "./session-notification-scheduler";
-export { createSessionRecoveryHook, type SessionRecoveryHook, type SessionRecoveryOptions } from "./session-recovery";
-export { createCommentCheckerHooks } from "./comment-checker";
-export { createToolOutputTruncatorHook } from "./tool-output-truncator";
-export { createDirectoryAgentsInjectorHook } from "./directory-agents-injector";
-export { createDirectoryReadmeInjectorHook } from "./directory-readme-injector";
-export { createEmptyTaskResponseDetectorHook } from "./empty-task-response-detector";
-export { createAnthropicContextWindowLimitRecoveryHook, type AnthropicContextWindowLimitRecoveryOptions } from "./anthropic-context-window-limit-recovery";
-
-export { createThinkModeHook } from "./think-mode";
-export { createModelFallbackHook, setPendingModelFallback, clearPendingModelFallback, type ModelFallbackState } from "./model-fallback/hook";
-export { createClaudeCodeHooksHook } from "./claude-code-hooks";
-export { createRulesInjectorHook } from "./rules-injector";
-export { createBackgroundNotificationHook } from "./background-notification"
-
-export { createAgentUsageReminderHook } from "./agent-usage-reminder";
-export { createKeywordDetectorHook } from "./keyword-detector";
-export { createNonInteractiveEnvHook } from "./non-interactive-env";
-export { createInteractiveBashSessionHook } from "./interactive-bash-session";
-
-export { createThinkingBlockValidatorHook } from "./thinking-block-validator";
-export { createToolPairValidatorHook } from "./tool-pair-validator";
-export { createCategorySkillReminderHook } from "./category-skill-reminder";
-export { createRalphLoopHook, type RalphLoopHook } from "./ralph-loop";
-export { createAutoSlashCommandHook } from "./auto-slash-command";
-export { createEditErrorRecoveryHook } from "./edit-error-recovery";
-
-export { createStrategistMdOnlyHook } from "./strategist-md-only";
-export { createBobJuniorNotepadHook } from "./sub-notepad";
-export { createTaskResumeInfoHook } from "./task-resume-info";
-export { createStartWorkHook } from "./start-work";
-export { createGuardHook } from "./guard";
-export { createDelegateTaskRetryHook } from "./delegate-task-retry";
-export { createQuestionLabelTruncatorHook } from "./question-label-truncator";
-export { createStopContinuationGuardHook, type StopContinuationGuard } from "./stop-continuation-guard";
-export { createCompactionContextInjector } from "./compaction-context-injector";
-export { createCompactionTodoPreserverHook } from "./compaction-todo-preserver";
-export { createUnstableAgentBabysitterHook } from "./unstable-agent-babysitter";
-export { createPreemptiveCompactionHook } from "./preemptive-compaction";
-export { createTasksTodowriteDisablerHook } from "./tasks-todowrite-disabler";
-export { createRuntimeFallbackHook, type RuntimeFallbackHook, type RuntimeFallbackOptions } from "./runtime-fallback";
-export { createWriteExistingFileGuardHook } from "./write-existing-file-guard";
-export { createBashFileReadGuardHook } from "./bash-file-read-guard";
-export { createHashlineReadEnhancerHook } from "./hashline-read-enhancer";
-export { createJsonErrorRecoveryHook, JSON_ERROR_TOOL_EXCLUDE_LIST, JSON_ERROR_PATTERNS, JSON_ERROR_REMINDER } from "./json-error-recovery";
-export { createReadImageResizerHook } from "./read-image-resizer"
-export { createTodoDescriptionOverrideHook } from "./todo-description-override"
-export { createWebFetchRedirectGuardHook } from "./webfetch-redirect-guard"
-export { createLegacyPluginToastHook } from "./legacy-plugin-toast"
-export { createFastApplyHook } from "./fast-apply"

package/src/hooks/interactive-bash-session/constants.ts

@@ -1,13 +0,0 @@
-import { join } from "node:path";
-import { OPENCODE_STORAGE } from "../../shared";
-export const INTERACTIVE_BASH_SESSION_STORAGE = join(
-  OPENCODE_STORAGE,
-  "interactive-bash-session",
-);
-
-export const OMO_SESSION_PREFIX = "omo-";
-
-export function buildSessionReminderMessage(sessions: string[]): string {
-  if (sessions.length === 0) return "";
-  return `\n\n[System Reminder] Active omo-* tmux sessions: ${sessions.join(", ")}`;
-}