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

specpulse/resources/scripts/pulse-plan.ps1

@@ -0,0 +1,251 @@
+# SpecPulse Plan Generation Script
+# Cross-platform PowerShell equivalent of pulse-plan.sh
+
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$FeatureDir,
+    
+    [string]$PlanContent = ""
+)
+
+$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-FeatureDir {
+    param([string]$Dir)
+    
+    if ([string]::IsNullOrWhiteSpace($Dir)) {
+        Exit-WithError "Feature directory cannot be empty"
+    }
+    
+    # Remove non-alphanumeric characters except hyphens and underscores
+    $Sanitized = $Dir -replace '[^a-zA-Z0-9_-]', ''
+    
+    if ([string]::IsNullOrWhiteSpace($Sanitized)) {
+        Exit-WithError "Invalid feature directory: '$Dir'"
+    }
+    
+    return $Sanitized
+}
+
+function Find-FeatureDirectory {
+    if (-not (Test-Path $ContextFile)) {
+        Exit-WithError "No context file found and no feature directory provided"
+    }
+    
+    try {
+        $Content = Get-Content $ContextFile -Raw -Encoding UTF8
+        # Look for "Active Feature" section
+        if ($Content -match 'Active Feature:\s*(.+)') {
+            $FeatureDir = $matches[1].Trim()
+            Write-Log "Using active feature from context: $FeatureDir"
+            return $FeatureDir
+        } else {
+            Exit-WithError "No active feature found in context file"
+        }
+    } catch {
+        Exit-WithError "Failed to read context file: $_"
+    }
+}
+
+function Get-CurrentFeatureDir {
+    param([string]$ProvidedDir)
+    
+    if ($ProvidedDir) {
+        return Sanitize-FeatureDir -Dir $ProvidedDir
+    } else {
+        return Find-FeatureDirectory
+    }
+}
+
+function Validate-PlanStructure {
+    param([string]$PlanFile)
+    
+    if (-not (Test-Path $PlanFile)) {
+        Exit-WithError "Plan file does not exist: $PlanFile"
+    }
+    
+    # Required sections
+    $RequiredSections = @(
+        "# Implementation Plan:",
+        "## Technology Stack",
+        "## Architecture Overview",
+        "## Implementation Phases"
+    )
+    
+    $Content = Get-Content $PlanFile -Raw -Encoding UTF8
+    $MissingSections = @()
+    
+    foreach ($Section in $RequiredSections) {
+        if ($Content -notmatch [regex]::Escape($Section)) {
+            $MissingSections += $Section
+        }
+    }
+    
+    if ($MissingSections.Count -gt 0) {
+        Write-Log "WARNING: Missing required sections: $($MissingSections -join ', ')"
+    }
+    
+    return $MissingSections.Count
+}
+
+function Check-ConstitutionalGates {
+    param([string]$PlanFile)
+    
+    if (-not (Test-Path $PlanFile)) {
+        Exit-WithError "Plan file does not exist: $PlanFile"
+    }
+    
+    $Content = Get-Content $PlanFile -Raw -Encoding UTF8
+    $GatesStatus = @{}
+    
+    # Check for constitutional gates compliance
+    $Gates = @{
+        "Simplicity Gate" = "Article VII: Simplicity Gate"
+        "Anti-Abstraction Gate" = "Article VII: Anti-Abstraction Gate"
+        "Test-First Gate" = "Article III: Test-First Gate"
+        "Integration-First Gate" = "Article VIII: Integration-First Gate"
+        "Research Gate" = "Article VI: Research Gate"
+    }
+    
+    foreach ($Gate in $Gates.GetEnumerator()) {
+        if ($Content -match $Gate.Value) {
+            $GatesStatus[$Gate.Key] = "COMPLETED"
+        } else {
+            $GatesStatus[$Gate.Key] = "PENDING"
+        }
+    }
+    
+    return $GatesStatus
+}
+
+function Analyze-Complexity {
+    param([string]$PlanFile)
+    
+    if (-not (Test-Path $PlanFile)) {
+        Exit-WithError "Plan file does not exist: $PlanFile"
+    }
+    
+    $Content = Get-Content $PlanFile -Raw -Encoding UTF8
+    
+    # Count complexity exceptions
+    $ExceptionMatches = [regex]::Matches($Content, "Complexity Exception")
+    $ExceptionCount = $ExceptionMatches.Count
+    
+    # Check for complexity tracking
+    $HasComplexityTracking = $Content -match "Complexity Tracking"
+    
+    # Count modules/projects mentioned
+    $ModuleMatches = [regex]::Matches($Content, "(?i)(module|project)s?\s*[:\-]?\s*\d+")
+    $ModuleCount = 0
+    if ($ModuleMatches.Count -gt 0) {
+        foreach ($Match in $ModuleMatches) {
+            if ($Match.Value -match "\d+") {
+                $ModuleCount = [int]$matches[0]
+                break
+            }
+        }
+    }
+    
+    return @{
+        ExceptionCount = $ExceptionCount
+        HasComplexityTracking = $HasComplexityTracking
+        ModuleCount = $ModuleCount
+    }
+}
+
+# Main execution
+Write-Log "Processing plan..."
+
+# Get and sanitize feature directory
+$SanitizedDir = Get-CurrentFeatureDir -ProvidedDir $FeatureDir
+
+# Set file paths
+$PlanFile = Join-Path $ProjectRoot "plans" $SanitizedDir "plan.md"
+$SpecFile = Join-Path $ProjectRoot "specs" $SanitizedDir "spec.md"
+$TemplateFile = Join-Path $TemplatesDir "plan.md"
+
+# Ensure plans directory exists
+$PlanDir = Split-Path $PlanFile -Parent
+New-Item -ItemType Directory -Path $PlanDir -Force | Out-Null
+
+# Handle plan content
+if ($PlanContent) {
+    Write-Log "Updating plan file: $PlanFile"
+    try {
+        Set-Content -Path $PlanFile -Value $PlanContent -Encoding UTF8
+    } catch {
+        Exit-WithError "Failed to write plan content: $_"
+    }
+} else {
+    # Ensure plan file exists from template
+    if (-not (Test-Path $PlanFile)) {
+        if (-not (Test-Path $TemplateFile)) {
+            Exit-WithError "Template not found: $TemplateFile"
+        }
+        
+        Write-Log "Creating plan file from template: $PlanFile"
+        try {
+            Copy-Item $TemplateFile $PlanFile -Force
+        } catch {
+            Exit-WithError "Failed to copy plan template: $_"
+        }
+    } else {
+        Write-Log "Plan file already exists: $PlanFile"
+    }
+}
+
+# Validate plan structure
+Write-Log "Validating plan structure..."
+$MissingSections = Validate-PlanStructure -PlanFile $PlanFile
+
+# Check constitutional gates
+Write-Log "Checking constitutional gates..."
+$GatesStatus = Check-ConstitutionalGates -PlanFile $PlanFile
+
+# Analyze complexity
+Write-Log "Analyzing complexity..."
+$ComplexityAnalysis = Analyze-Complexity -PlanFile $PlanFile
+
+# Count completed constitutional gates
+$CompletedGates = 0
+foreach ($Status in $GatesStatus.Values) {
+    if ($Status -eq "COMPLETED") {
+        $CompletedGates++
+    }
+}
+
+# Check if specification exists
+$SpecExists = Test-Path $SpecFile
+
+Write-Log "Plan processing completed successfully"
+
+# Output results
+Write-Host "PLAN_FILE=$PlanFile"
+Write-Host "SPEC_EXISTS=$SpecExists"
+Write-Host "MISSING_SECTIONS=$MissingSections"
+Write-Host "COMPLETED_GATES=$CompletedGates"
+Write-Host "TOTAL_GATES=$($GatesStatus.Count)"
+Write-Host "COMPLEXITY_EXCEPTIONS=$($ComplexityAnalysis.ExceptionCount)"
+Write-Host "HAS_COMPLEXITY_TRACKING=$($ComplexityAnalysis.HasComplexityTracking)"
+Write-Host "MODULE_COUNT=$($ComplexityAnalysis.ModuleCount)"
+Write-Host "STATUS=processed"

