stravinsky 0.2.67__py3-none-any.whl → 0.4.66__py3-none-any.whl

stravinsky_claude_assets/commands/delphi.md

@@ -0,0 +1,9 @@
+---
+name: delphi
+description: |
+  (⚠️ DEPRECATED) Strategic advisor. Use Delphi native subagent instead.
+---
+
+# /delphi (⚠️ DEPRECATED)
+
+**Status**: Deprecated. The Delphi agent is now available as a **Native Subagent** (`.claude/agents/delphi.md`).

stravinsky_claude_assets/commands/dewey.md

@@ -0,0 +1,54 @@
+---
+description: Research librarian - docs, OSS implementations, GitHub examples.
+---
+# Dewey - Research Librarian
+
+Invokes the dewey agent (gemini-3-flash) for multi-source research.
+
+Equivalent to oh-my-opencode's `librarian` agent.
+
+## Usage
+
+```
+/dewey <research question>
+```
+
+## Capabilities
+
+- Official documentation lookup (Context7)
+- GitHub code search (grep.app)
+- Web search for best practices (Exa)
+- OSS implementation examples with permalinks
+- Multi-repository analysis
+
+## Instructions
+
+Spawn the dewey agent for comprehensive research:
+
+```python
+stravinsky_agent_spawn(
+    prompt="""$ARGUMENTS
+
+Research this topic using ALL available sources:
+1. Official documentation via Context7
+2. GitHub code examples via grep.app  
+3. Web search for current best practices via Exa
+4. Clone relevant repos if needed for deep analysis
+
+REQUIREMENTS:
+- Provide GitHub permalinks for code citations
+- Include version/date context
+- Synthesize findings with evidence links
+- Note any conflicting information""",
+    agent_type="dewey",
+    description="Research: $ARGUMENTS"
+)
+```
+
+The dewey agent uses gemini-3-flash and has access to:
+- `MCP_DOCKER_web_search_exa` - Real-time web search
+- `context7_query-docs` - Official library documentation
+- `gh` CLI - GitHub operations
+- `grep_search` / `ast_grep_search` - Code search
+
+$ARGUMENTS

stravinsky_claude_assets/commands/git-master.md

@@ -0,0 +1,112 @@
+# Git Master Skill
+
+Atomic commits with conventional format and smart history search.
+
+## Invocation
+
+```
+/git-master <command>
+```
+
+## Commands
+
+### commit - Smart Atomic Commit
+
+```
+/git-master commit
+```
+
+Workflow:
+1. Run `git status` and `git diff --staged`
+2. Analyze changes to determine commit type
+3. Generate conventional commit message
+4. Create atomic commit
+
+**Commit Types** (Conventional Commits):
+- `feat`: New feature
+- `fix`: Bug fix
+- `docs`: Documentation only
+- `style`: Formatting, no code change
+- `refactor`: Code restructuring
+- `perf`: Performance improvement
+- `test`: Adding/updating tests
+- `chore`: Build, config, dependencies
+
+**Message Format**:
+```
+<type>(<scope>): <description>
+
+[optional body]
+
+[optional footer]
+```
+
+### search - History Search
+
+```
+/git-master search <pattern>
+```
+
+Find commits matching a pattern:
+- By message: `/git-master search "fix auth"`
+- By file: `/git-master search --file src/auth.py`
+- By author: `/git-master search --author david`
+- By date: `/git-master search --since "1 week ago"`
+
+### split - Split Large Changes
+
+```
+/git-master split
+```
+
+When staged changes are too large:
+1. Analyze logical groupings
+2. Suggest split points
+3. Create multiple atomic commits
+
+### amend - Smart Amend
+
+```
+/git-master amend
+```
+
+Safely amend the last commit:
+1. Verify commit hasn't been pushed
+2. Verify you're the author
+3. Add staged changes to last commit
+4. Update message if requested
+
+## Rules
+
+1. **Atomic Commits**: One logical change per commit
+2. **Conventional Format**: Always use conventional commits
+3. **No Secrets**: Block commits containing secrets
+4. **Pre-push Check**: Verify before push to main/master
+
+## Examples
+
+```bash
+# Smart commit with auto-generated message
+/git-master commit
+
+# Search for auth-related commits
+/git-master search "auth"
+
+# Find commits that modified a specific file
+/git-master search --file mcp_bridge/auth/oauth.py
+
+# Split large staged changes
+/git-master split
+```
+
+## Safety Checks
+
+Before committing, Git Master checks for:
+- Exposed secrets (API keys, tokens, passwords)
+- Debug/test code that shouldn't be committed
+- Large binary files
+- Merge conflict markers
+
+---
+
+$ARGUMENTS: command (required) - The git-master command to execute

