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

specpulse/resources/scripts/pulse-init.py

@@ -0,0 +1,171 @@
+#!/usr/bin/env python3
+"""
+SpecPulse Feature Initialization Script
+Cross-platform Python equivalent of pulse-init.sh
+"""
+
+import os
+import sys
+import subprocess
+import re
+import datetime
+from pathlib import Path
+
+class SpecPulseInit:
+    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_name(self, feature_name):
+        """Sanitize feature name for safe directory naming"""
+        if not feature_name:
+            self.error_exit("Feature name cannot be empty")
+        
+        # Convert to lowercase, replace spaces and special chars with hyphens
+        sanitized = re.sub(r'[^a-z0-9-]', '-', feature_name.lower())
+        sanitized = re.sub(r'-+', '-', sanitized)  # Remove consecutive hyphens
+        sanitized = sanitized.strip('-')  # Remove leading/trailing hyphens
+        
+        if not sanitized:
+            self.error_exit(f"Invalid feature name: '{feature_name}'")
+            
+        return sanitized
+        
+    def get_feature_id(self, custom_id=None):
+        """Get next feature ID"""
+        if custom_id:
+            return f"{int(custom_id):03d}"
+        
+        # Find existing feature directories
+        specs_dir = self.project_root / "specs"
+        if specs_dir.exists():
+            existing = [d for d in specs_dir.iterdir() if d.is_dir() and d.name.isdigit()]
+            next_id = len(existing) + 1
+        else:
+            next_id = 1
+            
+        return f"{next_id:03d}"
+        
+    def create_directories(self, branch_name):
+        """Create feature directories"""
+        dirs_to_create = [
+            self.project_root / "specs" / branch_name,
+            self.project_root / "plans" / branch_name,
+            self.project_root / "tasks" / branch_name
+        ]
+        
+        for directory in dirs_to_create:
+            try:
+                directory.mkdir(parents=True, exist_ok=True)
+                self.log(f"Created directory: {directory}")
+            except Exception as e:
+                self.error_exit(f"Failed to create directory {directory}: {e}")
+                
+    def copy_templates(self, branch_name):
+        """Copy templates to feature directories"""
+        templates = {
+            "spec.md": self.project_root / "specs" / branch_name / "spec.md",
+            "plan.md": self.project_root / "plans" / branch_name / "plan.md",
+            "task.md": self.project_root / "tasks" / branch_name / "tasks.md"
+        }
+        
+        for template_name, target_path in templates.items():
+            template_path = self.templates_dir / template_name
+            if not template_path.exists():
+                self.error_exit(f"Template not found: {template_path}")
+                
+            try:
+                target_path.write_text(template_path.read_text())
+                self.log(f"Copied template to: {target_path}")
+            except Exception as e:
+                self.error_exit(f"Failed to copy template {template_path}: {e}")
+                
+    def update_context(self, feature_name, feature_id, branch_name):
+        """Update context file"""
+        try:
+            self.memory_dir.mkdir(parents=True, exist_ok=True)
+            
+            context_entry = f"""
+
+## Active Feature: {feature_name}
+- Feature ID: {feature_id}
+- Branch: {branch_name}
+- Started: {datetime.datetime.now().isoformat()}
+"""
+            
+            with open(self.context_file, 'a', encoding='utf-8') as f:
+                f.write(context_entry)
+                
+            self.log(f"Updated context file: {self.context_file}")
+        except Exception as e:
+            self.error_exit(f"Failed to update context file: {e}")
+            
+    def create_git_branch(self, branch_name):
+        """Create git branch if in git repository"""
+        git_dir = self.project_root / ".git"
+        if not git_dir.exists():
+            return
+            
+        try:
+            # Check if branch already exists
+            result = subprocess.run(
+                ["git", "branch", "--list", branch_name],
+                cwd=self.project_root,
+                capture_output=True,
+                text=True
+            )
+            
+            if branch_name in result.stdout:
+                self.log(f"Git branch '{branch_name}' already exists, checking out")
+                subprocess.run(["git", "checkout", branch_name], cwd=self.project_root, check=True)
+            else:
+                self.log(f"Creating new git branch '{branch_name}'")
+                subprocess.run(["git", "checkout", "-b", branch_name], cwd=self.project_root, check=True)
+        except subprocess.CalledProcessError as e:
+            self.error_exit(f"Git operation failed: {e}")
+            
+    def main(self, args):
+        """Main execution function"""
+        if len(args) < 1:
+            self.error_exit("Usage: python pulse-init.py <feature-name> [feature-id]")
+            
+        feature_name = args[0]
+        custom_id = args[1] if len(args) > 1 else None
+        
+        self.log(f"Initializing feature: {feature_name}")
+        
+        # Sanitize and generate identifiers
+        sanitized_name = self.sanitize_feature_name(feature_name)
+        feature_id = self.get_feature_id(custom_id)
+        branch_name = f"{feature_id}-{sanitized_name}"
+        
+        # Create structure
+        self.create_directories(branch_name)
+        self.copy_templates(branch_name)
+        self.update_context(feature_name, feature_id, branch_name)
+        self.create_git_branch(branch_name)
+        
+        # Output results
+        print(f"BRANCH_NAME={branch_name}")
+        print(f"SPEC_DIR=specs/{branch_name}")
+        print(f"FEATURE_ID={feature_id}")
+        print("STATUS=initialized")
+        
+        self.log(f"Successfully initialized feature '{feature_name}' with ID {feature_id}")
+
+if __name__ == "__main__":
+    init = SpecPulseInit()
+    init.main(sys.argv[1:])

specpulse/resources/scripts/pulse-init.sh

@@ -1,37 +1,96 @@
 #!/bin/bash
 # Initialize a new feature with SpecPulse
 
