task-master-neo-sdlc/README.md

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

# Task Master Neo SDLC

[![License: MIT with Commons Clause](https://img.shields.io/badge/license-MIT%20with%20Commons%20Clause-blue.svg)](LICENSE)

Task Master Neo SDLC is an enhanced version of the original Task Master, extending it with comprehensive Software Development Lifecycle (SDLC) tools and Neo orchestration capabilities. It provides a complete AI-driven development system that integrates 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.

## New SDLC Tools and Features

This enhanced version adds MCP (Model Context Protocol) tools for each SDLC phase:

### Requirements Tools
- **extractRequirements**: Extract functional and non-functional requirements from documents
- **validateRequirements**: Validate requirements against quality criteria

### Design Tools
- **generateArchitecture**: Generate architecture design based on requirements
- **createUXDesign**: Create UX designs and wireframes

### Code Tools
- **generateCode**: Generate code based on specifications
- **refactorCode**: Refactor code for better quality

### Documentation Tools
- **generateDocumentation**: Generate documentation from code or specifications

### Testing Tools
- **generateTestCases**: Generate test cases based on requirements or code
- **analyzeCodeQuality**: Analyze code quality and suggest improvements

### Security Tools
- **analyzeSecurityVulnerabilities**: Analyze code for security vulnerabilities

### Planning Tools
- **decomposeTask**: Break down a task into smaller, manageable subtasks
- **estimateEffort**: Estimate effort for development tasks

## Overview

Neo orchestrates the SDLC through a series of phases and specialized agents, each responsible for specific tasks. The system is designed to be extensible and adaptable.

**Core Components:**

*   **Neo Orchestrator:** The central coordinating agent that manages the overall workflow.
*   **Knowledge Graph System:** Stores and relates information about the project (code, tasks, requirements, design, etc.).
*   **Agent Workflow System:** Manages the execution and communication between agents.
*   **Chain System:** Defines sequences of actions or sub-tasks for complex operations.
*   **Monitoring System:** Tracks system health, performance metrics, and provides audit logging.
*   **Design System Manager:** Manages design tokens, components, and templates.

**Specialized Agents:**

*   **UX Designer:** Handles user research (personas, journey maps, OOUX), wireframing, and interaction design.
*   **Security Auditor:** Manages security policies, audits code/config for vulnerabilities, and handles RBAC.
*   **Performance Analyst:** Analyzes performance data, suggests optimizations, and manages benchmarks.
*   **Compatibility Analyzer:** Checks compatibility between components, systems, and environments.
*   **Knowledge Base Manager:** Creates, searches, and links knowledge base articles.
*   **Technical Debt Manager:** Identifies, prioritizes, and plans the resolution of technical debt.
*   **Frontend Developer:** Manages UI component creation, implementation, and API integration.
*   **Backend Developer:** Handles API endpoint creation, business logic implementation, and database model definition.
*   **Database Manager:** Manages database schema migration, data seeding, and query performance analysis.
*   **Project Setup:** Handles initial project setup, including knowledge graph generation and context directory initialization.
*   **DevOps:** Generates CI/CD, deployment, load balancer, and scaling configurations.
*   **Process Manager:** Executes and tracks multi-step processes defined in workflows.
*   **Architecture Validator:** Ensures the system adheres to defined architectural rules.
*   **Requirements Validator:** Validates implemented features against defined requirements.

## How It Works

Neo utilizes a central **Knowledge Graph** to maintain a comprehensive understanding of the project state. Specialized agents interact with this graph and each other, coordinated by the **Agent Workflow System** and the **Neo Orchestrator**. The system uses **Chains** to execute complex, multi-step tasks.

A typical workflow might involve:

1.  **Initialization:** Using the `ProjectSetupAgent` (triggered via `/init_project` or MCP tool `initialize_project`) to set up the project structure, initial Knowledge Graph, and context directory.
2.  **Requirements:** Defining requirements (potentially using the `/init_requirement_docs` command or adding nodes to the KG).
3.  **Validation:** Using the `RequirementsValidatorAgent` to ensure requirements are clear and testable.
4.  **Design:**
    *   The `UXDesignerAgent` performs research, creates journey maps, site maps, OOUX templates, and wireframes.
    *   The `DesignSystemManager` manages tokens and components based on UI/UX design.
5.  **Implementation:**
    *   `FrontendDeveloperAgent` builds UI components, implements logic, and connects to APIs.
    *   `BackendDeveloperAgent` defines data models, creates API endpoints, and implements server-side logic.
    *   `DatabaseManagerAgent` handles schema migrations and seeding.
6.  **Validation & Auditing:**
    *   `ArchitectureValidatorAgent` checks against architectural rules.
    *   `SecurityAuditorAgent` audits for vulnerabilities, checks RBAC, and enforces policies.
    *   `CompatibilityAnalyzerAgent` checks integrations.
    *   `TechnicalDebtManagerAgent` identifies and tracks debt.
7.  **Deployment & Monitoring:**
    *   `DevOpsAgent` generates CI/CD and deployment configurations.
    *   `MonitoringSystem` tracks performance, logs audit events, and alerts on issues (including maintenance needs).
    *   `PerformanceAnalystAgent` analyzes metrics and suggests optimizations.
8.  **Knowledge Management:** `KnowledgeBaseManagerAgent` documents processes, decisions, and guidelines throughout the lifecycle.
9.  **Process Execution:** `ProcessManagerAgent` runs defined workflows, coordinating agent actions.

## Quick Start

### Option 1 | MCP (Recommended):

MCP (Model Context Protocol) provides the easiest way to interact with Task Master Neo SDLC and its agents directly in your editor.

1.  **Install the package**

    ```bash
    npm i -g task-master-neo-sdlc
    ```

2.  **Add the MCP config to your editor** (e.g., Cursor):

    ```json
    {
        "mcpServers": {
            "taskmaster-neo": {
                "command": "npx",
                "args": ["-y", "task-master-neo-mcp"],
                "env": {
                    "ANTHROPIC_API_KEY": "YOUR_ANTHROPIC_API_KEY_HERE",
                    "PERPLEXITY_API_KEY": "YOUR_PERPLEXITY_API_KEY_HERE",
                    "MODEL": "claude-3-opus-20240229", // Or your preferred model
                    "PERPLEXITY_MODEL": "sonar-medium-online", // Or your preferred model
                    "MAX_TOKENS": 100000, // Adjust as needed
                    "TEMPERATURE": 0.1,
                    "DEFAULT_SUBTASKS": 5,
                    "DEFAULT_PRIORITY": "medium"
                }
            }
        }
    }
    ```
    *(Remember to replace placeholders with your actual API keys)*

3.  **Enable the MCP** in your editor.

4.  **Initialize the project using Neo:**

    ```
    @taskmaster-neo Please initialize the project using the /init_project command.
    ```
    *(Or use the `initialize_project` MCP tool directly if your AI assistant supports it)*

5.  **Interact with Neo and specialized agents:**

    ```
    @taskmaster-neo Can you parse my PRD at scripts/prd.txt?
    @taskmaster-neo What's the next task I should work on?
    @taskmaster-neo Ask the FrontendDeveloperAgent to create a new Button component.
    @taskmaster-neo Ask the SecurityAuditorAgent to check for hardcoded secrets in the .env file.
    @taskmaster-neo Ask the UXDesignerAgent to create a journey map for user login.
    ```

6.  **Use the SDLC tools:**

    ```
    @taskmaster-neo Extract requirements from my project description in docs/project_description.md
    @taskmaster-neo Generate a microservices architecture based on the extracted requirements
    @taskmaster-neo Create wireframes for the user registration flow on our web platform
    @taskmaster-neo Generate code for a user authentication API endpoint using Express.js
    @taskmaster-neo Analyze this code for security vulnerabilities
    ```

### Option 2: Using Command Line

#### Installation

```bash
# Install globally
npm install -g task-master-neo-sdlc
```

#### Initialize a new project

```bash
task-master-neo init
```

#### Common Commands

```bash
# Parse a PRD and generate tasks
task-master-neo parse-prd your-prd.txt

# List all tasks
task-master-neo list

# Show the next task to work on
task-master-neo next

# Generate task files
task-master-neo generate
```

## Documentation

For more detailed information, check out the documentation in the `docs` directory:

- [Configuration Guide](docs/configuration.md) - Set up environment variables and customize Task Master
- [Tutorial](docs/tutorial.md) - Step-by-step guide to getting started with Task Master
- [Command Reference](docs/command-reference.md) - Complete list of all available commands
- [Task Structure](docs/task-structure.md) - Understanding the task format and features
- [Example Interactions](docs/examples.md) - Common Cursor AI interaction examples

## Troubleshooting

### If `task-master-neo init` doesn't respond:

Try running it with Node directly:

```bash
node scripts/init.js
```

## Licensing

Task Master Neo SDLC is licensed under the MIT License with Commons Clause. This means you can:

✅ **Allowed**:

- Use Task Master Neo SDLC for any purpose (personal, commercial, academic)
- Modify the code
- Distribute copies
- Create and sell products built using Task Master Neo SDLC

❌ **Not Allowed**:

- Sell Task Master Neo SDLC itself
- Offer Task Master Neo SDLC as a hosted service
- Create competing products based on Task Master Neo SDLC

See the [LICENSE](LICENSE) file for the complete license text and [licensing details](docs/licensing.md) for more information.

## Credits

This project is an enhanced version of [Task Master](https://github.com/eyaltoledano/claude-task-master) by Eyal Toledano, with additional Neo SDLC functionality developed by King Lerbercy.