specpulse 1.4.0__py3-none-any.whl → 1.4.2__py3-none-any.whl

specpulse/resources/templates/task.md

@@ -1,165 +1,220 @@
-<!-- SpecPulse Task List Template v3.0 - AI-Optimized -->
-<!-- AI Instructions: Generate from implementation plan using SDD gates -->
-
-# Task List: {{ feature_name }}
-
-## Metadata
-- **Plan Reference**: SPEC-{{ feature_id }}
-- **Total Tasks**: {{ task_count }}
-- **Estimated Duration**: {{ total_duration }}
-- **Parallel Groups**: {{ parallel_groups }}
-
-## Task Organization
-
-{% for group in parallel_groups %}
-### Parallel Group {{ loop.index }}
-*These tasks can be executed simultaneously*
-
-{% for task in group.tasks %}
-#### {{ task.id }}: {{ task.name }}
-- **Type**: {{ task.type }}
-- **Priority**: {{ task.priority }}
-- **Estimate**: {{ task.estimate }}
-- **Dependencies**: {{ task.dependencies | join(", ") | default("None") }}
-- **Description**: {{ task.description }}
-- **Acceptance**: {{ task.acceptance }}
-- **Files**: {{ task.files | join(", ") }}
-- **Assignable**: {{ task.assignable }}
-{% endfor %}
-{% endfor %}
-
-### Sequential Tasks
-*These tasks must be completed in order*
-
-{% for task in sequential_tasks %}
-#### {{ task.id }}: {{ task.name }}
-- **Dependencies**: {{ task.dependencies | join(", ") }}
-- **Type**: {{ task.type }}
-- **Priority**: {{ task.priority }}
-- **Estimate**: {{ task.estimate }}
-- **Description**: {{ task.description }}
-- **Acceptance**: {{ task.acceptance }}
-{% endfor %}
-
-### Critical Path
-*Tasks that directly impact timeline*
-
-{% for path in critical_path %}
-{{ loop.index }}. {{ path.tasks | join(" -> ") }}
-{% endfor %}
-- Estimated critical path duration: {{ critical_path_duration }}
-
-## SDD Gates Compliance
-
-### Pre-Implementation Validation
-{% for gate in SDD_gates %}
-#### {{ gate.name }}
-- [ ] {{ gate.check_1 }}
-- [ ] {{ gate.check_2 }}
-- [ ] {{ gate.check_3 }}
-- [ ] {{ gate.check_4 }}
-**Status**: {{ gate.status | default("PENDING") }}
-{% endfor %}
-
-## Task Details by Category
-
-{% for category in task_categories %}
-### {{ category.name }} Tasks {% if category.parallel %}[P]{% endif %}
-{% for task in category.tasks %}
-- [ ] {{ task.id }}: {{ task.name }}
-{% endfor %}
-{% endfor %}
-
-## Execution Schedule
-
-{% for phase in execution_schedule %}
-### {{ phase.name }}
-{% for time_block in phase.time_blocks %}
-- {{ time_block.timing }}: {{ time_block.tasks | join(", ") }}{% if time_block.parallel %} (parallel){% endif %}
-{% endfor %}
-{% endfor %}
+# Task Breakdown: {{feature_name}}
+
+## Feature Overview
+- **Feature ID**: {{feature_id}}
+- **Specification**: SPEC-{{spec_id}}
+- **Plan**: PLAN-{{plan_id}}
+- **Created**: {{date}}
+
+## Task Summary
+Total Tasks: {{total_tasks}}
+Estimated Effort: {{estimated_effort}}
+Priority: {{priority}}
+
+## Task Status Legend
+- [ ] Pending
+- [>] In Progress
+- [x] Completed
+- [!] Blocked
+
+## Phase 0: Foundation Tasks
+
+### T001: Project Setup
+**Complexity**: Simple
+**Estimate**: 1 hour
+**Status**: [ ] Pending
+
+**Description**: Initialize project structure and configuration
+**Acceptance Criteria**:
+- [ ] Project scaffolding created
+- [ ] Configuration files in place
+- [ ] Build system configured
+
+**Technical Notes**:
+- Use standard project template
+- Ensure all paths are relative
 
