@hung319/opencode-hive 1.4.3 → 1.4.4

package/dist/index.js

@@ -235,6 +235,410 @@ var require_dist = __commonJS((exports) => {
   exports.default = AgentBooster;
 });
 
+// ../../node_modules/.bun/@ast-grep+napi-linux-x64-musl@0.41.1/node_modules/@ast-grep/napi-linux-x64-musl/ast-grep-napi.linux-x64-musl.node
+var require_ast_grep_napi_linux_x64_musl = __commonJS((exports, module) => {
+  module.exports = __require("./ast-grep-napi.linux-x64-musl-qnd01z8b.node");
+});
+
+// ../../node_modules/.bun/@ast-grep+napi-linux-x64-gnu@0.41.1/node_modules/@ast-grep/napi-linux-x64-gnu/ast-grep-napi.linux-x64-gnu.node
+var require_ast_grep_napi_linux_x64_gnu = __commonJS((exports, module) => {
+  module.exports = __require("./ast-grep-napi.linux-x64-gnu-qdwfscvp.node");
+});
+
+// ../../node_modules/.bun/@ast-grep+napi@0.41.1/node_modules/@ast-grep/napi/index.js
+var require_napi = __commonJS((exports, module) => {
+  var __filename = "/home/runner/work/agent-hive/agent-hive/node_modules/.bun/@ast-grep+napi@0.41.1/node_modules/@ast-grep/napi/index.js";
+  var { createRequire: createRequire2 } = __require("node:module");
+  __require = createRequire2(__filename);
+  var { readFileSync: readFileSync5 } = __require("node:fs");
+  var nativeBinding = null;
+  var loadErrors = [];
+  var isMusl = () => {
+    let musl = false;
+    if (process.platform === "linux") {
+      musl = isMuslFromFilesystem();
+      if (musl === null) {
+        musl = isMuslFromReport();
+      }
+      if (musl === null) {
+        musl = isMuslFromChildProcess();
+      }
+    }
+    return musl;
+  };
+  var isFileMusl = (f) => f.includes("libc.musl-") || f.includes("ld-musl-");
+  var isMuslFromFilesystem = () => {
+    try {
+      return readFileSync5("/usr/bin/ldd", "utf-8").includes("musl");
+    } catch {
+      return null;
+    }
+  };
+  var isMuslFromReport = () => {
+    let report = null;
+    if (typeof process.report?.getReport === "function") {
+      process.report.excludeNetwork = true;
+      report = process.report.getReport();
+    }
+    if (!report) {
+      return null;
+    }
+    if (report.header && report.header.glibcVersionRuntime) {
+      return false;
+    }
+    if (Array.isArray(report.sharedObjects)) {
+      if (report.sharedObjects.some(isFileMusl)) {
+        return true;
+      }
+    }
+    return false;
+  };
+  var isMuslFromChildProcess = () => {
+    try {
+      return __require("child_process").execSync("ldd --version", { encoding: "utf8" }).includes("musl");
+    } catch (e) {
+      return false;
+    }
+  };
+  function requireNative() {
+    if (process.env.NAPI_RS_NATIVE_LIBRARY_PATH) {
+      try {
+        nativeBinding = __require(process.env.NAPI_RS_NATIVE_LIBRARY_PATH);
+      } catch (err) {
+        loadErrors.push(err);
+      }
+    } else if (process.platform === "android") {
+      if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.android-arm64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-android-arm64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.android-arm-eabi.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-android-arm-eabi");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on Android ${process.arch}`));
+      }
+    } else if (process.platform === "win32") {
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.win32-x64-msvc.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-win32-x64-msvc");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "ia32") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.win32-ia32-msvc.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-win32-ia32-msvc");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.win32-arm64-msvc.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-win32-arm64-msvc");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on Windows: ${process.arch}`));
+      }
+    } else if (process.platform === "darwin") {
+      try {
+        return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.darwin-universal.node");})();
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      try {
+        return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-darwin-universal");})();
+      } catch (e) {
+        loadErrors.push(e);
+      }
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.darwin-x64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-darwin-x64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.darwin-arm64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-darwin-arm64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on macOS: ${process.arch}`));
+      }
+    } else if (process.platform === "freebsd") {
+      if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.freebsd-x64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-freebsd-x64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.freebsd-arm64.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-freebsd-arm64");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on FreeBSD: ${process.arch}`));
+      }
+    } else if (process.platform === "linux") {
+      if (process.arch === "x64") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-x64-musl.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return require_ast_grep_napi_linux_x64_musl();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-x64-gnu.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return require_ast_grep_napi_linux_x64_gnu();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "arm64") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm64-musl.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm64-musl");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm64-gnu.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm64-gnu");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "arm") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm-musleabihf.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm-musleabihf");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm-gnueabihf.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm-gnueabihf");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "riscv64") {
+        if (isMusl()) {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-riscv64-musl.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-riscv64-musl");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        } else {
+          try {
+            return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-riscv64-gnu.node");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+          try {
+            return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-riscv64-gnu");})();
+          } catch (e) {
+            loadErrors.push(e);
+          }
+        }
+      } else if (process.arch === "ppc64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-ppc64-gnu.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-ppc64-gnu");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "s390x") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-s390x-gnu.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-s390x-gnu");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on Linux: ${process.arch}`));
+      }
+    } else if (process.platform === "openharmony") {
+      if (process.arch === "arm64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm64-ohos.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm64-ohos");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "x64") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-x64-ohos.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-x64-ohos");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else if (process.arch === "arm") {
+        try {
+          return (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.linux-arm-ohos.node");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+        try {
+          return (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-linux-arm-ohos");})();
+        } catch (e) {
+          loadErrors.push(e);
+        }
+      } else {
+        loadErrors.push(new Error(`Unsupported architecture on OpenHarmony: ${process.arch}`));
+      }
+    } else {
+      loadErrors.push(new Error(`Unsupported OS: ${process.platform}, architecture: ${process.arch}`));
+    }
+  }
+  nativeBinding = requireNative();
+  if (!nativeBinding || process.env.NAPI_RS_FORCE_WASI) {
+    try {
+      nativeBinding = (()=>{throw new Error("Cannot require module "+"./ast-grep-napi.wasi.cjs");})();
+    } catch (err) {
+      if (process.env.NAPI_RS_FORCE_WASI) {
+        loadErrors.push(err);
+      }
+    }
+    if (!nativeBinding) {
+      try {
+        nativeBinding = (()=>{throw new Error("Cannot require module "+"@ast-grep/napi-wasm32-wasi");})();
+      } catch (err) {
+        if (process.env.NAPI_RS_FORCE_WASI) {
+          loadErrors.push(err);
+        }
+      }
+    }
+  }
+  if (!nativeBinding) {
+    if (loadErrors.length > 0) {
+      throw new Error(`Cannot find native binding. ` + `npm has a bug related to optional dependencies (https://github.com/npm/cli/issues/4828). ` + "Please try `npm i` again after removing both package-lock.json and node_modules directory.", { cause: loadErrors });
+    }
+    throw new Error(`Failed to load native binding`);
+  }
+  module.exports = nativeBinding;
+  module.exports.SgNode = nativeBinding.SgNode;
+  module.exports.SgRoot = nativeBinding.SgRoot;
+  module.exports.findInFiles = nativeBinding.findInFiles;
+  module.exports.kind = nativeBinding.kind;
+  module.exports.Lang = nativeBinding.Lang;
+  module.exports.parse = nativeBinding.parse;
+  module.exports.parseAsync = nativeBinding.parseAsync;
+  module.exports.parseFiles = nativeBinding.parseFiles;
+  module.exports.pattern = nativeBinding.pattern;
+  module.exports.registerDynamicLanguage = nativeBinding.registerDynamicLanguage;
+  module.exports.css = nativeBinding.css;
+  module.exports.html = nativeBinding.html;
+  module.exports.js = nativeBinding.js;
+  module.exports.jsx = nativeBinding.jsx;
+  module.exports.ts = nativeBinding.ts;
+  module.exports.tsx = nativeBinding.tsx;
+});
+
 // src/utils/context-compression.ts
 var exports_context_compression = {};
 __export(exports_context_compression, {
@@ -450,7 +854,7 @@ var init_context_compression = __esm(() => {
 });
 
 // src/index.ts
-import * as path9 from "path";
+import * as path11 from "path";
 import * as os4 from "os";
 
 // ../../node_modules/.bun/zod@4.1.8/node_modules/zod/v4/classic/external.js
@@ -17357,6 +17761,681 @@ var hiveVectorStatusTool = tool({
   }
 });
 
+// src/tools/ast-grep-native.ts
+import * as fs5 from "fs";
+var astGrepModule = null;
+var astGrepInitPromise = null;
+async function initAstGrep() {
+  if (astGrepModule !== null) {
+    return;
+  }
+  if (astGrepInitPromise !== null) {
+    await astGrepInitPromise;
+    return;
+  }
+  astGrepInitPromise = (async () => {
+    try {
+      astGrepModule = await Promise.resolve().then(() => __toESM(require_napi(), 1));
+      console.log("[ast-grep] Native NAPI initialized successfully");
+    } catch (error45) {
+      console.warn("[ast-grep] Failed to load @ast-grep/napi:", error45 instanceof Error ? error45.message : error45);
+      astGrepModule = null;
+    }
+  })();
+  await astGrepInitPromise;
+}
+var astGrepDumpSyntaxTreeTool = tool({
+  description: `Dump code's syntax structure or dump a query's pattern structure.
+
+This is useful to discover correct syntax kind and syntax tree structure. Call it when debugging a rule.
+
+**Parameters:**
+- code: The code you need
+- language: Programming language (typescript, javascript, python, rust, go, java, etc.)
+- format: Output format - 'cst' (concrete syntax tree) or 'pattern' (to inspect rule patterns)
+
+**Use when:**
+- Debugging AST patterns
+- Finding correct syntax kind names
+- Understanding code structure`,
+  args: {
+    code: tool.schema.string().describe("The code to analyze"),
+    language: tool.schema.string().describe("Programming language (typescript, javascript, python, rust, go, java, etc.)"),
+    format: tool.schema.enum(["cst", "pattern"]).default("cst").describe("Output format")
+  },
+  async execute({ code, language, format }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      const langMap = {
+        typescript: "TypeScript",
+        javascript: "JavaScript",
+        tsx: "Tsx",
+        jsx: "Jsx",
+        python: "Python",
+        rust: "Rust",
+        go: "Go",
+        java: "Java",
+        c: "C",
+        cpp: "Cpp",
+        csharp: "CSharp"
+      };
+      const lang = langMap[language.toLowerCase()] || language;
+      const Lang = astGrepModule.Lang;
+      if (!Lang || !Lang[lang]) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported language: ${language}`,
+          availableLanguages: Object.keys(langMap)
+        }, null, 2);
+      }
+      if (format === "pattern") {
+        return JSON.stringify({
+          success: true,
+          format: "pattern",
+          language,
+          example: {
+            match: "AwaitExpression",
+            kind: "Use kind to match AST node types",
+            pattern: "Use pattern for code templates"
+          }
+        }, null, 2);
+      }
+      const parse5 = astGrepModule.parse;
+      const ast = parse5(Lang[lang], code);
+      const root = ast.root();
+      const dump = (node, depth = 0) => {
+        if (!node)
+          return null;
+        return {
+          kind: node.kind(),
+          text: node.text(),
+          children: node.children().map((child) => dump(child, depth + 1))
+        };
+      };
+      return JSON.stringify({
+        success: true,
+        format: "cst",
+        language,
+        tree: dump(root)
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepTestMatchCodeRuleTool = tool({
+  description: `Test a code against an ast-grep YAML rule.
+
+This is useful to test a rule before using it in a project.
+
+**Parameters:**
+- code: The code to test against the rule
+- yaml: The ast-grep YAML rule to test
+
+**Returns:**
+- Whether the rule matched
+- Matched nodes with locations`,
+  args: {
+    code: tool.schema.string().describe("The code to test against the rule"),
+    yaml: tool.schema.string().describe("The ast-grep YAML rule to search")
+  },
+  async execute({ code, yaml }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      const parse5 = astGrepModule.parse;
+      const Lang = astGrepModule.Lang;
+      const ast = parse5(Lang.TypeScript, code);
+      const root = ast.root();
+      return JSON.stringify({
+        success: true,
+        matched: false,
+        note: "YAML rule testing requires @ast-grep/cli. Use ast_grep_find_code for pattern-based search.",
+        example: {
+          pattern: "console.log($ARG)",
+          description: "Match console.log with any argument"
+        }
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepFindCodeTool = tool({
+  description: `Find code in a project folder that matches the given ast-grep pattern.
+
+Pattern is good for simple and single-AST node result. For more complex usage, use ast_grep_scan_code.
+
+**Parameters:**
+- project_folder: The absolute path to the project folder
+- pattern: The ast-grep pattern to search for (e.g., 'console.log($ARG)', '$VAR = $VALUE')
+- language: Optional - programming language filter
+
+**Pattern Examples:**
+- 'console.log($ARG)' - Match console.log with any argument
+- '$VAR = $VALUE' - Match any assignment
+- 'function $NAME($PARAMS) { $BODY }' - Match function declarations`,
+  args: {
+    project_folder: tool.schema.string().describe("The absolute path to the project folder"),
+    pattern: tool.schema.string().describe("The ast-grep pattern to search for"),
+    language: tool.schema.string().optional().describe("Programming language filter (typescript, javascript, python, etc.)")
+  },
+  async execute({ project_folder, pattern, language }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      if (!fs5.existsSync(project_folder)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${project_folder}`
+        }, null, 2);
+      }
+      const langMap = {
+        typescript: "TypeScript",
+        javascript: "JavaScript",
+        tsx: "Tsx",
+        jsx: "Jsx",
+        python: "Python",
+        rust: "Rust",
+        go: "Go",
+        java: "Java"
+      };
+      const lang = language ? langMap[language.toLowerCase()] || language : "TypeScript";
+      const Lang = astGrepModule.Lang;
+      if (!Lang[lang]) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported language: ${language}`
+        }, null, 2);
+      }
+      const findInFiles = astGrepModule.findInFiles;
+      const results = [];
+      await findInFiles(Lang[lang], {
+        paths: [project_folder],
+        matcher: { rule: { pattern } }
+      }, (err, node) => {
+        if (err) {
+          console.warn("[ast-grep] Search error:", err);
+          return;
+        }
+        if (node) {
+          const text = node.text();
+          const range = node.range();
+          results.push({
+            file: node.filename() || "unknown",
+            line: range ? range.start.index : 0,
+            column: range ? range.start.column : 0,
+            matched: text.slice(0, 100)
+          });
+        }
+      });
+      return JSON.stringify({
+        success: true,
+        count: results.length,
+        matches: results.slice(0, 50)
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepScanCodeTool = tool({
+  description: `Analyze TypeScript/JS code for common bugs, performance issues and best practices.
+
+Uses AST-based analysis for precise detection without false positives. Essential for maintaining code quality and preventing runtime errors.
+
+**Detects:**
+- Type safety violations
+- Loose object types
+- Incorrect async patterns
+- Import style issues
+- Common bugs
+
+**Parameters:**
+- project_folder: Optional - path to scan (defaults to current directory)`,
+  args: {
+    project_folder: tool.schema.string().optional().describe("Path to scan (defaults to current directory)")
+  },
+  async execute({ project_folder }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      const scanPath = project_folder || process.cwd();
+      if (!fs5.existsSync(scanPath)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${scanPath}`
+        }, null, 2);
+      }
+      const bugPatterns = [
+        { pattern: "await Promise.all($ARR)", severity: "warning", message: "Check if Promise.all is used correctly with async operations" },
+        { pattern: "JSON.parse($STR)", severity: "info", message: "Consider adding try-catch for JSON.parse" },
+        { pattern: "$VAR == $VAL", severity: "warning", message: "Use === instead of == for strict equality" }
+      ];
+      const issues = [];
+      const Lang = astGrepModule.Lang;
+      const findInFiles = astGrepModule.findInFiles;
+      for (const bug of bugPatterns) {
+        await findInFiles(Lang.TypeScript, {
+          paths: [scanPath],
+          matcher: { rule: { pattern: bug.pattern } }
+        }, (err, node) => {
+          if (err || !node)
+            return;
+          issues.push({
+            file: node.filename() || "unknown",
+            line: node.range()?.start.index || 0,
+            severity: bug.severity,
+            message: bug.message,
+            pattern: bug.pattern
+          });
+        });
+      }
+      return JSON.stringify({
+        success: true,
+        scanned: scanPath,
+        issuesFound: issues.length,
+        issues: issues.slice(0, 20),
+        summary: issues.length === 0 ? "No common issues detected" : `Found ${issues.length} potential issues`
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepRewriteCodeTool = tool({
+  description: `Transform and refactor code using AST-based find-and-replace patterns.
+
+Use metavariables ($VAR, $$$VARS) in both pattern and replacement.
+
+**Example:** Find 'console.log($ARG)' and replace with 'logger.info($ARG)'
+
+**Parameters:**
+- project_folder: Path to the project folder
+- pattern: AST pattern to find
+- replacement: Replacement pattern
+- language: Programming language (defaults to TypeScript)`,
+  args: {
+    project_folder: tool.schema.string().describe("Path to the project folder"),
+    pattern: tool.schema.string().describe("AST pattern to find"),
+    replacement: tool.schema.string().describe("Replacement pattern"),
+    language: tool.schema.string().optional().default("TypeScript").describe("Programming language")
+  },
+  async execute({ project_folder, pattern, replacement, language }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available",
+        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+      }, null, 2);
+    }
+    try {
+      if (!fs5.existsSync(project_folder)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${project_folder}`
+        }, null, 2);
+      }
+      const Lang = astGrepModule.Lang;
+      if (!Lang[language]) {
+        return JSON.stringify({
+          success: false,
+          error: `Unsupported language: ${language}`
+        }, null, 2);
+      }
+      return JSON.stringify({
+        success: true,
+        operation: "info",
+        message: "Full rewrite requires @ast-grep/cli with config file",
+        suggestion: "Use ast_grep_find_code to find matches, then hive_code_edit for individual replacements",
+        parameters: {
+          projectFolder: project_folder,
+          pattern,
+          replacement,
+          language
+        }
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+var astGrepAnalyzeImportsTool = tool({
+  description: `Analyze import statements and dependencies in your codebase.
+
+Choose "usage" to see which imports are actually used (great for refactoring), or "discovery" to explore all imports and identifiers in the code (great for understanding structure).
+
+**Parameters:**
+- mode: "usage" (default) shows where imports are used, "discovery" shows all imports
+- path: Specific directory or file to analyze (defaults to current directory)`,
+  args: {
+    mode: tool.schema.enum(["usage", "discovery"]).default("usage").describe("Analysis mode"),
+    path: tool.schema.string().optional().describe("Directory or file to analyze")
+  },
+  async execute({ mode, path: path5 }) {
+    await initAstGrep();
+    if (!astGrepModule) {
+      return JSON.stringify({
+        success: false,
+        error: "@ast-grep/napi not available"
+      }, null, 2);
+    }
+    try {
+      const analyzePath = path5 || process.cwd();
+      if (!fs5.existsSync(analyzePath)) {
+        return JSON.stringify({
+          success: false,
+          error: `Path not found: ${analyzePath}`
+        }, null, 2);
+      }
+      const Lang = astGrepModule.Lang;
+      const findInFiles = astGrepModule.findInFiles;
+      const imports = {};
+      await findInFiles(Lang.TypeScript, {
+        paths: [analyzePath],
+        matcher: { rule: { kind: "import_statement" } }
+      }, (err, node) => {
+        if (err || !node)
+          return;
+        const text = node.text();
+        const match = text.match(/from ['"]([^'"]+)['"]/);
+        if (match) {
+          const module = match[1];
+          const file2 = node.filename() || "unknown";
+          if (!imports[module]) {
+            imports[module] = [];
+          }
+          if (!imports[module].includes(file2)) {
+            imports[module].push(file2);
+          }
+        }
+      });
+      if (mode === "usage") {
+        return JSON.stringify({
+          success: true,
+          mode: "usage",
+          imports: Object.entries(imports).map(([module, files]) => ({
+            module,
+            importCount: 1,
+            filesCount: files.length
+          })),
+          note: "Full usage analysis requires @ast-grep/cli"
+        }, null, 2);
+      }
+      return JSON.stringify({
+        success: true,
+        mode: "discovery",
+        totalModules: Object.keys(imports).length,
+        imports: Object.entries(imports).map(([module, files]) => ({
+          module,
+          importCount: files.length,
+          files: files.slice(0, 5)
+        }))
+      }, null, 2);
+    } catch (error45) {
+      return JSON.stringify({
+        success: false,
+        error: error45 instanceof Error ? error45.message : String(error45)
+      }, null, 2);
+    }
+  }
+});
+
+// src/tools/hive-doctor.ts
+import * as fs6 from "fs";
+import * as path5 from "path";
+async function checkPackage(packageName) {
+  try {
+    const packageJsonPath = __require.resolve(`${packageName}/package.json`, {
+      paths: [
+        process.cwd(),
+        path5.join(process.cwd(), "node_modules"),
+        path5.join(process.cwd(), "packages/opencode-hive/node_modules")
+      ]
+    });
+    if (fs6.existsSync(packageJsonPath)) {
+      const pkg = JSON.parse(fs6.readFileSync(packageJsonPath, "utf-8"));
+      return { installed: true, version: pkg.version };
+    }
+  } catch {}
+  return { installed: false };
+}
+function checkOptimizations() {
+  const checks3 = [];
+  const configPaths = [
+    path5.join(process.env.HOME || "", ".config/opencode/agent_hive.json"),
+    path5.join(process.env.HOME || "", ".config/opencode/agent_hive.jsonc")
+  ];
+  let config2 = null;
+  for (const configPath of configPaths) {
+    if (fs6.existsSync(configPath)) {
+      try {
+        const content = fs6.readFileSync(configPath, "utf-8");
+        config2 = JSON.parse(content.replace(/\\/g, ""));
+        break;
+      } catch {}
+    }
+  }
+  const snipConfig = config2?.snip;
+  checks3.push({
+    name: "snip",
+    enabled: snipConfig?.enabled === true,
+    recommendation: !snipConfig?.enabled ? "Enable snip in config for 60-90% token reduction on shell output" : undefined
+  });
+  const vectorConfig = config2?.vectorMemory;
+  checks3.push({
+    name: "vectorMemory",
+    enabled: vectorConfig?.enabled === true,
+    recommendation: !vectorConfig?.enabled ? "Enable vector memory for semantic search across memories" : undefined
+  });
+  const boosterConfig = config2?.agentBooster;
+  checks3.push({
+    name: "agentBooster",
+    enabled: boosterConfig?.enabled !== false,
+    recommendation: boosterConfig?.enabled === false ? "Enable agent booster for 52x faster code editing" : undefined
+  });
+  const sandboxConfig = config2?.sandbox;
+  checks3.push({
+    name: "sandbox",
+    enabled: sandboxConfig !== "none",
+    recommendation: sandboxConfig === "none" ? "Enable Docker sandbox for isolated test environments" : undefined
+  });
+  const disabledMcps = config2?.disableMcps || [];
+  const hasAstGrep = !disabledMcps.includes("ast_grep");
+  checks3.push({
+    name: "nativeAstGrep",
+    enabled: hasAstGrep,
+    recommendation: !hasAstGrep ? "Enable native ast-grep for fast AST analysis" : undefined
+  });
+  const hasPareSearch = !disabledMcps.includes("pare_search");
+  checks3.push({
+    name: "pareSearch",
+    enabled: hasPareSearch,
+    recommendation: !hasPareSearch ? "Enable pare_search for structured ripgrep output (65-95% token reduction)" : undefined
+  });
+  return checks3;
+}
+function generateRecommendations(dependencies, optimizations) {
+  const recommendations = [];
+  const missingRequired = dependencies.filter((d) => d.required && !d.installed);
+  if (missingRequired.length > 0) {
+    recommendations.push(`Missing required packages: ${missingRequired.map((d) => d.name).join(", ")}`);
+  }
+  const disabledOptimizations = optimizations.filter((o) => !o.enabled && o.recommendation);
+  for (const opt of disabledOptimizations) {
+    if (opt.recommendation) {
+      recommendations.push(opt.recommendation);
+    }
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("System is optimized! No immediate actions needed.");
+  }
+  return recommendations;
+}
+function generateQuickFixes(dependencies, optimizations) {
+  const fixes = [];
+  const missingPackages = dependencies.filter((d) => !d.installed && !d.required);
+  for (const pkg of missingPackages) {
+    fixes.push({
+      command: `npm install ${pkg.package}`,
+      description: `Install ${pkg.name}`
+    });
+  }
+  if (optimizations.find((o) => o.name === "snip" && !o.enabled)) {
+    fixes.push({
+      command: 'Add to ~/.config/opencode/agent_hive.json: { "snip": { "enabled": true } }',
+      description: "Enable snip for token reduction"
+    });
+  }
+  if (optimizations.find((o) => o.name === "vectorMemory" && !o.enabled)) {
+    fixes.push({
+      command: 'Add to ~/.config/opencode/agent_hive.json: { "vectorMemory": { "enabled": true } }',
+      description: "Enable vector memory for semantic search"
+    });
+  }
+  return fixes;
+}
+function calculateStatus(dependencies, optimizations) {
+  const missingRequired = dependencies.filter((d) => d.required && !d.installed);
+  if (missingRequired.length > 0) {
+    return "issues";
+  }
+  const disabledCount = optimizations.filter((o) => !o.enabled).length;
+  if (disabledCount > 2) {
+    return "warning";
+  }
+  return "healthy";
+}
+var hiveDoctorTool = tool({
+  description: `Hive Doctor - System health check and optimization advisor.
+
+**What it checks:**
+1. Dependencies - Optional packages installed and working
+2. Optimizations - Features enabled in config
+3. Recommendations - Suggestions for improvements
+
+**Use when:**
+- Setting up Hive for the first time
+- Troubleshooting issues
+- Optimizing performance
+- Checking if new features are available
+
+**Example output:**
+- healthy: All checks pass
+- warning: Some optimizations disabled
+- issues: Missing required packages`,
+  args: {},
+  async execute() {
+    const dependencyChecks = [
+      { name: "agent-booster", package: "@sparkleideas/agent-booster", required: false },
+      { name: "vector-memory", package: "@sparkleideas/memory", required: false },
+      { name: "ast-grep NAPI", package: "@ast-grep/napi", required: false },
+      { name: "pare-search", package: "@paretools/search", required: false },
+      { name: "context7", package: "@upstash/context7-mcp", required: false },
+      { name: "Exa search", package: "exa-mcp-server", required: false }
+    ];
+    for (const dep of dependencyChecks) {
+      const result2 = await checkPackage(dep.package);
+      dep.installed = result2.installed;
+      dep.version = result2.version;
+    }
+    const optimizationChecks = checkOptimizations();
+    const recommendations = generateRecommendations(dependencyChecks, optimizationChecks);
+    const quickFixes = generateQuickFixes(dependencyChecks, optimizationChecks);
+    const status = calculateStatus(dependencyChecks, optimizationChecks);
+    const result = {
+      status,
+      timestamp: new Date().toISOString(),
+      checks: {
+        dependencies: {
+          total: dependencyChecks.length,
+          installed: dependencyChecks.filter((d) => d.installed).length,
+          packages: dependencyChecks
+        },
+        optimizations: {
+          total: optimizationChecks.length,
+          enabled: optimizationChecks.filter((o) => o.enabled).length,
+          features: optimizationChecks
+        }
+      },
+      recommendations,
+      quickFixes
+    };
+    return JSON.stringify(result, null, 2);
+  }
+});
+var hiveDoctorQuickTool = tool({
+  description: `Quick health check - shows status summary only.
+
+**Returns:**
+- healthy: All systems go
+- warning: Some optimizations disabled
+- issues: Action required`,
+  args: {},
+  async execute() {
+    const keyPackages = [
+      "@ast-grep/napi",
+      "@sparkleideas/agent-booster",
+      "@paretools/search"
+    ];
+    const results = {};
+    let healthy = true;
+    for (const pkg of keyPackages) {
+      const result = await checkPackage(pkg);
+      results[pkg] = result.installed;
+      if (!result.installed) {
+        healthy = false;
+      }
+    }
+    return JSON.stringify({
+      status: healthy ? "healthy" : "warning",
+      packages: results,
+      runFullCheck: "Use hive_doctor for detailed analysis"
+    }, null, 2);
+  }
+});
+
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
@@ -18690,12 +19769,19 @@ var astGrepMcp = {
   command: ["npx", "-y", "@notprolands/ast-grep-mcp"]
 };
 
+// src/mcp/pare-search.ts
+var pareSearchMcp = {
+  type: "local",
+  command: ["npx", "-y", "@paretools/search"]
+};
+
 // src/mcp/index.ts
 var allBuiltinMcps = {
   websearch: websearchMcp,
   context7: context7Mcp,
   grep_app: grepAppMcp,
-  ast_grep: astGrepMcp
+  ast_grep: astGrepMcp,
+  pare_search: pareSearchMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -18704,16 +19790,16 @@ var createBuiltinMcps = (disabledMcps = []) => {
 
 // ../hive-core/dist/index.js
 import { createRequire as createRequire2 } from "node:module";
-import * as path5 from "path";
+import * as path6 from "path";
 import * as os3 from "os";
 import * as path22 from "path";
-import * as fs5 from "fs";
+import * as fs7 from "fs";
 import * as path32 from "path";
 import * as fs22 from "fs";
 import * as fs32 from "fs";
 import * as fs42 from "fs";
 import * as fs52 from "fs";
-import * as fs7 from "fs/promises";
+import * as fs72 from "fs/promises";
 import * as path42 from "path";
 import { Buffer as Buffer2 } from "node:buffer";
 import { spawn } from "child_process";
@@ -19579,7 +20665,7 @@ var DEFAULT_HIVE_CONFIG = {
   },
   vectorMemory: {
     enabled: false,
-    indexPath: path5.join(os3.homedir(), ".config", "opencode", "hive", "vector-index"),
+    indexPath: path6.join(os3.homedir(), ".config", "opencode", "hive", "vector-index"),
     dimensions: 384
   }
 };
@@ -19653,22 +20739,22 @@ function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolde
   return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs5.existsSync(dirPath)) {
-    fs5.mkdirSync(dirPath, { recursive: true });
+  if (!fs7.existsSync(dirPath)) {
+    fs7.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs5.existsSync(filePath);
+  return fs7.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs5.existsSync(filePath))
+  if (!fs7.existsSync(filePath))
     return null;
-  const content = fs5.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
   ensureDir(path22.dirname(filePath));
-  fs5.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -19680,7 +20766,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs5.statSync(lockPath);
+    const stat2 = fs7.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -19700,12 +20786,12 @@ function acquireLockSync(filePath, options = {}) {
   ensureDir(lockDir);
   while (true) {
     try {
-      const fd = fs5.openSync(lockPath, fs5.constants.O_CREAT | fs5.constants.O_EXCL | fs5.constants.O_WRONLY);
-      fs5.writeSync(fd, lockContent);
-      fs5.closeSync(fd);
+      const fd = fs7.openSync(lockPath, fs7.constants.O_CREAT | fs7.constants.O_EXCL | fs7.constants.O_WRONLY);
+      fs7.writeSync(fd, lockContent);
+      fs7.closeSync(fd);
       return () => {
         try {
-          fs5.unlinkSync(lockPath);
+          fs7.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -19715,7 +20801,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs5.unlinkSync(lockPath);
+            fs7.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -19734,11 +20820,11 @@ function writeAtomic(filePath, content) {
   ensureDir(path22.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs5.writeFileSync(tempPath, content);
-    fs5.renameSync(tempPath, filePath);
+    fs7.writeFileSync(tempPath, content);
+    fs7.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs5.unlinkSync(tempPath);
+      fs7.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -19773,13 +20859,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs5.existsSync(filePath))
+  if (!fs7.existsSync(filePath))
     return null;
-  return fs5.readFileSync(filePath, "utf-8");
+  return fs7.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
   ensureDir(path22.dirname(filePath));
-  fs5.writeFileSync(filePath, content);
+  fs7.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -24614,7 +25700,7 @@ class WorktreeService {
     const featurePath = path42.join(this.config.hiveDir, "features", feature);
     const tasksPath = path42.join(featurePath, "tasks", step, "status.json");
     try {
-      await fs7.access(tasksPath);
+      await fs72.access(tasksPath);
       return tasksPath;
     } catch {}
     return path42.join(featurePath, "execution", step, "status.json");
@@ -24626,7 +25712,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     const git = this.getGit();
-    await fs7.mkdir(path42.dirname(worktreePath), { recursive: true });
+    await fs72.mkdir(path42.dirname(worktreePath), { recursive: true });
     const base = baseBranch || (await git.revparse(["HEAD"])).trim();
     const existing = await this.get(feature, step);
     if (existing) {
@@ -24655,7 +25741,7 @@ class WorktreeService {
     const worktreePath = this.getWorktreePath(feature, step);
     const branchName = this.getBranchName(feature, step);
     try {
-      await fs7.access(worktreePath);
+      await fs72.access(worktreePath);
       const worktreeGit = this.getGit(worktreePath);
       const commit = (await worktreeGit.revparse(["HEAD"])).trim();
       return {
@@ -24675,7 +25761,7 @@ class WorktreeService {
     let base = baseCommit;
     if (!base) {
       try {
-        const status = JSON.parse(await fs7.readFile(statusPath, "utf-8"));
+        const status = JSON.parse(await fs72.readFile(statusPath, "utf-8"));
         base = status.baseCommit;
       } catch {}
     }
@@ -24725,7 +25811,7 @@ class WorktreeService {
     const base = baseBranch || "HEAD~1";
     const worktreeGit = this.getGit(worktreePath);
     const diff = await worktreeGit.diff([`${base}...HEAD`]);
-    await fs7.writeFile(patchPath, diff);
+    await fs72.writeFile(patchPath, diff);
     return patchPath;
   }
   async applyDiff(feature, step, baseBranch) {
@@ -24735,13 +25821,13 @@ class WorktreeService {
     }
     const patchPath = path42.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
-      await fs7.writeFile(patchPath, diffContent);
+      await fs72.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath);
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       return { success: true, filesAffected: filesChanged };
     } catch (error45) {
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       const err = error45;
       return {
         success: false,
@@ -24757,13 +25843,13 @@ class WorktreeService {
     }
     const patchPath = path42.join(this.config.hiveDir, ".worktrees", feature, `${step}.patch`);
     try {
-      await fs7.writeFile(patchPath, diffContent);
+      await fs72.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath, ["-R"]);
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       return { success: true, filesAffected: filesChanged };
     } catch (error45) {
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       const err = error45;
       return {
         success: false,
@@ -24782,7 +25868,7 @@ class WorktreeService {
     return [...new Set(files)];
   }
   async revertFromSavedDiff(diffPath) {
-    const diffContent = await fs7.readFile(diffPath, "utf-8");
+    const diffContent = await fs72.readFile(diffPath, "utf-8");
     if (!diffContent.trim()) {
       return { success: true, filesAffected: [] };
     }
@@ -24807,7 +25893,7 @@ class WorktreeService {
     try {
       await git.raw(["worktree", "remove", worktreePath, "--force"]);
     } catch {
-      await fs7.rm(worktreePath, { recursive: true, force: true });
+      await fs72.rm(worktreePath, { recursive: true, force: true });
     }
     try {
       await git.raw(["worktree", "prune"]);
@@ -24822,13 +25908,13 @@ class WorktreeService {
     const worktreesDir = this.getWorktreesDir();
     const results = [];
     try {
-      const features = feature ? [feature] : await fs7.readdir(worktreesDir);
+      const features = feature ? [feature] : await fs72.readdir(worktreesDir);
       for (const feat of features) {
         const featurePath = path42.join(worktreesDir, feat);
-        const stat2 = await fs7.stat(featurePath).catch(() => null);
+        const stat2 = await fs72.stat(featurePath).catch(() => null);
         if (!stat2?.isDirectory())
           continue;
-        const steps = await fs7.readdir(featurePath).catch(() => []);
+        const steps = await fs72.readdir(featurePath).catch(() => []);
         for (const step of steps) {
           const info = await this.get(feat, step);
           if (info) {
@@ -24846,16 +25932,16 @@ class WorktreeService {
       await git.raw(["worktree", "prune"]);
     } catch {}
     const worktreesDir = this.getWorktreesDir();
-    const features = feature ? [feature] : await fs7.readdir(worktreesDir).catch(() => []);
+    const features = feature ? [feature] : await fs72.readdir(worktreesDir).catch(() => []);
     for (const feat of features) {
       const featurePath = path42.join(worktreesDir, feat);
-      const stat2 = await fs7.stat(featurePath).catch(() => null);
+      const stat2 = await fs72.stat(featurePath).catch(() => null);
       if (!stat2?.isDirectory())
         continue;
-      const steps = await fs7.readdir(featurePath).catch(() => []);
+      const steps = await fs72.readdir(featurePath).catch(() => []);
       for (const step of steps) {
         const worktreePath = path42.join(featurePath, step);
-        const stepStat = await fs7.stat(worktreePath).catch(() => null);
+        const stepStat = await fs72.stat(worktreePath).catch(() => null);
         if (!stepStat?.isDirectory())
           continue;
         try {
@@ -24876,13 +25962,13 @@ class WorktreeService {
     }
     const patchPath = path42.join(this.config.hiveDir, ".worktrees", feature, `${step}-check.patch`);
     try {
-      await fs7.writeFile(patchPath, diffContent);
+      await fs72.writeFile(patchPath, diffContent);
       const git = this.getGit();
       await git.applyPatch(patchPath, ["--check"]);
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       return [];
     } catch (error45) {
-      await fs7.unlink(patchPath).catch(() => {});
+      await fs72.unlink(patchPath).catch(() => {});
       const err = error45;
       const stderr = err.message || "";
       const conflicts2 = stderr.split(`
@@ -24895,7 +25981,7 @@ class WorktreeService {
   }
   async checkConflictsFromSavedDiff(diffPath, reverse = false) {
     try {
-      await fs7.access(diffPath);
+      await fs72.access(diffPath);
     } catch {
       return [];
     }
@@ -24918,7 +26004,7 @@ class WorktreeService {
   async commitChanges(feature, step, message) {
     const worktreePath = this.getWorktreePath(feature, step);
     try {
-      await fs7.access(worktreePath);
+      await fs72.access(worktreePath);
     } catch {
       return { committed: false, sha: "", message: "Worktree not found" };
     }
@@ -26130,15 +27216,15 @@ function applyContextBudget(files, config2 = {}) {
 }
 
 // src/utils/prompt-file.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
+import * as fs9 from "fs";
+import * as path9 from "path";
 function writeWorkerPromptFile(feature, task, prompt, hiveDir) {
-  const promptDir = path6.join(hiveDir, "features", feature, "tasks", task);
-  const promptPath = path6.join(promptDir, "worker-prompt.md");
-  if (!fs6.existsSync(promptDir)) {
-    fs6.mkdirSync(promptDir, { recursive: true });
+  const promptDir = path9.join(hiveDir, "features", feature, "tasks", task);
+  const promptPath = path9.join(promptDir, "worker-prompt.md");
+  if (!fs9.existsSync(promptDir)) {
+    fs9.mkdirSync(promptDir, { recursive: true });
   }
-  fs6.writeFileSync(promptPath, prompt, "utf-8");
+  fs9.writeFileSync(promptPath, prompt, "utf-8");
   return promptPath;
 }
 
@@ -26302,7 +27388,7 @@ var plugin = async (ctx) => {
   const effectiveAutoLoadSkills = configService.getAgentConfig("zetta").autoLoadSkills ?? [];
   const worktreeService = new WorktreeService({
     baseDir: directory,
-    hiveDir: path9.join(directory, ".hive")
+    hiveDir: path11.join(directory, ".hive")
   });
   const isOmoSlimEnabled = () => {
     return configService.isOmoSlimEnabled();
@@ -26328,10 +27414,10 @@ var plugin = async (ctx) => {
     }
   };
   const checkBlocked = (feature) => {
-    const fs9 = __require("fs");
-    const blockedPath = path9.join(directory, ".hive", "features", feature, "BLOCKED");
-    if (fs9.existsSync(blockedPath)) {
-      const reason = fs9.readFileSync(blockedPath, "utf-8").trim();
+    const fs12 = __require("fs");
+    const blockedPath = path11.join(directory, ".hive", "features", feature, "BLOCKED");
+    if (fs12.existsSync(blockedPath)) {
+      const reason = fs12.readFileSync(blockedPath, "utf-8").trim();
       return `⛔ BLOCKED by Beekeeper
 
 ${reason || "(No reason provided)"}
@@ -26483,9 +27569,9 @@ To unblock: Remove .hive/features/${feature}/BLOCKED`;
       spec: specContent,
       workerPrompt
     });
-    const hiveDir = path9.join(directory, ".hive");
+    const hiveDir = path11.join(directory, ".hive");
     const workerPromptPath = writeWorkerPromptFile(feature, task, workerPrompt, hiveDir);
-    const relativePromptPath = normalizePath(path9.relative(directory, workerPromptPath));
+    const relativePromptPath = normalizePath(path11.relative(directory, workerPromptPath));
     const PREVIEW_MAX_LENGTH = 200;
     const workerPromptPreview = workerPrompt.length > PREVIEW_MAX_LENGTH ? workerPrompt.slice(0, PREVIEW_MAX_LENGTH) + "..." : workerPrompt;
     const taskToolPrompt = `Follow instructions in @${relativePromptPath}`;
@@ -26893,7 +27979,7 @@ ${snapshot}
       if (sandboxConfig.mode !== "none") {
         const workdir = output.args?.workdir;
         if (workdir) {
-          const hiveWorktreeBase = path9.join(directory, ".hive", ".worktrees");
+          const hiveWorktreeBase = path11.join(directory, ".hive", ".worktrees");
           if (workdir.startsWith(hiveWorktreeBase)) {
             const wrapped = DockerSandboxService.wrapCommand(workdir, finalCommand, sandboxConfig);
             output.args.command = wrapped;
@@ -26960,6 +28046,14 @@ ${snapshot}
       hive_vector_search: hiveVectorSearchTool,
       hive_vector_add: hiveVectorAddTool,
       hive_vector_status: hiveVectorStatusTool,
+      ast_grep_dump_syntax_tree: astGrepDumpSyntaxTreeTool,
+      ast_grep_test_match_code_rule: astGrepTestMatchCodeRuleTool,
+      ast_grep_find_code: astGrepFindCodeTool,
+      ast_grep_scan_code: astGrepScanCodeTool,
+      ast_grep_rewrite_code: astGrepRewriteCodeTool,
+      ast_grep_analyze_imports: astGrepAnalyzeImportsTool,
+      hive_doctor: hiveDoctorTool,
+      hive_doctor_quick: hiveDoctorQuickTool,
       hive_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",