ralph-review 0.2.2 → 0.2.4

package/src/lib/tui/workspace/use-workspace-state.ts

@@ -2,7 +2,7 @@ import { basename } from "node:path";
 import { useCallback, useEffect, useRef, useState } from "react";
 import { loadEffectiveConfig } from "@/lib/config";
 import { ensureGitRepositoryAsync } from "@/lib/git";
-import type { LogIncrementalState } from "@/lib/logger";
+import type { LogIncrementalState, LogSession } from "@/lib/logger";
 import {
   computeProjectStats,
   computeSessionStats,
@@ -11,7 +11,7 @@ import {
   listProjectLogSessions,
   readLogIncremental,
 } from "@/lib/logger";
-import type { ActiveSession } from "@/lib/session-state";
+import type { ActiveSession, SessionState } from "@/lib/session-state";
 import {
   getLatestProjectActiveSession,
   listAllActiveSessions,
@@ -35,7 +35,91 @@ import {
 import type { SessionGroupData, WorkspaceState } from "./workspace-types";
 
 const DEFAULT_REFRESH_INTERVAL = 1000;
-const LIVE_REFRESH_INTERVAL = TMUX_CAPTURE_MIN_INTERVAL_MS;
+
+export interface WorkspaceStateDeps {
+  loadEffectiveConfig: typeof loadEffectiveConfig;
+  ensureGitRepositoryAsync: typeof ensureGitRepositoryAsync;
+  listAllActiveSessions: typeof listAllActiveSessions;
+  listProjectActiveSessions: typeof listProjectActiveSessions;
+  getLatestProjectActiveSession: (
+    storageRoot: string | undefined,
+    projectPath: string
+  ) => Promise<SessionState | null>;
+  getLatestProjectLogSession: (
+    storageRoot: string | undefined,
+    projectPath: string
+  ) => Promise<LogSession | null>;
+  readLogIncremental: typeof readLogIncremental;
+  listProjectLogSessions: typeof listProjectLogSessions;
+  computeSessionStats: typeof computeSessionStats;
+  computeProjectStats: typeof computeProjectStats;
+  getProjectName: typeof getProjectName;
+  shouldCaptureTmux: typeof shouldCaptureTmux;
+  getSessionOutput: (sessionName: string, lines: number) => Promise<string>;
+  computeNextTmuxCaptureInterval: typeof computeNextTmuxCaptureInterval;
+  tmuxCaptureMinIntervalMs: number;
+}
+
+const defaultWorkspaceStateDeps: WorkspaceStateDeps = {
+  loadEffectiveConfig,
+  ensureGitRepositoryAsync,
+  listAllActiveSessions,
+  listProjectActiveSessions,
+  getLatestProjectActiveSession,
+  getLatestProjectLogSession,
+  readLogIncremental,
+  listProjectLogSessions,
+  computeSessionStats,
+  computeProjectStats,
+  getProjectName,
+  shouldCaptureTmux,
+  getSessionOutput,
+  computeNextTmuxCaptureInterval,
+  tmuxCaptureMinIntervalMs: TMUX_CAPTURE_MIN_INTERVAL_MS,
+};
+
+export function createInitialWorkspaceState(
+  overrides: Partial<WorkspaceState> = {}
+): WorkspaceState {
+  return {
+    sessionGroups: [],
+    allSessions: [],
+    projectSessions: [],
+    selectedSessionId: null,
+    currentSession: null,
+    logEntries: [],
+    fixes: [],
+    skipped: [],
+    findings: [],
+    storedFindings: [],
+    selectedFindingIds: [],
+    selectedFindings: [],
+    unselectedFindings: [],
+    fixResults: [],
+    unresolvedSelectedFindings: [],
+    auditRegressionFindings: [],
+    iterationFixes: [],
+    iterationSkipped: [],
+    iterationFindings: [],
+    latestReviewIteration: null,
+    codexReviewText: null,
+    tmuxOutput: "",
+    elapsed: 0,
+    maxIterations: 0,
+    error: null,
+    liveRefreshError: null,
+    isLoading: true,
+    lastSessionStats: null,
+    projectStats: null,
+    config: null,
+    configWarning: null,
+    isGitRepo: true,
+    currentAgent: null,
+    reviewOptions: undefined,
+    outputVisible: false,
+    ...overrides,
+  };
+}
 
 function buildSessionGroups(
   allSessions: ActiveSession[],
@@ -78,45 +162,10 @@ function buildSessionGroups(
 export function useWorkspaceState(
   projectPath: string,
   _branch?: string,
-  refreshInterval: number = DEFAULT_REFRESH_INTERVAL
+  refreshInterval: number = DEFAULT_REFRESH_INTERVAL,
+  deps: WorkspaceStateDeps = defaultWorkspaceStateDeps
 ): WorkspaceState {
-  const [state, setState] = useState<WorkspaceState>({
-    sessionGroups: [],
-    allSessions: [],
-    projectSessions: [],
-    selectedSessionId: null,
-    currentSession: null,
-    logEntries: [],
-    fixes: [],
-    skipped: [],
-    findings: [],
-    storedFindings: [],
-    selectedFindingIds: [],
-    selectedFindings: [],
-    unselectedFindings: [],
-    fixResults: [],
-    unresolvedSelectedFindings: [],
-    auditRegressionFindings: [],
-    iterationFixes: [],
-    iterationSkipped: [],
-    iterationFindings: [],
-    latestReviewIteration: null,
-    codexReviewText: null,
-    tmuxOutput: "",
-    elapsed: 0,
-    maxIterations: 0,
-    error: null,
-    liveRefreshError: null,
-    isLoading: true,
-    lastSessionStats: null,
-    projectStats: null,
-    config: null,
-    configWarning: null,
-    isGitRepo: true,
-    currentAgent: null,
-    reviewOptions: undefined,
-    outputVisible: false,
-  });
+  const [state, setState] = useState<WorkspaceState>(() => createInitialWorkspaceState());
 
   const stateRef = useRef(state);
   stateRef.current = state;
@@ -126,7 +175,7 @@ export function useWorkspaceState(
   const lastTmuxCaptureRef = useRef(0);
   const lastTmuxOutputRef = useRef("");
   const lastTmuxSessionRef = useRef<string | null>(null);
-  const tmuxCaptureIntervalRef = useRef(TMUX_CAPTURE_MIN_INTERVAL_MS);
+  const tmuxCaptureIntervalRef = useRef(deps.tmuxCaptureMinIntervalMs);
   const lastLiveMetaRef = useRef<LiveRefreshMeta | null>(null);
   const logIncrementalStateRef = useRef<LogIncrementalState | undefined>(undefined);
   const lastLogSessionPathRef = useRef<string | null>(null);
@@ -138,12 +187,12 @@ export function useWorkspaceState(
     try {
       const [isGitRepo, allSessions, projectSessions, currentSession, logSession, configResult] =
         await Promise.all([
-          ensureGitRepositoryAsync(projectPath),
-          listAllActiveSessions(),
-          listProjectActiveSessions(undefined, projectPath),
-          getLatestProjectActiveSession(undefined, projectPath),
-          getLatestProjectLogSession(undefined, projectPath),
-          loadWorkspaceConfigSafe(projectPath, loadEffectiveConfig),
+          deps.ensureGitRepositoryAsync(projectPath),
+          deps.listAllActiveSessions(),
+          deps.listProjectActiveSessions(undefined, projectPath),
+          deps.getLatestProjectActiveSession(undefined, projectPath),
+          deps.getLatestProjectLogSession(undefined, projectPath),
+          loadWorkspaceConfigSafe(projectPath, deps.loadEffectiveConfig),
         ]);
 
       const sessionGroups = buildSessionGroups(allSessions, projectPath);
@@ -165,7 +214,7 @@ export function useWorkspaceState(
 
       if (logPath) {
         const logSessionChanged = logPath !== lastLogSessionPathRef.current;
-        const incrementalResult = await readLogIncremental(
+        const incrementalResult = await deps.readLogIncremental(
           logPath,
           logSessionChanged ? undefined : logIncrementalStateRef.current
         );
@@ -202,11 +251,14 @@ export function useWorkspaceState(
       let projectStats: ProjectStats | null = null;
 
       if (!currentSession) {
-        const projectLogSessions = await listProjectLogSessions(undefined, projectPath);
+        const projectLogSessions = await deps.listProjectLogSessions(undefined, projectPath);
         const latestSession = projectLogSessions[0];
         if (latestSession) {
-          lastSessionStats = await computeSessionStats(latestSession);
-          projectStats = await computeProjectStats(getProjectName(projectPath), projectLogSessions);
+          lastSessionStats = await deps.computeSessionStats(latestSession);
+          projectStats = await deps.computeProjectStats(
+            deps.getProjectName(projectPath),
+            projectLogSessions
+          );
         }
       }
 
@@ -254,14 +306,14 @@ export function useWorkspaceState(
     } finally {
       isHeavyRefreshingRef.current = false;
     }
-  }, [projectPath]);
+  }, [deps, projectPath]);
 
   const refreshLive = useCallback(async () => {
     if (isLiveRefreshingRef.current) return;
     isLiveRefreshingRef.current = true;
 
     try {
-      const currentSession = await getLatestProjectActiveSession(undefined, projectPath);
+      const currentSession = await deps.getLatestProjectActiveSession(undefined, projectPath);
 
       let tmuxOutput = lastTmuxOutputRef.current;
       const liveMeta = getLiveRefreshMeta(currentSession);
@@ -274,10 +326,10 @@ export function useWorkspaceState(
         lastTmuxOutputRef.current = "";
         lastTmuxSessionRef.current = null;
         lastTmuxCaptureRef.current = 0;
-        tmuxCaptureIntervalRef.current = TMUX_CAPTURE_MIN_INTERVAL_MS;
+        tmuxCaptureIntervalRef.current = deps.tmuxCaptureMinIntervalMs;
       } else {
         const sessionChanged = sessionName !== lastTmuxSessionRef.current;
-        const shouldCapture = shouldCaptureTmux({
+        const shouldCapture = deps.shouldCaptureTmux({
           sessionChanged,
           liveMetaChanged,
           now,
@@ -286,14 +338,14 @@ export function useWorkspaceState(
         });
 
         if (shouldCapture) {
-          const capturedOutput = await getSessionOutput(sessionName, 1000);
+          const capturedOutput = await deps.getSessionOutput(sessionName, 1000);
           const nextOutput = capturedOutput || (sessionChanged ? "" : lastTmuxOutputRef.current);
           const outputChanged = nextOutput !== lastTmuxOutputRef.current;
           tmuxOutput = nextOutput;
           lastTmuxOutputRef.current = tmuxOutput;
           lastTmuxSessionRef.current = sessionName;
           lastTmuxCaptureRef.current = now;
-          tmuxCaptureIntervalRef.current = computeNextTmuxCaptureInterval({
+          tmuxCaptureIntervalRef.current = deps.computeNextTmuxCaptureInterval({
             sessionChanged,
             liveMetaChanged,
             outputChanged,
@@ -322,7 +374,7 @@ export function useWorkspaceState(
     } finally {
       isLiveRefreshingRef.current = false;
     }
-  }, [projectPath]);
+  }, [deps, projectPath]);
 
   useEffect(() => {
     void refreshHeavy();
@@ -338,9 +390,9 @@ export function useWorkspaceState(
   }, [refreshLive]);
 
   useEffect(() => {
-    const interval = setInterval(refreshLive, LIVE_REFRESH_INTERVAL);
+    const interval = setInterval(refreshLive, deps.tmuxCaptureMinIntervalMs);
     return () => clearInterval(interval);
-  }, [refreshLive]);
+  }, [deps.tmuxCaptureMinIntervalMs, refreshLive]);
 
   return state;
 }

package/src/lib/types/fix.ts

@@ -1,5 +1,6 @@
 import type { FixDecision, Priority } from "./domain";
 import { VALID_FIX_DECISIONS, VALID_PRIORITIES } from "./domain";
+import { asRecord, isCodeLocation } from "./guards";
 import type { CodeLocation } from "./review";
 
 export interface FixEntry {
@@ -26,53 +27,27 @@ export interface FixSummary {
   skipped: SkippedEntry[];
 }
 
-function isLineRange(value: unknown): value is CodeLocation["line_range"] {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const obj = value as Record<string, unknown>;
-
+function hasFixEntryHeader(obj: Record<string, unknown>): boolean {
   return (
-    typeof obj.start === "number" &&
-    Number.isInteger(obj.start) &&
-    obj.start > 0 &&
-    typeof obj.end === "number" &&
-    Number.isInteger(obj.end) &&
-    obj.end >= obj.start
+    typeof obj.id === "number" &&
+    typeof obj.title === "string" &&
+    typeof obj.priority === "string" &&
+    VALID_PRIORITIES.includes(obj.priority as Priority)
   );
 }
 
-function isCodeLocation(value: unknown): value is CodeLocation {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const obj = value as Record<string, unknown>;
-
-  if (typeof obj.absolute_file_path !== "string") {
-    return false;
-  }
-
-  return isLineRange(obj.line_range);
-}
-
 function isFixEntry(value: unknown): value is FixEntry {
-  if (typeof value !== "object" || value === null) {
+  const obj = asRecord(value);
+  if (obj === null) {
     return false;
   }
 
-  const obj = value as Record<string, unknown>;
-
   return (
-    typeof obj.id === "number" &&
-    typeof obj.title === "string" &&
-    typeof obj.priority === "string" &&
-    VALID_PRIORITIES.includes(obj.priority as Priority) &&
+    hasFixEntryHeader(obj) &&
     (obj.file === undefined || obj.file === null || typeof obj.file === "string") &&
     (obj.code_location === undefined ||
       obj.code_location === null ||
-      isCodeLocation(obj.code_location)) &&
+      isCodeLocation(obj.code_location, { requirePositive: true })) &&
     typeof obj.claim === "string" &&
     typeof obj.evidence === "string" &&
     typeof obj.fix === "string"
@@ -80,28 +55,20 @@ function isFixEntry(value: unknown): value is FixEntry {
 }
 
 function isSkippedEntry(value: unknown): value is SkippedEntry {
-  if (typeof value !== "object" || value === null) {
+  const obj = asRecord(value);
+  if (obj === null) {
     return false;
   }
 
-  const obj = value as Record<string, unknown>;
-
-  return (
-    typeof obj.id === "number" &&
-    typeof obj.title === "string" &&
-    typeof obj.priority === "string" &&
-    VALID_PRIORITIES.includes(obj.priority as Priority) &&
-    typeof obj.reason === "string"
-  );
+  return hasFixEntryHeader(obj) && typeof obj.reason === "string";
 }
 
 export function isFixSummary(value: unknown): value is FixSummary {
-  if (typeof value !== "object" || value === null) {
+  const obj = asRecord(value);
+  if (obj === null) {
     return false;
   }
 
-  const obj = value as Record<string, unknown>;
-
   // Check decision field
   if (
     typeof obj.decision !== "string" ||

package/src/lib/types/guards.ts

@@ -0,0 +1,47 @@
+export function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== "object" || value === null) {
+    return null;
+  }
+
+  return value as Record<string, unknown>;
+}
+
+function isInteger(value: unknown): value is number {
+  return typeof value === "number" && Number.isInteger(value);
+}
+
+function asRecordWithStringField(value: unknown, field: string): Record<string, unknown> | null {
+  const obj = asRecord(value);
+  if (obj === null || typeof obj[field] !== "string") {
+    return null;
+  }
+
+  return obj;
+}
+
+function isLineRange(
+  value: unknown,
+  options: { requirePositive?: boolean } = {}
+): value is { start: number; end: number } {
+  const obj = asRecord(value);
+  if (obj === null || !isInteger(obj.start) || !isInteger(obj.end) || obj.end < obj.start) {
+    return false;
+  }
+
+  if (options.requirePositive && (obj.start <= 0 || obj.end <= 0)) {
+    return false;
+  }
+
+  return true;
+}
+
+export function isCodeLocation(
+  value: unknown,
+  options: { requirePositive?: boolean } = {}
+): value is {
+  absolute_file_path: string;
+  line_range: { start: number; end: number };
+} {
+  const obj = asRecordWithStringField(value, "absolute_file_path");
+  return obj !== null && isLineRange(obj.line_range, options);
+}

package/src/lib/types/review.ts

@@ -1,5 +1,6 @@
 import type { OverallCorrectness } from "./domain";
 import { VALID_OVERALL_CORRECTNESS } from "./domain";
+import { asRecord, isCodeLocation } from "./guards";
 
 export interface LineRange {
   start: number;
@@ -32,46 +33,12 @@ export interface CodexReviewSummary {
 
 const DEFAULT_CODEX_CONFIDENCE = 0.69;
 
-function isLineRange(value: unknown): value is LineRange {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const obj = value as Record<string, unknown>;
-
-  return (
-    typeof obj.start === "number" &&
-    Number.isInteger(obj.start) &&
-    typeof obj.end === "number" &&
-    Number.isInteger(obj.end)
-  );
-}
-
-function isCodeLocation(value: unknown): value is CodeLocation {
-  if (typeof value !== "object" || value === null) {
-    return false;
-  }
-
-  const obj = value as Record<string, unknown>;
-
-  if (typeof obj.absolute_file_path !== "string") {
-    return false;
-  }
-
-  if (!isLineRange(obj.line_range)) {
-    return false;
-  }
-
-  return true;
-}
-
 function isFinding(value: unknown): value is Finding {
-  if (typeof value !== "object" || value === null) {
+  const obj = asRecord(value);
+  if (obj === null) {
     return false;
   }
 
-  const obj = value as Record<string, unknown>;
-
   if (typeof obj.title !== "string" || typeof obj.body !== "string") {
     return false;
   }
@@ -99,12 +66,11 @@ function isFinding(value: unknown): value is Finding {
 }
 
 export function isReviewSummary(value: unknown): value is ReviewSummary {
-  if (typeof value !== "object" || value === null) {
+  const obj = asRecord(value);
+  if (obj === null) {
     return false;
   }
 
-  const obj = value as Record<string, unknown>;
-
   if (!Array.isArray(obj.findings)) {
     return false;
   }