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

mcp_bridge/tools/skill_loader.py

@@ -17,21 +17,21 @@ from typing import Any
 def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
     """
     Parse YAML frontmatter from markdown content.
-    
+
     Returns:
         Tuple of (metadata dict, body content)
     """
     if not content.startswith("---"):
         return {}, content
-    
+
     # Find the closing ---
     end_match = content.find("---", 3)
     if end_match == -1:
         return {}, content
-    
+
     frontmatter = content[3:end_match].strip()
-    body = content[end_match + 3:].strip()
-    
+    body = content[end_match + 3 :].strip()
+
     # Simple YAML parsing for key: value pairs
     metadata = {}
     for line in frontmatter.split("\n"):
@@ -40,122 +40,126 @@ def parse_frontmatter(content: str) -> tuple[dict[str, Any], str]:
             key = key.strip()
             value = value.strip().strip('"').strip("'")
             metadata[key] = value
-    
+
     return metadata, body
 
 
 def discover_skills(project_path: str | None = None) -> list[dict[str, Any]]:
     """
     Discover available skills/commands.
-    
+
     Searches:
     1. Project-local: {project}/.claude/commands/
     2. User-global: ~/.claude/commands/
-    
+
     Args:
         project_path: Project directory to search (defaults to cwd)
-        
+
     Returns:
         List of skill definitions.
     """
     skills = []
     search_paths = []
-    
+
     # Project-local commands
     project = Path(project_path) if project_path else Path.cwd()
     project_commands = project / ".claude" / "commands"
     if project_commands.exists():
         search_paths.append(("project", project_commands))
-    
+
     # User-global commands
     user_commands = Path.home() / ".claude" / "commands"
     if user_commands.exists():
         search_paths.append(("user", user_commands))
-    
+
     for scope, commands_dir in search_paths:
-        for md_file in commands_dir.glob("*.md"):
+        for md_file in commands_dir.glob("**/*.md"):
             try:
                 content = md_file.read_text()
                 metadata, body = parse_frontmatter(content)
-                
-                skills.append({
-                    "name": md_file.stem,
-                    "scope": scope,
-                    "path": str(md_file),
-                    "description": metadata.get("description", ""),
-                    "allowed_tools": metadata.get("allowed-tools", "").split(",") if metadata.get("allowed-tools") else [],
-                    "body_preview": body[:200] + "..." if len(body) > 200 else body,
-                })
+
+                skills.append(
+                    {
+                        "name": md_file.stem,
+                        "scope": scope,
+                        "path": str(md_file),
+                        "description": metadata.get("description", ""),
+                        "allowed_tools": metadata.get("allowed-tools", "").split(",")
+                        if metadata.get("allowed-tools")
+                        else [],
+                        "body_preview": body[:200] + "..." if len(body) > 200 else body,
+                    }
+                )
             except Exception:
                 continue
-    
+
     return skills
 
 
 def list_skills(project_path: str | None = None) -> str:
     """
     List all available skills for MCP tool.
-    
+
     Args:
         project_path: Project directory to search
-        
+
     Returns:
         Formatted skill listing.
     """
     skills = discover_skills(project_path)
-    
+
     if not skills:
         return "No skills found. Create .claude/commands/*.md files to add skills."
-    
+
     lines = [f"Found {len(skills)} skill(s):\n"]
-    
+
     for skill in skills:
         scope_badge = "[project]" if skill["scope"] == "project" else "[user]"
         lines.append(f"  /{skill['name']} {scope_badge}")
         if skill["description"]:
             lines.append(f"    {skill['description']}")
-    
+
     return "\n".join(lines)
 
 
 def get_skill(name: str, project_path: str | None = None) -> str:
     """
     Get the content of a specific skill.
-    
+
     Args:
         name: Skill name (filename without .md)
         project_path: Project directory to search
-        
+
     Returns:
         Skill content or error message.
     """
     skills = discover_skills(project_path)
-    
+
     skill = next((s for s in skills if s["name"] == name), None)
     if not skill:
         available = ", ".join(s["name"] for s in skills)
         return f"Skill '{name}' not found. Available: {available or 'none'}"
-    
+
     try:
         content = Path(skill["path"]).read_text()
         metadata, body = parse_frontmatter(content)
