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

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"

specpulse/resources/scripts/pulse-spec.ps1

@@ -0,0 +1,185 @@
+# SpecPulse Specification Generation Script
+# Cross-platform PowerShell equivalent of pulse-spec.sh
+
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$FeatureDir,
+    
+    [string]$SpecContent = ""
+)
+
+$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-Specification {
+    param([string]$SpecFile)
+    
+    if (-not (Test-Path $SpecFile)) {
+        Exit-WithError "Specification file does not exist: $SpecFile"
+    }
+    
+    # Required sections
+    $RequiredSections = @(
+        "## Specification:",
+        "## Metadata", 
+        "## Functional Requirements",
+        "## Acceptance Scenarios"
+    )
+    
+    $Content = Get-Content $SpecFile -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 ', ')"
+    }
+    
+    # Check for clarifications needed
+    $ClarificationMatches = [regex]::Matches($Content, 'NEEDS CLARIFICATION')
+    if ($ClarificationMatches.Count -gt 0) {
+        $ClarificationCount = $ClarificationMatches.Count
+        Write-Log "WARNING: Specification has $ClarificationCount clarifications needed"
+        return $ClarificationCount
+    }
+    
+    return 0
+}
+
+# Main execution
+Write-Log "Processing specification..."
+
+# Get and sanitize feature directory
+$SanitizedDir = Get-CurrentFeatureDir -ProvidedDir $FeatureDir
+
+# Set file paths
+$SpecFile = Join-Path $ProjectRoot "specs" $SanitizedDir "spec.md"
+$TemplateFile = Join-Path $TemplatesDir "spec.md"
+
+# Ensure specs directory exists
+$SpecDir = Split-Path $SpecFile -Parent
+New-Item -ItemType Directory -Path $SpecDir -Force | Out-Null
+
+# Handle specification content
+if ($SpecContent) {
+    Write-Log "Updating specification: $SpecFile"
+    try {
+        Set-Content -Path $SpecFile -Value $SpecContent -Encoding UTF8
+    } catch {
+        Exit-WithError "Failed to write specification content: $_"
+    }
+} else {
+    # Ensure specification exists from template
+    if (-not (Test-Path $SpecFile)) {
+        if (-not (Test-Path $TemplateFile)) {
+            Exit-WithError "Template not found: $TemplateFile"
+        }
+        
+        Write-Log "Creating specification from template: $SpecFile"
+        try {
+            Copy-Item $TemplateFile $SpecFile -Force
+        } catch {
+            Exit-WithError "Failed to copy specification template: $_"
+        }
+    } else {
+        Write-Log "Specification already exists: $SpecFile"
+    }
+}
+
+# Validate specification
+Write-Log "Validating specification..."
+$ClarificationCount = Validate-Specification -SpecFile $SpecFile
+
+# Check for missing sections
+$Content = Get-Content $SpecFile -Raw -Encoding UTF8
+$RequiredSections = @(
+    "## Specification:",
+    "## Metadata", 
+    "## Functional Requirements",
+    "## Acceptance Scenarios"
+)
+
+$MissingSections = @()
+foreach ($Section in $RequiredSections) {
+    if ($Content -notmatch [regex]::Escape($Section)) {
+        $MissingSections += $Section
+    }
+}
+
+Write-Log "Specification processing completed successfully"
+
+# Output results
+Write-Host "SPEC_FILE=$SpecFile"
+Write-Host "CLARIFICATIONS_NEEDED=$ClarificationCount"
+Write-Host "MISSING_SECTIONS=$($MissingSections.Count)"
+Write-Host "STATUS=updated"

specpulse/resources/scripts/pulse-spec.py

@@ -0,0 +1,167 @@
+#!/usr/bin/env python3
+"""
+SpecPulse Specification Generation Script
+Cross-platform Python equivalent of pulse-spec.sh
+"""
+
+import os
+import sys
+import re
+from pathlib import Path
+import datetime
+
+class SpecPulseSpec:
+    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")
+        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")
+            
+        # Remove non-alphanumeric characters except hyphens and underscores
+        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')
+            # Look for "Active Feature" section
+            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_specification(self, spec_file):
+        """Validate specification structure"""
+        if not spec_file.exists():
+            self.error_exit(f"Specification file does not exist: {spec_file}")
+            
+        # Required sections
+        required_sections = [
+            "## Specification:",
+            "## Metadata", 
+            "## Functional Requirements",
+            "## Acceptance Scenarios"
+        ]
+        
+        missing_sections = []
+        content = spec_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)}")
+            
+        # Check for clarifications needed
+        clarification_matches = re.findall(r'NEEDS CLARIFICATION', content)
+        if clarification_matches:
+            clarification_count = len(clarification_matches)
+            self.log(f"WARNING: Specification has {clarification_count} clarifications needed")
+            return clarification_count
+            
+        return 0
+        
+    def main(self, args):
+        """Main execution function"""
+        if len(args) < 1:
+            self.error_exit("Usage: python pulse-spec.py <feature-dir> [spec-content]")
+            
+        feature_dir = args[0]
+        spec_content = args[1] if len(args) > 1 else None
+        
+        self.log("Processing specification...")
+        
+        # Get and sanitize feature directory
+        sanitized_dir = self.get_current_feature_dir(feature_dir)
+        
+        # Set file paths
+        spec_file = self.project_root / "specs" / sanitized_dir / "spec.md"
+        template_file = self.templates_dir / "spec.md"
+        
+        # Ensure specs directory exists
+        spec_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Handle specification content
+        if spec_content:
+            self.log(f"Updating specification: {spec_file}")
+            try:
+                spec_file.write_text(spec_content, encoding='utf-8')
+            except Exception as e:
+                self.error_exit(f"Failed to write specification content: {e}")
+        else:
+            # Ensure specification exists from template
+            if not spec_file.exists():
+                if not template_file.exists():
+                    self.error_exit(f"Template not found: {template_file}")
+                    
+                self.log(f"Creating specification from template: {spec_file}")
+                try:
+                    spec_file.write_text(template_file.read_text(encoding='utf-8'))
+                except Exception as e:
+                    self.error_exit(f"Failed to copy specification template: {e}")
+            else:
+                self.log(f"Specification already exists: {spec_file}")
+                
+        # Validate specification
+        self.log("Validating specification...")
+        clarification_count = self.validate_specification(spec_file)
+        
+        # Check for missing sections
+        required_sections = [
+            "## Specification:",
+            "## Metadata", 
+            "## Functional Requirements",
+            "## Acceptance Scenarios"
+        ]
+        
+        content = spec_file.read_text(encoding='utf-8')
+        missing_sections = [s for s in required_sections if s not in content]
+        
+        self.log("Specification processing completed successfully")
+        
+        # Output results
+        print(f"SPEC_FILE={spec_file}")
+        print(f"CLARIFICATIONS_NEEDED={clarification_count}")
+        print(f"MISSING_SECTIONS={len(missing_sections)}")
+        print("STATUS=updated")
+
+if __name__ == "__main__":
+    spec = SpecPulseSpec()
+    spec.main(sys.argv[1:])