bugzero 0.0.1 → 0.0.4

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> bugzero@0.0.1 build D:\WD projects\OpsPilot\packages\cli
+> bugzero@0.0.4 build D:\WD projects\OpsPilot\packages\cli
 > tsup src/index.ts --format esm --dts
 
 CLI Building entry: src/index.ts
@@ -7,8 +7,10 @@
 CLI tsup v8.5.1
 CLI Target: es2022
 ESM Build start
-ESM dist\index.js 41.55 KB
-ESM ⚡️ Build success in 165ms
+ESM dist\index.js          31.38 KB
+ESM dist\chunk-4ANZDGVD.js 16.11 KB
+ESM dist\dist-FQYNA36C.js  85.00 B
+ESM ⚡️ Build success in 133ms
 DTS Build start
-DTS ⚡️ Build success in 1740ms
+DTS ⚡️ Build success in 1828ms
 DTS dist\index.d.ts 20.00 B

package/README.md

@@ -0,0 +1,165 @@
+# 🚀 BugZero
+
+[![npm version](https://img.shields.io/npm/v/bugzero.svg?style=flat-square&color=FF69B4)](https://www.npmjs.com/package/bugzero)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg?style=flat-square)](https://opensource.org/licenses/MIT)
+[![pnpm](https://img.shields.io/badge/maintained%20with-pnpm-cc00ff.svg?style=flat-square)](https://pnpm.io/)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](https://github.com/Saksham1800t)
+
+**BugZero** is an autonomous, AI-powered self-healing command-line tool. It monitors build, lint, and test errors in your project, analyzes them using an LLM, generates precise surgical code patches, applies them safely, and runs validation loops recursively until your build is completely green.
+
+Designed for modern developer loops, CI/CD pipelines, and automated hotfixes.
+
+---
+
+## 🛠️ How it Works
+
+```
+bugzero rescue
+      │
+      ▼
+ Run Build + Lint + Tests
+      │
+      ▼
+ Any failures? ──── No ──▶ ✅ Exit cleanly
+      │
+     Yes
+      │
+      ▼
+ Capture error logs
+      │
+      ▼
+ Prompt LLM via LangGraph
+      │
+      ▼
+ Parse fix suggestion (JSON)
+      │
+      ▼
+ Apply search-and-replace patch
+      │
+      ▼
+ Re-run build to verify
+      │
+      ▼
+ Build fixed? ─── Yes ──▶ ✅ Print fix details & Exit
+      │
+      No
+      │
+      ▼
+ Max attempts reached? ── Yes ──▶ ❌ Exit with logs
+      │
+      No
+      │
+      └──────────────────▶ Prompt LLM again (loop)
+```
+
+---
+
+## 🌟 Key Features
+
+*   **🔍 Automatic Framework Detection**: Detects common web frameworks and tooling setups inside your target directories.
+*   **🤖 LangGraph-Based Feedback Loop**: Employs stateful graphs to analyze compiler/test outputs, write minimal patches, and re-run compilation checks recursively.
+*   **⚡ Surgical Search-and-Replace**: Avoids corrupting files by using highly specific search-and-replace strings generated directly from the abstract syntax context.
+*   **📦 Safe Backups**: Creates a backup `.bugzero.bak` for every modified file so you can revert modifications easily.
+*   **📈 Multiple Checkups**: Validates builds, style guidelines (ESLint), and testing frameworks (Jest) automatically.
+
+---
+
+## 🚀 Getting Started
+
+### 1. Global Installation
+Install `bugzero` globally from NPM:
+```bash
+npm install -g bugzero
+```
+
+### 2. Configure Environment Variables
+BugZero relies on OpenRouter to access AI models (such as DeepSeek, Claude, Gemini, or GPT-4o). Configure your environment variable in your terminal session or add it to a `.env` file at the root of the project you are fixing:
+
+**On macOS/Linux:**
+```bash
+export OPENROUTER_API_KEY="your_openrouter_api_key_here"
+```
+
+**On Windows (PowerShell):**
+```powershell
+$env:OPENROUTER_API_KEY="your_openrouter_api_key_here"
+```
+
+---
+
+## 💻 Usage & Commands
+
+Run `bugzero` from any terminal directory.
+
+### 1. Hunt for Bugs (Dry-Run / Safe Check)
+Run build, lint, and test checks to report error diagnostics without modifying any files.
+```bash
+bugzero hunt --path /path/to/your/project
+```
+
+### 2. Rescue Your Project (Autonomous Mode)
+Run the AI repair loop to automatically detect compilation errors, generate code patches, apply them, and verify the build.
+```bash
+bugzero rescue --path /path/to/your/project
+```
+
+### 3. Vibe With a Brain (Change AI Model)
+List and select which LLM model you want to use. This fetches the latest available models from OpenRouter, lets you pick one, and saves it inside `.bugzerorc`.
+```bash
+bugzero vibe
+```
+
+### CLI Command Options
+
+| Option | Shorthand | Description | Default |
+| :--- | :--- | :--- | :--- |
+| `--path <dir>` | `-p <dir>` | The path to the target project you want to check/fix | `.` (Current directory) |
+| `--max-attempts <num>` | `-n <num>` | Maximum AI fix loops/attempts before giving up | `3` |
+| `--dry-run` | | Print the recommended fixes without saving changes to files | `false` |
+
+---
+
+## 🧱 Monorepo Development & Local Setup
+
+If you want to contribute to the BugZero engine:
+
+### Prerequisites
+*   Node.js (LTS version recommended)
+*   `pnpm` (workspace manager)
+
+### Installation
+Clone the repository, go into the workspace root, and run:
+```bash
+pnpm install
+```
+
+### Local Commands
+*   **Build all monorepo packages**:
+    ```bash
+    pnpm build
+    ```
+*   **Run CLI locally in development mode (shortcuts)**:
+    ```bash
+    pnpm hunt --path ./demo-project
+    pnpm rescue --path ./demo-project
+    pnpm vibe
+    ```
+
+---
+
+## 👥 Author
+
+Made with ❤️ and 😎 by:
+
+*   **Name**: Saksham Agarwal
+*   **Email**: [sakshamagarwal0507@gmail.com](mailto:sakshamagarwal0507@gmail.com)
+*   **GitHub**: [@Saksham1800t](https://github.com/Saksham1800t)
+*   **LinkedIn**: [Saksham Agarwal](https://www.linkedin.com/in/saksham-agarwal-/)
+
+---
+
+## ☕ Support My Work
+
+If BugZero saved you debugging hours in production or deployment pipelines, support the project!
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/saksham_)

package/dist/chunk-4ANZDGVD.js

@@ -0,0 +1,426 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+var __commonJS = (cb, mod) => function __require2() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// ../../node_modules/.pnpm/dotenv@17.4.2/node_modules/dotenv/lib/main.js
+var require_main = __commonJS({
+  "../../node_modules/.pnpm/dotenv@17.4.2/node_modules/dotenv/lib/main.js"(exports, module) {
+    "use strict";
+    var fs = __require("fs");
+    var path = __require("path");
+    var os = __require("os");
+    var crypto = __require("crypto");
+    var TIPS = [
+      "\u25C8 encrypted .env [www.dotenvx.com]",
+      "\u25C8 secrets for agents [www.dotenvx.com]",
+      "\u2301 auth for agents [www.vestauth.com]",
+      "\u2318 custom filepath { path: '/custom/path/.env' }",
+      "\u2318 enable debugging { debug: true }",
+      "\u2318 override existing { override: true }",
+      "\u2318 suppress logs { quiet: true }",
+      "\u2318 multiple files { path: ['.env.local', '.env'] }"
+    ];
+    function _getRandomTip() {
+      return TIPS[Math.floor(Math.random() * TIPS.length)];
+    }
+    function parseBoolean(value) {
+      if (typeof value === "string") {
+        return !["false", "0", "no", "off", ""].includes(value.toLowerCase());
+      }
+      return Boolean(value);
+    }
+    function supportsAnsi() {
+      return process.stdout.isTTY;
+    }
+    function dim(text) {
+      return supportsAnsi() ? `\x1B[2m${text}\x1B[0m` : text;
+    }
+    var LINE = /(?:^|^)\s*(?:export\s+)?([\w.-]+)(?:\s*=\s*?|:\s+?)(\s*'(?:\\'|[^'])*'|\s*"(?:\\"|[^"])*"|\s*`(?:\\`|[^`])*`|[^#\r\n]+)?\s*(?:#.*)?(?:$|$)/mg;
+    function parse(src) {
+      const obj = {};
+      let lines = src.toString();
+      lines = lines.replace(/\r\n?/mg, "\n");
+      let match;
+      while ((match = LINE.exec(lines)) != null) {
+        const key = match[1];
+        let value = match[2] || "";
+        value = value.trim();
+        const maybeQuote = value[0];
+        value = value.replace(/^(['"`])([\s\S]*)\1$/mg, "$2");
+        if (maybeQuote === '"') {
+          value = value.replace(/\\n/g, "\n");
+          value = value.replace(/\\r/g, "\r");
+        }
+        obj[key] = value;
+      }
+      return obj;
+    }
+    function _parseVault(options) {
+      options = options || {};
+      const vaultPath = _vaultPath(options);
+      options.path = vaultPath;
+      const result = DotenvModule.configDotenv(options);
+      if (!result.parsed) {
+        const err = new Error(`MISSING_DATA: Cannot parse ${vaultPath} for an unknown reason`);
+        err.code = "MISSING_DATA";
+        throw err;
+      }
+      const keys = _dotenvKey(options).split(",");
+      const length = keys.length;
+      let decrypted;
+      for (let i = 0; i < length; i++) {
+        try {
+          const key = keys[i].trim();
+          const attrs = _instructions(result, key);
+          decrypted = DotenvModule.decrypt(attrs.ciphertext, attrs.key);
+          break;
+        } catch (error) {
+          if (i + 1 >= length) {
+            throw error;
+          }
+        }
+      }
+      return DotenvModule.parse(decrypted);
+    }
+    function _warn(message) {
+      console.error(`\u26A0 ${message}`);
+    }
+    function _debug(message) {
+      console.log(`\u2506 ${message}`);
+    }
+    function _log(message) {
+      console.log(`\u25C7 ${message}`);
+    }
+    function _dotenvKey(options) {
+      if (options && options.DOTENV_KEY && options.DOTENV_KEY.length > 0) {
+        return options.DOTENV_KEY;
+      }
+      if (process.env.DOTENV_KEY && process.env.DOTENV_KEY.length > 0) {
+        return process.env.DOTENV_KEY;
+      }
+      return "";
+    }
+    function _instructions(result, dotenvKey) {
+      let uri;
+      try {
+        uri = new URL(dotenvKey);
+      } catch (error) {
+        if (error.code === "ERR_INVALID_URL") {
+          const err = new Error("INVALID_DOTENV_KEY: Wrong format. Must be in valid uri format like dotenv://:key_1234@dotenvx.com/vault/.env.vault?environment=development");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        }
+        throw error;
+      }
+      const key = uri.password;
+      if (!key) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing key part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environment = uri.searchParams.get("environment");
+      if (!environment) {
+        const err = new Error("INVALID_DOTENV_KEY: Missing environment part");
+        err.code = "INVALID_DOTENV_KEY";
+        throw err;
+      }
+      const environmentKey = `DOTENV_VAULT_${environment.toUpperCase()}`;
+      const ciphertext = result.parsed[environmentKey];
+      if (!ciphertext) {
+        const err = new Error(`NOT_FOUND_DOTENV_ENVIRONMENT: Cannot locate environment ${environmentKey} in your .env.vault file.`);
+        err.code = "NOT_FOUND_DOTENV_ENVIRONMENT";
+        throw err;
+      }
+      return { ciphertext, key };
+    }
+    function _vaultPath(options) {
+      let possibleVaultPath = null;
+      if (options && options.path && options.path.length > 0) {
+        if (Array.isArray(options.path)) {
+          for (const filepath of options.path) {
+            if (fs.existsSync(filepath)) {
+              possibleVaultPath = filepath.endsWith(".vault") ? filepath : `${filepath}.vault`;
+            }
+          }
+        } else {
+          possibleVaultPath = options.path.endsWith(".vault") ? options.path : `${options.path}.vault`;
+        }
+      } else {
+        possibleVaultPath = path.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path.join(os.homedir(), envPath.slice(1)) : envPath;
+    }
+    function _configVault(options) {
+      const debug = parseBoolean(process.env.DOTENV_CONFIG_DEBUG || options && options.debug);
+      const quiet = parseBoolean(process.env.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (debug || !quiet) {
+        _log("loading env from encrypted .env.vault");
+      }
+      const parsed = DotenvModule._parseVault(options);
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      DotenvModule.populate(processEnv, parsed, options);
+      return { parsed };
+    }
+    function configDotenv(options) {
+      const dotenvPath = path.resolve(process.cwd(), ".env");
+      let encoding = "utf8";
+      let processEnv = process.env;
+      if (options && options.processEnv != null) {
+        processEnv = options.processEnv;
+      }
+      let debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || options && options.debug);
+      let quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || options && options.quiet);
+      if (options && options.encoding) {
+        encoding = options.encoding;
+      } else {
+        if (debug) {
+          _debug("no encoding is specified (UTF-8 is used by default)");
+        }
+      }
+      let optionPaths = [dotenvPath];
+      if (options && options.path) {
+        if (!Array.isArray(options.path)) {
+          optionPaths = [_resolveHome(options.path)];
+        } else {
+          optionPaths = [];
+          for (const filepath of options.path) {
+            optionPaths.push(_resolveHome(filepath));
+          }
+        }
+      }
+      let lastError;
+      const parsedAll = {};
+      for (const path2 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path2, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path2} ${e.message}`);
+          }
+          lastError = e;
+        }
+      }
+      const populated = DotenvModule.populate(processEnv, parsedAll, options);
+      debug = parseBoolean(processEnv.DOTENV_CONFIG_DEBUG || debug);
+      quiet = parseBoolean(processEnv.DOTENV_CONFIG_QUIET || quiet);
+      if (debug || !quiet) {
+        const keysCount = Object.keys(populated).length;
+        const shortPaths = [];
+        for (const filePath of optionPaths) {
+          try {
+            const relative = path.relative(process.cwd(), filePath);
+            shortPaths.push(relative);
+          } catch (e) {
+            if (debug) {
+              _debug(`failed to load ${filePath} ${e.message}`);
+            }
+            lastError = e;
+          }
+        }
+        _log(`injected env (${keysCount}) from ${shortPaths.join(",")} ${dim(`// tip: ${_getRandomTip()}`)}`);
+      }
+      if (lastError) {
+        return { parsed: parsedAll, error: lastError };
+      } else {
+        return { parsed: parsedAll };
+      }
+    }
+    function config(options) {
+      if (_dotenvKey(options).length === 0) {
+        return DotenvModule.configDotenv(options);
+      }
+      const vaultPath = _vaultPath(options);
+      if (!vaultPath) {
+        _warn(`you set DOTENV_KEY but you are missing a .env.vault file at ${vaultPath}`);
+        return DotenvModule.configDotenv(options);
+      }
+      return DotenvModule._configVault(options);
+    }
+    function decrypt(encrypted, keyStr) {
+      const key = Buffer.from(keyStr.slice(-64), "hex");
+      let ciphertext = Buffer.from(encrypted, "base64");
+      const nonce = ciphertext.subarray(0, 12);
+      const authTag = ciphertext.subarray(-16);
+      ciphertext = ciphertext.subarray(12, -16);
+      try {
+        const aesgcm = crypto.createDecipheriv("aes-256-gcm", key, nonce);
+        aesgcm.setAuthTag(authTag);
+        return `${aesgcm.update(ciphertext)}${aesgcm.final()}`;
+      } catch (error) {
+        const isRange = error instanceof RangeError;
+        const invalidKeyLength = error.message === "Invalid key length";
+        const decryptionFailed = error.message === "Unsupported state or unable to authenticate data";
+        if (isRange || invalidKeyLength) {
+          const err = new Error("INVALID_DOTENV_KEY: It must be 64 characters long (or more)");
+          err.code = "INVALID_DOTENV_KEY";
+          throw err;
+        } else if (decryptionFailed) {
+          const err = new Error("DECRYPTION_FAILED: Please check your DOTENV_KEY");
+          err.code = "DECRYPTION_FAILED";
+          throw err;
+        } else {
+          throw error;
+        }
+      }
+    }
+    function populate(processEnv, parsed, options = {}) {
+      const debug = Boolean(options && options.debug);
+      const override = Boolean(options && options.override);
+      const populated = {};
+      if (typeof parsed !== "object") {
+        const err = new Error("OBJECT_REQUIRED: Please check the processEnv argument being passed to populate");
+        err.code = "OBJECT_REQUIRED";
+        throw err;
+      }
+      for (const key of Object.keys(parsed)) {
+        if (Object.prototype.hasOwnProperty.call(processEnv, key)) {
+          if (override === true) {
+            processEnv[key] = parsed[key];
+            populated[key] = parsed[key];
+          }
+          if (debug) {
+            if (override === true) {
+              _debug(`"${key}" is already defined and WAS overwritten`);
+            } else {
+              _debug(`"${key}" is already defined and was NOT overwritten`);
+            }
+          }
+        } else {
+          processEnv[key] = parsed[key];
+          populated[key] = parsed[key];
+        }
+      }
+      return populated;
+    }
+    var DotenvModule = {
+      configDotenv,
+      _configVault,
+      _parseVault,
+      config,
+      decrypt,
+      parse,
+      populate
+    };
+    module.exports.configDotenv = DotenvModule.configDotenv;
+    module.exports._configVault = DotenvModule._configVault;
+    module.exports._parseVault = DotenvModule._parseVault;
+    module.exports.config = DotenvModule.config;
+    module.exports.decrypt = DotenvModule.decrypt;
+    module.exports.parse = DotenvModule.parse;
+    module.exports.populate = DotenvModule.populate;
+    module.exports = DotenvModule;
+  }
+});
+
+// ../config/dist/index.js
+var require_dist = __commonJS({
+  "../config/dist/index.js"(exports, module) {
+    var __create2 = Object.create;
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    var __getProtoOf2 = Object.getPrototypeOf;
+    var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+    var __export = (target, all) => {
+      for (var name in all)
+        __defProp2(target, name, { get: all[name], enumerable: true });
+    };
+    var __copyProps2 = (to, from, except, desc) => {
+      if (from && typeof from === "object" || typeof from === "function") {
+        for (let key of __getOwnPropNames2(from))
+          if (!__hasOwnProp2.call(to, key) && key !== except)
+            __defProp2(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc2(from, key)) || desc.enumerable });
+      }
+      return to;
+    };
+    var __toESM2 = (mod, isNodeMode, target) => (target = mod != null ? __create2(__getProtoOf2(mod)) : {}, __copyProps2(
+      // If the importer is in node compatibility mode or this is not an ESM
+      // file that has been converted to a CommonJS file using a Babel-
+      // compatible transform (i.e. "__esModule" has not been set), then set
+      // "default" to the CommonJS "module.exports" for node compatibility.
+      isNodeMode || !mod || !mod.__esModule ? __defProp2(target, "default", { value: mod, enumerable: true }) : target,
+      mod
+    ));
+    var __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      env: () => env,
+      getLocalConfig: () => getLocalConfig,
+      getSelectedModel: () => getSelectedModel,
+      saveLocalConfig: () => saveLocalConfig
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_dotenv = __toESM2(require_main());
+    import_dotenv.default.config();
+    var env = {
+      openRouterKey: process.env.OPENROUTER_API_KEY
+    };
+    var import_fs = __toESM2(__require("fs"));
+    var import_path = __toESM2(__require("path"));
+    var CONFIG_FILENAME = ".bugzerorc";
+    function getLocalConfig(cwd = process.cwd()) {
+      try {
+        const configPath = import_path.default.resolve(cwd, CONFIG_FILENAME);
+        if (import_fs.default.existsSync(configPath)) {
+          const content = import_fs.default.readFileSync(configPath, "utf-8");
+          return JSON.parse(content);
+        }
+      } catch (e) {
+      }
+      return {};
+    }
+    function saveLocalConfig(config, cwd = process.cwd()) {
+      const configPath = import_path.default.resolve(cwd, CONFIG_FILENAME);
+      import_fs.default.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    function getSelectedModel(cwd = process.cwd()) {
+      const config = getLocalConfig(cwd);
+      return config.model || "deepseek/deepseek-chat";
+    }
+  }
+});
+
+export {
+  __require,
+  __commonJS,
+  __toESM,
+  require_dist
+};

package/dist/dist-FQYNA36C.js

@@ -0,0 +1,4 @@
+import {
+  require_dist
+} from "./chunk-4ANZDGVD.js";
+export default require_dist();