-        
+
         lines = [
             f"## Skill: {name}",
             f"**Scope**: {skill['scope']}",
             f"**Path**: {skill['path']}",
         ]
-        
+
         if metadata.get("description"):
             lines.append(f"**Description**: {metadata['description']}")
-        
+
         if metadata.get("allowed-tools"):
             lines.append(f"**Allowed Tools**: {metadata['allowed-tools']}")
-        
+
         lines.extend(["", "---", "", body])
-        
+
         return "\n".join(lines)
-        
+
     except Exception as e:
         return f"Error reading skill: {e}"
 
@@ -169,34 +173,34 @@ def create_skill(
 ) -> str:
     """
     Create a new skill file.
-    
+
     Args:
         name: Skill name (will be used as filename)
         description: Short description for frontmatter
         content: Skill body content
         scope: "project" or "user"
         project_path: Project directory for project-scope skills
-        
+
     Returns:
         Success or error message.
     """
     # Sanitize name
     name = re.sub(r"[^a-zA-Z0-9_-]", "-", name.lower())
-    
+
     if scope == "project":
         base_dir = Path(project_path) if project_path else Path.cwd()
         commands_dir = base_dir / ".claude" / "commands"
     else:
         commands_dir = Path.home() / ".claude" / "commands"
-    
+
     # Ensure directory exists
     commands_dir.mkdir(parents=True, exist_ok=True)
-    
+
     skill_path = commands_dir / f"{name}.md"
-    
+
     if skill_path.exists():
         return f"Skill '{name}' already exists at {skill_path}"
-    
+
     # Create skill content
     skill_content = f"""---
 description: {description}
@@ -204,7 +208,7 @@ description: {description}
 
 {content}
 """
-    
+
     try:
         skill_path.write_text(skill_content)
         return f"Created skill '{name}' at {skill_path}"

mcp_bridge/tools/task_runner.py

@@ -0,0 +1,141 @@
+"""
+Task Runner for Stravinsky background sub-agents.
+
+This script is executed as a background process to handle agent tasks,
+capture output, and update status in tasks.json.
+"""
+
+import argparse
+import json
+import logging
+import os
+import sys
+import asyncio
+import subprocess
+from datetime import datetime
+from pathlib import Path
+
+# Setup logging
+logging.basicConfig(level=logging.INFO, format="%(asctime)s [%(levelname)s] %(message)s")
+logger = logging.getLogger("task_runner")
+
+
+async def run_task(task_id: str, base_dir: str):
+    base_path = Path(base_dir)
+    tasks_file = base_path / "tasks.json"
+    agents_dir = base_path / "agents"
+
+    # Load task details
+    try:
+        with open(tasks_file, "r") as f:
+            tasks = json.load(f)
+        task = tasks.get(task_id)
+    except Exception as e:
+        logger.error(f"Failed to load tasks: {e}")
+        return
+
+    if not task:
+        logger.error(f"Task {task_id} not found")
+        return
+
+    prompt = task.get("prompt")
+    model = task.get("model", "gemini-2.0-flash")
+
+    output_file = agents_dir / f"{task_id}.out"
+    agents_dir.mkdir(parents=True, exist_ok=True)
+
+    try:
+        # Use Claude CLI for background tasks to ensure tool access
+        # Discover CLI path
+        claude_cli = os.environ.get("CLAUDE_CLI", "/opt/homebrew/bin/claude")
+
+        cmd = [
+            claude_cli,
+            "-p",
+        ]
+
+        if model:
+            cmd.extend(["--model", model])
+
+        cmd.append(prompt)
+
+        logger.info(f"Executing task {task_id} via CLI ({model})...")
+
+        # Open output and log files
+        with (
+            open(output_file, "w") as out_f,
+            open(base_path / "tasks" / f"{task_id}.log", "a") as log_f,
+        ):
+            process = await asyncio.create_subprocess_exec(
+                *cmd, stdout=out_f, stderr=log_f, cwd=os.getcwd()
+            )
+
+            await process.wait()
+
+        # Read result
+        if output_file.exists():
+            result = output_file.read_text()
+        else:
+            result = ""
+
+        # Save result
+        with open(output_file, "w") as f:
+            f.write(result)
+
+        # Update status
+        with open(tasks_file, "r") as f:
+            tasks = json.load(f)
+
+        if task_id in tasks:
+            tasks[task_id].update(
+                {
+                    "status": "completed",
+                    "result": result,
+                    "completed_at": datetime.now().isoformat(),
+                }
+            )
+            with open(tasks_file, "w") as f:
+                json.dump(tasks, f, indent=2)
+
+        logger.info(f"Task {task_id} completed successfully")
+
+    except Exception as e:
+        logger.exception(f"Task {task_id} failed: {e}")
+
+        # Update status with error
+        try:
+            with open(tasks_file, "r") as f:
+                tasks = json.load(f)
+            if task_id in tasks:
+                tasks[task_id].update(
+                    {
+                        "status": "failed",
+                        "error": str(e),
+                        "completed_at": datetime.now().isoformat(),
+                    }
+                )
+                with open(tasks_file, "w") as f:
+                    json.dump(tasks, f, indent=2)
+        except:
+            pass
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Internal task runner for Stravinsky background agents. "
+        "Executes agent tasks via Claude CLI and manages output/status.",
+        prog="task_runner",
+    )
+    parser.add_argument(
+        "--task-id",
+        required=True,
+        help="Unique identifier for the task to execute",
+    )
+    parser.add_argument(
+        "--base-dir",
+        required=True,
+        help="Base directory containing tasks.json and agents/ output folder",
+    )
+    args = parser.parse_args()
+
+    asyncio.run(run_task(args.task_id, args.base_dir))

