@hung319/opencode-hive 1.5.9 → 1.6.1

package/README.md

@@ -230,21 +230,9 @@ Hive uses a config file at `~/.config/opencode/agent_hive.json`. You can customi
 | `websearch` | Web search via [Exa AI](https://exa.ai). Real-time web searches and content scraping. | Set `EXA_API_KEY` env var |
 | `context7` | Library documentation lookup via [Context7](https://context7.com). Query up-to-date docs for any programming library. | None |
 | `grep_app` | GitHub code search via [grep.app](https://grep.app). Find real-world code examples from public repositories. | None |
-| `ast_grep` | Native NAPI-powered AST analysis. Pattern matching across 25+ languages. | Built-in (no npx needed) |
+| `ast_grep` | AST-based pattern matching and code analysis. | None (runs via npx) |
 | `pare_search` | Structured ripgrep/fd search with 65-95% token reduction. | None (runs via npx) |
-
-#### Native ast-grep Tools
-
-Instead of MCP-based ast-grep, this plugin includes native tools using `@ast-grep/napi`:
-
-| Tool | Description |
-|------|-------------|
-| `ast_grep_dump_syntax_tree` | Dump code's syntax structure for debugging |
-| `ast_grep_test_match_code_rule` | Test code against YAML rules |
-| `ast_grep_find_code` | Find code matching patterns in project |
-| `ast_grep_scan_code` | Scan for TypeScript bugs and best practices |
-| `ast_grep_rewrite_code` | Transform/refactor code with AST patterns |
-| `ast_grep_analyze_imports` | Analyze import usage in codebase |
+| `veil` | Code discovery and intelligent retrieval. | None (runs via npx) |
 
 ### Per-Agent Skills
 
@@ -559,23 +547,20 @@ bunx @hung319/opencode-hive doctor
 ### What it checks
 
 1. **Dependencies** - npm packages installed?
-   - Core: `@ast-grep/napi`, `@notprolands/ast-grep-mcp`, `@paretools/search`
+   - Core: `@ast-grep/napi`, `@notprolands/ast-grep-mcp`
    - Agent: `@sparkleideas/agent-booster`, `@sparkleideas/memory`
-   - MCPs: `@upstash/context7-mcp`, `exa-mcp-server`, `grep-mcp`
-   - Blockchain: `btca-ask`, `opencode-model-selector`
+   - MCPs: `@paretools/search`, `@upstash/context7-mcp`, `exa-mcp-server`, `grep-mcp`
+   - Blockchain: `btca`, `opencode-model-selector`
 
 2. **CLI Tools** - npx tools available?
    - `dora` - Code navigation (SCIP-based)
    - `auto-cr` - Automated code review (SWC)
    - `scip-typescript` - TypeScript indexer
    - `veil` - Code discovery
-   - `btca` - BTC/A blockchain agent
-
-3. **Native Binaries** - @ast-grep/napi tree-sitter?
-   - Native mode: Fastest, uses compiled binaries
-   - CLI mode: Falls back to MCP via npx
+   - `btca` - BTC/A blockchain agent (from npmx.dev)
+   - `ast-grep` - AST-based pattern matching
 
-4. **Config** - Features enabled?
+3. **Config** - Features enabled?
    - snip, vectorMemory, agentBooster
    - sandbox mode
    - MCPs: ast_grep, veil, pare_search
@@ -586,9 +571,8 @@ bunx @hung319/opencode-hive doctor
 {
   "status": "warning",
   "summary": {
-    "dependencies": "⚠️ 2 missing: agent-booster, vector-memory",
+    "dependencies": "⚠️ 2 missing: agent-booster, memory",
     "cliTools": "⚠️ 1 missing: auto-cr",
-    "nativeBinaries": "⚡ CLI mode (native unavailable)",
     "config": "💡 2 disabled: snip, vectorMemory"
   },
   "actionItems": [

package/bin/doctor.ts

@@ -239,7 +239,7 @@ function runDoctor(): DoctorOutput {
     '@upstash/context7-mcp',
     'exa-mcp-server',
     'grep-mcp',
-    'btca-ask',
+    'btca',
     'opencode-model-selector',
   ];
   
@@ -253,7 +253,7 @@ function runDoctor(): DoctorOutput {
     { name: 'auto-cr', command: 'auto-cr-cmd', description: 'SWC-based automated code review' },
     { name: 'veil', command: '@ushiradineth/veil', description: 'Code discovery and retrieval' },
     { name: 'scip-typescript', command: '@sourcegraph/scip-typescript', description: 'TypeScript SCIP indexer' },
-    { name: 'btca', command: 'btca-ask', description: 'BTC/A agent for blockchain tasks' },
+    { name: 'btca', command: 'btca', description: 'BTC/A agent for blockchain tasks' },
     { name: 'ast-grep', command: '@notprolands/ast-grep-mcp', description: 'AST-based pattern matching' },
   ];
   

package/dist/index.js

@@ -17812,8 +17812,7 @@ async function checkPackage(packageName) {
   const result = {
     name: packageName,
     package: packageName,
-    installed: false,
-    optional: true
+    installed: false
   };
   try {
     const packageJsonPath = __require.resolve(`${packageName}/package.json`, {
@@ -17847,34 +17846,6 @@ function checkCliTool(name, command, description) {
   }
   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 checkConfig() {
   const checks3 = [];
   const configPaths = [
@@ -17921,11 +17892,6 @@ function checkConfig() {
     recommendation: sandboxEnabled ? `Sandbox enabled (${sandboxMode} mode)` : 'Enable sandbox: Add { "sandbox": { "mode": "docker" } } to config for isolated testing'
   });
   const disabledMcps = config2?.disableMcps || [];
-  checks3.push({
-    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"),
@@ -17942,10 +17908,9 @@ var hiveDoctorTool = tool({
   description: `Hive Doctor - System health check with actionable fixes.
 
 **Checks performed:**
-1. Dependencies - All MCP packages, ast-grep, agent-booster, etc.
+1. Dependencies - MCP packages, agent tools, blockchain, etc.
 2. CLI Tools - dora, auto-cr, scip-typescript, veil, btca, etc.
-3. Native Binaries - tree-sitter binaries for ast-grep
-4. Config - optimizations and MCPs enabled
+3. Config - optimizations and MCPs enabled
 
 **Output includes:**
 - Status summary (healthy/warning/action-required)
@@ -17957,28 +17922,22 @@ var hiveDoctorTool = tool({
   args: {},
   async execute() {
     const dependencyChecks = await Promise.all([
-      checkPackage("@ast-grep/napi"),
-      checkPackage("@notprolands/ast-grep-mcp"),
-      checkPackage("@paretools/search"),
       checkPackage("@sparkleideas/agent-booster"),
       checkPackage("@sparkleideas/memory"),
+      checkPackage("@paretools/search"),
       checkPackage("@upstash/context7-mcp"),
       checkPackage("exa-mcp-server"),
       checkPackage("grep-mcp"),
-      checkPackage("btca-ask"),
-      checkPackage("opencode-model-selector"),
-      checkPackage("opencode-model-selector-free")
+      checkPackage("btca"),
+      checkPackage("opencode-model-selector")
     ]);
     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"),
-      checkCliTool("btca", "btca-ask", "BTC/A agent for blockchain tasks"),
-      checkCliTool("ast-grep", "@notprolands/ast-grep-mcp", "AST-based pattern matching")
+      checkCliTool("btca", "btca", "BTC/A agent for blockchain tasks")
     ];
-    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);
@@ -17995,15 +17954,15 @@ var hiveDoctorTool = tool({
         priority: "high",
         action: `Install ${tool3.name}`,
         command: `npx -y ${tool3.command}`,
-        reason: `${tool3.description} - improves code navigation/review`
+        reason: `${tool3.description}`
       });
     }
-    if (!dependencyChecks.find((d) => d.package === "@notprolands/ast-grep-mcp")?.installed) {
+    if (!dependencyChecks.find((d) => d.package === "btca")?.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"
+        action: "Install btca for blockchain tasks",
+        command: `npm install btca`,
+        reason: "BTC/A agent for blockchain analysis and development"
       });
     }
     for (const config2 of disabledConfigs) {
@@ -18020,7 +17979,6 @@ var hiveDoctorTool = tool({
     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 = {
@@ -18037,14 +17995,6 @@ var hiveDoctorTool = tool({
           available: cliToolChecks.filter((t) => t.installed).length,
           missing: missingTools
         },
-        nativeBinaries: {
-          status: nativeStatus,
-          reason: nativeCheck.reason,
-          astGrep: {
-            available: nativeCheck.available,
-            version: nativeCheck.version
-          }
-        },
         config: configChecks
       },
       actionItems,
@@ -18063,8 +18013,8 @@ var hiveDoctorQuickTool = tool({
   args: {},
   async execute() {
     const checks3 = await Promise.all([
-      checkPackage("@ast-grep/napi"),
       checkPackage("@sparkleideas/agent-booster"),
+      checkPackage("btca"),
       checkCliTool("dora", "@butttons/dora", ""),
       checkCliTool("auto-cr", "auto-cr-cmd", "")
     ]);
@@ -18563,377 +18513,6 @@ 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)
 
@@ -20298,7 +19877,7 @@ import { createRequire as createRequire2 } from "node:module";
 import * as path7 from "path";
 import * as os3 from "os";
 import * as path22 from "path";
-import * as fs8 from "fs";
+import * as fs7 from "fs";
 import * as path32 from "path";
 import * as fs22 from "fs";
 import * as fs32 from "fs";
@@ -20307,10 +19886,10 @@ 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 spawn3 } from "child_process";
+import { spawn as spawn2 } from "child_process";
 import { normalize } from "node:path";
 import { EventEmitter } from "node:events";
-import * as fs82 from "fs";
+import * as fs8 from "fs";
 import * as path52 from "path";
 import * as fs10 from "fs";
 import * as path72 from "path";
@@ -21244,22 +20823,22 @@ function getSubtaskReportPath(projectRoot, featureName, taskFolder, subtaskFolde
   return path22.join(getSubtaskPath(projectRoot, featureName, taskFolder, subtaskFolder), REPORT_FILE);
 }
 function ensureDir(dirPath) {
-  if (!fs8.existsSync(dirPath)) {
-    fs8.mkdirSync(dirPath, { recursive: true });
+  if (!fs7.existsSync(dirPath)) {
+    fs7.mkdirSync(dirPath, { recursive: true });
   }
 }
 function fileExists(filePath) {
-  return fs8.existsSync(filePath);
+  return fs7.existsSync(filePath);
 }
 function readJson(filePath) {
-  if (!fs8.existsSync(filePath))
+  if (!fs7.existsSync(filePath))
     return null;
-  const content = fs8.readFileSync(filePath, "utf-8");
+  const content = fs7.readFileSync(filePath, "utf-8");
   return JSON.parse(content);
 }
 function writeJson(filePath, data) {
   ensureDir(path22.dirname(filePath));
-  fs8.writeFileSync(filePath, JSON.stringify(data, null, 2));
+  fs7.writeFileSync(filePath, JSON.stringify(data, null, 2));
 }
 var DEFAULT_LOCK_OPTIONS = {
   timeout: 5000,
@@ -21271,7 +20850,7 @@ function getLockPath(filePath) {
 }
 function isLockStale(lockPath, staleTTL) {
   try {
-    const stat2 = fs8.statSync(lockPath);
+    const stat2 = fs7.statSync(lockPath);
     const age = Date.now() - stat2.mtimeMs;
     return age > staleTTL;
   } catch {
@@ -21291,12 +20870,12 @@ function acquireLockSync(filePath, options = {}) {
   ensureDir(lockDir);
   while (true) {
     try {
-      const fd = fs8.openSync(lockPath, fs8.constants.O_CREAT | fs8.constants.O_EXCL | fs8.constants.O_WRONLY);
-      fs8.writeSync(fd, lockContent);
-      fs8.closeSync(fd);
+      const fd = fs7.openSync(lockPath, fs7.constants.O_CREAT | fs7.constants.O_EXCL | fs7.constants.O_WRONLY);
+      fs7.writeSync(fd, lockContent);
+      fs7.closeSync(fd);
       return () => {
         try {
-          fs8.unlinkSync(lockPath);
+          fs7.unlinkSync(lockPath);
         } catch {}
       };
     } catch (err) {
@@ -21306,7 +20885,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs8.unlinkSync(lockPath);
+            fs7.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -21325,11 +20904,11 @@ function writeAtomic(filePath, content) {
   ensureDir(path22.dirname(filePath));
   const tempPath = `${filePath}.tmp.${process.pid}.${Date.now()}`;
   try {
-    fs8.writeFileSync(tempPath, content);
-    fs8.renameSync(tempPath, filePath);
+    fs7.writeFileSync(tempPath, content);
+    fs7.renameSync(tempPath, filePath);
   } catch (error45) {
     try {
-      fs8.unlinkSync(tempPath);
+      fs7.unlinkSync(tempPath);
     } catch {}
     throw error45;
   }
@@ -21364,13 +20943,13 @@ function patchJsonLockedSync(filePath, patch, options = {}) {
   }
 }
 function readText(filePath) {
-  if (!fs8.existsSync(filePath))
+  if (!fs7.existsSync(filePath))
     return null;
-  return fs8.readFileSync(filePath, "utf-8");
+  return fs7.readFileSync(filePath, "utf-8");
 }
 function writeText(filePath, content) {
   ensureDir(path22.dirname(filePath));
-  fs8.writeFileSync(filePath, content);
+  fs7.writeFileSync(filePath, content);
 }
 function detectContext(cwd) {
   const result = {
@@ -23461,7 +23040,7 @@ var init_git_executor_chain = __esm2({
               rejection = reason || rejection;
             }
           });
-          const spawned = spawn3(command, args2, spawnOptions);
+          const spawned = spawn2(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));
@@ -26655,10 +26234,10 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     if (!fileExists(contextPath))
       return [];
-    const files = fs82.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
+    const files = fs8.readdirSync(contextPath, { withFileTypes: true }).filter((f) => f.isFile() && f.name.endsWith(".md")).map((f) => f.name);
     return files.map((name) => {
       const filePath = path52.join(contextPath, name);
-      const stat2 = fs82.statSync(filePath);
+      const stat2 = fs8.statSync(filePath);
       const content = readText(filePath) || "";
       return {
         name: name.replace(/\.md$/, ""),
@@ -26671,7 +26250,7 @@ class ContextService {
     const contextPath = getContextPath(this.projectRoot, featureName);
     const filePath = path52.join(contextPath, this.normalizeFileName(fileName));
     if (fileExists(filePath)) {
-      fs82.unlinkSync(filePath);
+      fs8.unlinkSync(filePath);
       return true;
     }
     return false;
@@ -26702,8 +26281,8 @@ ${f.content}`);
       const archiveName = `${timestamp}_${ctx.name}.md`;
       const src = path52.join(contextPath, `${ctx.name}.md`);
       const dest = path52.join(archiveDir, archiveName);
-      fs82.copyFileSync(src, dest);
-      fs82.unlinkSync(src);
+      fs8.copyFileSync(src, dest);
+      fs8.unlinkSync(src);
       archived.push(ctx.name);
     }
     return { archived, archivePath: archiveDir };
@@ -28565,12 +28144,6 @@ ${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",

package/dist/mcp/ast-grep.d.ts

@@ -2,6 +2,6 @@ import type { LocalMcpConfig } from './types';
 /**
  * Ast-grep MCP for code analysis
  *
- * Uses local npx execution (remote endpoint mcp.ast-grep.dev is unavailable)
+ * Uses @notprolands/ast-grep-mcp via npx for AST-based code search.
  */
 export declare const astGrepMcp: LocalMcpConfig;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hung319/opencode-hive",
-  "version": "1.5.9",
+  "version": "1.6.1",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",

package/dist/tools/ast-grep-native.d.ts

@@ -1,19 +0,0 @@
-import { type ToolDefinition } from "@opencode-ai/plugin";
-/**
- * Check if native ast-grep is available
- */
-export declare function isAstGrepAvailable(): Promise<boolean>;
-/**
- * Get ast-grep status
- */
-export declare function getAstGrepStatus(): Promise<{
-    available: boolean;
-    mode: 'native' | 'cli' | 'unavailable';
-    version?: string;
-}>;
-export declare const astGrepDumpSyntaxTreeTool: ToolDefinition;
-export declare const astGrepTestMatchCodeRuleTool: ToolDefinition;
-export declare const astGrepFindCodeTool: ToolDefinition;
-export declare const astGrepScanCodeTool: ToolDefinition;
-export declare const astGrepRewriteCodeTool: ToolDefinition;
-export declare const astGrepAnalyzeImportsTool: ToolDefinition;