@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

package/src/hooks/question-label-truncator/hook.ts

@@ -1,62 +0,0 @@
-const MAX_LABEL_LENGTH = 30;
-
-interface QuestionOption {
-  label: string;
-  description?: string;
-}
-
-interface Question {
-  question: string;
-  header?: string;
-  options: QuestionOption[];
-  multiSelect?: boolean;
-}
-
-interface AskUserQuestionArgs {
-  questions: Question[];
-}
-
-function truncateLabel(label: string, maxLength: number = MAX_LABEL_LENGTH): string {
-  if (label.length <= maxLength) {
-    return label;
-  }
-  return label.substring(0, maxLength - 3) + "...";
-}
-
-function truncateQuestionLabels(args: AskUserQuestionArgs): AskUserQuestionArgs {
-  if (!args.questions || !Array.isArray(args.questions)) {
-    return args;
-  }
-
-  return {
-    ...args,
-    questions: args.questions.map((question) => ({
-      ...question,
-      options:
-        question.options?.map((option) => ({
-          ...option,
-          label: truncateLabel(option.label),
-        })) ?? [],
-    })),
-  };
-}
-
-export function createQuestionLabelTruncatorHook() {
-  return {
-    "tool.execute.before": async (
-      input: { tool: string },
-      output: { args: Record<string, unknown> }
-    ): Promise<void> => {
-      const toolName = input.tool?.toLowerCase();
-
-      if (toolName === "askuserquestion" || toolName === "ask_user_question") {
-        const args = output.args as unknown as AskUserQuestionArgs | undefined;
-
-        if (args?.questions) {
-          const truncatedArgs = truncateQuestionLabels(args);
-          Object.assign(output.args, truncatedArgs);
-        }
-      }
-    },
-  };
-}

package/src/hooks/question-label-truncator/index.ts

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

package/src/hooks/ralph-loop/AGENTS.md

@@ -1,62 +0,0 @@
-# src/hooks/ralph-loop/ — Self-Referential Dev Loop
-
-**Generated:** 2026-04-11
-
-## OVERVIEW
-
-14 files (~1687 LOC). The `ralphLoop` Session Tier hook — powers the `/ralph-loop` command. Iterates a development loop until the agent emits `<promise>DONE</promise>` or max iterations reached.
-
-## LOOP LIFECYCLE
-
-```
-/ralph-loop → startLoop(sessionID, prompt, options)
-  → loopState.startLoop() → persists state to .bob/ralph-loop.local.md
-  → session.idle events → createRalphLoopEventHandler()
-    → completionPromiseDetector: scan output for <promise>DONE</promise>
-    → if not done: inject continuation prompt → loop
-    → if done or maxIterations: cancelLoop()
-```
-
-## KEY FILES
-
-| File | Purpose |
-|------|---------|
-| `ralph-loop-hook.ts` | `createRalphLoopHook()` — composes controller + recovery + event handler |
-| `ralph-loop-event-handler.ts` | `createRalphLoopEventHandler()` — handles session.idle, drives loop |
-| `loop-state-controller.ts` | State CRUD: startLoop, cancelLoop, getState, persist to disk |
-| `loop-session-recovery.ts` | Recover from crashed/interrupted loop sessions |
-| `completion-promise-detector.ts` | Scan session transcript for `<promise>DONE</promise>` |
-| `continuation-prompt-builder.ts` | Build continuation message for next iteration |
-| `continuation-prompt-injector.ts` | Inject built prompt into active session |
-| `storage.ts` | Read/write `.bob/ralph-loop.local.md` state file |
-| `message-storage-directory.ts` | Temp dir for prompt injection |
-| `with-timeout.ts` | API call wrapper with timeout (default 5000ms) |
-| `types.ts` | `RalphLoopState`, `RalphLoopOptions`, loop iteration types |
-
-## STATE FILE
-
-```
-.bob/ralph-loop.local.md  (gitignored)
-  → sessionID, prompt, iteration count, maxIterations, completionPromise, ultrawork flag
-```
-
-## OPTIONS
-
-```typescript
-startLoop(sessionID, prompt, {
-  maxIterations?: number  // Default from config (default: 100)
-  completionPromise?: string  // Custom "done" signal (default: "<promise>DONE</promise>")
-  ultrawork?: boolean  // Enable ultrawork mode for iterations
-})
-```
-
-## EXPORTED INTERFACE
-
-```typescript
-interface RalphLoopHook {
-  event: (input) => Promise<void>  // session.idle handler
-  startLoop: (sessionID, prompt, options?) => boolean
-  cancelLoop: (sessionID) => boolean
-  getState: () => RalphLoopState | null
-}
-```

