specpulse 1.0.6__py3-none-any.whl → 1.1.0__py3-none-any.whl

specpulse/resources/commands/claude/sp-status.md

@@ -0,0 +1,170 @@
+---
+name: sp-status
+description: Track progress across all features and specific feature details
+allowed_tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - TodoWrite
+---
+
+# /sp-status Command
+
+Track progress across all features or get detailed status of a specific feature.
+
+## Usage
+```
+/sp-status [feature-name]
+```
+
+## Implementation
+
+When called with `/sp-status $ARGUMENTS`, I will:
+
+1. **Parse arguments** to determine scope:
+   - If feature name provided: Show detailed status for that feature
+   - Otherwise: Show overview of all features
+
+2. **Read feature context** from `memory/context.md`
+
+3. **For `/sp-status` (all features overview):**
+   - Scan all feature directories (specs/*, plans/*, tasks/*)
+   - Count features by status: active, completed, in_progress, paused
+   - Calculate overall project progress
+   - Show summary statistics:
+     ```
+     TOTAL_FEATURES=5
+     ACTIVE_FEATURES=2
+     COMPLETED_FEATURES=1
+     IN_PROGRESS_FEATURES=1
+     PAUSED_FEATURES=1
+     OVERALL_PROGRESS=42%
+     ```
+   - List all features with their status and progress percentage
+   - Highlight current active feature from context
+
+4. **For `/sp-status [feature-name]` (detailed feature status):**
+   - Detect feature directory (using context detection logic)
+   - Read all task files in the feature's tasks directory
+   - Calculate completion percentage based on task status
+   - Show detailed breakdown:
+     ```
+     FEATURE: 001-user-authentication
+     STATUS: active
+     PROGRESS: 65%
+     SPECS: 2 files
+     PLANS: 1 file  
+     TASKS: 1 file (25 total tasks)
+     COMPLETED_TASKS: 16
+     IN_PROGRESS_TASKS: 5
+     BLOCKED_TASKS: 1
+     LAST_UPDATED: 2025-01-09
+     ```
+   - Show phase-by-phase progress
+   - List any blockers or issues
+   - Provide recommendations for next steps
+
+5. **Progress calculation logic:**
+   - Scan task files for completion status: `[x]` for completed, `[ ]` for pending, `[-]` for in progress, `[!]` for blocked
+   - Calculate percentages: completed / total * 100
+   - Track trends over time if historical data available
+
+## Feature Status Indicators
+
+- **Active**: Currently being worked on (in context.md)
+- **Completed**: All tasks marked as complete
+- **In Progress**: Has task files with some completed tasks
+- **Paused**: No recent activity, not all tasks complete
+- **Blocked**: Has blocked tasks preventing progress
+
+## Examples
+
+### All features overview
+```
+User: /sp-status
+```
+
+I will display:
+```
+## Feature Status Overview
+
+**Total Features**: 5
+**Overall Progress**: 42%
+
+### Active Features
+- [🔄] 001-user-authentication (65%)
+- [🔄] 002-payment-processing (23%)
+
+### Completed Features  
+- [✅] 000-project-setup (100%)
+
+### In Progress Features
+- [⏳] 003-user-profile (45%)
+
+### Paused Features
+- [⏸️] 004-notifications (78%)
+
+### Current Context
+**Active Feature**: 001-user-authentication
+**Last Updated**: 2025-01-09
+```
+
+### Specific feature status
+```
+User: /sp-status user-authentication
+```
+
+I will display:
+```
+## Feature Status: 001-user-authentication
+
+**Overall Progress**: 65%
+**Status**: Active
+**Created**: 2025-01-09
+**Last Updated**: 2025-01-09
+
+### Files
+- **Specifications**: spec-001.md, spec-002.md (2 files)
+- **Plans**: plan-001.md (1 file)
+- **Tasks**: task-001.md (1 file, 25 total tasks)
+
+### Task Progress
+- **Completed**: 16 tasks (64%)
+- **In Progress**: 5 tasks (20%)
+- **Blocked**: 1 task (4%)
+- **Pending**: 3 tasks (12%)
+
+### Phase Progress
+- **Phase 0 (Critical Path)**: 80% complete
+- **Phase 1 (Foundation)**: 70% complete
+- **Phase 2 (Core Features)**: 50% complete
+- **Phase 3 (Polish)**: 20% complete
+- **Phase 4 (Testing)**: 0% complete
+
+### Blockers
+- T015: Database schema approval pending
+
+### Recommendations
+1. Resolve database schema blocker (T015)
+2. Continue with Phase 2 core features
+3. Consider starting Phase 4 testing in parallel
+```
+
+## Integration Features
+
+- **Multi-feature tracking** across entire project
+- **Progress percentage calculation** from task completion
+- **Status categorization** with visual indicators
+- **Blocker identification** and resolution tracking
+- **Context-aware operation** using memory/context.md
+- **Cross-platform compatibility** with proper path handling
+- **Historical trend tracking** for progress over time
+
+## Error Handling
+
+- Feature directory validation
+- Task file parsing with error recovery
+- Progress calculation validation
+- Context file fallback handling
+- Permission and access error handling

specpulse/resources/commands/claude/{task.md → sp-task.md}

@@ -1,5 +1,5 @@
 ---
-name: task
+name: sp-task
 description: Generate and manage task breakdowns using AI-optimized templates
 allowed_tools:
   - Read
@@ -9,50 +9,60 @@ allowed_tools:
   - TodoWrite
 ---
 
-# /task Command
+# /sp-task Command
 
 Generate task breakdowns from implementation plans using SpecPulse methodology with AI-optimized templates and enhanced validation.
 
 ## Usage
 ```
-/task [action] [feature-directory]
+/sp-task [action] [feature-directory]
 ```
 
 Actions: `breakdown`, `update`, `status`, `execute` (defaults to `breakdown`)
 
 ## Implementation
 
-When called with `/task $ARGUMENTS`, I will:
+When called with `/sp-task $ARGUMENTS`, I will:
 
-1. **Parse arguments** to determine action:
+1. **Detect current feature context**:
+   - Read `memory/context.md` for current feature metadata
+   - Use git branch name if available (e.g., `001-user-authentication`)
+   - Fall back to most recently created feature directory
+   - If no context found, ask user to specify feature or run `/sp-pulse` first
+
+2. **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`:**
+3. **For `/sp-task breakdown` or `/sp-task`:**
    
-   a. **Enhanced validation** using cross-platform script:
+   a. **Show existing plan files**: List all plan-XXX.md files in current feature directory
+   b. **Ask user to select**: Which plan file to base tasks on
+   c. **Enhanced validation** using cross-platform script:
       ```bash
       # Cross-platform detection
       if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
-          powershell scripts/pulse-task.ps1 "$FEATURE_DIR"
+          python scripts/sp-pulse-task.py "$FEATURE_DIR"
       else
-          bash scripts/pulse-task.sh "$FEATURE_DIR" || python scripts/pulse-task.py "$FEATURE_DIR"
+          bash scripts/sp-pulse-task.sh "$FEATURE_DIR" || python scripts/sp-pulse-task.py "$FEATURE_DIR"
       fi
       ```
    
-   b. **Read implementation plan** from `plans/XXX-feature/plan.md`
+   d. **Read implementation plan** from selected plan file
    
-   c. **Generate AI-optimized tasks** using template variables:
+   e. **Generate AI-optimized tasks** using template variables:
       ```markdown
       # Task List: {{ feature_name }}
       ## Metadata
       - **Total Tasks**: {{ task_count }}
       - **Estimated Duration**: {{ total_duration }}
+      - **Plan Reference**: plan-{{ plan_version }}.md
+      - **Task Version**: {{ task_version }}
       ```
 
-   d. **Generate structured task categories**:
+   f. **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
@@ -60,7 +70,7 @@ When called with `/task $ARGUMENTS`, I will:
       - **Execution Schedule**: Time-based task organization
       - **Progress Tracking**: YAML configuration for monitoring
 
-   e. **For each task**, generate comprehensive metadata:
+   g. **For each task**, generate comprehensive metadata:
       - **ID**: T[XXX] format (T001, T002)
       - **Type**: setup, development, testing, documentation
       - **Priority**: HIGH, MEDIUM, LOW
@@ -72,63 +82,73 @@ When called with `/task $ARGUMENTS`, I will:
       - **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
+   h. **Generate AI execution guidelines** with workflow integration:
+      ```markdown
+      ## AI Execution Strategy
+      ### Parallel Tasks (can be worked on simultaneously):
+      - T001, T002, T003: Independent tasks, no dependencies
+      ### Sequential Tasks (must be completed in order):
+      - T004 → T005 → T006: Dependency chain
       ```
 
-   g. **Write comprehensive task breakdown** to `tasks/XXX-feature/tasks.md`
+   i. **Version management**: Check existing task files and create next version (task-001.md, task-002.md, etc.)
+   j. **Write comprehensive task breakdown** to `tasks/XXX-feature/task-XXX.md`
 
-3. **For `/task update`:**
-   - **Enhanced analysis** using cross-platform script:
+4. **For `/sp-task update`:**
+   a. **Show existing task files**: List all task-XXX.md files in current feature directory
+   b. **Ask user to select**: Which task file to update
+   c. **Enhanced analysis** using cross-platform script:
      ```bash
      # Cross-platform detection
      if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
-         powershell scripts/pulse-task.ps1 "$FEATURE_DIR"
+         python scripts/sp-pulse-task.py "$FEATURE_DIR"
      else
-         bash scripts/pulse-task.sh "$FEATURE_DIR" || python scripts/pulse-task.py "$FEATURE_DIR"
+         bash scripts/sp-pulse-task.sh "$FEATURE_DIR" || python scripts/sp-pulse-task.py "$FEATURE_DIR"
      fi
      ```
-   - **Parse current tasks** with comprehensive status:
+   d. **Parse current tasks** from selected file with comprehensive status:
      - Total tasks, completed, pending, blocked
      - Parallel tasks identification
      - Constitutional gates status
      - Completion percentage calculation
-   - **Interactive task updates**:
+   e. **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
+   f. **Generate updated progress tracking** YAML
 
-4. **For `/task status`:**
-   - **Enhanced reporting** from script output:
+5. **For `/sp-task status`:**
+   a. **Show existing task files**: List all task-XXX.md files in current feature directory
+   b. **Ask user to select**: Which task file to show status for
+   c. **Enhanced reporting** from script output:
      ```bash
      TOTAL_TASKS=25
      COMPLETED_TASKS=10
      COMPLETION_PERCENTAGE=40%
      CONSTITUTIONAL_GATES_PENDING=2
      ```
-   - **Display comprehensive progress**:
+   d. **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"
+6. **For `/sp-task execute`:**
+   a. **Show existing task files**: List all task-XXX.md files in current feature directory
+   b. **Ask user to select**: Which task file to execute from
+   c. **Ask user to specify**: Which specific task ID to execute
+   d. **Validate task readiness** using constitutional gates
+   e. **Execute task** using AI assistant capabilities:
+     ```markdown
+     ## Task Execution: {{ TASK_ID }}
+     **AI Assistant**: Claude/Gemini
+     **Method**: Direct implementation within AI session
+     **Status**: [ ] Pending → [-] In Progress → [x] Completed
      ```
-   - **Track execution results** and update status
-   - **Update progress tracking** automatically
+   f. **Track execution results** and update status
+   g. **Update progress tracking** automatically
 
 ## Enhanced Task Format
 ```markdown
@@ -170,16 +190,16 @@ Each task breakdown includes constitutional compliance validation:
 
 ### Generate task breakdown
 ```
-User: /task breakdown
+User: /sp-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"
+      python scripts/sp-pulse-task.py "$FEATURE_DIR"
   else
-      bash scripts/pulse-task.sh "$FEATURE_DIR" || python scripts/pulse-task.py "$FEATURE_DIR"
+      bash scripts/sp-pulse-task.sh "$FEATURE_DIR" || python scripts/sp-pulse-task.py "$FEATURE_DIR"
   fi
   ```
 - Create: AI-optimized task structure with template variables
@@ -187,19 +207,19 @@ I will:
 
 ### Update task status
 ```
-User: /task update mark T001-T005 as completed
+User: /sp-task update mark T001-T005 as completed
 ```
 I will update task status and recalculate progress metrics.
 
 ### Show comprehensive status
 ```
-User: /task status
+User: /sp-task status
 ```
 I will display detailed progress with constitutional gates compliance.
 
 ### Execute specific task
 ```
-User: /task execute T001
+User: /sp-task execute T001
 ```
 I will:
 - Validate: Constitutional gates compliance and task readiness
@@ -207,16 +227,16 @@ I will:
   ```bash
   # Cross-platform task execution
   if [[ "$OSTYPE" == "msys" || "$OSTYPE" == "win32" ]]; then
-      powershell scripts/pulse-task.ps1 "$FEATURE_DIR" "execute:$TASK_ID"
+      python scripts/sp-pulse-task.py "$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"
+      bash scripts/sp-pulse-task.sh "$FEATURE_DIR" "execute:$TASK_ID" || python scripts/sp-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)
+- **Cross-platform script execution** with automatic detection (Bash/Python)
 - **AI-optimized templates** with Jinja2-style variables
 - **Enhanced script integration** for validation and execution
 - **Constitutional gates compliance** tracking

specpulse/resources/commands/gemini/sp-continue.toml

@@ -0,0 +1,56 @@
+description = "Switch context and continue work on a specific feature"
+prompt = """
+Handle the /sp-continue command with arguments: {{args}}
+
+Parse arguments to extract feature name or ID
+
+## Feature Detection:
+1. Find feature directory using context detection:
+   - Search for matching feature directory (specs/*, plans/*, tasks/*)
+   - Support partial matching (e.g., "auth" matches "001-user-authentication")
+   - Support ID matching (e.g., "001" matches "001-user-authentication")
+
+2. Validate feature exists:
+   - Check if feature directory has any files
+   - Verify feature structure is intact
+   - Report if feature not found
+
+3. Update context in memory/context.md:
+   - Switch current feature to selected feature
+   - Update timestamp and switch reason
+   - Preserve previous context data
+
+4. Switch git branch if in git repository:
+   - Checkout feature branch if it exists
+   - Report if branch doesn't exist
+   - Handle branch switching errors gracefully
+
+5. Display feature status:
+   - Show current progress percentage
+   - List next available actions
+   - Highlight any blockers or issues
+   - Show recent activity
+
+6. Suggest next steps based on feature state:
+   - If no spec files: /sp-spec <description>
+   - If spec but no plan: /sp-plan
+   - If plan but no tasks: /sp-task
+   - If tasks exist: Show task completion status and suggest next task
+
+## Supported Feature Identification:
+- By name: /sp-continue user-authentication
+- By ID: /sp-continue 001
+- By partial match: /sp-continue auth
+
+## Context Switching:
+1. Save previous context state
+2. Load new feature context
+3. Update memory/context.md
+4. Switch git branch if available
+5. Display feature status and next steps
+
+Examples:
+- /sp-continue user-authentication
+- /sp-continue 001
+- /sp-continue auth
+"""

specpulse/resources/commands/gemini/sp-plan.toml

@@ -0,0 +1,68 @@
+description = "Generate or validate implementation plans with versioning"
+prompt = """
+Handle the /sp-plan command with arguments: {{args}}
+
+First, detect current feature context:
+- Read memory/context.md for current feature metadata
+- Use git branch name if available (e.g., 001-user-authentication)
+- Fall back to most recently created feature directory
+- If no context found, ask user to specify feature or run /sp-pulse first
+
+Parse arguments to determine action:
+- If "validate": Check plan against constitution
+- Otherwise: Generate new plan
+
+## For /sp-plan generate or /sp-plan:
+1. Show list of existing spec files in current feature directory
+2. Ask user which spec file to base plan on
+3. Read selected specification from @{specs/*/spec-XXX.md}
+
+4. Run Phase Gates checks:
+   - Constitutional compliance
+   - Simplicity check (≤3 modules)
+   - Test-first strategy defined
+   - Framework selection complete
+   - Research completed
+
+5. Generate plan sections:
+   - Technology stack
+   - Architecture overview
+   - Implementation phases
+   - API contracts
+   - Data models
+   - Testing strategy
+
+6. Track complexity:
+   - If >3 modules, document justification
+   - Create simplification roadmap
+
+7. Check existing plan files and create next version (plan-001.md, plan-002.md, etc.)
+8. Write plan to plans/XXX-feature/plan-XXX.md
+9. Run cross-platform validation:
+   - Linux/macOS: !{bash scripts/sp-pulse-plan.sh "XXX-feature"}
+   - Fallback: !{python scripts/sp-pulse-plan.py "XXX-feature"}
+
+## For /sp-plan validate:
+1. Show list of existing plan files in current feature directory
+2. Ask user which plan file to validate
+3. Read selected plan from @{plans/*/plan-XXX.md}
+4. Run cross-platform validation:
+   - Linux/macOS: !{bash scripts/sp-pulse-plan.sh "XXX-feature"}
+   - Fallback: !{python scripts/sp-pulse-plan.py "XXX-feature"}
+5. Verify Phase Gates compliance
+6. Check complexity tracking
+7. Ensure test-first approach
+8. Validate framework choices
+9. 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:
+- /sp-plan generate
+- /sp-plan validate
+"""

specpulse/resources/commands/gemini/{pulse.toml → sp-pulse.toml}

@@ -6,9 +6,8 @@ Please follow these steps:
 
 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}"}
+   - Linux/macOS: !{bash scripts/sp-pulse-init.sh "{{args}}"}  
+   - Fallback: !{python scripts/sp-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/
@@ -16,12 +15,19 @@ Please follow these steps:
    - Update memory/context.md with current feature
    - Create git branch if in git repository
 
-4. Report the results showing:
+4. Suggest specification options:
+   - Generate 2-3 different specification suggestions based on the feature name
+   - Present options to user as numbered choices
+   - Ask user to choose one or provide their own specification description
+   - Guide user to use /sp-spec command after making selection
+
+5. Report the results showing:
    - Created structure paths
    - Feature ID and branch name
-   - Next steps for the user
+   - Specification suggestions for user to choose from
+   - Next steps guidance
 
 If no feature name is provided, ask the user for the feature name first.
 
-Example usage: /pulse user-authentication
+Example usage: /sp-pulse user-authentication
 """

specpulse/resources/commands/gemini/sp-spec.toml

@@ -0,0 +1,54 @@
+description = "Create or manage feature specifications with versioning"
+prompt = """
+Handle the /sp-spec command with arguments: {{args}}
+
+First, detect current feature context:
+- Read memory/context.md for current feature metadata
+- Use git branch name if available (e.g., 001-user-authentication)
+- Fall back to most recently created feature directory
+- If no context found, ask user to specify feature or run /sp-pulse first
+
+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
+
+## For /sp-spec create [description] or /sp-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 from detected context
+5. Check existing spec files and create next version (spec-001.md, spec-002.md, etc.)
+6. Write specification to specs/XXX-feature/spec-XXX.md
+7. Run cross-platform validation:
+   - Linux/macOS: !{bash scripts/sp-pulse-spec.sh "XXX-feature"}
+   - Fallback: !{python scripts/sp-pulse-spec.py "XXX-feature"}
+
+## For /sp-spec update:
+1. Show list of existing spec files in current feature directory
+2. Ask user which spec file to update
+3. Read selected specification file
+4. Ask user for clarifications or changes
+5. Update content while preserving structure
+6. Remove resolved [NEEDS CLARIFICATION] markers
+
+## For /sp-spec validate:
+1. Show list of existing spec files in current feature directory
+2. Ask user which spec file to validate
+3. Run cross-platform validation:
+   - Linux/macOS: !{bash scripts/sp-pulse-spec.sh "XXX-feature"}
+   - Fallback: !{python scripts/sp-pulse-spec.py "XXX-feature"}
+4. Check all required sections are filled
+5. Count [NEEDS CLARIFICATION] markers
+6. Verify acceptance criteria are testable
+7. Report validation results
+
+Examples:
+- /sp-spec user authentication with OAuth2 and email/password
+- /sp-spec update
+- /sp-spec validate
+"""