bugzero 0.0.41 → 0.0.42

package/README.md

@@ -102,6 +102,7 @@ bugzero rescue
 - **Backups on every patch.** Each file BugZero modifies gets a `.opspilot.bak` copy of its original content first.
 - **Dry-run mode.** `bugzero rescue --dry-run` runs validation and error analysis, but makes no fix attempts and never modifies your source files (it still writes a report that diagnoses the failures it found). It exits with code 1 if it found failures and 0 if everything already passes, so you can use it as a check in scripts.
 - **Prompt size limits.** Very long error output and very large source files are shortened before being sent to the model (for logs, the start and end are kept), so a big failure can't exceed the model's context window or waste tokens.
+- **Command timeouts.** `--timeout <seconds>` (available on both `hunt` and `rescue`) stops any build, lint, or test command that runs longer than that. It kills the whole process tree rather than just the shell, so a hung test run cannot linger in the background, and the step is reported as failed along with whatever output it produced. Without it, a command that hangs will hang BugZero too, so it is worth setting in CI.
 
 ### Project awareness
 
@@ -190,7 +191,7 @@ OPENROUTER_API_KEY=your_openrouter_api_key_here
 ## Commands
 
 ### `bugzero hunt`
-Run build, lint, and test checks. Reports all failures without modifying any files.
+Run build, lint, and test checks. Reports all failures without modifying any files. Accepts `--timeout <seconds>`, like `rescue`.
 
 ```bash
 bugzero hunt --path /path/to/your/project
@@ -210,6 +211,7 @@ bugzero rescue --path /path/to/your/project
 |---|---|---|---|
 | `--path <dir>` | `-p` | `.` | Path to the target project |
 | `--max-attempts <n>` | `-n` | `3` | Maximum AI fix iterations before giving up |
+| `--timeout <seconds>` | `-t` | none | Stop any build, lint, or test command that runs longer than this many seconds |
 | `--dry-run` | | `false` | Analyze only — no files will be written |
 
 </details>

package/dist/index.js

@@ -479,9 +479,9 @@ var require_dist2 = __commonJS({
     });
     module2.exports = __toCommonJS(index_exports);
     var import_fs2 = __toESM2(require("fs"));
-    var import_path2 = __toESM2(require("path"));
-    var import_fs3 = __toESM2(require("fs"));
     var import_path3 = __toESM2(require("path"));
+    var import_fs3 = __toESM2(require("fs"));
+    var import_path2 = __toESM2(require("path"));
     var VALID_MANAGERS = ["npm", "pnpm", "yarn", "bun"];
     var LOCKFILE_MANAGERS = [
       { file: "pnpm-workspace.yaml", manager: "pnpm" },
@@ -493,7 +493,7 @@ var require_dist2 = __commonJS({
     ];
     function detectPackageManager3(cwd = process.cwd()) {
       try {
-        const pkgPath = import_path3.default.join(cwd, "package.json");
+        const pkgPath = import_path2.default.join(cwd, "package.json");
         if (import_fs3.default.existsSync(pkgPath)) {
           const pkg = JSON.parse(import_fs3.default.readFileSync(pkgPath, "utf-8"));
           if (typeof pkg.packageManager === "string") {
@@ -506,39 +506,76 @@ var require_dist2 = __commonJS({
       } catch {
       }
       for (const { file, manager } of LOCKFILE_MANAGERS) {
-        if (import_fs3.default.existsSync(import_path3.default.join(cwd, file))) return manager;
+        if (import_fs3.default.existsSync(import_path2.default.join(cwd, file))) return manager;
       }
       return "npm";
     }
     function getRunScriptCommand(manager, script) {
       return `${manager} run ${script}`;
     }
-    async function runCommand(command, cwd) {
+    var import_child_process = require("child_process");
+    var import_path22 = __toESM2(require("path"));
+    var import_tree_kill = __toESM2(require("tree-kill"));
+    function killProcessTree(pid) {
+      if (process.platform === "win32") {
+        const systemRoot = process.env.SystemRoot ?? process.env.windir ?? "C:\\Windows";
+        const taskkill = import_path22.default.join(systemRoot, "System32", "taskkill.exe");
+        (0, import_child_process.spawnSync)(taskkill, ["/pid", String(pid), "/T", "/F"], { stdio: "ignore", windowsHide: true });
+        return;
+      }
+      (0, import_tree_kill.default)(pid, "SIGKILL");
+    }
+    var KILL_GRACE_MS = 5e3;
+    async function runCommand(command, cwd, options = {}) {
       const { execa } = await import("execa");
-      try {
-        const result = await execa(command, {
-          shell: true,
-          cwd: cwd ?? process.cwd(),
-          all: true,
-          env: {
-            ...process.env,
-            CI: "true"
-          }
-        });
-        return {
-          success: true,
-          output: result.all ?? result.stdout
-        };
-      } catch (err) {
+      const subprocess = execa(command, {
+        shell: true,
+        cwd: cwd ?? process.cwd(),
+        all: true,
+        env: {
+          ...process.env,
+          CI: "true"
+        }
+      });
+      const timedOutResult = (output, confirmedStopped) => {
+        const seconds = options.timeoutMs / 1e3;
+        const note = confirmedStopped ? "and was stopped" : "and could not be confirmed stopped";
         return {
           success: false,
-          output: err.all ?? err.stderr ?? err.stdout ?? err.message
+          timedOut: true,
+          output: `${output}
+
+[BugZero] Command timed out after ${seconds}s ${note}: ${command}`
         };
+      };
+      let timedOut = false;
+      let timer;
+      let graceTimer;
+      const gaveUp = new Promise((resolve) => {
+        if (options.timeoutMs === void 0) return;
+        timer = setTimeout(() => {
+          timedOut = true;
+          if (subprocess.pid !== void 0) killProcessTree(subprocess.pid);
+          graceTimer = setTimeout(() => resolve(timedOutResult("", false)), KILL_GRACE_MS);
+        }, options.timeoutMs);
+      });
+      const finished = subprocess.then(
+        (result) => ({ success: true, output: result.all ?? result.stdout }),
+        (err) => {
+          const output = err.all ?? err.stderr ?? err.stdout ?? err.message;
+          return timedOut ? timedOutResult(output, true) : { success: false, output };
+        }
+      );
+      try {
+        return await Promise.race([finished, gaveUp]);
+      } finally {
+        clearTimeout(timer);
+        clearTimeout(graceTimer);
       }
     }
     function readScripts(cwd = process.cwd()) {
       try {
-        const pkgPath = import_path2.default.join(cwd, "package.json");
+        const pkgPath = import_path3.default.join(cwd, "package.json");
         if (!import_fs2.default.existsSync(pkgPath)) return [];
         const pkg = JSON.parse(import_fs2.default.readFileSync(pkgPath, "utf-8"));
         if (typeof pkg.scripts !== "object" || pkg.scripts === null) return [];
@@ -547,15 +584,15 @@ var require_dist2 = __commonJS({
         return [];
       }
     }
-    async function runScript(script, cwd) {
+    async function runScript(script, cwd, options) {
       if (!readScripts(cwd).includes(script)) {
         return { success: true, output: "", skipped: true };
       }
-      return runCommand(getRunScriptCommand(detectPackageManager3(cwd), script), cwd);
+      return runCommand(getRunScriptCommand(detectPackageManager3(cwd), script), cwd, options);
     }
-    var runBuild = (cwd) => runScript("build", cwd);
-    var runLint = (cwd) => runScript("lint", cwd);
-    var runTests = (cwd) => runScript("test", cwd);
+    var runBuild = (cwd, options) => runScript("build", cwd, options);
+    var runLint = (cwd, options) => runScript("lint", cwd, options);
+    var runTests = (cwd, options) => runScript("test", cwd, options);
     var TS_ERROR_RE = /^(.+)\((\d+),(\d+)\):\s+error\s+TS\d+:\s+(.+)$/gm;
     var ESLINT_ERROR_RE = /^\s+(\d+):(\d+)\s+error\s+(.+)$/gm;
     var JEST_FAIL_RE = /● (.+)/g;
@@ -610,7 +647,7 @@ var require_dist2 = __commonJS({
       { step: "lint", label: "lint", run: runLint },
       { step: "test", label: "tests", run: runTests }
     ];
-    async function runValidationPipeline(cwd) {
+    async function runValidationPipeline(cwd, options) {
       const targetCwd = cwd ?? process.cwd();
       const scripts = readScripts(targetCwd);
       let ranAnyStep = false;
@@ -621,7 +658,7 @@ var require_dist2 = __commonJS({
         }
         ranAnyStep = true;
         console.log(`[BugZero] Running ${label}...`);
-        const result = await run(targetCwd);
+        const result = await run(targetCwd, options);
         if (!result.success) {
           return { success: false, step, output: result.output };
         }
@@ -1307,6 +1344,11 @@ var require_dist6 = __commonJS({
       completionTokens: (0, import_langgraph.Annotation)({
         reducer: (old, value) => old + value,
         default: () => 0
+      }),
+      /** Per-command timeout in milliseconds for validation steps (undefined = no limit) */
+      timeoutMs: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => void 0
       })
     });
     var import_ai_provider = require_dist3();
@@ -1387,7 +1429,7 @@ Any other files from that same suggestion were rolled back to keep the change at
         };
       }
       console.log("[BugZero] Re-running validation pipeline to verify fix\u2026");
-      const result = await (0, import_analyzers.runValidationPipeline)(state.cwd);
+      const result = await (0, import_analyzers.runValidationPipeline)(state.cwd, { timeoutMs: state.timeoutMs });
       if (result.success) {
         console.log("[BugZero] \u2705 Validation succeeded!");
       } else {
@@ -1456,7 +1498,8 @@ var require_dist7 = __commonJS({
       detectPackageManager: () => import_analyzers2.detectPackageManager,
       orchestrate: () => orchestrate2,
       orchestrateAndFix: () => orchestrateAndFix2,
-      resolveMaxAttempts: () => resolveMaxAttempts2
+      resolveMaxAttempts: () => resolveMaxAttempts2,
+      resolveTimeoutMs: () => resolveTimeoutMs2
     });
     module2.exports = __toCommonJS(index_exports);
     var import_fs2 = __toESM2(require("fs"));
@@ -1537,6 +1580,13 @@ Re-run without \`--dry-run\` to let BugZero attempt a fix.
 `;
     }
     var DEFAULT_MAX_ATTEMPTS = 3;
