@hiai-gg/hiai-opencode 0.1.6 → 0.1.8

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

package/src/hooks/ralph-loop/loop-state-controller.ts

@@ -1,178 +0,0 @@
-import type { RalphLoopOptions, RalphLoopState } from "./types"
-import {
-	DEFAULT_COMPLETION_PROMISE,
-	DEFAULT_MAX_ITERATIONS,
-	HOOK_NAME,
-	ULTRAWORK_MAX_ITERATIONS,
-	ULTRAWORK_VERIFICATION_PROMISE,
-} from "./constants"
-import { clearState, incrementIteration, readState, writeState } from "./storage"
-import { log } from "../../shared/logger"
-
-export function createLoopStateController(options: {
-	directory: string
-	stateDir: string | undefined
-	config: RalphLoopOptions["config"] | undefined
-}) {
-	const directory = options.directory
-	const stateDir = options.stateDir
-	const config = options.config
-
-	return {
-		startLoop(
-			sessionID: string,
-			prompt: string,
-			loopOptions?: {
-				maxIterations?: number
-				completionPromise?: string
-				messageCountAtStart?: number
-				ultrawork?: boolean
-				strategy?: "reset" | "continue"
-			},
-		): boolean {
-			const initialCompletionPromise =
-				loopOptions?.completionPromise ??
-				DEFAULT_COMPLETION_PROMISE
-			const state: RalphLoopState = {
-				active: true,
-				iteration: 1,
-				max_iterations: loopOptions?.ultrawork
-					? ULTRAWORK_MAX_ITERATIONS
-					: loopOptions?.maxIterations ??
-						config?.default_max_iterations ??
-						DEFAULT_MAX_ITERATIONS,
-				message_count_at_start: loopOptions?.messageCountAtStart,
-				completion_promise: initialCompletionPromise,
-				initial_completion_promise: initialCompletionPromise,
-				verification_attempt_id: undefined,
-				verification_session_id: undefined,
-				ultrawork: loopOptions?.ultrawork,
-				verification_pending: undefined,
-				strategy: loopOptions?.strategy ?? config?.default_strategy ?? "continue",
-				started_at: new Date().toISOString(),
-				prompt,
-				session_id: sessionID,
-			}
-
-			const success = writeState(directory, state, stateDir)
-			if (success) {
-				log(`[${HOOK_NAME}] Loop started`, {
-					sessionID,
-					maxIterations: state.max_iterations,
-					completionPromise: state.completion_promise,
-				})
-			}
-			return success
-		},
-
-		cancelLoop(sessionID: string): boolean {
-			const state = readState(directory, stateDir)
-			if (!state || state.session_id !== sessionID) {
-				return false
-			}
-
-			const success = clearState(directory, stateDir)
-			if (success) {
-				log(`[${HOOK_NAME}] Loop cancelled`, { sessionID, iteration: state.iteration })
-			}
-			return success
-		},
-
-		getState(): RalphLoopState | null {
-			return readState(directory, stateDir)
-		},
-
-		clear(): boolean {
-			return clearState(directory, stateDir)
-		},
-
-		incrementIteration(): RalphLoopState | null {
-			return incrementIteration(directory, stateDir)
-		},
-
-		setSessionID(sessionID: string): RalphLoopState | null {
-			const state = readState(directory, stateDir)
-			if (!state) {
-				return null
-			}
-
-			state.session_id = sessionID
-			if (!writeState(directory, state, stateDir)) {
-				return null
-			}
-
-			return state
-		},
-
-		setMessageCountAtStart(sessionID: string, messageCountAtStart: number): RalphLoopState | null {
-			const state = readState(directory, stateDir)
-			if (!state || state.session_id !== sessionID) {
-				return null
-			}
-
-			state.message_count_at_start = messageCountAtStart
-			if (!writeState(directory, state, stateDir)) {
-				return null
-			}
-
-			return state
-		},
-
-		markVerificationPending(sessionID: string): RalphLoopState | null {
-			const state = readState(directory, stateDir)
-			if (!state || state.session_id !== sessionID || !state.ultrawork) {
-				return null
-			}
-
-			state.verification_pending = true
-			state.completion_promise = ULTRAWORK_VERIFICATION_PROMISE
-			state.verification_attempt_id = undefined
-			state.verification_session_id = undefined
-			state.initial_completion_promise ??= DEFAULT_COMPLETION_PROMISE
-
-			if (!writeState(directory, state, stateDir)) {
-				return null
-			}
-
-			return state
-		},
-
-		setVerificationSessionID(sessionID: string, verificationSessionID: string): RalphLoopState | null {
-			const state = readState(directory, stateDir)
-			if (!state || state.session_id !== sessionID || !state.ultrawork || !state.verification_pending) {
-				return null
-			}
-
-			state.verification_session_id = verificationSessionID
-
-			if (!writeState(directory, state, stateDir)) {
-				return null
-			}
-
-			return state
-		},
-
-		restartAfterFailedVerification(sessionID: string, messageCountAtStart?: number): RalphLoopState | null {
-			const state = readState(directory, stateDir)
-			if (!state || state.session_id !== sessionID || !state.ultrawork || !state.verification_pending) {
-				return null
-			}
-
-			state.iteration += 1
-			state.started_at = new Date().toISOString()
-			state.completion_promise = state.initial_completion_promise ?? DEFAULT_COMPLETION_PROMISE
-			state.verification_pending = undefined
-			state.verification_attempt_id = undefined
-			state.verification_session_id = undefined
-			if (typeof messageCountAtStart === "number") {
-				state.message_count_at_start = messageCountAtStart
-			}
-
-			if (!writeState(directory, state, stateDir)) {
-				return null
-			}
-
-			return state
-		},
-	}
-}

