claude-code-orchestrator-kit 1.4.1 → 1.4.16

package/.claude/commands/speckit.implement.md

@@ -17,13 +17,6 @@ You **MUST** consider the user input before proceeding (if not empty).
 
 ## Outline
 
-0. **Session Check** (DeksdenFlow):
-   - Invoke `resume-session` skill to check for existing session
-   - If valid session found: ask user "Resume previous session or start fresh?"
-   - If resume: load context.md and session-log.md, jump to saved phase
-   - If fresh or no session: proceed to step 1
-   - **Also**: Invoke `load-project-context` skill to load project structure map
-
 1. Run `.specify/scripts/bash/check-prerequisites.sh --json --require-tasks --include-tasks` from repo root and parse FEATURE_DIR and AVAILABLE_DOCS list. All paths must be absolute. For single quotes in args like "I'm Groot", use escape syntax: e.g 'I'\''m Groot' (or double-quote if possible: "I'm Groot").
 
 2. **Check checklists status** (if FEATURE_DIR/checklists/ exists):
@@ -192,10 +185,6 @@ You **MUST** consider the user input before proceeding (if not empty).
    - Provide clear error messages with context for debugging
    - Suggest next steps if implementation cannot proceed
    - **IMPORTANT** For completed tasks, make sure to mark the task off as [X] in the tasks file
-   - **Session Context** (DeksdenFlow):
-     * After completing each PHASE (not task): invoke `save-session-context` skill
-     * On error or pause: save context before stopping
-     * Log significant decisions to session-log.md (architecture choices, issue resolutions)
    - **Critical Rules**:
      * NEVER skip verification
      * NEVER proceed if task failed

package/.claude/commands/supabase-performance-optimizer.md

@@ -0,0 +1,73 @@
+---
+allowed-tools: Read, Write, Edit, Bash, Task
+argument-hint: [--all] | --queries | --indexes | --rls | --functions | --realtime | --storage
+description: Optimize Supabase database performance by delegating to specialized agents
+---
+
+# Supabase Performance Optimizer
+
+Optimize Supabase database performance with specialized agents: **$ARGUMENTS**
+
+## Agent Delegation Matrix
+
+| Argument | Agent | What it fixes |
+|----------|-------|---------------|
+| `--queries`, `--indexes`, `--rls`, `--functions` | `supabase-fixer` | Advisors API issues (security + performance) |
+| `--realtime` | `supabase-realtime-optimizer` | Publication issues, subscription indexes |
+| `--storage` | `supabase-storage-optimizer` | Orphaned files, table sizes, data types |
+| `--all` | All three agents | Complete optimization |
+
+## Task Execution
+
+Based on **$ARGUMENTS**, delegate to the appropriate agent(s):
+
+### For `--queries`, `--indexes`, `--rls`, `--functions`:
+
+Use Task tool with:
+- `subagent_type`: `supabase-fixer`
+- `prompt`: Focus on performance advisors for query/index optimization, or security advisors for RLS/function issues
+
+### For `--realtime`:
+
+Use Task tool with:
+- `subagent_type`: `supabase-realtime-optimizer`
+- `prompt`: Optimize realtime subscriptions, check publications, add missing indexes for filters
+
+### For `--storage`:
+
+Use Task tool with:
+- `subagent_type`: `supabase-storage-optimizer`
+- `prompt`: Analyze table sizes, find orphaned files, optimize data types
+
+### For `--all`:
+
+Run all three agents sequentially:
+1. First: `supabase-fixer` (security + performance advisors)
+2. Then: `supabase-realtime-optimizer` (realtime publications)
+3. Finally: `supabase-storage-optimizer` (storage cleanup)
+
+## Expected Output
+
+Each agent generates a structured report in `.tmp/current/`:
+- `database-fixing-report.md` (from supabase-fixer)
+- `realtime-optimization-report.md` (from supabase-realtime-optimizer)
+- `storage-optimization-report.md` (from supabase-storage-optimizer)
+
+## Quick Reference
+
+```bash
+# Fix security issues (RLS, functions)
+/supabase-performance-optimizer --rls --functions
+
+# Optimize queries and indexes
+/supabase-performance-optimizer --queries --indexes
+
+# Optimize realtime subscriptions
+/supabase-performance-optimizer --realtime
+
+# Clean up storage
+/supabase-performance-optimizer --storage
+
+# Full optimization (all agents)
+/supabase-performance-optimizer --all
+```

package/.claude/commands/ultra-think.md

