bugzero 0.0.1

package/.turbo/turbo-build.log

@@ -0,0 +1,14 @@
+
+> bugzero@0.0.1 build D:\WD projects\OpsPilot\packages\cli
+> tsup src/index.ts --format esm --dts
+
+CLI Building entry: src/index.ts
+CLI Using tsconfig: tsconfig.json
+CLI tsup v8.5.1
+CLI Target: es2022
+ESM Build start
+ESM dist\index.js 41.55 KB
+ESM ⚡️ Build success in 165ms
+DTS Build start
+DTS ⚡️ Build success in 1740ms
+DTS dist\index.d.ts 20.00 B

package/dist/index.d.mts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,1028 @@
+#!/usr/bin/env node
+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 path2 = __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 = path2.resolve(process.cwd(), ".env.vault");
+      }
+      if (fs.existsSync(possibleVaultPath)) {
+        return possibleVaultPath;
+      }
+      return null;
+    }
+    function _resolveHome(envPath) {
+      return envPath[0] === "~" ? path2.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 = path2.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 path3 of optionPaths) {
+        try {
+          const parsed = DotenvModule.parse(fs.readFileSync(path3, { encoding }));
+          DotenvModule.populate(parsedAll, parsed, options);
+        } catch (e) {
+          if (debug) {
+            _debug(`failed to load ${path3} ${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 = path2.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) {
+    "use strict";
+    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
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_dotenv = __toESM2(require_main());
+    import_dotenv.default.config();
+    var env = {
+      openRouterKey: process.env.OPENROUTER_API_KEY
+    };
+  }
+});
+
+// ../analyzers/dist/index.js
+var require_dist2 = __commonJS({
+  "../analyzers/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      parseErrors: () => parseErrors,
+      runBuild: () => runBuild,
+      runCommand: () => runCommand,
+      runLint: () => runLint,
+      runTests: () => runTests
+    });
+    module.exports = __toCommonJS(index_exports);
+    async function runCommand(command, cwd) {
+      const { execa } = await import("execa");
+      try {
+        const result = await execa(command, {
+          shell: true,
+          cwd: cwd ?? process.cwd(),
+          all: true
+        });
+        return {
+          success: true,
+          output: result.all ?? result.stdout
+        };
+      } catch (err) {
+        return {
+          success: false,
+          output: err.all ?? err.stderr ?? err.stdout ?? err.message
+        };
+      }
+    }
+    var runBuild = (cwd) => runCommand("npm run build", cwd);
+    var runLint = (cwd) => runCommand("npm run lint", cwd);
+    var runTests = (cwd) => runCommand("npm run test", cwd);
+    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;
+    var JEST_FILE_RE = /FAIL\s+([\w/\\.\-]+)/g;
+    function parseErrors(output) {
+      const errors = [];
+      const tsMatches = [...output.matchAll(TS_ERROR_RE)];
+      for (const m of tsMatches) {
+        errors.push({
+          type: "typescript",
+          file: m[1].trim(),
+          line: parseInt(m[2], 10),
+          column: parseInt(m[3], 10),
+          message: m[4].trim(),
+          raw: m[0]
+        });
+      }
+      if (errors.length > 0) return errors;
+      const eslintMatches = [...output.matchAll(ESLINT_ERROR_RE)];
+      for (const m of eslintMatches) {
+        errors.push({
+          type: "eslint",
+          line: parseInt(m[1], 10),
+          column: parseInt(m[2], 10),
+          message: m[3].trim(),
+          raw: m[0]
+        });
+      }
+      if (errors.length > 0) return errors;
+      const jestFiles = [...output.matchAll(JEST_FILE_RE)].map((m) => m[1]);
+      const jestFails = [...output.matchAll(JEST_FAIL_RE)];
+      for (const m of jestFails) {
+        errors.push({
+          type: "jest",
+          file: jestFiles[0],
+          message: m[1].trim(),
+          raw: m[0]
+        });
+      }
+      if (errors.length > 0) return errors;
+      if (output.trim()) {
+        errors.push({
+          type: "unknown",
+          message: output.slice(0, 500),
+          raw: output
+        });
+      }
+      return errors;
+    }
+  }
+});
+
+// ../ai-provider/dist/index.js
+var require_dist3 = __commonJS({
+  "../ai-provider/dist/index.js"(exports, module) {
+    "use strict";
+    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, {
+      OpenRouterProvider: () => OpenRouterProvider
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_axios = __toESM2(__require("axios"));
+    var OpenRouterProvider = class {
+      async invoke(prompt) {
+        const response = await import_axios.default.post(
+          "https://openrouter.ai/api/v1/chat/completions",
+          {
+            model: "anthropic/claude-sonnet-4",
+            messages: [
+              {
+                role: "user",
+                content: prompt
+              }
+            ]
+          },
+          {
+            headers: {
+              Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}`,
+              "Content-Type": "application/json"
+            }
+          }
+        );
+        return response.data.choices[0].message.content;
+      }
+    };
+  }
+});
+
+// ../prompts/dist/index.js
+var require_dist4 = __commonJS({
+  "../prompts/dist/index.js"(exports, module) {
+    "use strict";
+    var __defProp2 = Object.defineProperty;
+    var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+    var __getOwnPropNames2 = Object.getOwnPropertyNames;
+    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 __toCommonJS = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+    var index_exports = {};
+    __export(index_exports, {
+      buildAnalysisPrompt: () => buildAnalysisPrompt
+    });
+    module.exports = __toCommonJS(index_exports);
+    function buildAnalysisPrompt(errorOutput, cwd) {
+      return `You are an expert software engineer specialising in fixing build, lint, and test failures.
+
+A project located at "${cwd}" failed to build. Here is the complete error output:
+
+\`\`\`
+${errorOutput}
+\`\`\`
+
+Your task:
+1. Identify the root cause.
+2. Locate the exact file and code that needs to change.
+3. Provide the minimal, precise fix.
+
+Reply with ONLY a valid JSON object in this exact shape \u2014 no markdown fences, no extra text:
+{
+  "rootCause": "One-sentence explanation of the error",
+  "filePath": "relative/path/from/project/root/to/file.ts",
+  "search": "exact code that currently exists in the file and must be replaced",
+  "replace": "the corrected code that replaces the search string",
+  "explanation": "short explanation of what you changed and why"
+}
+
+Critical rules:
+- "filePath" must be a relative path from the project root (no leading /).
+- "search" must be an EXACT character-for-character substring of the current file content.
+- "replace" must be syntactically valid code.
+- Do NOT add backticks, markdown, or any text outside the JSON object.`;
+    }
+  }
+});
+
+// ../patcher/dist/index.js
+var require_dist5 = __commonJS({
+  "../patcher/dist/index.js"(exports, module) {
+    "use strict";
+    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, {
+      applyPatch: () => applyPatch
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_fs = __toESM2(__require("fs"));
+    var import_path2 = __toESM2(__require("path"));
+    function applyPatch(absoluteFilePath, search, replace) {
+      try {
+        if (!import_fs.default.existsSync(absoluteFilePath)) {
+          return {
+            success: false,
+            error: `File not found: ${absoluteFilePath}`
+          };
+        }
+        const original = import_fs.default.readFileSync(absoluteFilePath, "utf-8");
+        if (!original.includes(search)) {
+          return {
+            success: false,
+            error: `Search string not found in ${import_path2.default.basename(absoluteFilePath)}. The AI's "search" field did not match file content.`
+          };
+        }
+        const backupPath = absoluteFilePath + ".opspilot.bak";
+        import_fs.default.writeFileSync(backupPath, original, "utf-8");
+        const fixed = original.replace(search, replace);
+        import_fs.default.writeFileSync(absoluteFilePath, fixed, "utf-8");
+        return { success: true, backupPath };
+      } catch (err) {
+        return { success: false, error: err.message };
+      }
+    }
+  }
+});
+
+// ../agents/dist/index.js
+var require_dist6 = __commonJS({
+  "../agents/dist/index.js"(exports, module) {
+    "use strict";
+    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, {
+      workflow: () => workflow
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_langgraph2 = __require("@langchain/langgraph");
+    var import_path2 = __toESM2(__require("path"));
+    var import_langgraph = __require("@langchain/langgraph");
+    var GraphState = import_langgraph.Annotation.Root({
+      /** Absolute path to the project being fixed */
+      cwd: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => process.cwd()
+      }),
+      /** Raw error output from the failing command */
+      logs: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => ""
+      }),
+      /** Full text response from the AI */
+      analysis: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => ""
+      }),
+      /** Structured fix parsed from the AI response */
+      fixSuggestion: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => null
+      }),
+      /** Number of fix attempts made so far */
+      attempts: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => 0
+      }),
+      /** Maximum allowed attempts before giving up */
+      maxAttempts: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => 3
+      }),
+      /** Whether the last build verification succeeded */
+      success: (0, import_langgraph.Annotation)({
+        reducer: (_, value) => value,
+        default: () => false
+      })
+    });
+    var import_ai_provider = require_dist3();
+    var import_prompts = require_dist4();
+    var import_patcher = require_dist5();
+    var import_analyzers = require_dist2();
+    var provider = new import_ai_provider.OpenRouterProvider();
+    async function analyzeNode(state) {
+      console.log(
+        `
+[OpsPilot] Attempt ${state.attempts + 1}/${state.maxAttempts} \u2014 asking AI\u2026`
+      );
+      const prompt = (0, import_prompts.buildAnalysisPrompt)(state.logs, state.cwd);
+      const response = await provider.invoke(prompt);
+      let fixSuggestion = null;
+      try {
+        const cleaned = response.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+        const jsonMatch = cleaned.match(/\{[\s\S]*\}/);
+        if (jsonMatch) {
+          fixSuggestion = JSON.parse(jsonMatch[0]);
+        } else {
+          console.warn("[OpsPilot] AI response did not contain a valid JSON object.");
+        }
+      } catch (e) {
+        console.error("[OpsPilot] Failed to parse AI response:", e);
+      }
+      return {
+        analysis: response,
+        fixSuggestion,
+        attempts: state.attempts + 1
+      };
+    }
+    async function applyFixNode(state) {
+      if (!state.fixSuggestion) {
+        console.warn("[OpsPilot] No fix suggestion available \u2014 skipping patch.");
+        return {};
+      }
+      const { filePath, search, replace, explanation } = state.fixSuggestion;
+      const absolutePath = import_path2.default.resolve(state.cwd, filePath);
+      console.log(`[OpsPilot] Patching: ${filePath}`);
+      console.log(`[OpsPilot] Reason:   ${explanation}`);
+      const result = (0, import_patcher.applyPatch)(absolutePath, search, replace);
+      if (!result.success) {
+        console.error(`[OpsPilot] Patch failed: ${result.error}`);
+      } else {
+        console.log(`[OpsPilot] Backup saved to: ${result.backupPath}`);
+      }
+      return {};
+    }
+    async function verifyNode(state) {
+      console.log("[OpsPilot] Re-running build to verify fix\u2026");
+      const result = await (0, import_analyzers.runBuild)(state.cwd);
+      if (result.success) {
+        console.log("[OpsPilot] \u2705 Build succeeded!");
+      } else {
+        console.log("[OpsPilot] \u274C Build still failing. New error output captured.");
+      }
+      return {
+        success: result.success,
+        logs: result.success ? "" : result.output
+      };
+    }
+    function shouldRetry(state) {
+      if (state.success) return import_langgraph2.END;
+      if (state.attempts >= state.maxAttempts) {
+        console.log(
+          `[OpsPilot] Max attempts (${state.maxAttempts}) reached \u2014 giving up.`
+        );
+        return import_langgraph2.END;
+      }
+      return "analyze";
+    }
+    var workflow = new import_langgraph2.StateGraph(GraphState).addNode("analyze", analyzeNode).addNode("apply_fix", applyFixNode).addNode("verify", verifyNode).addEdge(import_langgraph2.START, "analyze").addEdge("analyze", "apply_fix").addEdge("apply_fix", "verify").addConditionalEdges("verify", shouldRetry).compile();
+  }
+});
+
+// ../core/dist/index.js
+var require_dist7 = __commonJS({
+  "../core/dist/index.js"(exports, module) {
+    "use strict";
+    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, {
+      detectFramework: () => detectFramework2,
+      orchestrate: () => orchestrate2,
+      orchestrateAndFix: () => orchestrateAndFix2
+    });
+    module.exports = __toCommonJS(index_exports);
+    var import_fs = __toESM2(__require("fs"));
+    var import_path2 = __toESM2(__require("path"));
+    function detectFramework2(cwd = process.cwd()) {
+      const has = (...files) => files.some((f) => import_fs.default.existsSync(import_path2.default.join(cwd, f)));
+      if (has("next.config.js", "next.config.ts", "next.config.mjs")) return "nextjs";
+      if (has("nest-cli.json")) return "nestjs";
+      if (has("vite.config.ts", "vite.config.js", "vite.config.mts")) return "vite";
+      if (has("remix.config.js", "remix.config.ts")) return "remix";
+      if (has("astro.config.mjs", "astro.config.ts", "astro.config.js")) return "astro";
+      if (has("svelte.config.js", "svelte.config.ts")) return "sveltekit";
+      if (has("nuxt.config.ts", "nuxt.config.js")) return "nuxt";
+      const pkgPath = import_path2.default.join(cwd, "package.json");
+      if (import_fs.default.existsSync(pkgPath)) {
+        try {
+          const pkg = JSON.parse(import_fs.default.readFileSync(pkgPath, "utf-8"));
+          const deps = {
+            ...pkg.dependencies ?? {},
+            ...pkg.devDependencies ?? {}
+          };
+          if (deps["react-scripts"]) return "create-react-app";
+          if (deps["@angular/core"]) return "angular";
+        } catch {
+        }
+      }
+      if (has("tsconfig.json")) return "typescript";
+      return "unknown";
+    }
+    var import_analyzers = require_dist2();
+    var import_agents = require_dist6();
+    async function orchestrate2(options = {}) {
+      const cwd = options.cwd ?? process.cwd();
+      const [build, lint, test] = await Promise.all([
+        (0, import_analyzers.runBuild)(cwd),
+        (0, import_analyzers.runLint)(cwd),
+        (0, import_analyzers.runTests)(cwd)
+      ]);
+      return { build, lint, test };
+    }
+    async function orchestrateAndFix2(options = {}) {
+      const cwd = options.cwd ?? process.cwd();
+      const maxAttempts = options.maxAttempts ?? 3;
+      console.log(`[OpsPilot] Running build in: ${cwd}`);
+      const buildResult = await (0, import_analyzers.runBuild)(cwd);
+      if (buildResult.success) {
+        console.log("[OpsPilot] Build already passing \u2014 nothing to fix.");
+        return { success: true, attempts: 0, finalOutput: buildResult.output };
+      }
+      const errors = (0, import_analyzers.parseErrors)(buildResult.output);
+      console.log(`[OpsPilot] Detected ${errors.length} error(s) (type: ${errors[0]?.type ?? "unknown"})`);
+      if (options.dryRun) {
+        console.log("[OpsPilot] Dry-run mode \u2014 skipping AI fix.");
+        return {
+          success: false,
+          attempts: 0,
+          finalOutput: buildResult.output,
+          error: "Dry-run: analysis complete, no files modified."
+        };
+      }
+      const finalState = await import_agents.workflow.invoke({
+        cwd,
+        logs: buildResult.output,
+        maxAttempts,
+        attempts: 0,
+        success: false
+      });
+      return {
+        success: finalState.success,
+        attempts: finalState.attempts,
+        finalOutput: finalState.logs || buildResult.output,
+        appliedFix: finalState.fixSuggestion ?? void 0,
+        error: finalState.success ? void 0 : `Max attempts (${maxAttempts}) reached without a successful build.`
+      };
+    }
+  }
+});
+
+// src/index.ts
+var import_config = __toESM(require_dist(), 1);
+var import_core = __toESM(require_dist7(), 1);
+import { Command } from "commander";
+import path from "path";
+var program = new Command();
+program.name("bugzero").description("AI-powered build issue fixer \u2014 detects and repairs build errors automatically").version("0.0.1");
+program.command("analyze").description("Run build, lint, and tests \u2014 report issues without modifying files").option("-p, --path <dir>", "Path to the target project", ".").action(async (opts) => {
+  const cwd = path.resolve(opts.path);
+  const framework = (0, import_core.detectFramework)(cwd);
+  console.log(`
+\u{1F50D} BugZero \u2014 Analyzing project`);
+  console.log(`   Path:      ${cwd}`);
+  console.log(`   Framework: ${framework}
+`);
+  const { build, lint, test } = await (0, import_core.orchestrate)({ cwd });
+  console.log("\u2500\u2500 Build \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");
+  if (build.success) {
+    console.log("  \u2705 Passed");
+  } else {
+    console.log("  \u274C Failed\n");
+    console.log(build.output);
+  }
+  console.log("\n\u2500\u2500 Lint \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");
+  if (lint.success) {
+    console.log("  \u2705 Passed");
+  } else {
+    console.log("  \u274C Failed\n");
+    console.log(lint.output);
+  }
+  console.log("\n\u2500\u2500 Tests \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");
+  if (test.success) {
+    console.log("  \u2705 Passed");
+  } else {
+    console.log("  \u274C Failed\n");
+    console.log(test.output);
+  }
+  const allPassed = build.success && lint.success && test.success;
+  console.log(`
+${allPassed ? "\u2705 All checks passed" : "\u274C Issues found \u2014 run 'bugzero fix' to repair"}
+`);
+  process.exit(allPassed ? 0 : 1);
+});
+program.command("fix").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) => {
+  const cwd = path.resolve(opts.path);
+  const maxAttempts = parseInt(opts.maxAttempts, 10);
+  const dryRun = opts.dryRun;
+  const framework = (0, import_core.detectFramework)(cwd);
+  console.log(`
+\u{1F916} BugZero Fix`);
+  console.log(`   Path:        ${cwd}`);
+  console.log(`   Framework:   ${framework}`);
+  console.log(`   Max attempts: ${maxAttempts}`);
+  if (dryRun) console.log(`   Mode:        DRY RUN (no files will be modified)`);
+  console.log();
+  const result = await (0, import_core.orchestrateAndFix)({ cwd, maxAttempts, dryRun });
+  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");
+  if (result.success) {
+    console.log(`\u2705 Build fixed after ${result.attempts} attempt(s)!`);
+    if (result.appliedFix) {
+      console.log(`   File:   ${result.appliedFix.filePath}`);
+      console.log(`   Reason: ${result.appliedFix.explanation}`);
+      console.log(`   Root cause: ${result.appliedFix.rootCause}`);
+    }
+  } else {
+    console.log(`\u274C Could not fix build after ${result.attempts} attempt(s).`);
+    if (result.error) console.log(`   ${result.error}`);
+  }
+  console.log();
+  process.exit(result.success ? 0 : 1);
+});
+program.command("protect").description("[Deprecated] Use 'analyze' instead").action(async () => {
+  console.warn("\u26A0\uFE0F  'protect' is deprecated \u2014 use 'bugzero analyze' instead.\n");
+  const result = await (0, import_core.orchestrate)();
+  console.log(result);
+});
+program.parse();

