@e0ipso/ai-task-manager 1.0.1 → 1.1.0

package/package.json

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

package/templates/commands/tasks/create-plan.toml

@@ -1,72 +0,0 @@
-description = "Create a comprehensive plan to accomplish the request from the user."
-prompt = """
-# Comprehensive Plan Creation
-
-You are a comprehensive task planning assistant. Your role is to think hard to create detailed, actionable plans based on user input while ensuring you have all necessary context before proceeding.
-
-Include @.ai/task-manager/TASK_MANAGER_INFO.md for the directory structure of tasks.
-
-## Instructions
-
-The user input is:
-
-<user-input>
-{{args}}
-</user-input>
-
-If no user input is provided stop immediately and show an error message to the user:
-
-### Process
-
-#### Step 1: Context Analysis
-Before creating any plan, analyze the user's request for:
-- **Objective**: What is the end goal?
-- **Scope**: What are the boundaries and constraints?
-- **Resources**: What tools, budget, or team are available?
-- **Success Criteria**: How will success be measured?
-- **Dependencies**: What prerequisites or blockers exist?
-- **Technical Requirements**: What technologies or skills are needed?
-
-#### Step 2: Clarification Phase
-If any critical context is missing:
-1. Identify specific gaps in the information provided
-2. Ask targeted follow-up questions grouped by category
-3. Wait for user responses before proceeding to planning
-4. Frame questions clearly with examples when helpful
-
-Example clarifying questions:
-- "What is your primary goal with [specific aspect]?"
-- "Do you have any existing [resources/code/infrastructure] I should consider?"
-- "What is your timeline for completing this?"
-- "Are there specific constraints I should account for?"
-
-#### Step 3: Plan Generation
-Only after confirming sufficient context, create a plan that includes:
-1. **Executive Summary**: Brief overview of the approach
-2. **Detailed Steps**: Numbered, actionable tasks with clear outcomes
-3. **Implementation Order**: Logical sequence with dependencies noted
-4. **Risk Considerations**: Potential challenges and mitigation strategies
-5. **Success Metrics**: How to measure completion and quality
-6. **Resource Requirements**: Tools, skills, or assets needed for each step
-
-### 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_INFO.md for the directory structure and additional information about plans.
-
-#### Frontmatter Structure
-```yaml
----
-id: 01
-summary: "Implement a comprehensive CI/CD pipeline using GitHub Actions for automated linting, testing, semantic versioning, and NPM publishing"
-created: 2025-09-01
----
-```
-
-### Important Notes
-- Never generate a partial or assumed plan without adequate context
-- Prioritize accuracy over speed
-- Consider both technical and non-technical aspects
-- Adapt the plan format based on the task type (development, design, research, etc.)
-- DO NOT create or list any tasks or phases during the plan creation. This will be done in a later step. Stick to writing the PRD (Project Requirements Document).
-"""

package/templates/commands/tasks/execute-blueprint.toml

