@e0ipso/ai-task-manager 1.3.0 → 1.5.0

package/templates/ai-task-manager/config/scripts/check-task-dependencies.js

@@ -0,0 +1,332 @@
+#!/usr/bin/env node
+
+/**
+ * Script: check-task-dependencies.js
+ * Purpose: Check if a task has all of its dependencies resolved (completed)
+ * Usage: node check-task-dependencies.js <plan-id> <task-id>
+ * Returns: 0 if all dependencies are resolved, 1 if not
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+const { execSync } = require('child_process');
+
+// Chalk instance - loaded dynamically to handle ESM module
+let chalkInstance = null;
+
+// Initialize chalk instance dynamically
+async function initChalk() {
+    if (chalkInstance) return chalkInstance;
+    
+    try {
+        const { default: chalk } = await import('chalk');
+        chalkInstance = chalk;
+    } catch (_error) {
+        // Chalk not available, will fall back to plain console output
+        chalkInstance = null;
+    }
+    
+    return chalkInstance;
+}
+
+// Color functions for output
+const printError = (message, chalk) => {
+    const formattedMessage = chalk?.red(`ERROR: ${message}`) || `ERROR: ${message}`;
+    console.error(formattedMessage);
+};
+
+const printSuccess = (message, chalk) => {
+    const formattedMessage = chalk?.green(`✓ ${message}`) || `✓ ${message}`;
+    console.log(formattedMessage);
+};
+
+const printWarning = (message, chalk) => {
+    const formattedMessage = chalk?.yellow(`⚠ ${message}`) || `⚠ ${message}`;
+    console.log(formattedMessage);
+};
+
+const printInfo = (message) => {
+    console.log(message);
+};
+
+// Function to find plan directory
+const findPlanDirectory = (planId) => {
+    try {
+        // Use find command similar to bash script
+        const findCommand = `find .ai/task-manager/plans .ai/task-manager/archive -type d -name "${planId}--*" 2>/dev/null || true`;
+        const result = execSync(findCommand, { encoding: 'utf8' }).trim();
+        const directories = result.split('\n').filter(dir => dir.length > 0);
+        return directories.length > 0 ? directories[0] : null;
+    } catch (error) {
+        return null;
+    }
+};
+
+// Function to find task file with padded/unpadded ID handling
+const findTaskFile = (planDir, taskId) => {
+    const taskDir = path.join(planDir, 'tasks');
+    
+    if (!fs.existsSync(taskDir)) {
+        return null;
+    }
+
+    // Try exact match first
+    let pattern = `${taskId}--*.md`;
+    let files = fs.readdirSync(taskDir).filter(file => {
+        const regex = new RegExp(`^${taskId}--.*\\.md$`);
+        return regex.test(file);
+    });
+    
+    if (files.length > 0) {
+        return path.join(taskDir, files[0]);
+    }
+
+    // Try with zero-padding if direct match fails
+    const paddedTaskId = taskId.padStart(2, '0');
+    if (paddedTaskId !== taskId) {
+        pattern = `${paddedTaskId}--*.md`;
+        files = fs.readdirSync(taskDir).filter(file => {
+            const regex = new RegExp(`^${paddedTaskId}--.*\\.md$`);
+            return regex.test(file);
+        });
+        
+        if (files.length > 0) {
+            return path.join(taskDir, files[0]);
+        }
+    }
+
+    // Try removing potential zero-padding from taskId
+    const unpaddedTaskId = taskId.replace(/^0+/, '') || '0';
+    if (unpaddedTaskId !== taskId) {
+        pattern = `${unpaddedTaskId}--*.md`;
+        files = fs.readdirSync(taskDir).filter(file => {
+            const regex = new RegExp(`^${unpaddedTaskId}--.*\\.md$`);
+            return regex.test(file);
+        });
+        
+        if (files.length > 0) {
+            return path.join(taskDir, files[0]);
+        }
+
+        // Try with zero-padding of unpadded version
+        const repaddedTaskId = unpaddedTaskId.padStart(2, '0');
+        pattern = `${repaddedTaskId}--*.md`;
+        files = fs.readdirSync(taskDir).filter(file => {
+            const regex = new RegExp(`^${repaddedTaskId}--.*\\.md$`);
+            return regex.test(file);
+        });
+        
+        if (files.length > 0) {
+            return path.join(taskDir, files[0]);
+        }
+    }
+
+    return null;
+};
+
+// Function to parse YAML frontmatter
+const parseFrontmatter = (content) => {
+    const lines = content.split('\n');
+    let inFrontmatter = false;
+    let frontmatterEnd = false;
+    let delimiterCount = 0;
+    const frontmatterLines = [];
+
+    for (const line of lines) {
+        if (line.trim() === '---') {
+            delimiterCount++;
+            if (delimiterCount === 1) {
+                inFrontmatter = true;
+                continue;
+            } else if (delimiterCount === 2) {
+                frontmatterEnd = true;
+                break;
+            }
+        }
+        
+        if (inFrontmatter && !frontmatterEnd) {
+            frontmatterLines.push(line);
+        }
+    }
+
+    return frontmatterLines.join('\n');
+};
+
+// Function to extract dependencies from frontmatter
+const extractDependencies = (frontmatter) => {
+    const lines = frontmatter.split('\n');
+    const dependencies = [];
+    let inDependenciesSection = false;
+
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        
+        // Check for dependencies line
+        if (line.match(/^dependencies:/)) {
+            inDependenciesSection = true;
+            
+            // Check if dependencies are on the same line (array syntax)
+            const arrayMatch = line.match(/\[(.*)\]/);
+            if (arrayMatch) {
+                const deps = arrayMatch[1]
+                    .split(',')
+                    .map(dep => dep.trim().replace(/['"]/g, ''))
+                    .filter(dep => dep.length > 0);
+                dependencies.push(...deps);
+                inDependenciesSection = false;
+            }
+            continue;
+        }
+
+        // If we're in dependencies section and hit a non-indented line that's not a list item, exit
+        if (inDependenciesSection && line.match(/^[^ ]/) && !line.match(/^[ \t]*-/)) {
+            inDependenciesSection = false;
+        }
+
+        // Parse list format dependencies
+        if (inDependenciesSection && line.match(/^[ \t]*-/)) {
+            const dep = line.replace(/^[ \t]*-[ \t]*/, '').replace(/[ \t]*$/, '').replace(/['"]/g, '');
+            if (dep.length > 0) {
+                dependencies.push(dep);
+            }
+        }
+    }
+
+    return dependencies;
+};
+
+// Function to extract status from frontmatter
+const extractStatus = (frontmatter) => {
+    const lines = frontmatter.split('\n');
+    
+    for (const line of lines) {
+        if (line.match(/^status:/)) {
+            return line.replace(/^status:[ \t]*/, '').replace(/^["']/, '').replace(/["']$/, '').trim();
+        }
+    }
+    
+    return null;
+};
+
+// Main function
+const main = async () => {
+    // Initialize chalk
+    const chalk = await initChalk();
+    
+    // Check arguments
+    if (process.argv.length !== 4) {
+        printError('Invalid number of arguments', chalk);
+        console.log('Usage: node check-task-dependencies.js <plan-id> <task-id>');
+        console.log('Example: node check-task-dependencies.js 16 03');
+        process.exit(1);
+    }
+
+    const planId = process.argv[2];
+    const taskId = process.argv[3];
+
+    // Find the plan directory
+    const planDir = findPlanDirectory(planId);
+    
+    if (!planDir) {
+        printError(`Plan with ID ${planId} not found`, chalk);
+        process.exit(1);
+    }
+
+    printInfo(`Found plan directory: ${planDir}`);
+
+    // Find task file
+    const taskFile = findTaskFile(planDir, taskId);
+
+    if (!taskFile || !fs.existsSync(taskFile)) {
+        printError(`Task with ID ${taskId} not found in plan ${planId}`, chalk);
+        process.exit(1);
+    }
+
+    printInfo(`Checking task: ${path.basename(taskFile)}`);
+    console.log('');
+
+    // Read and parse task file
+    const taskContent = fs.readFileSync(taskFile, 'utf8');
+    const frontmatter = parseFrontmatter(taskContent);
+    const dependencies = extractDependencies(frontmatter);
+
+    // Check if there are any dependencies
+    if (dependencies.length === 0) {
+        printSuccess('Task has no dependencies - ready to execute!', chalk);
+        process.exit(0);
+    }
+
+    // Display dependencies
+    printInfo('Task dependencies found:');
+    dependencies.forEach(dep => {
+        console.log(`  - Task ${dep}`);
+    });
+    console.log('');
+
+    // Check each dependency
+    let allResolved = true;
+    let unresolvedDeps = [];
+    let resolvedCount = 0;
+    const totalDeps = dependencies.length;
+
+    printInfo('Checking dependency status...');
+    console.log('');
+
+    for (const depId of dependencies) {
+        // Find dependency task file
+        const depFile = findTaskFile(planDir, depId);
+
+        if (!depFile || !fs.existsSync(depFile)) {
+            printError(`Dependency task ${depId} not found`, chalk);
+            allResolved = false;
+            unresolvedDeps.push(`${depId} (not found)`);
+            continue;
+        }
+
+        // Extract status from dependency task
+        const depContent = fs.readFileSync(depFile, 'utf8');
+        const depFrontmatter = parseFrontmatter(depContent);
+        const status = extractStatus(depFrontmatter);
+
+        // Check if status is completed
+        if (status === 'completed') {
+            printSuccess(`Task ${depId} - Status: completed ✓`, chalk);
+            resolvedCount++;
+        } else {
+            printWarning(`Task ${depId} - Status: ${status || 'unknown'} ✗`, chalk);
+            allResolved = false;
+            unresolvedDeps.push(`${depId} (${status || 'unknown'})`);
+        }
+    }
+
+    console.log('');
+    printInfo('=========================================');
+    printInfo('Dependency Check Summary');
+    printInfo('=========================================');
+    printInfo(`Total dependencies: ${totalDeps}`);
+    printInfo(`Resolved: ${resolvedCount}`);
+    printInfo(`Unresolved: ${totalDeps - resolvedCount}`);
+    console.log('');
+
+    if (allResolved) {
+        printSuccess(`All dependencies are resolved! Task ${taskId} is ready to execute.`, chalk);
+        process.exit(0);
+    } else {
+        printError(`Task ${taskId} has unresolved dependencies:`, chalk);
+        unresolvedDeps.forEach(dep => {
+            console.log(dep);
+        });
+        printInfo('Please complete the dependencies before executing this task.');
+        process.exit(1);
+    }
+};
+
+// Run the script
+if (require.main === module) {
+    main().catch((error) => {
+        console.error('Script execution failed:', error);
+        process.exit(1);
+    });
+}
+
+module.exports = { main };

package/templates/assistant/commands/tasks/execute-blueprint.md

@@ -37,7 +37,7 @@ Before starting execution check if you are in the `main` branch. If so, create a
         ```bash
         # For each task in current phase
         for TASK_ID in $PHASE_TASKS; do
-            if ! @templates/ai-task-manager/config/scripts/check-task-dependencies.sh "$1" "$TASK_ID"; then
+            if ! node .ai/task-manager/config/scripts/check-task-dependencies.js "$1" "$TASK_ID"; then
                 echo "ERROR: Task $TASK_ID has unresolved dependencies - cannot proceed with phase execution"
                 echo "Please resolve dependencies before continuing with blueprint execution"
                 exit 1

package/templates/assistant/commands/tasks/execute-task.md

@@ -16,9 +16,9 @@ You are responsible for executing a single task within a plan while maintaining
 
 ## Input Requirements
 - Plan ID: $1 (required)
-- Task ID: $2 (required)  
+- Task ID: $2 (required)
 - Task management directory structure: `@.ai/task-manager/`
-- Dependency checking script: `@templates/ai-task-manager/config/scripts/check-task-dependencies.sh`
+- Dependency checking script: `.ai/task-manager/config/scripts/check-task-dependencies.js`
 
 ### Input Validation
 
@@ -87,7 +87,7 @@ Check current task status to ensure it can be executed:
 # Extract current status from task frontmatter
 CURRENT_STATUS=$(awk '
     /^---$/ { if (++delim == 2) exit }
-    /^status:/ { 
+    /^status:/ {
         gsub(/^status:[ \t]*/, "")
         gsub(/^["'\'']/, "")
         gsub(/["'\'']$/, "")
@@ -125,7 +125,7 @@ Use the dependency checking script to validate all dependencies:
 
 ```bash
 # Call the dependency checking script
-if ! @templates/ai-task-manager/config/scripts/check-task-dependencies.sh "$PLAN_ID" "$TASK_ID"; then
+if ! node .ai/task-manager/config/scripts/check-task-dependencies.js "$PLAN_ID" "$TASK_ID"; then
     echo ""
     echo "Task execution blocked by unresolved dependencies."
     echo "Please complete the required dependencies first."
@@ -144,7 +144,7 @@ Read task skills and select appropriate task-specific agent:
 # Extract skills from task frontmatter
 TASK_SKILLS=$(awk '
     /^---$/ { if (++delim == 2) exit }
-    /^skills:/ { 
+    /^skills:/ {
         in_skills = 1
         # Check if skills are on the same line
         if (match($0, /\[.*\]/)) {
@@ -191,7 +191,7 @@ echo "Updating task status to in-progress..."
 # Create temporary file with updated status
 TEMP_FILE=$(mktemp)
 awk '
-    /^---$/ { 
+    /^---$/ {
         if (++delim == 1) {
             print
             next
@@ -201,9 +201,9 @@ awk '
             next
         }
     }
-    /^status:/ && delim == 1 { 
+    /^status:/ && delim == 1 {
         print "status: \"in-progress\""
-        next 
+        next
     }
     { print }
 ' "$TASK_FILE" > "$TEMP_FILE"
@@ -220,7 +220,7 @@ Deploy the task using the Task tool with full context:
 
 **Task Deployment**: Use your internal Task tool to execute the task with the following context:
 - Task file path: `$TASK_FILE`
-- Plan directory: `$PLAN_DIR` 
+- Plan directory: `$PLAN_DIR`
 - Required skills: `$TASK_SKILLS`
 - Agent selection: Based on skills analysis or general-purpose agent
 
@@ -236,7 +236,7 @@ After task completion, update the status based on execution outcome:
 ```bash
 TEMP_FILE=$(mktemp)
 awk '
-    /^---$/ { 
+    /^---$/ {
         if (++delim == 1) {
             print
             next
@@ -246,9 +246,9 @@ awk '
             next
         }
     }
-    /^status:/ && delim == 1 { 
+    /^status:/ && delim == 1 {
         print "status: \"completed\""
-        next 
+        next
     }
     { print }
 ' "$TASK_FILE" > "$TEMP_FILE"
@@ -270,7 +270,7 @@ echo "Task execution failed - updating status..."
 
 TEMP_FILE=$(mktemp)
 awk '
-    /^---$/ { 
+    /^---$/ {
         if (++delim == 1) {
             print
             next
@@ -280,9 +280,9 @@ awk '
             next
         }
     }
-    /^status:/ && delim == 1 { 
+    /^status:/ && delim == 1 {
         print "status: \"failed\""
-        next 
+        next
     }
     { print }
 ' "$TASK_FILE" > "$TEMP_FILE"
@@ -312,7 +312,7 @@ exit 1
 This command integrates with the existing task management system by:
 - Using established plan and task location patterns
 - Leveraging the dependency checking script for validation
-- Following status management conventions 
+- Following status management conventions
 - Maintaining compatibility with execute-blueprint workflows
 - Preserving task isolation and dependency order
 

package/templates/ai-task-manager/config/scripts/check-task-dependencies.sh

@@ -1,185 +0,0 @@
-#!/bin/bash
-
-# Script: check-task-dependencies.sh
-# Purpose: Check if a task has all of its dependencies resolved (completed)
-# Usage: ./check-task-dependencies.sh <plan-id> <task-id>
-# Returns: 0 if all dependencies are resolved, 1 if not
-
-set -e
-
-# Color codes for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-NC='\033[0m' # No Color
-
-# Function to print colored output
-print_error() {
-    echo -e "${RED}ERROR: $1${NC}" >&2
-}
-
-print_success() {
-    echo -e "${GREEN}✓ $1${NC}"
-}
-
-print_warning() {
-    echo -e "${YELLOW}⚠ $1${NC}"
-}
-
-print_info() {
-    echo -e "$1"
-}
-
-# Check arguments
-if [ $# -ne 2 ]; then
-    print_error "Invalid number of arguments"
-    echo "Usage: $0 <plan-id> <task-id>"
-    echo "Example: $0 16 03"
-    exit 1
-fi
-
-PLAN_ID="$1"
-TASK_ID="$2"
-
-# Find the plan directory
-PLAN_DIR=$(find .ai/task-manager/{plans,archive} -type d -name "${PLAN_ID}--*" 2>/dev/null | head -1)
-
-if [ -z "$PLAN_DIR" ]; then
-    print_error "Plan with ID ${PLAN_ID} not found"
-    exit 1
-fi
-
-print_info "Found plan directory: ${PLAN_DIR}"
-
-# Construct task file path
-# Handle both padded (01, 02) and unpadded (1, 2) task IDs
-TASK_FILE=""
-if [ -f "${PLAN_DIR}/tasks/${TASK_ID}--"*.md ]; then
-    TASK_FILE=$(ls "${PLAN_DIR}/tasks/${TASK_ID}--"*.md 2>/dev/null | head -1)
-elif [ -f "${PLAN_DIR}/tasks/0${TASK_ID}--"*.md ]; then
-    # Try with zero-padding if direct match fails
-    TASK_FILE=$(ls "${PLAN_DIR}/tasks/0${TASK_ID}--"*.md 2>/dev/null | head -1)
-fi
-
-if [ -z "$TASK_FILE" ] || [ ! -f "$TASK_FILE" ]; then
-    print_error "Task with ID ${TASK_ID} not found in plan ${PLAN_ID}"
-    exit 1
-fi
-
-print_info "Checking task: $(basename "$TASK_FILE")"
-echo ""
-
-# Extract dependencies from task frontmatter
-# Using awk to parse YAML frontmatter
-DEPENDENCIES=$(awk '
-    /^---$/ { if (++delim == 2) exit }
-    /^dependencies:/ { 
-        dep_section = 1
-        # Check if dependencies are on the same line
-        if (match($0, /\[.*\]/)) {
-            gsub(/^dependencies:[ \t]*\[/, "")
-            gsub(/\].*$/, "")
-            gsub(/[ \t]/, "")
-            print
-            dep_section = 0
-        }
-        next
-    }
-    dep_section && /^[^ ]/ { dep_section = 0 }
-    dep_section && /^[ \t]*-/ {
-        gsub(/^[ \t]*-[ \t]*/, "")
-        gsub(/[ \t]*$/, "")
-        print
-    }
-' "$TASK_FILE" | tr ',' '\n' | sed 's/^[ \t]*//;s/[ \t]*$//' | grep -v '^$')
-
-# Check if there are any dependencies
-if [ -z "$DEPENDENCIES" ]; then
-    print_success "Task has no dependencies - ready to execute!"
-    exit 0
-fi
-
-# Display dependencies
-print_info "Task dependencies found:"
-echo "$DEPENDENCIES" | while read -r dep; do
-    echo "  - Task ${dep}"
-done
-echo ""
-
-# Check each dependency
-ALL_RESOLVED=true
-UNRESOLVED_DEPS=""
-RESOLVED_COUNT=0
-TOTAL_DEPS=$(echo "$DEPENDENCIES" | wc -l)
-
-print_info "Checking dependency status..."
-echo ""
-
-for DEP_ID in $DEPENDENCIES; do
-    # Find dependency task file
-    DEP_FILE=""
-    
-    # Try exact match first
-    if [ -f "${PLAN_DIR}/tasks/${DEP_ID}--"*.md ]; then
-        DEP_FILE=$(ls "${PLAN_DIR}/tasks/${DEP_ID}--"*.md 2>/dev/null | head -1)
-    elif [ -f "${PLAN_DIR}/tasks/0${DEP_ID}--"*.md ]; then
-        # Try with zero-padding
-        DEP_FILE=$(ls "${PLAN_DIR}/tasks/0${DEP_ID}--"*.md 2>/dev/null | head -1)
-    else
-        # Try removing potential zero-padding from DEP_ID
-        UNPADDED_DEP=$(echo "$DEP_ID" | sed 's/^0*//')
-        if [ -f "${PLAN_DIR}/tasks/${UNPADDED_DEP}--"*.md ]; then
-            DEP_FILE=$(ls "${PLAN_DIR}/tasks/${UNPADDED_DEP}--"*.md 2>/dev/null | head -1)
-        elif [ -f "${PLAN_DIR}/tasks/0${UNPADDED_DEP}--"*.md ]; then
-            DEP_FILE=$(ls "${PLAN_DIR}/tasks/0${UNPADDED_DEP}--"*.md 2>/dev/null | head -1)
-        fi
-    fi
-    
-    if [ -z "$DEP_FILE" ] || [ ! -f "$DEP_FILE" ]; then
-        print_error "Dependency task ${DEP_ID} not found"
-        ALL_RESOLVED=false
-        UNRESOLVED_DEPS="${UNRESOLVED_DEPS}${DEP_ID} (not found)\n"
-        continue
-    fi
-    
-    # Extract status from dependency task
-    STATUS=$(awk '
-        /^---$/ { if (++delim == 2) exit }
-        /^status:/ { 
-            gsub(/^status:[ \t]*/, "")
-            gsub(/^["'\'']/, "")
-            gsub(/["'\'']$/, "")
-            print
-            exit
-        }
-    ' "$DEP_FILE")
-    
-    # Check if status is completed
-    if [ "$STATUS" = "completed" ]; then
-        print_success "Task ${DEP_ID} - Status: completed ✓"
-        ((RESOLVED_COUNT++))
-    else
-        print_warning "Task ${DEP_ID} - Status: ${STATUS:-unknown} ✗"
-        ALL_RESOLVED=false
-        UNRESOLVED_DEPS="${UNRESOLVED_DEPS}${DEP_ID} (${STATUS:-unknown})\n"
-    fi
-done
-
-echo ""
-print_info "========================================="
-print_info "Dependency Check Summary"
-print_info "========================================="
-print_info "Total dependencies: ${TOTAL_DEPS}"
-print_info "Resolved: ${RESOLVED_COUNT}"
-print_info "Unresolved: $((TOTAL_DEPS - RESOLVED_COUNT))"
-echo ""
-
-if [ "$ALL_RESOLVED" = true ]; then
-    print_success "All dependencies are resolved! Task ${TASK_ID} is ready to execute."
-    exit 0
-else
-    print_error "Task ${TASK_ID} has unresolved dependencies:"
-    echo -e "$UNRESOLVED_DEPS"
-    print_info "Please complete the dependencies before executing this task."
-    exit 1
-fi