@@ -0,0 +1,158 @@
+---
+description: Deep analysis and problem solving with multi-dimensional thinking
+argument-hint: [problem or question to analyze]
+---
+
+# Deep Analysis and Problem Solving Mode
+
+Deep analysis and problem solving mode
+
+## Instructions
+
+1. **Initialize Ultra Think Mode**
+   - Acknowledge the request for enhanced analytical thinking
+   - Set context for deep, systematic reasoning
+   - Prepare to explore the problem space comprehensively
+
+2. **Parse the Problem or Question**
+   - Extract the core challenge from: $ARGUMENTS
+   - Identify all stakeholders and constraints
+   - Recognize implicit requirements and hidden complexities
+   - Question assumptions and surface unknowns
+
+3. **Multi-Dimensional Analysis**
+   Approach the problem from multiple angles:
+   
+   ### Technical Perspective
+   - Analyze technical feasibility and constraints
+   - Consider scalability, performance, and maintainability
+   - Evaluate security implications
+   - Assess technical debt and future-proofing
+   
+   ### Business Perspective
+   - Understand business value and ROI
+   - Consider time-to-market pressures
+   - Evaluate competitive advantages
+   - Assess risk vs. reward trade-offs
+   
+   ### User Perspective
+   - Analyze user needs and pain points
+   - Consider usability and accessibility
+   - Evaluate user experience implications
+   - Think about edge cases and user journeys
+   
+   ### System Perspective
+   - Consider system-wide impacts
+   - Analyze integration points
+   - Evaluate dependencies and coupling
+   - Think about emergent behaviors
+
+4. **Generate Multiple Solutions**
+   - Brainstorm at least 3-5 different approaches
+   - For each approach, consider:
+     - Pros and cons
+     - Implementation complexity
+     - Resource requirements
+     - Potential risks
+     - Long-term implications
+   - Include both conventional and creative solutions
+   - Consider hybrid approaches
+
+5. **Deep Dive Analysis**
+   For the most promising solutions:
+   - Create detailed implementation plans
+   - Identify potential pitfalls and mitigation strategies
+   - Consider phased approaches and MVPs
+   - Analyze second and third-order effects
+   - Think through failure modes and recovery
+
+6. **Cross-Domain Thinking**
+   - Draw parallels from other industries or domains
+   - Apply design patterns from different contexts
+   - Consider biological or natural system analogies
+   - Look for innovative combinations of existing solutions
+
+7. **Challenge and Refine**
+   - Play devil's advocate with each solution
+   - Identify weaknesses and blind spots
+   - Consider "what if" scenarios
+   - Stress-test assumptions
+   - Look for unintended consequences
+
+8. **Synthesize Insights**
+   - Combine insights from all perspectives
+   - Identify key decision factors
+   - Highlight critical trade-offs
+   - Summarize innovative discoveries
+   - Present a nuanced view of the problem space
+
+9. **Provide Structured Recommendations**
+   Present findings in a clear structure:
+   ```
+   ## Problem Analysis
+   - Core challenge
+   - Key constraints
+   - Critical success factors
+   
+   ## Solution Options
+   ### Option 1: [Name]
+   - Description
+   - Pros/Cons
+   - Implementation approach
+   - Risk assessment
+   
+   ### Option 2: [Name]
+   [Similar structure]
+   
+   ## Recommendation
+   - Recommended approach
+   - Rationale
+   - Implementation roadmap
+   - Success metrics
+   - Risk mitigation plan
+   
+   ## Alternative Perspectives
+   - Contrarian view
+   - Future considerations
+   - Areas for further research
+   ```
+
+10. **Meta-Analysis**
+    - Reflect on the thinking process itself
+    - Identify areas of uncertainty
+    - Acknowledge biases or limitations
+    - Suggest additional expertise needed
+    - Provide confidence levels for recommendations
+
+## Usage Examples
+
+```bash
+# Architectural decision
+/ultra-think Should we migrate to microservices or improve our monolith?
+
+# Complex problem solving
+/ultra-think How do we scale our system to handle 10x traffic while reducing costs?
+
+# Strategic planning
+/ultra-think What technology stack should we choose for our next-gen platform?
+
+# Design challenge
+/ultra-think How can we improve our API to be more developer-friendly while maintaining backward compatibility?
+```
+
+## Key Principles
+
+- **First Principles Thinking**: Break down to fundamental truths
+- **Systems Thinking**: Consider interconnections and feedback loops
+- **Probabilistic Thinking**: Work with uncertainties and ranges
+- **Inversion**: Consider what to avoid, not just what to do
+- **Second-Order Thinking**: Consider consequences of consequences
+
+## Output Expectations
+
+- Comprehensive analysis (typically 2-4 pages of insights)
+- Multiple viable solutions with trade-offs
+- Clear reasoning chains
+- Acknowledgment of uncertainties
+- Actionable recommendations
+- Novel insights or perspectives

