@hiai-gg/hiai-opencode 0.1.7 → 0.1.9

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

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

@@ -1,90 +0,0 @@
-import type { PluginInput } from "@opencode-ai/plugin"
-import type { RalphLoopOptions, RalphLoopState } from "./types"
-import { getTranscriptPath as getDefaultTranscriptPath } from "../claude-code-hooks/transcript"
-import { createLoopSessionRecovery } from "./loop-session-recovery"
-import { createLoopStateController } from "./loop-state-controller"
-import { createRalphLoopEventHandler } from "./ralph-loop-event-handler"
-
-export interface RalphLoopHook {
-  event: (input: { event: { type: string; properties?: unknown } }) => Promise<void>
-  startLoop: (
-    sessionID: string,
-    prompt: string,
-    options?: {
-      maxIterations?: number
-      completionPromise?: string
-      messageCountAtStart?: number
-      ultrawork?: boolean
-      strategy?: "reset" | "continue"
-    }
-  ) => boolean
-  cancelLoop: (sessionID: string) => boolean
-  getState: () => RalphLoopState | null
-}
-
-const DEFAULT_API_TIMEOUT = 5000 as const
-
-function getMessageCountFromResponse(messagesResponse: unknown): number {
-  if (Array.isArray(messagesResponse)) {
-    return messagesResponse.length
-  }
-
-  if (typeof messagesResponse === "object" && messagesResponse !== null && "data" in messagesResponse) {
-    const data = (messagesResponse as { data?: unknown }).data
-    return Array.isArray(data) ? data.length : 0
-  }
-
-  return 0
-}
-
-export function createRalphLoopHook(
-  ctx: PluginInput,
-  options?: RalphLoopOptions
-): RalphLoopHook {
-  const config = options?.config
-  const stateDir = config?.state_dir
-  const getTranscriptPath = options?.getTranscriptPath ?? getDefaultTranscriptPath
-  const apiTimeout = options?.apiTimeout ?? DEFAULT_API_TIMEOUT
-  const checkSessionExists = options?.checkSessionExists
-
-	const loopState = createLoopStateController({
-		directory: ctx.directory,
-		stateDir,
-		config,
-	})
-	const sessionRecovery = createLoopSessionRecovery()
-
-	const event = createRalphLoopEventHandler(ctx, {
-		directory: ctx.directory,
-		apiTimeoutMs: apiTimeout,
-		getTranscriptPath,
-		checkSessionExists,
-		sessionRecovery,
-		loopState,
-	})
-
-	return {
-		event,
-		startLoop: (sessionID, prompt, loopOptions): boolean => {
-			const startSuccess = loopState.startLoop(sessionID, prompt, loopOptions)
-			if (!startSuccess || typeof loopOptions?.messageCountAtStart === "number") {
-				return startSuccess
-			}
-
-			ctx.client.session
-				.messages({
-					path: { id: sessionID },
-					query: { directory: ctx.directory },
-				})
-				.then((messagesResponse: unknown) => {
-					const messageCountAtStart = getMessageCountFromResponse(messagesResponse)
-					loopState.setMessageCountAtStart(sessionID, messageCountAtStart)
-				})
-				.catch(() => {})
-
-			return startSuccess
-		},
-		cancelLoop: loopState.cancelLoop,
-		getState: loopState.getState as () => RalphLoopState | null,
-	}
-}

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

@@ -1,56 +0,0 @@
-import { log } from "../../shared/logger"
-import { HOOK_NAME } from "./constants"
-import type { RalphLoopState } from "./types"
-
-type LoopStateController = {
-	getState: () => RalphLoopState | null
-	clear: () => boolean
-}
-
-type SessionRecovery = {
-	clear: (sessionID: string) => void
-	markRecovering: (sessionID: string) => void
-}
-
-export function handleDeletedLoopSession(
-	props: Record<string, unknown> | undefined,
-	loopState: LoopStateController,
-	sessionRecovery: SessionRecovery,
-): boolean {
-	const sessionInfo = props?.info as { id?: string } | undefined
-	if (!sessionInfo?.id) return false
-
-	const state = loopState.getState()
-	if (state?.session_id === sessionInfo.id) {
-		loopState.clear()
-		log(`[${HOOK_NAME}] Session deleted, loop cleared`, { sessionID: sessionInfo.id })
-	}
-	sessionRecovery.clear(sessionInfo.id)
-	return true
-}
-
-export function handleErroredLoopSession(
-	props: Record<string, unknown> | undefined,
-	loopState: LoopStateController,
-	sessionRecovery: SessionRecovery,
-): boolean {
-	const sessionID = props?.sessionID as string | undefined
-	const error = props?.error as { name?: string } | undefined
-
-	if (error?.name === "MessageAbortedError") {
-		if (sessionID) {
-			const state = loopState.getState()
-			if (state?.session_id === sessionID) {
-				loopState.clear()
-				log(`[${HOOK_NAME}] User aborted, loop cleared`, { sessionID })
-			}
-			sessionRecovery.clear(sessionID)
-		}
-		return true
-	}
-
-	if (sessionID) {
-		sessionRecovery.markRecovering(sessionID)
-	}
-	return true
-}