@e0ipso/ai-task-manager 1.8.2 → 1.8.3

package/package.json

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

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

@@ -0,0 +1,124 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Find the task manager root directory by traversing up from CWD
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot() {
+  let currentPath = process.cwd();
+  const root = path.parse(currentPath).root;
+  
+  while (currentPath !== root) {
+    const taskManagerPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    if (fs.existsSync(taskManagerPath)) {
+      return path.join(currentPath, '.ai', 'task-manager');
+    }
+    currentPath = path.dirname(currentPath);
+  }
+  
+  // Check root directory as well
+  const rootTaskManager = path.join(root, '.ai', 'task-manager', 'plans');
+  if (fs.existsSync(rootTaskManager)) {
+    return path.join(root, '.ai', 'task-manager');
+  }
+  
+  return null;
+}
+
+/**
+ * Parse YAML frontmatter for ID with resilience to different formats
+ * @param {string} content - File content
+ * @returns {number|null} Extracted ID or null
+ */
+function extractIdFromFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+  
+  const frontmatterText = frontmatterMatch[1];
+  
+  // Handle various YAML formats for id field using regex:
+  // id: 5
+  // id: "5"
+  // id: '5'
+  // "id": 5
+  // 'id': 5
+  // id : 5 (with spaces)
+  const patterns = [
+    /^\s*["']?id["']?\s*:\s*["']?(\d+)["']?\s*$/m,  // Most flexible pattern
+    /^\s*id\s*:\s*(\d+)\s*$/m,                       // Simple numeric
+    /^\s*id\s*:\s*"(\d+)"\s*$/m,                     // Double quoted
+    /^\s*id\s*:\s*'(\d+)'\s*$/m,                     // Single quoted
+  ];
+  
+  for (const pattern of patterns) {
+    const match = frontmatterText.match(pattern);
+    if (match) {
+      const id = parseInt(match[1], 10);
+      if (!isNaN(id)) return id;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Get the next available plan ID by scanning existing plan files
+ * @returns {number} Next available plan ID
+ */
+function getNextPlanId() {
+  const taskManagerRoot = findTaskManagerRoot();
+  
+  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.');
+    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.isFile() && entry.name.match(/^plan-\d+--.*\.md$/)) {
+          // Extract ID from filename as fallback
+          const filenameMatch = entry.name.match(/^plan-(\d+)--/);
+          if (filenameMatch) {
+            const id = parseInt(filenameMatch[1], 10);
+            if (!isNaN(id) && id > maxId) maxId = id;
+          }
+          
+          // Also check frontmatter for more reliable ID
+          try {
+            const filePath = path.join(dir, entry.name);
+            const content = fs.readFileSync(filePath, 'utf8');
+            const id = extractIdFromFrontmatter(content);
+            
+            if (id !== null && id > maxId) {
+              maxId = id;
+            }
+          } catch (err) {
+            // Skip corrupted files
+          }
+        }
+      });
+    } catch (err) {
+      // Skip directories that can't be read
+    }
+  });
+  
+  return maxId + 1;
+}
+
+// Output the next plan ID
+console.log(getNextPlanId());

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