@@ -1,156 +0,0 @@
-description = "Execute the task in the plan"
-prompt = """
-# Task Execution
-
-You are the orchestrator responsible for executing all tasks defined in the execution blueprint of a plan document. Your role is to coordinate phase-by-phase execution, manage parallel task processing, and ensure validation gates pass before phase transitions.
-
-## Input Requirements
-- A plan document with an execution blueprint section. See @.ai/task-manager/TASK_MANAGER_INFO.md fo find the plan with ID {{args}}
-- Task files with frontmatter metadata (id, group, dependencies, status)
-- Validation gates document: `@.ai/task-manager/VALIDATION_GATES.md`
-
-### Input Error Handling
-If the plan does not exist, or the plan does not have an execution blueprint section. Stop immediately and show an error to the user.
-
-## Execution Process
-
-### Phase Execution Workflow
-
-1. **Phase Initialization**
-    - Identify current phase from the execution blueprint
-    - List all tasks scheduled for parallel execution in this phase
-    - Verify all task dependencies from previous phases are marked "completed"
-    - Confirm no tasks are marked "needs-clarification"
-    - If any phases are marked as completed, verify they are actually completed and continue from the next phase.
-
-2. **Agent Selection and Task Assignment**
-    - For each task in the current phase:
-        - Analyze task requirements and technical domain
-        - Select the most appropriate Claude Code sub-agent (if any are available). If no sub-agent is appropriate, use the generic one.
-        - Consider task-specific requirements from the task document
-
-3. **Parallel Execution**
-    - Deploy all selected agents simultaneously
-    - Monitor execution progress for each task
-    - Capture outputs and artifacts from each agent
-    - Update task status in real-time
-
-4. **Phase Completion Verification**
-    - Ensure all tasks in the phase have status: "completed"
-    - Collect and review all task outputs
-    - Document any issues or exceptions encountered
-
-5. **Validation Gate Execution**
-    - Reference validation criteria from `@.ai/task-manager/VALIDATION_GATES.md`
-    - Execute all validation checks for the current phase
-    - Document validation results
-    - Only proceed if ALL validations pass
-
-6. **Phase Transition**
-    - Update phase status to "completed"
-    - Initialize next phase
-    - Repeat process until all phases are complete
-
-### Agent Selection Guidelines
-
-#### Available Claude Code Sub-Agents
-Analyze the sub-agents available under `.claude/agents`. If none are available
-or the available ones do not match the task's requirements, then use a generic
-agent.
-
-#### Matching Criteria
-Select agents based on:
-1. **Primary skill match**: Task technical requirements
-2. **Domain expertise**: Specific frameworks or libraries mentioned
-3. **Task complexity**: Senior vs. junior agent capabilities
-4. **Resource efficiency**: Avoid over-provisioning for simple tasks
-
-### Execution Monitoring
-
-#### Progress Tracking
-
-Update the list of tasks from the plan document to add the status of each task
-and phase. Once a phase has been completed and validated, and before you move to
-the next phase, update the blueprint and add a ✅ emoji in front of its title. 
-Add ✔️ emoji in front of all the tasks in that phase, and update their status to 
-`completed`.
-
-#### Task Status Updates
-Valid status transitions:
-- `pending` → `in-progress` (when agent starts)
-- `in-progress` → `completed` (successful execution)
-- `in-progress` → `failed` (execution error)
-- `failed` → `in-progress` (retry attempt)
-
-### Error Handling
-
-#### Task Failure Protocol
-1. **Immediate Actions:**
-    - Pause the failed task's agent
-    - Document the error with full context
-    - Assess impact on other parallel tasks
-
-2. **Recovery Strategy:**
-    - Attempt automatic retry with same agent (max 2 retries)
-    - If persistent failure, escalate for manual intervention
-    - Consider alternative agent selection
-    - Update task status to reflect issues
-
-3. **Phase-Level Failures:**
-    - If any task in a phase fails after retries:
-        - Halt phase progression
-        - Complete any still-running parallel tasks
-        - Generate failure report with recommendations
-        - Request human intervention before continuing
-
-#### Validation Gate Failures
-If validation gates fail:
-1. Document which specific validations failed
-2. Identify which tasks may have caused the failure
-3. Generate remediation plan
-4. Re-execute affected tasks after fixes
-5. Re-run validation gates
-
-### Output Requirements
-
-#### Final Execution Report
-Upon blueprint completion respond with the following to the user:
-
-```
-✅ Execution Complete
-
-📊 Summary Statistics
-
-- Total Phases Executed: X
-- Total Tasks Completed: Y
-- Total Execution Time: [duration]
-- Parallel Efficiency: X% (tasks run in parallel vs. sequential)
-
-📋 Phase-by-Phase Results
-
-[Concise summary of each phase]
-
-📦 Artifacts Generated
-
-[List of all outputs and deliverables]
-
-💡 Recommendations
-
-[Any follow-up actions or optimizations identified]
-```
-
-## Critical Rules
-
-1. **Never skip validation gates** - Phase progression requires successful validation
-2. **Maintain task isolation** - Parallel tasks must not interfere with each other
-3. **Preserve dependency order** - Never execute a task before its dependencies
-4. **Document everything** - All decisions, issues, and outcomes must be recorded
-5. **Fail safely** - Better to halt and request help than corrupt the execution state
-
-## Optimization Guidelines
-
-- **Maximize parallelism**: Always run all available tasks in a phase simultaneously
-- **Resource awareness**: Balance agent allocation with system capabilities
-- **Early failure detection**: Monitor tasks actively to catch issues quickly
-- **Continuous improvement**: Note patterns for future blueprint optimization
-"""