-## Progress Tracking
-```yaml
-status:
-  total: {{ task_count }}
-  completed: 0
-  in_progress: 0
-  blocked: 0
-  
-metrics:
-  velocity: {{ velocity | default("2-3 tasks/day") }}
-  estimated_completion: {{ estimated_completion }}
-  blockers: []
-  
-parallel_groups:
-{% for group in parallel_groups %}
-  - name: "{{ group.name }}"
-    tasks: [{{ group.tasks | map(attribute='id') | join(", ") }}]
-    can_start: {{ group.can_start }}
-{% endfor %}
-
-sequential_tasks:
-{% for task in sequential_tasks %}
-  - name: "{{ task.name }}"
-    id: {{ task.id }}
-    dependencies: [{{ task.dependencies | join(", ") }}]
-{% endfor %}
-```
+---
+
+### T002: Development Environment
+**Complexity**: Simple
+**Estimate**: 2 hours
+**Status**: [ ] Pending
+
+**Description**: Set up development environment and dependencies
+**Acceptance Criteria**:
+- [ ] All dependencies installed
+- [ ] Environment variables configured
+- [ ] Development server runs successfully
+
+**Technical Notes**:
+- Document any special setup requirements
+- Create setup script if needed
+
+---
+
+## Phase 1: Core Implementation Tasks
+
+### T003: Data Models
+**Complexity**: Medium
+**Estimate**: 4 hours
+**Status**: [ ] Pending
+
+**Description**: Create data models and database schema
+**Acceptance Criteria**:
+- [ ] Models defined with proper types
+- [ ] Relationships established
+- [ ] Migrations created and tested
+
+**Technical Notes**:
+- Follow existing naming conventions
+- Add appropriate indexes
+
+---
+
+### T004: Business Logic
+**Complexity**: Complex
+**Estimate**: 8 hours
+**Status**: [ ] Pending
+
+**Description**: Implement core business logic
+**Acceptance Criteria**:
+- [ ] All business rules implemented
+- [ ] Edge cases handled
+- [ ] Unit tests written and passing
+
+**Technical Notes**:
+- Ensure proper error handling
+- Follow SOLID principles
+
+---
+
+### T005: API Endpoints
+**Complexity**: Medium
+**Estimate**: 6 hours
+**Status**: [ ] Pending
+
+**Description**: Create API endpoints for feature
+**Acceptance Criteria**:
+- [ ] All endpoints implemented
+- [ ] Request/response validation
+- [ ] API documentation updated
+
+**Technical Notes**:
+- Follow RESTful conventions
+- Implement proper status codes
+
+---
+
+## Phase 2: Enhancement Tasks
+
+### T006: Error Handling
+**Complexity**: Medium
+**Estimate**: 3 hours
+**Status**: [ ] Pending
+
+**Description**: Implement comprehensive error handling
+**Acceptance Criteria**:
+- [ ] All errors caught and logged
+- [ ] User-friendly error messages
+- [ ] Error recovery mechanisms
 
-## Task Execution Guidelines
-
-### AI-Assisted Development Process
-All task execution should be handled by AI assistants (Claude or Gemini) following the SpecPulse methodology:
-
-1. **Task Selection**: AI assistants should select tasks based on:
-   - Dependency order (sequential tasks first)
-   - Parallel execution opportunities
-   - Current context and feature priorities
-   - Resource availability
-
-2. **Implementation Process**: For each task:
-   ```markdown
-   ## Task: {{ task.id }} - {{ task.name }}
-   
-   **Status**: [ ] Pending / [x] Completed / [-] In Progress / [!] Blocked
-   **Dependencies**: {{ task.dependencies | join(", ") | default("None") }}
-   **Acceptance**: {{ task.acceptance }}
-   ```
-
-3. **Parallel Execution Strategy**: When tasks can be executed in parallel:
-   - AI assistants should work on multiple tasks simultaneously
-   - Coordinate task completion status
-   - Handle cross-task dependencies
-   - Maintain code consistency
-
-### Task Dependencies Management
-
-- **Sequential Dependencies**: Tasks must be completed in specific order
-- **Parallel Opportunities**: Independent tasks can be worked on simultaneously
-- **Dependency Resolution**: AI should resolve conflicts and blocking issues
-- **Progress Coordination**: Multiple AI assistants should coordinate task completion
-
-## AI Integration Notes
-
-### SDD Gates
-- All tasks MUST pass SDD compliance before implementation
-- Use `/sp-validate` command to check compliance status
-- Mark gates as completed only after actual validation
-
-### Progress Tracking
-- Update task status in real-time using markdown checkboxes: `[ ]` → `[-]` → `[x]`
-- Document blockers immediately with `[!]` status and resolution notes
-- Use velocity metrics to refine future estimates
-- Coordinate with other AI assistants for parallel task execution
-
-### Quality Assurance
-- Each task requires specific acceptance criteria
-- Testing strategy based on Principle 6: Quality Assurance
-- Appropriate tests for your project type
+**Technical Notes**:
+- Use centralized error handling
+- Log errors with context
 
 ---
