monomind 1.19.0 → 2.0.0

package/.claude/commands/pair/examples.md

@@ -1,156 +0,0 @@
----
-name: pair:examples
-description: Real-world pair programming scenarios — JWT auth, memory leak debugging, TDD, code review, and refactoring with effective prompt patterns
----
-
-# Pair Programming Examples
-
-Real-world scenarios with actual Claude Code patterns — no fictional CLI.
-
----
-
-## Example 1: Feature Implementation (Navigator Mode)
-
-**Goal:** Implement JWT authentication with refresh tokens.
-
-**Setup:**
-```bash
-npx monomind hooks pre-task -d "Implement JWT auth with refresh tokens"
-```
-
-**Session:**
-
-> "Implement JWT auth middleware for Express. Include: access token (15min expiry), refresh token (7 days), token rotation on refresh, and blacklisting revoked tokens. Start with the token generation utilities, then we'll do the middleware."
-
-Claude implements. Review each piece:
-
-> "Good. One issue: store refresh tokens in Redis, not in-memory. Update that before continuing."
-
-After middleware is done:
-
-> "Now write unit tests for the token generation utilities. Use Jest. Cover: valid tokens, expired tokens, tampered tokens, and token rotation."
-
-End:
-> "Summarize what we built and what's still needed before this is production-ready."
-
-```bash
-npx monomind hooks post-task --task-id <id> --success true --quality 0.9
-```
-
----
-
-## Example 2: Debugging (Debug Mode)
-
-**Goal:** Memory leak in a Node.js service.
-
-**Setup:**
-```
-Skill("superpowers:systematic-debugging")
-```
-
-Or directly:
-
-> "Debug session: our Node.js service leaks memory — grows from 150MB to 450MB over 10 minutes, then crashes. I'll share code as needed. Start by asking me questions to narrow down the cause."
-
-Claude asks targeted questions. You share relevant code sections.
-
-> "Here's the event emitter setup: [paste code]"
-
-> "Found it: EventEmitter listeners aren't removed on cleanup. Show me the fix and explain why this pattern causes the leak."
-
-Apply the fix, verify:
-
-> "Fixed. Write a test that would have caught this — one that monitors memory over time or checks listener counts."
-
----
-
-## Example 3: TDD (TDD Mode)
-
-**Goal:** Shopping cart feature, test-first.
-
-**Setup:**
-```
-Skill("superpowers:test-driven-development")
-```
-
-Or:
-
-> "TDD session: shopping cart. Write failing tests first for: add item, remove item, update quantity, calculate total, apply discount. Then I'll implement each. Don't write implementation code — just tests."
-
-**Red phase:** Claude writes failing tests. You read and understand each.
-
-**Green phase:** You implement just enough to pass.
-
-> "Tests passing. Now refactor the total calculation — it's too long."
-
-Claude refactors. You verify tests still pass.
-
-> "Next cycle: write failing tests for the discount system."
-
----
-
-## Example 4: Code Review (Review Mode)
-
-**Goal:** Review a PR diff before merging.
-
-**Setup:**
-```bash
-git diff main...feat/auth > /tmp/auth-diff.txt
-```
-
-> "Review this PR. File: `src/auth/middleware.ts`. Rate: (1) correctness, (2) security vulnerabilities, (3) error handling, (4) test coverage. List issues as: [CRITICAL] / [MAJOR] / [MINOR] with file+line."
-
-Review output guides your fixes. For each CRITICAL issue:
-
-> "Fix #2 (JWT secret in code). Show me the corrected version."
-
-After applying fixes:
-
-> "Any remaining issues worth fixing before merge?"
-
----
-
-## Example 5: Refactoring (Driver Mode)
-
-**Goal:** Modernize callback-heavy code to async/await.
-
-> "Driver mode: I'm refactoring `UserService.js` from callbacks to async/await. Watch what I change and flag if I miss anything or introduce bugs. I'll share the original first."
-
-Paste the original code.
-
-> "Here's the original getUserById. I'm changing it to async/await now."
-
-Paste your refactored version.
-
-Claude reviews: "Looks good, but you're missing error handling on the database call. Add a try/catch."
-
-Continue through each function.
-
-At end:
-
-> "Final check: any patterns in the refactored code that should be extracted into utilities?"
-
----
-
-## Effective Prompts Reference
-
-| Situation | Prompt |
-|---|---|
-| Start navigator mode | "Implement [X]. I'll review each section before you continue." |
-| Start driver mode | "I'm implementing [X]. Review as I share code and flag issues." |
-| Start TDD | "Write failing tests for [X] first. I'll implement after." |
-| Start review | "Review [file/diff]. Focus on [concern]. Rate and list issues." |
-| Start debug | "Debug [symptom]. Ask me questions to narrow down the cause." |
-| Switch mode | "Now you drive — implement [next piece] based on what we've discussed." |
-| Mid-session check | "Before we continue: summarize state and confirm the next step." |
-| End session | "Summarize: what we built, decisions made, what's left." |
-| Get unstuck | "I'm not sure how to handle [edge case]. What are the options?" |
-| Pattern question | "Is this the right pattern here, or is there a better approach?" |
-
-## See Also
-
-- [modes.md](./modes.md) — choosing the right mode
-- [session.md](./session.md) — session lifecycle and tracking
-- `superpowers:pair-programming` — structured pair programming skill
-- `superpowers:test-driven-development` — full TDD workflow
-- `superpowers:systematic-debugging` — debugging methodology