package/src/hooks/ralph-loop/message-storage-directory.ts

@@ -1 +0,0 @@
-export { getMessageDir } from "../../shared/opencode-message-dir"

package/src/hooks/ralph-loop/pending-verification-handler.ts

@@ -1,152 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./constants"
-import { extractCriticSessionID, isCriticVerified } from "./logician-verification-detector"
-import type { RalphLoopState } from "./types"
-import { handleFailedVerification } from "./verification-failure-handler"
-import { withTimeout } from "./with-timeout"
-
-type OpenCodeSessionMessage = {
-	info?: { role?: string }
-	parts?: Array<{ type?: string; text?: string }>
-}
-
-function collectAssistantText(message: OpenCodeSessionMessage): string {
-	if (!Array.isArray(message.parts)) {
-		return ""
-	}
-
-	let text = ""
-	for (const part of message.parts) {
-		if (part.type !== "text" && part.type !== "tool_result") {
-			continue
-		}
-		text += `${text ? "\n" : ""}${part.text ?? ""}`
-	}
-
-	return text
-}
-
-async function detectCriticVerificationFromParentSession(
-	ctx: PluginInput,
-	parentSessionID: string,
-	directory: string,
-	apiTimeoutMs: number,
-): Promise<string | undefined> {
-	try {
-		const response = await withTimeout(
-			ctx.client.session.messages({
-				path: { id: parentSessionID },
-				query: { directory },
-			}),
-			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
-				: []
-
-		for (let index = messageArray.length - 1; index >= 0; index -= 1) {
-			const message = messageArray[index] as OpenCodeSessionMessage
-			if (message.info?.role !== "assistant") {
-				continue
-			}
-
-			const assistantText = collectAssistantText(message)
-			if (!isCriticVerified(assistantText)) {
-				continue
-			}
-
-			const detectedCriticSessionID = extractCriticSessionID(assistantText)
-			if (detectedCriticSessionID) {
-				return detectedCriticSessionID
-			}
-		}
-
-		return undefined
-	} catch (error) {
-		log(`[${HOOK_NAME}] Failed to scan parent session for critic verification evidence`, {
-			parentSessionID,
-			error: String(error),
-		})
-		return undefined
-	}
-}
-
-type LoopStateController = {
-	restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null
-	setVerificationSessionID: (sessionID: string, verificationSessionID: string) => RalphLoopState | null
-}
-
-export async function handlePendingVerification(
-	ctx: PluginInput,
-	input: {
-		sessionID: string
-		state: RalphLoopState
-		verificationSessionID?: string
-		matchesParentSession: boolean
-		matchesVerificationSession: boolean
-		loopState: LoopStateController
-		directory: string
-		apiTimeoutMs: number
-	},
-): Promise<void> {
-	const {
-		sessionID,
-		state,
-		verificationSessionID,
-		matchesParentSession,
-		matchesVerificationSession,
-		loopState,
-		directory,
-		apiTimeoutMs,
-	} = input
-
-	if (matchesParentSession || (verificationSessionID && matchesVerificationSession)) {
-		if (!verificationSessionID && state.session_id) {
-			const recoveredVerificationSessionID = await detectCriticVerificationFromParentSession(
-				ctx,
-				state.session_id,
-				directory,
-				apiTimeoutMs,
-			)
-
-			if (recoveredVerificationSessionID) {
-				const updatedState = loopState.setVerificationSessionID(
-					state.session_id,
-					recoveredVerificationSessionID,
-				)
-				if (updatedState) {
-					log(`[${HOOK_NAME}] Recovered missing verification session from parent evidence`, {
-						parentSessionID: state.session_id,
-						recoveredVerificationSessionID,
-					})
-					return
-				}
-			}
-		}
-
-		const restarted = await handleFailedVerification(ctx, {
-			state,
-			loopState,
-			directory,
-			apiTimeoutMs,
-		})
-		if (restarted) {
-			return
-		}
-	}
-
-	log(`[${HOOK_NAME}] Waiting for critic verification`, {
-		sessionID,
-		verificationSessionID,
-		iteration: state.iteration,
-	})
-}

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

@@ -1,231 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import { log } from "../../shared/logger"
-import type { RalphLoopOptions, RalphLoopState } from "./types"
-import { HOOK_NAME } from "./constants"
-import { handleDetectedCompletion } from "./completion-handler"
-import {
-	detectCompletionInSessionMessages,
-	detectCompletionInTranscript,
-} from "./completion-promise-detector"
-import { continueIteration } from "./iteration-continuation"
-import { handlePendingVerification } from "./pending-verification-handler"
-import { handleDeletedLoopSession, handleErroredLoopSession } from "./session-event-handler"
-
-type SessionRecovery = {
-	isRecovering: (sessionID: string) => boolean
-	markRecovering: (sessionID: string) => void
-	clear: (sessionID: string) => void
-}
-type LoopStateController = {
-	getState: () => RalphLoopState | null
-	clear: () => boolean
-	incrementIteration: () => RalphLoopState | null
-	setSessionID: (sessionID: string) => RalphLoopState | null
-	markVerificationPending: (sessionID: string) => RalphLoopState | null
-	setVerificationSessionID: (sessionID: string, verificationSessionID: string) => RalphLoopState | null
-	restartAfterFailedVerification: (sessionID: string, messageCountAtStart?: number) => RalphLoopState | null
-}
-type RalphLoopEventHandlerOptions = { directory: string; apiTimeoutMs: number; getTranscriptPath: (sessionID: string) => string | undefined; checkSessionExists?: RalphLoopOptions["checkSessionExists"]; sessionRecovery: SessionRecovery; loopState: LoopStateController }
-
-export function createRalphLoopEventHandler(
-	ctx: PluginInput,
-	options: RalphLoopEventHandlerOptions,
-) {
-	const inFlightSessions = new Set<string>()
-
-	return async ({ event }: { event: { type: string; properties?: unknown } }): Promise<void> => {
-		const props = event.properties as Record<string, unknown> | undefined
-
-		if (event.type === "session.idle") {
-			const sessionID = props?.sessionID as string | undefined
-			if (!sessionID) return
-
-			if (inFlightSessions.has(sessionID)) {
-				log(`[${HOOK_NAME}] Skipped: handler in flight`, { sessionID })
-				return
-			}
-
-			inFlightSessions.add(sessionID)
-
-			try {
-
-				if (options.sessionRecovery.isRecovering(sessionID)) {
-					log(`[${HOOK_NAME}] Skipped: in recovery`, { sessionID })
-					return
-				}
-
-				const state = options.loopState.getState()
-				if (!state || !state.active) {
-					return
-				}
-
-				const verificationSessionID = state.verification_pending
-					? state.verification_session_id
-					: undefined
-				const matchesParentSession = state.session_id === undefined || state.session_id === sessionID
-				const matchesVerificationSession = verificationSessionID === sessionID
-
-				if (!matchesParentSession && !matchesVerificationSession && state.session_id) {
-					if (options.checkSessionExists) {
-						try {
-							const exists = await options.checkSessionExists(state.session_id)
-							if (!exists) {
-								options.loopState.clear()
-								log(`[${HOOK_NAME}] Cleared orphaned state from deleted session`, {
-									orphanedSessionId: state.session_id,
-									currentSessionId: sessionID,
-								})
-								return
-							}
-						} catch (err) {
-							log(`[${HOOK_NAME}] Failed to check session existence`, {
-								sessionId: state.session_id,
-								error: String(err),
-							})
-						}
-					}
-					return
-				}
-
-				const completionSessionID = verificationSessionID ?? sessionID
-				const transcriptPath = completionSessionID ? options.getTranscriptPath(completionSessionID) : undefined
-				const completionViaTranscript = completionSessionID
-					? detectCompletionInTranscript(
-						transcriptPath,
-						state.completion_promise,
-						state.started_at,
-					)
-					: false
-				const completionViaApi = completionViaTranscript
-					? false
-					: verificationSessionID
-						? await detectCompletionInSessionMessages(ctx, {
-							sessionID: verificationSessionID,
-							promise: state.completion_promise,
-							apiTimeoutMs: options.apiTimeoutMs,
-							directory: options.directory,
-							sinceMessageIndex: undefined,
-						})
-					: state.verification_pending
-						? await detectCompletionInSessionMessages(ctx, {
-							sessionID,
-							promise: state.completion_promise,
-							apiTimeoutMs: options.apiTimeoutMs,
-							directory: options.directory,
-							sinceMessageIndex: state.message_count_at_start,
-						})
-					: await detectCompletionInSessionMessages(ctx, {
-						sessionID,
-						promise: state.completion_promise,
-						apiTimeoutMs: options.apiTimeoutMs,
-						directory: options.directory,
-						sinceMessageIndex: state.message_count_at_start,
-					})
-
-				if (completionViaTranscript || completionViaApi) {
-					log(`[${HOOK_NAME}] Completion detected!`, {
-						sessionID,
-						iteration: state.iteration,
-						promise: state.completion_promise,
-						detectedVia: completionViaTranscript
-							? "transcript_file"
-							: "session_messages_api",
-					})
-					await handleDetectedCompletion(ctx, {
-						sessionID,
-						state,
-						loopState: options.loopState,
-						directory: options.directory,
-						apiTimeoutMs: options.apiTimeoutMs,
-					})
-					return
-				}
-
-				if (state.verification_pending) {
-					if (!verificationSessionID && matchesParentSession) {
-						log(`[${HOOK_NAME}] Verification pending without tracked critic session, running recovery check`, {
-							sessionID,
-							iteration: state.iteration,
-						})
-					}
-
-					await handlePendingVerification(ctx, {
-						sessionID,
-						state,
-						verificationSessionID,
-						matchesParentSession,
-						matchesVerificationSession,
-						loopState: options.loopState,
-						directory: options.directory,
-						apiTimeoutMs: options.apiTimeoutMs,
-					})
-					return
-				}
-
-				if (
-					typeof state.max_iterations === "number"
-					&& state.iteration >= state.max_iterations
-				) {
-					log(`[${HOOK_NAME}] Max iterations reached`, {
-						sessionID,
-						iteration: state.iteration,
-						max: state.max_iterations,
-					})
-					options.loopState.clear()
-
-					await ctx.client.tui?.showToast?.({
-						body: { title: "Ralph Loop Stopped", message: `Max iterations (${state.max_iterations}) reached without completion`, variant: "warning", duration: 5000 },
-						}).catch(() => {})
-					return
-				}
-
-				const newState = options.loopState.incrementIteration()
-				if (!newState) {
-					log(`[${HOOK_NAME}] Failed to increment iteration`, { sessionID })
-					return
-				}
-
-				log(`[${HOOK_NAME}] Continuing loop`, {
-					sessionID,
-					iteration: newState.iteration,
-					max: newState.max_iterations,
-				})
-
-				await ctx.client.tui?.showToast?.({
-					body: {
-						title: "Ralph Loop",
-						message: `Iteration ${newState.iteration}/${typeof newState.max_iterations === "number" ? newState.max_iterations : "unbounded"}`,
-						variant: "info",
-						duration: 2000,
-					},
-					}).catch(() => {})
-
-				try {
-					await continueIteration(ctx, newState, {
-						previousSessionID: sessionID,
-						directory: options.directory,
-						apiTimeoutMs: options.apiTimeoutMs,
-						loopState: options.loopState,
-					})
-				} catch (err) {
-					log(`[${HOOK_NAME}] Failed to inject continuation`, {
-						sessionID,
-						error: String(err),
-					})
-				}
-				return
-			} finally {
-				inFlightSessions.delete(sessionID)
-			}
-		}
-
-		if (event.type === "session.deleted") {
-			if (!handleDeletedLoopSession(props, options.loopState, options.sessionRecovery)) return
-			return
-		}
-
-		if (event.type === "session.error") {
-			handleErroredLoopSession(props, options.loopState, options.sessionRecovery)
-		}
-	}
-}