@yail259/overnight 0.2.0 → 0.3.0

package/src/planner.ts

@@ -0,0 +1,238 @@
+import { query, type Options as ClaudeCodeOptions } from "@anthropic-ai/claude-agent-sdk";
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { execSync } from "child_process";
+import { stringify as stringifyYaml } from "yaml";
+import * as readline from "readline";
+import {
+  type GoalConfig,
+  DEFAULT_TOOLS,
+  DEFAULT_TIMEOUT,
+  DEFAULT_MAX_TURNS,
+  DEFAULT_MAX_ITERATIONS,
+  DEFAULT_CONVERGENCE_THRESHOLD,
+  DEFAULT_DENY_PATTERNS,
+} from "./types.js";
+
+type LogCallback = (msg: string) => void;
+
+// --- Claude executable ---
+
+let claudeExecutablePath: string | undefined;
+
+function findClaudeExecutable(): string | undefined {
+  if (claudeExecutablePath !== undefined) return claudeExecutablePath;
+  if (process.env.CLAUDE_CODE_PATH) {
+    claudeExecutablePath = process.env.CLAUDE_CODE_PATH;
+    return claudeExecutablePath;
+  }
+  try {
+    const cmd = process.platform === "win32" ? "where claude" : "which claude";
+    claudeExecutablePath = execSync(cmd, { encoding: "utf-8" }).trim().split("\n")[0];
+    return claudeExecutablePath;
+  } catch {
+    const commonPaths = [
+      "/usr/local/bin/claude",
+      "/opt/homebrew/bin/claude",
+      `${process.env.HOME}/.local/bin/claude`,
+    ];
+    for (const p of commonPaths) {
+      if (existsSync(p)) {
+        claudeExecutablePath = p;
+        return claudeExecutablePath;
+      }
+    }
+  }
+  return undefined;
+}
+
+// --- Interactive prompting ---
+
+function createReadline(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+}
+
+function ask(rl: readline.Interface, question: string): Promise<string> {
+  return new Promise((resolve) => {
+    rl.question(question, (answer) => resolve(answer.trim()));
+  });
+}
+
+// --- Planner ---
+
+const PLANNER_SYSTEM_PROMPT = `You are an expert software architect helping plan an autonomous overnight build.
+
+Your job is to have a focused design conversation with the user, then produce a goal.yaml file that an autonomous build agent will use to implement the project overnight.
+
+Guidelines:
+- Ask clarifying questions about scope, technology choices, priorities, and constraints
+- Keep the conversation focused and efficient — 3-5 rounds max
+- When you have enough information, produce the goal.yaml
+- The goal.yaml should be specific enough for an agent to work autonomously
+- Include concrete acceptance criteria that can be verified
+- Include verification commands when possible (build, test, lint)
+- Set realistic constraints
+
+When you're ready to produce the final plan, output it in this format:
+
+\`\`\`yaml
+goal: "Clear description of what to build"
+
+acceptance_criteria:
+  - "Specific, verifiable criterion 1"
+  - "Specific, verifiable criterion 2"
+
+verification_commands:
+  - "npm run build"
+  - "npm test"
+
+constraints:
+  - "Don't modify existing API contracts"
+
+max_iterations: 15
+convergence_threshold: 3
+
+defaults:
+  timeout_seconds: 600
+  allowed_tools:
+    - Read
+    - Edit
+    - Write
+    - Glob
+    - Grep
+    - Bash
+  security:
+    sandbox_dir: "."
+    max_turns: 150
+\`\`\`
+
+IMPORTANT: Only output the yaml block when you and the user agree the plan is ready. Before that, ask questions and discuss.`;
+
+export async function runPlanner(
+  initialGoal: string,
+  options: {
+    outputFile?: string;
+    log?: LogCallback;
+  } = {}
+): Promise<GoalConfig | null> {
+  const log = options.log ?? ((msg: string) => console.log(msg));
+  const outputFile = options.outputFile ?? "goal.yaml";
+  const claudePath = findClaudeExecutable();
+
+  if (!claudePath) {
+    log("\x1b[31m✗ Error: Could not find 'claude' CLI.\x1b[0m");
+    return null;
+  }
+
+  log("\x1b[1movernight plan: Interactive design session\x1b[0m");
+  log("\x1b[2mDescribe your goal and I'll help shape it into a plan.\x1b[0m");
+  log("\x1b[2mType 'done' to finalize, 'quit' to abort.\x1b[0m\n");
+
+  const rl = createReadline();
+  const conversationHistory: Array<{ role: "user" | "assistant"; content: string }> = [];
+
+  // First turn: send the initial goal to the planner
+  let currentPrompt = `The user wants to plan the following project for an overnight autonomous build:\n\n${initialGoal}\n\nAsk clarifying questions to understand scope, tech choices, priorities, and constraints. Be concise.`;
+
+  try {
+    let sessionId: string | undefined;
+
+    for (let round = 0; round < 10; round++) {
+      // Run Claude
+      const sdkOptions: ClaudeCodeOptions = {
+        allowedTools: ["Read", "Glob", "Grep"],  // Read-only for planning
+        systemPrompt: PLANNER_SYSTEM_PROMPT,
+        permissionMode: "acceptEdits",
+        pathToClaudeCodeExecutable: claudePath,
+        ...(sessionId && { resume: sessionId }),
+      };
+
+      let result: string | undefined;
+
+      const conversation = query({ prompt: currentPrompt, options: sdkOptions });
+      for await (const message of conversation) {
+        if (message.type === "result") {
+          sessionId = message.session_id;
+          if (message.subtype === "success") {
+            result = message.result;
+          }
+        } else if (message.type === "system" && "subtype" in message) {
+          if (message.subtype === "init") {
+            sessionId = message.session_id;
+          }
+        }
+      }
+
+      if (!result) {
+        log("\x1b[31m✗ No response from planner\x1b[0m");
+        break;
+      }
+
+      conversationHistory.push({ role: "assistant", content: result });
+
+      // Check if the planner produced a goal.yaml
+      const yamlMatch = result.match(/```yaml\n([\s\S]*?)\n```/);
+      if (yamlMatch) {
+        // Show the plan
+        log("\n\x1b[1m━━━ Proposed Plan ━━━\x1b[0m\n");
+        log(yamlMatch[1]);
+        log("\n\x1b[1m━━━━━━━━━━━━━━━━━━━━\x1b[0m\n");
+
+        const answer = await ask(rl, "\x1b[36m?\x1b[0m Accept this plan? (yes/no/revise): ");
+
+        if (answer.toLowerCase() === "yes" || answer.toLowerCase() === "y") {
+          // Write the goal.yaml
+          writeFileSync(outputFile, yamlMatch[1]);
+          log(`\n\x1b[32m✓ Plan saved to ${outputFile}\x1b[0m`);
+          log(`Run with: \x1b[1movernight run ${outputFile}\x1b[0m`);
+          rl.close();
+
+          // Parse and return
+          const { parse: parseYaml } = await import("yaml");
+          return parseYaml(yamlMatch[1]) as GoalConfig;
+        } else if (answer.toLowerCase() === "quit" || answer.toLowerCase() === "q") {
+          log("\x1b[33mAborted\x1b[0m");
+          rl.close();
+          return null;
+        } else {
+          // User wants revisions
+          const revision = await ask(rl, "\x1b[36m?\x1b[0m What would you like to change? ");
+          currentPrompt = revision;
+          conversationHistory.push({ role: "user", content: revision });
+          continue;
+        }
+      }
+
+      // Show the assistant's response
+      log(`\n\x1b[2m─── Planner ───\x1b[0m\n`);
+      log(result);
+      log("");
+
+      // Get user input
+      const userInput = await ask(rl, "\x1b[36m>\x1b[0m ");
+
+      if (userInput.toLowerCase() === "done") {
+        // Ask the planner to finalize
+        currentPrompt = "The user is satisfied. Please produce the final goal.yaml now based on our discussion.";
+        conversationHistory.push({ role: "user", content: currentPrompt });
+        continue;
+      }
+
+      if (userInput.toLowerCase() === "quit" || userInput.toLowerCase() === "q") {
+        log("\x1b[33mAborted\x1b[0m");
+        rl.close();
+        return null;
+      }
+
+      currentPrompt = userInput;
+      conversationHistory.push({ role: "user", content: userInput });
+    }
+  } finally {
+    rl.close();
+  }
+
+  log("\x1b[33m⚠ Design session ended without producing a plan\x1b[0m");
+  return null;
+}

