bluera-knowledge 0.16.6 → 0.17.1

package/hooks/check-dependencies.sh

@@ -1,145 +0,0 @@
-#!/bin/bash
-# Bluera Knowledge Plugin - Dependency Checker
-# Automatically checks and installs dependencies for the plugin
-#
-# Environment variables:
-#   BK_SKIP_AUTO_INSTALL=1  - Skip automatic 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)
-#   - Python virtual environment with crawl4ai (isolated from system Python)
-#   - Playwright Chromium browser (via playwright CLI, for headless crawling)
-
-set -e
-
-# Get the plugin root directory
-PLUGIN_ROOT="${CLAUDE_PLUGIN_ROOT:-$(dirname "$(dirname "$0")")}"
-
-# Venv location within plugin (isolated from system Python)
-VENV_DIR="$PLUGIN_ROOT/.venv"
-VENV_PYTHON="$VENV_DIR/bin/python3"
-VENV_PIP="$VENV_DIR/bin/pip"
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# =====================
-# Helper Functions
-# =====================
-
-# Install Playwright browser using specified python
-# Args: $1 = python path to use
-install_playwright_browser() {
-    local PYTHON_CMD="${1:-python3}"
-
-    # Check if Playwright Chromium is already installed by testing if browser can be launched
-    if "$PYTHON_CMD" -c "from playwright.sync_api import sync_playwright; p = sync_playwright().start(); b = p.chromium.launch(); b.close(); p.stop()" 2>/dev/null; then
-        echo -e "${GREEN}[bluera-knowledge] Playwright Chromium ready ✓${NC}"
-        return 0
-    fi
-
-    echo -e "${YELLOW}[bluera-knowledge] Installing Playwright browser (one-time setup)...${NC}"
-    if "$PYTHON_CMD" -m playwright install chromium 2>/dev/null; then
-        echo -e "${GREEN}[bluera-knowledge] Playwright Chromium installed ✓${NC}"
-        return 0
-    else
-        echo -e "${YELLOW}[bluera-knowledge] Playwright browser install failed.${NC}"
-        echo -e "${YELLOW}Manual fix: $PYTHON_CMD -m playwright install chromium${NC}"
-        return 1
-    fi
-}
-
-# =====================
-# Node.js Dependencies
-# =====================
-
-# Check if node_modules exists
-if [ ! -d "$PLUGIN_ROOT/node_modules" ]; then
-    echo -e "${YELLOW}[bluera-knowledge] Installing Node.js dependencies...${NC}"
-
-    # Try bun first (faster), fall back to npm
-    if command -v bun &> /dev/null; then
-        (cd "$PLUGIN_ROOT" && bun install --frozen-lockfile 2>/dev/null) && \
-            echo -e "${GREEN}[bluera-knowledge] Node.js dependencies installed ✓${NC}" || \
-            echo -e "${RED}[bluera-knowledge] Failed to install Node.js dependencies${NC}"
-    elif command -v npm &> /dev/null; then
-        (cd "$PLUGIN_ROOT" && npm ci --silent 2>/dev/null) && \
-            echo -e "${GREEN}[bluera-knowledge] Node.js dependencies installed ✓${NC}" || \
-            echo -e "${RED}[bluera-knowledge] Failed to install Node.js dependencies${NC}"
-    else
-        echo -e "${RED}[bluera-knowledge] Neither bun nor npm found. Please install Node.js dependencies manually.${NC}"
-    fi
-fi
-
-# =====================
-# Python Dependencies (using venv)
-# =====================
-
-# Check if Python3 is installed
-if ! command -v python3 &> /dev/null; then
-    echo -e "${RED}[bluera-knowledge] Python3 is not installed${NC}"
-    echo -e "${YELLOW}Web crawling features require Python 3.x${NC}"
-    echo -e "${YELLOW}Install Python3: https://www.python.org/downloads/${NC}"
-    exit 0  # Don't block the session, just warn
-fi
-
-# Check Python version (require 3.8+)
-python_version=$(python3 -c 'import sys; print(".".join(map(str, sys.version_info[:2])))')
-
-if ! python3 -c "import sys; exit(0 if sys.version_info >= (3, 8) else 1)"; then
-    echo -e "${YELLOW}[bluera-knowledge] Python ${python_version} detected. Python 3.8+ recommended for crawl4ai${NC}"
-fi
-
-# Check if venv exists and has crawl4ai installed
-if [ -f "$VENV_PYTHON" ] && "$VENV_PYTHON" -c "import crawl4ai" 2>/dev/null; then
-    crawl4ai_version=$("$VENV_PYTHON" -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "unknown")
-    echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} ready (venv) ✓${NC}"
-    # Ensure Playwright browser is installed for headless crawling
-    install_playwright_browser "$VENV_PYTHON"
-    exit 0
-fi
-
-# 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}To enable web crawling, create venv manually:${NC}"
-    echo -e "  ${GREEN}python3 -m venv $VENV_DIR${NC}"
-    echo -e "  ${GREEN}$VENV_PIP install crawl4ai${NC}"
-    echo -e "  ${GREEN}$VENV_PYTHON -m playwright install chromium${NC}"
-    exit 0
-fi
-
-# Create venv if it doesn't exist
-if [ ! -d "$VENV_DIR" ]; then
-    echo -e "${YELLOW}[bluera-knowledge] Creating Python virtual environment...${NC}"
-    if python3 -m venv "$VENV_DIR" 2>/dev/null; then
-        echo -e "${GREEN}[bluera-knowledge] Virtual environment created ✓${NC}"
-    else
-        echo -e "${RED}[bluera-knowledge] Failed to create virtual environment${NC}"
-        echo -e "${YELLOW}Manual fix: python3 -m venv $VENV_DIR${NC}"
-        exit 0
-    fi
-fi
-
-# Install crawl4ai into venv
-echo -e "${YELLOW}[bluera-knowledge] Installing crawl4ai into virtual environment...${NC}"
-echo -e "${YELLOW}(Set BK_SKIP_AUTO_INSTALL=1 to disable auto-install)${NC}"
-
-if "$VENV_PIP" install --quiet crawl4ai 2>/dev/null; then
-    crawl4ai_version=$("$VENV_PYTHON" -c "import crawl4ai; print(crawl4ai.__version__)" 2>/dev/null || echo "installed")
-    echo -e "${GREEN}[bluera-knowledge] crawl4ai ${crawl4ai_version} installed (venv) ✓${NC}"
-    # Install Playwright browser for headless crawling
-    install_playwright_browser "$VENV_PYTHON"
-else
-    echo -e "${RED}[bluera-knowledge] Failed to install crawl4ai${NC}"
-    echo -e "${YELLOW}Manual fix:${NC}"
-    echo -e "  ${GREEN}$VENV_PIP install crawl4ai${NC}"
-    echo -e "  ${GREEN}$VENV_PYTHON -m playwright install chromium${NC}"
-fi
-
-# Always exit 0 to not block the session
-exit 0