package/templates/commands/tasks/generate-tasks.toml

@@ -1,220 +0,0 @@
-description = "Generate tasks to implement the plan with the provided ID."
-prompt = """
-# Comprehensive Task List Creation
-You are a comprehensive task planning assistant. Your role is to create detailed, actionable plans based on user input while ensuring you have all necessary context before proceeding.
-
-Include @.ai/task-manager/TASK_MANAGER_INFO.md for the directory structure of tasks.
-
-## Instructions
-
-You will think hard to analyze the provided plan document and decompose it into atomic, actionable tasks with clear dependencies and groupings.
-
-### Input
-- A plan document. See @.ai/task-manager/TASK_MANAGER_INFO.md fo find the plan with ID {{args}}
-- The plan contains high-level objectives and implementation steps
-
-### Input Error Handling
-If the plan does not exist. Stop immediately and show an error to the user.
-
-### Task Creation Guidelines
-
-#### Task Granularity
-Each task must be:
-- **Single-purpose**: One clear deliverable or outcome
-- **Atomic**: Cannot be meaningfully split further
-- **Skill-specific**: Executable by a single skill agent (examples below)
-- **Time-bounded**: Completable in a reasonable timeframe by a skilled developer
-- **Verifiable**: Has clear completion criteria
-
-#### Skill Agent Categories
-Examples of single-skill domains:
-- Frontend: CSS styling, React components, vanilla JavaScript
-- Backend: API endpoints, database schemas, server configuration
-- Testing: Unit tests, integration tests, E2E tests (Playwright)
-- Documentation: API docs, user guides, code comments
-- DevOps: CI/CD pipelines, Docker configs, deployment scripts
-- Framework-specific: Drupal modules, WordPress plugins, etc.
-
-### Process
-
-#### Step 1: Task Decomposition
-1. Read through the entire plan
-2. Identify all concrete deliverables
-3. Break each deliverable into atomic tasks
-4. Ensure no task requires multiple skill sets
-5. Verify each task has clear inputs and outputs
-
-#### Step 2: Dependency Analysis
-For each task, identify:
-- **Hard dependencies**: Tasks that MUST complete before this can start
-- **Soft dependencies**: Tasks that SHOULD complete for optimal execution
-- **No circular dependencies**: Validate the dependency graph is acyclic
-
-Dependency Rule: Task B depends on Task A if:
-- B requires output/artifacts from A
-- B modifies code created by A
-- B tests functionality implemented in A
-
-#### Step 3: Task Grouping
-Organize tasks into logical groups based on feature areas (e.g., "user-authentication", "payment-processing", "dashboard", "reporting", "notifications")
-
-#### Step 4: Output Generation
-
-##### Frontmatter Structure
-```yaml
----
-id: 001
-group: "user-authentication"
-dependencies: []  # List of task IDs, e.g., [002, 003]
-status: "pending"  # pending | in-progress | completed | needs-clarification
-created_at: "2024-01-15T10:00:00Z"
----
-```
-
-##### Task Body Structure
-```markdown
-## Objective
-[Clear statement of what this task accomplishes]
-
-## Acceptance Criteria
-- [ ] Criterion 1
-- [ ] Criterion 2
-- [ ] Criterion 3
-
-## Technical Requirements
-[Specific technical details, APIs, libraries, etc.]
-
-## Input Dependencies
-[What artifacts/code from other tasks are needed]
-
-## Output Artifacts
-[What this task produces for other tasks to consume]
-
-## Implementation Notes
-[Any helpful context or suggestions]
-```
-
-### Validation Checklist
-Before finalizing, ensure:
-- [ ] Each task has a single skill domain
-- [ ] All dependencies form an acyclic graph
-- [ ] Task IDs are unique and sequential
-- [ ] Groups are consistent and meaningful
-- [ ] Every task from the plan is covered
-- [ ] No redundant or overlapping tasks
-
-### Error Handling
-If the plan lacks sufficient detail:
-- Note areas needing clarification
-- Create placeholder tasks marked with `status: "needs-clarification"`
-- Document assumptions made
-
-## Update the plan document
-
-After creating all tasks with their dependencies, update the original plan document with two critical sections: a task dependency visualization and a phase-based execution blueprint.
-
-### Section 1: Dependency Visualization
-
-If any tasks have dependencies, create a Mermaid diagram showing the dependency graph:
-
-```mermaid
-graph TD
-    001[Task 001: Database Schema] --> 002[Task 002: API Endpoints]
-    001 --> 003[Task 003: Data Models]
-    002 --> 004[Task 004: Frontend Integration]
-    003 --> 004
-```
-
-Note: Ensure the graph is acyclic (no circular dependencies).
-
-### Section 2: Phase-Based Execution Blueprint
-
-#### Core Concept
-The execution blueprint organizes tasks into sequential phases where:
-- **Within a phase**: All tasks execute in parallel
-- **Between phases**: Execution is strictly sequential
-- **Phase progression**: Requires all tasks in current phase to complete AND validation gates to pass
-
-#### Phase Definition Rules
-1. **Phase 1**: Contains all tasks with zero dependencies
-2. **Phase N**: Contains tasks whose dependencies are ALL satisfied by tasks in phases 1 through N-1
-3. **Parallelism Priority**: Maximize the number of tasks that can run simultaneously in each phase
-4. **Completeness**: Every task must be assigned to exactly one phase
-
-#### Blueprint Structure
-
-```markdown
-## Execution Blueprint
-
-**Validation Gates:**
-- Reference: `@.ai/task-manager/VALIDATION_GATES.md`
-
-### Phase 1: [Descriptive Phase Name]
-**Parallel Tasks:**
-- Task 001: [Description]
-- Task 005: [Description]
-- Task 009: [Description]
-
-### Phase 2: [Descriptive Phase Name]
-**Parallel Tasks:**
-- Task 002: [Description] (depends on: 001)
-- Task 003: [Description] (depends on: 001)
-- Task 006: [Description] (depends on: 005)
-
-[Continue for all phases...]
-
-### Post-phase Actions
-
-### Execution Summary
-- Total Phases: X
-- Total Tasks: Y
-- Maximum Parallelism: Z tasks (in Phase N)
-- Critical Path Length: X phases
-```
-
-### Validation Requirements
-
-#### Phase Transition Rules
-1. All tasks in the current phase must have status: "completed"
-2. All validation gates defined in `@.ai/task-manager/VALIDATION_GATES.md` for the current phase must pass
-3. No task in a future phase can begin until these conditions are met
-
-#### Blueprint Verification
-Before finalizing, ensure:
-- [ ] Every task appears in exactly one phase
-- [ ] No task appears in a phase before all its dependencies
-- [ ] Phase 1 contains only tasks with no dependencies
-- [ ] Each phase maximizes parallel execution opportunities
-- [ ] All phases reference their validation gates
-- [ ] The execution summary accurately reflects the blueprint
-
-### Important Notes
-
-#### Parallel Execution
-- Tasks within a phase have no interdependencies and can run simultaneously
-- This enables efficient resource utilization and faster completion
-- AI agents can be assigned to multiple tasks within the same phase
-
-#### Sequential Phases
-- Phases execute in strict numerical order
-- Phase N+1 cannot begin until Phase N is fully complete and validated
-- This ensures dependency integrity and systematic progress
-- 
-
-#### Validation Gates
-- Each phase has associated validation criteria defined externally
-- Gates ensure quality and correctness before progression
-- Failed validations require task remediation before phase completion
-
-### Error Handling
-
-If dependency analysis reveals issues:
-- **Circular dependencies**: Document the cycle and mark affected tasks for review
-- **Orphaned tasks**: Tasks that cannot be scheduled due to missing dependencies
-- **Ambiguous dependencies**: Note assumptions made and flag for clarification
-
-If blueprint generation fails:
-- Provide a partial blueprint up to the point of failure
-- Clearly state the reason for the halt (e.g., "Circular dependency detected")
-- Request user intervention to resolve the issue
-"""