package/.claude/commands/pair/modes.md

@@ -1,122 +0,0 @@
----
-name: pair:modes
-description: Pair programming collaboration modes — driver, navigator, TDD, review, and debug modes with effective prompts for each
----
-
-# Pair Programming Modes
-
-Different collaboration patterns for different goals. Choose based on what you're trying to accomplish.
-
-## Driver Mode — You Write, Claude Reviews
-
-You do the coding. Claude watches, suggests, and catches issues in real time.
-
-**Start it:**
-> "I'm implementing [feature]. Watch what I'm building and review each piece as I share it. Point out issues, security problems, and improvements."
-
-**Best for:**
-- Learning new patterns (you get hands-on + feedback)
-- Implementing features you understand but want reviewed
-- Debugging when you have a hypothesis to test
-
-**Effective prompts during driver mode:**
-- "Here's what I wrote — what do you think?"
-- "I'm about to add validation here. Any pitfalls?"
-- "Is this the right pattern for this situation?"
-- "Review this function before I move on."
-
----
-
-## Navigator Mode — Claude Writes, You Guide
-
-Claude does the coding. You provide direction, review output, and control architecture decisions.
-
-**Start it:**
-> "Implement [feature]. I'll guide the direction and review each section before you move on. Start with [specific first piece]."
-
-**Best for:**
-- Rapid prototyping
-- Boilerplate and scaffolding
-- Exploring approaches you haven't used before
-- Getting unstuck quickly
-
-**Effective prompts during navigator mode:**
-- "Implement X. Use [pattern/library]."
-- "That's good but change [specific thing]."
-- "Before writing the next piece, explain your approach."
-- "Show me an alternative approach to this."
-
----
-
-## TDD Mode — Tests First
-
-Write failing tests, then implement just enough to pass, then refactor.
-
-**Start it:**
-> "We're doing TDD for [feature]. Write the failing tests first, explain what each test covers, then I'll implement. We refactor together after tests pass."
-
-**The cycle:**
-1. Claude writes a failing test — you understand it
-2. You implement minimal passing code
-3. Claude reviews the implementation
-4. Together you refactor
-5. Repeat
-
-**Invoke the TDD skill for full workflow:**
-```
-Skill("superpowers:test-driven-development")
-```
-
----
-
-## Review Mode — Quality Focus
-
-Work through existing code with Claude as reviewer.
-
-**Start it:**
-> "Review the changes in `src/auth/`. Focus on [security / correctness / performance]. Be specific about issues — give file, line, and explanation."
-
-**Structured review request:**
-> "Review this PR diff. Rate it on: (1) correctness, (2) security, (3) readability, (4) test coverage. List issues by severity."
-
-**Invoke the review skill:**
-```
-Skill("superpowers:requesting-code-review")
-```
-
----
-
-## Debug Mode — Problem Solving
-
-Systematic debugging as a pair.
-
-**Start it:**
-> "We have a bug: [describe symptom]. Let's debug together. Start by asking me questions to narrow down the cause."
-
-**Invoke the debugging skill:**
-```
-Skill("superpowers:systematic-debugging")
-```
-
----
-
-## Switching Modes
-
-You can switch modes at any point just by redirecting:
-
-> "Let's switch — now you drive. Implement the auth middleware based on what we've discussed."
-
-> "Actually let me write this part. Review as I go."
-
-> "Stop implementing — let's do TDD for the rest of this."
-
-## Mode Selection Guide
-
-| Goal | Mode |
-|---|---|
-| Learning + control | Driver |
-| Speed + generation | Navigator |
-| Quality from the start | TDD |
-| Fix existing code | Review |
-| Fix a bug | Debug |
-| Long complex feature | Switch (start navigator, finish driver) |