specpulse/resources/scripts/pulse-plan.py

@@ -0,0 +1,191 @@
+#!/usr/bin/env python3
+"""
+SpecPulse Plan Generation Script
+Cross-platform Python equivalent of pulse-plan.sh
+"""
+
+import os
+import sys
+import re
+from pathlib import Path
+import datetime
+
+class SpecPulsePlan:
+    def __init__(self):
+        self.script_name = Path(__file__).name
+        self.project_root = Path(__file__).parent.parent.parent
+        self.memory_dir = self.project_root / "memory"
+        self.context_file = self.memory_dir / "context.md"
+        self.templates_dir = self.project_root / "resources" / "templates"
+        
+    def log(self, message):
+        """Log messages with timestamp"""
+        timestamp = datetime.datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+        try:
+            print(f"[{timestamp}] {self.script_name}: {message}", file=sys.stderr)
+        except UnicodeEncodeError:
+            # Fallback for Windows console encoding issues
+            message = message.encode('cp1252', errors='replace').decode('cp1252')
+            print(f"[{timestamp}] {self.script_name}: {message}", file=sys.stderr)
+        
+    def error_exit(self, message):
+        """Exit with error message"""
+        self.log(f"ERROR: {message}")
+        sys.exit(1)
+        
+    def sanitize_feature_dir(self, feature_dir):
+        """Sanitize feature directory name"""
+        if not feature_dir:
+            self.error_exit("Feature directory cannot be empty")
+            
+        sanitized = re.sub(r'[^a-zA-Z0-9_-]', '', feature_dir)
+        
+        if not sanitized:
+            self.error_exit(f"Invalid feature directory: '{feature_dir}'")
+            
+        return sanitized
+        
+    def find_feature_directory(self):
+        """Find feature directory from context file"""
+        if not self.context_file.exists():
+            self.error_exit("No context file found and no feature directory provided")
+            
+        try:
+            content = self.context_file.read_text(encoding='utf-8')
+            match = re.search(r'Active Feature:\s*(.+)', content)
+            if match:
+                feature_dir = match.group(1).strip()
+                self.log(f"Using active feature from context: {feature_dir}")
+                return feature_dir
+            else:
+                self.error_exit("No active feature found in context file")
+        except Exception as e:
+            self.error_exit(f"Failed to read context file: {e}")
+            
+    def get_current_feature_dir(self, provided_dir):
+        """Get current feature directory"""
+        if provided_dir:
+            return self.sanitize_feature_dir(provided_dir)
+        else:
+            return self.find_feature_directory()
+            
+    def validate_plan_structure(self, plan_file):
+        """Validate plan structure"""
+        required_sections = [
+            "## Implementation Plan:",
+            "## Specification Reference",
+            "## Phase -1: Pre-Implementation Gates",
+            "## Implementation Phases"
+        ]
+        
+        missing_sections = []
+        content = plan_file.read_text(encoding='utf-8')
+        
+        for section in required_sections:
+            if section not in content:
+                missing_sections.append(section)
+                
+        if missing_sections:
+            self.log(f"WARNING: Missing required sections: {', '.join(missing_sections)}")
+            
+        return len(missing_sections)
+        
+    def check_constitutional_gates(self, plan_file):
+        """Check constitutional gates"""
+        constitutional_gates = [
+            "Simplicity Gate",
+            "Anti-Abstraction Gate", 
+            "Test-First Gate",
+            "Integration-First Gate",
+            "Research Gate"
+        ]
+        
+        missing_gates = []
+        content = plan_file.read_text(encoding='utf-8')
+        
+        for gate in constitutional_gates:
+            if gate not in content:
+                missing_gates.append(gate)
+                
+        if missing_gates:
+            self.log(f"WARNING: Missing constitutional gates: {', '.join(missing_gates)}")
+            
+        # Check gate status
+        gate_status_match = re.search(r'Gate Status:\s*\[([^\]]+)\]', content)
+        if gate_status_match:
+            gate_status = gate_status_match.group(1)
+            if gate_status.upper() != "COMPLETED":
+                self.log(f"WARNING: Constitutional gates not completed. Status: {gate_status}")
+                return gate_status
+        else:
+            self.log("WARNING: Constitutional gates status not found")
+            return "UNKNOWN"
+            
+        return "COMPLETED"
+        
+    def main(self, args):
+        """Main execution function"""
+        if len(args) < 1:
+            self.error_exit("Usage: python pulse-plan.py <feature-dir>")
+            
+        feature_dir = args[0]
+        
+        self.log("Processing implementation plan...")
+        
+        # Get and sanitize feature directory
+        sanitized_dir = self.get_current_feature_dir(feature_dir)
+        
+        # Set file paths
+        plan_file = self.project_root / "plans" / sanitized_dir / "plan.md"
+        template_file = self.templates_dir / "plan.md"
+        spec_file = self.project_root / "specs" / sanitized_dir / "spec.md"
+        
+        # Ensure plans directory exists
+        plan_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Check if specification exists first
+        if not spec_file.exists():
+            self.error_exit(f"Specification file not found: {spec_file}. Please create specification first.")
+            
+        # Ensure plan template exists
+        if not template_file.exists():
+            self.error_exit(f"Template not found: {template_file}")
+            
+        # Create plan if it doesn't exist
+        if not plan_file.exists():
+            self.log(f"Creating implementation plan from template: {plan_file}")
+            try:
+                plan_file.write_text(template_file.read_text(encoding='utf-8'))
+            except Exception as e:
+                self.error_exit(f"Failed to copy plan template: {e}")
+        else:
+            self.log(f"Implementation plan already exists: {plan_file}")
+            
+        # Validate plan structure
+        self.log("Validating implementation plan...")
+        missing_sections = self.validate_plan_structure(plan_file)
+        
+        # Check Constitutional Gates
+        self.log("Checking Constitutional Gates...")
+        gate_status = self.check_constitutional_gates(plan_file)
+        
+        # Check if specification has clarifications needed
+        if spec_file.exists():
+            spec_content = spec_file.read_text(encoding='utf-8')
+            clarification_matches = re.findall(r'NEEDS CLARIFICATION', spec_content)
+            if clarification_matches:
+                clarification_count = len(clarification_matches)
+                self.log(f"WARNING: Specification has {clarification_count} clarifications needed - resolve before proceeding")
+        
+        self.log("Implementation plan processing completed successfully")
+        
+        # Output results
+        print(f"PLAN_FILE={plan_file}")
+        print(f"SPEC_FILE={spec_file}")
+        print(f"MISSING_SECTIONS={missing_sections}")
+        print(f"CONSTITUTIONAL_GATES_STATUS={gate_status}")
+        print("STATUS=ready")
+
+if __name__ == "__main__":
+    plan = SpecPulsePlan()
+    plan.main(sys.argv[1:])

