Taskmaster AI

The extension uses a two-stage CI/CD process driven by changesets and GitHub Actions:

1. Extension CI (extension-ci.yml)

Triggers: Push or Pull Request to main or next branches (only if extension files change). Actions:

• Lints and type-checks code.
• Builds the extension (npm run build).
• Creates a clean package (npm run package).
• Runs tests via the VS Code test framework.
• Creates a test VSIX package and uploads build artifacts.

2. Version & Publish (version.yml)

Triggers: Push to main branch. Actions:

• Detects pending changesets and creates a "Version Packages" PR.
• Upon merging the Version PR:
  • Builds and packages the extension.
  • Creates git tags (e.g., taskr-kanban@1.0.1).
  • Publishes to VS Code Marketplace (requires VSCE_PAT).
  • Publishes to Open VSX Registry (requires OVSX_PAT).
  • Updates CHANGELOG and package versions.

The task update system is designed using an Object-Oriented approach within tm-core and apps/cli. It employs a Strategy Pattern to handle different update modes (Bulk, Single, and Subtask) through a unified interface.

Key architectural components include:

• UpdateTaskService: The main orchestrator that coordinates validation, strategy selection, context building, execution, and result display.
• IUpdateStrategy: A contract defining the lifecycle of an update: validate -> loadTasks -> buildPrompts -> callAIService -> mergeResults.
• BaseUpdateStrategy: An abstract class implementing the Template Method Pattern, providing a shared execute workflow for all concrete strategies.
• UpdateStrategyFactory: Responsible for detecting the update mode based on input parameters and instantiating the correct strategy.
• Service Layer: Specialized services like ContextBuilderService (AI context), PromptBuilderService (prompt construction), and DataMergerService (merging AI results with local data) handle specific business logic.

┌─────────────────────────┐
│  UpdateTaskService      │ ◄─── Main Orchestrator
│  (Coordinates)          │
└───────┬─────────────────┘
        │ uses
        ├──► UpdateStrategyFactory ──creates──► IUpdateStrategy
        │                                           │
        ├──► ContextBuilderService                 │ implements
        │                                           ▼
        ├──► IDisplayManager ◄──creates── UpdateDisplayFactory
        │         │
        │         ├── CLIDisplayManager
        │         └── JSONDisplayManager
        │
        └──► ConfigManager (existing)
             IStorage (existing)
             Logger (existing)

┌────────────────────────────────────────────────────┐
│                 IUpdateStrategy                    │
└────────────────────────────────────────────────────┘
                        △
                        │ extends
            ┌───────────┴────────────┐
            │                        │
┌───────────────────────┐    ┌──────────────────────┐
│   BaseUpdateStrategy  │    │  Abstract base with  │
│  (Template Method)   │    │  common workflow     │
└───────────┬───────────┘    └──────────────────────┘
            │ extends
    ┌───────┼──────────┬─────────────┐
    │       │          │             │
┌───▼───┐ ┌─▼────┐  ┌─▼──────────┐  │
│ Bulk  │ │Single│  │  Subtask   │  │
│Update │ │Task  │  │  Update    │  │
│       │ │Update│  │            │  │
└───────┘ └──────┘  └────────────┘  │
                                     ├──► ContextBuilderService
                                     │      ├─uses─► ContextGatherer (existing)
                                     │      └─uses─► FuzzyTaskSearch (existing)
                                     │
                                     ├──► PromptBuilderService
                                     │      └─uses─► PromptManager (existing)
                                     │
                                     └──► DataMergerService

Task Master uses an intelligent dependency system when creating new tasks. When a user requests a new task, the system performs two types of dependency analysis:

1. Explicit Dependencies: These are task IDs manually provided by the user or identified via specific numeric inputs. The system focuses on these and analyzes their own dependency chains to build a complete context for the AI.
2. Auto-discovery Mode: If no explicit dependencies are provided, the system performs keyword matching against existing tasks and analyzes recent tasks to build a relevant context for the AI.

The AI is then prompted to return a JSON object that includes a dependencies array containing only the task IDs that the new task directly depends on, based on the provided project context.

{
  "title": "Task title goes here",
  "description": "A concise one or two sentence description of what the task involves",
  "details": "In-depth implementation details, considerations, and guidance.",
  "testStrategy": "Detailed approach for verifying task completion.",
  "dependencies": [1, 2, 3] // Optional: Array of existing task IDs that this task depends on
}