package/.claude/commands/pair/session.md

@@ -1,124 +0,0 @@
----
-name: pair:session
-description: Pair programming session lifecycle — pre-session setup, context setting, mid-session quality checks, breakpoints, end-of-session recording, and multi-session continuity
----
-
-# Pair Programming Session Lifecycle
-
-How to structure a productive pair programming session from start to finish.
-
-## 1. Before You Start
-
-Get routing and context from the hooks system:
-
-```bash
-# Register the task and get agent/model recommendations
-npx monomind hooks pre-task -d "Pair programming: implement [feature]"
-```
-
-Load relevant context from memory:
-
-```bash
-npx monomind memory search --query "[feature domain]" --type hybrid
-```
-
-## 2. Set Session Context
-
-Tell Claude everything it needs to know upfront:
-
-```
-Context for this session:
-- Goal: [what we're building]
-- Mode: [driver/navigator/TDD/review]
-- Stack: [language, framework, key libraries]
-- Constraints: [any architectural decisions already made]
-- Focus: [what matters most — correctness / speed / learning]
-```
-
-The more context upfront, the less correction mid-session.
-
-## 3. During the Session
-
-**Keeping the session focused:**
-- One concern at a time — don't mix "implement auth" with "also fix the bug in payments"
-- Check in at logical breakpoints: "Before we continue, does this approach make sense?"
-- If you get stuck: "I'm not sure how to handle [edge case]. What are our options?"
-
-**Real-time quality checks:**
-```bash
-# Watch system status during long sessions
-npx monomind status --watch
-
-# Check test state
-# (run your test suite normally)
-```
-
-**Capture decisions as you go:**
-```bash
-# Store important patterns discovered during session
-npx monomind memory store --key "session-[date]-[feature]" \
-  --value "[what we decided and why]" \
-  --namespace "decisions"
-```
-
-## 4. Breakpoints and Handoffs
-
-Use natural stopping points:
-- After implementing a complete unit (function, class, endpoint)
-- Before switching between subsystems
-- When you need to run tests and wait
-
-At each breakpoint:
-> "Summarize what we've done so far and what comes next."
-
-This keeps both you and Claude aligned on state.
-
-## 5. End of Session
-
-Record outcomes for future sessions:
-
-```bash
-# Record task completion
-npx monomind hooks post-task --task-id <id> --success true --quality 0.9
-
-# Store any patterns worth remembering
-npx monomind memory store \
-  --key "pattern-[name]" \
-  --value "[the pattern we found/confirmed]" \
-  --namespace "patterns"
-```
-
-Get a session summary:
-> "Summarize: what did we build, what decisions did we make, and what's left to do?"
-
-## Session Anti-Patterns
-
-| Anti-pattern | Instead |
-|---|---|
-| Asking 5 things at once | One question at a time |
-| No upfront context | Always set context first |
-| Never verifying Claude's code | Test frequently, review before committing |
-| Letting the session drift | Define the goal, return to it |
-| Skipping the summary | Always end with a recap |
-
-## Multi-Session Continuity
-
-Use the hooks session system to restore context across conversations:
-
-```bash
-# At session end — persist state
-npx monomind hooks session-end
-
-# Next session — restore
-npx monomind hooks session-restore
-```
-
-Or just tell Claude at the start of the next session:
-> "We were implementing JWT auth. We finished the token generation but still need the refresh token endpoint. Continue from there."
-
-## See Also
-
-- [modes.md](./modes.md) — pick the right collaboration mode
-- [examples.md](./examples.md) — real workflow examples
-- `hooks pre-task` / `hooks post-task` — task tracking
-- `memory store` / `memory search` — persist session knowledge

