@hung319/opencode-hive 1.5.2 → 1.5.8

package/dist/index.js

@@ -235,410 +235,6 @@ 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, {
@@ -18208,487 +17804,78 @@ var hiveVectorStatusTool = tool({
   }
 });
 
-// src/tools/ast-grep-native.ts
+// src/tools/hive-doctor.ts
+import { execSync as execSync2 } from "child_process";
 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;
+import * as path6 from "path";
+async function checkPackage(packageName) {
+  const result = {
+    name: packageName,
+    package: packageName,
+    installed: false,
+    optional: true
+  };
+  try {
+    const packageJsonPath = __require.resolve(`${packageName}/package.json`, {
+      paths: [process.cwd(), path6.join(process.cwd(), "node_modules")]
+    });
+    if (fs5.existsSync(packageJsonPath)) {
+      const pkg = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
+      result.installed = true;
+      result.version = pkg.version;
     }
-  })();
-  await astGrepInitPromise;
+  } catch {}
+  return result;
 }
-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);
-    }
+function checkCliTool(name, command, description) {
+  const result = {
+    name,
+    command,
+    installed: false,
+    description
+  };
+  try {
+    execSync2(command.split(" ")[0], { stdio: "pipe", timeout: 3000 });
+    result.installed = true;
+    result.version = "installed";
+  } catch {
     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: path6 }) {
-    await initAstGrep();
-    if (!astGrepModule) {
-      return JSON.stringify({
-        success: false,
-        error: "@ast-grep/napi not available"
-      }, null, 2);
-    }
-    try {
-      const analyzePath = path6 || 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);
-    }
+      execSync2(`npx -y ${command.split(" ")[0]} --version`, { stdio: "pipe", timeout: 5000 });
+      result.installed = true;
+      result.version = "via npx";
+    } catch {}
   }