stravinsky_claude_assets/commands/index.md

@@ -0,0 +1,49 @@
+# Index Project for Semantic Search
+
+Index the current project for natural language code search using Ollama embeddings.
+
+## What This Does
+
+Creates a vector database for semantic code search that enables queries like:
+- "find authentication logic"
+- "error handling in API endpoints"
+- "database connection pooling"
+
+## Related Commands
+
+- `/str:watch` - Start automatic file watching for background reindexing
+- `/str:unwatch` - Stop file watcher
+- `/str:cancel` - Cancel ongoing indexing operation
+- `/str:clean` - Delete indexes to free disk space
+
+## Prerequisites
+
+Ensure Ollama is installed and the embedding model is available:
+
+```bash
+# Install Ollama (if not already installed)
+brew install ollama
+
+# Pull the lightweight embedding model (274MB, recommended)
+ollama pull nomic-embed-text
+
+# Or for better accuracy (670MB):
+ollama pull mxbai-embed-large
+```
+
+## Indexing
+
+Use the `semantic_index` MCP tool to index the current project:
+
+**Parameters:**
+- `project_path`: "." (current directory)
+- `provider`: "ollama" (free, local)
+- `force`: false (only index new/changed files)
+
+After indexing, you can use `semantic_search` with natural language queries.
+
+**Check index status:** Use `semantic_stats` to view indexed files and metadata.
+
+## Re-indexing
+
+Run `/index` again to incrementally update the index with new or modified files. Use `force=true` to rebuild the entire index from scratch.

stravinsky_claude_assets/commands/publish.md

@@ -0,0 +1,86 @@
+---
+description: Bump version, publish to PyPI, and upgrade local installation
+allowed-tools: Bash, Read, Edit
+---
+
+# Publish Stravinsky
+
+Publish a new version to PyPI and upgrade local installation.
+
+## ⚡ Quick Start (Recommended)
+
+**The user runs `./deploy.sh` manually** - This is a complete deployment script that handles:
+
+1. ✅ **Version consistency checks** - Verifies `pyproject.toml` and `mcp_bridge/__init__.py` match
+2. ✅ **Git commit** - Auto-commits version changes if only version files modified
+3. ✅ **Push to repo** - Pushes commits to origin/main
+4. ✅ **Clean build** - Removes old artifacts, builds only current version
+5. ✅ **Publish to PyPI** - Uploads wheel and tarball with API token
+6. ✅ **Create git tag** - Tags the release (e.g., v0.4.13)
+7. ✅ **Push tag to repo** - Pushes tag with `git push origin v0.4.X` (NOT --tags)
+8. ✅ **Deployment verification** - Waits 10s and checks PyPI for new version
+
+**Your role:**
+- Help bump the version in `pyproject.toml` and `mcp_bridge/__init__.py` if requested
+- Tell the user to run `./deploy.sh` - that's it!
+- **NEVER** run the deployment yourself - the script must run in the user's terminal for interactive prompts
+
+## Manual Workflow (Legacy)
+
+If the user prefers manual control:
+
+1. **Bump version** in pyproject.toml (patch by default, or specify: major, minor, patch)
+2. **Commit** the version bump
+3. **Tag** with version
+4. **Push** to trigger GitHub Actions publish workflow
+5. **Wait** for PyPI to update (~60 seconds)
+6. **Upgrade** local uv tool installation
+
+## Usage
+
+```
+/publish           # Bump patch version (0.2.56 -> 0.2.57)
+/publish minor     # Bump minor version (0.2.56 -> 0.3.0)
+/publish major     # Bump major version (0.2.56 -> 1.0.0)
+```
+
+## Implementation
+
+Execute the following steps:
+
+### Step 1: Get current version
+```bash
+grep "^version" pyproject.toml
+```
+
+### Step 2: Calculate new version
+Parse the current version and increment based on argument (default: patch).
+
+### Step 3: Update pyproject.toml
+Edit the version line to the new version.
+
+### Step 4: Commit and tag
+```bash
+git add pyproject.toml
+git commit -m "chore: bump version to X.Y.Z for PyPI release"
+git tag vX.Y.Z
+git push origin main --tags
+```
+
+### Step 5: Wait for PyPI
+```bash
+echo "Waiting 60s for PyPI publish..."
+sleep 60
+```
+
+### Step 6: Upgrade local installation
+```bash
+uv tool upgrade stravinsky
+```
+
+### Step 7: Verify
+```bash
+uv tool list | grep stravinsky
+```
+
+IMPORTANT: Always complete ALL steps. The local upgrade is critical - never skip it.

