@e0ipso/ai-task-manager 1.18.7 → 1.20.0

package/templates/ai-task-manager/config/scripts/compose-prompt.cjs

@@ -0,0 +1,234 @@
+#!/usr/bin/env node
+
+/**
+ * Runtime Prompt Composition Script
+ *
+ * Reads markdown command files, performs variable substitution, and outputs
+ * composed prompts to enable uninterrupted workflow execution.
+ *
+ * Usage:
+ *   node compose-prompt.cjs --template "create-plan.md" --variable "ARGUMENTS=user input" --variable "1=51"
+ *
+ * Arguments:
+ *   --template: Relative path to template file (e.g., "create-plan.md")
+ *   --variable: Key=value pairs for substitution (can be specified multiple times)
+ *
+ * Output:
+ *   Composed markdown prompt to stdout with variables substituted
+ *
+ * Exit Codes:
+ *   0: Success
+ *   1: Error (with message to stderr)
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Parse command line arguments
+ * @returns {Object} Parsed arguments with template and variables
+ */
+function parseArguments() {
+  const args = process.argv.slice(2);
+  const result = {
+    template: null,
+    variables: {}
+  };
+
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === '--template') {
+      if (i + 1 >= args.length) {
+        throw new Error('--template requires a value');
+      }
+      result.template = args[++i];
+    } else if (args[i] === '--variable') {
+      if (i + 1 >= args.length) {
+        throw new Error('--variable requires a value');
+      }
+      const varArg = args[++i];
+      const eqIndex = varArg.indexOf('=');
+      if (eqIndex === -1) {
+        throw new Error(`Invalid variable format: ${varArg}. Expected format: key=value`);
+      }
+      const key = varArg.substring(0, eqIndex);
+      const value = varArg.substring(eqIndex + 1);
+      result.variables[key] = value;
+    } else {
+      throw new Error(`Unknown argument: ${args[i]}`);
+    }
+  }
+
+  if (!result.template) {
+    throw new Error('--template argument is required');
+  }
+
+  return result;
+}
+
+/**
+ * Find the template file in the appropriate directory
+ * Priority: .claude/commands/tasks/ then templates/assistant/commands/tasks/
+ * @param {string} templateName - Relative path to template file
+ * @returns {string} Absolute path to template file
+ */
+function findTemplateFile(templateName) {
+  // Get the root directory (assuming script is in templates/ai-task-manager/config/scripts/)
+  const scriptDir = __dirname;
+  const rootDir = path.resolve(scriptDir, '../../../..');
+
+  // Define search paths in priority order
+  const searchPaths = [
+    path.join(rootDir, '.claude', 'commands', 'tasks', templateName),
+    path.join(rootDir, 'templates', 'assistant', 'commands', 'tasks', templateName)
+  ];
+
+  for (const searchPath of searchPaths) {
+    if (fs.existsSync(searchPath)) {
+      return searchPath;
+    }
+  }
+
+  throw new Error(`Template not found: ${templateName}`);
+}
+
+/**
+ * Parse YAML frontmatter from markdown content
+ * Based on the parseFrontmatter function from src/utils.ts
+ * @param {string} content - The markdown content with frontmatter
+ * @returns {Object} Object containing frontmatter and body content
+ */
+function parseFrontmatter(content) {
+  const frontmatterRegex = /^---\r?\n([\s\S]*?)\r?\n---(?:\r?\n([\s\S]*))?$/;
+  const match = content.match(frontmatterRegex);
+
+  if (!match) {
+    return {
+      frontmatter: {},
+      body: content
+    };
+  }
+
+  const frontmatterContent = match[1] || '';
+  const bodyContent = match[2] || '';
+
+  // Simple YAML parser for our specific use case
+  const frontmatter = {};
+  const lines = frontmatterContent.split('\n');
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith('#')) continue;
+
+    const colonIndex = trimmed.indexOf(':');
+    if (colonIndex === -1) continue;
+
+    const key = trimmed.substring(0, colonIndex).trim();
+    const value = trimmed.substring(colonIndex + 1).trim();
+
+    // Remove quotes if present
+    frontmatter[key] = value.replace(/^["']|["']$/g, '');
+  }
+
+  return {
+    frontmatter,
+    body: bodyContent
+  };
+}
+
+/**
+ * Perform variable substitution in the template body
+ * Replaces $ARGUMENTS, $1, $2, etc. with provided values
+ * Does NOT process frontmatter variables (those stay as-is)
+ * @param {string} body - The template body content
+ * @param {Object} variables - Key-value pairs for substitution
+ * @returns {string} Body content with substitutions applied
+ */
+function substituteVariables(body, variables) {
+  let result = body;
+
+  // Replace $ARGUMENTS if provided
+  if (variables.ARGUMENTS !== undefined) {
+    // Use regex with negative lookahead to avoid replacing $ARGUMENTS that are part of longer identifiers
+    result = result.replace(/\$ARGUMENTS(?![0-9A-Za-z_])/g, variables.ARGUMENTS);
+  }
+
+  // Replace positional arguments ($1, $2, $3, etc.)
+  // Use regex with negative lookahead to avoid replacing $1 that's part of $10, etc.
+  for (const key in variables) {
+    if (/^\d+$/.test(key)) {
+      const pattern = new RegExp(`\\$${key}(?![0-9])`, 'g');
+      result = result.replace(pattern, variables[key]);
+    }
+  }
+
+  return result;
+}
+
+/**
+ * Reconstruct markdown content with frontmatter
+ * @param {Object} frontmatter - The frontmatter object
+ * @param {string} body - The body content
+ * @returns {string} Complete markdown content
+ */
+function reconstructMarkdown(frontmatter, body) {
+  if (Object.keys(frontmatter).length === 0) {
+    return body;
+  }
+
+  let result = '---\n';
+  for (const [key, value] of Object.entries(frontmatter)) {
+    // Preserve original formatting - add quotes if value contains special characters
+    if (typeof value === 'string' && (value.includes(':') || value.includes('[') || value.includes(']'))) {
+      result += `${key}: "${value}"\n`;
+    } else {
+      result += `${key}: ${value}\n`;
+    }
+  }
+  result += '---\n';
+
+  if (body) {
+    result += body;
+  }
+
+  return result;
+}
+
+/**
+ * Main execution function
+ */
+function main() {
+  try {
+    // Parse command line arguments
+    const { template, variables } = parseArguments();
+
+    // Find the template file
+    const templatePath = findTemplateFile(template);
+
+    // Read the template file
+    const content = fs.readFileSync(templatePath, 'utf-8');
+
+    // Parse frontmatter and body
+    const { frontmatter, body } = parseFrontmatter(content);
+
+    // Perform variable substitution on the body only
+    const substitutedBody = substituteVariables(body, variables);
+
+    // Reconstruct the markdown with frontmatter preserved
+    const output = reconstructMarkdown(frontmatter, substitutedBody);
+
+    // Output to stdout
+    process.stdout.write(output);
+
+    // Exit successfully
+    process.exit(0);
+  } catch (error) {
+    // Write error to stderr
+    process.stderr.write(`Error: ${error.message}\n`);
+
+    // Exit with error code
+    process.exit(1);
+  }
+}
+
+// Execute main function
+main();