package/.claude/commands/sparc/analyzer.md

@@ -1,35 +0,0 @@
----
-name: sparc:analyzer
-description: Analyzer - Deep code and data analysis with batch processing capabilities. Performs parallel file analysis, pattern recognition, and performance profiling.
----
-
-# SPARC Analyzer Mode
-
-## Purpose
-Deep code and data analysis with batch processing capabilities.
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:analyzer")
-```
-
-## Core Capabilities
-- Code analysis with parallel file processing
-- Data pattern recognition
-- Performance profiling
-- Memory usage analysis
-- Dependency mapping
-
-## Batch Operations
-- Parallel file analysis using concurrent Read operations
-- Batch pattern matching with Grep tool
-- Simultaneous metric collection
-- Aggregated reporting
-
-## Output Format
-- Detailed analysis reports
-- Performance metrics
-- Improvement recommendations
-- Visualizations when applicable

package/.claude/commands/sparc/architect.md

@@ -1,36 +0,0 @@
----
-name: sparc:architect
-description: Architect - System design with Memory-based coordination for scalable architectures. Covers microservices, DDD, event-driven design, and API contracts.
----
-
-# SPARC Architect Mode
-
-## Purpose
-System design with Memory-based coordination for scalable architectures.
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:architect")
-```
-
-## Core Capabilities
-- System architecture design
-- Component interface definition
-- Database schema design
-- API contract specification
-- Infrastructure planning
-
-## Memory Integration
-- Store architecture decisions in Memory
-- Share component specifications across agents
-- Maintain design consistency
-- Track architectural evolution
-
-## Design Patterns
-- Microservices
-- Event-driven architecture
-- Domain-driven design
-- Hexagonal architecture
-- CQRS and Event Sourcing

package/.claude/commands/sparc/ask.md

@@ -1,56 +0,0 @@
----
-name: sparc:ask
-description: Ask - You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correct SPARC modes.
----
-
-# Ask
-
-## Role Definition
-You are a task-formulation guide that helps users navigate, ask, and delegate tasks to the correct SPARC modes.
-
-## Custom Instructions
-Guide users to ask questions using SPARC methodology:
-
-• `spec-pseudocode` – logic plans, pseudocode, flow outlines
-• `architect` – system diagrams, API boundaries
-• `code` – implement features with env abstraction
-• `tdd` – test-first development, coverage tasks
-• `debug` – isolate runtime issues
-• `security-review` – check for secrets, exposure
-• `docs-writer` – create markdown guides
-• `integration` – link services, ensure cohesion
-• `post-deployment-monitoring-mode` – observe production
-• `refinement-optimization-mode` – refactor & optimize
-• `supabase-admin` – manage Supabase database, auth, and storage
-
-Help users craft `new_task` messages to delegate effectively, and always remind them:
-- Modular
-- Env-safe
-- Files < 500 lines
-- Use `attempt_completion`
-
-## Available Tools
-- **read**: File reading and viewing
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:ask")
-```
-
-## Memory Integration
-
-```javascript
-// Store context
-mcp__monomind__memory_store({ key: "ask_context", value: "important decisions", namespace: "ask" })
-
-// Search previous work
-mcp__monomind__memory_search({ query: "ask", namespace: "ask", limit: 5 })
-```
-
-```bash
-# CLI equivalents
-npx monomind memory store "ask_context" "important decisions" --namespace ask
-npx monomind memory search --query "ask" --namespace ask
-```

package/.claude/commands/sparc/batch-executor.md

@@ -1,37 +0,0 @@
----
-name: sparc:batch-executor
-description: Batch Executor - Parallel task execution specialist using batch operations. Concurrent file operations, load balancing, and result aggregation.
----
-
-# SPARC Batch Executor Mode
-
-## Purpose
-Parallel task execution specialist using batch operations.
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:batch-executor")
-```
-
-## Core Capabilities
-- Parallel file operations
-- Concurrent task execution
-- Resource optimization
-- Load balancing
-- Progress tracking
-
-## Execution Patterns
-- Parallel Read/Write operations
-- Concurrent Edit operations
-- Batch file transformations
-- Distributed processing
-- Pipeline orchestration
-
-## Performance Features
-- Dynamic resource allocation
-- Automatic load balancing
-- Progress monitoring
-- Error recovery
-- Result aggregation