package/hooks/format-search-results.py

@@ -1,132 +0,0 @@
-#!/usr/bin/env python3
-"""
-PostToolUse hook to format mcp__bluera-knowledge__search results
-into a fixed-width table with deterministic output.
-"""
-
-import json
-import sys
-import os
-
-# Column widths (content only, not including | separators)
-SCORE_WIDTH = 6   # Right-aligned: " 1.00 "
-STORE_WIDTH = 12  # Left-aligned: "store       "
-FILE_WIDTH = 45   # Left-aligned: "path/to/file..."
-PURPOSE_WIDTH = 48  # Left-aligned: "Purpose text..."
-
-
-def truncate(text: str, max_len: int) -> str:
-    """Truncate text with ellipsis if needed."""
-    if len(text) <= max_len:
-        return text
-    return text[:max_len - 3] + "..."
-
-
-def format_score(score: float) -> str:
-    """Format score as right-aligned fixed-width string."""
-    return f"{score:5.2f}".rjust(SCORE_WIDTH)
-
-
-def format_store(store_name: str) -> str:
-    """Format store name as left-aligned fixed-width string."""
-    truncated = truncate(store_name, STORE_WIDTH)
-    return truncated.ljust(STORE_WIDTH)
-
-
-def format_file(location: str, repo_root: str) -> str:
-    """Format file path as left-aligned fixed-width string."""
-    # Strip repo root prefix
-    if repo_root and location.startswith(repo_root):
-        path = location[len(repo_root):].lstrip("/")
-    else:
-        path = location
-    truncated = truncate(path, FILE_WIDTH)
-    return truncated.ljust(FILE_WIDTH)
-
-
-def format_purpose(purpose: str) -> str:
-    """Format purpose as left-aligned fixed-width string."""
-    # Clean up purpose text
-    clean = purpose.replace("\n", " ").strip()
-    truncated = truncate(clean, PURPOSE_WIDTH)
-    return truncated.ljust(PURPOSE_WIDTH)
-
-
-def format_table(results: list, query: str) -> str:
-    """Format search results into a fixed-width markdown table."""
-    lines = []
-
-    # Header
-    lines.append(f"## Search Results for \"{query}\"")
-    lines.append("")
-
-    if not results:
-        lines.append(f"No results found for \"{query}\"")
-        lines.append("")
-        lines.append("Try:")
-        lines.append("- Broadening your search terms")
-        lines.append("- Checking if the relevant stores are indexed")
-        lines.append("- Using /bluera-knowledge:stores to see available stores")
-        return "\n".join(lines)
-
-    # Table header
-    header = f"| {'Score'.rjust(SCORE_WIDTH)} | {'Store'.ljust(STORE_WIDTH)} | {'File'.ljust(FILE_WIDTH)} | {'Purpose'.ljust(PURPOSE_WIDTH)} |"
-    # Separator: Score is right-aligned (colon at end), others are left-aligned
-    # The +2 accounts for the spaces around content, -1 for the colon on Score column
-    separator = f"|{'-' * (SCORE_WIDTH + 1)}:|{'-' * (STORE_WIDTH + 2)}|{'-' * (FILE_WIDTH + 2)}|{'-' * (PURPOSE_WIDTH + 2)}|"
-
-    lines.append(header)
-    lines.append(separator)
-
-    # Data rows
-    for result in results:
-        score = result.get("score", 0)
-        summary = result.get("summary", {})
-        store_name = summary.get("storeName", "unknown")
-        location = summary.get("location", "")
-        repo_root = summary.get("repoRoot", "")
-        purpose = summary.get("purpose", "")
-
-        row = f"| {format_score(score)} | {format_store(store_name)} | {format_file(location, repo_root)} | {format_purpose(purpose)} |"
-        lines.append(row)
-
-    lines.append("")
-    lines.append(f"**Found**: {len(results)} results")
-
-    return "\n".join(lines)
-
-
-def main():
-    try:
-        # Read hook input from stdin
-        input_data = json.load(sys.stdin)
-
-        tool_name = input_data.get("tool_name", "")
-        tool_input = input_data.get("tool_input", {})
-        tool_result = input_data.get("tool_result", {})
-
-        # Only process search results
-        if tool_name != "mcp__bluera-knowledge__search":
-            sys.exit(0)
-
-        # Extract results and query
-        results = tool_result.get("results", [])
-        query = tool_input.get("query", "")
-
-        # Format the table
-        formatted = format_table(results, query)
-
-        # Output the formatted table
-        # For PostToolUse, stdout is shown in the transcript
-        print(formatted)
-
-    except json.JSONDecodeError as e:
-        print(f"Error parsing hook input: {e}", file=sys.stderr)
-        sys.exit(1)
-    except Exception as e:
-        print(f"Error formatting results: {e}", file=sys.stderr)
-        sys.exit(1)
-
-
-if __name__ == "__main__":
-    main()

