bluera-knowledge 0.16.5 → 0.17.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())

package/hooks/skill-activation.py

@@ -1,194 +0,0 @@
-#!/usr/bin/env python3
-"""
-Skill activation hook for bluera-knowledge plugin.
-Matches user prompts against skill rules and injects activation reminders.
-
-Runs on UserPromptSubmit to detect users who would benefit from learning
-about BK skills, while excluding users who already know BK terminology.
-"""
-
-import json
-import os
-import re
-import sys
-from pathlib import Path
-from typing import Any
-
-CONFIG_DIR = Path.home() / ".local" / "share" / "bluera-knowledge"
-CONFIG_FILE = CONFIG_DIR / "skill-activation.json"
-DEFAULT_CONFIG: dict[str, Any] = {
-    "enabled": True,
-    "threshold": 1,
-    "skills": {
-        "knowledge-search": True,
-        "when-to-query": True,
-        "search-optimization": True,
-        "advanced-workflows": True,
-        "store-lifecycle": True,
-    },
-}
-
-
-def load_config() -> dict[str, Any]:
-    """Load skill activation configuration."""
-    if not CONFIG_FILE.exists():
-        return DEFAULT_CONFIG.copy()
-    try:
-        with open(CONFIG_FILE, encoding="utf-8") as f:
-            return json.load(f)
-    except (json.JSONDecodeError, IOError):
-        return DEFAULT_CONFIG.copy()
-
-
-def load_rules(plugin_root: Path) -> dict[str, Any]:
-    """Load skill rules from plugin hooks directory."""
-    rules_path = plugin_root / "hooks" / "skill-rules.json"
-    if not rules_path.exists():
-        return {"skills": [], "threshold": 1, "globalExclusions": []}
-    with open(rules_path, encoding="utf-8") as f:
-        return json.load(f)
-
-
-def matches_condition(prompt: str, condition: dict[str, Any]) -> bool:
-    """Check if prompt matches a single condition (keyword or regex)."""
-    prompt_lower = prompt.lower()
-    if "keyword" in condition:
-        return condition["keyword"].lower() in prompt_lower
-    if "regex" in condition:
-        return bool(re.search(condition["regex"], prompt, flags=re.IGNORECASE))
-    return False
-
-
-def check_exclusions(
-    prompt: str, exclusions: list[dict[str, Any]]
-) -> bool:
-    """Check if any exclusion pattern matches. Returns True if excluded."""
-    for exc in exclusions:
-        if matches_condition(prompt, exc):
-            return True
-    return False
-
-
-def score_skill(
-    prompt: str, skill: dict[str, Any]
-) -> tuple[int, list[str]]:
-    """Score a skill against the user prompt. Returns (score, reasons)."""
-    reasons: list[str] = []
-    score = 0
-
-    # Check skill-specific exclusions first
-    if check_exclusions(prompt, skill.get("exclusions", [])):
-        return 0, []
-
-    for trigger in skill.get("triggers", []):
-        if matches_condition(prompt, trigger):
-            weight = trigger.get("weight", 1)
-            score += weight
-            if "keyword" in trigger:
-                reasons.append(f'keyword "{trigger["keyword"]}"')
-            elif "regex" in trigger:
-                reasons.append(f'pattern match')
-
-    return score, reasons
-
-
-def generate_reminder(
-    matches: list[tuple[str, int, list[str], str]]
-) -> str:
-    """Generate assertive skill activation reminder using forced evaluation pattern."""
-    lines = [
-        "BLUERA-KNOWLEDGE SKILL ACTIVATION - MANDATORY EVALUATION",
-        "",
-        "CRITICAL: Complete these steps IN ORDER before answering:",
-        "",
-        "STEP 1 - EVALUATE each skill (YES/NO with one-line reason):",
-    ]
-
-    for name, score, reasons, description in matches:
-        lines.append(f"  • [{name}] - {description}")
-        lines.append(f"    Triggered by: {', '.join(reasons[:2])}")
-
-    lines.append("")
-    lines.append("STEP 2 - ACTIVATE: For each YES, invoke Skill(skill='bluera-knowledge:<name>') NOW")
-    lines.append("")
-    lines.append("STEP 3 - RESPOND: Only after activation, answer the user's question")
-    lines.append("")
-    lines.append("WARNING: This evaluation is WORTHLESS if you skip activation.")
-    lines.append("Skills provide indexed library knowledge - faster than grepping node_modules.")
-
-    return "\n".join(lines)
-
-
-def main() -> int:
-    # Load configuration
-    config = load_config()
-
-    # Check if skill activation is enabled
-    if not config.get("enabled", True):
-        return 0
-
-    # Get plugin root from environment
-    plugin_root_env = os.environ.get("CLAUDE_PLUGIN_ROOT", "")
-    if not plugin_root_env:
-        return 0
-    plugin_root = Path(plugin_root_env)
-
-    # Read hook input from stdin
-    try:
-        stdin_data = sys.stdin.read()
-        if not stdin_data.strip():
-            return 0
-        hook_input = json.loads(stdin_data)
-    except json.JSONDecodeError:
-        return 0
-
-    prompt = hook_input.get("prompt", "")
-    if not prompt.strip():
-        return 0
-
-    # Load rules
-    rules = load_rules(plugin_root)
-
-    # Check global exclusions first
-    if check_exclusions(prompt, rules.get("globalExclusions", [])):
-        return 0
-
-    threshold = config.get("threshold", rules.get("threshold", 1))
-    enabled_skills = config.get("skills", {})
-
-    # Score each skill
-    matches: list[tuple[str, int, list[str], str]] = []
-
-    for skill in rules.get("skills", []):
-        name = skill["name"]
-
-        # Skip disabled skills
-        if not enabled_skills.get(name, True):
-            continue
-
-        score, reasons = score_skill(prompt, skill)
-        if score >= threshold:
-            matches.append((name, score, reasons, skill.get("description", "")))
-
-    # No matches - silent exit
-    if not matches:
-        return 0
-
-    # Sort by score (highest first)
-    matches.sort(key=lambda t: t[1], reverse=True)
-
-    # Generate and output the reminder using proper JSON format
-    reminder = generate_reminder(matches)
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "UserPromptSubmit",
-            "additionalContext": reminder,
-        }
-    }
-    print(json.dumps(output))
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())