@hung319/opencode-hive 1.5.6 → 1.5.8

package/dist/index.js

@@ -17809,49 +17809,73 @@ import { execSync as execSync2 } from "child_process";
 import * as fs5 from "fs";
 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"),
-        path6.join(process.cwd(), "packages/opencode-hive/node_modules")
-      ]
+      paths: [process.cwd(), path6.join(process.cwd(), "node_modules")]
     });
     if (fs5.existsSync(packageJsonPath)) {
       const pkg = JSON.parse(fs5.readFileSync(packageJsonPath, "utf-8"));
-      return { installed: true, version: pkg.version };
+      result.installed = true;
+      result.version = pkg.version;
     }
   } catch {}
-  return { installed: false };
+  return result;
 }
-function checkCliTool(tool3) {
+function checkCliTool(name, command, description) {
+  const result = {
+    name,
+    command,
+    installed: false,
+    description
+  };
   try {
-    const result = execSync2(tool3.command, { stdio: "pipe", timeout: 5000 });
-    const output = result.toString().trim();
-    const versionMatch = output.match(/(\d+\.\d+\.\d+)/);
-    return {
-      ...tool3,
-      installed: true,
-      version: versionMatch ? versionMatch[1] : output.slice(0, 50)
-    };
+    execSync2(command.split(" ")[0], { stdio: "pipe", timeout: 3000 });
+    result.installed = true;
+    result.version = "installed";
   } catch {
-    const npxCmd = tool3.command.split(" ")[0];
     try {
-      execSync2(`npx -y ${npxCmd} --version`, { stdio: "pipe", timeout: 1e4 });
-      return {
-        ...tool3,
-        installed: true,
-        version: "via npx"
-      };
-    } catch {
-      return {
-        ...tool3,
-        installed: false
-      };
+      execSync2(`npx -y ${command.split(" ")[0]} --version`, { stdio: "pipe", timeout: 5000 });
+      result.installed = true;
+      result.version = "via npx";
+    } catch {}
+  }
+  return result;
+}
+function checkAstGrepNative() {
+  const result = {
+    available: false,
+    reason: ""
+  };
+  try {
+    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 (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"),
@@ -17867,227 +17891,181 @@ function checkOptimizations() {
       } 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 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: "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'
   });
-  const hasVeil = !disabledMcps.includes("veil");
   checks3.push({
-    name: "veil",
-    enabled: hasVeil,
-    recommendation: !hasVeil ? "Enable veil for code discovery and intelligent retrieval" : undefined
+    name: "veil MCP",
+    enabled: !disabledMcps.includes("veil"),
+    recommendation: !disabledMcps.includes("veil") ? "veil MCP enabled" : 'Enable veil: Remove "veil" from disableMcps array'
+  });
+  checks3.push({
+    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, cliTools, 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 missingCliTools = cliTools.filter((t) => !t.installed);
-  if (missingCliTools.length > 0) {
-    recommendations.push(`⚠️ Missing CLI tools: ${missingCliTools.map((t) => t.name).join(", ")}`, `Install with: ${missingCliTools.map((t) => `npx -y ${t.command}`).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 healthy! All checks passed.");
-  }
-  return recommendations;
-}
-function generateQuickFixes(dependencies, cliTools, 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}`
-    });
-  }
-  const missingTools = cliTools.filter((t) => !t.installed);
-  for (const tool3 of missingTools) {
-    fixes.push({
-      command: `npx -y ${tool3.command}`,
-      description: `Install ${tool3.name} via npx`
-    });
-  }
-  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, cliTools, optimizations) {
-  const missingRequired = dependencies.filter((d) => d.required && !d.installed);
-  if (missingRequired.length > 0) {
-    return "issues";
-  }
-  const missingTools = cliTools.filter((t) => !t.installed);
-  const disabledCount = optimizations.filter((o) => !o.enabled).length;
-  if (missingTools.length > 0 || 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. CLI Tools - dora, auto-cr, etc. available via npx
-3. Optimizations - Features enabled in config
-4. 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 or CLI tools missing
-- 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: "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 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 = [
-      {
-        name: "dora",
-        command: "@butttons/dora",
-        description: "SCIP-based code navigation",
-        installCommand: "npx -y @butttons/dora"
-      },
-      {
-        name: "auto-cr",
-        command: "auto-cr-cmd",
-        description: "SWC-based automated code review",
-        installCommand: "npx -y auto-cr-cmd"
-      },
-      {
-        name: "veil",
-        command: "@ushiradineth/veil",
-        description: "Code discovery and retrieval",
-        installCommand: "npx -y @ushiradineth/veil"
-      },
-      {
-        name: "scip-typescript",
-        command: "@sourcegraph/scip-typescript",
-        description: "TypeScript SCIP indexer (for dora)",
-        installCommand: "npx -y @sourcegraph/scip-typescript"
-      }
+      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 tool3 of cliToolChecks) {
-      checkCliTool(tool3);
+    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 optimizationChecks = checkOptimizations();
-    const recommendations = generateRecommendations(dependencyChecks, cliToolChecks, optimizationChecks);
-    const quickFixes = generateQuickFixes(dependencyChecks, cliToolChecks, optimizationChecks);
-    const status = calculateStatus(dependencyChecks, cliToolChecks, optimizationChecks);
+    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
         },
         cliTools: {
           total: cliToolChecks.length,
           available: cliToolChecks.filter((t) => t.installed).length,
-          tools: cliToolChecks,
-          missing: cliToolChecks.filter((t) => !t.installed).map((t) => t.name)
+          missing: missingTools
         },
-        optimizations: {
-          total: optimizationChecks.length,
-          enabled: optimizationChecks.filter((o) => o.enabled).length,
-          features: optimizationChecks
-        }
+        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 CLI tools missing or 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 = [
-      "@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 with CLI tool checks"
+      status: missing === 0 ? "healthy" : missing >= 2 ? "action-required" : "warning",
+      missingCount: missing,
+      runFullCheck: "Run hive_doctor for detailed analysis and install commands"
     }, null, 2);
   }
 });
