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

specpulse/resources/scripts/pulse-task.ps1

@@ -0,0 +1,263 @@
+# 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"

specpulse/resources/scripts/pulse-task.py

@@ -0,0 +1,237 @@
+#!/usr/bin/env python3
+"""
+SpecPulse Task Generation Script
+Cross-platform Python equivalent of pulse-task.sh
+"""
+
+import os
+import sys
+import re
+from pathlib import Path
+import datetime
+
+class SpecPulseTask:
+    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 analyze_tasks(self, task_file):
+        """Analyze task structure and count statuses"""
+        if not task_file.exists():
+            return {
+                'total': 0,
+                'completed': 0,
+                'pending': 0,
+                'blocked': 0,
+                'parallel': 0
+            }
+            
+        content = task_file.read_text(encoding='utf-8')
+        
+        # Count different task states
+        total_tasks = len(re.findall(r'^- \[.\]', content, re.MULTILINE))
+        completed_tasks = len(re.findall(r'^- \[x\]', content, re.MULTILINE))
+        pending_tasks = len(re.findall(r'^- \[ \]', content, re.MULTILINE))
+        blocked_tasks = len(re.findall(r'^- \[!\]', content, re.MULTILINE))
+        parallel_tasks = len(re.findall(r'\[P\]', content))
+        
+        return {
+            'total': total_tasks,
+            'completed': completed_tasks,
+            'pending': pending_tasks,
+            'blocked': blocked_tasks,
+            'parallel': parallel_tasks
+        }
+        
+    def validate_task_structure(self, task_file):
+        """Validate task structure"""
+        required_sections = [
+            "## Task List:",
+            "## Task Organization",
+            "## Critical Path",
+            "## Execution Schedule"
+        ]
+        
+        missing_sections = []
+        content = task_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, task_file):
+        """Check constitutional gates compliance"""
+        if not task_file.exists():
+            return 0
+            
+        content = task_file.read_text(encoding='utf-8')
+        
+        # Find constitutional gates section
+        constitutional_section = re.search(
+            r'Constitutional Gates Compliance.*?(?=\n##|\Z)', 
+            content, 
+            re.DOTALL
+        )
+        
+        if constitutional_section:
+            gates_text = constitutional_section.group(0)
+            pending_gates = len(re.findall(r'\[ \]', gates_text))
+            return pending_gates
+            
+        return 0
+        
+    def check_plan_gates_status(self, plan_file):
+        """Check if plan has constitutional gates completed"""
+        if not plan_file.exists():
+            return "UNKNOWN"
+            
+        content = plan_file.read_text(encoding='utf-8')
+        gate_status_match = re.search(r'Gate Status:\s*\[([^\]]+)\]', content)
+        
+        if gate_status_match:
+            return gate_status_match.group(1)
+        else:
+            return "UNKNOWN"
+            
+    def main(self, args):
+        """Main execution function"""
+        if len(args) < 1:
+            self.error_exit("Usage: python pulse-task.py <feature-dir>")
+            
+        feature_dir = args[0]
+        
+        self.log("Processing task breakdown...")
+        
+        # Get and sanitize feature directory
+        sanitized_dir = self.get_current_feature_dir(feature_dir)
+        
+        # Set file paths
+        task_file = self.project_root / "tasks" / sanitized_dir / "tasks.md"
+        template_file = self.templates_dir / "task.md"
+        plan_file = self.project_root / "plans" / sanitized_dir / "plan.md"
+        spec_file = self.project_root / "specs" / sanitized_dir / "spec.md"
+        
+        # Ensure tasks directory exists
+        task_file.parent.mkdir(parents=True, exist_ok=True)
+        
+        # Check if specification and plan exist first
+        if not spec_file.exists():
+            self.error_exit(f"Specification file not found: {spec_file}. Please create specification first.")
+            
+        if not plan_file.exists():
+            self.error_exit(f"Implementation plan not found: {plan_file}. Please create plan first.")
+            
+        # Ensure task template exists
+        if not template_file.exists():
+            self.error_exit(f"Template not found: {template_file}")
+            
+        # Create task file if it doesn't exist
+        if not task_file.exists():
+            self.log(f"Creating task breakdown from template: {task_file}")
+            try:
+                task_file.write_text(template_file.read_text(encoding='utf-8'))
+            except Exception as e:
+                self.error_exit(f"Failed to copy task template: {e}")
+        else:
+            self.log(f"Task breakdown already exists: {task_file}")
+            
+        # Validate task structure
+        self.log("Validating task breakdown...")
+        missing_sections = self.validate_task_structure(task_file)
+        
+        # Analyze tasks
+        task_stats = self.analyze_tasks(task_file)
+        
+        # Check constitutional gates compliance
+        pending_gates = self.check_constitutional_gates(task_file)
+        
+        # Check if plan has constitutional gates completed
+        plan_gate_status = self.check_plan_gates_status(plan_file)
+        
+        if plan_gate_status != "COMPLETED":
+            self.log(f"WARNING: Implementation plan constitutional gates not completed. Status: {plan_gate_status}")
+            
+        # Calculate completion percentage
+        if task_stats['total'] > 0:
+            completion_percentage = int((task_stats['completed'] / task_stats['total']) * 100)
+        else:
+            completion_percentage = 0
+            
+        self.log(f"Task analysis completed - Total: {task_stats['total']}, Completed: {task_stats['completed']} ({completion_percentage}%), Parallel: {task_stats['parallel']}")
+        
+        # Output comprehensive status
+        print(f"TASK_FILE={task_file}")
+        print(f"SPEC_FILE={spec_file}")
+        print(f"PLAN_FILE={plan_file}")
+        print(f"TOTAL_TASKS={task_stats['total']}")
+        print(f"COMPLETED_TASKS={task_stats['completed']}")
+        print(f"PENDING_TASKS={task_stats['pending']}")
+        print(f"BLOCKED_TASKS={task_stats['blocked']}")
+        print(f"PARALLEL_TASKS={task_stats['parallel']}")
+        print(f"CONSTITUTIONAL_GATES_PENDING={pending_gates}")
+        print(f"COMPLETION_PERCENTAGE={completion_percentage}")
+        print(f"MISSING_SECTIONS={missing_sections}")
+        print("STATUS=generated")
+
+if __name__ == "__main__":
+    task = SpecPulseTask()
+    task.main(sys.argv[1:])

