bluera-knowledge 0.13.0 → 0.13.2

package/eslint.config.js

@@ -83,7 +83,7 @@ export default tseslint.config(
     },
   },
   {
-    ignores: ['dist/**', 'node_modules/**', '*.config.js', '*.config.ts', '**/*.test.ts', 'tests/**/*.ts'],
+    ignores: ['dist/**', 'node_modules/**', 'scripts/**', '*.config.js', '*.config.ts', '**/*.test.ts', 'tests/**/*.ts'],
   },
   // Test files: Apply custom skip-comment rule only
   {

package/hooks/check-dependencies.sh

@@ -1,6 +1,15 @@
 #!/bin/bash
 # Bluera Knowledge Plugin - Dependency Checker
 # Automatically checks and installs dependencies for the plugin
+#
+# Environment variables:
+#   BK_SKIP_AUTO_INSTALL=1  - Skip automatic pip installation of crawl4ai
+#                             Set this if you prefer to manage Python packages manually
+#
+# What this script auto-installs (if missing):
+#   - Node.js dependencies (via bun or npm, from package.json)
+#   - crawl4ai Python package (via pip, for web crawling)
+#   - Playwright Chromium browser (via playwright CLI, for headless crawling)
 
 set -e
 
@@ -95,9 +104,17 @@ echo -e "${YELLOW}To enable web crawling, install crawl4ai:${NC}"
 echo -e "  ${GREEN}pip install crawl4ai${NC}"
 echo ""
 
+# Check if auto-install is disabled
+if [ "${BK_SKIP_AUTO_INSTALL:-}" = "1" ]; then
+    echo -e "${YELLOW}[bluera-knowledge] Auto-install disabled (BK_SKIP_AUTO_INSTALL=1)${NC}"
+    echo -e "${YELLOW}Install manually: pip install crawl4ai && python3 -m playwright install chromium${NC}"
+    exit 0
+fi
+
 # Check if we should auto-install
 if command -v pip3 &> /dev/null || command -v pip &> /dev/null; then
-    echo -e "${YELLOW}Attempting automatic installation via pip...${NC}"
+    echo -e "${YELLOW}[bluera-knowledge] Auto-installing crawl4ai via pip...${NC}"
+    echo -e "${YELLOW}(Set BK_SKIP_AUTO_INSTALL=1 to disable auto-install)${NC}"
 
     # Try to install using pip3 or pip
     if command -v pip3 &> /dev/null; then

package/hooks/hooks.json

@@ -40,12 +40,12 @@
           {
             "type": "command",
             "command": "${CLAUDE_PLUGIN_ROOT}/hooks/job-status-hook.sh",
-            "timeout": 5
+            "timeout": 2
           },
           {
             "type": "command",
             "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/skill-activation.py",
-            "timeout": 5
+            "timeout": 2
           }
         ]
       }

package/hooks/posttooluse-bk-reminder.py

@@ -10,6 +10,20 @@ import re
 import sys
 from typing import Any
 