@@ -18580,10 +18558,39 @@ 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 (astGrepModule !== null) {
+  if (nativeChecked) {
+    return;
+  }
+  nativeAvailable = checkNativeBinariesExist();
+  if (!nativeAvailable) {
+    console.log("[ast-grep] Native binaries not found, using CLI mode");
+    nativeChecked = true;
     return;
   }
   if (astGrepInitPromise !== null) {
@@ -18594,13 +18601,57 @@ async function initAstGrep() {
     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:", error45 instanceof Error ? error45.message : 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.
 
@@ -18622,74 +18673,78 @@ This is useful to discover correct syntax kind and syntax tree structure. Call i
   },
   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);
+    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);
       }
-      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);
     }
+    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.
 
@@ -18697,218 +18752,136 @@ 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`,
+- 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 (!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);
+    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.
 
-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`,
+- 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 (typescript, javascript, python, etc.)")
+    language: tool.schema.string().optional().describe("Programming language filter")
   },
   async execute({ project_folder, pattern, language }) {
     await initAstGrep();
-    if (!astGrepModule) {
+    if (!fs7.existsSync(project_folder)) {
       return JSON.stringify({
         success: false,
-        error: "@ast-grep/napi not available",
-        hint: "Install @ast-grep/napi or use MCP-based ast_grep"
+        error: `Path not found: ${project_folder}`
       }, null, 2);
     }
-    try {
-      if (!fs7.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);
+    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 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);
     }
+    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.
 
-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)")
+    project_folder: tool.schema.string().optional().describe("Path to scan")
   },
   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 (!fs7.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) {
+    const scanPath = project_folder || process.cwd();
+    if (!fs7.existsSync(scanPath)) {
       return JSON.stringify({
         success: false,
-        error: error45 instanceof Error ? error45.message : String(error45)
+        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.
 
-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)`,
+- language: Programming language`,
   args: {
     project_folder: tool.schema.string().describe("Path to the project folder"),
     pattern: tool.schema.string().describe("AST pattern to find"),
@@ -18917,125 +18890,40 @@ Use metavariables ($VAR, $$$VARS) in both pattern and replacement.
   },
   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 (!fs7.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);
-    }
+    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.
 
-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)`,
+- 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();
-    if (!astGrepModule) {
-      return JSON.stringify({
-        success: false,
-        error: "@ast-grep/napi not available"
-      }, null, 2);
-    }
-    try {
-      const analyzePath = path7 || process.cwd();
-      if (!fs7.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) {
+    const analyzePath = path7 || process.cwd();
+    if (!fs7.existsSync(analyzePath)) {
       return JSON.stringify({
         success: false,
-        error: error45 instanceof Error ? error45.message : String(error45)
+        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);
   }
 });
 
@@ -20412,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";
@@ -23566,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));