package/templates/ai-task-manager/config/scripts/validate-plan-blueprint.cjs

@@ -233,17 +233,22 @@ function listAvailablePlans() {
 }
 
 /**
- * Validate plan blueprint and output JSON
+ * Validate plan blueprint and output JSON or specific field
  * @param {string|number} planId - Plan ID to validate
+ * @param {string} [fieldName] - Optional field name to extract (planFile, planDir, taskCount, blueprintExists)
  */
-function validatePlanBlueprint(planId) {
+function validatePlanBlueprint(planId, fieldName) {
   if (!planId) {
     errorLog('Plan ID is required');
     errorLog('');
-    errorLog('Usage: node validate-plan-blueprint.cjs <plan-id>');
+    errorLog('Usage: node validate-plan-blueprint.cjs <plan-id> [field-name]');
     errorLog('');
-    errorLog('Example:');
-    errorLog('  node validate-plan-blueprint.cjs 47');
+    errorLog('Examples:');
+    errorLog('  node validate-plan-blueprint.cjs 47                  # Output full JSON');
+    errorLog('  node validate-plan-blueprint.cjs 47 planFile         # Output just the plan file path');
+    errorLog('  node validate-plan-blueprint.cjs 47 planDir          # Output just the plan directory');
+    errorLog('  node validate-plan-blueprint.cjs 47 taskCount        # Output just the task count');
+    errorLog('  node validate-plan-blueprint.cjs 47 blueprintExists  # Output yes/no');
     process.exit(1);
   }
 
@@ -282,13 +287,27 @@ function validatePlanBlueprint(planId) {
     planFile,
     planDir,
     taskCount,
-    blueprintExists
+    blueprintExists: blueprintExists ? 'yes' : 'no'
   };
 
   debugLog('Validation complete:', result);
-  console.log(JSON.stringify(result, null, 2));
+
+  // If field name is provided, output just that field
+  if (fieldName) {
+    const validFields = ['planFile', 'planDir', 'taskCount', 'blueprintExists'];
+    if (!validFields.includes(fieldName)) {
+      errorLog(`Invalid field name: ${fieldName}`);
+      errorLog(`Valid fields: ${validFields.join(', ')}`);
+      process.exit(1);
+    }
+    console.log(result[fieldName]);
+  } else {
+    // Output full JSON for backward compatibility
+    console.log(JSON.stringify(result, null, 2));
+  }
 }
 
 // Main execution
 const planId = process.argv[2];
-validatePlanBlueprint(planId);
+const fieldName = process.argv[3];
+validatePlanBlueprint(planId, fieldName);

package/templates/ai-task-manager/config/templates/PLAN_TEMPLATE.md

@@ -2,8 +2,6 @@
 id: [PLAN-ID]
 summary: "[Brief one-line description of what this plan accomplishes]"
 created: [YYYY-MM-DD]
-approval_method_plan: [auto|manual]  # Workflow approval for plan review (default: manual)
-approval_method_tasks: [auto|manual]  # Workflow approval for task generation review (default: manual)
 ---
 
 # Plan: [Descriptive Plan Title]

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

@@ -83,17 +83,15 @@ Only after confirming sufficient context, create a plan that includes:
 
 Remember that a plan needs to be reviewed by a human. Be concise and to the point. Also, include mermaid diagrams to illustrate the plan.
 
-##### Output Format
-Structure your response as follows:
-- If context is insufficient: List specific clarifying questions
-- If context is sufficient: Provide the comprehensive plan using the structure above. Use the information in @TASK_MANAGER.md for the directory structure and additional information about plans.
+##### CRITICAL: Output Format
 
 **Output Behavior: CRITICAL - Structured Output for Command Coordination**
 
-Always end your output with a standardized summary in this exact format:
+Always end your output with a standardized summary in this exact format, for command coordination:
 
 ```
 ---
+
 Plan Summary:
 - Plan ID: [numeric-id]
 - Plan File: [full-path-to-plan-file]
@@ -118,13 +116,9 @@ Example:
 id: 1
 summary: "Implement a comprehensive CI/CD pipeline using GitHub Actions for automated linting, testing, semantic versioning, and NPM publishing"
 created: 2025-09-01
-approval_method_plan: "manual"
-approval_method_tasks: "manual"
 ---
 ```
 
-**Important**: Always set both `approval_method_plan` and `approval_method_tasks` to "manual" when creating a plan. The full-workflow command will modify these fields to "auto" after creation if running in automated mode.
-
 The schema for this frontmatter is:
 ```json
 {
@@ -143,16 +137,6 @@ The schema for this frontmatter is:
       "type": "string",
       "pattern": "^\\d{4}-\\d{2}-\\d{2}$",
       "description": "Creation date in YYYY-MM-DD format"
-    },
-    "approval_method_plan": {
-      "type": "string",
-      "enum": ["auto", "manual"],
-      "description": "Workflow approval mode for plan review: auto for automated workflows, manual for standalone execution"
-    },
-    "approval_method_tasks": {
-      "type": "string",
-      "enum": ["auto", "manual"],
-      "description": "Workflow approval mode for task generation review: auto when tasks auto-generated in workflow, manual for standalone execution"
     }
   },
   "additionalProperties": false
@@ -169,19 +153,3 @@ node .ai/task-manager/config/scripts/get-next-plan-id.cjs
 **Key formatting:**
 - **Front-matter**: Use numeric values (`id: 7`)
 - **Directory names**: Use zero-padded strings (`07--plan-name`)
-
-This Node.js script provides robust plan ID generation with comprehensive error handling:
-
-**Features:**
-- **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 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 → Uses filename fallback
-- File system errors → Gracefully handled