stravinsky 0.4.17__tar.gz → 0.4.36__tar.gz

stravinsky-0.4.36/.claude/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-0.4.36/.claude/commands/str/list_watchers.md

@@ -0,0 +1,96 @@
+---
+description: /str:list_watchers - List all active file watchers across projects
+allowed-tools: mcp__stravinsky__list_file_watchers
+---
+
+# List Active File Watchers
+
+View all currently running file watchers for automatic semantic search reindexing.
+
+## What This Does
+
+Displays information about active file watchers across all projects including:
+- Project path being watched
+- Embedding provider (ollama, gemini, openai, huggingface)
+- Debounce interval (wait time before reindexing)
+- Current status (running/stopped)
+
+## Prerequisites
+
+At least one file watcher must be running. Start a watcher with `/str:start_filewatch` first.
+
+## Usage
+
+Call the MCP tool directly (no parameters):
+
+```python
+mcp__stravinsky__list_file_watchers()
+```
+
+Returns a list of dicts with:
+- `project_path`: Root directory being watched
+- `provider`: Embedding provider name
+- `debounce_seconds`: Wait time before reindexing
+- `status`: "running" or "stopped"
+
+## Example Output
+
+```
+Active File Watchers
+====================
+
+Watcher 1:
+  Project: /Users/dev/project1
+  Provider: ollama
+  Debounce: 2.0s
+  Status: running
+
+Watcher 2:
+  Project: /Users/dev/project2
+  Provider: gemini
+  Debounce: 3.0s
+  Status: running
+
+Total: 2 active watchers
+```
+
+## Use Cases
+
+**Before stopping a watcher:**
+```python
+# List watchers to get project path
+mcp__stravinsky__list_file_watchers()
+
+# Stop specific watcher
+mcp__stravinsky__stop_file_watcher(project_path="/Users/dev/project1")
+```
+
+**Check status across multiple repos:**
+```python
+# See all watched projects at once
+mcp__stravinsky__list_file_watchers()
+```
+
+**Verify watcher started successfully:**
+```python
+# After starting watcher
+mcp__stravinsky__start_file_watcher(project_path=".", provider="ollama")
+
+# Confirm it's running
+mcp__stravinsky__list_file_watchers()
+```
+
+## Troubleshooting
+
+**"No active watchers"**: Start a watcher with `/str:start_filewatch` first.
+
+**"Watcher shows stopped"**: The watcher encountered an error or was manually stopped. Restart with `/str:start_filewatch`.
+
+**Multiple watchers for same project**: This indicates duplicate watcher processes. Stop and restart with `/str:stop_filewatch`.
+
+## Tips
+
+- Run this before stopping watchers to identify project paths
+- Use to verify watchers are running after system restart
+- Check status if reindexing seems not to be happening automatically
+- Each project can only have ONE active watcher per provider

{stravinsky-0.4.17 → stravinsky-0.4.36}/.claude/commands/strav.md

@@ -26,10 +26,30 @@ Before ANY classification or action:
 
 ## Phase 1: Classify & Validate
 
+### Step 0: IRONSTAR Mode Detection (PRIORITY CHECK)
+
+**BEFORE classification, scan prompt for:**
+- Keywords: `ironstar`, `irs`, `ultrawork`, `ulw` (case-insensitive)
+- If detected: **ACTIVATE MAXIMUM PARALLEL MODE**
+
+**IRONSTAR MODE RULES:**
+1. **ALWAYS use agents** - NEVER work alone with Read/Grep/Bash
+2. **Spawn ALL independent tasks in parallel** - Minimum 2+ agents for any multi-step work
+3. **Default to explore/dewey** - Use cheap agents aggressively
+4. **No sequential work** - If tasks can run in parallel, they MUST
+
+**Example:**
+```
+User: "ironstar Find auth flow and error handling"
+→ IMMEDIATE: agent_spawn(explore, "auth flow") + agent_spawn(explore, "error handling")
+→ NEVER: Read file yourself, grep yourself, or work sequentially
+```
+
 ### Step 1: Classify Request Type
 
 | Type | Signal | Action |
 |------|--------|--------|
