@hung319/opencode-hive 1.5.8 → 1.6.0

package/README.md

@@ -26,26 +26,26 @@ Hive: Plan → Review → Approve → Execute → Ship
 
 ### For Humans
 
-**Step 1: Install the plugin**
+**Step 1: Check if your system is ready** (run BEFORE installing)
 ```bash
-npm install @hung319/opencode-hive
+# Run standalone doctor to see what's needed
+bunx @hung319/opencode-hive doctor
+# or
+npx @hung319/opencode-hive doctor
 ```
 
-**Step 2: Check what's available**
-Open OpenCode and ask: "Run hive_doctor to check the system"
-
-**Step 3: Install extras you want**
-- For **code analysis**: Install `@notprolands/ast-grep-mcp`
-- For **fast code search**: Install `@paretools/search`
-- For **code navigation**: Install `@butttons/dora`
-- For **auto code review**: Install `auto-cr-cmd`
-
+**Step 2: Install the plugin**
 ```bash
-# Install all extras at once
-npm install @notprolands/ast-grep-mcp @paretools/search
-npx -y @butttons/dora auto-cr-cmd
+npm install @hung319/opencode-hive
 ```
 
+**Step 3: Install extras you want**
+- For **code analysis**: `npm install @notprolands/ast-grep-mcp`
+- For **fast code search**: `npm install @paretools/search`
+- For **code navigation**: `npx -y @butttons/dora`
+- For **auto code review**: `npx -y auto-cr-cmd`
+- For **blockchain tasks**: `npm install btca-ask`
+
 **Step 4: Optional config**
 Create `~/.config/opencode/agent_hive.json`:
 ```json
@@ -71,7 +71,7 @@ npm install @hung319/opencode-hive
 2. Set `EXA_API_KEY` to enable `websearch_exa` (optional).
 3. Restart OpenCode.
 
-This enables tools like `grep_app_searchGitHub`, `context7_query-docs`, `websearch_web_search_exa`, and `ast_grep_search`.
+This enables tools like `grep_app_searchGitHub`, `context7_query-docs`, and `websearch_web_search_exa`.
 
 ## The Workflow
 
@@ -206,7 +206,7 @@ Hive uses a config file at `~/.config/opencode/agent_hive.json`. You can customi
 {
   "$schema": "https://raw.githubusercontent.com/hung319/agent-hive/main/packages/opencode-hive/schema/agent_hive.schema.json",
   "disableSkills": ["brainstorming", "writing-plans"],
-  "disableMcps": ["websearch", "ast_grep"]
+  "disableMcps": ["websearch", "pare_search"]
 }
 ```
 
@@ -230,21 +230,8 @@ 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) |
 | `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
 
@@ -551,30 +538,29 @@ hive_doctor()
 hive_doctor_quick()
 ```
 
+**Standalone (before installing):**
+```bash
+bunx @hung319/opencode-hive doctor
+```
+
 ### What it checks
 
 1. **Dependencies** - npm packages installed?
-   - `@ast-grep/napi` - Native AST analysis
-   - `@sparkleideas/agent-booster` - Fast code editing
-   - `@sparkleideas/memory` - Vector memory
-   - `@paretools/search` - Structured search
-   - `@upstash/context7-mcp` - Library docs
-   - `exa-mcp-server` - Web search
+   - Agent: `@sparkleideas/agent-booster`, `@sparkleideas/memory`
+   - 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 (from npmx.dev)
 
-3. **Native Binaries** - @ast-grep/napi tree-sitter?
-   - Native mode: Fastest, uses compiled binaries
-   - CLI mode: Falls back to MCP via npx
-
-4. **Config** - Features enabled?
+3. **Config** - Features enabled?
    - snip, vectorMemory, agentBooster
    - sandbox mode
-   - MCPs: ast_grep, veil, pare_search
+   - MCPs: veil, pare_search
 
 ### Example Output
 
