@e0ipso/ai-task-manager 1.26.3 → 1.26.5

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

@@ -2,71 +2,46 @@
 
 const fs = require('fs');
 const path = require('path');
-const { findTaskManagerRoot, extractIdFromFrontmatter } = require('./shared-utils.cjs');
+const {
+  resolvePlan,
+  extractIdFromFrontmatter
+} = require('./shared-utils.cjs');
 
 /**
  * Get the next available task ID for a specific plan
- * @param {number|string} planId - The plan ID to get next task ID for
+ * @private
+ * @param {number|string} inputId - The plan ID or path to get next task ID for
  * @returns {number} Next available task ID
  */
-function getNextTaskId(planId) {
-  if (!planId) {
-    console.error('Error: Plan ID is required');
+function _getNextTaskId(inputId) {
+  if (!inputId) {
+    console.error('Error: Plan ID or path is required');
     process.exit(1);
   }
 
-  const taskManagerRoot = findTaskManagerRoot();
+  const resolved = resolvePlan(inputId);
 
-  if (!taskManagerRoot) {
-    console.error('Error: No .ai/task-manager/plans directory found in current directory or any parent directory.');
-    console.error('Please ensure you are in a project with task manager initialized.');
+  if (!resolved) {
+    console.error(`Error: Plan "${inputId}" not found or invalid.`);
     process.exit(1);
   }
 
-  const plansDir = path.join(taskManagerRoot, 'plans');
-
-  // Find the plan directory (supports both padded and unpadded formats)
-  const paddedPlanId = String(planId).padStart(2, '0');
-
-  let planDir = null;
-
-  // Optimization: 90% of the time there are no tasks, so check if plans directory exists first
-  if (!fs.existsSync(plansDir)) {
-    return 1; // No plans directory = no tasks = start with ID 1
-  }
-
-  try {
-    const entries = fs.readdirSync(plansDir, { withFileTypes: true });
-
-    // Look for directory matching the plan ID pattern
-    for (const entry of entries) {
-      if (entry.isDirectory()) {
-        const match = entry.name.match(/^(\d+)--/);
-        if (match) {
-          const dirPlanId = match[1].padStart(2, '0');
-          if (dirPlanId === paddedPlanId) {
-            const tasksPath = path.join(plansDir, entry.name, 'tasks');
-            if (fs.existsSync(tasksPath)) {
-              planDir = tasksPath;
-            }
-            break;
-          }
-        }
-      }
-    }
-  } catch (err) {
-    // Directory doesn't exist or can't be read
-  }
+  const {
+    planDir
+  } = resolved;
+  const tasksPath = path.join(planDir, 'tasks');
 
   // Optimization: If no tasks directory exists, return 1 immediately (90% case)
-  if (!planDir) {
+  if (!fs.existsSync(tasksPath)) {
     return 1;
   }
 
   let maxId = 0;
 
   try {
-    const entries = fs.readdirSync(planDir, { withFileTypes: true });
+    const entries = fs.readdirSync(tasksPath, {
+      withFileTypes: true
+    });
 
     // Another optimization: If directory is empty, return 1 immediately
     if (entries.length === 0) {
@@ -76,7 +51,7 @@ function getNextTaskId(planId) {
     entries.forEach(entry => {
       if (entry.isFile() && entry.name.endsWith('.md')) {
         try {
-          const filePath = path.join(planDir, entry.name);
+          const filePath = path.join(tasksPath, entry.name);
           const content = fs.readFileSync(filePath, 'utf8');
           const id = extractIdFromFrontmatter(content);
 
@@ -96,5 +71,11 @@ function getNextTaskId(planId) {
 }
 
 // Get plan ID from command line argument
-const planId = process.argv[2];
-console.log(getNextTaskId(planId));
+if (require.main === module) {
+  const inputId = process.argv[2];
+  console.log(_getNextTaskId(inputId));
+}
+
+module.exports = {
+  _getNextTaskId
+};

package/templates/ai-task-manager/config/scripts/shared-utils.cjs

@@ -4,61 +4,90 @@ const fs = require('fs');
 const path = require('path');
 
 /**
- * Find the task manager root directory by traversing up from current working directory
- * @returns {string|null} Path to task manager root or null if not found
+ * Validate that a task manager root is correctly initialized
+ * @internal
+ * @param {string} taskManagerPath - Path to .ai/task-manager
+ * @returns {boolean} True if root is valid, false otherwise
  */
-function findTaskManagerRoot() {
-  let currentPath = process.cwd();
-  const filesystemRoot = path.parse(currentPath).root;
+function isValidTaskManagerRoot(taskManagerPath) {
+  try {
+    if (!fs.existsSync(taskManagerPath)) return false;
+    if (!fs.lstatSync(taskManagerPath).isDirectory()) return false;
 
-  // Traverse upward through parent directories until we reach the filesystem root
-  while (currentPath !== filesystemRoot) {
-    const taskManagerPlansPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    // Must contain .init-metadata.json with valid version prop
+    const metadataPath = path.join(taskManagerPath, '.init-metadata.json');
+    if (!fs.existsSync(metadataPath)) return false;
 
-    try {
-      // Check if this is a valid task manager directory
-      if (fs.existsSync(taskManagerPlansPath)) {
-        // Verify it's a directory, not a file
-        const stats = fs.lstatSync(taskManagerPlansPath);
-        if (stats.isDirectory()) {
-          const taskManagerRoot = path.join(currentPath, '.ai', 'task-manager');
-          return taskManagerRoot;
-        }
-      }
-    } catch (err) {
-      // Handle permission errors or other filesystem issues gracefully
-      // Continue searching in parent directories
-      if (err.code === 'EPERM' || err.code === 'EACCES') {
-        // Silently continue - permission errors are expected in some directories
-      }
-    }
+    const metadataContent = fs.readFileSync(metadataPath, 'utf8');
+    const metadata = JSON.parse(metadataContent);
 
-    // Move up to parent directory
-    const parentPath = path.dirname(currentPath);
+    return metadata && typeof metadata === 'object' && 'version' in metadata;
+  } catch (err) {
+    return false;
+  }
+}
 
-    // Safety check: if path.dirname returns the same path, we've reached the root
-    if (parentPath === currentPath) {
-      break;
-    }
+/**
+ * Check if a directory contains a valid task manager root
+ * @internal
+ * @param {string} directory - Directory to check
+ * @returns {string|null} Task manager path if valid, otherwise null
+ */
+function getTaskManagerAt(directory) {
+  const taskManagerPath = path.join(directory, '.ai', 'task-manager');
+  return isValidTaskManagerRoot(taskManagerPath) ? taskManagerPath : null;
+}
 
-    currentPath = parentPath;
-  }
+/**
+ * Get all parent directories from a start path up to the filesystem root (recursive)
+ * @private
+ * @param {string} currentPath - Path to start from
+ * @param {string[]} [acc=[]] - Accumulator for paths
+ * @returns {string[]} Array of paths from start to root
+ */
+function _getParentPaths(currentPath, acc = []) {
+  const absolutePath = path.resolve(currentPath);
+  const nextAcc = [...acc, absolutePath];
+  const parentPath = path.dirname(absolutePath);
 
-  // Check the filesystem root as the final attempt
-  try {
-    const rootTaskManagerPlans = path.join(filesystemRoot, '.ai', 'task-manager', 'plans');
-    if (fs.existsSync(rootTaskManagerPlans)) {
-      const stats = fs.lstatSync(rootTaskManagerPlans);
-      if (stats.isDirectory()) {
-        const taskManagerRoot = path.join(filesystemRoot, '.ai', 'task-manager');
-        return taskManagerRoot;
-      }
-    }
-  } catch (err) {
-    // Silently continue
+  if (parentPath === absolutePath) {
+    return nextAcc;
   }
 
-  return null;
+  return _getParentPaths(parentPath, nextAcc);
+}
+
+/**
+ * Find the task manager root directory by traversing up from an optional start path
+ * @param {string} [startPath=process.cwd()] - Starting path for root discovery (defaults to current working directory)
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot(startPath = process.cwd()) {
+  const paths = _getParentPaths(startPath);
+  const foundPath = paths.find(p => getTaskManagerAt(p));
+  return foundPath ? getTaskManagerAt(foundPath) : null;
+}
+
+/**
+ * Check if the path matches the standard .ai/task-manager structure
+ * @param {string} filePath - Path to plan file
+ * @returns {string|null} The possible root path if matches, otherwise null
+ */
+function checkStandardRootShortcut(filePath) {
+  const planDir = path.dirname(filePath);
+  const parentDir = path.dirname(planDir);
+  const possibleRoot = path.dirname(parentDir);
+
+  const parentBase = path.basename(parentDir);
+  const isPlansOrArchive = parentBase === 'plans' || parentBase === 'archive';
+  if (!isPlansOrArchive) return null;
+
+  if (path.basename(possibleRoot) !== 'task-manager') return null;
+
+  const dotAiDir = path.dirname(possibleRoot);
+  if (path.basename(dotAiDir) !== '.ai') return null;
+
+  return isValidTaskManagerRoot(possibleRoot) ? possibleRoot : null;
 }
 
 /**
@@ -101,34 +130,34 @@ function extractIdFromFrontmatter(content, filePath = 'unknown') {
     /^\s*id\s*:\s*[|>]\s*([+-]?\d+)\s*$/mi
   ];
 
-  // Try each pattern in order
-  for (const regex of patterns) {
-    const match = frontmatterText.match(regex);
-    if (match) {
-      const rawId = match[1];
-      const id = parseInt(rawId, 10);
-
-      // Validate the parsed ID
-      if (isNaN(id)) {
-        console.error(`[ERROR] Invalid ID value "${rawId}" in ${filePath} - not a valid number`);
-        continue;
-      }
+  // Try each pattern in order using functional find
+  const foundPattern = patterns
+    .map(regex => ({ regex, match: frontmatterText.match(regex) }))
+    .find(({ match }) => match);
 
-      if (id < 0) {
-        console.error(`[ERROR] Invalid ID value ${id} in ${filePath} - ID must be non-negative`);
-        continue;
-      }
+  if (!foundPattern) return null;
 
-      if (id > Number.MAX_SAFE_INTEGER) {
-        console.error(`[ERROR] Invalid ID value ${id} in ${filePath} - ID exceeds maximum safe integer`);
-        continue;
-      }
+  const { match, regex } = foundPattern;
+  const rawId = match[1];
+  const id = parseInt(rawId, 10);
 
-      return id;
-    }
+  // Validate the parsed ID
+  if (isNaN(id)) {
+    console.error(`[ERROR] Invalid ID value "${rawId}" in ${filePath} - not a valid number`);
+    return null;
+  }
+
+  if (id < 0) {
+    console.error(`[ERROR] Invalid ID value ${id} in ${filePath} - ID must be non-negative`);
+    return null;
+  }
+
+  if (id > Number.MAX_SAFE_INTEGER) {
+    console.error(`[ERROR] Invalid ID value ${id} in ${filePath} - ID exceeds maximum safe integer`);
+    return null;
   }
 
-  return null;
+  return id;
 }
 
 /**
@@ -139,33 +168,251 @@ function extractIdFromFrontmatter(content, filePath = 'unknown') {
  */
 function parseFrontmatter(content) {
   const lines = content.split('\n');
-  let inFrontmatter = false;
-  let frontmatterEnd = false;
-  let delimiterCount = 0;
-  const frontmatterLines = [];
 
-  for (const line of lines) {
+  const result = lines.reduce((acc, line) => {
+    if (acc.done) return acc;
+
     if (line.trim() === '---') {
-      delimiterCount++;
-      if (delimiterCount === 1) {
-        inFrontmatter = true;
-        continue;
-      } else if (delimiterCount === 2) {
-        frontmatterEnd = true;
-        break;
+      const nextDelimiterCount = acc.delimiterCount + 1;
+      if (nextDelimiterCount === 2) {
+        return { ...acc, delimiterCount: nextDelimiterCount, done: true };
       }
+      return { ...acc, delimiterCount: nextDelimiterCount };
     }
 
-    if (inFrontmatter && !frontmatterEnd) {
-      frontmatterLines.push(line);
+    if (acc.delimiterCount === 1) {
+      return { ...acc, frontmatterLines: [...acc.frontmatterLines, line] };
     }
+
+    return acc;
+  }, { delimiterCount: 0, frontmatterLines: [], done: false });
+
+  return result.frontmatterLines.join('\n');
+}
+
+/**
+ * Find plan file and directory for a given plan ID
+ * @param {string|number} planId - Plan ID to search for
+ * @param {string} [taskManagerRoot] - Optional task manager root path (uses findTaskManagerRoot() if not provided)
+ * @returns {Object|null} Object with planFile and planDir, or null if not found
+ */
+function findPlanById(planId, taskManagerRoot) {
+  const numericPlanId = parseInt(planId, 10);
+  if (isNaN(numericPlanId)) return null;
+
+  const plans = getAllPlans(taskManagerRoot);
+  const plan = plans.find(p => p.id === numericPlanId);
+
+  if (!plan) return null;
+
+  return {
+    planFile: plan.file,
+    planDir: plan.dir,
+    isArchive: plan.isArchive
+  };
+}
+
+/**
+ * Count task files in a plan's tasks directory
+ * @param {string} planDir - Plan directory path
+ * @returns {number} Number of task files found
+ */
+function countTasks(planDir) {
+  const tasksDir = path.join(planDir, 'tasks');
+
+  if (!fs.existsSync(tasksDir)) {
+    return 0;
+  }
+
+  try {
+    const stats = fs.lstatSync(tasksDir);
+    if (!stats.isDirectory()) {
+      return 0;
+    }
+
+    const files = fs.readdirSync(tasksDir).filter(f => f.endsWith('.md'));
+    return files.length;
+  } catch (err) {
+    return 0;
+  }
+}
+
+/**
+ * Check if execution blueprint section exists in plan file
+ * @param {string} planFile - Path to plan file
+ * @returns {boolean} True if blueprint section exists, false otherwise
+ */
+function checkBlueprintExists(planFile) {
+  try {
+    const planContent = fs.readFileSync(planFile, 'utf8');
+    const blueprintExists = /^## Execution Blueprint/m.test(planContent);
+    return blueprintExists;
+  } catch (err) {
+    return false;
+  }
+}
+
+/**
+ * Validate plan file frontmatter
+ * @param {string} filePath - Path to plan file
+ * @returns {number|null} Plan ID from frontmatter or null if invalid
+ */
+function validatePlanFile(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+
+    const content = fs.readFileSync(filePath, 'utf8');
+    const frontmatter = parseFrontmatter(content);
+
+    // Check for required fields
+    if (!frontmatter) {
+      return null;
+    }
+
+    // Check for 'created' field
+    if (!/\bcreated\b/i.test(frontmatter)) {
+      return null;
+    }
+
+    // Extract and return ID
+    const id = extractIdFromFrontmatter(content, filePath);
+    return id;
+  } catch (err) {
+    return null;
   }
+}
+
+/**
+ * Get all plans (active and archived) in a task manager root
+ * @param {string} [taskManagerRoot] - Task manager root path
+ * @returns {Array<Object>} Array of plan objects { id, file, dir, isArchive }
+ */
+function getAllPlans(taskManagerRoot) {
+  const root = taskManagerRoot || findTaskManagerRoot();
+  if (!root) return [];
+
+  const types = [
+    { dir: path.join(root, 'plans'), isArchive: false },
+    { dir: path.join(root, 'archive'), isArchive: true }
+  ];
+
+  return types.flatMap(({ dir, isArchive }) => {
+    if (!fs.existsSync(dir)) return [];
+
+    try {
+      const entries = fs.readdirSync(dir, { withFileTypes: true });
+      return entries.flatMap(entry => {
+        if (!entry.isDirectory()) return [];
+
+        const planDirPath = path.join(dir, entry.name);
+
+        try {
+          const planDirEntries = fs.readdirSync(planDirPath, { withFileTypes: true });
+          return planDirEntries
+            .filter(planEntry => planEntry.isFile() && planEntry.name.endsWith('.md'))
+            .flatMap(planEntry => {
+              const filePath = path.join(planDirPath, planEntry.name);
+              try {
+                const content = fs.readFileSync(filePath, 'utf8');
+                const id = extractIdFromFrontmatter(content, filePath);
+
+                if (id !== null) {
+                  return {
+                    id,
+                    file: filePath,
+                    dir: planDirPath,
+                    isArchive,
+                    name: entry.name
+                  };
+                }
+              } catch (err) {
+                // Skip files that can't be read
+              }
+              return [];
+            });
+        } catch (err) {
+          return [];
+        }
+      });
+    } catch (err) {
+      return [];
+    }
+  });
+}
+
+/**
+ * Resolve plan information from either a numeric ID or an absolute path
+ * @param {string|number} input - Numeric ID or absolute path
+ * @param {string} [startPath=process.cwd()] - Starting path for hierarchical search
+ * @returns {Object|null} { planFile, planDir, taskManagerRoot, planId } or null if not found
+ */
+function resolvePlan(input, startPath = process.cwd()) {
+  if (!input) return null;
+  const inputStr = String(input);
+
+  // 1. Handle Absolute Path
+  if (inputStr.startsWith('/')) {
+    const planId = validatePlanFile(inputStr);
+    if (planId === null) return null;
+
+    const tmRoot = checkStandardRootShortcut(inputStr) || findTaskManagerRoot(path.dirname(inputStr));
+    if (!tmRoot) return null;
+
+    return {
+      planFile: inputStr,
+      planDir: path.dirname(inputStr),
+      taskManagerRoot: tmRoot,
+      planId
+    };
+  }
+
+  // 2. Handle Numeric ID with Hierarchical Search
+  const planId = parseInt(inputStr, 10);
+  if (isNaN(planId)) return null;
+
+  const findInAncestry = (currentPath, searched = new Set()) => {
+    const tmRoot = findTaskManagerRoot(currentPath);
+    if (!tmRoot) return null;
+
+    const normalized = path.normalize(tmRoot);
+    if (searched.has(normalized)) {
+      return null;
+    }
+    searched.add(normalized);
+
+    const plan = findPlanById(planId, tmRoot);
+    if (plan) {
+      return {
+        planFile: plan.planFile,
+        planDir: plan.planDir,
+        taskManagerRoot: tmRoot,
+        planId
+      };
+    }
+
+    // Move to parent directory (parent of the directory containing task-manager)
+    const parentOfRoot = path.dirname(path.dirname(tmRoot));
+    if (parentOfRoot === tmRoot) return null;
+    return findInAncestry(parentOfRoot, searched);
+  };
 
-  return frontmatterLines.join('\n');
+  return findInAncestry(startPath);
 }
 
 module.exports = {
   findTaskManagerRoot,
+  isValidTaskManagerRoot,
+  getTaskManagerAt,
+  checkStandardRootShortcut,
+  validatePlanFile,
   extractIdFromFrontmatter,
-  parseFrontmatter
+  parseFrontmatter,
+  findPlanById,
+  countTasks,
+  checkBlueprintExists,
+  getAllPlans,
+  _getParentPaths,
+  resolvePlan
 };