specpulse 1.3.4__py3-none-any.whl → 1.4.1__py3-none-any.whl

specpulse/__init__.py

@@ -3,7 +3,7 @@ SpecPulse: Specification-Driven Development Framework
 Built for the AI era
 """
 
-__version__ = "1.3.3"
+__version__ = "1.4.1"
 __author__ = "SpecPulse"
 __url__ = "https://github.com/specpulse"
 

specpulse/core/specpulse.py

@@ -294,14 +294,14 @@ indexes:
 - Performance Benchmarks
 - Security Scenarios
 
-## Constitution Compliance
+## SDD Compliance
 
 ### Principle Validation
-- [ ] Single Responsibility: Each component has one purpose
-- [ ] Test-First: Tests written before implementation
-- [ ] Documentation: All code is documented
-- [ ] Security: Security considered by design
-- [ ] Performance: Meets performance targets
+- [ ] Specification First: Requirements clearly defined
+- [ ] Incremental Planning: Phased approach planned
+- [ ] Task Decomposition: Broken into executable tasks
+- [ ] Quality Assurance: Appropriate testing strategy
+- [ ] Architecture Documentation: Decisions recorded
 
 ## Risk Assessment
 
@@ -317,7 +317,7 @@ indexes:
 
 ## Success Criteria
 - [ ] All functional requirements implemented
-- [ ] Test coverage > 80%
+- [ ] Appropriate test coverage for project type
 - [ ] Performance targets met
 - [ ] Security audit passed
 - [ ] Documentation complete
@@ -419,79 +419,9 @@ metrics:
         if template_path.exists():
             with open(template_path, 'r', encoding='utf-8') as f:
                 return f.read()
-        # Fallback to embedded template if file not found
-        return """# Project Constitution
-
-## Immutable Principles
-
-### Principle 1: Simplicity First
-Every solution must start with the simplest approach that could work.
-Complexity is added only when proven necessary.
-
-### Principle 2: Test-Driven Development
-No production code without tests.
-Tests are written first, implementation follows.
-
-### Principle 3: Single Responsibility
-Each module, function, and component does one thing well.
-If you need "and" to describe it, split it.
-
-### Principle 4: Documentation as Code
-Documentation lives with code.
-If it's not documented, it doesn't exist.
-
-### Principle 5: Security by Design
-Security is not an afterthought.
-Every feature considers security implications from the start.
-
-## Technical Standards
-
-### Code Style
-- Python: PEP 8 with type hints
-- JavaScript: StandardJS
-- Go: Official Go formatting
-
-### Testing Requirements
-- Minimum 80% code coverage
-- All API endpoints must have contract tests
-- Critical paths require E2E tests
-
-### Performance Targets
-- API response time: < 200ms (p95)
-- Page load time: < 2 seconds
-- Database queries: < 50ms
-
-### Security Requirements
-- All data encrypted in transit (TLS 1.3+)
-- Sensitive data encrypted at rest
-- Authentication: OAuth 2.0 / JWT
-- Authorization: RBAC with least privilege
-
-## Architecture Rules
-
-### Service Boundaries
-- Services communicate only through defined APIs
-- No shared databases between services
-- Each service owns its data
-
-### Data Management
-- Single source of truth for each data type
-- Event sourcing for audit requirements
-- CQRS where read/write patterns differ
-
-### Error Handling
-- All errors are handled explicitly
-- User-facing errors are helpful and actionable
-- System errors are logged with context
-
-## Amendment Process
-
-Changes to this constitution require:
-1. Documented rationale
-2. Team consensus
-3. Gradual migration plan
-4. Update to all affected documentation
-"""
+        # Fallback - return empty if template not found
+        # Templates should always be loaded from resources/memory/constitution.md
+        return ""
     
     def get_context_template(self) -> str:
         """Get context template from file"""
@@ -915,20 +845,24 @@ Validates specifications, plans, or project.
 4. Plan approved → Use `/sp-task breakdown`
 5. Before implementation → Use `/validate all`
 
-## Constitution Rules
+## SDD Principles
 
-Always enforce these principles:
-1. Simplicity first
-2. Test-driven development
-3. Single responsibility
-4. Documentation as code
-5. Security by design
+Follow these universal principles:
+1. Specification First
+2. Incremental Planning
+3. Task Decomposition
+4. Traceable Implementation
+5. Continuous Validation
+6. Quality Assurance
+7. Architecture Documentation
+8. Iterative Refinement
+9. Stakeholder Alignment
 
 ## Context Management
 
 - Read `memory/context.md` for project state
 - Update context after major decisions
-- Check `memory/constitution.md` for principles
+- Check `memory/constitution.md` for SDD principles
 - Reference previous specs for consistency
 
 ## Templates

specpulse/core/validator.py

@@ -32,8 +32,8 @@ class Validator:
         # Validate plans
         self._validate_plans(project_path, fix, verbose)
         
-        # Validate constitution compliance
-        self._validate_constitution_compliance(project_path, verbose)
+        # Validate SDD principles compliance
+        self._validate_sdd_compliance(project_path, verbose)
         
         return self.results
     
@@ -101,10 +101,10 @@ class Validator:
         
         return self.results
     
-    def validate_constitution(self, project_path: Path, verbose: bool = False) -> List[Dict]:
-        """Validate constitution compliance"""
+    def validate_sdd_compliance(self, project_path: Path, verbose: bool = False) -> List[Dict]:
+        """Validate SDD principles compliance"""
         self.results = []
-        self._validate_constitution_compliance(project_path, verbose)
+        self._validate_sdd_compliance(project_path, verbose)
         return self.results
     
     def _validate_structure(self, project_path: Path):
@@ -283,27 +283,31 @@ class Validator:
                     "message": "No implementation plans found"
                 })
     
-    def _validate_constitution_compliance(self, project_path: Path, verbose: bool):
-        """Validate compliance with constitution principles"""
+    def _validate_sdd_compliance(self, project_path: Path, verbose: bool):
+        """Validate compliance with SDD principles"""
         constitution_path = project_path / "memory" / "constitution.md"
         
         if not constitution_path.exists():
             self.results.append({
                 "status": "error",
-                "message": "Constitution file not found"
+                "message": "SDD principles file (constitution.md) not found"
             })
             return
         
         with open(constitution_path, 'r', encoding='utf-8') as f:
             constitution = f.read()
         
-        # Check for key principles
+        # Check for key SDD principles
         principles = [
-            "Simplicity First",
-            "Test-Driven Development",
-            "Single Responsibility",
-            "Documentation as Code",
-            "Security by Design"
+            "Specification First",
+            "Incremental Planning",
+            "Task Decomposition",
+            "Traceable Implementation",
+            "Continuous Validation",
+            "Quality Assurance",
+            "Architecture Documentation",
+            "Iterative Refinement",
+            "Stakeholder Alignment"
         ]
         
         for principle in principles:
@@ -311,12 +315,12 @@ class Validator:
                 if verbose:
                     self.results.append({
                         "status": "success",
-                        "message": f"Constitution includes: {principle}"
+                        "message": f"SDD principle found: {principle}"
                     })
             else:
                 self.results.append({
                     "status": "warning",
-                    "message": f"Constitution missing principle: {principle}"
+                    "message": f"Missing SDD principle: {principle}"
                 })
         
         # Check config for constitution enforcement
@@ -325,15 +329,15 @@ class Validator:
             with open(config_path, 'r', encoding='utf-8') as f:
                 config = yaml.safe_load(f)
             
-            if config.get("constitution", {}).get("enforce", False):
+            if config.get("sdd", {}).get("enforce", True):
                 self.results.append({
                     "status": "success",
-                    "message": "Constitution enforcement enabled"
+                    "message": "SDD principles enforcement enabled"
                 })
             else:
                 self.results.append({
                     "status": "warning",
-                    "message": "Constitution enforcement disabled"
+                    "message": "SDD principles enforcement disabled"
                 })
     
     def _load_constitution(self, project_root: Path):
@@ -362,7 +366,7 @@ class Validator:
         self._load_constitution(project_root)
         return self.constitution is not None
     
-    def validate_spec(self, spec_path: Path, verbose: bool = False) -> Dict:
+    def validate_spec_file(self, spec_path: Path, verbose: bool = False) -> Dict:
         """Validate a single specification file"""
         if not spec_path.exists():
             return {"status": "error", "message": f"Spec file not found: {spec_path}"}
@@ -381,7 +385,7 @@ class Validator:
         
         return result
     
-    def validate_plan(self, plan_path: Path, verbose: bool = False) -> Dict:
+    def validate_plan_file(self, plan_path: Path, verbose: bool = False) -> Dict:
         """Validate a single plan file"""
         if not plan_path.exists():
             return {"status": "error", "message": f"Plan file not found: {plan_path}"}
@@ -400,7 +404,7 @@ class Validator:
         
         return result
     
-    def validate_task(self, task_path: Path, verbose: bool = False) -> Dict:
+    def validate_task_file(self, task_path: Path, verbose: bool = False) -> Dict:
         """Validate a single task file"""
         if not task_path.exists():
             return {"status": "error", "message": f"Task file not found: {task_path}"}
@@ -417,16 +421,16 @@ class Validator:
         
         return result
     
-    def validate_constitution_compliance(self, spec_content: str, verbose: bool = False) -> Dict:
-        """Validate that content complies with constitution"""
+    def validate_sdd_principles(self, spec_content: str, verbose: bool = False) -> Dict:
+        """Validate that content complies with SDD principles"""
         result = {"status": "compliant", "violations": []}
         
         if not self.constitution:
             return result
         
-        # Check for simplicity principle
-        if 'complexity' in spec_content.lower() and 'simple' not in spec_content.lower():
-            result["violations"].append("Simplicity principle: Complex solution without justification")
+        # Check for specification clarity
+        if '[needs clarification]' in spec_content.lower():
+            result["violations"].append("Specification First: Contains unresolved clarifications")
         
         if result["violations"]:
             result["status"] = "non-compliant"
@@ -435,9 +439,9 @@ class Validator:
     
     def check_phase_gate(self, gate_name: str, context: Dict) -> bool:
         """Check if a phase gate passes"""
-        # Simple gate checking logic
-        if gate_name == "simplicity":
-            return context.get("module_count", 0) <= 3
+        # Gate checking logic
+        if gate_name == "specification":
+            return context.get("spec_complete", False)
         elif gate_name == "test-first":
             return context.get("tests_written", False)
         return True
@@ -448,26 +452,26 @@ class Validator:
             "specs": [],
             "plans": [],
             "tasks": [],
-            "constitution_compliance": True
+            "sdd_compliance": True
         }
         
         # Validate specs
         specs_dir = project_root / "specs"
         if specs_dir.exists():
             for spec_file in specs_dir.glob("*/spec*.md"):
-                results["specs"].append(self.validate_spec(spec_file, verbose))
+                results["specs"].append(self.validate_spec_file(spec_file, verbose))
         
         # Validate plans
         plans_dir = project_root / "plans"
         if plans_dir.exists():
             for plan_file in plans_dir.glob("*/plan*.md"):
-                results["plans"].append(self.validate_plan(plan_file, verbose))
+                results["plans"].append(self.validate_plan_file(plan_file, verbose))
         
         # Validate tasks
         tasks_dir = project_root / "tasks"
         if tasks_dir.exists():
             for task_file in tasks_dir.glob("*/task*.md"):
-                results["tasks"].append(self.validate_task(task_file, verbose))
+                results["tasks"].append(self.validate_task_file(task_file, verbose))
         
         return results
     

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

@@ -108,8 +108,8 @@ When called with `/sp-decompose $ARGUMENTS`, I will:
    - Check for circular dependencies
    - Verify data consistency boundaries
    - Ensure single responsibility principle
-   - Validate against constitutional principles:
-     - Simplicity (≤3 modules per service)
+   - Validate against SDD principles:
+     - Clear service boundaries
      - Clear boundaries
      - Testability
 
@@ -180,28 +180,28 @@ specs/001-authentication/decomposition/
 └── migration-plan.md         # Decomposition strategy
 ```
 
-## Constitutional Compliance
+## SDD Compliance
 
-**Article I: Simplicity**
-- Each service limited to 3 core modules
-- Clear, focused responsibilities
-- Minimal inter-service dependencies
+**Principle 1: Specification First**
+- Each service has clear specifications
+- Service boundaries well-defined
+- Requirements traced to services
 
-**Article V: Single Responsibility**
-- Services own their data
-- Clear aggregate boundaries
-- Independent deployment capability
+**Principle 3: Task Decomposition**
+- Services broken into manageable tasks
+- Clear service-specific work items
+- Integration tasks identified
 
-**Article VIII: Framework Selection**
-- Choose appropriate tech stack per service
-- Leverage existing libraries
-- Standardize communication protocols
+**Principle 7: Architecture Documentation**
+- Service boundaries documented
+- Technology choices recorded
+- Integration patterns defined
 
 ## Integration with SpecPulse Workflow
 
 1. **After `/sp-spec create`**: 
    - AI analyzes spec complexity
-   - Suggests decomposition if >3 modules detected
+   - Suggests decomposition if complexity warrants it
    - User confirms with `/sp-decompose`
 
 2. **During decomposition**:
@@ -223,7 +223,7 @@ specs/001-authentication/decomposition/
 5. **With `/sp-validate`**: 
    - Validates service boundaries
    - Checks circular dependencies
-   - Ensures constitutional compliance
+   - Ensures SDD compliance
 
 ## Error Handling
 

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

@@ -11,7 +11,7 @@ allowed_tools:
 
 # /sp-plan Command
 
-Generate implementation plans from specifications following SpecPulse methodology with constitutional compliance and AI-optimized templates.
+Generate implementation plans from specifications following SpecPulse methodology with SDD compliance and AI-optimized templates.
 
 ## CRITICAL: File Edit Restrictions
 - **NEVER EDIT**: templates/, scripts/, commands/, .claude/, .gemini/
@@ -36,7 +36,7 @@ When called with `/sp-plan $ARGUMENTS`, I will:
    - If no context found, ask user to specify feature or run `/sp-pulse` first
 
 2. **Parse arguments** and determine action:
-   - If `validate`: Check plan against constitutional gates
+   - If `validate`: Check plan against SDD gates
    - If `optimize`: Improve existing plan complexity
    - Otherwise: Generate new plan
 
@@ -57,12 +57,12 @@ When called with `/sp-plan $ARGUMENTS`, I will:
       bash scripts/sp-pulse-plan.sh "$FEATURE_DIR"
       ```
 
-   e. **Run Constitutional Phase Gates** (Article VII):
-      - Simplicity Gate: ≤3 modules justification
-      - Anti-Abstraction Gate: Direct framework usage
-      - Test-First Gate: Tests before implementation
-      - Integration-First Gate: Real services over mocks
-      - Research Gate: Technology choices documented
+   e. **Run SDD Compliance Gates**:
+      - Specification First: Requirements clear and traced
+      - Incremental Planning: Phased approach defined
+      - Task Decomposition: Clear breakdown planned
+      - Quality Assurance: Testing strategy defined
+      - Architecture Documentation: Decisions recorded
 
    f. **Generate AI-optimized plan** by COPYING template from templates/plan.md to plans/XXX-feature/:
       ```markdown
@@ -91,10 +91,10 @@ When called with `/sp-plan $ARGUMENTS`, I will:
         * Security considerations
         * Deployment strategy with rollback plans
 
-   h. **Complexity tracking** (Article VII):
-      - Document all complexity exceptions with justifications
-      - Create mitigation strategies for each exception
-      - Track optimization opportunities
+   h. **Architecture documentation**:
+      - Document all architectural decisions with rationale
+      - Create improvement strategies for technical debt
+      - Track future enhancement opportunities
 
    i. **Version management**: Check existing plan files and create next version (plan-001.md, plan-002.md, etc.)
    j. **Write NEW plan file** to `plans/XXX-feature/plan-XXX.md`
@@ -107,8 +107,8 @@ When called with `/sp-plan $ARGUMENTS`, I will:
      ```bash
      bash scripts/sp-pulse-plan.sh "$FEATURE_DIR"
      ```
-   d. Verify all constitutional gates are addressed
-   e. Check complexity exceptions have proper justifications
+   d. Verify all SDD gates are addressed
+   e. Check architectural decisions have proper documentation
    f. Validate test-first approach is documented
    g. Ensure integration strategy uses real services
    h. Report detailed validation results
@@ -124,38 +124,38 @@ When called with `/sp-plan $ARGUMENTS`, I will:
    e. **Generate optimization recommendations**
    f. **Create new version**: Write optimized plan as next version (plan-XXX.md)
 
-## Constitutional Phase Gates (Phase -1)
+## SDD Compliance Gates (Phase -1)
 
 **Must pass before implementation:**
 
-### Article VII: Simplicity Gate
-- [ ] Using ≤3 projects/modules for initial implementation
-- [ ] No future-proofing without documented need
-- [ ] Direct framework usage (no unnecessary wrappers)
-- [ ] Single model representation per concept
-
-### Article VII: Anti-Abstraction Gate  
-- [ ] Using framework features directly
-- [ ] No unnecessary abstraction layers
-- [ ] Clear, simple interfaces
-- [ ] Avoiding premature optimization
-
-### Article III: Test-First Gate
-- [ ] Test specifications written
-- [ ] Tests reviewed and approved
-- [ ] Tests confirmed to FAIL before implementation
-- [ ] TDD cycle planned (Red-Green-Refactor)
-
-### Article VIII: Integration-First Gate
-- [ ] Contract tests defined
-- [ ] Using real services over mocks
-- [ ] Production-like test environment planned
-- [ ] End-to-end test scenarios identified
-
-### Article VI: Research Gate
-- [ ] Library options researched
-- [ ] Performance implications documented
-- [ ] Security considerations analyzed
+### Principle 1: Specification First
+- [ ] Clear requirements documented
+- [ ] User stories with acceptance criteria
+- [ ] [NEEDS CLARIFICATION] markers used
+- [ ] Functional and non-functional requirements
+
+### Principle 2: Incremental Planning
+- [ ] Work broken into valuable phases
+- [ ] Each phase delivers working software
+- [ ] Milestones and checkpoints defined
+- [ ] Features prioritized by business value
+
+### Principle 3: Task Decomposition
+- [ ] Tasks are specific and actionable
+- [ ] Effort estimates provided
+- [ ] Definition of Done clear
+- [ ] Dependencies identified
+
+### Principle 6: Quality Assurance
+- [ ] Testing strategy appropriate for project
+- [ ] Acceptance criteria testable
+- [ ] Code review process defined
+- [ ] Quality metrics identified
+
+### Principle 7: Architecture Documentation
+- [ ] Technology choices documented
+- [ ] Integration points identified
+- [ ] Technical debt tracked
 - [ ] Trade-offs documented
 
 ## Examples
@@ -184,7 +184,7 @@ User: /sp-plan validate
 I will run comprehensive validation:
 ```
 PLAN_FILE=plans/001-user-authentication/plan.md
-CONSTITUTIONAL_GATES_STATUS=COMPLETED
+SDD_GATES_STATUS=COMPLETED
 MISSING_SECTIONS=0
 STATUS=validation_complete
 ```
@@ -199,8 +199,8 @@ I will analyze and recommend complexity reductions.
 
 - **AI-optimized templates** with Jinja2-style variables
 - **Script execution** with Bash
-- **Constitutional compliance tracking** with gate status
-- **Complexity exception management** with justifications
+- **SDD compliance tracking** with gate status
+- **Architecture decision tracking** with rationale
 - **Performance and security considerations** integrated
 - **Integration-first approach** with real service usage
 - **Detailed validation reporting** with specific recommendations
@@ -209,7 +209,7 @@ I will analyze and recommend complexity reductions.
 ## Error Handling
 
 - Specification existence validation
-- Constitutional gate compliance checking
+- SDD gate compliance checking
 - Template structure validation
 - Directory structure verification
 - Feature context auto-discovery

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

@@ -11,7 +11,7 @@ allowed_tools:
 
 # /sp-pulse Command
 
-Initialize a new feature following SpecPulse methodology with constitutional compliance.
+Initialize a new feature following SpecPulse methodology with SDD compliance.
 
 ## CRITICAL SECURITY NOTE
 **NEVER edit files in these protected directories:**
@@ -53,17 +53,17 @@ When called with `/sp-pulse $ARGUMENTS`, I will:
 
 5. **Validate structure** and report comprehensive status
 
-## Constitutional Compliance
+## SDD Compliance
 
-**Article I: Simplicity**
+**Principle 1: Specification First**
 - [ ] Feature name is clear and specific
-- [ ] No unnecessary abstractions in initial structure
-- [ ] Single responsibility per feature
+- [ ] Ready for requirements documentation
+- [ ] Structure supports specifications
 
-**Article II: Anti-Abstraction**  
-- [ ] Direct template usage (no wrapper layers)
-- [ ] Minimal initial structure
-- [ ] Framework-ready files
+**Principle 2: Incremental Planning**
+- [ ] Initial structure supports phased development
+- [ ] Templates ready for iterative work
+- [ ] Supports any project type
 
 ## Example
 ```
@@ -100,7 +100,7 @@ The `/sp-pulse` command creates the feature structure and then guides you throug
 1. **Phase -1**: **MANUAL** - Use `/sp-spec` to create specification with AI assistance
 2. **Phase 0**: **MANUAL** - Use `/sp-plan` to generate implementation plan  
 3. **Phase 1**: **MANUAL** - Use `/sp-task` to create task breakdown
-4. **Implementation**: Begin development following constitutional principles
+4. **Implementation**: Begin development following SDD principles
 
 ## Context Detection
 

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

@@ -85,7 +85,7 @@ When called with `/sp-spec $ARGUMENTS`, I will:
      ```
    - Count `[NEEDS CLARIFICATION]` markers
    - Verify acceptance criteria follow Given-When-Then format
-   - Check constitutional compliance indicators
+   - Check SDD compliance indicators
    - Report detailed validation results
 
 6. **For `/sp-spec clarify`:**
@@ -105,7 +105,7 @@ User: /sp-spec create user authentication system with OAuth2 and JWT tokens
 ```
 I will create a comprehensive specification using AI-optimized templates with:
 - Jinja2-style variables for AI processing
-- Constitutional compliance sections
+- SDD compliance sections
 - Testable acceptance criteria
 - Automated validation
 
@@ -137,23 +137,28 @@ I will systematically address all [NEEDS CLARIFICATION] markers.
 
 The AI-optimized specification template includes:
 - **Metadata**: Template variables for AI processing
-- **Constitutional Gates**: Pre-implementation validation
+- **SDD Gates**: Pre-implementation validation
 - **Functional Requirements**: Structured Must/Should/Could/Won't
 - **User Stories**: Given-When-Then acceptance criteria
 - **Validation Checklist**: Automated completeness checks
 - **Integration Points**: AI command workflow guidance
 
-## Constitutional Compliance
+## SDD Compliance
 
-**Article III: Test-First**
-- [ ] Acceptance criteria written before implementation
-- [ ] Test scenarios clearly defined
-- [ ] Integration points identified
+**Principle 1: Specification First**
+- [ ] Requirements clearly documented
+- [ ] Acceptance criteria defined
+- [ ] User stories included
+
+**Principle 6: Quality Assurance**
+- [ ] Test scenarios defined
+- [ ] Acceptance criteria testable
+- [ ] Quality metrics specified
 
-**Article VI: Research**
+**Principle 7: Architecture Documentation**
 - [ ] Technology choices documented
+- [ ] Integration points identified
 - [ ] Security considerations addressed
-- [ ] Performance requirements specified
 
 ## Enhanced Error Handling