mcp_bridge/tools/templates.py

@@ -0,0 +1,175 @@
+"""
+Templates for stravinsky repository initialization.
+"""
+
+CLAUDE_MD_TEMPLATE = """## stravinsky MCP (Parallel Agents)
+
+Use stravinsky MCP tools. **DEFAULT: spawn parallel agents for multi-step tasks.**
+
+### Agent Tools
+- `agent_spawn(prompt, agent_type, description)` - Spawn background agent with full tool access
+- `agent_output(task_id, block)` - Get results (block=True to wait)
+- `agent_progress(task_id)` - Check real-time progress
+- `agent_list()` - Overview of all running agents
+- `agent_cancel(task_id)` - Stop a running agent
+
+### Agent Types
+- `explore` - Codebase search, "where is X?" questions
+- `dewey` - Documentation research, implementation examples
+- `frontend` - UI/UX work, component design
+- `delphi` - Strategic advice, architecture review
+
+### Parallel Execution (IRONSTAR)
+For ANY task with 2+ independent steps:
+1. **Immediately use agent_spawn** for each independent component
+2. Fire all agents simultaneously, don't wait
+3. Monitor with agent_progress, collect with agent_output
+
+### Trigger Commands
+- **IRONSTAR** / **IRS**: Maximum parallel execution - spawn agents aggressively for every subtask
+- **ULTRATHINK**: Engage exhaustive deep reasoning, multi-dimensional analysis
+- **SEARCH**: Maximize search effort across codebase and external resources
+- **ANALYZE**: Deep analysis mode with delphi consultation for complex issues
+"""
+
+COMMAND_STRAVINSKY = """---
+description: stravinsky Orchestrator - Parallel agent execution for complex workflows.
+---
+
+## CRITICAL: USE STRAVINSKY MCP TOOLS
+
+You MUST use the Stravinsky MCP server tools for ALL file reading, searching, and parallel work.
+
+### MANDATORY TOOL USAGE:
+
+**For ANY file reading or searching:**
+```
+stravinsky:agent_spawn(
+  prompt="Read and analyze [file path]. Return: [what you need]",
+  agent_type="explore",
+  description="Read [file]"
+)
+```
+
+**For documentation/library research:**
+```
+stravinsky:agent_spawn(
+  prompt="Find documentation for [topic]",
+  agent_type="dewey",
+  description="Research [topic]"
+)
+```
+
+**For 2+ independent tasks (ALWAYS parallel):**
+```
+// Fire ALL at once in ONE response - NEVER sequential
+stravinsky:agent_spawn(prompt="Task 1...", agent_type="explore", description="Task 1")
+stravinsky:agent_spawn(prompt="Task 2...", agent_type="explore", description="Task 2")
+stravinsky:agent_spawn(prompt="Task 3...", agent_type="dewey", description="Task 3")
+// Then immediately continue - don't wait
+```
+
+**To get results:**
+```
+stravinsky:agent_output(task_id="[id]", block=true)
+```
+
+### DO NOT USE:
+- ❌ Built-in Read tool for file reading
+- ❌ Built-in Search/Glob for searching
+- ❌ Built-in Task tool for subagents
+
+### ALWAYS USE:
+- ✅ stravinsky:agent_spawn for ALL exploration
+- ✅ stravinsky:agent_output for collecting results
+- ✅ stravinsky:agent_list to see running agents
+
+### Execution Modes:
+- `ironstar` / `irs` / `ultrawork` - Maximum parallel execution (10+ agents)
+- `ultrathink` - Deep reasoning with delphi consultation
+- `search` - Exhaustive multi-agent search
+
+**Your FIRST action must be spawning agents, not using Read/Search tools.**
+"""
+
+COMMAND_PARALLEL = """---
+description: Execute a task with multiple parallel agents for speed.
+---
+
+Use the stravinsky MCP tools to execute this task with PARALLEL AGENTS.
+
+**MANDATORY:** For the following task items, spawn a SEPARATE `agent_spawn` call for EACH independent item. Do not work on them sequentially - fire all agents simultaneously:
+
+$ARGUMENTS
+
+After spawning all agents:
+1. Use `agent_list` to show running agents
+2. Use `agent_progress(task_id)` to monitor each
+3. Collect results with `agent_output(task_id, block=True)` when ready
+"""
+
+COMMAND_CONTEXT = """---
+description: Refresh project situational awareness (Git, Rules, Top Todos).
+---
+
+Call the `get_project_context` tool to retrieve the current Git branch, modified files, local project rules from `.claude/rules/`, and any pending `[ ]` todos in the current scope.
+"""
+
+COMMAND_HEALTH = """---
+description: Perform a comprehensive system health and dependency check.
+---
+
+Call the `get_system_health` tool to verify that all CLI dependencies (rg, fd, sg, tsc, etc.) are installed and that authentication for Gemini and OpenAI is active.
+"""
+
+COMMAND_DELPHI = """---
+description: Consult the delphi Strategic Advisor for architecture and hard debugging.
+---
+
+Use the `delphi` prompt to analyze the current problem. This triggers a GPT-based consulting phase focused on strategic reasoning, architectural trade-offs, and root-cause analysis for difficult bugs.
+
+**When to use delphi:**
+- Complex architecture design decisions
+- After 2+ failed fix attempts
+- Multi-system tradeoffs
+- Security/performance concerns
+- Unfamiliar code patterns
+"""
+
+COMMAND_LIST = """---
+description: List all active and recent background agent tasks.
+---
+
+Call the `agent_list` tool to see an overview of all currently running and completed background agents, including their Task IDs and statuses.
+"""
+
+COMMAND_DEWEY = """---
+description: Trigger dewey for documentation research and implementation examples.
+---
+
+Use the `dewey` prompt to find evidence and documentation for the topic at hand. dewey specializes in multi-repository search and official documentation retrieval.
+
+**When to use dewey:**
+- Unfamiliar npm/pip/cargo packages
+- "How do I use [library]?"
+- "What's the best practice for [framework feature]?"
+- Finding OSS implementation examples
+"""
+
+COMMAND_VERSION = """---
+description: Returns the current version and diagnostic info for stravinsky.
+---
+
+Display the stravinsky MCP version, registered hooks, available agents, and system health status.
+"""
+
+SLASH_COMMANDS = {
+    "stravinsky.md": COMMAND_STRAVINSKY,
+    "parallel.md": COMMAND_PARALLEL,
+    "list.md": COMMAND_LIST,
+    "context.md": COMMAND_CONTEXT,
+    "health.md": COMMAND_HEALTH,
+    "delphi.md": COMMAND_DELPHI,
+    "dewey.md": COMMAND_DEWEY,
+    "version.md": COMMAND_VERSION,
+}