package/src/hooks/ralph-loop/command-arguments.ts

@@ -1,30 +0,0 @@
-export type RalphLoopStrategy = "reset" | "continue"
-
-export type ParsedRalphLoopArguments = {
-  prompt: string
-  maxIterations?: number
-  completionPromise?: string
-  strategy?: RalphLoopStrategy
-}
-
-const DEFAULT_PROMPT = "Complete the task as instructed"
-
-export function parseRalphLoopArguments(rawArguments: string): ParsedRalphLoopArguments {
-  const taskMatch = rawArguments.match(/^(["'])(.+?)\1/)
-  const promptCandidate = taskMatch?.[2] ?? (rawArguments.startsWith("--") ? "" : rawArguments.split(/\s+--/)[0]?.trim() ?? "")
-  const prompt = promptCandidate || DEFAULT_PROMPT
-
-  const maxIterationMatch = rawArguments.match(/--max-iterations=(\d+)/i)
-  const completionPromiseQuoted = rawArguments.match(/--completion-promise=(["'])(.+?)\1/i)
-  const completionPromiseUnquoted = rawArguments.match(/--completion-promise=([^\s"']+)/i)
-  const completionPromise = completionPromiseQuoted?.[2] ?? completionPromiseUnquoted?.[1]
-  const strategyMatch = rawArguments.match(/--strategy=(reset|continue)/i)
-  const strategyValue = strategyMatch?.[1]?.toLowerCase()
-
-  return {
-    prompt,
-    maxIterations: maxIterationMatch ? Number.parseInt(maxIterationMatch[1], 10) : undefined,
-    completionPromise,
-    strategy: strategyValue === "reset" || strategyValue === "continue" ? strategyValue : undefined,
-  }
-}

package/src/hooks/ralph-loop/completion-handler.ts

@@ -1,65 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import { buildContinuationPrompt } from "./continuation-prompt-builder"
-import { HOOK_NAME } from "./constants"
-import { injectContinuationPrompt } from "./continuation-prompt-injector"
-import type { RalphLoopState } from "./types"
-
-type LoopStateController = {
-	clear: () => boolean
-	markVerificationPending: (sessionID: string) => RalphLoopState | null
-}
-
-export async function handleDetectedCompletion(
-	ctx: PluginInput,
-	input: {
-		sessionID: string
-		state: RalphLoopState
-		loopState: LoopStateController
-		directory: string
-		apiTimeoutMs: number
-	},
-): Promise<void> {
-	const { sessionID, state, loopState, directory, apiTimeoutMs } = input
-
-	if (state.ultrawork && !state.verification_pending) {
-		if (state.verification_session_id) {
-			ctx.client.session.abort({ path: { id: state.verification_session_id } }).catch(() => {})
-		}
-
-		const verificationState = loopState.markVerificationPending(sessionID)
-		if (!verificationState) {
-			log(`[${HOOK_NAME}] Failed to transition ultrawork loop to verification`, {
-				sessionID,
-			})
-			return
-		}
-
-		await injectContinuationPrompt(ctx, {
-			sessionID,
-			prompt: buildContinuationPrompt(verificationState),
-			directory,
-			apiTimeoutMs,
-		})
-
-		await ctx.client.tui?.showToast?.({
-			body: {
-				title: "ULTRAWORK LOOP",
-				message: "DONE detected. Critic verification is now required.",
-				variant: "info",
-				duration: 5000,
-			},
-		}).catch(() => {})
-		return
-	}
-
-	loopState.clear()
-
-	const title = state.ultrawork ? "ULTRAWORK LOOP COMPLETE!" : "Ralph Loop Complete!"
-	const message = state.ultrawork
-		? `JUST ULW ULW! Task completed after ${state.iteration} iteration(s)`
-		: `Task completed after ${state.iteration} iteration(s)`
-	await ctx.client.tui?.showToast?.({
-		body: { title, message, variant: "success", duration: 5000 },
-	}).catch(() => {})
-}

package/src/hooks/ralph-loop/completion-promise-detector-test-input.ts

@@ -1,23 +0,0 @@
-/// <reference types="bun-types" />
-import type { PluginInput } from "@opencode-ai/plugin"
-
-export type SessionMessage = {
-	info?: { role?: string }
-	parts?: Array<{ type: string; text?: string }>
-}
-
-export function createPluginInput(messages: SessionMessage[]): PluginInput {
-	const pluginInput = {
-		client: { session: {} } as PluginInput["client"],
-		project: {} as PluginInput["project"],
-		directory: "/tmp",
-		worktree: "/tmp",
-		serverUrl: new URL("http://localhost"),
-		$: {} as PluginInput["$"],
-	} as PluginInput
-
-	pluginInput.client.session.messages =
-		(async () => ({ data: messages })) as unknown as PluginInput["client"]["session"]["messages"]
-
-	return pluginInput
-}

package/src/hooks/ralph-loop/completion-promise-detector.ts

@@ -1,165 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { existsSync, readFileSync } from "node:fs"
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./constants"
-import { ULTRAWORK_VERIFICATION_PROMISE } from "./constants"
-import { isCriticVerified } from "./logician-verification-detector"
-import { withTimeout } from "./with-timeout"
-
-interface OpenCodeSessionMessage {
-	info?: { role?: string }
-	parts?: Array<{ type: string; text?: string }>
-}
-
-interface TranscriptEntry {
-	type?: string
-	timestamp?: string
-	content?: string
-	tool_output?: { output?: string } | string
-}
-
-function extractTranscriptEntryText(entry: TranscriptEntry): string {
-	if (typeof entry.content === "string") return entry.content
-	if (typeof entry.tool_output === "string") return entry.tool_output
-	if (entry.tool_output && typeof entry.tool_output === "object" && typeof entry.tool_output.output === "string") return entry.tool_output.output
-	return ""
-}
-
-function escapeRegex(str: string): string {
-	return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")
-}
-
-function buildPromisePattern(promise: string): RegExp {
-	return new RegExp(`<promise>\\s*${escapeRegex(promise)}\\s*</promise>`, "is")
-}
-
-function shouldInspectSessionMessagePart(
-	partType: string,
-	promise: string,
-	partText: string,
-): boolean {
-	if (partType === "text") {
-		return true
-	}
-
-	if (partType !== "tool_result") {
-		return false
-	}
-
-	return promise === ULTRAWORK_VERIFICATION_PROMISE && isCriticVerified(partText)
-}
-
-function shouldInspectTranscriptEntry(
-	entry: TranscriptEntry,
-	promise: string,
-	entryText: string,
-): boolean {
-	if (entry.type === "assistant" || entry.type === "text") {
-		return true
-	}
-
-	if (entry.type !== "tool_result") {
-		return false
-	}
-
-	return promise === ULTRAWORK_VERIFICATION_PROMISE && isCriticVerified(entryText)
-}
-
-export function detectCompletionInTranscript(
-	transcriptPath: string | undefined,
-	promise: string,
-	startedAt?: string,
-): boolean {
-	if (!transcriptPath) return false
-
-	try {
-		if (!existsSync(transcriptPath)) return false
-
-		const content = readFileSync(transcriptPath, "utf-8")
-		const pattern = buildPromisePattern(promise)
-		const lines = content.split("\n").filter((line: string) => line.trim())
-
-		for (const line of lines) {
-			try {
-				const entry = JSON.parse(line) as TranscriptEntry
-				if (entry.type === "user") continue
-				if (startedAt && entry.timestamp && entry.timestamp < startedAt) continue
-				const entryText = extractTranscriptEntryText(entry)
-				if (!entryText) continue
-				if (!shouldInspectTranscriptEntry(entry, promise, entryText)) continue
-				if (pattern.test(entryText)) return true
-			} catch {
-				continue
-			}
-		}
-		return false
-	} catch {
-		return false
-	}
-}
-
-export async function detectCompletionInSessionMessages(
-	ctx: PluginInput,
-	options: {
-		sessionID: string
-		promise: string
-		apiTimeoutMs: number
-		directory: string
-		sinceMessageIndex?: number
-	},
-): Promise<boolean> {
-	try {
-		const response = await withTimeout(
-			ctx.client.session.messages({
-				path: { id: options.sessionID },
-				query: { directory: options.directory },
-			}),
-			options.apiTimeoutMs,
-		)
-
-		const messagesResponse: unknown = response
-		const responseData =
-			typeof messagesResponse === "object" && messagesResponse !== null && "data" in messagesResponse
-				? (messagesResponse as { data?: unknown }).data
-				: undefined
-
-		const messageArray: unknown[] = Array.isArray(messagesResponse)
-			? messagesResponse
-			: Array.isArray(responseData)
-				? responseData
-				: []
-
-		const scopedMessages =
-			typeof options.sinceMessageIndex === "number" && options.sinceMessageIndex >= 0 && options.sinceMessageIndex < messageArray.length
-				? messageArray.slice(options.sinceMessageIndex)
-				: messageArray
-
-		const assistantMessages = (scopedMessages as OpenCodeSessionMessage[]).filter((msg) => msg.info?.role === "assistant")
-		if (assistantMessages.length === 0) return false
-
-		const pattern = buildPromisePattern(options.promise)
-		for (let index = assistantMessages.length - 1; index >= 0; index -= 1) {
-			const assistant = assistantMessages[index]
-			if (!assistant.parts) continue
-
-			for (const part of assistant.parts) {
-				const partText = part.text ?? ""
-				if (!partText) continue
-				if (!shouldInspectSessionMessagePart(part.type, options.promise, partText)) continue
-				if (pattern.test(partText)) {
-					return true
-				}
-			}
-		}
-
-		return false
-	} catch (err) {
-		setTimeout(() => {
-			log(`[${HOOK_NAME}] Session messages check failed`, {
-				sessionID: options.sessionID,
-				error: String(err),
-			})
-		}, 0)
-		return false
-	}
-}

package/src/hooks/ralph-loop/constants.ts

@@ -1,7 +0,0 @@
-export const HOOK_NAME = "ralph-loop"
-export const DEFAULT_STATE_FILE = ".bob/ralph-loop.local.md"
-export const COMPLETION_TAG_PATTERN = /<promise>(.*?)<\/promise>/is
-export const DEFAULT_MAX_ITERATIONS = 100
-export const ULTRAWORK_MAX_ITERATIONS = 500
-export const DEFAULT_COMPLETION_PROMISE = "DONE"
-export const ULTRAWORK_VERIFICATION_PROMISE = "VERIFIED"

package/src/hooks/ralph-loop/continuation-prompt-builder.ts

@@ -1,77 +0,0 @@
-import { SYSTEM_DIRECTIVE_PREFIX } from "../../shared/system-directive"
-import type { RalphLoopState } from "./types"
-
-function getMaxIterationsLabel(state: RalphLoopState): string {
-	return typeof state.max_iterations === "number" ? String(state.max_iterations) : "unbounded"
-}
-
-const CONTINUATION_PROMPT = `${SYSTEM_DIRECTIVE_PREFIX} - RALPH LOOP {{ITERATION}}/{{MAX}}]
-
-Your previous attempt did not output the completion promise. Continue working on the task.
-
-IMPORTANT:
-- Review your progress so far
-- Continue from where you left off
-- When FULLY complete, output: <promise>{{PROMISE}}</promise>
-- Do not stop until the task is truly done
-
-Original task:
-{{PROMPT}}`
-
-const ULTRAWORK_VERIFICATION_PROMPT = `${SYSTEM_DIRECTIVE_PREFIX} - ULTRAWORK LOOP VERIFICATION {{ITERATION}}/{{MAX}}]
-
-You already emitted <promise>{{INITIAL_PROMISE}}</promise>. This does NOT finish the loop yet.
-
-REQUIRED NOW:
-- Call Critic using task(subagent_type="critic", load_skills=[], run_in_background=false, ...)
-- Ask Critic to verify whether the original task is actually complete
-- Include the original task in the Critic request
-- Explicitly tell Critic to review skeptically and critically, and to look for reasons the task may still be incomplete or wrong
-- The system will inspect the Critic session directly for the verification result
-- If Critic does not verify, continue fixing the task and do not consider it complete
-
-Original task:
-{{PROMPT}}`
-
-const ULTRAWORK_VERIFICATION_FAILED_PROMPT = `${SYSTEM_DIRECTIVE_PREFIX} - ULTRAWORK LOOP VERIFICATION FAILED {{ITERATION}}/{{MAX}}]
-
-Critic did not emit <promise>VERIFIED</promise>. Verification failed.
-
-REQUIRED NOW:
-- Verification failed. Fix the task until Critic's review is satisfied
-- Critic does not lie. Treat the verification result as ground truth
-- Do not claim completion early or argue with the failed verification
-- After fixing the remaining issues, request Critic review again using task(subagent_type="critic", load_skills=[], run_in_background=false, ...)
-- Include the original task in the Critic request and tell Critic to review skeptically and critically
-- Only when the work is ready for review again, output: <promise>{{PROMISE}}</promise>
-
-Original task:
-{{PROMPT}}`
-
-export function buildContinuationPrompt(state: RalphLoopState): string {
-	const template = state.verification_pending
-		? ULTRAWORK_VERIFICATION_PROMPT
-		: CONTINUATION_PROMPT
-	const continuationPrompt = template.replace(
-		"{{ITERATION}}",
-		String(state.iteration),
-	)
-		.replace("{{MAX}}", getMaxIterationsLabel(state))
-		.replace("{{INITIAL_PROMISE}}", state.initial_completion_promise ?? state.completion_promise)
-		.replace("{{PROMISE}}", state.completion_promise)
-		.replace("{{PROMPT}}", state.prompt)
-
-	return state.ultrawork ? `ultrawork ${continuationPrompt}` : continuationPrompt
-}
-
-export function buildVerificationFailurePrompt(state: RalphLoopState): string {
-	const continuationPrompt = ULTRAWORK_VERIFICATION_FAILED_PROMPT.replace(
-		"{{ITERATION}}",
-		String(state.iteration),
-	)
-		.replace("{{MAX}}", getMaxIterationsLabel(state))
-		.replace("{{PROMISE}}", state.completion_promise)
-		.replace("{{PROMPT}}", state.prompt)
-
-	return state.ultrawork ? `ultrawork ${continuationPrompt}` : continuationPrompt
-}

package/src/hooks/ralph-loop/continuation-prompt-injector.ts

@@ -1,91 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import { findNearestMessageWithFields } from "../../features/hook-message-injector"
-import { getMessageDir } from "./message-storage-directory"
-import { withTimeout } from "./with-timeout"
-import {
-	createInternalAgentTextPart,
-	normalizeSDKResponse,
-	resolveInheritedPromptTools,
-} from "../../shared"
-
-type MessageInfo = {
-	agent?: string
-	model?: { providerID: string; modelID: string; variant?: string }
-	modelID?: string
-	providerID?: string
-	tools?: Record<string, boolean | "allow" | "deny" | "ask">
-}
-
-export async function injectContinuationPrompt(
-	ctx: PluginInput,
-	options: {
-		sessionID: string
-		prompt: string
-		directory: string
-		apiTimeoutMs: number
-		inheritFromSessionID?: string
-	},
-): Promise<void> {
-	let agent: string | undefined
-	let model: { providerID: string; modelID: string; variant?: string } | undefined
-	let tools: Record<string, boolean | "allow" | "deny" | "ask"> | undefined
-	const sourceSessionID = options.inheritFromSessionID ?? options.sessionID
-
-	try {
-		const messagesResp = await withTimeout(
-			ctx.client.session.messages({
-				path: { id: sourceSessionID },
-			}),
-			options.apiTimeoutMs,
-		)
-		const messages = normalizeSDKResponse(messagesResp, [] as Array<{ info?: MessageInfo }>)
-		for (let i = messages.length - 1; i >= 0; i--) {
-			const info = messages[i]?.info
-			if (info?.agent || info?.model || (info?.modelID && info?.providerID)) {
-				agent = info.agent
-				model =
-					info.model ??
-					(info.providerID && info.modelID
-						? { providerID: info.providerID, modelID: info.modelID }
-						: undefined)
-				tools = info.tools
-				break
-			}
-		}
-	} catch {
-		const messageDir = getMessageDir(sourceSessionID)
-		const currentMessage = messageDir ? findNearestMessageWithFields(messageDir) : null
-		agent = currentMessage?.agent
-		model =
-			currentMessage?.model?.providerID && currentMessage?.model?.modelID
-				? {
-					providerID: currentMessage.model.providerID,
-					modelID: currentMessage.model.modelID,
-					...(currentMessage.model.variant ? { variant: currentMessage.model.variant } : {}),
-				}
-				: undefined
-		tools = currentMessage?.tools
-	}
-
-	const inheritedTools = resolveInheritedPromptTools(sourceSessionID, tools)
-
-	const launchModel = model
-		? { providerID: model.providerID, modelID: model.modelID }
-		: undefined
-	const launchVariant = model?.variant
-
-	await ctx.client.session.promptAsync({
-		path: { id: options.sessionID },
-		body: {
-			...(agent !== undefined ? { agent } : {}),
-			...(launchModel ? { model: launchModel } : {}),
-			...(launchVariant ? { variant: launchVariant } : {}),
-			...(inheritedTools ? { tools: inheritedTools } : {}),
-			parts: [createInternalAgentTextPart(options.prompt)],
-		},
-		query: { directory: options.directory },
-	})
-
-	log("[ralph-loop] continuation injected", { sessionID: options.sessionID })
-}

package/src/hooks/ralph-loop/index.ts

@@ -1,6 +0,0 @@
-export * from "./types"
-export * from "./constants"
-export { readState, writeState, clearState, incrementIteration } from "./storage"
-
-export { createRalphLoopHook } from "./ralph-loop-hook"
-export type { RalphLoopHook } from "./ralph-loop-hook"

package/src/hooks/ralph-loop/iteration-continuation.ts

@@ -1,64 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { RalphLoopState } from "./types"
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./constants"
-import { buildContinuationPrompt } from "./continuation-prompt-builder"
-import { injectContinuationPrompt } from "./continuation-prompt-injector"
-import { createIterationSession, selectSessionInTui } from "./session-reset-strategy"
-
-type ContinuationOptions = {
-  directory: string
-  apiTimeoutMs: number
-  previousSessionID: string
-  loopState: {
-    setSessionID: (sessionID: string) => RalphLoopState | null
-  }
-}
-
-export async function continueIteration(
-  ctx: PluginInput,
-  state: RalphLoopState,
-  options: ContinuationOptions,
-): Promise<void> {
-  const strategy = state.strategy ?? "continue"
-  const continuationPrompt = buildContinuationPrompt(state)
-
-  if (strategy === "reset") {
-    const newSessionID = await createIterationSession(
-      ctx,
-      options.previousSessionID,
-      options.directory,
-    )
-    if (!newSessionID) {
-      return
-    }
-
-    await injectContinuationPrompt(ctx, {
-      sessionID: newSessionID,
-      inheritFromSessionID: options.previousSessionID,
-      prompt: continuationPrompt,
-      directory: options.directory,
-      apiTimeoutMs: options.apiTimeoutMs,
-    })
-
-    await selectSessionInTui(ctx.client, newSessionID)
-
-    const boundState = options.loopState.setSessionID(newSessionID)
-    if (!boundState) {
-      log(`[${HOOK_NAME}] Failed to bind loop state to new session`, {
-        previousSessionID: options.previousSessionID,
-        newSessionID,
-      })
-      return
-    }
-
-    return
-  }
-
-  await injectContinuationPrompt(ctx, {
-    sessionID: options.previousSessionID,
-    prompt: continuationPrompt,
-    directory: options.directory,
-    apiTimeoutMs: options.apiTimeoutMs,
-  })
-}