stravinsky_claude_assets/commands/review.md

@@ -0,0 +1,73 @@
+---
+description: (⚠️ DEPRECATED) Fast security and quality code review. Use code-reviewer native subagent instead.
+---
+# /review (⚠️ DEPRECATED)
+
+**Status**: Deprecated. Use the **Native Subagent** (`.claude/agents/code-reviewer.md`) instead.
+
+
+Perform a thorough code review on recent changes before committing.
+
+## Usage
+
+```
+/review [scope: staged|unstaged|branch|file]
+```
+
+Default: Reviews both staged and unstaged changes.
+
+## Review Checklist
+
+### Security
+- [ ] No hardcoded secrets or credentials
+- [ ] Input validation on user data
+- [ ] SQL injection prevention (parameterized queries)
+- [ ] XSS prevention (output encoding)
+- [ ] No command injection vulnerabilities
+
+### Performance
+- [ ] No N+1 query patterns
+- [ ] Appropriate use of caching
+- [ ] No unnecessary loops or iterations
+- [ ] Efficient data structures
+
+### Code Quality
+- [ ] Clear, descriptive names
+- [ ] Single responsibility principle
+- [ ] No code duplication
+- [ ] Appropriate error handling
+- [ ] No commented-out code
+
+### Testing
+- [ ] New code has tests
+- [ ] Edge cases covered
+- [ ] Tests are meaningful (not just coverage)
+
+## Instructions
+
+Review recent code changes:
+
+1. Get the diff:
+```bash
+git diff HEAD          # unstaged changes
+git diff --cached      # staged changes
+```
+
+2. Analyze each changed file for:
+   - Security vulnerabilities (OWASP top 10)
+   - Performance issues
+   - Code style and maintainability
+   - Missing error handling
+   - Missing tests
+
+3. Provide specific, actionable feedback:
+   - File and line number
+   - Issue description
+   - Suggested fix
+
+4. Categorize issues by severity:
+   - CRITICAL: Must fix before merge
+   - WARNING: Should fix/m
+   - SUGGESTION: Nice to have
+
+$ARGUMENTS

stravinsky_claude_assets/commands/str/agent_cancel.md