package/hooks/hooks.json

@@ -1,54 +0,0 @@
-{
-  "description": "bluera-knowledge plugin hooks - dependency checking, job monitoring, and BK suggestions",
-  "hooks": {
-    "PostToolUse": [
-      {
-        "matcher": "Grep",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse-bk-reminder.py",
-            "timeout": 3
-          }
-        ]
-      },
-      {
-        "matcher": "Read",
-        "hooks": [
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse-bk-reminder.py",
-            "timeout": 3
-          }
-        ]
-      }
-    ],
-    "SessionStart": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/check-dependencies.sh",
-            "timeout": 30
-          }
-        ]
-      }
-    ],
-    "UserPromptSubmit": [
-      {
-        "hooks": [
-          {
-            "type": "command",
-            "command": "${CLAUDE_PLUGIN_ROOT}/hooks/job-status-hook.sh",
-            "timeout": 2
-          },
-          {
-            "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/skill-activation.py",
-            "timeout": 2
-          }
-        ]
-      }
-    ]
-  }
-}

package/hooks/job-status-hook.sh

@@ -1,51 +0,0 @@
-#!/bin/bash
-# Show active jobs in context when user submits a prompt
-#
-# This hook runs on UserPromptSubmit events and injects
-# information about active background jobs into the context.
-
-JOBS_DIR="$HOME/.local/share/bluera-knowledge/jobs"
-
-# Exit silently if jobs directory doesn't exist
-if [ ! -d "$JOBS_DIR" ]; then
-  exit 0
-fi
-
-# Find active jobs (modified in last 60 minutes)
-active_jobs=$(find "$JOBS_DIR" -name "*.json" -type f -not -name "*.pid" -mmin -60 2>/dev/null | while read -r file; do
-  # Skip if file doesn't exist or isn't readable
-  if [ ! -r "$file" ]; then
-    continue
-  fi
-
-  # Extract job details using jq (if available) or grep fallback
-  if command -v jq >/dev/null 2>&1; then
-    status=$(jq -r '.status' "$file" 2>/dev/null || echo "unknown")
-    if [ "$status" = "running" ] || [ "$status" = "pending" ]; then
-      job_id=$(basename "$file" .json)
-      type=$(jq -r '.type' "$file" 2>/dev/null || echo "unknown")
-      progress=$(jq -r '.progress' "$file" 2>/dev/null || echo "0")
-      message=$(jq -r '.message' "$file" 2>/dev/null || echo "No message")
-      echo "- $type job ($job_id): ${progress}% - $message"
-    fi
-  else
-    # Fallback using grep if jq not available
-    status=$(grep -o '"status"[[:space:]]*:[[:space:]]*"[^"]*"' "$file" | cut -d'"' -f4)
-    if [ "$status" = "running" ] || [ "$status" = "pending" ]; then
-      job_id=$(basename "$file" .json)
-      type=$(grep -o '"type"[[:space:]]*:[[:space:]]*"[^"]*"' "$file" | cut -d'"' -f4)
-      progress=$(grep -o '"progress"[[:space:]]*:[[:space:]]*[0-9.]*' "$file" | awk '{print $NF}')
-      message=$(grep -o '"message"[[:space:]]*:[[:space:]]*"[^"]*"' "$file" | cut -d'"' -f4)
-      echo "- $type job ($job_id): ${progress}% - $message"
-    fi
-  fi
-done)
-
-# Output active jobs if any found
-if [ -n "$active_jobs" ]; then
-  echo ""
-  echo "Active background jobs:"
-  echo "$active_jobs"
-  echo ""
-  echo "Check status with: /bluera-knowledge:check-status"
-fi

