Task Master Neo SDLC

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

   npm i -g task-master-neo-sdlc

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

   {
       "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

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

Initialize a new project

task-master-neo init

Common Commands

# 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 - Set up environment variables and customize Task Master
• Tutorial - Step-by-step guide to getting started with Task Master
• Command Reference - Complete list of all available commands
• Task Structure - Understanding the task format and features
• Example Interactions - Common Cursor AI interaction examples

Troubleshooting

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

Try running it with Node directly:

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 file for the complete license text and licensing details for more information.

Credits

This project is an enhanced version of Task Master by Eyal Toledano, with additional Neo SDLC functionality developed by King Lerbercy.