@hiai-gg/hiai-opencode 0.1.7 → 0.1.8

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,
-  })
-}

package/src/hooks/ralph-loop/logician-verification-detector.ts

@@ -1,88 +0,0 @@
-import { stripInvisibleAgentCharacters } from "../../shared/agent-display-names"
-import { ULTRAWORK_VERIFICATION_PROMISE } from "./constants"
-
-const VERIFICATION_GATE_AGENT_KEYS = new Set(["critic"])
-
-export interface CriticVerificationEvidence {
-	agent: string
-	promise: string
-	sessionID?: string
-}
-
-const AGENT_LINE_PATTERN = /^Agent:[ \t]*(\S+)$/im
-const PROMISE_TAG_PATTERN = /<promise>[ \t]*(\S+?)[ \t]*<\/promise>/is
-const TASK_METADATA_PATTERN = /<task_metadata>[ \t]*([\s\S]*?)[ \t]*<\/task_metadata>/is
-const SESSION_ID_LINE_PATTERN = /^session_id:[ \t]*(\S+)$/im
-
-function normalizeVerificationGateAgentKey(agentName: string): string {
-	return stripInvisibleAgentCharacters(agentName).trim().toLowerCase()
-}
-
-function isVerificationGateAgent(agentName: string): boolean {
-	return VERIFICATION_GATE_AGENT_KEYS.has(normalizeVerificationGateAgentKey(agentName))
-}
-
-export function parseCriticVerificationEvidence(text: string): CriticVerificationEvidence | undefined {
-	const trimmedText = text.trim()
-	if (!trimmedText) {
-		return undefined
-	}
-
-	const agentMatch = trimmedText.match(AGENT_LINE_PATTERN)
-	if (!agentMatch) {
-		return undefined
-	}
-	const agent = agentMatch[1]?.trim()
-	if (!agent) {
-		return undefined
-	}
-
-	const promiseMatch = trimmedText.match(PROMISE_TAG_PATTERN)
-	if (!promiseMatch) {
-		return undefined
-	}
-	const promise = promiseMatch[1]?.trim()
-	if (!promise) {
-		return undefined
-	}
-
-	const metadataMatch = trimmedText.match(TASK_METADATA_PATTERN)
-	let sessionID: string | undefined
-	if (metadataMatch) {
-		const metadataContent = metadataMatch[1]
-		const sessionIDMatch = metadataContent.match(SESSION_ID_LINE_PATTERN)
-		if (sessionIDMatch) {
-			sessionID = sessionIDMatch[1]?.trim()
-		}
-	}
-
-	return { agent, promise, sessionID }
-}
-
-export type LogicianVerificationEvidence = CriticVerificationEvidence
-
-export const parseLogicianVerificationEvidence = parseCriticVerificationEvidence
-
-export function isCriticVerified(text: string): boolean {
-	const evidence = parseCriticVerificationEvidence(text)
-	if (!evidence) {
-		return false
-	}
-
-	const isVerifiedPromise = evidence.promise === ULTRAWORK_VERIFICATION_PROMISE
-
-	return isVerificationGateAgent(evidence.agent) && isVerifiedPromise
-}
-
-export const isLogicianVerified = isCriticVerified
-
-export function extractCriticSessionID(text: string): string | undefined {
-	const evidence = parseCriticVerificationEvidence(text)
-	if (!evidence || !isVerificationGateAgent(evidence.agent)) {
-		return undefined
-	}
-
-	return evidence.sessionID
-}
-
-export const extractLogicianSessionID = extractCriticSessionID

package/src/hooks/ralph-loop/loop-session-recovery.ts

@@ -1,33 +0,0 @@
-type SessionState = {
-	isRecovering?: boolean
-}
-
-export function createLoopSessionRecovery(options?: { recoveryWindowMs?: number }) {
-	const recoveryWindowMs = options?.recoveryWindowMs ?? 5000
-	const sessions = new Map<string, SessionState>()
-
-	function getSessionState(sessionID: string): SessionState {
-		let state = sessions.get(sessionID)
-		if (!state) {
-			state = {}
-			sessions.set(sessionID, state)
-		}
-		return state
-	}
-
-	return {
-		isRecovering(sessionID: string): boolean {
-			return getSessionState(sessionID).isRecovering === true
-		},
-		markRecovering(sessionID: string): void {
-			const state = getSessionState(sessionID)
-			state.isRecovering = true
-			setTimeout(() => {
-				state.isRecovering = false
-			}, recoveryWindowMs)
-		},
-		clear(sessionID: string): void {
-			sessions.delete(sessionID)
-		},
-	}
-}