-**Generated by**: {{ ai_assistant }} on {{ date }}
-**Feature**: {{ feature_name }}
-**SDD Gates**: {{ SDD_status | default("PENDING VALIDATION") }}
-**Next Steps**: Execute tasks following SDD order
+
+### T007: Performance Optimization
+**Complexity**: Medium
+**Estimate**: 4 hours
+**Status**: [ ] Pending
+
+**Description**: Optimize performance bottlenecks
+**Acceptance Criteria**:
+- [ ] Database queries optimized
+- [ ] Caching implemented where needed
+- [ ] Load testing completed
+
+**Technical Notes**:
+- Profile before optimizing
+- Document optimization decisions
+
+---
+
+## Phase 3: Testing & Documentation
+
+### T008: Integration Testing
+**Complexity**: Medium
+**Estimate**: 4 hours
+**Status**: [ ] Pending
+
+**Description**: Write and run integration tests
+**Acceptance Criteria**:
+- [ ] All happy paths tested
+- [ ] Error scenarios tested
+- [ ] Tests automated in CI/CD
+
+**Technical Notes**:
+- Use existing test framework
+- Mock external dependencies
+
+---
+
+### T009: Documentation
+**Complexity**: Simple
+**Estimate**: 2 hours
+**Status**: [ ] Pending
+
+**Description**: Complete feature documentation
+**Acceptance Criteria**:
+- [ ] API documentation complete
+- [ ] User guide written
+- [ ] Code comments added
+
+**Technical Notes**:
+- Follow documentation standards
+- Include examples
+
+---
+
+### T010: Deployment
+**Complexity**: Simple
+**Estimate**: 2 hours
+**Status**: [ ] Pending
+
+**Description**: Deploy feature to production
+**Acceptance Criteria**:
+- [ ] Deployed successfully
+- [ ] Monitoring configured
+- [ ] Rollback plan tested
+
+**Technical Notes**:
+- Follow deployment checklist
+- Verify in staging first
+
+---
+
+## Dependencies
+- T003 depends on T001 and T002
+- T004 depends on T003
+- T005 depends on T004
+- T006-T007 can be done in parallel after T005
+- T008 depends on all implementation tasks
+- T009 can be done in parallel with testing
+- T010 depends on all other tasks
+
+## Progress Tracking
+```
+[##########----------] 50% Complete
+Completed: 5/10
+In Progress: 1/10
+Pending: 4/10
+Blocked: 0/10
+```
+
+## Notes
+<!-- Additional task notes -->
+- Review with team before starting
+- Update estimates based on actual effort
+- Log any blockers immediately

specpulse/utils/console.py

@@ -131,9 +131,17 @@ class Console:
     
     def spinner(self, message: str):
         """Show a loading spinner"""
-        # Simplified version for Windows compatibility
+        # Return a context manager for compatibility
+        class SpinnerContext:
+            def __enter__(self):
+                return self
+            def __exit__(self, *args):
+                pass
+            def update(self, message):
+                pass
+
         self.console.print(f"[bold cyan]{message}...[/bold cyan]")
-        return None
+        return SpinnerContext()
     
     def animated_text(self, text: str, delay: float = 0.03):
         """Print text with typewriter effect"""