specpulse/resources/scripts/pulse-task.sh

@@ -1,23 +1,137 @@
 #!/bin/bash
 # Generate task breakdown
 
-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
 
-TASK_FILE="tasks/${FEATURE_DIR}/tasks.md"
+TASK_FILE="$PROJECT_ROOT/tasks/${FEATURE_DIR}/tasks.md"
+TEMPLATE_FILE="$PROJECT_ROOT/templates/task.md"
+PLAN_FILE="$PROJECT_ROOT/plans/${FEATURE_DIR}/plan.md"
+SPEC_FILE="$PROJECT_ROOT/specs/${FEATURE_DIR}/spec.md"
+
+# Ensure tasks directory exists
+mkdir -p "$(dirname "$TASK_FILE")"
+
+# Check if specification and plan exist first
+if [ ! -f "$SPEC_FILE" ]; then
+    error_exit "Specification file not found: $SPEC_FILE. Please create specification first."
+fi
 
-# Ensure template exists
+if [ ! -f "$PLAN_FILE" ]; then
+    error_exit "Implementation plan not found: $PLAN_FILE. Please create plan first."
+fi
+
+# Ensure task template exists
+if [ ! -f "$TEMPLATE_FILE" ]; then
+    error_exit "Template not found: $TEMPLATE_FILE"
+fi
+
+# Create task file if it doesn't exist
 if [ ! -f "$TASK_FILE" ]; then
