specpulse 1.0.3__py3-none-any.whl → 1.0.5__py3-none-any.whl

specpulse/resources/commands/claude/task.md

@@ -1,56 +1,237 @@
-# /task
+---
+name: task
+description: Generate and manage task breakdowns using AI-optimized templates
+allowed_tools:
+  - Read
+  - Write  
+  - Edit
+  - Bash
+  - TodoWrite
+---
 
-Generate task breakdowns using SpecPulse structure.
+# /task Command
+
+Generate task breakdowns from implementation plans using SpecPulse methodology with AI-optimized templates and enhanced validation.
 
 ## Usage
 ```
-/task breakdown
-/task update
-/task status
-```
-
-## Commands
-
-### breakdown
-Generate tasks from plan:
-1. Create task categories:
-   - Critical Path (Phase 0)
-   - Phase 1: Foundation
-   - Phase 2: Core Features
-   - Phase 3: Polish
-   - Phase 4: Testing
-
-2. For each task:
-   - Use T[XXX] format (T001, T002)
-   - Include clear description
-   - Mark dependencies
-   - Estimate complexity (S/M/L/XL)
-   - Assign priority
-
-3. Write to tasks/[feature]/tasks.md
-
-### update
-Update task status:
-1. Mark tasks as completed
-2. Add new discovered tasks
-3. Update dependencies
-4. Track blockers
-
-### status
-Show task progress:
-1. Count completed vs total
-2. Show current phase
-3. List blockers
-4. Estimate remaining work
-
-## Task Format
+/task [action] [feature-directory]
+```
+
+Actions: `breakdown`, `update`, `status`, `execute` (defaults to `breakdown`)
+
+## Implementation
+
+When called with `/task $ARGUMENTS`, I will:
+
+1. **Parse arguments** to determine action:
+   - If `update`: Update task status and dependencies
+   - If `status`: Show comprehensive progress with metrics
+   - If `execute`: Execute task with script integration
+   - Otherwise: Generate task breakdown
+
+2. **For `/task breakdown` or `/task`:**
+   
+   a. **Enhanced validation** using cross-platform script:
+      ```bash
+      # Cross-platform detection
+      if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+          powershell scripts/pulse-task.ps1 "$FEATURE_DIR"
+      else
+          bash scripts/pulse-task.sh "$FEATURE_DIR" || python scripts/pulse-task.py "$FEATURE_DIR"
+      fi
+      ```
+   
+   b. **Read implementation plan** from `plans/XXX-feature/plan.md`
+   
+   c. **Generate AI-optimized tasks** using template variables:
+      ```markdown
+      # Task List: {{ feature_name }}
+      ## Metadata
+      - **Total Tasks**: {{ task_count }}
+      - **Estimated Duration**: {{ total_duration }}
+      ```
+
+   d. **Generate structured task categories**:
+      - **Constitutional Gates Compliance**: Pre-implementation validation
+      - **Critical Path (Phase 0)**: Tasks that impact timeline
+      - **Parallel Groups**: Tasks that can execute simultaneously
+      - **Sequential Tasks**: Tasks with dependencies
+      - **Execution Schedule**: Time-based task organization
+      - **Progress Tracking**: YAML configuration for monitoring
+
+   e. **For each task**, generate comprehensive metadata:
+      - **ID**: T[XXX] format (T001, T002)
+      - **Type**: setup, development, testing, documentation
+      - **Priority**: HIGH, MEDIUM, LOW
+      - **Estimate**: Hours or complexity points
+      - **Dependencies**: Task ID dependencies
+      - **Description**: Clear what needs to be done
+      - **Acceptance**: How to verify completion
+      - **Files**: Files to be created/modified
+      - **Assignable**: Role/skill required
+      - **Parallel**: Whether can run in parallel [P]
+
+   f. **Generate execution commands** with script integration:
+      ```bash
+      # Execute parallel tasks
+      parallel_tasks="T001 T002 T003"
+      for task in $parallel_tasks; do
+          ./scripts/execute-task.sh "$task" &
+      done
+      wait
+      ```
+
+   g. **Write comprehensive task breakdown** to `tasks/XXX-feature/tasks.md`
+
+3. **For `/task update`:**
+   - **Enhanced analysis** using cross-platform script:
+     ```bash
+     # Cross-platform detection
+     if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+         powershell scripts/pulse-task.ps1 "$FEATURE_DIR"
+     else
+         bash scripts/pulse-task.sh "$FEATURE_DIR" || python scripts/pulse-task.py "$FEATURE_DIR"
+     fi
+     ```
+   - **Parse current tasks** with comprehensive status:
+     - Total tasks, completed, pending, blocked
+     - Parallel tasks identification
+     - Constitutional gates status
+     - Completion percentage calculation
+   - **Interactive task updates**:
+     - Mark tasks as completed/in-progress/blocked
+     - Update dependencies and blockers
+     - Add newly discovered tasks with proper metadata
+     - Adjust estimates based on actual progress
+   - **Generate updated progress tracking** YAML
+
+4. **For `/task status`:**
+   - **Enhanced reporting** from script output:
+     ```bash
+     TOTAL_TASKS=25
+     COMPLETED_TASKS=10
+     COMPLETION_PERCENTAGE=40%
+     CONSTITUTIONAL_GATES_PENDING=2
+     ```
+   - **Display comprehensive progress**:
+     - Overall completion percentage
+     - Phase-by-phase progress
+     - Blocker identification and resolution
+     - Velocity metrics and estimates
+     - Constitutional gates compliance status
+
+5. **For `/task execute`:**
+   - **Validate task readiness** using constitutional gates
+   - **Execute task** with enhanced error handling:
+     ```bash
+     ./scripts/execute-task.sh "$TASK_ID"
+     ```
+   - **Track execution results** and update status
+   - **Update progress tracking** automatically
+
+## Enhanced Task Format
 ```markdown