{stravinsky-0.1.2.dist-info → stravinsky-0.2.38.dist-info}/METADATA

@@ -1,7 +1,9 @@
 Metadata-Version: 2.4
 Name: stravinsky
-Version: 0.1.2
+Version: 0.2.38
 Summary: MCP Bridge for Claude Code with Multi-Model Support. Install globally: claude mcp add --scope user stravinsky -- uvx stravinsky. Add to CLAUDE.md: See https://pypi.org/project/stravinsky/
+Project-URL: Repository, https://github.com/GratefulDave/stravinsky
+Project-URL: Issues, https://github.com/GratefulDave/stravinsky/issues
 Author: Stravinsky Team
 License: MIT
 Keywords: claude,gemini,mcp,oauth,openai
@@ -13,14 +15,14 @@ Requires-Dist: google-auth>=2.20.0
 Requires-Dist: httpx>=0.24.0
 Requires-Dist: jedi>=0.19.2
 Requires-Dist: keyring>=25.7.0
-Requires-Dist: mcp>=1.0.0
+Requires-Dist: mcp>=1.2.1
 Requires-Dist: openai>=1.0.0
 Requires-Dist: psutil>=5.9.0
 Requires-Dist: pydantic>=2.0.0
 Requires-Dist: python-dotenv>=1.0.0
 Requires-Dist: rich>=13.0.0
 Requires-Dist: ruff>=0.14.10