package/hooks/posttooluse-bk-reminder.py

@@ -1,166 +0,0 @@
-#!/usr/bin/env python3
-"""
-PostToolUse hook for bluera-knowledge plugin.
-Fires after Claude reads/greps in dependency directories,
-reminding to consider using BK for similar future queries.
-"""
-
-import json
-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/",
-    r"vendor/",
-    r"site-packages/",
-    r"\.venv/",
-    r"venv/",
-    r"bower_components/",
-    r"packages/.*/node_modules/",
-    r"\.npm/",
-    r"\.cargo/registry/",
-    r"go/pkg/mod/",
-]
-
-# Compile patterns for efficiency
-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/...
-    match = re.search(r"node_modules/(@[^/]+/[^/]+|[^/]+)", path)
-    if match:
-        return match.group(1)
-
-    # site-packages/package_name/...
-    match = re.search(r"site-packages/([^/]+)", path)
-    if match:
-        return match.group(1)
-
-    # vendor/package/...
-    match = re.search(r"vendor/([^/]+)", path)
-    if match:
-        return match.group(1)
-
-    # .cargo/registry/.../package-name-version/...
-    match = re.search(r"\.cargo/registry/[^/]+/([^/]+)-\d", path)
-    if match:
-        return match.group(1)
-
-    # go/pkg/mod/package@version/...
-    match = re.search(r"go/pkg/mod/([^@]+)@", path)
-    if match:
-        return match.group(1)
-
-    return None
-
-
-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", "")
-
-    # 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
-
-    return None, None
-
-
-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", "")
-
-    # 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
-
-    return None, None
-
-
-def main() -> int:
-    try:
-        stdin_data = sys.stdin.read()
-        if not stdin_data.strip():
-            return 0
-        hook_input = json.loads(stdin_data)
-    except json.JSONDecodeError:
-        return 0
-
-    tool_name = hook_input.get("tool_name", "")
-    tool_input = hook_input.get("tool_input", {})
-
-    action = None
-    lib_name = None
-
-    if tool_name == "Grep":
-        action, lib_name = check_grep_tool(tool_input)
-    elif tool_name == "Read":
-        action, lib_name = check_read_tool(tool_input)
-
-    if not action:
-        return 0
-
-    # Build context-aware reminder
-    lib_hint = f" ({lib_name})" if lib_name else ""
-    add_suggestion = (
-        f"If {lib_name} is not indexed, consider: /bluera-knowledge:add-repo"
-        if lib_name
-        else "Consider indexing frequently-used libraries with /bluera-knowledge:add-repo"
-    )
-
-    reminder_text = f"""BLUERA-KNOWLEDGE REMINDER
-
-You just {action} - this is dependency/library code{lib_hint}.
-
-For FUTURE queries about this library, use Bluera Knowledge instead:
-- MCP tool: search(query="your question about {lib_name or 'the library'}")
-- Slash command: /bluera-knowledge:search <query>
-
-BK provides indexed, semantic search across library sources - significantly faster
-and more context-efficient than reading through dependency directories.
-
-{add_suggestion}"""
-
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "PostToolUse",
-            "additionalContext": reminder_text,
-        }
-    }
-    print(json.dumps(output))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())