@@ -0,0 +1,70 @@
+---
+description: Cancel a running background agent
+allowed-tools: mcp__stravinsky__agent_cancel
+---
+
+# Cancel Background Agent
+
+Stop a running background agent immediately.
+
+## What This Does
+
+Terminates a running agent and cleans up resources. The agent's status will change to "cancelled" and no further work will be done.
+
+## Usage
+
+```python
+# Cancel a specific agent
+agent_cancel(task_id="task_001")
+```
+
+## Parameters
+
+- `task_id`: The task ID from `agent_spawn`
+
+## When to Cancel
+
+- **Agent stuck**: Agent is taking too long or appears hung
+- **Wrong task**: Accidentally spawned wrong agent or wrong prompt
+- **Task no longer needed**: Requirements changed, agent work is obsolete
+- **Resource management**: Too many agents running, need to free up slots
+
+## Example Workflow
+
+```python
+# 1. Spawn multiple agents
+task_1 = agent_spawn(agent_type="explore", prompt="Find X", description="Task 1")
+task_2 = agent_spawn(agent_type="dewey", prompt="Research Y", description="Task 2")
+task_3 = agent_spawn(agent_type="delphi", prompt="Review Z", description="Task 3")
+
+# 2. Check progress
+agent_list(show_all=False)
+
+# 3. Cancel slow/stuck agent
+agent_cancel(task_id=task_1["task_id"])
+
+# 4. Wait for remaining agents
+result_2 = agent_output(task_id=task_2["task_id"], block=True)
+result_3 = agent_output(task_id=task_3["task_id"], block=True)
+```
+
+## Output
+
+```
+✅ Cancelled agent task_001 (explore - Find X)
+Agent stopped gracefully
+```
+
+## Notes
+
+- **Graceful shutdown**: Agent completes current tool call before stopping
+- **No partial results**: Cancelled agents don't return partial work
+- **Safe operation**: No data loss or corruption
+- **Cannot uncancelled**: Once cancelled, use `agent_retry` to restart with same prompt
+
+## Related Commands
+
+- `/str:agent_list` - List all agents
+- `/str:agent_retry` - Retry cancelled/failed agent
+- `/str:agent_progress` - Monitor agent before cancelling
+- `/str:agent_output` - Get results from completed agents

stravinsky_claude_assets/commands/str/agent_list.md

@@ -0,0 +1,56 @@
+---
+description: List all background agents (running, completed, failed)
+allowed-tools: mcp__stravinsky__agent_list
+---
+
+# List Background Agents
+
+Show overview of all background agents spawned with `agent_spawn`, including their status, task IDs, and descriptions.
+
+## What This Does
+
+Returns a formatted table showing:
+- **Task ID**: Unique identifier for each agent
+- **Agent Type**: explore, dewey, frontend, delphi, etc.
+- **Status**: running, completed, failed
+- **Description**: Short description of the task
+- **Model**: Which model the agent is using
+- **Duration**: How long the agent has been running/ran
+
+## Usage
+
+```python
+# Show all agents (default)
+agent_list(show_all=True)
+
+# Show only running agents
+agent_list(show_all=False)
+```
+
+## Example Output
+
+```
+Background Agents (3 total, 1 running):
+
+┌──────────┬─────────┬───────────┬──────────────────────┬────────┬──────────┐
+│ Task ID  │ Type    │ Status    │ Description          │ Model  │ Duration │
+├──────────┼─────────┼───────────┼──────────────────────┼────────┼──────────┤
+│ task_001 │ explore │ running   │ Find auth code       │ Gemini │ 2m 15s   │
+│ task_002 │ dewey   │ completed │ Research JWT docs    │ Gemini │ 1m 30s   │
+│ task_003 │ delphi  │ failed    │ Architecture review  │ GPT-5  │ 3m 45s   │
+└──────────┴─────────┴───────────┴──────────────────────┴────────┴──────────┘
+```
+
+## Use Cases
+
+- **Monitor parallel agents**: Check progress of multiple spawned agents
+- **Debugging**: Find failed agents and retry
+- **Status check**: See what's currently running
+- **Task tracking**: Get task IDs for `agent_output` and `agent_progress`
+
+## Related Commands
+
+- `/str:agent_progress` - Monitor real-time agent logs
+- `/str:agent_output` - Get agent results
+- `/str:agent_cancel` - Stop running agent
+- `/str:agent_retry` - Retry failed agent

stravinsky_claude_assets/commands/str/agent_output.md