package/.claude/commands/sparc/code.md

@@ -1,48 +0,0 @@
----
-name: sparc:code
-description: Auto-Coder - You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.
----
-
-# Auto-Coder
-
-## Role Definition
-You write clean, efficient, modular code based on pseudocode and architecture. You use configuration for environments and break large components into maintainable files.
-
-## Custom Instructions
-Write modular code using clean architecture principles. Never hardcode secrets or environment values. Split code into files < 500 lines. Use config files or environment abstractions. Use `new_task` for subtasks and finish with `attempt_completion`.
-
-## Tool Usage Guidelines:
-- Use `insert_content` when creating new files or when the target file is empty
-- Use `apply_diff` when modifying existing code, always with complete search and replace blocks
-- Only use `search_and_replace` as a last resort and always include both search and replace parameters
-- Always verify all required parameters are included before executing any tool
-
-## Available Tools
-- **read**: File reading and viewing
-- **edit**: File modification and creation
-- **browser**: Web browsing capabilities
-- **mcp**: Model Context Protocol tools
-- **command**: Command execution
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:code")
-```
-
-## Memory Integration
-
-```javascript
-// Store context
-mcp__monomind__memory_store({ key: "code_context", value: "important decisions", namespace: "code" })
-
-// Search previous work
-mcp__monomind__memory_search({ query: "code", namespace: "code", limit: 5 })
-```
-
-```bash
-# CLI equivalents
-npx monomind memory store "code_context" "important decisions" --namespace code
-npx monomind memory search --query "code" --namespace code
-```

package/.claude/commands/sparc/coder.md

@@ -1,37 +0,0 @@
----
-name: sparc:coder
-description: Coder - Autonomous code generation with batch file operations. ES2022/TypeScript standards with comprehensive error handling and security best practices.
----
-
-# SPARC Coder Mode
-
-## Purpose
-Autonomous code generation with batch file operations.
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:coder")
-```
-
-## Core Capabilities
-- Feature implementation
-- Code refactoring
-- Bug fixes
-- API development
-- Algorithm implementation
-
-## Batch Operations
-- Parallel file creation
-- Concurrent code modifications
-- Batch import updates
-- Test file generation
-- Documentation updates
-
-## Code Quality
-- ES2022 standards
-- Type safety with TypeScript
-- Comprehensive error handling
-- Performance optimization
-- Security best practices

package/.claude/commands/sparc/debug.md

@@ -1,42 +0,0 @@
----
-name: sparc:debug
-description: Debugger - You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.
----
-
-# Debugger
-
-## Role Definition
-You troubleshoot runtime bugs, logic errors, or integration failures by tracing, inspecting, and analyzing behavior.
-
-## Custom Instructions
-Use logs, traces, and stack analysis to isolate bugs. Avoid changing env configuration directly. Keep fixes modular. Refactor if a file exceeds 500 lines. Use `new_task` to delegate targeted fixes and return your resolution via `attempt_completion`.
-
-## Available Tools
-- **read**: File reading and viewing
-- **edit**: File modification and creation
-- **browser**: Web browsing capabilities
-- **mcp**: Model Context Protocol tools
-- **command**: Command execution
-
-## How to Invoke
-
-In Claude Code, load this mode as a skill:
-```
-Skill("sparc:debug")
-```
-
-## Memory Integration
-
-```javascript
-// Store context
-mcp__monomind__memory_store({ key: "debug_context", value: "important decisions", namespace: "debug" })
-
-// Search previous work
-mcp__monomind__memory_search({ query: "debug", namespace: "debug", limit: 5 })
-```
-
-```bash
-# CLI equivalents
-npx monomind memory store "debug_context" "important decisions" --namespace debug
-npx monomind memory search --query "debug" --namespace debug
-```