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

specpulse/resources/commands/claude/task.md

@@ -1,78 +1,237 @@
 ---
 name: task
-description: Generate and manage task breakdowns
+description: Generate and manage task breakdowns using AI-optimized templates
 allowed_tools:
   - Read
   - Write  
   - Edit
   - Bash
+  - TodoWrite
 ---
 
 # /task Command
 
-Generate task breakdowns from implementation plans using SpecPulse structure.
+Generate task breakdowns from implementation plans using SpecPulse methodology with AI-optimized templates and enhanced validation.
 
 ## Usage
 ```
-/task [action]
+/task [action] [feature-directory]
 ```
 
-Actions: `breakdown`, `update`, `status` (defaults to `breakdown`)
+Actions: `breakdown`, `update`, `status`, `execute` (defaults to `breakdown`)
 
 ## Implementation
 
 When called with `/task $ARGUMENTS`, I will:
 
 1. **Parse arguments** to determine action:
-   - If `$ARGUMENTS` is `update`: Update task status
-   - If `$ARGUMENTS` is `status`: Show progress
+   - 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. **Read implementation plan** from `plans/XXX-feature/plan.md`
+   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. **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
-
-   c. **Write tasks** to `tasks/XXX-feature/tasks.md`
+   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`:**
-   - Read current tasks from `tasks/XXX-feature/tasks.md`
-   - Ask which tasks to update
-   - Mark tasks as completed/in-progress
-   - Add newly discovered tasks
-   - Update dependencies and blockers
-   - Save updated task list
+   - **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`:**
-   - Read current tasks
-   - Count completed vs total
-   - Show current phase progress
-   - List any blockers
-   - Estimate remaining work
-   - Display progress summary
-
-## Task Format
+   - **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
 ```
-/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
+```
+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

@@ -29,14 +29,22 @@ Parse arguments to determine action:
    - 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. Verify Phase Gates compliance
-3. Check complexity tracking
-4. Ensure test-first approach
-5. Validate framework choices
-6. Report validation results
+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

specpulse/resources/commands/gemini/pulse.toml

@@ -5,7 +5,10 @@ Initialize a new SpecPulse feature with the name: {{args}}
 Please follow these steps:
 
 1. Extract the feature name from the provided arguments
-2. Run the initialization script: !{bash scripts/pulse-init.sh "{{args}}"}
+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/

specpulse/resources/commands/gemini/spec.toml