+| **IRONSTAR Mode** | Contains: ironstar, irs, ultrawork, ulw | Maximum parallel delegation (2+ agents minimum) |
 | **Skill Match** | Matches skill trigger | INVOKE skill via `skill_get` |
 | **Exploratory** | "How does X work?", "Find Y" | Fire explore agents in parallel |
 | **Implementation** | "Add feature", "Refactor" | Create TODO list → spawn parallel agents |
@@ -40,22 +60,24 @@ Before ANY classification or action:
 - Do I have implicit assumptions?
 - What tools/agents can I use: `agent_spawn`, parallel tools, LSP?
 - Should I challenge the user if design seems flawed?
+- **If IRONSTAR detected**: Am I spawning at least 2+ agents in parallel?
 
 ---
 
 ## ⚠️ CRITICAL: PARALLEL-FIRST WORKFLOW
 
-**For implementation tasks, your response MUST be:**
+**For ANY task with 2+ independent steps, your response MUST be:**
 
 ```
-1. TodoWrite (create all items)
-2. SAME RESPONSE: Multiple agent_spawn() calls for ALL independent TODOs
+1. TodoWrite (create all items) OR identify independent subtasks
+2. SAME RESPONSE: Multiple agent_spawn() calls for ALL independent work
 3. NEVER mark in_progress until agents return
+4. NEVER use Read/Grep/Bash when agents can do it
 ```
 
-**BLOCKING REQUIREMENT**: After TodoWrite, spawn ALL agents in the SAME response.
+**BLOCKING REQUIREMENT**: After TodoWrite OR after identifying exploratory work, spawn ALL agents in the SAME response.
 
-### CORRECT (one response with parallel agents):
+### ✅ CORRECT Pattern 1: Implementation with TODOs
 ```
 TodoWrite([todo1, todo2, todo3])
 agent_spawn(agent_type="explore", prompt="TODO 1...")
@@ -64,14 +86,46 @@ agent_spawn(agent_type="explore", prompt="TODO 2...")
   → explore:gemini-3-flash('TODO 2...') task_id=agent_def456
 agent_spawn(agent_type="dewey", prompt="TODO 3...")
   → dewey:gemini-3-flash('TODO 3...') task_id=agent_ghi789
+# Continue in SAME response - collect results later
 ```
 
-### WRONG (sequential - defeats parallelism):
+### ✅ CORRECT Pattern 2: Exploratory (NO TodoWrite needed)
+```
+User: "Find auth flow and error handling"
+
+# IMMEDIATE parallel spawn (no TodoWrite):
+agent_spawn(agent_type="explore", prompt="Find auth flow...")
+  → explore:gemini-3-flash('Find auth flow...') task_id=agent_abc123
+agent_spawn(agent_type="explore", prompt="Find error handling...")
+  → explore:gemini-3-flash('Find error handling...') task_id=agent_def456
+# Continue in SAME response
+```
+
+### ❌ WRONG Pattern 1: Sequential (defeats parallelism)
 ```
 TodoWrite([todo1, todo2, todo3])
 # Response ends - WRONG!
-# Next: Mark todo1 in_progress - WRONG!
-# Next: Do work manually - WRONG!
+# Next response: Mark todo1 in_progress - WRONG!
+# Next response: Do work manually - WRONG!
+```
+
+### ❌ WRONG Pattern 2: Manual Work (when agents available)
+```
+User: "Find auth flow and error handling"
+
+# WRONG - doing it yourself:
+Read("src/auth.py")  # Should be agent_spawn(explore)
+Grep("error", "**/*.py")  # Should be agent_spawn(explore)
+```
+
+### Decision Tree: When to Spawn Agents
+
+```
+Is this exploratory (search, find, understand)?
+├─ YES → Spawn explore/dewey agents immediately (no TodoWrite)
+└─ NO → Is this implementation with 2+ steps?
+    ├─ YES → TodoWrite + spawn agents in SAME response
+    └─ NO → Single simple task, work directly (rare)
 ```
 
 ---