-- [ ] T001: [S] Set up project structure
-- [ ] T002: [M] Create database schema
-- [x] T003: [L] Implement authentication
+### Parallel Group A
+#### T001: Initialize project structure
+- **Type**: setup
+- **Priority**: HIGH
+- **Estimate**: 2 hours
+- **Dependencies**: None
+- **Description**: Set up project directory structure and configuration
+- **Acceptance**: All directories exist and config files are valid
+- **Files**: package.json, README.md, .gitignore
+- **Assignable**: developer
+- **Parallel**: [P]
+
+## Progress Tracking
+```yaml
+status:
+  total: 25
+  completed: 10
+  in_progress: 3
+  blocked: 0
+  
+metrics:
+  velocity: 2-3 tasks/day
+  estimated_completion: 2025-09-15
+  completion_percentage: 40%
 ```
 
-## Example
+## Constitutional Gates Integration
+
+Each task breakdown includes constitutional compliance validation:
+- **Simplicity Gate**: Tasks avoid unnecessary complexity
+- **Test-First Gate**: Test tasks before implementation tasks
+- **Integration-First Gate**: Real service integration preferred
+- **Research Gate**: Technology research tasks included
+
+## Examples
+
+### Generate task breakdown
+```
+User: /task breakdown
+```
+I will:
+- Run: Cross-platform detection and execution
+  ```bash
+  # Cross-platform detection
+  if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+      powershell scripts/pulse-task.ps1 "$FEATURE_DIR"
+  else
+      bash scripts/pulse-task.sh "$FEATURE_DIR" || python scripts/pulse-task.py "$FEATURE_DIR"
+  fi
+  ```
+- Create: AI-optimized task structure with template variables
+- Output: `TOTAL_TASKS=25, PARALLEL_TASKS=8, STATUS=generated`
+
+### Update task status
+```
+User: /task update mark T001-T005 as completed
+```
+I will update task status and recalculate progress metrics.
+
+### Show comprehensive status
 ```
-/task breakdown
-```
+User: /task status
+```
+I will display detailed progress with constitutional gates compliance.
+
+### Execute specific task
+```
+User: /task execute T001
+```
+I will:
+- Validate: Constitutional gates compliance and task readiness
+- Execute: Cross-platform task execution
+  ```bash
+  # Cross-platform task execution
+  if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
+      powershell scripts/pulse-task.ps1 "$FEATURE_DIR" "execute:$TASK_ID"
+  else
+      bash scripts/pulse-task.sh "$FEATURE_DIR" "execute:$TASK_ID" || python scripts/pulse-task.py "$FEATURE_DIR" "execute:$TASK_ID"
+  fi
+  ```
+- Track: Results and update progress automatically
+
+## Enhanced Features
+
+- **Cross-platform script execution** with automatic detection (PowerShell/Bash/Python)
+- **AI-optimized templates** with Jinja2-style variables
+- **Enhanced script integration** for validation and execution
+- **Constitutional gates compliance** tracking
+- **Parallel task identification** and execution
+- **Comprehensive progress tracking** with YAML configuration
+- **Automatic percentage calculation** and velocity metrics
+- **Task dependency management** with conflict detection
+- **Execution command generation** with script integration
+- **Platform-agnostic operation** for Windows, Linux, and macOS
+
+## Error Handling
+
+- Plan existence validation before task generation
+- Constitutional gates compliance checking
+- Template structure validation
+- Dependency conflict detection
+- Task execution error handling with rollback
+- Progress tracking validation and correction

specpulse/resources/commands/gemini/plan.toml

@@ -1,48 +1,59 @@
-[command]
-name = "plan"
-description = "Generate implementation plans"
-
-[command.subcommands.generate]
-description = "Create plan from specification"
-usage = "/plan generate"
-
-[[command.subcommands.generate.phase_gates]]
-name = "Constitutional Compliance"
-checks = [
-    "simplicity_check",
-    "test_first_check",
-    "framework_usage_check"
-]
-
-[[command.subcommands.generate.phase_gates]]
-name = "Complexity Check"
-max_modules = 3
-requires_justification = true
-
-[[command.subcommands.generate.actions]]
-step = "read_spec"
-file = "specs/{{feature}}/spec.md"
-
-[[command.subcommands.generate.actions]]
-step = "generate_plan"
-template = "templates/plan.md"
-sections = [
-    "technology_stack",
-    "architecture",
-    "phases",
-    "api_contracts",
-    "data_models",
-    "test_strategy"
-]
-
-[[command.subcommands.generate.actions]]
-step = "write_file"
-path = "plans/{{feature}}/plan.md"
-
-[command.subcommands.validate]
-description = "Validate plan against constitution"
-checks = [
-    "phase_gates_passed",
-    "complexity_tracked",
-    "test_first_defined"
-]
+description = "Generate or validate implementation plans"
+prompt = """
+Handle the /plan command with arguments: {{args}}
+
+Parse arguments to determine action:
+- If "validate": Check plan against constitution
+- Otherwise: Generate new plan
+
+## For /plan generate or /plan:
+1. Read current specification from @{specs/*/spec.md}
+
+2. Run Phase Gates checks:
+   - Constitutional compliance
+   - Simplicity check (≤3 modules)
+   - Test-first strategy defined
+   - Framework selection complete
+   - Research completed
+
+3. Generate plan sections:
+   - Technology stack
+   - Architecture overview
+   - Implementation phases
+   - API contracts
+   - Data models
+   - Testing strategy
+
+4. Track complexity:
+   - If >3 modules, document justification
+   - Create simplification roadmap
+
+5. Write plan to plans/XXX-feature/plan.md
+6. Run cross-platform validation:
+   - Windows: !{powershell scripts/pulse-plan.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-plan.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-plan.py "XXX-feature"}
+
+## For /plan validate:
+1. Read existing plan from @{plans/*/plan.md}
+2. Run cross-platform validation:
+   - Windows: !{powershell scripts/pulse-plan.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-plan.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-plan.py "XXX-feature"}
+3. Verify Phase Gates compliance
+4. Check complexity tracking
+5. Ensure test-first approach
+6. Validate framework choices
+7. Report validation results
+
+Phase Gates (Phase -1) must pass before implementation:
+- ✅ Using ≤3 projects/modules
+- ✅ Tests defined before code
+- ✅ Using framework features directly
+- ✅ No premature abstractions
+- ✅ Research completed
+
+Examples:
+- /plan generate
+- /plan validate
+"""

specpulse/resources/commands/gemini/pulse.toml

@@ -1,45 +1,27 @@
-[command]
-name = "pulse"
-description = "Initialize SpecPulse features"
+description = "Initialize a new feature with SpecPulse framework"
+prompt = """
+Initialize a new SpecPulse feature with the name: {{args}}
 
-[command.subcommands.init]
-description = "Initialize a new feature with proper structure"
-usage = "/pulse init <feature-name>"
+Please follow these steps:
 
-[[command.subcommands.init.steps]]
-action = "run_script"
-script = "scripts/pulse-init.sh"
-args = ["{{feature_name}}"]
+1. Extract the feature name from the provided arguments
+2. Run the initialization script with cross-platform detection:
+   - Windows: !{powershell scripts/pulse-init.ps1 "{{args}}"}
+   - Linux/macOS: !{bash scripts/pulse-init.sh "{{args}}"}  
+   - Fallback: !{python scripts/pulse-init.py "{{args}"}
+3. Create the feature structure:
+   - Generate feature ID (001, 002, etc.)
+   - Create directories: specs/XXX-feature/, plans/XXX-feature/, tasks/XXX-feature/
+   - Copy templates to feature directories
+   - Update memory/context.md with current feature
+   - Create git branch if in git repository
 
-[[command.subcommands.init.steps]]
-action = "create_files"
-files = [
-    "specs/{{branch_name}}/spec.md",
-    "plans/{{branch_name}}/plan.md",
-    "tasks/{{branch_name}}/tasks.md"
-]
+4. Report the results showing:
+   - Created structure paths
+   - Feature ID and branch name
+   - Next steps for the user
 
-[[command.subcommands.init.steps]]
-action = "update_context"
-file = "memory/context.md"
-content = """
-## Active Feature: {{feature_name}}
-- Feature ID: {{feature_id}}
-- Branch: {{branch_name}}
-- Started: {{timestamp}}
-"""
+If no feature name is provided, ask the user for the feature name first.
 
-[[command.subcommands.init.steps]]
-action = "git_branch"
-branch = "{{branch_name}}"
-
-[command.response]
-template = """
-✅ Feature initialized: {{feature_name}}
-- Branch: {{branch_name}}
-- Spec: specs/{{branch_name}}/spec.md
-- Plan: plans/{{branch_name}}/plan.md
-- Tasks: tasks/{{branch_name}}/tasks.md
-
-Next: Use /spec create to define requirements
+Example usage: /pulse user-authentication
 """

specpulse/resources/commands/gemini/spec.toml

@@ -1,33 +1,45 @@
-[command]
-name = "spec"
-description = "Manage feature specifications"
+description = "Create or manage feature specifications"
+prompt = """
+Handle the /spec command with arguments: {{args}}
 
-[command.subcommands.create]
-description = "Create specification from requirements"
-usage = "/spec create <description>"
+Parse the arguments to determine the action:
+- If starts with "create": Generate new specification
+- If starts with "update": Modify existing specification  
+- If starts with "validate": Check specification completeness
+- If no action specified: Default to "create" with full arguments as description
 
-[[command.subcommands.create.actions]]
-step = "analyze_requirements"
-input = "{{description}}"
+## For /spec create [description] or /spec [description]:
+1. Read template from @{templates/spec.md}
+2. Parse the description to identify:
+   - Functional requirements (Must/Should/Could have)
+   - User stories and acceptance criteria
+   - Technical requirements
+3. Mark any uncertainties with [NEEDS CLARIFICATION: detail]
+4. Find current feature directory (latest in specs/)
+5. Write specification to specs/XXX-feature/spec.md
+6. Run cross-platform validation:
+   - Windows: !{powershell scripts/pulse-spec.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-spec.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-spec.py "XXX-feature"}
 
-[[command.subcommands.create.actions]]
-step = "generate_spec"
-template = "templates/spec.md"
-markers = ["[NEEDS CLARIFICATION]"]
+## For /spec update:
+1. Read existing specification from @{specs/*/spec.md}
+2. Ask user for clarifications or changes
+3. Update content while preserving structure
+4. Remove resolved [NEEDS CLARIFICATION] markers
 
-[[command.subcommands.create.actions]]
-step = "write_file"
-path = "specs/{{feature}}/spec.md"
+## For /spec validate:
+1. Run cross-platform validation:
+   - Windows: !{powershell scripts/pulse-spec.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-spec.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-spec.py "XXX-feature"}
+2. Check all required sections are filled
+3. Count [NEEDS CLARIFICATION] markers
+4. Verify acceptance criteria are testable
+5. Report validation results
 
-[command.subcommands.validate]
-description = "Validate specification completeness"
-checks = [
-    "all_sections_filled",
-    "no_clarification_markers",
-    "testable_criteria",
-    "technical_specs_defined"
-]
-
-[command.subcommands.update]
-description = "Update existing specification"
-usage = "/spec update"
+Examples:
+- /spec user authentication with OAuth2 and email/password
+- /spec update
+- /spec validate
+"""

specpulse/resources/commands/gemini/task.toml

@@ -1,51 +1,69 @@
-[command]
-name = "task"
-description = "Manage task breakdowns"
-
-[command.subcommands.breakdown]
-description = "Generate tasks from plan"
-usage = "/task breakdown"
-
-[[command.subcommands.breakdown.categories]]
-name = "Critical Path"
-phase = 0
-prefix = "T0"
-
-[[command.subcommands.breakdown.categories]]
-name = "Foundation"
-phase = 1
-prefix = "T1"
-
-[[command.subcommands.breakdown.categories]]
-name = "Core Features"
-phase = 2
-prefix = "T2"
-
-[[command.subcommands.breakdown.categories]]
-name = "Polish"
-phase = 3
-prefix = "T3"
-
-[[command.subcommands.breakdown.categories]]
-name = "Testing"
-phase = 4
-prefix = "T4"
-
-[command.subcommands.breakdown.format]
-pattern = "T{id:03d}"
-complexity = ["S", "M", "L", "XL"]
-template = "- [ ] {id}: [{complexity}] {description}"
-
-[command.subcommands.update]
-description = "Update task status"
-actions = ["complete", "add", "block", "unblock"]
-
-[command.subcommands.status]
-description = "Show task progress"
-shows = [
-    "completed_count",
-    "total_count",
-    "current_phase",
-    "blockers",
-    "estimate"
-]
+description = "Generate and manage task breakdowns"
+prompt = """
+Handle the /task command with arguments: {{args}}
+
+Parse arguments to determine action:
+- If "update": Update task status
+- If "status": Show progress
+- Otherwise: Generate task breakdown
+
+## For /task breakdown or /task:
+1. Read implementation plan from @{plans/*/plan.md}
+
+2. Generate tasks from plan:
+   - Create task categories:
+     • Critical Path (Phase 0)
+     • Phase 1: Foundation
+     • Phase 2: Core Features
+     • Phase 3: Polish
+     • Phase 4: Testing
+
+   - For each task:
+     • Use T[XXX] format (T001, T002)
+     • Include clear description
+     • Mark dependencies
+     • Estimate complexity (S/M/L/XL)
+     • Assign priority
+
+3. Write tasks to tasks/XXX-feature/tasks.md
+4. Run cross-platform validation:
+   - Windows: !{powershell scripts/pulse-task.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-task.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-task.py "XXX-feature"}
+
+## For /task update:
+1. Read current tasks from @{tasks/*/tasks.md}
+2. Ask which tasks to update
+3. Mark tasks as completed/in-progress
+4. Add newly discovered tasks
+5. Update dependencies and blockers
+6. Save updated task list
+7. Run cross-platform validation:
+   - Windows: !{powershell scripts/pulse-task.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-task.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-task.py "XXX-feature"}
+
+## For /task status:
+1. Read current tasks
+2. Run cross-platform analysis:
+   - Windows: !{powershell scripts/pulse-task.ps1 "XXX-feature"}
+   - Linux/macOS: !{bash scripts/pulse-task.sh "XXX-feature"}
+   - Fallback: !{python scripts/pulse-task.py "XXX-feature"}
+3. Count completed vs total
+4. Show current phase progress
+5. List any blockers
+6. Estimate remaining work
+7. Display progress summary
+
+Task Format:
+```markdown
+- [ ] T001: [S] Set up project structure
+- [ ] T002: [M] Create database schema
+- [x] T003: [L] Implement authentication
+```
+
+Examples:
+- /task breakdown
+- /task update
+- /task status
+"""