-Requires-Dist: uuid-utils>=0.9.0
+Requires-Dist: tenacity>=8.5.0
 Provides-Extra: dev
 Requires-Dist: mypy>=1.10.0; extra == 'dev'
 Requires-Dist: pytest-asyncio>=0.23.0; extra == 'dev'
@@ -29,7 +31,7 @@ Requires-Dist: ruff>=0.4.0; extra == 'dev'
 Description-Content-Type: text/markdown
 
 <div align="center">
-  <img src=".gemini/antigravity/brain/d170f128-7b96-4abe-b1dc-77cfecd0fc18/stravinsky_logo_1767303800556.png" width="200" alt="Stravinsky Logo">
+  <img src="https://raw.githubusercontent.com/GratefulDave/stravinsky/main/assets/logo.png" width="300" alt="Stravinsky Logo">
   <h1>Stravinsky</h1>
   <p><strong>The Avant-Garde MCP Bridge for Claude Code</strong></p>
   <p><em>Movement • Rhythm • Precision</em></p>
@@ -75,7 +77,7 @@ claude mcp add stravinsky -- stravinsky
 
 ### Authentication
 
-```bash
+````bash
 # Login to Google (Gemini)
 stravinsky-auth login gemini
 
@@ -87,7 +89,54 @@ stravinsky-auth status
 
 # Logout
 stravinsky-auth logout gemini
-```
+
+### Slash Commands
+
+Slash commands are discovered from:
+- Project-local: `.claude/commands/**/*.md` (recursive)
+- User-global: `~/.claude/commands/**/*.md` (recursive)
+
+Commands can be organized in subdirectories (e.g., `.claude/commands/strav/stravinsky.md`).
+
+````
+
+## Add to Your CLAUDE.md
+
+After installing globally, add this to your project's `CLAUDE.md`:
+
+```markdown
+## Stravinsky MCP (Parallel Agents)
+
+Use Stravinsky MCP tools. **DEFAULT: spawn parallel agents for multi-step tasks.**
+
+### Agent Tools
+
+- `agent_spawn(prompt, agent_type, description)` - Spawn background agent with full tool access
+- `agent_output(task_id, block)` - Get results (block=True to wait)
+- `agent_progress(task_id)` - Check real-time progress
+- `agent_list()` - Overview of all running agents
+- `agent_cancel(task_id)` - Stop a running agent
+
+### Agent Types
+
+- `explore` - Codebase search, "where is X?" questions
+- `dewey` - Documentation research, implementation examples
+- `frontend` - UI/UX work, component design
+- `delphi` - Strategic advice, architecture review
+
+### Parallel Execution (MANDATORY)
+
+For ANY task with 2+ independent steps:
+
+1. **Immediately use agent_spawn** for each independent component
+2. Fire all agents simultaneously, don't wait
+3. Monitor with agent_progress, collect with agent_output
+
+### ULTRATHINK / ULTRAWORK
+
+- **ULTRATHINK**: Engage exhaustive deep reasoning, multi-dimensional analysis
+- **ULTRAWORK**: Maximum parallel execution - spawn agents aggressively for every subtask
+````
 
 ## Tools (31)
 
@@ -153,7 +202,3 @@ The Codex CLI uses the same port. Stop it with: `killall codex`
 MIT
 
 ---
-
-<div align="center">
-  <small>Built with obsession by the Google Deepmind team.</small>
-</div>