@@ -119,12 +173,30 @@ When using `agent_spawn`, include ALL 7 sections:
 
 | Domain | Delegate To | Trigger |
 |--------|-------------|---------|
+| **Maximum Parallel Mode** | `explore` + `dewey` | **IRONSTAR, IRS, ULTRAWORK, ULW** |
 | Frontend Visual | `frontend` | Color, spacing, layout, CSS, animation |
 | External Research | `dewey` | Docs, library usage, OSS examples |
 | Internal Search | `explore` | Find patterns in THIS repo |
 | Architecture | `delphi` | Design decisions, tradeoffs |
 | Hard Debugging | `delphi` | After 2+ failed fixes |
 
+### IRONSTAR Mode Behavior
+
+When IRONSTAR/IRS/ULTRAWORK/ULW keywords detected:
+
+**MANDATORY:**
+- ✅ Spawn 2+ agents minimum (even for simple tasks)
+- ✅ Use explore for ALL code searches
+- ✅ Use dewey for ALL external research
+- ✅ Fire all agents in SAME response
+- ✅ NEVER use Read/Grep/Bash directly
+
+**FORBIDDEN:**
+- ❌ Working alone without agents
+- ❌ Sequential execution (spawn one, wait, spawn another)
+- ❌ Single agent for multi-part tasks
+- ❌ Direct tool usage (Read, Grep, Bash) when agents available
+
 ---
 
 ## Execution Context (READ THIS FIRST)

stravinsky-0.4.36/.claude/hooks/comment_checker.py

