Initial commit

commands/juggle-plan-all.md

@@ -0,0 +1,153 @@
+---
+description: Analyze all active juggler balls and create a comprehensive execution plan
+---
+
+# Juggle Plan All Command
+
+**Task**: Analyze all active juggler balls in the current project and create a comprehensive execution plan.
+
+## Objective
+
+Review all active tasks (balls) being juggled and create a prioritized, structured plan for completing them efficiently.
+
+## Execution Steps
+
+### Step 1: Gather Ball Data
+
+Run the following command to export all active balls:
+
+```bash
+juggle export --format json
+```
+
+This will output JSON data containing all balls (excluding completed/done by default).
+
+### Step 2: Analyze Balls
+
+Review the exported ball data and identify:
+
+**Ball Properties to Consider**:
+- `id` - Ball identifier
+- `intent` - What the ball is trying to accomplish
+- `priority` - high/medium/low priority
+- `active_state` - Current state (ready/juggling)
+- `juggle_state` - Sub-state (needs-thrown/in-air/needs-caught)
+- `todos` - Specific tasks within the ball (if present)
+- `last_activity` - When the ball was last touched
+- `zellij_session`/`zellij_tab` - Context information
+
+**Analysis Criteria**:
+1. **State Priority**:
+   - `needs-caught` balls should be addressed first (work completed, needs verification)
+   - `needs-thrown` balls need direction/input next
+   - `in-air` balls are actively being worked on
+   - `ready` balls haven't been started yet
+
+2. **Priority Levels**:
+   - High priority balls should be tackled before medium/low
+   - Consider if priority conflicts with state priority
+
+3. **Dependencies**:
+   - Look for balls that reference similar components/files
+   - Identify balls that might block or enable other balls
+   - Note balls with todos that relate to other balls' intents
+
+4. **Completeness**:
+   - Balls with todos: Check how many are completed vs pending
+   - Balls near completion should generally be prioritized
+
+### Step 3: Create Structured Plan
+
+Generate a comprehensive plan with the following sections:
+
+**1. Executive Summary**:
+- Total number of active balls
+- Breakdown by state (needs-caught, needs-thrown, in-air, ready)
+- Breakdown by priority
+
+**2. Ball Groups** (organize by theme/component):
+- Group related balls together
+- Identify common themes (e.g., CLI improvements, refactoring, bug fixes)
+- Note dependencies between groups
+
+**3. Recommended Execution Order**:
+For each ball in suggested order, provide:
+- Ball ID and intent
+- Current state and why it's positioned here
+- Key todos or next actions
+- Estimated complexity (if discernible)
+- Dependencies or blockers
+
+**4. Quick Wins**:
+- Identify balls that are nearly complete
+- Highlight balls that unblock others
+- Note any balls in `needs-caught` state that just need verification
+
+**5. Parking Lot**:
+- Balls that can wait (low priority + not blocking)
+- Balls that need more information (needs-thrown with unclear direction)
+
+### Step 4: Present Recommendations
+
+After presenting the plan, provide:
+
+**Immediate Next Steps**:
+- Which ball(s) to address first and why
+- Specific commands to run (e.g., `juggle juggler-8 in-air`)
+- Any preparation needed before starting
+
+**Workflow Suggestion**:
+- Should balls be tackled sequentially or can some be parallelized?
+- Are there natural break points for user review?
+- When should `/split-plan` be invoked to delegate to specialized agents?
+
+## Output Format
+
+Structure your response as:
+
+```
+# Juggler Plan Analysis
+
+## Executive Summary
+[Stats and overview]
+
+## Active Ball Groups
+
+### Group 1: [Theme Name]
+**Balls**: juggler-X, juggler-Y
+**Dependencies**: [Any dependencies]
+**Description**: [What these balls accomplish together]
+
+### Group 2: [Theme Name]
+...
+
+## Recommended Execution Order
+
+1. **juggler-X**: [Intent]
+   - State: [Current state]
+   - Priority: [Priority level]
+   - Next Action: [What to do]
+   - Why First: [Reasoning]
+
+2. **juggler-Y**: [Intent]
+   ...
+
+## Quick Wins
+- [Balls that can be completed quickly]
+
+## Parking Lot
+- [Balls that can wait]
+
+## Immediate Next Steps
+1. [First action]
+2. [Second action]
+3. [When to use /split-plan]
+```
+
+## Success Criteria
+
+- All active balls are accounted for in the plan
+- Execution order has clear reasoning based on priority, state, and dependencies
+- User has actionable next steps
+- Plan identifies which balls should be tackled immediately vs later
+- Dependencies and blockers are clearly identified