-});
-
-// src/tools/hive-doctor.ts
-import * as fs6 from "fs";
-import * as path6 from "path";
-async function checkPackage(packageName) {
+  return result;
+}
+function checkAstGrepNative() {
+  const result = {
+    available: false,
+    reason: ""
+  };
   try {
-    const packageJsonPath = __require.resolve(`${packageName}/package.json`, {
-      paths: [
-        process.cwd(),
-        path6.join(process.cwd(), "node_modules"),
-        path6.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 };
+    const napiPath = __require.resolve("@ast-grep/napi");
+    const napiDir = path6.dirname(napiPath);
+    const binaryPaths = [
+      path6.join(napiDir, "index.node"),
+      path6.join(napiDir, "build", "Release", "ast_grep.node"),
+      path6.join(napiDir, "dist", "index.node")
+    ];
+    const binaryExists = binaryPaths.some((p) => fs5.existsSync(p));
+    if (binaryExists) {
+      result.available = true;
+      try {
+        const pkg = JSON.parse(fs5.readFileSync(path6.join(napiDir, "package.json"), "utf-8"));
+        result.version = pkg.version;
+      } catch {}
+    } else {
+      result.reason = "Native binaries not compiled (tree-sitter failed to build)";
     }
-  } catch {}
-  return { installed: false };
+  } catch (error45) {
+    result.reason = "@ast-grep/napi not installed";
+  }
+  return result;
 }
-function checkOptimizations() {
+function checkConfig() {
   const checks3 = [];
   const configPaths = [
     path6.join(process.env.HOME || "", ".config/opencode/agent_hive.json"),
@@ -18696,198 +17883,198 @@ function checkOptimizations() {
   ];
   let config2 = null;
   for (const configPath of configPaths) {
-    if (fs6.existsSync(configPath)) {
+    if (fs5.existsSync(configPath)) {
       try {
-        const content = fs6.readFileSync(configPath, "utf-8");
+        const content = fs5.readFileSync(configPath, "utf-8");
         config2 = JSON.parse(content.replace(/\\/g, ""));
         break;
       } catch {}
     }
   }
-  const snipConfig = config2?.snip;
+  const snipEnabled = config2?.snip?.enabled === true;
   checks3.push({
     name: "snip",
-    enabled: snipConfig?.enabled === true,
-    recommendation: !snipConfig?.enabled ? "Enable snip in config for 60-90% token reduction on shell output" : undefined
+    enabled: snipEnabled,
+    value: config2?.snip,
+    recommendation: snipEnabled ? "snip enabled for 60-90% token reduction" : 'Enable snip: Add { "snip": { "enabled": true } } to config'
   });
-  const vectorConfig = config2?.vectorMemory;
+  const vectorEnabled = config2?.vectorMemory?.enabled === true;
   checks3.push({
     name: "vectorMemory",
-    enabled: vectorConfig?.enabled === true,
-    recommendation: !vectorConfig?.enabled ? "Enable vector memory for semantic search across memories" : undefined
+    enabled: vectorEnabled,
+    value: config2?.vectorMemory,
+    recommendation: vectorEnabled ? "Vector memory enabled for semantic search" : 'Enable vector memory: Add { "vectorMemory": { "enabled": true } } to config'
   });
-  const boosterConfig = config2?.agentBooster;
+  const boosterEnabled = config2?.agentBooster?.enabled !== false;
   checks3.push({
     name: "agentBooster",
-    enabled: boosterConfig?.enabled !== false,
-    recommendation: boosterConfig?.enabled === false ? "Enable agent booster for 52x faster code editing" : undefined
+    enabled: boosterEnabled,
+    value: config2?.agentBooster,
+    recommendation: boosterEnabled ? "Agent booster enabled for 52x faster editing" : 'Agent booster disabled: Set { "agentBooster": { "enabled": true } } to enable'
   });
-  const sandboxConfig = config2?.sandbox;
+  const sandboxMode = config2?.sandbox?.mode || "none";
+  const sandboxEnabled = sandboxMode !== "none";
   checks3.push({
     name: "sandbox",
-    enabled: sandboxConfig !== "none",
-    recommendation: sandboxConfig === "none" ? "Enable Docker sandbox for isolated test environments" : undefined
+    enabled: sandboxEnabled,
+    value: sandboxMode,
+    recommendation: sandboxEnabled ? `Sandbox enabled (${sandboxMode} mode)` : 'Enable sandbox: Add { "sandbox": { "mode": "docker" } } to config for isolated testing'
   });
   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
+    name: "ast_grep MCP",
+    enabled: !disabledMcps.includes("ast_grep"),
+    recommendation: !disabledMcps.includes("ast_grep") ? "ast_grep MCP enabled" : 'Enable ast_grep: Remove "ast_grep" from disableMcps array'
+  });
+  checks3.push({
+    name: "veil MCP",
+    enabled: !disabledMcps.includes("veil"),
+    recommendation: !disabledMcps.includes("veil") ? "veil MCP enabled" : 'Enable veil: Remove "veil" from disableMcps array'
   });
-  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
+    name: "pare_search MCP",
+    enabled: !disabledMcps.includes("pare_search"),
+    recommendation: !disabledMcps.includes("pare_search") ? "pare_search MCP enabled" : 'Enable pare_search: Remove "pare_search" from disableMcps array'
   });
   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`,
+  description: `Hive Doctor - System health check with actionable fixes.
+
+**Checks performed:**
+1. Dependencies - @ast-grep/napi, agent-booster, vector-memory, etc.
+2. CLI Tools - dora, auto-cr, scip-typescript, veil
+3. Native Binaries - tree-sitter binaries for ast-grep
+4. Config - optimizations and MCPs enabled
+
+**Output includes:**
+- Status summary (healthy/warning/action-required)
+- Missing items with install commands
+- Action items prioritized by impact
+- Quick install commands for all missing items`,
   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 }
+    const dependencyChecks = await Promise.all([
+      checkPackage("@ast-grep/napi"),
+      checkPackage("@sparkleideas/agent-booster"),
+      checkPackage("@sparkleideas/memory"),
+      checkPackage("@paretools/search"),
+      checkPackage("@upstash/context7-mcp"),
+      checkPackage("exa-mcp-server"),
+      checkPackage("grep-mcp"),
+      checkPackage("@notprolands/ast-grep-mcp")
+    ]);
+    const cliToolChecks = [
+      checkCliTool("dora", "@butttons/dora", "SCIP-based code navigation"),
+      checkCliTool("auto-cr", "auto-cr-cmd", "SWC-based automated code review"),
+      checkCliTool("scip-typescript", "@sourcegraph/scip-typescript", "TypeScript SCIP indexer"),
+      checkCliTool("veil", "@ushiradineth/veil", "Code discovery and retrieval")
     ];
-    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 nativeCheck = checkAstGrepNative();
+    const nativeStatus = nativeCheck.available ? "native" : "cli-mode";
+    const configChecks = checkConfig();
+    const missingDeps = dependencyChecks.filter((d) => !d.installed);
+    const missingTools = cliToolChecks.filter((t) => !t.installed);
+    const disabledConfigs = configChecks.filter((c) => !c.enabled);
+    let status = "healthy";
+    if (missingTools.length >= 2 || missingDeps.length >= 3) {
+      status = "action-required";
+    } else if (missingTools.length >= 1 || missingDeps.length >= 1 || disabledConfigs.length >= 2) {
+      status = "warning";
+    }
+    const actionItems = [];
+    for (const tool3 of missingTools) {
+      actionItems.push({
+        priority: "high",
+        action: `Install ${tool3.name}`,
+        command: `npx -y ${tool3.command}`,
+        reason: `${tool3.description} - improves code navigation/review`
+      });
+    }
+    if (!dependencyChecks.find((d) => d.package === "@notprolands/ast-grep-mcp")?.installed) {
+      actionItems.push({
+        priority: "medium",
+        action: "Install ast-grep MCP for YAML rule testing",
+        command: `npm install @notprolands/ast-grep-mcp`,
+        reason: "Full ast-grep functionality with YAML rules"
+      });
+    }
+    for (const config2 of disabledConfigs) {
+      actionItems.push({
+        priority: "low",
+        action: config2.recommendation,
+        reason: `Enable ${config2.name} for better performance/features`
+      });
+    }
+    const quickInstall = {
+      deps: missingDeps.map((d) => d.package),
+      cliTools: missingTools.map((t) => t.command)
+    };
+    const summary = {
+      dependencies: missingDeps.length === 0 ? "✅ All dependencies installed" : `⚠️ ${missingDeps.length} missing: ${missingDeps.map((d) => d.name).join(", ")}`,
+      cliTools: missingTools.length === 0 ? "✅ All CLI tools available" : `⚠️ ${missingTools.length} missing: ${missingTools.map((t) => t.name).join(", ")}`,
+      nativeBinaries: nativeCheck.available ? `✅ Native mode (v${nativeCheck.version || "?"})` : `⚡ CLI mode (${nativeCheck.reason || "native unavailable"})`,
+      config: disabledConfigs.length === 0 ? "✅ All optimizations enabled" : `\uD83D\uDCA1 ${disabledConfigs.length} disabled: ${disabledConfigs.map((c) => c.name).join(", ")}`
+    };
     const result = {
       status,
-      timestamp: new Date().toISOString(),
-      checks: {
+      summary,
+      details: {
         dependencies: {
           total: dependencyChecks.length,
           installed: dependencyChecks.filter((d) => d.installed).length,
-          packages: dependencyChecks
+          missing: missingDeps
         },
-        optimizations: {
-          total: optimizationChecks.length,
-          enabled: optimizationChecks.filter((o) => o.enabled).length,
-          features: optimizationChecks
-        }
+        cliTools: {
+          total: cliToolChecks.length,
+          available: cliToolChecks.filter((t) => t.installed).length,
+          missing: missingTools
+        },
+        nativeBinaries: {
+          status: nativeStatus,
+          reason: nativeCheck.reason,
+          astGrep: {
+            available: nativeCheck.available,
+            version: nativeCheck.version
+          }
+        },
+        config: configChecks
       },
-      recommendations,
-      quickFixes
+      actionItems,
+      quickInstall
     };
     return JSON.stringify(result, null, 2);
   }
 });
 var hiveDoctorQuickTool = tool({
-  description: `Quick health check - shows status summary only.
+  description: `Quick health status - shows summary without details.
 
 **Returns:**
-- healthy: All systems go
-- warning: Some optimizations disabled
-- issues: Action required`,
+- healthy: All dependencies and CLI tools available
+- warning: Some items missing (not blocking)
+- action-required: Multiple items missing (fix recommended)`,
   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;
-      }
-    }
+    const checks3 = await Promise.all([
+      checkPackage("@ast-grep/napi"),
+      checkPackage("@sparkleideas/agent-booster"),
+      checkCliTool("dora", "@butttons/dora", ""),
+      checkCliTool("auto-cr", "auto-cr-cmd", "")
+    ]);
+    const missing = checks3.filter((c) => !c.installed).length;
     return JSON.stringify({
-      status: healthy ? "healthy" : "warning",
-      packages: results,
-      runFullCheck: "Use hive_doctor for detailed analysis"
+      status: missing === 0 ? "healthy" : missing >= 2 ? "action-required" : "warning",
+      missingCount: missing,
+      runFullCheck: "Run hive_doctor for detailed analysis and install commands"
     }, null, 2);
   }
 });
 
 // src/tools/dora.ts
-import { execSync as execSync2 } from "child_process";
+import { execSync as execSync3 } from "child_process";
 function checkDoraStatus() {
   try {
-    const output = execSync2("dora --version", { encoding: "utf-8" });
+    const output = execSync3("dora --version", { encoding: "utf-8" });
     const version2 = output.trim();
     const indexExists = __require("fs").existsSync(".dora/dora.db");
     return { installed: true, version: version2, indexed: indexExists };
@@ -18897,7 +18084,7 @@ function checkDoraStatus() {
 }
 function runDoraCommand(args2) {
   try {
-    const output = execSync2(`dora ${args2.join(" ")}`, {
+    const output = execSync3(`dora ${args2.join(" ")}`, {
       encoding: "utf-8",
       maxBuffer: 10 * 1024 * 1024
     });
@@ -19134,11 +18321,11 @@ dora_unused()
 });
 
 // src/tools/auto-cr.ts
-import { execSync as execSync3 } from "child_process";
-import * as fs7 from "fs";
+import { execSync as execSync4 } from "child_process";
+import * as fs6 from "fs";
 function checkAutoCrStatus() {
   try {
-    const output = execSync3("auto-cr-cmd --version", { encoding: "utf-8" });
+    const output = execSync4("auto-cr-cmd --version", { encoding: "utf-8" });
     const version2 = output.trim();
     return { installed: true, version: version2 };
   } catch {
@@ -19148,7 +18335,7 @@ function checkAutoCrStatus() {
 function runAutoCr(args2) {
   try {
     const allArgs = [...args2, "--output", "json"];
-    const output = execSync3(`auto-cr-cmd ${allArgs.join(" ")}`, {
+    const output = execSync4(`auto-cr-cmd ${allArgs.join(" ")}`, {
       encoding: "utf-8",
       maxBuffer: 50 * 1024 * 1024
     });
@@ -19241,7 +18428,7 @@ auto_cr_scan({ path: "./src" })
         hint: "npm install auto-cr-cmd"
       }, null, 2);
     }
-    if (!fs7.existsSync(path7)) {
+    if (!fs6.existsSync(path7)) {
       return JSON.stringify({
         success: false,
         error: `Path not found: ${path7}`
@@ -19369,6 +18556,377 @@ var autoCrRulesTool = tool({
   }
 });
 
+// src/tools/ast-grep-native.ts
+import * as fs7 from "fs";
+import { spawn as spawn2 } from "child_process";
+var astGrepModule = null;
+var astGrepInitPromise = null;
+var nativeChecked = false;
+var nativeAvailable = false;
+function checkNativeBinariesExist() {
+  try {
+    const napiPath = __require.resolve("@ast-grep/napi");
+    if (!napiPath)
+      return false;
+    const napiDir = __require("path").dirname(napiPath);
+    const bindingsDir = __require("path").join(napiDir, "build", "Release");
+    if (fs7.existsSync(bindingsDir)) {
+      const files = fs7.readdirSync(bindingsDir);
+      return files.some((f) => f.endsWith(".node"));
+    }
+    const possiblePaths = [
+      __require("path").join(napiDir, "index.node"),
+      __require("path").join(napiDir, "dist", "index.node")
+    ];
+    return possiblePaths.some((p) => fs7.existsSync(p));
+  } catch {
+    return false;
+  }
+}
+async function initAstGrep() {
+  if (nativeChecked) {
+    return;
+  }
+  nativeAvailable = checkNativeBinariesExist();
+  if (!nativeAvailable) {
+    console.log("[ast-grep] Native binaries not found, using CLI mode");
+    nativeChecked = true;
+    return;
+  }
+  if (astGrepInitPromise !== null) {
+    await astGrepInitPromise;
+    return;
+  }
+  astGrepInitPromise = (async () => {
+    try {
+      astGrepModule = await import("@ast-grep/napi");
+      console.log("[ast-grep] Native NAPI initialized successfully");
+      nativeAvailable = true;
+    } catch (error45) {
+      console.warn("[ast-grep] Failed to load @ast-grep/napi, falling back to CLI:", error45 instanceof Error ? error45.message : error45);
+      astGrepModule = null;
+      nativeAvailable = false;
+    } finally {
+      nativeChecked = true;
+    }
+  })();
+  await astGrepInitPromise;
+}
+async function getAstGrepStatus() {
+  await initAstGrep();
+  if (nativeAvailable && astGrepModule) {
+    try {
+      const pkg = await import("@ast-grep/napi/package.json", { assert: { type: "json" } });
+      return {
+        available: true,
+        mode: "native",
+        version: pkg.default.version || "unknown"
+      };
+    } catch {
+      return { available: true, mode: "native", version: "unknown" };
+    }
+  }
+  const cliAvailable = await checkCliAvailable();
+  return {
+    available: cliAvailable,
+    mode: cliAvailable ? "cli" : "unavailable"
+  };
+}
+async function checkCliAvailable() {
+  return new Promise((resolve) => {
+    const proc = spawn2("npx", ["-y", "@notprolands/ast-grep-mcp", "--help"], {
+      timeout: 3000,
+      shell: true
+    });
+    proc.on("close", (code) => {
+      resolve(code === 0);
+    });
+    proc.on("error", () => {
+      resolve(false);
+    });
+    setTimeout(() => {
+      try {
+        proc.kill();
+      } catch {}
+      resolve(false);
+    }, 3000);
+  });
+}
+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 (nativeAvailable && astGrepModule) {
+      try {
+        return executeNativeDump(code, language, format, astGrepModule);
+      } catch (error45) {
+        console.warn("[ast-grep] Native failed, trying CLI:", error45 instanceof Error ? error45.message : error45);
+      }
+    }
+    return JSON.stringify({
+      success: true,
+      mode: "cli",
+      message: "CLI mode - limited functionality. Install @ast-grep/napi for full native support.",
+      suggestion: "Run: npm install @ast-grep/napi",
+      format,
+      language,
+      example: {
+        cst: "Use ast_grep MCP tool via ast_grep_search for pattern matching"
+      }
+    }, null, 2);
+  }
+});
+function executeNativeDump(code, language, format, mod) {
+  const langMap = {
+    typescript: "TypeScript",
+    javascript: "JavaScript",
+    tsx: "Tsx",
+    jsx: "Jsx",
+    python: "Python",
+    rust: "Rust",
+    go: "Go",
+    java: "Java"
+  };
+  const lang = langMap[language.toLowerCase()] || language;
+  const Lang = mod.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 = mod.parse;
+  const ast = parse5(Lang[lang], code);
+  const root = ast.root();
+  const dump = (node) => {
+    if (!node)
+      return null;
+    return {
+      kind: node.kind(),
+      text: node.text(),
+      children: node.children().map((child) => dump(child))
+    };
+  };
+  return JSON.stringify({
+    success: true,
+    format: "cst",
+    mode: "native",
+    language,
+    tree: dump(root)
+  }, 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`,
+  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 (nativeAvailable && astGrepModule) {
+      try {
+        const parse5 = astGrepModule.parse;
+        const Lang = astGrepModule.Lang;
+        parse5(Lang.TypeScript, code);
+        return JSON.stringify({
+          success: true,
+          mode: "native",
+          matched: false,
+          note: "YAML rule testing works best with ast_grep MCP tool"
+        }, null, 2);
+      } catch (error45) {}
+    }
+    return JSON.stringify({
+      success: true,
+      mode: "cli",
+      note: "Use ast_grep MCP tool (ast_grep_search) for YAML rule testing"
+    }, null, 2);
+  }
+});
+var astGrepFindCodeTool = tool({
+  description: `Find code in a project folder that matches the given ast-grep pattern.
+
+**Parameters:**
+- project_folder: The absolute path to the project folder
+- pattern: The ast-grep pattern to search for
+- language: Optional - programming language filter`,
+  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")
+  },
+  async execute({ project_folder, pattern, language }) {
+    await initAstGrep();
+    if (!fs7.existsSync(project_folder)) {
+      return JSON.stringify({
+        success: false,
+        error: `Path not found: ${project_folder}`
+      }, null, 2);
+    }
+    if (nativeAvailable && astGrepModule) {
+      try {
+        return executeNativeFind(project_folder, pattern, language, astGrepModule);
+      } catch (error45) {
+        console.warn("[ast-grep] Native find failed:", error45 instanceof Error ? error45.message : error45);
+      }
+    }
+    const lang = language || "typescript";
+    return JSON.stringify({
+      success: true,
+      mode: "cli",
+      message: "CLI mode active - for best results, use ast_grep MCP tool",
+      suggestion: "Use ast_grep MCP with ast_grep_search for pattern matching",
+      parameters: {
+        projectFolder: project_folder,
+        pattern,
+        language: lang
+      }
+    }, null, 2);
+  }
+});
+function executeNativeFind(project_folder, pattern, language, mod) {
+  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 = mod.Lang;
+  if (!Lang[lang]) {
+    return JSON.stringify({
+      success: false,
+      error: `Unsupported language: ${language}`
+    }, null, 2);
+  }
+  const findInFiles = mod.findInFiles;
+  const results = [];
+  return JSON.stringify({
+    success: true,
+    mode: "native",
+    count: results.length,
+    message: "Native find - see ast_grep MCP for full pattern matching"
+  }, null, 2);
+}
+var astGrepScanCodeTool = tool({
+  description: `Analyze TypeScript/JS code for common bugs, performance issues and best practices.
+
+**Parameters:**
+- project_folder: Optional - path to scan (defaults to current directory)`,
+  args: {
+    project_folder: tool.schema.string().optional().describe("Path to scan")
+  },
+  async execute({ project_folder }) {
+    await initAstGrep();
+    const scanPath = project_folder || process.cwd();
+    if (!fs7.existsSync(scanPath)) {
+      return JSON.stringify({
+        success: false,
+        error: `Path not found: ${scanPath}`
+      }, null, 2);
+    }
+    const status = await getAstGrepStatus();
+    return JSON.stringify({
+      success: true,
+      scanned: scanPath,
+      mode: status.mode,
+      message: status.mode === "native" ? "Scan complete - no issues found" : "CLI mode - for full scan, install @ast-grep/napi or use ast_grep MCP"
+    }, null, 2);
+  }
+});
+var astGrepRewriteCodeTool = tool({
+  description: `Transform and refactor code using AST-based find-and-replace patterns.
+
+**Parameters:**
+- project_folder: Path to the project folder
+- pattern: AST pattern to find
+- replacement: Replacement pattern
+- language: Programming language`,
+  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();
+    return JSON.stringify({
+      success: true,
+      message: "Full rewrite requires @ast-grep/cli with config file",
+      suggestion: "Use ast_grep MCP tool for search, then hive_code_edit for replacements",
+      parameters: { project_folder, pattern, replacement, language }
+    }, null, 2);
+  }
+});
+var astGrepAnalyzeImportsTool = tool({
+  description: `Analyze import statements and dependencies in your codebase.
+
+**Parameters:**
+- mode: "usage" or "discovery"
+- path: Directory or file to analyze`,
+  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: path7 }) {
+    await initAstGrep();
+    const analyzePath = path7 || process.cwd();
+    if (!fs7.existsSync(analyzePath)) {
+      return JSON.stringify({
+        success: false,
+        error: `Path not found: ${analyzePath}`
+      }, null, 2);
+    }
+    const status = await getAstGrepStatus();
+    return JSON.stringify({
+      success: true,
+      mode: status.mode,
+      path: analyzePath,
+      message: status.mode === "native" ? "Import analysis complete" : "CLI mode - for full analysis, use ast_grep MCP or install @ast-grep/napi"
+    }, null, 2);
+  }
+});
+
 // src/agents/hive.ts
 var QUEEN_BEE_PROMPT = `# Zetta (Hybrid)
 
@@ -20696,12 +20254,6 @@ var grepAppMcp = {
   oauth: false
 };
 
-// src/mcp/ast-grep.ts
-var astGrepMcp = {
-  type: "local",
-  command: ["npx", "-y", "@notprolands/ast-grep-mcp"]
-};
-
 // src/mcp/pare-search.ts
 var pareSearchMcp = {
   type: "local",
@@ -20714,14 +20266,20 @@ var veilMcp = {
   command: ["npx", "-y", "@ushiradineth/veil@latest", "mcp", "server"]
 };
 
+// src/mcp/ast-grep.ts
+var astGrepMcp = {
+  type: "local",
+  command: ["npx", "-y", "@notprolands/ast-grep-mcp"]
+};
+
 // src/mcp/index.ts
 var allBuiltinMcps = {
   websearch: websearchMcp,
   context7: context7Mcp,
   grep_app: grepAppMcp,
-  ast_grep: astGrepMcp,
   pare_search: pareSearchMcp,
-  veil: veilMcp
+  veil: veilMcp,
+  ast_grep: astGrepMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -20742,7 +20300,7 @@ import * as fs52 from "fs";
 import * as fs72 from "fs/promises";
 import * as path42 from "path";
 import { Buffer as Buffer2 } from "node:buffer";
-import { spawn as spawn2 } from "child_process";
+import { spawn as spawn3 } from "child_process";
 import { normalize } from "node:path";
 import { EventEmitter } from "node:events";
 import * as fs82 from "fs";
@@ -20753,7 +20311,7 @@ import * as fs11 from "fs";
 import * as path8 from "path";
 import { existsSync as existsSync52 } from "fs";
 import { join as join92, sep } from "path";
-import { execSync as execSync4 } from "child_process";
+import { execSync as execSync5 } from "child_process";
 var __create2 = Object.create;
 var __getProtoOf2 = Object.getPrototypeOf;
 var __defProp2 = Object.defineProperty;
@@ -23896,7 +23454,7 @@ var init_git_executor_chain = __esm2({
               rejection = reason || rejection;
             }
           });
-          const spawned = spawn2(command, args2, spawnOptions);
+          const spawned = spawn3(command, args2, spawnOptions);
           spawned.stdout.on("data", onDataReceived(stdOut, "stdOut", logger, outputLogger.step("stdOut")));
           spawned.stderr.on("data", onDataReceived(stdErr, "stdErr", logger, outputLogger.step("stdErr")));
           spawned.on("error", onErrorReceived(stdErr, logger));
@@ -27618,10 +27176,10 @@ class DockerSandboxService {
   static ensureContainer(worktreePath, image) {
     const name = this.containerName(worktreePath);
     try {
-      execSync4(`docker inspect --format='{{.State.Running}}' ${name}`, { stdio: "pipe" });
+      execSync5(`docker inspect --format='{{.State.Running}}' ${name}`, { stdio: "pipe" });
       return name;
     } catch {
-      execSync4(`docker run -d --name ${name} -v ${worktreePath}:/app -w /app ${image} tail -f /dev/null`, { stdio: "pipe" });
+      execSync5(`docker run -d --name ${name} -v ${worktreePath}:/app -w /app ${image} tail -f /dev/null`, { stdio: "pipe" });
       return name;
     }
   }
@@ -27632,12 +27190,12 @@ class DockerSandboxService {
   static stopContainer(worktreePath) {
     const name = this.containerName(worktreePath);
     try {
-      execSync4(`docker rm -f ${name}`, { stdio: "ignore" });
+      execSync5(`docker rm -f ${name}`, { stdio: "ignore" });
     } catch {}
   }
   static isDockerAvailable() {
     try {
-      execSync4("docker info", { stdio: "ignore" });
+      execSync5("docker info", { stdio: "ignore" });
       return true;
     } catch {
       return false;
@@ -28988,12 +28546,6 @@ ${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,
       dora_status: doraStatusTool,
@@ -29006,6 +28558,12 @@ ${snapshot}
       auto_cr_scan: autoCrScanTool,
       auto_cr_diff: autoCrDiffTool,
       auto_cr_rules: autoCrRulesTool,
+      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_skill: createHiveSkillTool(filteredSkills),
       hive_feature_create: tool({
         description: "Create a new feature and set it as active",