specpulse/resources/scripts/pulse-plan.sh

@@ -1,26 +1,127 @@
 #!/bin/bash
 # Generate implementation plan
 
-FEATURE_DIR="${1}"
+set -euo pipefail  # Exit on error, unset vars, pipe failures
 
+# Configuration
+SCRIPT_NAME="$(basename "$0")"
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
+
+# Function to log messages
+log() {
+    echo "[$(date '+%Y-%m-%d %H:%M:%S')] $SCRIPT_NAME: $1" >&2
+}
+
+# Function to handle errors
+error_exit() {
+    log "ERROR: $1"
+    exit 1
+}
+
+# Validate arguments
+if [ $# -eq 0 ]; then
+    error_exit "Usage: $SCRIPT_NAME <feature-dir>"
+fi
+
+FEATURE_DIR="$1"
+
+# Sanitize feature directory
+SANITIZED_DIR=$(echo "$FEATURE_DIR" | sed 's/[^a-zA-Z0-9_-]//g')
+
+if [ -z "$SANITIZED_DIR" ]; then
+    error_exit "Invalid feature directory: '$FEATURE_DIR'"
+fi
+
+# Find feature directory if not provided
 if [ -z "$FEATURE_DIR" ]; then
-    # Find current feature from context
-    FEATURE_DIR=$(grep -A1 "Active Feature" memory/context.md | tail -1 | cut -d: -f2 | xargs)
+    CONTEXT_FILE="$PROJECT_ROOT/memory/context.md"
+    if [ -f "$CONTEXT_FILE" ]; then
+        FEATURE_DIR=$(grep -A1 "Active Feature" "$CONTEXT_FILE" | tail -1 | cut -d: -f2 | xargs)
+        if [ -z "$FEATURE_DIR" ]; then
+            error_exit "No active feature found in context file"
+        fi
+        log "Using active feature from context: $FEATURE_DIR"
+    else
+        error_exit "No feature directory provided and no context file found"
+    fi
 fi
 
-PLAN_FILE="plans/${FEATURE_DIR}/plan.md"
+PLAN_FILE="$PROJECT_ROOT/plans/${FEATURE_DIR}/plan.md"
+TEMPLATE_FILE="$PROJECT_ROOT/templates/plan.md"
+SPEC_FILE="$PROJECT_ROOT/specs/${FEATURE_DIR}/spec.md"
+
+# Ensure plans directory exists
+mkdir -p "$(dirname "$PLAN_FILE")"
+
+# Check if specification exists first
+if [ ! -f "$SPEC_FILE" ]; then
+    error_exit "Specification file not found: $SPEC_FILE. Please create specification first."
+fi
+
+# Ensure plan template exists
+if [ ! -f "$TEMPLATE_FILE" ]; then
+    error_exit "Template not found: $TEMPLATE_FILE"
+fi
 
-# Ensure template exists
+# Create plan if it doesn't exist
 if [ ! -f "$PLAN_FILE" ]; then
-    cp templates/plan.md "$PLAN_FILE"
+    log "Creating implementation plan from template: $PLAN_FILE"
+    cp "$TEMPLATE_FILE" "$PLAN_FILE" || error_exit "Failed to copy plan template"
+else
+    log "Implementation plan already exists: $PLAN_FILE"
+fi
+
+# Validate plan structure
+log "Validating implementation plan..."
+
+# Check for required sections
+REQUIRED_SECTIONS=("## Implementation Plan:" "## Specification Reference" "## Phase -1: Pre-Implementation Gates" "## Implementation Phases")
+MISSING_SECTIONS=()
+
+for section in "${REQUIRED_SECTIONS[@]}"; do
+    if ! grep -q "$section" "$PLAN_FILE"; then
+        MISSING_SECTIONS+=("$section")
+    fi
+done
+
+if [ ${#MISSING_SECTIONS[@]} -gt 0 ]; then
+    log "WARNING: Missing required sections: ${MISSING_SECTIONS[*]}"
+fi
+
+# Check Constitutional Gates
+log "Checking Constitutional Gates..."
+
+CONSTITUTIONAL_GATES=(
+    "Simplicity Gate"
+    "Anti-Abstraction Gate"
+    "Test-First Gate"
+    "Integration-First Gate"
+    "Research Gate"
+)
+
+for gate in "${CONSTITUTIONAL_GATES[@]}"; do
+    if ! grep -q "$gate" "$PLAN_FILE"; then
+        log "WARNING: Missing constitutional gate: $gate"
+    fi
+done
+
+# Check if specification has clarifications needed
+if grep -q "NEEDS CLARIFICATION" "$SPEC_FILE"; then
+    CLARIFICATION_COUNT=$(grep -c "NEEDS CLARIFICATION" "$SPEC_FILE")
+    log "WARNING: Specification has $CLARIFICATION_COUNT clarifications needed - resolve before proceeding"
+fi
+
+# Validate gate compliance
+GATE_STATUS=$(grep -A5 "Gate Status:" "$PLAN_FILE" | tail -1 | sed 's/.*\[\(.*\)\].*/\1/' || echo "PENDING")
+
+if [ "$GATE_STATUS" != "COMPLETED" ]; then
+    log "WARNING: Constitutional gates not completed. Status: $GATE_STATUS"
 fi
 
-# Check Phase Gates
-echo "Checking Phase Gates..."
-echo "- Constitutional compliance"
-echo "- Simplicity check (≤3 modules)"
-echo "- Test-first strategy"
-echo "- Framework selection"
+log "Implementation plan processing completed successfully"
 
 echo "PLAN_FILE=$PLAN_FILE"
+echo "SPEC_FILE=$SPEC_FILE"
+echo "MISSING_SECTIONS=${#MISSING_SECTIONS[@]}"
+echo "CONSTITUTIONAL_GATES_STATUS=$GATE_STATUS"
 echo "STATUS=ready"