@@ -582,9 +568,8 @@ hive_doctor_quick()
 {
   "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

@@ -0,0 +1,433 @@
+#!/usr/bin/env bun
+
+/**
+ * Hive Doctor - Standalone version
+ * 
+ * Run BEFORE installing the plugin to check if your system is ready:
+ * 
+ *   bunx @hung319/opencode-hive doctor
+ *   npx @hung319/opencode-hive doctor
+ * 
+ * Or install and run:
+ * 
+ *   npm install @hung319/opencode-hive
+ *   hive_doctor()  // via OpenCode
+ */
+
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ============================================================================
+// Types
+// ============================================================================
+
+interface CheckResult {
+  name: string;
+  installed: boolean;
+  version?: string;
+  reason?: string;
+}
+
+interface CliCheck {
+  name: string;
+  command: string;
+  installed: boolean;
+  version?: string;
+  description: string;
+}
+
+interface DoctorOutput {
+  status: 'ready' | 'needs-setup' | 'action-required';
+  version: string;
+  summary: {
+    os: string;
+    nodeVersion: string;
+    packageManager: string;
+  };
+  checks: {
+    dependencies: {
+      total: number;
+      installed: number;
+      items: CheckResult[];
+    };
+    cliTools: {
+      total: number;
+      available: number;
+      items: CliCheck[];
+    };
+    nativeBinaries: {
+      status: 'native' | 'cli-mode';
+      reason?: string;
+    };
+    config: {
+      exists: boolean;
+      path?: string;
+      optimizations: string[];
+    };
+  };
+  actionItems: {
+    priority: 'critical' | 'high' | 'medium' | 'low';
+    action: string;
+    command?: string;
+    reason: string;
+  }[];
+  installCommands: {
+    deps: string;
+    cliTools: string;
+  };
+}
+
+// ============================================================================
+// Color helpers
+// ============================================================================
+
+const colors = {
+  green: (text: string) => `\x1b[32m${text}\x1b[0m`,
+  yellow: (text: string) => `\x1b[33m${text}\x1b[0m`,
+  red: (text: string) => `\x1b[31m${text}\x1b[0m`,
+  blue: (text: string) => `\x1b[34m${text}\x1b[0m`,
+  gray: (text: string) => `\x1b[90m${text}\x1b[0m`,
+};
+
+// ============================================================================
+// Check functions
+// ============================================================================
+
+function getSystemInfo() {
+  return {
+    os: process.platform,
+    nodeVersion: process.version,
+    packageManager: exists('npm') ? 'npm' : exists('bun') ? 'bun' : 'unknown',
+  };
+}
+
+function exists(cmd: string): boolean {
+  try {
+    execSync(cmd, { stdio: 'ignore' });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function checkNpmPackage(name: string): CheckResult {
+  const result: CheckResult = { name, installed: false };
+  
+  try {
+    const output = execSync(`npm list ${name} --depth=0 --json 2>/dev/null`, {
+      encoding: 'utf-8',
+      timeout: 10000,
+    });
+    const json = JSON.parse(output);
+    if (json.dependencies && json.dependencies[name]) {
+      result.installed = true;
+      result.version = json.dependencies[name].version;
+    }
+  } catch {}
+  
+  return result;
+}
+
+function checkCliTool(name: string, command: string, description: string): CliCheck {
+  const result: CliCheck = { name, command, installed: false, description };
+  
+  // Try direct command
+  try {
+    const cmd = command.split(' ')[0];
+    execSync(cmd, { stdio: 'ignore', timeout: 3000 });
+    result.installed = true;
+    result.version = 'installed';
+    return result;
+  } catch {}
+  
+  // Try npx
+  try {
+    execSync(`npx -y ${command.split(' ')[0]} --version`, { 
+      stdio: 'ignore', 
+      timeout: 10000 
+    });
+    result.installed = true;
+    result.version = 'via npx';
+    return result;
+  } catch {}
+  
+  return result;
+}
+
+function checkAstGrepNative(): { status: 'native' | 'cli-mode'; reason?: string } {
+  // Check if @ast-grep/napi package exists with native binaries
+  const napiDirs = [
+    path.join(process.cwd(), 'node_modules/@ast-grep/napi'),
+    path.join(process.env.HOME || '', '.npm-global/lib/node_modules/@ast-grep/napi'),
+  ];
+  
+  for (const napiDir of napiDirs) {
+    if (!fs.existsSync(napiDir)) continue;
+    
+    const binaryPaths = [
+      path.join(napiDir, 'index.node'),
+      path.join(napiDir, 'build/Release/ast_grep.node'),
+      path.join(napiDir, 'dist/index.node'),
+    ];
+    
+    const hasBinary = binaryPaths.some(p => fs.existsSync(p));
+    
+    if (hasBinary) {
+      return { status: 'native' };
+    }
+  }
+  
+  return { 
+    status: 'cli-mode',
+    reason: 'Native binaries not found (tree-sitter compilation may have failed)'
+  };
+}
+
+function checkConfig(): { exists: boolean; path?: string; optimizations: string[] } {
+  const configPaths = [
+    path.join(process.env.HOME || '', '.config/opencode/agent_hive.json'),
+    path.join(process.env.HOME || '', '.config/opencode/agent_hive.jsonc'),
+  ];
+  
+  for (const configPath of configPaths) {
+    if (fs.existsSync(configPath)) {
+      try {
+        const content = fs.readFileSync(configPath, 'utf-8');
+        const config = JSON.parse(content.replace(/\\/g, ''));
+        const optimizations: string[] = [];
+        
+        if (config.snip?.enabled) optimizations.push('snip');
+        if (config.vectorMemory?.enabled) optimizations.push('vectorMemory');
+        if (config.agentBooster?.enabled !== false) optimizations.push('agentBooster');
+        if (config.sandbox?.mode !== 'none') optimizations.push('sandbox');
+        
+        return { exists: true, path: configPath, optimizations };
+      } catch {}
+    }
+  }
+  
+  return { exists: false, optimizations: [] };
+}
+
+// ============================================================================
+// Main check
+// ============================================================================
+
+function runDoctor(): DoctorOutput {
+  const output: DoctorOutput = {
+    status: 'ready',
+    version: '1.5.8',
+    summary: getSystemInfo(),
+    checks: {
+      dependencies: { total: 0, installed: 0, items: [] },
+      cliTools: { total: 0, available: 0, items: [] },
+      nativeBinaries: { status: 'cli-mode' },
+      config: { exists: false, optimizations: [] },
+    },
+    actionItems: [],
+    installCommands: { deps: '', cliTools: '' },
+  };
+  
+  // Check dependencies
+  const deps = [
+    '@sparkleideas/agent-booster',
+    '@sparkleideas/memory',
+    '@paretools/search',
+    '@upstash/context7-mcp',
+    'exa-mcp-server',
+    'grep-mcp',
+    'btca',
+    'opencode-model-selector',
+  ];
+  
+  output.checks.dependencies.items = deps.map(d => checkNpmPackage(d));
+  output.checks.dependencies.total = deps.length;
+  output.checks.dependencies.installed = output.checks.dependencies.items.filter(d => d.installed).length;
+  
+  // Check CLI tools
+  const cliTools = [
+    { name: 'dora', command: '@butttons/dora', description: 'SCIP-based code navigation' },
+    { 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', description: 'BTC/A agent for blockchain tasks' },
+  ];
+  
+  output.checks.cliTools.items = cliTools.map(t => checkCliTool(t.name, t.command, t.description));
+  output.checks.cliTools.total = cliTools.length;
+  output.checks.cliTools.available = output.checks.cliTools.items.filter(t => t.installed).length;
+  
+  // Check native binaries
+  output.checks.nativeBinaries = checkAstGrepNative();
+  
+  // Check config
+  output.checks.config = checkConfig();
+  
+  // Generate action items
+  const missingDeps = output.checks.dependencies.items.filter(d => !d.installed);
+  const missingTools = output.checks.cliTools.items.filter(t => !t.installed);
+  
+  if (missingTools.length > 0) {
+    output.actionItems.push({
+      priority: 'high',
+      action: `Install ${missingTools.length} CLI tool(s)`,
+      command: missingTools.map(t => `npx -y ${t.command}`).join(' && '),
+      reason: 'CLI tools provide code navigation, review, and analysis features',
+    });
+  }
+  
+  if (missingDeps.length > 0) {
+    const important = missingDeps.filter(d => 
+      ['@ast-grep/napi', '@notprolands/ast-grep-mcp', '@paretools/search'].includes(d.name)
+    );
+    
+    if (important.length > 0) {
+      output.actionItems.push({
+        priority: 'medium',
+        action: `Install ${important.length} important package(s)`,
+        command: important.map(d => `npm install ${d.name}`).join(' && '),
+        reason: 'These packages enable core functionality',
+      });
+    }
+  }
+  
+  if (!output.checks.config.exists) {
+    output.actionItems.push({
+      priority: 'low',
+      action: 'Create config file',
+      command: `mkdir -p ~/.config/opencode && cat > ~/.config/opencode/agent_hive.json << 'EOF'\n{\n  "snip": { "enabled": true },\n  "vectorMemory": { "enabled": true }\n}\nEOF`,
+      reason: 'Enable optimizations for better performance',
+    });
+  }
+  
+  // Generate install commands
+  if (missingDeps.length > 0) {
+    output.installCommands.deps = `npm install ${missingDeps.map(d => d.name).join(' ')}`;
+  }
+  
+  if (missingTools.length > 0) {
+    output.installCommands.cliTools = `npx -y ${missingTools.map(t => t.command.split(' ')[0]).join(' ')}`;
+  }
+  
+  // Determine status
+  if (output.actionItems.some(a => a.priority === 'critical')) {
+    output.status = 'action-required';
+  } else if (output.actionItems.some(a => a.priority === 'high' || a.priority === 'medium')) {
+    output.status = 'needs-setup';
+  }
+  
+  return output;
+}
+
+// ============================================================================
+// Print output
+// ============================================================================
+
+function printDoctor(output: DoctorOutput) {
+  console.log('\n' + colors.blue('╔═══════════════════════════════════════════════════════════╗'));
+  console.log(colors.blue('║') + '          🐝 Hive Doctor v' + output.version + ' - System Check' + ' '.repeat(14) + colors.blue('║'));
+  console.log(colors.blue('╚═══════════════════════════════════════════════════════════╝'));
+  
+  // Summary
+  console.log('\n' + colors.gray('─'.repeat(55)));
+  console.log(`  OS: ${output.summary.os}`);
+  console.log(`  Node: ${output.summary.nodeVersion}`);
+  console.log(`  Package Manager: ${output.summary.packageManager}`);
+  console.log(colors.gray('─'.repeat(55)));
+  
+  // Status
+  const statusColor = output.status === 'ready' ? colors.green : 
+                      output.status === 'needs-setup' ? colors.yellow : colors.red;
+  const statusText = output.status === 'ready' ? '✅ READY' : 
+                     output.status === 'needs-setup' ? '⚠️ NEEDS SETUP' : '❌ ACTION REQUIRED';
+  
+  console.log('\n  Status: ' + statusColor(statusText));
+  
+  // Dependencies
+  console.log('\n📦 Dependencies (' + output.checks.dependencies.installed + '/' + output.checks.dependencies.total + ')');
+  for (const dep of output.checks.dependencies.items) {
+    const icon = dep.installed ? colors.green('✅') : colors.yellow('○');
+    const version = dep.version ? colors.gray(`v${dep.version}`) : colors.red('not installed');
+    console.log(`   ${icon} ${dep.name} ${version}`);
+  }
+  
+  // CLI Tools
+  console.log('\n🔧 CLI Tools (' + output.checks.cliTools.available + '/' + output.checks.cliTools.total + ')');
+  for (const tool of output.checks.cliTools.items) {
+    const icon = tool.installed ? colors.green('✅') : colors.yellow('○');
+    const version = tool.version ? colors.gray(`(${tool.version})`) : colors.red('not available');
+    console.log(`   ${icon} ${tool.name} - ${tool.description} ${version}`);
+  }
+  
+  // Native binaries
+  console.log('\n⚡ Native Binaries');
+  if (output.checks.nativeBinaries.status === 'native') {
+    console.log('   ' + colors.green('✅ Native mode (fastest)'));
+  } else {
+    console.log('   ' + colors.yellow('○ CLI mode (falls back via npx)'));
+    if (output.checks.nativeBinaries.reason) {
+      console.log('      ' + colors.gray(output.checks.nativeBinaries.reason));
+    }
+  }
+  
+  // Config
+  console.log('\n⚙️  Config');
+  if (output.checks.config.exists) {
+    console.log('   ' + colors.green('✅ Config file found'));
+    if (output.checks.config.optimizations.length > 0) {
+      console.log('      ' + colors.gray('Optimizations: ' + output.checks.config.optimizations.join(', ')));
+    }
+  } else {
+    console.log('   ' + colors.yellow('○ No config file (optional)'));
+  }
+  
+  // Action items
+  if (output.actionItems.length > 0) {
+    console.log('\n' + colors.gray('─'.repeat(55)));
+    console.log('📋 Action Items\n');
+    
+    for (const item of output.actionItems) {
+      const priorityColor = item.priority === 'critical' ? colors.red :
+                           item.priority === 'high' ? colors.yellow :
+                           item.priority === 'medium' ? colors.blue : colors.gray;
+      
+      console.log(`  [${priorityColor(item.priority.toUpperCase())}] ${item.action}`);
+      console.log(`      ${colors.gray(item.reason)}`);
+      if (item.command) {
+        console.log(`      ${colors.green(item.command)}`);
+      }
+      console.log();
+    }
+  }
+  
+  // Quick install
+  if (output.installCommands.deps || output.installCommands.cliTools) {
+    console.log(colors.gray('─'.repeat(55)));
+    console.log('\n🚀 Quick Install\n');
+    
+    if (output.installCommands.deps) {
+      console.log('  ' + colors.cyan('Dependencies:'));
+      console.log('  ' + colors.green(output.installCommands.deps));
+    }
+    
+    if (output.installCommands.cliTools) {
+      console.log('\n  ' + colors.cyan('CLI Tools:'));
+      console.log('  ' + colors.green(output.installCommands.cliTools));
+    }
+  }
+  
+  console.log('\n' + colors.blue('═'.repeat(55)));
+  console.log(colors.gray('  Run with: bunx @hung319/opencode-hive doctor'));
+  console.log(colors.blue('═'.repeat(55)) + '\n');
+}
+
+// ============================================================================
+// Main
+// ============================================================================
+
+const output = runDoctor();
+printDoctor(output);
+
+// Exit with appropriate code
+process.exit(output.status === 'ready' ? 0 : 1);

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,36 +17908,36 @@ var hiveDoctorTool = tool({
   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
+1. Dependencies - MCP packages, agent tools, blockchain, etc.
+2. CLI Tools - dora, auto-cr, scip-typescript, veil, btca, etc.
+3. 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`,
+- Quick install commands for all missing items
+
+**Tip:** Run standalone before installing: \`bunx @hung319/opencode-hive doctor\``,
   args: {},
   async execute() {
     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")
+      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("veil", "@ushiradineth/veil", "Code discovery and retrieval"),
+      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);
@@ -17988,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) {
@@ -18013,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 = {
@@ -18030,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,
@@ -18056,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", "")
     ]);
@@ -18556,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)
 
@@ -20266,20 +19852,13 @@ 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,
   pare_search: pareSearchMcp,
-  veil: veilMcp,
-  ast_grep: astGrepMcp
+  veil: veilMcp
 };
 var createBuiltinMcps = (disabledMcps = []) => {
   const disabled = new Set(disabledMcps);
@@ -20291,7 +19870,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";
@@ -20300,10 +19879,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";
@@ -21237,22 +20816,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,
@@ -21264,7 +20843,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 {
@@ -21284,12 +20863,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) {
@@ -21299,7 +20878,7 @@ function acquireLockSync(filePath, options = {}) {
       } else if (error45.code === "EEXIST") {
         if (isLockStale(lockPath, opts.staleLockTTL)) {
           try {
-            fs8.unlinkSync(lockPath);
+            fs7.unlinkSync(lockPath);
             continue;
           } catch {}
         }
@@ -21318,11 +20897,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;
   }
@@ -21357,13 +20936,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 = {
@@ -23454,7 +23033,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));
@@ -26648,10 +26227,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$/, ""),
@@ -26664,7 +26243,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;
@@ -26695,8 +26274,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 };
@@ -28558,12 +28137,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/package.json

@@ -1,10 +1,13 @@
 {
   "name": "@hung319/opencode-hive",
-  "version": "1.5.8",
+  "version": "1.6.0",
   "type": "module",
   "description": "OpenCode plugin for Agent Hive - from vibe coding to hive coding",
   "license": "MIT WITH Commons-Clause",
   "author": "hung319",
+  "bin": {
+    "hive-doctor": "./bin/doctor.ts"
+  },
   "repository": {
     "type": "git",
     "url": "https://github.com/hung319/agent-hive.git",
@@ -28,7 +31,7 @@
   "scripts": {
     "clean": "rm -rf dist",
     "generate-skills": "bun run scripts/generate-skills.ts",
-    "build": "npm run clean && npm run generate-skills && bun build src/index.ts --outdir dist --target node --format esm --packages=bundle --external @ast-grep/napi && tsc --emitDeclarationOnly",
+    "build": "npm run clean && npm run generate-skills && bun build src/index.ts --outdir dist --target node --format esm --packages=bundle && tsc --emitDeclarationOnly",
     "dev": "opencode plugin dev",
     "test": "bun test"
   },
@@ -36,12 +39,10 @@
     "@opencode-ai/plugin": ">=0.13.7"
   },
   "dependencies": {
-    "@ast-grep/napi": "^0.41.1",
     "simple-git": "^3.27.0"
   },
   "optionalDependencies": {
     "grep-mcp": "^1.1.0",
-    "@notprolands/ast-grep-mcp": "^1.1.1",
     "@upstash/context7-mcp": "^2.1.0",
     "exa-mcp-server": "^3.1.5",
     "@sparkleideas/agent-booster": "^0.2.3",

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

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

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;