package/src/runner.ts

@@ -132,7 +132,7 @@ async function runWithTimeout<T>(
   promise: Promise<T>,
   timeoutMs: number
 ): Promise<T> {
-  let timeoutId: Timer;
+  let timeoutId: ReturnType<typeof setTimeout>;
   const timeoutPromise = new Promise<never>((_, reject) => {
     timeoutId = setTimeout(() => reject(new Error("TIMEOUT")), timeoutMs);
   });
@@ -191,8 +191,10 @@ async function collectResultWithProgress(
 
       // Handle different message types
       if (message.type === "result") {
-        result = message.result;
         sessionId = message.session_id;
+        if (message.subtype === "success") {
+          result = message.result;
+        }
       } 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> }> };
@@ -274,6 +276,8 @@ export async function runJob(
     logMsg(`\x1b[36m▶\x1b[0m ${taskPreview}`);
   }
 
+  let sessionId: string | undefined;
+
   for (let attempt = 0; attempt <= retryCount; attempt++) {
     try {
       // Build security hooks if security config provided
@@ -289,7 +293,6 @@ export async function runJob(
         ...(resumeSessionId && { resume: resumeSessionId }),
       };
 
-      let sessionId: string | undefined;
       let result: string | undefined;
 
       // Prompt: if resuming, ask to continue; otherwise use original prompt
@@ -465,7 +468,7 @@ export function taskHash(prompt: string): string {
 }
 
 function validateDag(configs: JobConfig[]): string | null {
-  const ids = new Set(configs.map(c => c.id).filter(Boolean));
+  const ids = new Set(configs.map(c => c.id).filter((id): id is string => Boolean(id)));
   // Check all depends_on references exist
   for (const c of configs) {
     for (const dep of c.depends_on ?? []) {

package/src/security.ts

@@ -49,7 +49,7 @@ export function createSecurityHooks(config: SecurityConfig) {
   // PreToolUse hook for path validation
   const preToolUseHook = async (
     input: Record<string, unknown>,
-    _toolUseId: string | null,
+    _toolUseId: string | undefined,
     _context: { signal?: AbortSignal }
   ) => {
     const hookEventName = input.hook_event_name as string;
@@ -80,8 +80,8 @@ export function createSecurityHooks(config: SecurityConfig) {
     if (sandboxDir && !isPathWithinSandbox(filePath, sandboxDir)) {
       return {
         hookSpecificOutput: {
-          hookEventName,
-          permissionDecision: "deny",
+          hookEventName: "PreToolUse" as const,
+          permissionDecision: "deny" as const,
           permissionDecisionReason: `Path "${filePath}" is outside sandbox directory "${sandboxDir}"`,
         },
       };
@@ -92,8 +92,8 @@ export function createSecurityHooks(config: SecurityConfig) {
     if (matchedPattern) {
       return {
         hookSpecificOutput: {
-          hookEventName,
-          permissionDecision: "deny",
+          hookEventName: "PreToolUse" as const,
+          permissionDecision: "deny" as const,
           permissionDecisionReason: `Path "${filePath}" matches deny pattern "${matchedPattern}"`,
         },
       };
@@ -105,7 +105,7 @@ export function createSecurityHooks(config: SecurityConfig) {
   // PostToolUse hook for audit logging
   const postToolUseHook = async (
     input: Record<string, unknown>,
-    _toolUseId: string | null,
+    _toolUseId: string | undefined,
     _context: { signal?: AbortSignal }
   ) => {
     if (!auditLog) return {};

package/src/types.ts

@@ -55,6 +55,51 @@ export interface TasksFile {
   tasks: (string | JobConfig)[];
 }
 
+// --- Goal mode types ---
+
+export interface GoalConfig {
+  goal: string;                      // High-level objective
+  acceptance_criteria?: string[];    // What must be true for the goal to be met
+  verification_commands?: string[];  // Commands that must exit 0 (e.g. "npm test", "npm run build")
+  constraints?: string[];            // Things the agent should NOT do
+  max_iterations?: number;           // Hard cap on build loop iterations
+  convergence_threshold?: number;    // Stalled iterations before stopping (default: 3)
+  defaults?: TasksFile["defaults"];  // Same defaults as tasks.yaml
+}
+
+export interface IterationState {
+  iteration: number;
+  completed_items: string[];
+  remaining_items: string[];
+  known_issues: string[];
+  files_modified: string[];
+  agent_done: boolean;               // Did the agent self-report "done"?
+  timestamp: string;
+}
+
+export interface GateCheck {
+  name: string;
+  passed: boolean;
+  output: string;
+}
+
+export interface GateResult {
+  passed: boolean;
+  checks: GateCheck[];
+  summary: string;
+  failures: string[];
+}
+
+export interface GoalRunState {
+  goal: string;
+  iterations: IterationState[];
+  gate_results: GateResult[];
+  status: "running" | "gate_passed" | "gate_failed" | "stalled" | "max_iterations";
+  timestamp: string;
+}
+
+// --- Constants ---
+
 export const DEFAULT_TOOLS = ["Read", "Edit", "Write", "Glob", "Grep"];
 export const DEFAULT_TIMEOUT = 300;
 export const DEFAULT_STALL_TIMEOUT = 120;
@@ -62,8 +107,11 @@ export const DEFAULT_RETRY_COUNT = 3;
 export const DEFAULT_RETRY_DELAY = 5;
 export const DEFAULT_VERIFY_PROMPT = "Review what you just implemented. Check for correctness, completeness, and compile errors. Fix any issues you find.";
 export const DEFAULT_STATE_FILE = ".overnight-state.json";
+export const DEFAULT_GOAL_STATE_FILE = ".overnight-goal-state.json";
 export const DEFAULT_NTFY_TOPIC = "overnight";
 export const DEFAULT_MAX_TURNS = 100;
+export const DEFAULT_MAX_ITERATIONS = 20;
+export const DEFAULT_CONVERGENCE_THRESHOLD = 3;
 export const DEFAULT_DENY_PATTERNS = [
   "**/.env",
   "**/.env.*",