@@ -0,0 +1,92 @@
+---
+description: Get output from a background agent (block until complete or return immediately)
+allowed-tools: mcp__stravinsky__agent_output
+---
+
+# Get Agent Output
+
+Retrieve the final output from a background agent spawned with `agent_spawn`.
+
+## What This Does
+
+Returns the agent's final response. Can either:
+- **Block**: Wait for agent to finish and return result
+- **Non-blocking**: Return immediately with current status
+
+## Usage
+
+```python
+# Block until agent completes (RECOMMENDED for collecting results)
+agent_output(task_id="task_001", block=True)
+
+# Check status without blocking
+agent_output(task_id="task_001", block=False)
+```
+
+## Parameters
+
+- `task_id`: The task ID from `agent_spawn` (e.g., "task_001")
+- `block`: Whether to wait for completion (default: False)
+
+## Example Workflow
+
+```python
+# 1. Spawn agents in parallel
+task_1 = agent_spawn(
+    agent_type="explore",
+    prompt="Find authentication code",
+    description="Auth search"
+)
+
+task_2 = agent_spawn(
+    agent_type="dewey",
+    prompt="Research JWT best practices",
+    description="JWT research"
+)
+
+# 2. Collect results (blocks until both complete)
+result_1 = agent_output(task_id=task_1["task_id"], block=True)
+result_2 = agent_output(task_id=task_2["task_id"], block=True)
+
+# 3. Process results
+print(result_1)
+print(result_2)
+```
+
+## Output Format
+
+### Running Agent (block=False)
+```
+Agent task_001 is still running (2m 15s elapsed)
+Use agent_progress(task_id="task_001") to monitor logs
+```
+
+### Completed Agent
+```
+[Agent Response]
+Found authentication code in the following files:
+- mcp_bridge/auth/oauth.py
+- mcp_bridge/auth/token_store.py
+...
+```
+
+### Failed Agent
+```
+Agent task_003 failed with error:
+Error: Connection timeout to GPT API
+Use agent_retry(task_id="task_003") to retry
+```
+
+## Use Cases
+
+- **Parallel collection**: Block on multiple agents to collect all results
+- **Status polling**: Check agent status without blocking
+- **Error handling**: Get error messages from failed agents
+- **Result synthesis**: Combine outputs from multiple agents
+
+## Related Commands
+
+- `/str:agent_list` - List all agents
+- `/str:agent_progress` - Monitor real-time logs
+- `/str:agent_retry` - Retry failed agent
+- `/str:agent_cancel` - Stop running agent

stravinsky_claude_assets/commands/str/agent_progress.md

@@ -0,0 +1,74 @@
+---
+description: Monitor real-time logs from a running background agent
+allowed-tools: mcp__stravinsky__agent_progress
+---
+
+# Monitor Agent Progress
+
+Stream real-time logs from a running background agent to see what it's doing.
+
+## What This Does
+
+Shows the last N lines of an agent's execution log, including:
+- Tool calls being made
+- Reasoning/thinking steps
+- Error messages
+- Current status
+
+## Usage
+
+```python
+# Show last 20 lines (default)
+agent_progress(task_id="task_001")
+
+# Show last 50 lines
+agent_progress(task_id="task_001", lines=50)
+```
+
+## Parameters
+
+- `task_id`: The task ID from `agent_spawn`
+- `lines`: Number of log lines to show (default: 20)
+
+## Example Output
+
+```
+Progress for agent task_001 (explore - Find auth code):
+Status: running (2m 15s)
+
+[2026-01-11 04:00:15] Starting agent task_001 (explore)
+[2026-01-11 04:00:16] Tool call: semantic_search(query="authentication logic")
+[2026-01-11 04:00:18] Found 5 results in semantic search
+[2026-01-11 04:00:19] Tool call: read_file(path="mcp_bridge/auth/oauth.py")
+[2026-01-11 04:00:20] Analyzing OAuth implementation...
+[2026-01-11 04:00:21] Tool call: read_file(path="mcp_bridge/auth/token_store.py")
+[2026-01-11 04:00:22] Found keyring storage implementation
+[2026-01-11 04:00:23] Synthesizing findings...
+[2026-01-11 04:00:24] Agent completed successfully
+```
+
+## Use Cases
+
+- **Debug long-running agents**: See what's taking so long
+- **Monitor progress**: Check if agent is making progress
+- **Spot errors**: Catch errors early before completion
+- **Learn patterns**: See what tools agents use and in what order
+
+## Monitoring Multiple Agents
+
+```python
+# List all running agents
+agent_list(show_all=False)
+
+# Check progress of each
+agent_progress(task_id="task_001")
+agent_progress(task_id="task_002")
+agent_progress(task_id="task_003")
+```
+
+## Related Commands
+
+- `/str:agent_list` - List all agents
+- `/str:agent_output` - Get final results
+- `/str:agent_cancel` - Stop agent
+- `/str:agent_retry` - Retry failed agent