stravinsky 0.2.38__py3-none-any.whl → 0.2.52__py3-none-any.whl

mcp_bridge/hooks/preemptive_compaction.py

@@ -4,7 +4,7 @@ Preemptive Context Compaction Hook.
 Proactively compresses context BEFORE hitting limits by:
 - Tracking estimated token usage
 - Triggering compaction at 70% capacity (not waiting for errors)
-- Using DCP -> Truncate -> Summarize pipeline
+- Using DCP -> Truncate -> Summarize pipeline with gemini-3-flash
 - Registered as pre_model_invoke hook
 """
 
@@ -14,6 +14,9 @@ from typing import Any, Dict, Optional
 
 logger = logging.getLogger(__name__)
 
+# Flag to prevent recursive summarization calls
+_in_summarization = False
+
 # Token estimation constants
 CHARS_PER_TOKEN = 4  # Rough estimate for English text
 MAX_CONTEXT_TOKENS = 200000  # Claude's context window
@@ -112,6 +115,60 @@ CRITICAL_WARNING = """
 > 3. Reference TASK_STATE.md in new session for continuity
 """
 
+SUMMARIZATION_PROMPT = """Summarize the following context concisely while preserving:
+1. Key technical decisions and their rationale
+2. Important code patterns and file paths mentioned
+3. Current task state and pending items
+4. Any errors or warnings that need attention
+
+Keep the summary under 2000 characters. Use bullet points for clarity.
+
+CONTEXT TO SUMMARIZE:
+{content}"""
+
+
+async def summarize_with_gemini(token_store: Any, content: str) -> str:
+    """
+    Use gemini-3-flash to summarize context for compaction.
+
+    Args:
+        token_store: Token store for Gemini authentication
+        content: The content to summarize
+
+    Returns:
+        Summarized content or original if summarization fails
+    """
+    global _in_summarization
+
+    if not token_store:
+        logger.warning("[PreemptiveCompaction] No token_store available, skipping summarization")
+        return content
+
+    try:
+        # Import here to avoid circular imports
+        from mcp_bridge.tools.model_invoke import invoke_gemini
+
+        _in_summarization = True
+
+        prompt = SUMMARIZATION_PROMPT.format(content=content[:50000])  # Limit input size
+
+        summary = await invoke_gemini(
+            token_store=token_store,
+            prompt=prompt,
+            model="gemini-3-flash",
+            max_tokens=2000,
+            temperature=0.3,
+        )
+
+        logger.info(f"[PreemptiveCompaction] Summarized {len(content)} chars -> {len(summary)} chars")
+        return summary
+
+    except Exception as e:
+        logger.error(f"[PreemptiveCompaction] Summarization failed: {e}")
+        return content  # Fall back to original content
+    finally:
+        _in_summarization = False
+
 
 async def preemptive_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
     """