-    cp templates/task.md "$TASK_FILE"
+    log "Creating task breakdown from template: $TASK_FILE"
+    cp "$TEMPLATE_FILE" "$TASK_FILE" || error_exit "Failed to copy task template"
+else
+    log "Task breakdown already exists: $TASK_FILE"
+fi
+
+# Validate task structure
+log "Validating task breakdown..."
+
+# Check for required sections
+REQUIRED_SECTIONS=("## Task List:" "## Task Organization" "## Critical Path" "## Execution Schedule")
+MISSING_SECTIONS=()
+
+for section in "${REQUIRED_SECTIONS[@]}"; do
+    if ! grep -q "$section" "$TASK_FILE"; then
+        MISSING_SECTIONS+=("$section")
+    fi
+done
+
+if [ ${#MISSING_SECTIONS[@]} -gt 0 ]; then
+    log "WARNING: Missing required sections: ${MISSING_SECTIONS[*]}"
+fi
+
+# Count tasks and analyze structure
+TOTAL_TASKS=$(grep -c "^- \[.\]" "$TASK_FILE" 2>/dev/null || echo "0")
+COMPLETED_TASKS=$(grep -c "^- \[x\]" "$TASK_FILE" 2>/dev/null || echo "0")
+PENDING_TASKS=$(grep -c "^- \[ \]" "$TASK_FILE" 2>/dev/null || echo "0")
+BLOCKED_TASKS=$(grep -c "^- \[!\]" "$TASK_FILE" 2>/dev/null || echo "0")
+
+# Check for parallel tasks
+PARALLEL_TASKS=$(grep -c "\[P\]" "$TASK_FILE" 2>/dev/null || echo "0")
+
+# Check constitutional gates compliance
+CONSTITUTIONAL_SECTION=$(grep -A 20 "Constitutional Gates Compliance" "$TASK_FILE" 2>/dev/null || echo "")
+GATES_COUNT=$(echo "$CONSTITUTIONAL_SECTION" | grep -c "\[ \]" 2>/dev/null || echo "0")
+
+# Check if plan has constitutional gates completed
+PLAN_GATE_STATUS=$(grep -A5 "Gate Status:" "$PLAN_FILE" | tail -1 | sed 's/.*\[\(.*\)\].*/\1/' || echo "PENDING")
+
+if [ "$PLAN_GATE_STATUS" != "COMPLETED" ]; then
+    log "WARNING: Implementation plan constitutional gates not completed. Task generation may be premature."
+fi
+
+# Calculate completion percentage
+if [ "$TOTAL_TASKS" -gt 0 ]; then
+    COMPLETION_PERCENTAGE=$((COMPLETED_TASKS * 100 / TOTAL_TASKS))
+else
+    COMPLETION_PERCENTAGE=0
 fi
 
-# Count tasks
-TASK_COUNT=$(grep -c "^- \[" "$TASK_FILE" 2>/dev/null || echo "0")
+log "Task analysis completed - Total: $TOTAL_TASKS, Completed: $COMPLETED_TASKS ($COMPLETION_PERCENTAGE%), Parallel: $PARALLEL_TASKS"
 
+# Output comprehensive status
 echo "TASK_FILE=$TASK_FILE"
-echo "TASK_COUNT=$TASK_COUNT"
+echo "SPEC_FILE=$SPEC_FILE"
+echo "PLAN_FILE=$PLAN_FILE"
+echo "TOTAL_TASKS=$TOTAL_TASKS"
+echo "COMPLETED_TASKS=$COMPLETED_TASKS"
+echo "PENDING_TASKS=$PENDING_TASKS"
+echo "BLOCKED_TASKS=$BLOCKED_TASKS"
+echo "PARALLEL_TASKS=$PARALLEL_TASKS"
+echo "CONSTITUTIONAL_GATES_PENDING=$GATES_COUNT"
+echo "COMPLETION_PERCENTAGE=$COMPLETION_PERCENTAGE"
+echo "MISSING_SECTIONS=${#MISSING_SECTIONS[@]}"
 echo "STATUS=generated"