specpulse 1.0.6__py3-none-any.whl → 1.1.0__py3-none-any.whl

specpulse/resources/scripts/pulse-plan.ps1

@@ -1,251 +0,0 @@
-# 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-spec.ps1

@@ -1,185 +0,0 @@
-# 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-task.ps1

@@ -1,263 +0,0 @@
-# SpecPulse Task Generation Script
-# Cross-platform PowerShell equivalent of pulse-task.sh
-
-param(
-    [Parameter(Mandatory=$true)]
-    [string]$FeatureDir,
-    
-    [string]$TaskContent = ""
-)
-
-$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-TaskStructure {
-    param([string]$TaskFile)
-    
-    if (-not (Test-Path $TaskFile)) {
-        Exit-WithError "Task file does not exist: $TaskFile"
-    }
-    
-    # Required sections
-    $RequiredSections = @(
-        "# Task List:",
-        "## Progress Tracking",
-        "### Parallel Group"
-    )
-    
-    $Content = Get-Content $TaskFile -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]$TaskFile)
-    
-    if (-not (Test-Path $TaskFile)) {
-        Exit-WithError "Task file does not exist: $TaskFile"
-    }
-    
-    $Content = Get-Content $TaskFile -Raw -Encoding UTF8
-    $GatesStatus = @{}
-    
-    # Check for constitutional gates compliance
-    $Gates = @{
-        "Simplicity Gate" = "Simplicity Gate"
-        "Test-First Gate" = "Test-First Gate"
-        "Integration-First Gate" = "Integration-First Gate"
-        "Research Gate" = "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-Tasks {
-    param([string]$TaskFile)
-    
-    if (-not (Test-Path $TaskFile)) {
-        Exit-WithError "Task file does not exist: $TaskFile"
-    }
-    
-    $Content = Get-Content $TaskFile -Raw -Encoding UTF8
-    
-    # Count tasks
-    $TaskMatches = [regex]::Matches($Content, '### T\d{3}:')
-    $TaskCount = $TaskMatches.Count
-    
-    # Count parallel tasks
-    $ParallelMatches = [regex]::Matches($Content, '\[P\]')
-    $ParallelCount = $ParallelMatches.Count
-    
-    # Check for completion status
-    $CompletionSection = $Content -match "## Progress Tracking"
-    $CompletedTasks = 0
-    $InProgressTasks = 0
-    $BlockedTasks = 0
-    
-    if ($CompletionSection) {
-        # Look for progress tracking YAML section
-        if ($Content -match "completed:\s*(\d+)") {
-            $CompletedTasks = [int]$matches[1]
-        }
-        if ($Content -match "in_progress:\s*(\d+)") {
-            $InProgressTasks = [int]$matches[1]
-        }
-        if ($Content -match "blocked:\s*(\d+)") {
-            $BlockedTasks = [int]$matches[1]
-        }
-    }
-    
-    return @{
-        TotalTasks = $TaskCount
-        ParallelTasks = $ParallelCount
-        CompletedTasks = $CompletedTasks
-        InProgressTasks = $InProgressTasks
-        BlockedTasks = $BlockedTasks
-    }
-}
-
-# Main execution
-Write-Log "Processing tasks..."
-
-# Get and sanitize feature directory
-$SanitizedDir = Get-CurrentFeatureDir -ProvidedDir $FeatureDir
-
-# Set file paths
-$TaskFile = Join-Path $ProjectRoot "tasks" $SanitizedDir "tasks.md"
-$PlanFile = Join-Path $ProjectRoot "plans" $SanitizedDir "plan.md"
-$TemplateFile = Join-Path $TemplatesDir "task.md"
-
-# Ensure tasks directory exists
-$TaskDir = Split-Path $TaskFile -Parent
-New-Item -ItemType Directory -Path $TaskDir -Force | Out-Null
-
-# Handle task content
-if ($TaskContent) {
-    Write-Log "Updating task file: $TaskFile"
-    try {
-        Set-Content -Path $TaskFile -Value $TaskContent -Encoding UTF8
-    } catch {
-        Exit-WithError "Failed to write task content: $_"
-    }
-} else {
-    # Ensure task file exists from template
-    if (-not (Test-Path $TaskFile)) {
-        if (-not (Test-Path $TemplateFile)) {
-            Exit-WithError "Template not found: $TemplateFile"
-        }
-        
-        Write-Log "Creating task file from template: $TaskFile"
-        try {
-            Copy-Item $TemplateFile $TaskFile -Force
-        } catch {
-            Exit-WithError "Failed to copy task template: $_"
-        }
-    } else {
-        Write-Log "Task file already exists: $TaskFile"
-    }
-}
-
-# Validate task structure
-Write-Log "Validating task structure..."
-$MissingSections = Validate-TaskStructure -TaskFile $TaskFile
-
-# Check constitutional gates
-Write-Log "Checking constitutional gates..."
-$GatesStatus = Check-ConstitutionalGates -TaskFile $TaskFile
-
-# Analyze tasks
-Write-Log "Analyzing tasks..."
-$TaskAnalysis = Analyze-Tasks -TaskFile $TaskFile
-
-# Calculate completion percentage
-$CompletionPercentage = 0
-if ($TaskAnalysis.TotalTasks -gt 0) {
-    $CompletionPercentage = [math]::Round(($TaskAnalysis.CompletedTasks / $TaskAnalysis.TotalTasks) * 100, 2)
-}
-
-# Count pending constitutional gates
-$PendingGates = 0
-foreach ($Status in $GatesStatus.Values) {
-    if ($Status -eq "PENDING") {
-        $PendingGates++
-    }
-}
-
-Write-Log "Task processing completed successfully"
-
-# Output results
-Write-Host "TASK_FILE=$TaskFile"
-Write-Host "TOTAL_TASKS=$($TaskAnalysis.TotalTasks)"
-Write-Host "COMPLETED_TASKS=$($TaskAnalysis.CompletedTasks)"
-Write-Host "IN_PROGRESS_TASKS=$($TaskAnalysis.InProgressTasks)"
-Write-Host "BLOCKED_TASKS=$($TaskAnalysis.BlockedTasks)"
-Write-Host "PARALLEL_TASKS=$($TaskAnalysis.ParallelTasks)"
-Write-Host "COMPLETION_PERCENTAGE=$CompletionPercentage"
-Write-Host "MISSING_SECTIONS=$MissingSections"
-Write-Host "CONSTITUTIONAL_GATES_PENDING=$PendingGates"
-Write-Host "STATUS=processed"