+# Fast string checks - if none of these are in the path, skip regex entirely
+# This avoids regex overhead for the vast majority of file accesses
+LIBRARY_QUICK_CHECKS = frozenset([
+    "node_modules",
+    "vendor",
+    "site-packages",
+    "venv",
+    "bower_components",
+    "packages",
+    ".npm",
+    ".cargo",
+    "go/pkg",
+])
+
 # Patterns indicating library/dependency code
 LIBRARY_PATH_PATTERNS = [
     r"node_modules/",
@@ -28,6 +42,12 @@ LIBRARY_PATH_PATTERNS = [
 LIBRARY_PATTERNS_RE = re.compile("|".join(LIBRARY_PATH_PATTERNS), re.IGNORECASE)
 
 
+def quick_path_check(path: str) -> bool:
+    """Fast check if path might contain library code. Avoids regex for most paths."""
+    path_lower = path.lower()
+    return any(keyword in path_lower for keyword in LIBRARY_QUICK_CHECKS)
+
+
 def extract_library_name(path: str) -> str | None:
     """Extract library name from dependency path."""
     # node_modules/package-name/...
@@ -62,7 +82,11 @@ def check_grep_tool(tool_input: dict[str, Any]) -> tuple[str | None, str | None]
     """Check if Grep targeted library code. Returns (action, library_name)."""
     path = tool_input.get("path", "")
 
-    if path and LIBRARY_PATTERNS_RE.search(path):
+    # Fast path: skip regex if no library keywords present
+    if not path or not quick_path_check(path):
+        return None, None
+
+    if LIBRARY_PATTERNS_RE.search(path):
         lib_name = extract_library_name(path)
         return f"grepped in `{path}`", lib_name
 
@@ -73,7 +97,11 @@ def check_read_tool(tool_input: dict[str, Any]) -> tuple[str | None, str | None]
     """Check if Read targeted library code. Returns (action, library_name)."""
     file_path = tool_input.get("file_path", "")
 
-    if file_path and LIBRARY_PATTERNS_RE.search(file_path):
+    # Fast path: skip regex if no library keywords present
+    if not file_path or not quick_path_check(file_path):
+        return None, None
+
+    if LIBRARY_PATTERNS_RE.search(file_path):
         lib_name = extract_library_name(file_path)
         return f"read `{file_path}`", lib_name
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.13.0",
+  "version": "0.13.2",
   "description": "CLI tool for managing knowledge stores with semantic search",
   "type": "module",
   "bin": {

package/scripts/test-mcp-dev.js

@@ -0,0 +1,260 @@
+#!/usr/bin/env node
+/**
+ * MCP Development Test Helper
+ *
+ * Spawns the MCP server and communicates with it directly via JSON-RPC over stdio.
+ * Used by test-plugin --dev to test MCP functionality without needing the plugin installed.
+ *
+ * Usage:
+ *   ./scripts/test-mcp-dev.mjs call <tool-name> '<json-args>'
+ *   ./scripts/test-mcp-dev.mjs call execute '{"command":"help"}'
+ *   ./scripts/test-mcp-dev.mjs call search '{"query":"test"}'
+ */
+
+import { spawn } from 'node:child_process';
+import { createInterface } from 'node:readline';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = join(__dirname, '..');
+
+class MCPTestClient {
+  constructor() {
+    this.server = null;
+    this.messageId = 0;
+    this.pendingRequests = new Map();
+    this.initialized = false;
+  }
+
+  async start() {
+    return new Promise((resolve, reject) => {
+      const serverPath = join(PROJECT_ROOT, 'dist', 'mcp', 'server.js');
+
+      this.server = spawn('node', [serverPath], {
+        cwd: PROJECT_ROOT,
+        env: {
+          ...process.env,
+          PROJECT_ROOT: PROJECT_ROOT,
+          DATA_DIR: '.bluera/bluera-knowledge/data',
+          CONFIG_PATH: '.bluera/bluera-knowledge/config.json',
+        },
+        stdio: ['pipe', 'pipe', 'pipe'],
+      });
+
+      // Handle stderr (logs)
+      this.server.stderr.on('data', (data) => {
+        // Suppress server logs in test output unless DEBUG
+        if (process.env.DEBUG) {
+          process.stderr.write(`[server] ${data}`);
+        }
+      });
+
+      // Handle stdout (JSON-RPC responses)
+      const rl = createInterface({ input: this.server.stdout });
+      rl.on('line', (line) => {
+        try {
+          const msg = JSON.parse(line);
+          if (msg.id !== undefined && this.pendingRequests.has(msg.id)) {
+            const { resolve, reject } = this.pendingRequests.get(msg.id);
+            this.pendingRequests.delete(msg.id);
+            if (msg.error) {
+              reject(new Error(msg.error.message || JSON.stringify(msg.error)));
+            } else {
+              resolve(msg.result);
+            }
+          }
+        } catch {
+          // Not JSON or parse error - ignore
+        }
+      });
+
+      this.server.on('error', reject);
+      this.server.on('spawn', () => {
+        // Give server a moment to initialize
+        setTimeout(() => resolve(), 100);
+      });
+    });
+  }
+
+  async initialize() {
+    if (this.initialized) return;
+
+    // Send initialize request
+    const initResult = await this.sendRequest('initialize', {
+      protocolVersion: '2024-11-05',
+      capabilities: {},
+      clientInfo: { name: 'test-mcp-dev', version: '1.0.0' },
+    });
+
+    // Send initialized notification
+    this.sendNotification('notifications/initialized', {});
+
+    this.initialized = true;
+    return initResult;
+  }
+
+  sendRequest(method, params) {
+    return new Promise((resolve, reject) => {
+      const id = ++this.messageId;
+      const request = { jsonrpc: '2.0', id, method, params };
+
+      this.pendingRequests.set(id, { resolve, reject });
+
+      // Set timeout for request
+      setTimeout(() => {
+        if (this.pendingRequests.has(id)) {
+          this.pendingRequests.delete(id);
+          reject(new Error(`Request timeout: ${method}`));
+        }
+      }, 30000);
+
+      this.server.stdin.write(JSON.stringify(request) + '\n');
+    });
+  }
+
+  sendNotification(method, params) {
+    const notification = { jsonrpc: '2.0', method, params };
+    this.server.stdin.write(JSON.stringify(notification) + '\n');
+  }
+
+  async callTool(name, args) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    const result = await this.sendRequest('tools/call', {
+      name,
+      arguments: args,
+    });
+
+    return result;
+  }
+
+  async listTools() {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+
+    return this.sendRequest('tools/list', {});
+  }
+
+  stop() {
+    if (this.server) {
+      this.server.kill('SIGTERM');
+      this.server = null;
+    }
+  }
+}
+
+// Session mode - reads multiple commands from stdin, maintains server across calls
+async function sessionMode() {
+  const client = new MCPTestClient();
+  await client.start();
+
+  const rl = createInterface({ input: process.stdin });
+  const results = [];
+  let lastResultId = null;
+
+  for await (const line of rl) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const spaceIndex = trimmed.indexOf(' ');
+    const toolName = spaceIndex > 0 ? trimmed.slice(0, spaceIndex) : trimmed;
+    let argsStr = spaceIndex > 0 ? trimmed.slice(spaceIndex + 1) : '{}';
+
+    // Substitute $LAST_ID with actual result ID from previous search
+    if (lastResultId && argsStr.includes('$LAST_ID')) {
+      argsStr = argsStr.replace(/\$LAST_ID/g, lastResultId);
+    }
+
+    const args = JSON.parse(argsStr);
+    const result = await client.callTool(toolName, args);
+    results.push(result);
+
+    // Extract result ID for next call (search results have results[0].id)
+    // Search results have a header line before JSON, so find first '{'
+    if (result?.content?.[0]?.text) {
+      const text = result.content[0].text;
+      const jsonStart = text.indexOf('{');
+      if (jsonStart >= 0) {
+        try {
+          const parsed = JSON.parse(text.slice(jsonStart));
+          if (parsed.results?.[0]?.id) {
+            lastResultId = parsed.results[0].id;
+          }
+        } catch {
+          // Not valid JSON or no results - ignore
+        }
+      }
+    }
+  }
+
+  client.stop();
+  console.log(JSON.stringify(results, null, 2));
+}
+
+// CLI interface
+async function main() {
+  const args = process.argv.slice(2);
+
+  if (args.length < 1) {
+    console.error('Usage: test-mcp-dev.js <command> [args...]');
+    console.error('Commands:');
+    console.error('  call <tool-name> <json-args>  - Call an MCP tool (one-shot)');
+    console.error('  session                       - Read commands from stdin (persistent server)');
+    console.error('  list                          - List available tools');
+    console.error('');
+    console.error('Examples:');
+    console.error('  ./scripts/test-mcp-dev.js call execute \'{"command":"help"}\'');
+    console.error('  ./scripts/test-mcp-dev.js call search \'{"query":"test"}\'');
+    console.error('  ./scripts/test-mcp-dev.js list');
+    console.error('');
+    console.error('Session mode (maintains cache across calls):');
+    console.error('  echo -e \'search {"query":"test"}\\nget_full_context {"resultId":"$LAST_ID"}\' | ./scripts/test-mcp-dev.js session');
+    process.exit(1);
+  }
+
+  const command = args[0];
+
+  // Session mode handles its own client lifecycle
+  if (command === 'session') {
+    await sessionMode();
+    return;
+  }
+
+  const client = new MCPTestClient();
+
+  try {
+    await client.start();
+
+    if (command === 'call') {
+      if (args.length < 3) {
+        console.error('Usage: test-mcp-dev.js call <tool-name> <json-args>');
+        process.exit(1);
+      }
+
+      const toolName = args[1];
+      const toolArgs = JSON.parse(args[2]);
+
+      const result = await client.callTool(toolName, toolArgs);
+
+      // Output result as JSON for parsing by test-plugin
+      console.log(JSON.stringify(result, null, 2));
+    } else if (command === 'list') {
+      const result = await client.listTools();
+      console.log(JSON.stringify(result, null, 2));
+    } else {
+      console.error(`Unknown command: ${command}`);
+      process.exit(1);
+    }
+  } catch (error) {
+    console.error(`Error: ${error.message}`);
+    process.exit(1);
+  } finally {
+    client.stop();
+  }
+}
+
+main();

package/src/mcp/plugin-mcp-config.test.ts

@@ -3,25 +3,32 @@ import { readFileSync, existsSync } from 'fs';
 import { join } from 'path';
 
 /**
- * Tests to verify plugin.json is correctly configured for MCP server.
+ * Tests to verify .mcp.json is correctly configured for MCP server.
  * The MCP server must work when the plugin is installed via marketplace.
  *
  * Key requirements:
  * - Must use ${CLAUDE_PLUGIN_ROOT} for server path (resolves to plugin cache)
  * - Must set PROJECT_ROOT env var (required by server fail-fast check)
  * - Must NOT use relative paths (would resolve to user's project, not plugin)
+ *
+ * Note: We use .mcp.json at plugin root (not inline in plugin.json) due to
+ * Claude Code Bug #16143 where inline mcpServers is ignored during parsing.
+ * See: https://github.com/anthropics/claude-code/issues/16143
  */
-describe('Plugin MCP Configuration (.claude-plugin/plugin.json)', () => {
-  const configPath = join(process.cwd(), '.claude-plugin/plugin.json');
-  const config = JSON.parse(readFileSync(configPath, 'utf-8'));
+describe('Plugin MCP Configuration (.mcp.json)', () => {
+  const mcpJsonPath = join(process.cwd(), '.mcp.json');
+  const config = JSON.parse(readFileSync(mcpJsonPath, 'utf-8'));
+
+  it('has .mcp.json file at plugin root', () => {
+    expect(existsSync(mcpJsonPath)).toBe(true);
+  });
 
-  it('has mcpServers configuration inline', () => {
-    expect(config).toHaveProperty('mcpServers');
-    expect(config.mcpServers).toHaveProperty('bluera-knowledge');
+  it('has bluera-knowledge server configuration', () => {
+    expect(config).toHaveProperty('bluera-knowledge');
   });
 
   it('uses ${CLAUDE_PLUGIN_ROOT} for server path (required for plugin mode)', () => {
-    const serverConfig = config.mcpServers['bluera-knowledge'];
+    const serverConfig = config['bluera-knowledge'];
     const argsString = JSON.stringify(serverConfig.args);
 
     // CLAUDE_PLUGIN_ROOT is set by Claude Code when plugin is installed
@@ -31,7 +38,7 @@ describe('Plugin MCP Configuration (.claude-plugin/plugin.json)', () => {
   });
 
   it('does NOT use relative paths (would break in plugin mode)', () => {
-    const serverConfig = config.mcpServers['bluera-knowledge'];
+    const serverConfig = config['bluera-knowledge'];
     const argsString = JSON.stringify(serverConfig.args);
 
     // Relative paths like ./dist would resolve to user's project directory
@@ -40,7 +47,7 @@ describe('Plugin MCP Configuration (.claude-plugin/plugin.json)', () => {
   });
 
   it('sets PROJECT_ROOT environment variable (required by fail-fast server)', () => {
-    const serverConfig = config.mcpServers['bluera-knowledge'];
+    const serverConfig = config['bluera-knowledge'];
 
     // PROJECT_ROOT is required since b404cd6 (fail-fast change)
     expect(serverConfig.env).toHaveProperty('PROJECT_ROOT');
@@ -49,16 +56,16 @@ describe('Plugin MCP Configuration (.claude-plugin/plugin.json)', () => {
 });
 
 /**
- * Tests to ensure .mcp.json is NOT distributed with the plugin.
- * .mcp.json at project root causes confusion between plugin and project config.
+ * Tests to ensure plugin.json does NOT have inline mcpServers.
+ * Inline mcpServers is broken due to Claude Code Bug #16143.
  */
-describe('No conflicting .mcp.json in repo', () => {
-  it('does NOT have .mcp.json in repo root (prevents config confusion)', () => {
-    const mcpJsonPath = join(process.cwd(), '.mcp.json');
+describe('plugin.json does NOT have inline mcpServers', () => {
+  it('plugin.json does NOT contain mcpServers (would be ignored by Claude Code)', () => {
+    const pluginJsonPath = join(process.cwd(), '.claude-plugin/plugin.json');
+    const pluginConfig = JSON.parse(readFileSync(pluginJsonPath, 'utf-8'));
 
-    // .mcp.json should NOT exist in the repo
-    // - For plugin mode: use mcpServers in plugin.json
-    // - For development: use ~/.claude.json per README
-    expect(existsSync(mcpJsonPath)).toBe(false);
+    // mcpServers in plugin.json is ignored due to Bug #16143
+    // All MCP config should be in .mcp.json at plugin root
+    expect(pluginConfig).not.toHaveProperty('mcpServers');
   });
 });

package/tests/integration/cli-consistency.test.ts

@@ -182,10 +182,11 @@ describe('CLI Consistency', () => {
     beforeAll(async () => {
       try {
         cli(`store create quiet-test-store --type file --source "${testFilesDir}"`);
+        cli('index quiet-test-store');
       } catch {
         // Store may already exist
       }
-    });
+    }, 120000);
 
     it('--quiet suppresses all output for index on success', () => {
       const result = runCli('index quiet-test-store --quiet');
@@ -204,7 +205,7 @@ describe('CLI Consistency', () => {
     });
 
     it('--quiet outputs only paths for search', () => {
-      const result = runCli('search "test" --quiet');
+      const result = runCli('search "test" --stores quiet-test-store --quiet');
       expect(result.exitCode).toBe(0);
       // Should not contain verbose headers
       expect(result.stdout).not.toContain('Search:');