@@ -216,6 +224,42 @@ class Console:
             box=box.DOUBLE
         )
         self.console.print(panel)
+
+    def type_effect(self, text: str, delay: float = 0.05):
+        """Display text with typing effect"""
+        for char in text:
+            self.console.print(char, end="")
+            import time
+            time.sleep(delay)
+        self.console.print()
+
+    def interactive_menu(self, title: str, options: List[str]) -> int:
+        """Display interactive menu and get user choice"""
+        self.header(title)
+        for i, option in enumerate(options, 1):
+            self.console.print(f"[bright_yellow]{i}.[/bright_yellow] {option}")
+
+        while True:
+            try:
+                choice = int(input("\nSelect option: "))
+                if 1 <= choice <= len(options):
+                    return choice - 1
+            except (ValueError, KeyboardInterrupt):
+                pass
+            self.error("Invalid choice. Please try again.")
+
+    def animation_wave(self, text: str = "Processing", duration: float = 2.0):
+        """Display wave animation"""
+        import time
+        frames = ["⚪⚫⚫⚫", "⚫⚪⚫⚫", "⚫⚫⚪⚫", "⚫⚫⚫⚪", "⚫⚫⚪⚫", "⚫⚪⚫⚫"]
+        start_time = time.time()
+        i = 0
+
+        with self.console.status(f"[bold green]{text}...", spinner="dots") as status:
+            while time.time() - start_time < duration:
+                status.update(f"[bold green]{text}... {frames[i % len(frames)]}")
+                time.sleep(0.2)
+                i += 1
     
     def validation_results(self, results: Dict[str, bool]):
         """Display validation results with visual indicators"""
@@ -305,17 +349,21 @@ class Console:
     def gradient_text(self, text: str, colors: List[str] = None):
         """Print text with gradient colors"""
         if not colors:
-            colors = ["bright_red", "bright_yellow", "bright_green", 
+            colors = ["bright_red", "bright_yellow", "bright_green",
                      "bright_cyan", "bright_blue", "bright_magenta"]
-        
+
         words = text.split()
         colored_words = []
-        
+
         for i, word in enumerate(words):
             color = colors[i % len(colors)]
             colored_words.append(f"[{color}]{word}[/{color}]")
-        
+
         self.console.print(" ".join(colored_words))
+
+    def tree_structure(self, data: Dict[str, Any], title: str = "Project Structure"):
+        """Display tree structure - alias for tree method"""
+        return self.tree(title, data)
     
     def celebration(self):
         """Show celebration animation"""

specpulse/utils/git_utils.py

@@ -29,10 +29,24 @@ class GitUtils:
         except FileNotFoundError:
             return False, "Git is not installed or not in PATH"
     
-    def check_git_installed(self) -> bool:
+    @staticmethod
+    def check_git_installed() -> bool:
+        """Check if git is installed (static method)"""
+        try:
+            result = subprocess.run(
+                ["git", "--version"],
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            return True
+        except (subprocess.CalledProcessError, FileNotFoundError):
+            return False
+
+    @staticmethod
+    def is_git_installed() -> bool:
         """Check if git is installed"""
-        success, _ = self._run_git_command("--version")
-        return success
+        return GitUtils.check_git_installed()
     
     def is_git_repo(self, path: Optional[Path] = None) -> bool:
         """Check if directory is a git repository"""
@@ -175,4 +189,33 @@ class GitUtils:
         success, output = self._run_git_command("tag", "-l")
         if success:
             return output.split('\n') if output else []
-        return []
+        return []
+
+    # Additional methods for test compatibility
+    def is_repo(self) -> bool:
+        """Check if current directory is a git repository"""
+        return (self.repo_path / ".git").exists()
+
+    def add_all_files(self) -> bool:
+        """Add all files to staging area"""
+        return self.add_files()
+
+    def get_commits(self, limit: int = 10) -> List[str]:
+        """Get recent commits"""
+        return self.get_log(limit)
+
+    def stash(self) -> bool:
+        """Stash current changes"""
+        success, _ = self._run_git_command("stash")
+        return success
+
+    def stash_pop(self) -> bool:
+        """Pop stashed changes"""
+        success, _ = self._run_git_command("stash", "pop")
+        return success
+
+    def merge(self, branch: str) -> bool:
+        """Merge branch into current branch"""
+        success, _ = self._run_git_command("merge", branch)
+        return success
+

specpulse/utils/version_check.py

@@ -78,11 +78,24 @@ def get_update_message(current: str, latest: str, is_major: bool) -> str:
     Returns:
         Formatted update message
     """
+    # Determine update type
+    curr_parts = current.split('.')
+    latest_parts = latest.split('.')
+
+    update_type = "patch"
+    if len(curr_parts) >= 2 and len(latest_parts) >= 2:
+        if curr_parts[0] != latest_parts[0]:
+            update_type = "major"
+        elif curr_parts[1] != latest_parts[1]:
+            update_type = "minor"
+        else:
+            update_type = "patch"
+
     if is_major:
-        urgency = "[!] MAJOR"
+        urgency = f"[!] MAJOR ({update_type} update)"
         color = "bright_red"
     else:
-        urgency = "[i]"
+        urgency = f"[i] {update_type.upper()}"
         color = "yellow"
 
     message = f"""

{specpulse-1.4.0.dist-info → specpulse-1.4.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: specpulse
-Version: 1.4.0
+Version: 1.4.2
 Summary: Specification-Driven Development Framework
 Home-page: https://github.com/specpulse
 Author: SpecPulse
@@ -67,13 +67,22 @@ Dynamic: requires-python
 
 SpecPulse is a universal **Specification-Driven Development (SDD)** framework that works with ANY software project - web apps, mobile apps, desktop software, games, APIs, ML projects, and more. It ensures every feature starts with clear specifications, validated plans, and tracked tasks.
 
-> **Latest Update (v1.4.0)** - Complete Framework Revolution:
+> **Latest Update (v1.4.2)** - Template System Enhancement:
+> - 📁 **Physical Template Files**: Templates now exist as physical files for AI tools to read
+> - 🔧 **Complete PowerShell Support**: Added PowerShell scripts matching all Bash functionality
+> - 📝 **Enhanced Decomposition Templates**: Full microservice decomposition template support
+>
+> **v1.4.1** - Bug Fix Release:
+> - 🐛 **Fixed Version Display**: Corrected `--version` command showing old version
+>
+> **v1.4.0** - Complete Framework Revolution:
 > - 🚀 **Universal SDD Framework**: Transformed from Constitutional to Specification-Driven Development
 > - 🎯 **No Technology Restrictions**: Support for ANY technology stack - web, mobile, desktop, games, ML
-> - 🧪 **86% Test Coverage**: Complete test suite rewrite with 98.3% success rate
+> - 🧪 **Comprehensive Testing**: Full test suite with extensive coverage
 > - ✨ **9 Universal Principles**: Flexible principles replacing rigid articles
 > - 🔄 **Major API Updates**: All methods renamed from `constitution` to `sdd_compliance`
 > - 📝 **Enhanced Documentation**: Complete overhaul of docs and templates
+> - 🏗️ **Hybrid Template System**: Templates exist as both files and embedded code
 
 ### Why SpecPulse?
 
@@ -276,10 +285,11 @@ Stop guessing what users want:
 Claude and Gemini use slash commands that accept arguments via `$ARGUMENTS`:
 
 **Script Execution:**
-- **All Platforms**: Bash (.sh) scripts only
-- **Requirements**: Bash shell required (Git Bash on Windows, native on Linux/macOS)
+- **Cross-Platform Scripts**: Bash (.sh) and PowerShell (.ps1) scripts included
+- **Requirements**: Bash shell (Git Bash on Windows) or PowerShell
 - **Universal Compatibility**: Works whether installed via PyPI or source code
 - **Unicode Support**: Full international character support (≤, ≥, →, ←)
+- **Template System**: Templates exist as physical files in `resources/templates/` for AI tools to read
 
 ```bash
 /sp-pulse user-authentication     # Start new feature with name
@@ -301,14 +311,15 @@ Claude and Gemini use slash commands that accept arguments via `$ARGUMENTS`:
 - Commands capture arguments using `$ARGUMENTS` variable
 - **Shell scripts** in `resources/scripts/` folder process the arguments:
   - `sp-pulse-*.sh` - Bash scripts (all platforms)
-- AI reads templates from `resources/templates/` folder
+  - `sp-pulse-*.ps1` - PowerShell scripts (Windows native)
+- Templates are **physical files** in `resources/templates/` and also embedded in code
 - Results are saved in `specs/`, `plans/`, `tasks/` folders
 - Memory system tracks progress in `memory/` folder
 
 **🔒 Important Security Rules:**
 - **Protected Directories** (Read-Only after init):
-  - `templates/` - Original template files
-  - `scripts/` - Shell scripts
+  - `templates/` - Generated template files (created on init)
+  - `scripts/` - Shell and PowerShell scripts
   - `commands/` - AI command definitions
   - `.claude/` and `.gemini/` - AI configurations
 - **Editable Directories**:
@@ -316,7 +327,7 @@ Claude and Gemini use slash commands that accept arguments via `$ARGUMENTS`:
   - `plans/` - Implementation plans (AI creates/edits here)
   - `tasks/` - Task breakdowns (AI creates/edits here)
   - `memory/` - Project context and decisions
-- **Workflow**: Templates are COPIED to working directories, never modified directly
+- **Workflow**: Templates are used as references, content is generated in working directories
 
 **Claude vs Gemini:**
 - **Claude**: Uses Markdown command files (`.claude/commands/*.md`) with YAML frontmatter
@@ -466,12 +477,20 @@ my-project/
 │       ├── auth-service-tasks.md
 │       ├── user-service-tasks.md
 │       └── integration-tasks.md
-├── templates/           # Customizable templates
-├── scripts/             # Shell scripts for AI execution
-│   ├── sp-pulse-init.sh    # Feature initialization
-│   ├── sp-pulse-spec.sh    # Specification creation
-│   ├── sp-pulse-plan.sh    # Plan generation
-│   └── sp-pulse-task.sh    # Task breakdown
+├── templates/           # Generated templates (created on init)
+├── scripts/             # Cross-platform scripts for AI execution
+│   ├── sp-pulse-init.sh     # Feature initialization (Bash)
+│   ├── sp-pulse-init.ps1    # Feature initialization (PowerShell)
+│   ├── sp-pulse-spec.sh     # Specification creation (Bash)
+│   ├── sp-pulse-spec.ps1    # Specification creation (PowerShell)
+│   ├── sp-pulse-plan.sh     # Plan generation (Bash)
+│   ├── sp-pulse-plan.ps1    # Plan generation (PowerShell)
+│   ├── sp-pulse-task.sh     # Task breakdown (Bash)
+│   ├── sp-pulse-task.ps1    # Task breakdown (PowerShell)
+│   ├── sp-pulse-decompose.sh  # Microservice decomposition (Bash)
+│   ├── sp-pulse-decompose.ps1 # Microservice decomposition (PowerShell)
+│   ├── sp-pulse-execute.sh    # Continuous task execution (Bash)
+│   └── sp-pulse-execute.ps1   # Continuous task execution (PowerShell)
 └── PULSE.md            # Project manifest
 ```
 
@@ -621,8 +640,8 @@ MIT License - see [LICENSE](LICENSE) file for details.
 ## 🚦 Project Status
 
 [![Build Status](https://img.shields.io/badge/build-passing-brightgreen)](https://github.com/specpulse/specpulse)
-[![Coverage](https://img.shields.io/badge/coverage-100%25-brightgreen)](https://github.com/specpulse/specpulse)
-[![Tests](https://img.shields.io/badge/tests-37%2B%20passed-brightgreen)](https://github.com/specpulse/specpulse)
+[![Coverage](https://img.shields.io/badge/coverage-improving-yellow)](https://github.com/specpulse/specpulse)
+[![Tests](https://img.shields.io/badge/tests-core%20passing-brightgreen)](https://github.com/specpulse/specpulse)
 [![Maintainability](https://img.shields.io/badge/maintainability-A-brightgreen)](https://github.com/specpulse/specpulse)
 
 ---