bluera-knowledge 0.12.2 → 0.12.3

package/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bluera-knowledge",
-  "version": "0.12.2",
+  "version": "0.12.3",
   "description": "Clone repos, crawl docs, search locally. Fast, authoritative answers for AI coding agents.",
   "mcpServers": {
     "bluera-knowledge": {

package/CHANGELOG.md

@@ -2,6 +2,20 @@
 
 All notable changes to this project will be documented in this file. See [commit-and-tag-version](https://github.com/absolute-version/commit-and-tag-version) for commit guidelines.
 
+## [0.12.3](https://github.com/blueraai/bluera-knowledge/compare/v0.11.21...v0.12.3) (2026-01-15)
+
+
+### Features
+
+* **hooks:** add PreToolUse hooks for BK suggestions ([23d3fa4](https://github.com/blueraai/bluera-knowledge/commit/23d3fa493dd16427d6bda3ea80064622c6244bba))
+* **hooks:** add skill auto-activation system ([2b4e96b](https://github.com/blueraai/bluera-knowledge/commit/2b4e96bd29f28df63377cdaacab922d4f4321a8f))
+
+
+### Bug Fixes
+
+* **hooks:** use JSON output for PreToolUse hook context injection ([a73977e](https://github.com/blueraai/bluera-knowledge/commit/a73977e0f8f690d43b9d7c987300522dd501fe38))
+* **tests:** stabilize watch service tests in coverage mode ([fdf6c3a](https://github.com/blueraai/bluera-knowledge/commit/fdf6c3a478adff9e4746b54a9519184ca280f344))
+
 ## [0.12.2](https://github.com/blueraai/bluera-knowledge/compare/v0.11.21...v0.12.2) (2026-01-15)
 
 

package/hooks/hooks.json

@@ -1,13 +1,13 @@
 {
   "description": "bluera-knowledge plugin hooks - dependency checking, job monitoring, and BK suggestions",
   "hooks": {
-    "PreToolUse": [
+    "PostToolUse": [
       {
         "matcher": "Grep",
         "hooks": [
           {
             "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse-bk-reminder.py",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse-bk-reminder.py",
             "timeout": 3
           }
         ]
@@ -17,7 +17,7 @@
         "hooks": [
           {
             "type": "command",
-            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/pretooluse-bk-reminder.py",
+            "command": "python3 ${CLAUDE_PLUGIN_ROOT}/hooks/posttooluse-bk-reminder.py",
             "timeout": 3
           }
         ]

package/hooks/posttooluse-bk-reminder.py

@@ -0,0 +1,138 @@
+#!/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
+
+# 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 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", "")
+
+    if path and 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", "")
+
+    if file_path and 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

@@ -95,28 +95,26 @@ def score_skill(
 def generate_reminder(
     matches: list[tuple[str, int, list[str], str]]
 ) -> str:
-    """Generate the system-reminder for matched skills."""
+    """Generate assertive skill activation reminder using forced evaluation pattern."""
     lines = [
-        "<system-reminder>",
-        "BLUERA-KNOWLEDGE SKILL ACTIVATION",
+        "BLUERA-KNOWLEDGE SKILL ACTIVATION - MANDATORY EVALUATION",
         "",
-        "The user's prompt suggests they may benefit from these skills.",
-        "For EACH skill below, decide YES/NO:",
-        "- YES: Invoke via Skill tool: Skill(skill='bluera-knowledge:<skill-name>')",
-        "- NO: Skip (user doesn't need this guidance)",
+        "CRITICAL: Complete these steps IN ORDER before answering:",
         "",
-        "Candidate skills (ranked by relevance):",
+        "STEP 1 - EVALUATE each skill (YES/NO with one-line reason):",
     ]
 
     for name, score, reasons, description in matches:
-        lines.append(f"")
-        lines.append(f"  [{name}] (score={score})")
-        lines.append(f"  Purpose: {description}")
-        lines.append(f"  Matched: {', '.join(reasons[:3])}")
+        lines.append(f"  • [{name}] - {description}")
+        lines.append(f"    Triggered by: {', '.join(reasons[:2])}")
 
     lines.append("")
-    lines.append("Evaluate quickly, then answer the user's question.")
-    lines.append("</system-reminder>")
+    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)
 
@@ -179,9 +177,15 @@ def main() -> int:
     # Sort by score (highest first)
     matches.sort(key=lambda t: t[1], reverse=True)
 
-    # Generate and output the reminder
+    # Generate and output the reminder using proper JSON format
     reminder = generate_reminder(matches)
-    print(reminder)
+    output = {
+        "hookSpecificOutput": {
+            "hookEventName": "UserPromptSubmit",
+            "additionalContext": reminder,
+        }
+    }
+    print(json.dumps(output))
 
     return 0
 

package/package.json

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

package/hooks/pretooluse-bk-reminder.py

@@ -1,101 +0,0 @@
-#!/usr/bin/env python3
-"""
-PreToolUse hook for bluera-knowledge plugin.
-Fires when Claude is about to Grep/Read in dependency directories,
-reminding to consider using BK instead.
-"""
-
-import json
-import re
-import sys
-from typing import Any
-
-# 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 check_grep_tool(tool_input: dict[str, Any]) -> str | None:
-    """Check if Grep is targeting library code."""
-    path = tool_input.get("path", "")
-    pattern = tool_input.get("pattern", "")
-
-    # Check if searching in library directories
-    if path and LIBRARY_PATTERNS_RE.search(path):
-        return f"grep in `{path}`"
-
-    # Check if pattern suggests library-specific search
-    # (searching for common library internals)
-    return None
-
-
-def check_read_tool(tool_input: dict[str, Any]) -> str | None:
-    """Check if Read is targeting library code."""
-    file_path = tool_input.get("file_path", "")
-
-    if file_path and LIBRARY_PATTERNS_RE.search(file_path):
-        return f"read `{file_path}`"
-
-    return 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", {})
-
-    trigger_reason = None
-
-    if tool_name == "Grep":
-        trigger_reason = check_grep_tool(tool_input)
-    elif tool_name == "Read":
-        trigger_reason = check_read_tool(tool_input)
-
-    if not trigger_reason:
-        return 0
-
-    # Output structured JSON for reliable context injection
-    reminder_text = f"""BLUERA-KNOWLEDGE SUGGESTION
-
-You're about to {trigger_reason} which appears to be dependency/library code.
-
-Consider querying Bluera Knowledge instead:
-- Use MCP tool `search` with a relevant query
-- Or invoke `/bluera-knowledge:search <query>`
-
-BK provides indexed, searchable access to library sources - faster and more context-efficient than grepping through node_modules.
-
-If you don't have this library indexed, continue with your current approach."""
-
-    output = {
-        "hookSpecificOutput": {
-            "hookEventName": "PreToolUse",
-            "additionalContext": reminder_text,
-        }
-    }
-    print(json.dumps(output))
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())