@yail259/overnight 0.1.0 → 0.2.0

package/src/runner.ts

@@ -1,5 +1,7 @@
 import { query, type Options as ClaudeCodeOptions } from "@anthropic-ai/claude-agent-sdk";
 import { readFileSync, writeFileSync, existsSync, unlinkSync } from "fs";
+import { execSync } from "child_process";
+import { createHash } from "crypto";
 import {
   type JobConfig,
   type JobResult,
@@ -10,9 +12,100 @@ import {
   DEFAULT_RETRY_DELAY,
   DEFAULT_VERIFY_PROMPT,
   DEFAULT_STATE_FILE,
+  DEFAULT_MAX_TURNS,
 } from "./types.js";
+import { createSecurityHooks } from "./security.js";
 
 type LogCallback = (msg: string) => void;
+type ProgressCallback = (activity: string) => void;
+
+// Progress display
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+
+class ProgressDisplay {
+  private interval: ReturnType<typeof setInterval> | null = null;
+  private frame = 0;
+  private startTime = Date.now();
+  private currentActivity = "Working";
+  private lastToolUse = "";
+
+  start(activity: string): void {
+    this.currentActivity = activity;
+    this.startTime = Date.now();
+    this.frame = 0;
+
+    if (this.interval) return;
+
+    this.interval = setInterval(() => {
+      const elapsed = Math.floor((Date.now() - this.startTime) / 1000);
+      const toolInfo = this.lastToolUse ? ` → ${this.lastToolUse}` : "";
+      process.stdout.write(
+        `\r\x1b[K${SPINNER_FRAMES[this.frame]} ${this.currentActivity} (${elapsed}s)${toolInfo}`
+      );
+      this.frame = (this.frame + 1) % SPINNER_FRAMES.length;
+    }, 100);
+  }
+
+  updateActivity(activity: string): void {
+    this.currentActivity = activity;
+  }
+
+  updateTool(toolName: string, detail?: string): void {
+    this.lastToolUse = detail ? `${toolName}: ${detail}` : toolName;
+  }
+
+  stop(finalMessage?: string): void {
+    if (this.interval) {
+      clearInterval(this.interval);
+      this.interval = null;
+    }
+    process.stdout.write("\r\x1b[K"); // Clear line
+    if (finalMessage) {
+      console.log(finalMessage);
+    }
+  }
+
+  getElapsed(): number {
+    return (Date.now() - this.startTime) / 1000;
+  }
+}
+
+// Cache the claude executable path
+let claudeExecutablePath: string | undefined;
+
+function findClaudeExecutable(): string | undefined {
+  if (claudeExecutablePath !== undefined) return claudeExecutablePath;
+
+  // Check environment variable first
+  if (process.env.CLAUDE_CODE_PATH) {
+    claudeExecutablePath = process.env.CLAUDE_CODE_PATH;
+    return claudeExecutablePath;
+  }
+
+  // Try to find claude using which/where
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    claudeExecutablePath = execSync(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
+    return claudeExecutablePath;
+  } catch {
+    // Fall back to common locations
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      `${process.env.HOME}/.local/bin/claude`,
+      `${process.env.HOME}/.nvm/versions/node/v22.12.0/bin/claude`,
+    ];
+
+    for (const p of commonPaths) {
+      if (existsSync(p)) {
+        claudeExecutablePath = p;
+        return claudeExecutablePath;
+      }
+    }
+  }
+
+  return undefined;
+}
 
 function isRetryableError(error: Error): boolean {
   const errorStr = error.message.toLowerCase();
@@ -54,28 +147,91 @@ async function runWithTimeout<T>(
   }
 }
 
