ralph-review 0.2.4 → 0.2.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "ralph-review",
-  "version": "0.2.4",
+  "version": "0.2.5",
   "description": "Orchestrating coding agents for code review, verification and fixing via the ralph loop.",
   "license": "MIT",
   "type": "module",

package/src/lib/review-workflow/review/run-review-session.ts

@@ -325,6 +325,20 @@ export async function runReviewSession(
     if (entry.type === "review_iteration") {
       latestPersistedFindings = [...latestPersistedFindings, ...entry.findings];
       completedReviewIterations = entry.iteration;
+
+      if (worktree && latestPersistedFindings.length > 0) {
+        await deps.saveFindingsArtifact(
+          CONFIG_DIR,
+          createFindingsArtifact(
+            sessionId,
+            projectPath,
+            sessionPath,
+            worktree,
+            latestPersistedFindings
+          )
+        );
+        shouldDeleteSessionRefs = false;
+      }
     }
   };
 

package/src/lib/stop-session.ts

@@ -1,5 +1,5 @@
 import { discardSessionWorktree, type GitSessionWorktree } from "@/lib/git";
-import { deleteSessionFiles, readLog } from "@/lib/logger";
+import { appendLog, deleteSessionFiles, readLog } from "@/lib/logger";
 import {
   type ActiveSession,
   readSessionState,
@@ -27,6 +27,7 @@ interface WaitForGracefulStopDeps {
 
 interface StopActiveSessionDeps {
   readLog: typeof readLog;
+  appendLog: typeof appendLog;
   deleteSessionFiles: typeof deleteSessionFiles;
   updateSessionState: typeof updateSessionState;
   sendInterrupt: typeof sendInterrupt;
@@ -41,6 +42,7 @@ interface StopActiveSessionDeps {
 
 const DEFAULT_STOP_ACTIVE_SESSION_DEPS: StopActiveSessionDeps = {
   readLog,
+  appendLog,
   deleteSessionFiles,
   updateSessionState,
   sendInterrupt,
@@ -137,6 +139,7 @@ interface SessionIterationState {
   hasRecordedIteration: boolean;
   hasRecordedReviewProgress: boolean;
   hasSuccessfulReviewIteration: boolean;
+  entries: LogEntry[];
 }
 
 async function resolveSessionIterationState(
@@ -153,12 +156,58 @@ async function resolveSessionIterationState(
       hasRecordedIteration: hasRecordedIteration(entries),
       hasRecordedReviewProgress: hasRecordedReviewProgress(entries),
       hasSuccessfulReviewIteration: hasSuccessfulReviewIteration(entries),
+      entries,
     };
   } catch {
     return null;
   }
 }
 
+function getLatestLifecycleEntry(entries: LogEntry[]): LogEntry | undefined {
+  return [...entries].reverse().find((entry) => entry.type !== "handoff");
+}
+
+function getLatestReviewIteration(entries: LogEntry[]) {
+  return entries.filter((entry) => entry.type === "review_iteration").at(-1);
+}
+
+function getAccumulatedReviewFindings(entries: LogEntry[]) {
+  return entries.flatMap((entry) => (entry.type === "review_iteration" ? entry.findings : []));
+}
+
+async function terminalizeForceStoppedReviewSession(
+  session: ActiveSession,
+  iterationState: SessionIterationState | null,
+  deps: StopActiveSessionDeps
+): Promise<void> {
+  if (!session.sessionPath || !iterationState?.hasRecordedReviewProgress) {
+    return;
+  }
+
+  if (getLatestLifecycleEntry(iterationState.entries)?.type === "session_end") {
+    return;
+  }
+
+  const latestReviewIteration = getLatestReviewIteration(iterationState.entries);
+  if (!latestReviewIteration) {
+    return;
+  }
+
+  await deps.appendLog(session.sessionPath, {
+    type: "session_end",
+    timestamp: Date.now(),
+    status: "interrupted",
+    reason: "Review stopped by user.",
+    iterations: latestReviewIteration.iteration,
+    phase: "review",
+    sessionStatus: "interrupted",
+    reviewOutcome:
+      getAccumulatedReviewFindings(iterationState.entries).length > 0
+        ? "findings-pending"
+        : "incomplete",
+  });
+}
+
 function createCleanupWorktree(
   session: ActiveSession,
   sourceRepoPath: string
@@ -239,6 +288,15 @@ export async function stopActiveSession(
   }
 
   const finalIterationState = await resolveSessionIterationState(session, stopDeps);
+  let terminalizeSessionError: unknown;
+  if (!stoppedGracefully) {
+    try {
+      await terminalizeForceStoppedReviewSession(session, finalIterationState, stopDeps);
+    } catch (error) {
+      terminalizeSessionError = error;
+    }
+  }
+
   if (finalIterationState?.hasSuccessfulReviewIteration === false) {
     cleanupUnpromotedSessionWorktree(session, stopDeps);
   }
@@ -256,6 +314,10 @@ export async function stopActiveSession(
     expectedSessionId: session.sessionId,
   });
 
+  if (terminalizeSessionError) {
+    throw terminalizeSessionError;
+  }
+
   if (deleteSessionFilesError) {
     throw deleteSessionFilesError;
   }

package/src/lib/tui/dashboard/Dashboard.tsx

@@ -17,9 +17,11 @@ import { StatusBar } from "./StatusBar";
 import { useDashboardRunControl } from "./use-dashboard-run-control";
 import { useDashboardStopControl } from "./use-dashboard-stop-control";
 
-export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: DashboardProps) {
+export function Dashboard({ projectPath, branch, refreshInterval = 1000, deps }: DashboardProps) {
   const renderer = useRenderer();
-  const state = useWorkspaceState(projectPath, branch, refreshInterval);
+  const resolvedUseWorkspaceState = deps?.useWorkspaceState ?? useWorkspaceState;
+  const ResolvedDashboardOverlays = deps?.DashboardOverlays ?? DashboardOverlays;
+  const state = resolvedUseWorkspaceState(projectPath, branch, refreshInterval);
   const {
     runError,
     startupMode,
@@ -29,7 +31,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
     spawnRunProcess,
     spawnFixProcess,
     isStartupSpawning,
-  } = useDashboardRunControl(projectPath);
+  } = useDashboardRunControl(projectPath, { spawn: deps?.spawn });
   const [focusedPane, setFocusedPane] = useState<FocusedPane>("detail");
   const [outputVisible, setOutputVisible] = useState(false);
   const [showHelp, setShowHelp] = useState(false);
@@ -37,11 +39,14 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
   const [showSession, setShowSession] = useState(false);
   const [showReviewModeOverlay, setShowReviewModeOverlay] = useState(false);
   const [showStopPicker, setShowStopPicker] = useState(false);
-  const { isStoppingRun, stopSelectedSession } = useDashboardStopControl({
-    currentSession: state.currentSession,
-    setShowStopPicker,
-    onError: setRunError,
-  });
+  const { isStoppingRun, stopSelectedSession } = useDashboardStopControl(
+    {
+      currentSession: state.currentSession,
+      setShowStopPicker,
+      onError: setRunError,
+    },
+    { stopActiveSession: deps?.stopActiveSession }
+  );
 
   const projectName = basename(projectPath);
   const isExitingRef = useRef(false);
@@ -271,7 +276,7 @@ export function Dashboard({ projectPath, branch, refreshInterval = 1000 }: Dashb
           liveRefreshError={state.liveRefreshError}
           configWarning={state.configWarning}
         />
-        <DashboardOverlays
+        <ResolvedDashboardOverlays
           showHelp={showHelp}
           showRunOverlay={showRunOverlay}
           showFixFindings={showFixFindings}

package/src/lib/tui/dashboard/use-dashboard-run-control.ts

@@ -15,10 +15,18 @@ export interface DashboardRunControl {
   isStartupSpawning: () => boolean;
 }
 
-export function useDashboardRunControl(projectPath: string): DashboardRunControl {
+interface DashboardRunControlDeps {
+  spawn?: typeof Bun.spawn;
+}
+
+export function useDashboardRunControl(
+  projectPath: string,
+  deps?: DashboardRunControlDeps
+): DashboardRunControl {
   const [runError, setRunError] = useState<string | null>(null);
   const [startupMode, setStartupMode] = useState<DashboardStartupMode>(null);
   const isStartupSpawningRef = useRef(false);
+  const spawn = deps?.spawn ?? Bun.spawn;
 
   const clearRunError = useCallback(() => {
     setRunError(null);
@@ -40,7 +48,7 @@ export function useDashboardRunControl(projectPath: string): DashboardRunControl
       setStartupMode(nextStartupMode);
 
       try {
-        const subprocess = Bun.spawn([process.execPath, CLI_PATH, command, ...argv], {
+        const subprocess = spawn([process.execPath, CLI_PATH, command, ...argv], {
           cwd: projectPath,
           stdin: "ignore",
           stdout: "pipe",
@@ -73,7 +81,7 @@ export function useDashboardRunControl(projectPath: string): DashboardRunControl
         setRunError(getErrorMessage(error));
       }
     },
-    [projectPath]
+    [projectPath, spawn]
   );
 
   const spawnRunProcess = useCallback(

package/src/lib/tui/dashboard/use-dashboard-stop-control.ts

@@ -22,13 +22,17 @@ export interface DashboardStopControl {
   stopSelectedSession: (session: ActiveSession) => Promise<void>;
 }
 
-export function useDashboardStopControl({
-  currentSession,
-  setShowStopPicker,
-  onError,
-}: DashboardStopControlOptions): DashboardStopControl {
+interface DashboardStopControlDeps {
+  stopActiveSession?: typeof stopActiveSession;
+}
+
+export function useDashboardStopControl(
+  options: DashboardStopControlOptions,
+  deps?: DashboardStopControlDeps
+): DashboardStopControl {
   const [stoppingSession, setStoppingSession] = useState<StoppingSessionState | null>(null);
   const settleTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null);
+  const stopSession = deps?.stopActiveSession ?? stopActiveSession;
 
   const clearSettleTimer = useMemo(
     () => () => {
@@ -42,7 +46,10 @@ export function useDashboardStopControl({
 
   if (
     stoppingSession &&
-    shouldClearStoppingSessionState({ marker: stoppingSession, currentSession })
+    shouldClearStoppingSessionState({
+      marker: stoppingSession,
+      currentSession: options.currentSession,
+    })
   ) {
     clearSettleTimer();
     setStoppingSession(null);
@@ -57,8 +64,8 @@ export function useDashboardStopControl({
 
       try {
         await stopSelectedDashboardSession(session, {
-          setShowStopPicker,
-          stopActiveSession,
+          setShowStopPicker: options.setShowStopPicker,
+          stopActiveSession: stopSession,
         });
 
         const settled = settleStoppingSessionState(createStoppingSessionState(session));
@@ -78,10 +85,10 @@ export function useDashboardStopControl({
       } catch (error) {
         clearSettleTimer();
         setStoppingSession(null);
-        onError(getErrorMessage(error));
+        options.onError(getErrorMessage(error));
       }
     },
-    [clearSettleTimer, onError, setShowStopPicker]
+    [clearSettleTimer, options.onError, options.setShowStopPicker, stopSession]
   );
 
   return {

package/src/lib/tui/shared/types.ts

@@ -1,5 +1,15 @@
+import type { stopActiveSession } from "@/lib/stop-session";
+import type { DashboardOverlays } from "@/lib/tui/dashboard/DashboardOverlays";
+import type { useWorkspaceState } from "@/lib/tui/workspace/use-workspace-state";
+
 export interface DashboardProps {
   projectPath: string;
   branch?: string;
   refreshInterval?: number;
+  deps?: {
+    useWorkspaceState?: typeof useWorkspaceState;
+    DashboardOverlays?: typeof DashboardOverlays;
+    spawn?: typeof Bun.spawn;
+    stopActiveSession?: typeof stopActiveSession;
+  };
 }