task-master-neo-sdlc/README-task-master.md

Enhanced task management system with Neo SDLC agents and MCP tools for comprehensive, AI-driven software development lifecycle management.

# Task Master Neo

### by [@eyaltoledano](https://x.com/eyaltoledano) & [@RalphEcom](https://x.com/RalphEcom)

Task Master is an AI-driven development system built around the concept of **Neo**, an SDLC orchestration agent. It integrates with various specialized agents to manage the entire software development lifecycle, leveraging a **Knowledge Graph** for context and state management. It's designed to work seamlessly with AI assistants like Cursor.

## System Overview

Neo acts as the central brain, coordinating a team of specialized AI agents to handle different phases of the software development lifecycle. Key components include:

*   **Neo Orchestrator:** Manages the overall workflow and agent interactions.
*   **Knowledge Graph:** A dynamic graph database storing project context (code structure, requirements, tasks, design decisions, agent states, etc.).
*   **Agent Workflow System:** Facilitates communication and task execution between agents.
*   **Specialized Agents:** A suite of agents covering roles like UX Design, Security Auditing, Performance Analysis, Frontend/Backend Development, Database Management, Architecture Validation, and more.
*   **Monitoring System:** Tracks performance, health, and logs significant events.
*   **Design System Manager:** Handles UI components, design tokens, and templates.
*   **Process Manager:** Executes predefined, complex workflows.

This agent-based architecture allows for modularity, specialization, and scalability in managing complex development processes.

## Requirements

- Node.js 14.0.0 or higher
- Anthropic API key (Claude API)
- (Optional) Perplexity API key (for research features)
- (Optional) Cursor AI or another AI assistant capable of MCP interaction.

## Configuration

Configure API keys and model preferences via environment variables in a `.env` file:

```
ANTHROPIC_API_KEY=YOUR_CLAUDE_API_KEY
PERPLEXITY_API_KEY=YOUR_PERPLEXITY_API_KEY # Optional
MODEL="claude-3-opus-20240229" # Or your preferred model
PERPLEXITY_MODEL="sonar-medium-online" # Or your preferred model
MAX_TOKENS=100000
TEMPERATURE=0.1
# ... other optional configurations like DEBUG, LOG_LEVEL, DEFAULT_SUBTASKS etc.
```
*(See `docs/configuration.md` or `.env.example` for all options)*

## Installation

```bash
npm install -g task-master-ai
```

## Quick Start: MCP Workflow (Recommended)

Using Task Master Neo with an AI assistant via MCP (Model Context Protocol) provides the most integrated experience.

1.  **Install:** `npm i -g task-master-ai`
2.  **Configure MCP Server:** Add the following to your editor's (e.g., Cursor) MCP server configuration:

    ```json
    {
        "mcpServers": {
            "taskmaster-ai": {
                "command": "npx",
                "args": ["-y", "task-master-mcp"],
                "env": {
                    "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
                    "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE"
                    // Add other relevant env vars like MODEL, MAX_TOKENS etc.
                }
            }
        }
    }
    ```
3.  **Enable MCP Server:** Activate the server in your editor.
4.  **Initialize Project:** Ask your AI assistant (referencing the MCP server, e.g., `@taskmaster-ai`) to initialize the project:
    ```
    @taskmaster-ai Initialize this project.
    ```
    (This uses the `initialize_project` tool).
5.  **Parse Requirements (Optional):** If you have a PRD:
    ```
    @taskmaster-ai Parse the PRD at path/to/prd.txt to generate initial tasks.
    ```
    (This uses the `parse_prd` tool).
6.  **Start Workflow:** Interact with Neo and the specialized agents:
    *   `@taskmaster-ai What is the next task to work on?` (Uses `next_task`)
    *   `@taskmaster-ai Ask the FrontendDeveloperAgent to create a login form component.`
    *   `@taskmaster-ai Ask the SecurityAuditorAgent to check for hardcoded passwords.`
    *   `@taskmaster-ai Ask the PerformanceAnalystAgent to suggest caching strategies for the /users endpoint.`
    *   `@taskmaster-ai Validate the architecture against the defined rules.` (Uses `ArchitectureValidatorAgent`)
    *   `@taskmaster-ai Log an audit event: User manually updated the database schema.` (Uses `MonitoringSystem`)

## AI-Driven SDLC Workflow with Neo

Neo orchestrates the development process through its specialized agents:

1.  **Initialization:** `ProjectSetupAgent` creates the structure, initial KG, and context files.
2.  **Requirements & Validation:** Requirements are defined (manually or via PRD parsing), and `RequirementsValidatorAgent` checks them.
3.  **Design:** `UXDesignerAgent` handles research, journey maps, wireframes. `DesignSystemManager` manages components/tokens.
4.  **Implementation:** `FrontendDeveloperAgent`, `BackendDeveloperAgent`, and `DatabaseManagerAgent` build features, APIs, and manage the database.
5.  **Continuous Validation:**
    *   `ArchitectureValidatorAgent` ensures adherence to architectural rules.
    *   `SecurityAuditorAgent` performs security checks and manages RBAC.
    *   `CompatibilityAnalyzerAgent` verifies integrations.
    *   `TechnicalDebtManagerAgent` monitors and plans debt resolution.
6.  **Deployment & Operations:** `DevOpsAgent` generates CI/CD and deployment configurations. `MonitoringSystem` tracks metrics and logs events. `PerformanceAnalystAgent` suggests optimizations.
7.  **Knowledge & Process:** `KnowledgeBaseManagerAgent` maintains documentation. `ProcessManagerAgent` executes complex, multi-step workflows.

This collaborative, agent-based approach, centered around the Knowledge Graph, allows for a more dynamic and context-aware development process.

## CLI Usage (Alternative)

While MCP is recommended for the full agentic experience, core task management can still be done via the CLI.

### Initialize a new project

```bash
task-master init
```

### Common CLI Commands

*(Existing command list remains largely relevant for basic task management)*

```bash
# Parse PRD
task-master parse-prd <prd-file.txt>

# List tasks
task-master list [--status=<status>] [--with-subtasks]

# Show next/specific task
task-master next
task-master show <id>

# Manage tasks
task-master set-status --id=<id> --status=<status>
task-master expand --id=<id> [--num=<n>] [--prompt=...] [--research]
task-master update --from=<id> --prompt="..."
task-master add-task --prompt="..."

# Generate task files
task-master generate

# Complexity & Dependencies
task-master analyze-complexity [--research]
task-master complexity-report
task-master add-dependency --id=<id> --depends-on=<id>
task-master validate-dependencies
```

*(Refer to `docs/command-reference.md` for the full list)*

## Task Structure

*(Existing Task Structure section is still valid)*

## Documentation

*(Existing Documentation section is still valid)*

## Troubleshooting

*(Existing Troubleshooting section is still valid)*

## Contributors

*(Existing Contributors section is still valid)*

## Star History

*(Existing Star History section is still valid)*

## Licensing

*(Existing Licensing section is still valid)*