@@ -119,11 +176,18 @@ async def preemptive_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[st
 
     Uses a multi-tier strategy:
     - Below 70%: No action
-    - 70-85%: Apply DCP truncation with notice
-    - Above 85%: Apply aggressive truncation with critical warning
+    - 70-85%: Apply DCP truncation + gemini-3-flash summarization
+    - Above 85%: Apply aggressive truncation + gemini-3-flash summarization
     """
+    global _in_summarization
+
+    # Prevent recursive calls (when this hook triggers summarization via gemini)
+    if _in_summarization:
+        return None
+
     prompt = params.get("prompt", "")
     prompt_length = len(prompt)
+    token_store = params.get("token_store")  # May be None if not provided
 
     # Skip if already optimized recently
     if "[PREEMPTIVE CONTEXT OPTIMIZATION]" in prompt or "[CRITICAL - CONTEXT WINDOW" in prompt:
@@ -132,25 +196,35 @@ async def preemptive_compaction_hook(params: Dict[str, Any]) -> Optional[Dict[st
     usage = calculate_usage_percentage(prompt)
 
     if prompt_length >= WARNING_CHAR_THRESHOLD:
-        # Critical level - aggressive truncation
+        # Critical level - aggressive truncation + summarization
         logger.warning(f"[PreemptiveCompaction] Critical context usage: {usage:.1f}%")
 
         truncated = apply_dcp_truncation(prompt, target_reduction=0.4)
+
+        # Use gemini-3-flash to summarize the truncated middle section
+        if token_store:
+            truncated = await summarize_with_gemini(token_store, truncated)
+
         notice = CRITICAL_WARNING.format(usage=usage)
         params["prompt"] = notice + truncated
 
-        logger.info(f"[PreemptiveCompaction] Applied aggressive truncation: {len(prompt)} -> {len(truncated)} chars")
+        logger.info(f"[PreemptiveCompaction] Applied aggressive compaction: {len(prompt)} -> {len(truncated)} chars")
         return params
 
     elif prompt_length >= PREEMPTIVE_CHAR_THRESHOLD:
-        # Preemptive level - moderate truncation
+        # Preemptive level - moderate truncation + summarization
         logger.info(f"[PreemptiveCompaction] Preemptive compaction at {usage:.1f}%")
 
         truncated = apply_dcp_truncation(prompt, target_reduction=0.3)
+
+        # Use gemini-3-flash to summarize the truncated content
+        if token_store:
+            truncated = await summarize_with_gemini(token_store, truncated)
+
         notice = PREEMPTIVE_COMPACTION_NOTICE.format(usage=usage)
         params["prompt"] = notice + truncated
 
-        logger.info(f"[PreemptiveCompaction] Applied moderate truncation: {len(prompt)} -> {len(truncated)} chars")
+        logger.info(f"[PreemptiveCompaction] Applied moderate compaction: {len(prompt)} -> {len(truncated)} chars")
         return params
 
     # Below threshold, no action needed

mcp_bridge/hooks/session_idle.py

@@ -0,0 +1,116 @@
+"""
+Session Idle Hook - Stop Hook Implementation.
+
+Detects when session becomes idle with incomplete todos and injects
+a continuation prompt to force task completion.
+
+Based on oh-my-opencode's todo-continuation-enforcer pattern.
+"""
+
+import logging
+from typing import Any, Dict, Optional
+
+logger = logging.getLogger(__name__)
+
+# Continuation prompt injected when session is idle with incomplete todos
+TODO_CONTINUATION_PROMPT = """
+[SYSTEM REMINDER - TODO CONTINUATION]
+
+You have incomplete tasks in your todo list. Continue working on the next pending task.
+
+RULES:
+- Proceed immediately without asking for permission
+- Mark the current task as in_progress before starting
+- Mark each task complete when finished
+- Do NOT stop until all tasks are done
+- If blocked, create a new task describing what needs to be resolved
+
+STATUS CHECK:
+Use TodoWrite to check your current task status and continue with the next pending item.
+"""
+
+# Track sessions to prevent duplicate injections
+_idle_sessions: Dict[str, bool] = {}
+_last_activity: Dict[str, float] = {}
+
+
+async def session_idle_hook(params: Dict[str, Any]) -> Optional[Dict[str, Any]]:
+    """
+    Pre-model-invoke hook that detects idle sessions with incomplete todos.
+
+    Checks if:
+    1. The conversation has pending todos
+    2. The session has been idle (no recent tool calls)
+    3. A continuation hasn't already been injected
+
+    If all conditions met, injects TODO_CONTINUATION_PROMPT.
+    """
+    import time
+
+    prompt = params.get("prompt", "")
+    session_id = params.get("session_id", "default")
+
+    # Skip if already contains continuation reminder
+    if "[SYSTEM REMINDER - TODO CONTINUATION]" in prompt:
+        return None
+
+    # Skip if this is a fresh prompt (user just typed something)
+    if params.get("is_user_message", False):
+        _last_activity[session_id] = time.time()
+        _idle_sessions[session_id] = False
+        return None
+
+    # Check for pending todos in the prompt/context
+    has_pending_todos = _detect_pending_todos(prompt)
+
+    if not has_pending_todos:
+        return None
+
+    # Check idle threshold (2 seconds of no activity)
+    current_time = time.time()
+    last_activity = _last_activity.get(session_id, current_time)
+    idle_seconds = current_time - last_activity
+
+    if idle_seconds < 2.0:
+        return None
+
+    # Check if already injected for this idle period
+    if _idle_sessions.get(session_id, False):
+        return None
+
+    # Mark as injected and inject continuation
+    _idle_sessions[session_id] = True
+    logger.info(f"[SessionIdleHook] Injecting TODO continuation for session {session_id}")
+
+    modified_prompt = prompt + "\n\n" + TODO_CONTINUATION_PROMPT
+
+    return {**params, "prompt": modified_prompt}
+
+
+def _detect_pending_todos(prompt: str) -> bool:
+    """
+    Detect if there are pending todos in the conversation.
+
+    Looks for patterns like:
+    - [pending] or status: pending
+    - TodoWrite with pending items
+    - Incomplete task lists
+    """
+    pending_patterns = [
+        "[pending]",
+        "status: pending",
+        '"status": "pending"',
+        "pending tasks",
+        "incomplete tasks",
+        "remaining todos",
+    ]
+
+    prompt_lower = prompt.lower()
+    return any(pattern.lower() in prompt_lower for pattern in pending_patterns)
+
+
+def reset_session(session_id: str = "default"):
+    """Reset idle state for a session (call when user provides new input)."""
+    _idle_sessions[session_id] = False
+    import time
+    _last_activity[session_id] = time.time()

mcp_bridge/native_hooks/todo_delegation.py

@@ -0,0 +1,54 @@
+#!/usr/bin/env python3
+"""
+PostToolUse hook for TodoWrite: Enforces parallel delegation.
+
+After TodoWrite is called, this hook injects a reminder to spawn
+parallel Task agents for all independent TODOs.
+"""
+import json
+import sys
+
+
+def main():
+    # Read hook input from stdin
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+
+    if tool_name != "TodoWrite":
+        return 0
+
+    # Get the todos that were just written
+    tool_input = hook_input.get("tool_input", {})
+    todos = tool_input.get("todos", [])
+
+    # Count pending todos
+    pending_count = sum(1 for t in todos if t.get("status") == "pending")
+
+    if pending_count < 2:
+        return 0
+
+    # Output the parallel delegation reminder
+    reminder = f"""
+[PARALLEL DELEGATION REQUIRED]
+
+You just created {pending_count} pending TODOs. Before your NEXT response:
+
+1. Identify which TODOs are INDEPENDENT (can run simultaneously)
+2. For EACH independent TODO, spawn a Task agent:
+   Task(subagent_type="Explore", prompt="[TODO details]", run_in_background=true)
+3. Fire ALL Task calls in ONE response - do NOT wait between them
+4. Do NOT mark any TODO as in_progress until agents return
+
+WRONG: Create TODO list -> Mark TODO 1 in_progress -> Work -> Complete -> Repeat
+CORRECT: Create TODO list -> Spawn Task for each -> Collect results -> Mark complete
+"""
+    print(reminder)
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())

mcp_bridge/prompts/__init__.py

@@ -6,13 +6,15 @@ from . import explore
 from . import frontend
 from . import document_writer
 from . import multimodal
+from . import planner
 
 __all__ = [
     "stravinsky",
-    "delphi", 
+    "delphi",
     "dewey",
     "explore",
     "frontend",
     "document_writer",
     "multimodal",
+    "planner",
 ]

mcp_bridge/prompts/dewey.py

@@ -50,8 +50,8 @@ Classify EVERY request into one of these categories before taking action:
 
 | Type | Trigger Examples | Tools |
 |------|------------------|-------|
-| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | docs + websearch (parallel) |
-| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + read + blame |
+| **TYPE A: CONCEPTUAL** | "How do I use X?", "Best practice for Y?" | exa websearch + grep-app GitHub search (parallel) |
+| **TYPE B: IMPLEMENTATION** | "How does X implement Y?", "Show me source of Z" | gh clone + ast-grep + read + blame |
 | **TYPE C: CONTEXT** | "Why was this changed?", "History of X?" | gh issues/prs + git log/blame |
 | **TYPE D: COMPREHENSIVE** | Complex/ambiguous requests | ALL tools in parallel |
 
@@ -64,12 +64,15 @@ Classify EVERY request into one of these categories before taking action:
 
 **Execute in parallel (3+ calls)**:
 ```
-Tool 1: Search official documentation
-Tool 2: Web search for recent articles/tutorials ("library-name topic 2025")
-Tool 3: GitHub code search for usage patterns (grep_search)
+Tool 1: mcp__MCP_DOCKER__web_search_exa(query="library-name topic 2026", num_results=5)
+        -> Current articles, blog posts, best practices (ALWAYS use Exa instead of native WebSearch)
+Tool 2: mcp__grep-app__searchCode(query="library-name implementation pattern")
+        -> Real GitHub code examples with permalinks
+Tool 3: gh search repos "library-name" --sort stars --limit 5
+        -> Popular repositories for reference
 ```
 
-**Output**: Summarize findings with links to official docs and real-world examples.
+**Output**: Synthesize with evidence links (Exa URLs + GitHub permalinks).
 
 ---
 
@@ -85,8 +88,8 @@ Step 2: Get commit SHA for permalinks
         cd ${TMPDIR:-/tmp}/repo-name && git rev-parse HEAD
 
 Step 3: Find the implementation
-        - grep_search for function/class
-        - ast_grep_search for AST patterns
+        - mcp__ast-grep__find_code(pattern="function $NAME", language="typescript") for structural search
+        - grep_search for function/class names
         - Read the specific file
         - git blame for context if needed
 
@@ -97,9 +100,9 @@ Step 4: Construct permalink
 **Parallel acceleration (4+ calls)**:
 ```
 Tool 1: gh repo clone owner/repo ${TMPDIR:-/tmp}/repo -- --depth 1
-Tool 2: GitHub code search for function_name
+Tool 2: mcp__grep-app__searchCode(query="repo:owner/repo function_name")
 Tool 3: gh api repos/owner/repo/commits/HEAD --jq '.sha'
-Tool 4: Documentation search for relevant API
+Tool 4: mcp__MCP_DOCKER__web_search_exa(query="library-name function_name documentation 2026")
 ```
 
 ---
@@ -131,13 +134,15 @@ gh api repos/owner/repo/pulls/<number>/files
 
 **Execute ALL in parallel (6+ calls)**:
 ```
-// Documentation & Web
-Tool 1: Documentation search
-Tool 2: Web search ("topic recent updates 2025")
+// Web Search (ALWAYS use Exa)
+Tool 1: mcp__MCP_DOCKER__web_search_exa(query="topic recent updates 2026", num_results=10)
 
-// Code Search
-Tool 3: grep_search(pattern1)
-Tool 4: grep_search(pattern2) or ast_grep_search
+// GitHub Code Search
+Tool 2: mcp__grep-app__searchCode(query="topic implementation pattern")
+Tool 3: mcp__grep-app__searchCode(query="topic usage example")
+
+// AST Pattern Search
+Tool 4: mcp__ast-grep__find_code(pattern="$PATTERN", language="typescript")
 
 // Source Analysis
 Tool 5: gh repo clone owner/repo ${TMPDIR:-/tmp}/repo -- --depth 1
@@ -182,15 +187,20 @@ https://github.com/tanstack/query/blob/abc123def/packages/react-query/src/useQue
 
 ---
 
-## TOOL REFERENCE (Stravinsky Tools)
+## TOOL REFERENCE (Stravinsky + MCP DOCKER Tools)
 
 ### Primary Tools by Purpose
 
 | Purpose | Tool | Usage |
 |---------|------|-------|
-| **Code Search** | grep_search | Pattern-based search in local/cloned repos |
-| **AST Search** | ast_grep_search | AST-aware code pattern search |
-| **File Glob** | glob_files | Find files by pattern |
+| **Web Search** | `mcp__MCP_DOCKER__web_search_exa` | **ALWAYS use instead of native WebSearch** - Real-time web search for current articles, docs, tutorials |
+| **GitHub Code Search** | `mcp__grep-app__searchCode` | Search across public GitHub repositories - returns permalinks |
+| **GitHub File Fetch** | `mcp__grep-app__github_file` | Fetch specific file from GitHub repo |
+| **AST Pattern Search** | `mcp__ast-grep__find_code` | Structural code search across 25+ languages with AST awareness |
+| **AST Replace** | `mcp__ast-grep__replace` | AST-aware code refactoring and replacement |
+| **Local Code Search** | `grep_search` | Pattern-based search in local/cloned repos (uses ripgrep) |
+| **Local AST Search** | `ast_grep_search` | AST search in cloned repos |
+| **File Glob** | `glob_files` | Find files by pattern |
 | **Clone Repo** | gh CLI | `gh repo clone owner/repo ${TMPDIR:-/tmp}/name -- --depth 1` |
 | **Issues/PRs** | gh CLI | `gh search issues/prs "query" --repo owner/repo` |
 | **View Issue/PR** | gh CLI | `gh issue/pr view <num> --repo owner/repo --comments` |

mcp_bridge/prompts/explore.py

@@ -96,14 +96,52 @@ Your response has **FAILED** if:
 - **No emojis**: Keep output clean and parseable
 - **No file creation**: Report findings as message text, never write files
 
-## Tool Strategy
-
-Use the right tool for the job:
-- **Semantic search** (definitions, references): LSP tools
-- **Structural patterns** (function shapes, class structures): ast_grep_search  
-- **Text patterns** (strings, comments, logs): grep
-- **File patterns** (find by name/extension): glob
-- **History/evolution** (when added, who changed): git commands
+## Tool Strategy & Available Tools
+
+### Local Codebase Tools
+- **Semantic search** (definitions, references): `lsp_goto_definition`, `lsp_find_references`, `lsp_workspace_symbols`
+- **Structural patterns** (function shapes, class structures): `ast_grep_search` (local), `mcp__ast-grep__find_code` (enhanced)
+- **Text patterns** (strings, comments, logs): `grep_search` (local ripgrep)
+- **File patterns** (find by name/extension): `glob_files`
+- **History/evolution** (when added, who changed): git commands (`git log`, `git blame`)
+
+### MCP DOCKER Enhanced Tools (ALWAYS prefer these when searching)
+- **`mcp__MCP_DOCKER__web_search_exa`**: Real-time web search for documentation, articles, best practices
+  - Use when: Researching external libraries, finding current tutorials, checking API docs
+  - Example: `mcp__MCP_DOCKER__web_search_exa(query="library-name best practices 2026", num_results=5)`
+
+### GitHub Code Search (MCP grep-app)
+- **`mcp__grep-app__searchCode`**: Search across ALL public GitHub repositories
+  - Use when: Finding implementation examples, usage patterns, community solutions
+  - Returns: GitHub permalinks with full context
+  - Example: `mcp__grep-app__searchCode(query="repo:owner/repo pattern")`
+- **`mcp__grep-app__github_file`**: Fetch specific files from GitHub repos
+  - Use when: Need to read implementation from remote repo
+  - Example: `mcp__grep-app__github_file(owner="facebook", repo="react", path="src/hooks/useEffect.ts")`
+
+### AST-Aware Search (MCP ast-grep)
+- **`mcp__ast-grep__find_code`**: Structural code search across 25+ languages
+  - Use when: Finding code patterns by structure, not just text
+  - Supports: TypeScript, Python, Rust, Go, Java, JavaScript, and 20+ more
+  - Example: `mcp__ast-grep__find_code(pattern="function $NAME($$$ARGS) { $$$ }", language="typescript")`
+- **`mcp__ast-grep__find_code_by_rule`**: Advanced AST search with YAML rules
+  - Use when: Complex pattern matching with constraints
+  - Example: Find all async functions that don't handle errors
+
+### Parallel Search Strategy
+
+**ALWAYS spawn 4-6 tools in parallel** for comprehensive search:
+
+```
+# Example: "Find authentication implementation"
+Parallel execution:
+1. lsp_workspace_symbols(query="auth")
+2. mcp__ast-grep__find_code(pattern="function $AUTH", language="typescript")
+3. mcp__grep-app__searchCode(query="repo:your-org/repo authentication")
+4. grep_search(pattern="authenticate|login|verify")
+5. glob_files(pattern="**/*auth*.ts")
+6. mcp__MCP_DOCKER__web_search_exa(query="library-name authentication implementation 2026")
+```
 
 Flood with parallel calls. Cross-validate findings across multiple tools."""