package/.claude/commands/worktree.md

@@ -0,0 +1,150 @@
+---
+description: Manage git worktrees for parallel feature development (create, remove, list, cleanup)
+---
+
+# Git Worktree Manager
+
+Manage git worktrees for parallel feature development.
+
+## Usage
+
+```bash
+/worktree create <feature-name> [base-branch]
+/worktree remove <feature-name> [--force] [--delete-branch]
+/worktree list
+/worktree cleanup [--dry-run] [--remove-dirs]
+```
+
+---
+
+## Commands
+
+### create
+
+Create new worktree for parallel development.
+
+**What it does:**
+- Creates `megacampus2-worktrees/` directory (if not exists)
+- Creates new branch `feature/<name>` from base
+- Creates worktree in separate directory
+- Copies gitignored files per `.worktree-sync.json`
+
+**Process:**
+1. Validate feature name (alphanumeric, hyphens only)
+2. Check for uncommitted changes (warn if present)
+3. Create worktree: `git worktree add ../megacampus2-worktrees/<name> -b feature/<name> <base>`
+4. Sync files from `.worktree-sync.json`:
+   - `sync.files`: `.env`, `.env.local`, `.mcp.json`, etc.
+   - `sync.directories`: `.vscode`
+   - `sync.patterns`: `packages/*/.env`, `services/*/.env`
+5. Output next steps (open in IDE, commit workflow)
+
+**Errors:**
+- Worktree exists: suggest different name or remove existing
+- Branch exists: checkout existing or use different name
+
+---
+
+### remove
+
+Remove worktree and optionally delete branch.
+
+**What it does:**
+- Checks for uncommitted changes
+- Removes worktree directory
+- Optionally deletes local and remote branch
+- Runs `git worktree prune`
+
+**Process:**
+1. Find worktree by name
+2. Check git status (if uncommitted changes, require --force or user choice)
+3. Remove: `git worktree remove [--force] <path>`
+4. If --delete-branch:
+   - Check if merged: `git branch --merged main | grep feature/<name>`
+   - Delete local: `git branch -d/-D feature/<name>`
+   - Delete remote: `git push origin --delete feature/<name>`
+5. Cleanup: `git worktree prune`
+
+**Errors:**
+- Not found: show available worktrees
+- Main worktree: cannot remove
+- Uncommitted changes: offer commit/force/cancel
+- Unmerged branch: warn, offer PR/force/keep-branch
+
+---
+
+### list
+
+Show all worktrees with status.
+
+**Output:**
+```
+# Git Worktrees (N total)
+
+| Name | Branch | Path | Status |
+|------|--------|------|--------|
+| main (основной) | main | /home/me/code/megacampus2 | Active |
+| feature-name | feature/feature-name | .../megacampus2-worktrees/feature-name | Active |
+
+Commands: /worktree create <name> | /worktree remove <name>
+```
+
+**Process:**
+1. Run `git worktree list --porcelain`
+2. For each worktree: extract path, branch, HEAD, status (locked/prunable)
+3. Format table with status indicators
+
+---
+
+### cleanup
+
+Clean up stale worktree files and orphaned directories.
+
+**What it does:**
+- Prunes administrative files for deleted worktrees
+- Repairs recoverable worktrees
+- Removes orphaned directories (with --remove-dirs)
+
+**Process:**
+1. Dry-run check: `git worktree prune --dry-run --verbose`
+2. Find orphaned dirs in `megacampus2-worktrees/` not in `git worktree list`
+3. Try repair: `git worktree repair <path>`
+4. If not --dry-run: `git worktree prune --verbose`
+5. If --remove-dirs: remove orphaned/empty directories
+
+**Output:**
+```
+# Worktree Cleanup Report
+
+✅ Pruned administrative records: N
+✅ Removed directories: N (--remove-dirs)
+✅ Recovered worktrees: N
+
+Active worktrees: N
+All valid: ✅
+```
+
+---
+
+## File Sync Config
+
+`.worktree-sync.json` format:
+```json
+{
+  "sync": {
+    "files": [".env", ".env.local", ".mcp.json"],
+    "directories": [".vscode"],
+    "patterns": ["packages/*/.env", "services/*/.env"]
+  }
+}
+```
+
+---
+
+## Notes
+
+- Worktrees share `.git` → saves disk space
+- Each worktree must be on unique branch
+- Cannot checkout same branch in multiple worktrees
+- Main worktree cannot be removed
+- Use --dry-run with cleanup to preview changes