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

specpulse/resources/memory/constitution.md

@@ -124,7 +124,7 @@ complexity_exceptions:
     violation: "Using 4 projects instead of 3"
     justification: "Authentication requires separate service for security isolation"
     approved_by: "Team Lead"
-    date: "2024-01-15"
+    date: "2025-09-11"
 ```
 
 ### Amendment Process
@@ -233,5 +233,5 @@ While principles are immutable, their application can evolve:
 ## Living Constitution
 This constitution is a living document that learns from experience while maintaining core principles. Each project iteration strengthens these principles through practical application and refinement.
 
-*Last Updated: 2024-12-27*
+*Last Updated: 2025-09-11*
 *Version: 2.0 - Full SDD Methodology Implementation*

specpulse/resources/scripts/pulse-init.ps1

@@ -0,0 +1,186 @@
+# SpecPulse Feature Initialization Script
+# Cross-platform PowerShell equivalent of pulse-init.sh
+
+param(
+    [Parameter(Mandatory=$true)]
+    [string]$FeatureName,
+    
+    [string]$CustomId = ""
+)
+
+$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-FeatureName {
+    param([string]$Name)
+    
+    if ([string]::IsNullOrWhiteSpace($Name)) {
+        Exit-WithError "Feature name cannot be empty"
+    }
+    
+    # Convert to lowercase, replace spaces and special chars with hyphens
+    $Sanitized = $Name.ToLower() -replace '[^a-z0-9-]', '-'
+    $Sanitized = $Sanitized -replace '-+', '-'  # Remove consecutive hyphens
+    $Sanitized = $Sanitized.Trim('-')  # Remove leading/trailing hyphens
+    
+    if ([string]::IsNullOrWhiteSpace($Sanitized)) {
+        Exit-WithError "Invalid feature name: '$Name'"
+    }
+    
+    return $Sanitized
+}
+
+function Get-FeatureId {
+    param([string]$CustomId)
+    
+    if ($CustomId) {
+        return "{0:D3}" -f [int]$CustomId
+    }
+    
+    # Find existing feature directories
+    $SpecsDir = Join-Path $ProjectRoot "specs"
+    if (Test-Path $SpecsDir) {
+        $Existing = Get-ChildItem -Path $SpecsDir -Directory | 
+                  Where-Object { $_.Name -match '^\d+$' } |
+                  Sort-Object Name
+        $NextId = $Existing.Count + 1
+    } else {
+        $NextId = 1
+    }
+    
+    return "{0:D3}" -f $NextId
+}
+
+function Create-Directories {
+    param([string]$BranchName)
+    
+    $Directories = @(
+        (Join-Path $ProjectRoot "specs" $BranchName),
+        (Join-Path $ProjectRoot "plans" $BranchName),
+        (Join-Path $ProjectRoot "tasks" $BranchName)
+    )
+    
+    foreach ($Directory in $Directories) {
+        try {
+            New-Item -ItemType Directory -Path $Directory -Force | Out-Null
+            Write-Log "Created directory: $Directory"
+        } catch {
+            Exit-WithError "Failed to create directory $Directory : $_"
+        }
+    }
+}
+
+function Copy-Templates {
+    param([string]$BranchName)
+    
+    $Templates = @{
+        "spec.md" = (Join-Path $ProjectRoot "specs" $BranchName "spec.md")
+        "plan.md" = (Join-Path $ProjectRoot "plans" $BranchName "plan.md")
+        "task.md" = (Join-Path $ProjectRoot "tasks" $BranchName "tasks.md")
+    }
+    
+    foreach ($Template in $Templates.GetEnumerator()) {
+        $TemplatePath = Join-Path $TemplatesDir $Template.Key
+        $TargetPath = $Template.Value
+        
+        if (-not (Test-Path $TemplatePath)) {
+            Exit-WithError "Template not found: $TemplatePath"
+        }
+        
+        try {
+            Copy-Item $TemplatePath $TargetPath -Force
+            Write-Log "Copied template to: $TargetPath"
+        } catch {
+            Exit-WithError "Failed to copy template $TemplatePath : $_"
+        }
+    }
+}
+
+function Update-Context {
+    param(
+        [string]$FeatureName,
+        [string]$FeatureId,
+        [string]$BranchName
+    )
+    
+    try {
+        New-Item -ItemType Directory -Path $MemoryDir -Force | Out-Null
+        
+        $ContextEntry = @"
+
+## Active Feature: $FeatureName
+- Feature ID: $FeatureId
+- Branch: $BranchName
+- Started: $(Get-Date -Format "o")
+"@
+        
+        Add-Content -Path $ContextFile -Value $ContextEntry -Encoding UTF8
+        Write-Log "Updated context file: $ContextFile"
+    } catch {
+        Exit-WithError "Failed to update context file: $_"
+    }
+}
+
+function New-GitBranch {
+    param([string]$BranchName)
+    
+    $GitDir = Join-Path $ProjectRoot ".git"
+    if (-not (Test-Path $GitDir)) {
+        return
+    }
+    
+    try {
+        # Check if branch already exists
+        $ExistingBranch = git branch --list $BranchName
+        if ($ExistingBranch) {
+            Write-Log "Git branch '$BranchName' already exists, checking out"
+            git checkout $BranchName
+        } else {
+            Write-Log "Creating new git branch '$BranchName'"
+            git checkout -b $BranchName
+        }
+    } catch {
+        Exit-WithError "Git operation failed: $_"
+    }
+}
+
+# Main execution
+Write-Log "Initializing feature: $FeatureName"
+
+# Sanitize and generate identifiers
+$SanitizedName = Sanitize-FeatureName -Name $FeatureName
+$FeatureId = Get-FeatureId -CustomId $CustomId
+$BranchName = "$FeatureId-$SanitizedName"
+
+# Create structure
+Create-Directories -BranchName $BranchName
+Copy-Templates -BranchName $BranchName
+Update-Context -FeatureName $FeatureName -FeatureId $FeatureId -BranchName $BranchName
+New-GitBranch -BranchName $BranchName
+
+# Output results
+Write-Host "BRANCH_NAME=$BranchName"
+Write-Host "SPEC_DIR=specs/$BranchName"
+Write-Host "FEATURE_ID=$FeatureId"
+Write-Host "STATUS=initialized"
+
+Write-Log "Successfully initialized feature '$FeatureName' with ID $FeatureId"

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"