@e0ipso/ai-task-manager 1.26.3 → 1.26.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@e0ipso/ai-task-manager",
-  "version": "1.26.3",
+  "version": "1.26.4",
   "description": "Task management for AI coding assistants",
   "main": "dist/index.js",
   "bin": {

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

@@ -9,323 +9,261 @@
 
 const fs = require('fs-extra');
 const path = require('path');
-const { execSync } = require('child_process');
-const { parseFrontmatter } = require('./shared-utils.cjs');
+const {
+  resolvePlan,
+  parseFrontmatter
+} = require('./shared-utils.cjs');
 
 // 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;
+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 _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 _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 _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) => {
-    const searchLocations = [
-        '.ai/task-manager/plans',
-        '.ai/task-manager/archive'
-    ];
-
-    // Generate ID variations to try (exact, padded, unpadded)
-    const idVariations = [
-        planId,                           // Try exact match first
-        planId.padStart(2, '0'),          // Try padded version (3 → 03)
-        planId.replace(/^0+/, '') || '0'  // Try unpadded version (03 → 3)
-    ];
-
-    // Remove duplicates from variations array
-    const uniqueVariations = [...new Set(idVariations)];
-
-    // Search for each variation in each location
-    for (const id of uniqueVariations) {
-        for (const location of searchLocations) {
-            try {
-                const findCommand = `find ${location} -type d -name "${id}--*" 2>/dev/null || true`;
-                const result = execSync(findCommand, { encoding: 'utf8' }).trim();
-                const directories = result.split('\n').filter(dir => dir.length > 0);
-
-                if (directories.length > 0) {
-                    return directories[0]; // Early return on first match
-                }
-            } catch (error) {
-                // Continue trying other variations/locations
-                continue;
-            }
-        }
-    }
-
-    return null; // No matches found
+const _printInfo = (message) => {
+  console.log(message);
 };
 
 // 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;
-    }
+const _findTaskFile = (planDir, taskId) => {
+  const taskDir = path.join(planDir, 'tasks');
 
-    // 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 (!fs.existsSync(taskDir)) {
+    return null;
+  }
+
+  const variations = [
+    taskId,
+    taskId.padStart(2, '0'),
+    taskId.replace(/^0+/, '') || '0'
+  ];
+
+  const uniqueVariations = [...new Set(variations)];
+
+  try {
+    const files = fs.readdirSync(taskDir);
+    const found = uniqueVariations.reduce((acc, v) => {
+      if (acc) return acc;
+      const match = files.find(f => f.startsWith(`${v}--`) && f.endsWith('.md'));
+      return match ? path.join(taskDir, match) : null;
+    }, null);
+    return found;
+  } catch (err) {
+    return null;
+  }
+};
 
-    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]);
-        }
+// 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;
     }
 
-    // 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]);
-        }
+    // 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;
     }
 
-    return null;
-};
-
-
-// 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);
-            }
-        }
+    // 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;
+  return dependencies;
 };
 
 // Function to extract status from frontmatter
-const extractStatus = (frontmatter) => {
-    const lines = frontmatter.split('\n');
+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();
-        }
+  for (const line of lines) {
+    if (line.match(/^status:/)) {
+      return line.replace(/^status:[ \t]*/, '').replace(/^["']/, '').replace(/["']$/, '').trim();
     }
+  }
 
-    return null;
+  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.cjs <plan-id> <task-id>');
-        console.log('Example: node check-task-dependencies.cjs 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);
+const _main = async (startPath = process.cwd()) => {
+  // 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.cjs <plan-id-or-path> <task-id>');
+    console.log('Example: node check-task-dependencies.cjs 16 03');
+    process.exit(1);
+  }
+
+  const inputId = process.argv[2];
+  const taskId = process.argv[3];
+
+  const resolved = resolvePlan(inputId, startPath);
+
+  if (!resolved) {
+    _printError(`Plan "${inputId}" not found or invalid`, chalk);
+    process.exit(1);
+  }
+
+  const {
+    planDir,
+    planId
+  } = resolved;
+  _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;
     }
 
-    printInfo(`Checking task: ${path.basename(taskFile)}`);
-    console.log('');
+    // Extract status from dependency task
+    const depContent = fs.readFileSync(depFile, 'utf8');
+    const depFrontmatter = parseFrontmatter(depContent);
+    const status = _extractStatus(depFrontmatter);
 
-    // 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);
+    // Check if status is completed
+    if (status === 'completed') {
+      _printSuccess(`Task ${depId} - Status: completed ✓`, chalk);
+      resolvedCount++;
     } 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);
+      _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);
-    });
+  _main().catch((error) => {
+    console.error('Script execution failed:', error);
+    process.exit(1);
+  });
 }
 