-async function collectResult(
+// Extract useful info from tool input for display
+function getToolDetail(toolName: string, toolInput: Record<string, unknown>): string {
+  switch (toolName) {
+    case "Read":
+    case "Write":
+    case "Edit":
+      const filePath = toolInput.file_path as string;
+      if (filePath) {
+        // Show just filename, not full path
+        return filePath.split("/").pop() || filePath;
+      }
+      break;
+    case "Glob":
+      return (toolInput.pattern as string) || "";
+    case "Grep":
+      return (toolInput.pattern as string)?.slice(0, 20) || "";
+    case "Bash":
+      const cmd = (toolInput.command as string) || "";
+      return cmd.slice(0, 30) + (cmd.length > 30 ? "..." : "");
+  }
+  return "";
+}
+
+async function collectResultWithProgress(
   prompt: string,
-  options: ClaudeCodeOptions
-): Promise<{ sessionId?: string; result?: string }> {
+  options: ClaudeCodeOptions,
+  progress: ProgressDisplay,
+  onSessionId?: (sessionId: string) => void
+): Promise<{ sessionId?: string; result?: string; error?: string }> {
   let sessionId: string | undefined;
   let result: string | undefined;
+  let lastError: string | undefined;
 
-  const conversation = query({ prompt, options });
+  try {
+    const conversation = query({ prompt, options });
 
-  for await (const message of conversation) {
-    if (message.type === "result") {
-      result = message.result;
-      sessionId = message.session_id;
+    for await (const message of conversation) {
+      // Debug logging
+      if (process.env.OVERNIGHT_DEBUG) {
+        console.error(`\n[DEBUG] message.type=${message.type}, keys=${Object.keys(message).join(",")}`);
+      }
+
+      // Handle different message types
+      if (message.type === "result") {
+        result = message.result;
+        sessionId = message.session_id;
+      } else if (message.type === "assistant" && "message" in message) {
+        // Assistant message with tool use - SDK nests content in message.message
+        const assistantMsg = message.message as { content?: Array<{ type: string; name?: string; input?: Record<string, unknown> }> };
+        if (assistantMsg.content) {
+          for (const block of assistantMsg.content) {
+            if (process.env.OVERNIGHT_DEBUG) {
+              console.error(`[DEBUG] content block: type=${block.type}, name=${block.name}`);
+            }
+            if (block.type === "tool_use" && block.name) {
+              const detail = block.input ? getToolDetail(block.name, block.input) : "";
+              progress.updateTool(block.name, detail);
+            }
+          }
+        }
+      } else if (message.type === "system" && "subtype" in message) {
+        // System messages
+        if (message.subtype === "init") {
+          sessionId = message.session_id;
+          if (sessionId && onSessionId) {
+            onSessionId(sessionId);
+          }
+        }
+      }
     }
+  } catch (e) {
+    lastError = (e as Error).message;
+    throw e;
   }
 
-  return { sessionId, result };
+  return { sessionId, result, error: lastError };
 }
 
 export async function runJob(
   config: JobConfig,
-  log?: LogCallback
+  log?: LogCallback,
+  options?: {
+    resumeSessionId?: string;        // Resume from a previous session
+    onSessionId?: (id: string) => void;  // Called when session ID is available
+  }
 ): Promise<JobResult> {
   const startTime = Date.now();
   const tools = config.allowed_tools ?? DEFAULT_TOOLS;
@@ -84,41 +240,95 @@ export async function runJob(
   const retryDelay = config.retry_delay ?? DEFAULT_RETRY_DELAY;
   const verifyPrompt = config.verify_prompt ?? DEFAULT_VERIFY_PROMPT;
   let retriesUsed = 0;
+  let resumeSessionId = options?.resumeSessionId;
 
   const logMsg = (msg: string) => log?.(msg);
-  logMsg(`Starting: ${config.prompt.slice(0, 60)}...`);
+  const progress = new ProgressDisplay();
+
+  // Find claude executable once at start
+  const claudePath = findClaudeExecutable();
+  if (!claudePath) {
+    logMsg("\x1b[31m✗ Error: Could not find 'claude' CLI.\x1b[0m");
+    logMsg("\x1b[33m  Install it with:\x1b[0m");
+    logMsg("    curl -fsSL https://claude.ai/install.sh | bash");
+    logMsg("\x1b[33m  Or set CLAUDE_CODE_PATH environment variable.\x1b[0m");
+    return {
+      task: config.prompt,
+      status: "failed",
+      error: "Claude CLI not found. Install with: curl -fsSL https://claude.ai/install.sh | bash",
+      duration_seconds: 0,
+      verified: false,
+      retries: 0,
+    };
+  }
+
+  if (process.env.OVERNIGHT_DEBUG) {
+    logMsg(`\x1b[2mDebug: Claude path = ${claudePath}\x1b[0m`);
+  }
+
+  // Show task being started
+  const taskPreview = config.prompt.slice(0, 60) + (config.prompt.length > 60 ? "..." : "");
+  if (resumeSessionId) {
+    logMsg(`\x1b[36m▶\x1b[0m Resuming: ${taskPreview}`);
+  } else {
+    logMsg(`\x1b[36m▶\x1b[0m ${taskPreview}`);
+  }
 
   for (let attempt = 0; attempt <= retryCount; attempt++) {
     try {
-      const options: ClaudeCodeOptions = {
+      // Build security hooks if security config provided
+      const securityHooks = config.security ? createSecurityHooks(config.security) : undefined;
+
+      const sdkOptions: ClaudeCodeOptions = {
         allowedTools: tools,
         permissionMode: "acceptEdits",
+        ...(claudePath && { pathToClaudeCodeExecutable: claudePath }),
         ...(config.working_dir && { cwd: config.working_dir }),
+        ...(config.security?.max_turns && { maxTurns: config.security.max_turns }),
+        ...(securityHooks && { hooks: securityHooks }),
+        ...(resumeSessionId && { resume: resumeSessionId }),
       };
 
       let sessionId: string | undefined;
       let result: string | undefined;
 
+      // Prompt: if resuming, ask to continue; otherwise use original prompt
+      const prompt = resumeSessionId
+        ? "Continue where you left off. Complete the original task."
+        : config.prompt;
+
+      // Start progress display
+      progress.start(resumeSessionId ? "Resuming" : "Working");
+
       try {
         const collected = await runWithTimeout(
-          collectResult(config.prompt, options),
+          collectResultWithProgress(prompt, sdkOptions, progress, (id) => {
+            sessionId = id;
+            options?.onSessionId?.(id);
+          }),
           timeout
         );
         sessionId = collected.sessionId;
         result = collected.result;
+        progress.stop();
       } catch (e) {
+        progress.stop();
         if ((e as Error).message === "TIMEOUT") {
           if (attempt < retryCount) {
             retriesUsed = attempt + 1;
+            // On timeout, if we have a session ID, use it for the retry
+            if (sessionId) {
+              resumeSessionId = sessionId;
+            }
             const delay = retryDelay * Math.pow(2, attempt);
             logMsg(
-              `Timeout after ${config.timeout_seconds ?? DEFAULT_TIMEOUT}s, retrying in ${delay}s (attempt ${attempt + 1}/${retryCount})...`
+              `\x1b[33m⚠ Timeout after ${config.timeout_seconds ?? DEFAULT_TIMEOUT}s, retrying in ${delay}s (${attempt + 1}/${retryCount})\x1b[0m`
             );
             await sleep(delay * 1000);
             continue;
           }
           logMsg(
-            `Timeout after ${config.timeout_seconds ?? DEFAULT_TIMEOUT}s (exhausted retries)`
+            `\x1b[31m✗ Timeout after ${config.timeout_seconds ?? DEFAULT_TIMEOUT}s (exhausted retries)\x1b[0m`
           );
           return {
             task: config.prompt,
@@ -132,42 +342,60 @@ export async function runJob(
         throw e;
       }
 
-      // Verification pass if enabled
+      // Verification pass if enabled — verify and fix issues
       if (config.verify !== false && sessionId) {
-        logMsg("Running verification...");
+        progress.start("Verifying");
 
         const verifyOptions: ClaudeCodeOptions = {
+          allowedTools: tools,
           resume: sessionId,
           permissionMode: "acceptEdits",
+          ...(claudePath && { pathToClaudeCodeExecutable: claudePath }),
+          ...(config.working_dir && { cwd: config.working_dir }),
+          ...(config.security?.max_turns && { maxTurns: config.security.max_turns }),
         };
 
+        const fixPrompt = verifyPrompt +
+          " If you find any issues, fix them now. Only report issues you cannot fix.";
+
         try {
           const verifyResult = await runWithTimeout(
-            collectResult(verifyPrompt, verifyOptions),
+            collectResultWithProgress(fixPrompt, verifyOptions, progress, (id) => {
+              sessionId = id;
+              options?.onSessionId?.(id);
+            }),
             timeout / 2
           );
+          progress.stop();
 
-          const issueWords = ["issue", "error", "fail", "incorrect", "missing"];
+          // Update result with verification output
+          if (verifyResult.result) {
+            result = verifyResult.result;
+          }
+
+          // Only mark as failed if there are issues that couldn't be fixed
+          const unfixableWords = ["cannot fix", "unable to", "blocked by", "requires manual"];
           if (
             verifyResult.result &&
-            issueWords.some((word) =>
+            unfixableWords.some((word) =>
               verifyResult.result!.toLowerCase().includes(word)
             )
           ) {
-            logMsg("Verification found potential issues");
+            logMsg(`\x1b[33m⚠ Verification found unfixable issues\x1b[0m`);
             return {
               task: config.prompt,
               status: "verification_failed",
               result,
-              error: `Verification issues: ${verifyResult.result}`,
+              error: `Unfixable issues: ${verifyResult.result}`,
               duration_seconds: (Date.now() - startTime) / 1000,
               verified: false,
               retries: retriesUsed,
             };
           }
         } catch (e) {
+          progress.stop();
           if ((e as Error).message === "TIMEOUT") {
-            logMsg("Verification timed out - continuing anyway");
+            logMsg("\x1b[33m⚠ Verification timed out - continuing anyway\x1b[0m");
           } else {
             throw e;
           }
@@ -175,7 +403,7 @@ export async function runJob(
       }
 
       const duration = (Date.now() - startTime) / 1000;
-      logMsg(`Completed in ${duration.toFixed(1)}s`);
+      logMsg(`\x1b[32m✓ Completed in ${duration.toFixed(1)}s\x1b[0m`);
 
       return {
         task: config.prompt,
@@ -186,19 +414,24 @@ export async function runJob(
         retries: retriesUsed,
       };
     } catch (e) {
+      progress.stop();
       const error = e as Error;
       if (isRetryableError(error) && attempt < retryCount) {
         retriesUsed = attempt + 1;
+        // Preserve session for resumption on retry
+        if (sessionId) {
+          resumeSessionId = sessionId;
+        }
         const delay = retryDelay * Math.pow(2, attempt);
         logMsg(
-          `Retryable error: ${error.message}, retrying in ${delay}s (attempt ${attempt + 1}/${retryCount})...`
+          `\x1b[33m⚠ ${error.message}, retrying in ${delay}s (${attempt + 1}/${retryCount})\x1b[0m`
         );
         await sleep(delay * 1000);
         continue;
       }
 
       const duration = (Date.now() - startTime) / 1000;
-      logMsg(`Failed: ${error.message}`);
+      logMsg(`\x1b[31m✗ Failed: ${error.message}\x1b[0m`);
       return {
         task: config.prompt,
         status: "failed",
@@ -221,6 +454,63 @@ export async function runJob(
   };
 }
 
+export function taskKey(config: JobConfig): string {
+  if (config.id) return config.id;
+  return createHash("sha256").update(config.prompt).digest("hex").slice(0, 12);
+}
+
+/** @deprecated Use taskKey(config) instead — kept for CLI backward compat */
+export function taskHash(prompt: string): string {
+  return createHash("sha256").update(prompt).digest("hex").slice(0, 12);
+}
+
+function validateDag(configs: JobConfig[]): string | null {
+  const ids = new Set(configs.map(c => c.id).filter(Boolean));
+  // Check all depends_on references exist
+  for (const c of configs) {
+    for (const dep of c.depends_on ?? []) {
+      if (!ids.has(dep)) {
+        return `Task "${c.id ?? c.prompt.slice(0, 40)}" depends on unknown id "${dep}"`;
+      }
+    }
+  }
+  // Check for cycles via DFS
+  const visited = new Set<string>();
+  const inStack = new Set<string>();
+  const idToConfig = new Map(configs.filter(c => c.id).map(c => [c.id!, c]));
+
+  function hasCycle(id: string): boolean {
+    if (inStack.has(id)) return true;
+    if (visited.has(id)) return false;
+    visited.add(id);
+    inStack.add(id);
+    const config = idToConfig.get(id);
+    for (const dep of config?.depends_on ?? []) {
+      if (hasCycle(dep)) return true;
+    }
+    inStack.delete(id);
+    return false;
+  }
+
+  for (const id of ids) {
+    if (hasCycle(id)) return `Dependency cycle detected involving "${id}"`;
+  }
+  return null;
+}
+
+function depsReady(
+  config: JobConfig,
+  completed: Record<string, JobResult>,
+): "ready" | "waiting" | "blocked" {
+  if (!config.depends_on || config.depends_on.length === 0) return "ready";
+  for (const dep of config.depends_on) {
+    const result = completed[dep];
+    if (!result) return "waiting";
+    if (result.status !== "success") return "blocked";
+  }
+  return "ready";
+}
+
 export function saveState(state: RunState, stateFile: string): void {
   writeFileSync(stateFile, JSON.stringify(state, null, 2));
 }
@@ -239,39 +529,126 @@ export async function runJobsWithState(
   options: {
     stateFile?: string;
     log?: LogCallback;
-    startIndex?: number;
-    priorResults?: JobResult[];
+    reloadConfigs?: () => JobConfig[];  // Called between jobs to pick up new tasks
   } = {}
 ): Promise<JobResult[]> {
   const stateFile = options.stateFile ?? DEFAULT_STATE_FILE;
-  const results: JobResult[] = options.priorResults
-    ? [...options.priorResults]
-    : [];
-  const startIndex = options.startIndex ?? 0;
 
-  for (let i = 0; i < configs.length; i++) {
-    if (i < startIndex) continue;
+  // Validate DAG if any tasks have dependencies
+  const dagError = validateDag(configs);
+  if (dagError) {
+    options.log?.(`\x1b[31m✗ DAG error: ${dagError}\x1b[0m`);
+    return [];
+  }
 
-    options.log?.(`\n[${i + 1}/${configs.length}] Running job...`);
+  // Load existing state or start fresh
+  const state: RunState = loadState(stateFile) ?? {
+    completed: {},
+    timestamp: new Date().toISOString(),
+  };
 
-    const result = await runJob(configs[i], options.log);
-    results.push(result);
+  let currentConfigs = configs;
+
+  while (true) {
+    // Find tasks not yet completed
+    const notDone = currentConfigs.filter(c => !(taskKey(c) in state.completed));
+    if (notDone.length === 0) break;
+
+    // Among not-done tasks, find those whose dependencies are satisfied
+    const ready = notDone.filter(c => depsReady(c, state.completed) === "ready");
+
+    // Find tasks blocked by failed dependencies
+    const blocked = notDone.filter(c => depsReady(c, state.completed) === "blocked");
+
+    // Mark blocked tasks as failed without running them
+    for (const bc of blocked) {
+      const key = taskKey(bc);
+      if (key in state.completed) continue; // already recorded
+      const failedDeps = (bc.depends_on ?? []).filter(
+        dep => state.completed[dep] && state.completed[dep].status !== "success"
+      );
+      const label = bc.id ?? bc.prompt.slice(0, 40);
+      options.log?.(`\n\x1b[31m✗ Skipping "${label}" — dependency failed: ${failedDeps.join(", ")}\x1b[0m`);
+      state.completed[key] = {
+        task: bc.prompt,
+        status: "failed",
+        error: `Blocked by failed dependencies: ${failedDeps.join(", ")}`,
+        duration_seconds: 0,
+        verified: false,
+        retries: 0,
+      };
+      state.timestamp = new Date().toISOString();
+      saveState(state, stateFile);
+    }
 
-    // Save state after each job
-    const state: RunState = {
-      completed_indices: Array.from({ length: results.length }, (_, i) => i),
-      results,
-      timestamp: new Date().toISOString(),
-      total_jobs: configs.length,
-    };
+    // If nothing is ready and nothing is blocked, everything remaining is waiting
+    // on something that will never complete — break to avoid infinite loop
+    if (ready.length === 0) break;
+
+    const config = ready[0];
+    const key = taskKey(config);
+
+    const totalNotDone = notDone.length - blocked.length;
+    const totalDone = Object.keys(state.completed).length;
+    const label = config.id ? `${config.id}` : "";
+    options.log?.(`\n\x1b[1m[${totalDone + 1}/${totalDone + totalNotDone}]${label ? ` ${label}` : ""}\x1b[0m`);
+
+    // Check if this task was previously in-progress (crashed mid-task)
+    const resumeSessionId = (state.inProgress?.hash === key)
+      ? state.inProgress.sessionId
+      : undefined;
+
+    if (resumeSessionId) {
+      options.log?.(`\x1b[2mResuming session ${resumeSessionId.slice(0, 8)}...\x1b[0m`);
+    }
+
+    // Mark task as in-progress before starting
+    state.inProgress = { hash: key, prompt: config.prompt, startedAt: new Date().toISOString() };
     saveState(state, stateFile);
 
+    const result = await runJob(config, options.log, {
+      resumeSessionId,
+      onSessionId: (id) => {
+        // Checkpoint the session ID so we can resume on crash
+        state.inProgress = { hash: key, prompt: config.prompt, sessionId: id, startedAt: state.inProgress!.startedAt };
+        saveState(state, stateFile);
+      },
+    });
+
+    // Task done — save result and clear in-progress
+    state.completed[key] = result;
+    state.inProgress = undefined;
+    state.timestamp = new Date().toISOString();
+    saveState(state, stateFile);
+
+    // Re-read YAML to pick up new tasks added while running
+    if (options.reloadConfigs) {
+      try {
+        currentConfigs = options.reloadConfigs();
+        // Re-validate DAG with new configs
+        const newDagError = validateDag(currentConfigs);
+        if (newDagError) {
+          options.log?.(`\x1b[33m⚠ DAG error in updated YAML, ignoring reload: ${newDagError}\x1b[0m`);
+          currentConfigs = configs; // revert to original
+        }
+      } catch {
+        // If reload fails (e.g. YAML syntax error mid-edit), keep current list
+      }
+    }
+
     // Brief pause between jobs
-    if (i < configs.length - 1) {
+    const nextNotDone = currentConfigs.filter(c => !(taskKey(c) in state.completed));
+    const nextReady = nextNotDone.filter(c => depsReady(c, state.completed) === "ready");
+    if (nextReady.length > 0) {
       await sleep(1000);
     }
   }
 
+  // Collect results in original order
+  const results = currentConfigs
+    .map(c => state.completed[taskKey(c)])
+    .filter((r): r is JobResult => r !== undefined);
+
   // Clean up state file on completion
   clearState(stateFile);