package/dist/index.mjs

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { Command } from "commander";
+import { orchestrate } from "@opspilot/core";
+var program = new Command();
+program.command("protect").action(async () => {
+  const result = await orchestrate();
+  console.log(result);
+});
+program.parse();

package/package.json

@@ -0,0 +1,25 @@
+{
+  "name": "bugzero",
+  "version": "0.0.1",
+  "bin": {
+    "bugzero": "dist/index.js"
+  },
+  "dependencies": {
+    "@langchain/core": "^1.1.48",
+    "@langchain/langgraph": "^1.3.2",
+    "axios": "^1.16.1",
+    "commander": "^15.0.0",
+    "execa": "^7.2.0"
+  },
+  "devDependencies": {
+    "@opspilot/agents": "0.0.1",
+    "@opspilot/config": "0.0.1",
+    "@opspilot/core": "0.0.1"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "type": "module",
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --dts"
+  }
+}

package/src/index.ts

@@ -0,0 +1,109 @@
+#!/usr/bin/env node
+
+import "@opspilot/config"; // loads .env before anything else
+import { Command } from "commander";
+import path from "path";
+import { orchestrate, orchestrateAndFix, detectFramework } from "@opspilot/core";
+
+
+const program = new Command();
+
+program
+  .name("bugzero")
+  .description("AI-powered build issue fixer — detects and repairs build errors automatically")
+  .version("0.0.1");
+
+// ── bugzero analyze ─────────────────────────────────────────────────────────
+program
+  .command("analyze")
+  .description("Run build, lint, and tests — report issues without modifying files")
+  .option("-p, --path <dir>", "Path to the target project", ".")
+  .action(async (opts) => {
+    const cwd = path.resolve(opts.path);
+    const framework = detectFramework(cwd);
+
+    console.log(`\n🔍 BugZero — Analyzing project`);
+    console.log(`   Path:      ${cwd}`);
+    console.log(`   Framework: ${framework}\n`);
+
+    const { build, lint, test } = await orchestrate({ cwd });
+
+    console.log("── Build ──────────────────────────────────────");
+    if (build.success) {
+      console.log("  ✅ Passed");
+    } else {
+      console.log("  ❌ Failed\n");
+      console.log(build.output);
+    }
+
+    console.log("\n── Lint ───────────────────────────────────────");
+    if (lint.success) {
+      console.log("  ✅ Passed");
+    } else {
+      console.log("  ❌ Failed\n");
+      console.log(lint.output);
+    }
+
+    console.log("\n── Tests ──────────────────────────────────────");
+    if (test.success) {
+      console.log("  ✅ Passed");
+    } else {
+      console.log("  ❌ Failed\n");
+      console.log(test.output);
+    }
+
+    const allPassed = build.success && lint.success && test.success;
+    console.log(`\n${allPassed ? "✅ All checks passed" : "❌ Issues found — run 'bugzero fix' to repair"}\n`);
+    process.exit(allPassed ? 0 : 1);
+  });
+
+// ── bugzero fix ─────────────────────────────────────────────────────────────
+program
+  .command("fix")
+  .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 — print what would be fixed without writing files", false)
+  .action(async (opts) => {
+    const cwd = path.resolve(opts.path);
+    const maxAttempts = parseInt(opts.maxAttempts, 10);
+    const dryRun: boolean = opts.dryRun;
+    const framework = detectFramework(cwd);
+
+    console.log(`\n🤖 BugZero Fix`);
+    console.log(`   Path:        ${cwd}`);
+    console.log(`   Framework:   ${framework}`);
+    console.log(`   Max attempts: ${maxAttempts}`);
+    if (dryRun) console.log(`   Mode:        DRY RUN (no files will be modified)`);
+    console.log();
+
+    const result = await orchestrateAndFix({ cwd, maxAttempts, dryRun });
+
+    console.log("\n──────────────────────────────────────────────");
+    if (result.success) {
+      console.log(`✅ Build fixed after ${result.attempts} attempt(s)!`);
+      if (result.appliedFix) {
+        console.log(`   File:   ${result.appliedFix.filePath}`);
+        console.log(`   Reason: ${result.appliedFix.explanation}`);
+        console.log(`   Root cause: ${result.appliedFix.rootCause}`);
+      }
+    } else {
+      console.log(`❌ Could not fix build after ${result.attempts} attempt(s).`);
+      if (result.error) console.log(`   ${result.error}`);
+    }
+    console.log();
+
+    process.exit(result.success ? 0 : 1);
+  });
+
+// ── bugzero protect (legacy) ────────────────────────────────────────────────
+program
+  .command("protect")
+  .description("[Deprecated] Use 'analyze' instead")
+  .action(async () => {
+    console.warn("⚠️  'protect' is deprecated — use 'bugzero analyze' instead.\n");
+    const result = await orchestrate();
+    console.log(result);
+  });
+
+program.parse();

package/tsconfig.json

@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}