@@ -17,6 +17,10 @@ Parse the arguments to determine the action:
 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"}
 
 ## For /spec update:
 1. Read existing specification from @{specs/*/spec.md}
@@ -25,10 +29,14 @@ Parse the arguments to determine the action:
 4. Remove resolved [NEEDS CLARIFICATION] markers
 
 ## For /spec validate:
-1. Check all required sections are filled
-2. Count [NEEDS CLARIFICATION] markers
-3. Verify acceptance criteria are testable
-4. Report validation results
+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
 
 Examples:
 - /spec user authentication with OAuth2 and email/password

specpulse/resources/commands/gemini/task.toml

@@ -26,6 +26,10 @@ Parse arguments to determine action:
      • 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}
@@ -34,14 +38,22 @@ Parse arguments to determine action:
 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. Count completed vs total
-3. Show current phase progress
-4. List any blockers
-5. Estimate remaining work
-6. Display progress summary
+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

specpulse/resources/memory/constitution.md

@@ -124,7 +124,7 @@ complexity_exceptions:
     violation: "Using 4 projects instead of 3"
     justification: "Authentication requires separate service for security isolation"
     approved_by: "Team Lead"
-    date: "2024-01-15"
+    date: "2025-09-11"
 ```
 
 ### Amendment Process
@@ -233,5 +233,5 @@ While principles are immutable, their application can evolve:
 ## Living Constitution
 This constitution is a living document that learns from experience while maintaining core principles. Each project iteration strengthens these principles through practical application and refinement.
 
-*Last Updated: 2024-12-27*
+*Last Updated: 2025-09-11*
 *Version: 2.0 - Full SDD Methodology Implementation*

specpulse/resources/scripts/pulse-init.ps1

@@ -0,0 +1,186 @@
+# SpecPulse Feature Initialization Script
+# Cross-platform PowerShell equivalent of pulse-init.sh
+
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$FeatureName,
+    
+    [string]$CustomId = ""
+)
+
+$ErrorActionPreference = "Stop"
+$ProgressPreference = "SilentlyContinue"
+
+# Configuration
+$ScriptName = $MyInvocation.MyCommand.Name
+$ProjectRoot = $PSScriptRoot | Split-Path -Parent | Split-Path -Parent
+$MemoryDir = Join-Path $ProjectRoot "memory"
+$ContextFile = Join-Path $MemoryDir "context.md"
+$TemplatesDir = Join-Path $ProjectRoot "resources" "templates"
+
+function Write-Log {
+    param([string]$Message)
+    $Timestamp = Get-Date -Format "yyyy-MM-dd HH:mm:ss"
+    Write-Host "[$Timestamp] $ScriptName : $Message" -ForegroundColor Yellow
+}
+
+function Exit-WithError {
+    param([string]$Message)
+    Write-Log "ERROR: $Message"
+    exit 1
+}
+
+function Sanitize-FeatureName {
+    param([string]$Name)
+    
+    if ([string]::IsNullOrWhiteSpace($Name)) {
+        Exit-WithError "Feature name cannot be empty"
+    }
+    
+    # Convert to lowercase, replace spaces and special chars with hyphens
+    $Sanitized = $Name.ToLower() -replace '[^a-z0-9-]', '-'
+    $Sanitized = $Sanitized -replace '-+', '-'  # Remove consecutive hyphens
+    $Sanitized = $Sanitized.Trim('-')  # Remove leading/trailing hyphens
+    
+    if ([string]::IsNullOrWhiteSpace($Sanitized)) {
+        Exit-WithError "Invalid feature name: '$Name'"
+    }
+    
+    return $Sanitized
+}
+
+function Get-FeatureId {
+    param([string]$CustomId)
+    
+    if ($CustomId) {
+        return "{0:D3}" -f [int]$CustomId
+    }
+    
+    # Find existing feature directories
+    $SpecsDir = Join-Path $ProjectRoot "specs"
+    if (Test-Path $SpecsDir) {
+        $Existing = Get-ChildItem -Path $SpecsDir -Directory | 
+                  Where-Object { $_.Name -match '^\d+$' } |
+                  Sort-Object Name
+        $NextId = $Existing.Count + 1
+    } else {
+        $NextId = 1
+    }
+    
+    return "{0:D3}" -f $NextId
+}
+
+function Create-Directories {
+    param([string]$BranchName)
+    
+    $Directories = @(
+        (Join-Path $ProjectRoot "specs" $BranchName),
+        (Join-Path $ProjectRoot "plans" $BranchName),
+        (Join-Path $ProjectRoot "tasks" $BranchName)
+    )
+    
+    foreach ($Directory in $Directories) {
+        try {
+            New-Item -ItemType Directory -Path $Directory -Force | Out-Null
+            Write-Log "Created directory: $Directory"
+        } catch {
+            Exit-WithError "Failed to create directory $Directory : $_"
+        }
+    }
+}
+
+function Copy-Templates {
+    param([string]$BranchName)
+    
+    $Templates = @{
+        "spec.md" = (Join-Path $ProjectRoot "specs" $BranchName "spec.md")
+        "plan.md" = (Join-Path $ProjectRoot "plans" $BranchName "plan.md")
+        "task.md" = (Join-Path $ProjectRoot "tasks" $BranchName "tasks.md")
+    }
+    
+    foreach ($Template in $Templates.GetEnumerator()) {
+        $TemplatePath = Join-Path $TemplatesDir $Template.Key
+        $TargetPath = $Template.Value
+        
+        if (-not (Test-Path $TemplatePath)) {
+            Exit-WithError "Template not found: $TemplatePath"
+        }
+        
+        try {
+            Copy-Item $TemplatePath $TargetPath -Force
+            Write-Log "Copied template to: $TargetPath"
+        } catch {
+            Exit-WithError "Failed to copy template $TemplatePath : $_"
+        }
+    }
+}
+
+function Update-Context {
+    param(
+        [string]$FeatureName,
+        [string]$FeatureId,
+        [string]$BranchName
+    )
+    
+    try {
+        New-Item -ItemType Directory -Path $MemoryDir -Force | Out-Null
+        
+        $ContextEntry = @"
+
+## Active Feature: $FeatureName
+- Feature ID: $FeatureId
+- Branch: $BranchName
+- Started: $(Get-Date -Format "o")
+"@
+        
+        Add-Content -Path $ContextFile -Value $ContextEntry -Encoding UTF8
+        Write-Log "Updated context file: $ContextFile"
+    } catch {
+        Exit-WithError "Failed to update context file: $_"
+    }
+}
+
+function New-GitBranch {
+    param([string]$BranchName)
+    
+    $GitDir = Join-Path $ProjectRoot ".git"
+    if (-not (Test-Path $GitDir)) {
+        return
+    }
+    
+    try {
+        # Check if branch already exists
+        $ExistingBranch = git branch --list $BranchName
+        if ($ExistingBranch) {
+            Write-Log "Git branch '$BranchName' already exists, checking out"
+            git checkout $BranchName
+        } else {
+            Write-Log "Creating new git branch '$BranchName'"
+            git checkout -b $BranchName
+        }
+    } catch {
+        Exit-WithError "Git operation failed: $_"
+    }
+}
+
+# Main execution
+Write-Log "Initializing feature: $FeatureName"
+
+# Sanitize and generate identifiers
+$SanitizedName = Sanitize-FeatureName -Name $FeatureName
+$FeatureId = Get-FeatureId -CustomId $CustomId
+$BranchName = "$FeatureId-$SanitizedName"
+
+# Create structure
+Create-Directories -BranchName $BranchName
+Copy-Templates -BranchName $BranchName
+Update-Context -FeatureName $FeatureName -FeatureId $FeatureId -BranchName $BranchName
+New-GitBranch -BranchName $BranchName
+
+# Output results
+Write-Host "BRANCH_NAME=$BranchName"
+Write-Host "SPEC_DIR=specs/$BranchName"
+Write-Host "FEATURE_ID=$FeatureId"
+Write-Host "STATUS=initialized"
+
+Write-Log "Successfully initialized feature '$FeatureName' with ID $FeatureId"