-module.exports = { main };
+module.exports = {
+  _main
+};

package/templates/ai-task-manager/config/scripts/find-root.cjs

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+
+const { findTaskManagerRoot } = require('./shared-utils.cjs');
+
+try {
+  const root = findTaskManagerRoot();
+  process.exit(root ? 0 : 1);
+} catch (err) {
+  process.exit(1);
+}

package/templates/ai-task-manager/config/scripts/get-next-plan-id.cjs

@@ -2,85 +2,48 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findTaskManagerRoot, extractIdFromFrontmatter } = require('./shared-utils.cjs');
+const { findTaskManagerRoot, getAllPlans } = require('./shared-utils.cjs');
 
 /**
  * Error logging utility
+ * @private
  * @param {string} message - Error message
  * @param {...any} args - Additional arguments to log
  */
-function errorLog(message, ...args) {
+function _errorLog(message, ...args) {
   console.error(`[ERROR] ${message}`, ...args);
 }
 
 /**
  * Get the next available plan ID by scanning existing plan files
+ * @private
  * @returns {number} Next available plan ID
  */
-function getNextPlanId() {
+function _getNextPlanId() {
   const taskManagerRoot = findTaskManagerRoot();
 
   if (!taskManagerRoot) {
-    errorLog('No .ai/task-manager/plans directory found in current directory or any parent directory.');
-    errorLog('');
-    errorLog('Please ensure you are in a project with task manager initialized, or navigate to the correct');
-    errorLog('project directory. The task manager looks for the .ai/task-manager/plans structure starting');
-    errorLog('from the current working directory and traversing upward through parent directories.');
-    errorLog('');
-    errorLog(`Current working directory: ${process.cwd()}`);
+    _errorLog('No .ai/task-manager/plans directory found in current directory or any parent directory.');
+    _errorLog('');
+    _errorLog('Please ensure you are in a project with task manager initialized, or navigate to the correct');
+    _errorLog('project directory. The task manager looks for the .ai/task-manager/plans structure starting');
+    _errorLog('from the current working directory and traversing upward through parent directories.');
+    _errorLog('');
+    _errorLog(`Current working directory: ${process.cwd()}`);
     process.exit(1);
   }
 
-  const plansDir = path.join(taskManagerRoot, 'plans');
-  const archiveDir = path.join(taskManagerRoot, 'archive');
-
-  let maxId = 0;
-
-  // Scan both plans and archive directories
-  [plansDir, archiveDir].forEach(dir => {
-    if (!fs.existsSync(dir)) {
-      return;
-    }
-
-    try {
-      const entries = fs.readdirSync(dir, { withFileTypes: true });
-
-      entries.forEach(entry => {
-        if (entry.isDirectory() && entry.name.match(/^\d+--/)) {
-          // This is a plan directory, look for plan files inside
-          const planDirPath = path.join(dir, entry.name);
-
-          try {
-            const planDirEntries = fs.readdirSync(planDirPath, { withFileTypes: true });
-
-            planDirEntries.forEach(planEntry => {
-              if (planEntry.isFile() && planEntry.name.match(/^plan-\d+--.*\.md$/)) {
-                const filePath = path.join(planDirPath, planEntry.name);
-
-                try {
-                  const content = fs.readFileSync(filePath, 'utf8');
-                  const frontmatterId = extractIdFromFrontmatter(content, filePath);
-
-                  if (frontmatterId !== null && frontmatterId > maxId) {
-                    maxId = frontmatterId;
-                  }
-                } catch (err) {
-                  errorLog(`Failed to read file ${filePath}: ${err.message}`);
-                }
-              }
-            });
-          } catch (err) {
-            errorLog(`Failed to read plan directory ${planDirPath}: ${err.message}`);
-          }
-        }
-      });
-    } catch (err) {
-      errorLog(`Failed to read directory ${dir}: ${err.message}`);
-    }
-  });
+  const plans = getAllPlans(taskManagerRoot);
+  const maxId = plans.reduce((max, p) => Math.max(max, p.id), 0);
 
   return maxId + 1;
 }
 
-// Output the next plan ID
-console.log(getNextPlanId());
+// Output the next plan ID if run directly
+if (require.main === module) {
+  console.log(_getNextPlanId());
+}
+
+module.exports = {
+  _getNextPlanId
+};