@@ -0,0 +1,193 @@
+#!/usr/bin/env python3
+"""
+PreToolUse hook: Comment Quality Enforcer (oh-my-opencode parity)
+
+Fires BEFORE git commit/push operations to check for low-quality comments.
+Challenges comments that just restate what the code does.
+
+Exit codes:
+- 0: Allow the operation to proceed
+- 2: Block the operation (hard block)
+
+Trigger: PreToolUse on Bash tool when command contains 'git commit' or 'git push'
+"""
+
+import json
+import sys
+import re
+from pathlib import Path
+from typing import List, Tuple, Optional
+
+# Patterns that indicate low-quality comments
+LOW_QUALITY_PATTERNS = [
+    # Comments that just describe what code literally does
+    r"#\s*(?:set|get|return|call|create|initialize|init)\s+\w+",
+    # Comments that are just variable/function names repeated
+    r"#\s*\w+\s*$",
+    # Empty or trivial comments
+    r"#\s*(?:TODO|FIXME|XXX|HACK)?\s*$",
+    # Comments that state the obvious
+    r"#\s*(?:loop|iterate|check|if|else|for|while)\s+(?:through|over|if|the)?\s*\w*\s*$",
+    # Comments like "# increment i" or "# add 1 to x"
+    r"#\s*(?:increment|decrement|add|subtract|multiply|divide)\s+\w+",
+]
+
+# Patterns for GOOD comments we should NOT flag
+GOOD_COMMENT_PATTERNS = [
+    # Docstrings and multi-line comments explaining WHY
+    r'""".*"""',
+    r"'''.*'''",
+    # Comments explaining business logic or reasoning
+    r"#\s*(?:because|since|note|important|warning|caution|reason|why|rationale)",
+    # Comments with URLs or references
+    r"#\s*(?:see|ref|https?://|link)",
+    # Type hints or type comments
+    r"#\s*type:",
+    # Pragma or directive comments
+    r"#\s*(?:noqa|type:|pragma|pylint|flake8)",
+]
+
+
+def is_low_quality_comment(comment: str) -> bool:
+    """Check if a comment is low-quality (just restates code)."""
+    comment_lower = comment.lower().strip()
+
+    # Skip if it matches a good pattern
+    for pattern in GOOD_COMMENT_PATTERNS:
+        if re.search(pattern, comment_lower, re.IGNORECASE):
+            return False
+
+    # Check against low-quality patterns
+    for pattern in LOW_QUALITY_PATTERNS:
+        if re.search(pattern, comment_lower, re.IGNORECASE):
+            return True
+
+    # Very short comments (< 10 chars after #) are often low quality
+    content = comment.replace("#", "").strip()
+    if len(content) < 10 and not any(c in content for c in ["!", "?", ":", "TODO", "FIXME"]):
+        return True
+
+    return False
+
+
+def extract_added_comments_from_diff(diff_text: str) -> List[Tuple[str, str]]:
+    """
+    Extract newly added comments from a git diff.
+    Returns list of (filename, comment) tuples.
+    """
+    added_comments = []
+    current_file = None
+
+    for line in diff_text.split("\n"):
+        # Track which file we're in
+        if line.startswith("+++ b/"):
+            current_file = line[6:]
+        # Only look at added lines (starting with +, but not +++)
+        elif line.startswith("+") and not line.startswith("+++"):
+            content = line[1:]  # Remove the leading +
+            # Check for Python comments
+            if "#" in content and not content.strip().startswith("#!"):
+                # Extract the comment part
+                comment_match = re.search(r"#.*$", content)
+                if comment_match:
+                    comment = comment_match.group(0)
+                    if current_file:
+                        added_comments.append((current_file, comment))
+
+    return added_comments
+
+
+def check_staged_diff() -> Optional[str]:
+    """
+    Check the staged diff for low-quality comments.
+    Returns a warning message if issues found, None otherwise.
+    """
+    import subprocess
+
+    try:
+        # Get the staged diff
+        result = subprocess.run(
+            ["git", "diff", "--cached", "--unified=0"], capture_output=True, text=True, timeout=10
+        )
+
+        if result.returncode != 0:
+            return None  # Can't get diff, allow commit
+
+        diff_text = result.stdout
+        if not diff_text:
+            return None  # No staged changes
+
+        # Extract and check comments
+        added_comments = extract_added_comments_from_diff(diff_text)
+        low_quality = []
+
+        for filename, comment in added_comments:
+            if is_low_quality_comment(comment):
+                low_quality.append((filename, comment))
+
+        if low_quality:
+            warning = "⚠️ **Comment Quality Check Failed**\n\n"
+            warning += "The following comments appear to just restate the code:\n\n"
+            for filename, comment in low_quality[:5]:  # Limit to 5 examples
+                warning += f"- `{filename}`: `{comment[:50]}...`\n"
+            warning += "\n**Good comments explain WHY, not WHAT.**\n"
+            warning += "Consider removing or improving these comments.\n\n"
+            warning += "To proceed anyway, use: `git commit --no-verify`"
+            return warning
+
+        return None
+
+    except subprocess.TimeoutExpired:
+        return None  # Timeout, allow commit
+    except FileNotFoundError:
+        return None  # Git not found, allow commit
+    except Exception:
+        return None  # Any other error, allow commit
+
+
+def is_git_commit_command(command: str) -> bool:
+    """Check if the command is a git commit or push."""
+    command_lower = command.lower()
+    return any(
+        pattern in command_lower
+        for pattern in [
+            "git commit",
+            "git push",
+        ]
+    )
+
+
+def main():
+    try:
+        hook_input = json.load(sys.stdin)
+    except (json.JSONDecodeError, EOFError):
+        return 0
+
+    tool_name = hook_input.get("tool_name", "")
+    tool_input = hook_input.get("tool_input", {})
+
+    # Only check Bash commands
+    if tool_name != "Bash":
+        return 0
+
+    command = tool_input.get("command", "")
+
+    # Only check git commit/push commands
+    if not is_git_commit_command(command):
+        return 0
+
+    # Check for low-quality comments in staged diff
+    warning = check_staged_diff()
+
+    if warning:
+        # Output warning to stderr (shown to user)
+        print(warning, file=sys.stderr)
+        # Return 0 to allow but warn, or 2 to block
+        # We'll warn but allow - users can use --no-verify to skip
+        return 0
+
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())