-FEATURE_NAME="${1:-feature}"
+set -euo pipefail  # Exit on error, unset vars, pipe failures
 
-# Get next feature ID
-FEATURE_ID=$(printf "%03d" $(ls -d specs/[0-9]* 2>/dev/null | wc -l | xargs expr 1 +))
+# Configuration
+SCRIPT_NAME="$(basename "$0")"
+PROJECT_ROOT="$(cd "$(dirname "${BASH_SOURCE[0]}")/../.." && pwd)"
 
-# Create branch name
-BRANCH_NAME="${FEATURE_ID}-${FEATURE_NAME}"
+# 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-name> [feature-id]"
+fi
+
+FEATURE_NAME="$1"
+CUSTOM_ID="${2:-}"
+
+# Sanitize feature name
+BRANCH_SAFE_NAME=$(echo "$FEATURE_NAME" | tr '[:upper:]' '[:lower:]' | sed 's/[^a-z0-9-]/-/g' | sed 's/--*/-/g' | sed 's/^-//;s/-$//')
+
+if [ -z "$BRANCH_SAFE_NAME" ]; then
+    error_exit "Invalid feature name: '$FEATURE_NAME'"
+fi
+
+# Get feature ID
+if [ -n "$CUSTOM_ID" ]; then
+    FEATURE_ID=$(printf "%03d" "$CUSTOM_ID")
+else
+    FEATURE_ID=$(printf "%03d" $(find "$PROJECT_ROOT/specs" -maxdepth 1 -type d -name '[0-9]*' 2>/dev/null | wc -l | awk '{print $1 + 1}'))
+fi
+
+BRANCH_NAME="${FEATURE_ID}-${BRANCH_SAFE_NAME}"
 
 # Create directories
-mkdir -p "specs/${BRANCH_NAME}"
-mkdir -p "plans/${BRANCH_NAME}"
-mkdir -p "tasks/${BRANCH_NAME}"
+SPECS_DIR="$PROJECT_ROOT/specs/${BRANCH_NAME}"
+PLANS_DIR="$PROJECT_ROOT/plans/${BRANCH_NAME}"
+TASKS_DIR="$PROJECT_ROOT/tasks/${BRANCH_NAME}"
+
+log "Creating feature directories for '$FEATURE_NAME'"
+
+mkdir -p "$SPECS_DIR" || error_exit "Failed to create specs directory: $SPECS_DIR"
+mkdir -p "$PLANS_DIR" || error_exit "Failed to create plans directory: $PLANS_DIR"
+mkdir -p "$TASKS_DIR" || error_exit "Failed to create tasks directory: $TASKS_DIR"
 
 # Create initial files from templates
-cp templates/spec.md "specs/${BRANCH_NAME}/spec.md"
-cp templates/plan.md "plans/${BRANCH_NAME}/plan.md"
-cp templates/task.md "tasks/${BRANCH_NAME}/tasks.md"
+TEMPLATE_DIR="$PROJECT_ROOT/templates"
+
+if [ ! -f "$TEMPLATE_DIR/spec.md" ]; then
+    error_exit "Template not found: $TEMPLATE_DIR/spec.md"
+fi
+
+cp "$TEMPLATE_DIR/spec.md" "$SPECS_DIR/spec.md" || error_exit "Failed to copy spec template"
+cp "$TEMPLATE_DIR/plan.md" "$PLANS_DIR/plan.md" || error_exit "Failed to copy plan template"
+cp "$TEMPLATE_DIR/task.md" "$TASKS_DIR/tasks.md" || error_exit "Failed to copy task template"
 
 # Update context
-echo "" >> memory/context.md
-echo "## Active Feature: ${FEATURE_NAME}" >> memory/context.md
-echo "- Feature ID: ${FEATURE_ID}" >> memory/context.md
-echo "- Branch: ${BRANCH_NAME}" >> memory/context.md
-echo "- Started: $(date -Iseconds)" >> memory/context.md
+CONTEXT_FILE="$PROJECT_ROOT/memory/context.md"
+mkdir -p "$(dirname "$CONTEXT_FILE")"
+
+{
+    echo ""
+    echo "## Active Feature: $FEATURE_NAME"
+    echo "- Feature ID: $FEATURE_ID"
+    echo "- Branch: $BRANCH_NAME"
+    echo "- Started: $(date -Iseconds)"
+} >> "$CONTEXT_FILE" || error_exit "Failed to update context file"
 
 # Create git branch if in git repo
-if [ -d .git ]; then
-    git checkout -b "${BRANCH_NAME}" 2>/dev/null || git checkout "${BRANCH_NAME}"
+if [ -d "$PROJECT_ROOT/.git" ]; then
+    cd "$PROJECT_ROOT"
+    if git rev-parse --verify "$BRANCH_NAME" >/dev/null 2>&1; then
+        log "Git branch '$BRANCH_NAME' already exists, checking out"
+        git checkout "$BRANCH_NAME" || error_exit "Failed to checkout existing branch"
+    else
+        log "Creating new git branch '$BRANCH_NAME'"
+        git checkout -b "$BRANCH_NAME" || error_exit "Failed to create new branch"
+    fi
 fi
 
-echo "BRANCH_NAME=${BRANCH_NAME}"
-echo "SPEC_DIR=specs/${BRANCH_NAME}"
-echo "FEATURE_ID=${FEATURE_ID}"
+log "Successfully initialized feature '$FEATURE_NAME' with ID $FEATURE_ID"
+
+echo "BRANCH_NAME=$BRANCH_NAME"
+echo "SPEC_DIR=$SPECS_DIR"
+echo "FEATURE_ID=$FEATURE_ID"
 echo "STATUS=initialized"

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"