+    function resolveTimeoutMs2(seconds) {
+      if (seconds === void 0) return void 0;
+      if (!Number.isFinite(seconds) || seconds <= 0) {
+        throw new Error(`--timeout must be a positive number of seconds (received ${seconds}).`);
+      }
+      return Math.round(seconds * 1e3);
+    }
     function resolveMaxAttempts2(value) {
       const attempts = value ?? DEFAULT_MAX_ATTEMPTS;
       if (!Number.isInteger(attempts) || attempts < 1) {
@@ -1559,10 +1609,11 @@ Re-run without \`--dry-run\` to let BugZero attempt a fix.
     async function orchestrate2(options = {}) {
       const cwd = options.cwd ?? process.cwd();
       assertNodeProject(cwd);
+      const timeoutMs = resolveTimeoutMs2(options.timeoutSeconds);
       const [build, lint, test] = await Promise.all([
-        (0, import_analyzers.runBuild)(cwd),
-        (0, import_analyzers.runLint)(cwd),
-        (0, import_analyzers.runTests)(cwd)
+        (0, import_analyzers.runBuild)(cwd, { timeoutMs }),
+        (0, import_analyzers.runLint)(cwd, { timeoutMs }),
+        (0, import_analyzers.runTests)(cwd, { timeoutMs })
       ]);
       await writeReport(cwd, "hunt", {
         success: build.success && lint.success && test.success,
@@ -1576,8 +1627,9 @@ Re-run without \`--dry-run\` to let BugZero attempt a fix.
       const cwd = options.cwd ?? process.cwd();
       assertNodeProject(cwd);
       const maxAttempts = resolveMaxAttempts2(options.maxAttempts);
+      const timeoutMs = resolveTimeoutMs2(options.timeoutSeconds);
       console.log(`[BugZero] Running validation pipeline in: ${cwd}`);
-      const pipelineResult = await (0, import_analyzers.runValidationPipeline)(cwd);
+      const pipelineResult = await (0, import_analyzers.runValidationPipeline)(cwd, { timeoutMs });
       if (pipelineResult.success) {
         console.log("[BugZero] Validation already passing \u2014 nothing to fix.");
         await writeReport(cwd, "rescue", {
@@ -1610,7 +1662,8 @@ Re-run without \`--dry-run\` to let BugZero attempt a fix.
       const finalState = await (0, import_agents.runRepairWorkflow)({
         cwd,
         logs: pipelineResult.output,
-        maxAttempts
+        maxAttempts,
+        timeoutMs
       });
       const result = {
         success: finalState.success,
@@ -1928,20 +1981,29 @@ function buildRescueSummary(result, options) {
 
 // src/index.ts
 var { version } = JSON.parse(import_fs.default.readFileSync(import_path.default.join(__dirname, "..", "package.json"), "utf-8"));
+var TIMEOUT_DESCRIPTION = "Stop any build/lint/test command that runs longer than this many seconds";
+function parseTimeout(raw) {
+  if (raw === void 0) return void 0;
+  const seconds = Number(raw);
+  (0, import_core.resolveTimeoutMs)(seconds);
+  return seconds;
+}
 var program = new import_commander.Command();
 program.name("bugzero").description("AI-powered build issue fixer \u2014 detects and repairs build errors automatically").version(version);
-program.command("hunt").description("Run build, lint, and tests \u2014 report issues without modifying files").option("-p, --path <dir>", "Path to the target project", ".").action(async (opts) => {
+program.command("hunt").description("Run build, lint, and tests \u2014 report issues without modifying files").option("-p, --path <dir>", "Path to the target project", ".").option("-t, --timeout <seconds>", TIMEOUT_DESCRIPTION).action(async (opts) => {
   try {
     const cwd = import_path.default.resolve(opts.path);
+    const timeoutSeconds = parseTimeout(opts.timeout);
     const framework = (0, import_core.detectFramework)(cwd);
     const packageManager = (0, import_core.detectPackageManager)(cwd);
     console.log(`
 \u{1F50D} BugZero \u2014 Analyzing project`);
     console.log(`   Path:      ${cwd}`);
     console.log(`   Framework: ${framework}`);
-    console.log(`   Package manager: ${packageManager}
-`);
-    const { build, lint, test } = await (0, import_core.orchestrate)({ cwd });
+    console.log(`   Package manager: ${packageManager}`);
+    if (timeoutSeconds !== void 0) console.log(`   Timeout:   ${timeoutSeconds}s per command`);
+    console.log();
+    const { build, lint, test } = await (0, import_core.orchestrate)({ cwd, timeoutSeconds });
     console.log("\u2500\u2500 Pipeline Summary \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     const label = (r) => r.skipped ? "\u23ED\uFE0F  Skipped (no script)" : r.success ? "\u2705 Passed" : "\u274C Failed (see report)";
     console.log(`   Build: ${label(build)}`);
@@ -1959,10 +2021,11 @@ ${allPassed ? "\u2705 All checks passed" : "\u274C Issues found \u2014 run 'bugz
     process.exit(1);
   }
 });
-program.command("rescue").description("Detect build failures and automatically apply AI-generated fixes").option("-p, --path <dir>", "Path to the target project", ".").option("-n, --max-attempts <number>", "Maximum AI fix attempts", "3").option("--dry-run", "Analyse only \u2014 print what would be fixed without writing files", false).action(async (opts) => {
+program.command("rescue").description("Detect build failures and automatically apply AI-generated fixes").option("-p, --path <dir>", "Path to the target project", ".").option("-n, --max-attempts <number>", "Maximum AI fix attempts", "3").option("-t, --timeout <seconds>", TIMEOUT_DESCRIPTION).option("--dry-run", "Analyse only \u2014 print what would be fixed without writing files", false).action(async (opts) => {
   try {
     const cwd = import_path.default.resolve(opts.path);
     const maxAttempts = (0, import_core.resolveMaxAttempts)(Number(opts.maxAttempts));
+    const timeoutSeconds = parseTimeout(opts.timeout);
     const dryRun = opts.dryRun;
     const framework = (0, import_core.detectFramework)(cwd);
     const packageManager = (0, import_core.detectPackageManager)(cwd);
@@ -1972,9 +2035,10 @@ program.command("rescue").description("Detect build failures and automatically a
     console.log(`   Framework:   ${framework}`);
     console.log(`   Package manager: ${packageManager}`);
     console.log(`   Max attempts: ${maxAttempts}`);
+    if (timeoutSeconds !== void 0) console.log(`   Timeout:     ${timeoutSeconds}s per command`);
     if (dryRun) console.log(`   Mode:        DRY RUN (no files will be modified)`);
     console.log();
-    const result = await (0, import_core.orchestrateAndFix)({ cwd, maxAttempts, dryRun });
+    const result = await (0, import_core.orchestrateAndFix)({ cwd, maxAttempts, dryRun, timeoutSeconds });
     console.log("\n\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500");
     const summary = buildRescueSummary(result, { dryRun });
     for (const line of summary.lines) console.log(line);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bugzero",
-  "version": "0.0.41",
+  "version": "0.0.42",
   "description": "Autonomous AI-powered CLI and GitHub Action that detects build, lint, and test failures, generates multi-file patches, applies them atomically with fuzzy matching, and re-verifies until your project is green.",
   "license": "MIT",
   "author": "Saksham Agarwal (https://github.com/Saksham1800t)",
@@ -48,7 +48,8 @@
     "@langchain/langgraph": "^1.3.2",
     "axios": "^1.16.1",
     "commander": "^15.0.0",
-    "execa": "^7.2.0"
+    "execa": "^7.2.0",
+    "tree-kill": "^1.2.2"
   },
   "devDependencies": {
     "@opspilot/agents": "workspace:*",