@@ -0,0 +1,160 @@
+#!/usr/bin/env node
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Find the task manager root directory by traversing up from CWD
+ * @returns {string|null} Path to task manager root or null if not found
+ */
+function findTaskManagerRoot() {
+  let currentPath = process.cwd();
+  const root = path.parse(currentPath).root;
+  
+  while (currentPath !== root) {
+    const taskManagerPath = path.join(currentPath, '.ai', 'task-manager', 'plans');
+    if (fs.existsSync(taskManagerPath)) {
+      return path.join(currentPath, '.ai', 'task-manager');
+    }
+    currentPath = path.dirname(currentPath);
+  }
+  
+  // Check root directory as well
+  const rootTaskManager = path.join(root, '.ai', 'task-manager', 'plans');
+  if (fs.existsSync(rootTaskManager)) {
+    return path.join(root, '.ai', 'task-manager');
+  }
+  
+  return null;
+}
+
+/**
+ * Parse YAML frontmatter for ID with resilience to different formats
+ * @param {string} content - File content
+ * @returns {number|null} Extracted ID or null
+ */
+function extractIdFromFrontmatter(content) {
+  const frontmatterMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+  if (!frontmatterMatch) return null;
+  
+  const frontmatterText = frontmatterMatch[1];
+  
+  // Handle various YAML formats for id field using regex:
+  // id: 5
+  // id: "5"
+  // id: '5'
+  // "id": 5
+  // 'id': 5
+  // id : 5 (with spaces)
+  const patterns = [
+    /^\s*["']?id["']?\s*:\s*["']?(\d+)["']?\s*$/m,  // Most flexible pattern
+    /^\s*id\s*:\s*(\d+)\s*$/m,                       // Simple numeric
+    /^\s*id\s*:\s*"(\d+)"\s*$/m,                     // Double quoted
+    /^\s*id\s*:\s*'(\d+)'\s*$/m,                     // Single quoted
+  ];
+  
+  for (const pattern of patterns) {
+    const match = frontmatterText.match(pattern);
+    if (match) {
+      const id = parseInt(match[1], 10);
+      if (!isNaN(id)) return id;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Get the next available task ID for a specific plan
+ * @param {number|string} planId - The plan ID to get next task ID for
+ * @returns {number} Next available task ID
+ */
+function getNextTaskId(planId) {
+  if (!planId) {
+    console.error('Error: Plan ID is required');
+    process.exit(1);
+  }
+  
+  const taskManagerRoot = findTaskManagerRoot();
+  
+  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.');
+    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
+  }
+  
+  // Optimization: If no tasks directory exists, return 1 immediately (90% case)
+  if (!planDir) {
+    return 1;
+  }
+  
+  let maxId = 0;
+  
+  try {
+    const entries = fs.readdirSync(planDir, { withFileTypes: true });
+    
+    // Another optimization: If directory is empty, return 1 immediately
+    if (entries.length === 0) {
+      return 1;
+    }
+    
+    entries.forEach(entry => {
+      if (entry.isFile() && entry.name.endsWith('.md')) {
+        try {
+          const filePath = path.join(planDir, entry.name);
+          const content = fs.readFileSync(filePath, 'utf8');
+          const id = extractIdFromFrontmatter(content);
+          
+          if (id !== null && id > maxId) {
+            maxId = id;
+          }
+        } catch (err) {
+          // Skip corrupted files
+        }
+      }
+    });
+  } catch (err) {
+    // Skip directories that can't be read
+  }
+  
+  return maxId + 1;
+}
+
+// Get plan ID from command line argument
+const planId = process.argv[2];
+console.log(getNextTaskId(planId));

package/templates/assistant/commands/tasks/create-plan.md

@@ -132,25 +132,25 @@ The schema for this frontmatter is:
 
 **Auto-generate the next plan ID:**
 ```bash
-echo $(($(find .ai/task-manager/{plans,archive} -name "plan-[0-9]*--*.md" 2>/dev/null -exec sh -c 'grep -m1 "^[[:space:]]*id:[[:space:]]*[0-9][0-9]*[[:space:]]*$" "$1" 2>/dev/null || echo "id: 0"' _ {} \; | sed -E "s/^[[:space:]]*id:[[:space:]]*([0-9]+)[[:space:]]*$/\1/" | awk 'BEGIN{max=0} {if($1+0>max) max=$1+0} END{print max}') + 1))
+node .ai/task-manager/config/scripts/get-next-plan-id.js
 ```
 
 **Key formatting:**
 - **Front-matter**: Use numeric values (`id: 7`)
 - **Directory names**: Use zero-padded strings (`07--plan-name`)
 
-This enhanced command provides robust plan ID generation with comprehensive error handling:
+This Node.js script provides robust plan ID generation with comprehensive error handling:
 
 **Features:**
-- **Flexible Whitespace Handling**: Supports various patterns: `id: 5`, `id:5`, `id:  15`, `id:	25` (tabs)
+- **Flexible Whitespace Handling**: Supports various frontmatter patterns
 - **Validation Layer**: Only processes files with valid numeric ID fields in YAML frontmatter
 - **Error Resilience**: Gracefully handles empty directories, corrupted files, and parsing failures
-- **Fallback Logic**: Returns ID 1 when no valid plans found, ensuring command never fails
-- **Robust Parsing**: Uses POSIX character classes for reliable whitespace matching across systems
+- **Fallback Logic**: Returns ID 1 when no valid plans found, ensuring script never fails
+- **Dual ID Detection**: Checks both filename patterns and frontmatter for maximum reliability
 
 **Handles Edge Cases:**
 - Empty plans/archive directories → Returns 1
 - Corrupted or malformed YAML frontmatter → Skips invalid files
 - Non-numeric ID values → Filters out automatically
-- Missing frontmatter → Ignored safely
-- File system errors → Suppressed with 2>/dev/null
+- Missing frontmatter → Uses filename fallback
+- File system errors → Gracefully handled

package/templates/assistant/commands/tasks/generate-tasks.md

@@ -220,18 +220,18 @@ When creating tasks, you need to determine the next available task ID for the sp
 
 #### Command
 ```bash
-PLAN_ID=$1; echo $(($(find .ai/task-manager/plans/$(printf "%02d" $PLAN_ID)--*/tasks -name "*.md" -exec grep "^id: *[0-9][0-9]* *$" {} \; 2>/dev/null | sed 's/.*id: *//' | sed 's/ *$//' | sort -n | tail -1 | sed 's/^$/0/') + 1))
+node .ai/task-manager/config/scripts/get-next-task-id.js $1
 ```
 
 #### How It Works
-1. **Finds task files** using the pattern `*.md` in the specific plan's tasks directory
-2. **Validates and extracts front-matter IDs** using grep to find `id:` lines with valid numeric values, filtering out malformed or string IDs
-3. **Strips the `id:` prefix and whitespace** using sed to get clean numeric values only
-4. **Sorts numerically** to find the highest existing task ID
-5. **Handles empty results** by defaulting to 0 if no valid tasks exist
-6. **Adds 1** to get the next available task ID
+1. **Finds the plan directory** using pattern matching for plan ID directories
+2. **Scans task files** in the plan's tasks directory for `.md` files
+3. **Validates frontmatter IDs** by parsing YAML frontmatter and extracting numeric ID values
+4. **Finds maximum ID** by comparing all valid task IDs numerically
+5. **Handles edge cases** by gracefully handling missing directories, corrupted files, and parsing errors
+6. **Returns next ID** by incrementing the maximum found ID by 1
 
-This command reads the actual `id:` values from task front-matter, making it the definitive source of truth.
+This Node.js script provides robust error handling and reliable ID generation.
 
 #### Parameter Usage
 - `$1` is the plan ID parameter passed to this template
@@ -249,7 +249,7 @@ This command reads the actual `id:` values from task front-matter, making it the
 **Example 1: Plan 6 with existing tasks**
 ```bash
 # Command execution (plan ID = 6)
-PLAN_ID=6; echo $(($(find .ai/task-manager/plans/$(printf "%02d" $PLAN_ID)--*/tasks -name "*.md" -exec grep "^id: *[0-9][0-9]* *$" {} \; 2>/dev/null | sed 's/.*id: *//' | sed 's/ *$//' | sort -n | tail -1 | sed 's/^$/0/') + 1))
+node .ai/task-manager/config/scripts/get-next-task-id.js 6
 # Output: 5 (if highest valid numeric task front-matter has id: 4)
 
 # Front-matter usage:
@@ -266,7 +266,7 @@ skills: ["api-endpoints", "database"]
 **Example 2: Plan 1 with no existing tasks**
 ```bash
 # Command execution (plan ID = 1)
-PLAN_ID=1; echo $(($(find .ai/task-manager/plans/$(printf "%02d" $PLAN_ID)--*/tasks -name "*.md" -exec grep "^id: *[0-9][0-9]* *$" {} \; 2>/dev/null | sed 's/.*id: *//' | sed 's/ *$//' | sort -n | tail -1 | sed 's/^$/0/') + 1))
+node .ai/task-manager/config/scripts/get-next-task-id.js 1
 # Output: 1 (empty tasks directory, no valid front-matter to read)
 
 # Front-matter usage: