Labsco
heffrey78 logo

Lifecycle MCP Server

★ 38

from heffrey78

An MCP server for managing the software development lifecycle, with support for an optional external SQLite database.

🔥🔥🔥✓ VerifiedFreeAdvanced setup
#email#automation#e-commerce#database#git#maps#security#monitoring

Lifecycle MCP Server

A Model Context Protocol (MCP) server for comprehensive software lifecycle management. This server provides structured tracking of requirements, tasks, and architecture decisions through a SQLite database with full traceability and automated state management.

Features

  • Requirements Management: Create and manage software requirements with validation and lifecycle tracking
  • Task Management: Track implementation tasks with hierarchical structure and effort estimation
  • Architecture Decisions: Record ADRs (Architecture Decision Records) with full context
  • Project Dashboards: Real-time project health metrics and status reporting
  • Requirement Tracing: Complete traceability from requirements through implementation
  • State Validation: Automatic validation of lifecycle state transitions
  • Relationship Tracking: Many-to-many relationships between requirements, tasks, and architecture

Best Practices

Database Location

  • Each project should have its own lifecycle.db file
  • Use LIFECYCLE_DB=./lifecycle.db to create the database in the current project
  • Or use an absolute path for a shared database: LIFECYCLE_DB=/path/to/shared/lifecycle.db

Virtual Environment (Recommended)

# Create a virtual environment for lifecycle-mcp
cd /path/to/lifecycle-mcp
python -m venv venv
source venv/bin/activate  # On Windows: venv\Scripts\activate

# Install in the virtual environment
pip install -e .

# Find the venv's lifecycle-mcp command
which lifecycle-mcp  # Copy this path

# Use the full path when adding to Claude
claude mcp add lifecycle /path/to/venv/bin/lifecycle-mcp -e LIFECYCLE_DB=./lifecycle.db

MCP Tools Reference

The server exposes 22 MCP tools across 6 handler modules for comprehensive lifecycle management:

Tool List

  • create_requirement - Create new requirements from interview data
  • update_requirement_status - Move requirements through lifecycle states
  • query_requirements - Search and filter requirements
  • get_requirement_details - Get full requirement with relationships
  • trace_requirement - Trace requirement through implementation
  • create_task - Create implementation tasks from requirements
  • update_task_status - Update task progress
  • query_tasks - Search and filter tasks
  • get_task_details - Get full task details with dependencies
  • sync_task_from_github - Sync individual task from GitHub issue changes
  • bulk_sync_github_tasks - Sync all tasks with their GitHub issues
  • create_architecture_decision - Record architecture decisions (ADRs)
  • update_architecture_status - Update architecture decision status
  • query_architecture_decisions - Search and filter architecture decisions
  • get_architecture_details - Get full architecture decision details
  • add_architecture_review - Add review comments to architecture decisions
  • get_project_status - Get project health metrics and dashboards
  • start_requirement_interview - Start interactive requirement gathering
  • continue_requirement_interview - Continue requirement interview sessions
  • start_architectural_conversation - Start interactive architecture discussions
  • continue_architectural_conversation - Continue architecture conversations
  • export_project_documentation - Export comprehensive markdown documentation
  • create_architectural_diagrams - Generate Mermaid diagrams for project visualization

Requirement Management

create_requirement

Create new requirements from interview data or analysis.

Parameters:

  • type (required): Requirement type - "FUNC", "NFUNC", "TECH", "BUS", "INTF"
  • title (required): Descriptive title
  • priority (required): Priority level - "P0", "P1", "P2", "P3"
  • current_state (required): Current system state
  • desired_state (required): Target system state
  • functional_requirements (optional): Array of functional requirements
  • acceptance_criteria (optional): Array of acceptance criteria
  • business_value (optional): Business justification
  • risk_level (optional): Risk assessment - "High", "Medium", "Low"
  • author (optional): Requirement author

Example:

{
  "type": "FUNC",
  "title": "User Authentication System",
  "priority": "P1",
  "current_state": "No user authentication exists",
  "desired_state": "Secure user login with JWT tokens",
  "functional_requirements": ["Login with email/password", "JWT token generation"],
  "acceptance_criteria": ["User can login successfully", "Token expires after 24 hours"],
  "business_value": "Enables secure user access to protected features",
  "risk_level": "Medium"
}

update_requirement_status

Move requirements through their lifecycle with validation.

Parameters:

  • requirement_id (required): Requirement ID (e.g., "REQ-0001-FUNC-00")
  • new_status (required): Target status - "Draft", "Under Review", "Approved", "Architecture", "Ready", "Implemented", "Validated", "Deprecated"
  • comment (optional): Review comment or justification

Valid State Transitions:

  • Draft → Under Review, Deprecated
  • Under Review → Draft, Approved, Deprecated
  • Approved → Architecture, Ready, Deprecated
  • Architecture → Ready, Approved
  • Ready → Implemented, Deprecated
  • Implemented → Validated, Ready
  • Validated → Deprecated

query_requirements

Search and filter requirements by various criteria.

Parameters:

  • status (optional): Filter by status
  • priority (optional): Filter by priority level
  • type (optional): Filter by requirement type
  • search_text (optional): Text search in title and desired state

get_requirement_details

Get comprehensive requirement information including all relationships.

Parameters:

  • requirement_id (required): Requirement ID

Returns: Detailed report with basic info, problem definition, functional requirements, acceptance criteria, and linked tasks.

trace_requirement

Trace a requirement through its complete implementation lifecycle.

Parameters:

  • requirement_id (required): Requirement ID

Returns: Complete trace including requirement details, implementation tasks, and architecture decisions.

Task Management

create_task

Create implementation tasks linked to requirements.

Parameters:

  • requirement_ids (required): Array of requirement IDs to link
  • title (required): Task title
  • priority (required): Priority level - "P0", "P1", "P2", "P3"
  • effort (optional): Effort estimation - "XS", "S", "M", "L", "XL"
  • user_story (optional): User story description
  • acceptance_criteria (optional): Array of acceptance criteria
  • parent_task_id (optional): Parent task for subtasks
  • assignee (optional): Task assignee

Example:

{
  "requirement_ids": ["REQ-0001-FUNC-00"],
  "title": "Implement JWT token generation",
  "priority": "P1",
  "effort": "M",
  "user_story": "As a developer, I need JWT token generation so users can authenticate securely",
  "acceptance_criteria": ["Generate JWT with user claims", "Token expires in 24 hours"],
  "assignee": "john.doe@company.com"
}

update_task_status

Update task progress and assignment.

Parameters:

  • task_id (required): Task ID (e.g., "TASK-0001-00-00")
  • new_status (required): New status - "Not Started", "In Progress", "Blocked", "Complete", "Abandoned"
  • comment (optional): Status update comment
  • assignee (optional): New assignee

query_tasks

Search and filter tasks by various criteria.

Parameters:

  • status (optional): Filter by status
  • priority (optional): Filter by priority level
  • assignee (optional): Filter by assignee
  • requirement_id (optional): Filter by linked requirement

get_task_details

Get comprehensive task information including dependencies and relationships.

Parameters:

  • task_id (required): Task ID

Returns: Detailed report with basic info, description, acceptance criteria, and linked requirements.

sync_task_from_github

Sync individual task from GitHub issue changes with conflict detection.

Parameters:

  • task_id (required): Task ID to sync with its linked GitHub issue

Returns: Sync status and any updates applied from GitHub issue data.

bulk_sync_github_tasks

Sync all tasks with their GitHub issues in batch operation.

Parameters: None

Returns: Summary of sync operations performed across all tasks with GitHub issue links.

Architecture Management

create_architecture_decision

Record architecture decisions (ADRs) with full context.

Parameters:

  • requirement_ids (required): Array of requirement IDs addressed
  • title (required): Decision title
  • context (required): Decision context and background
  • decision (required): The decision made
  • consequences (optional): Decision consequences object
  • decision_drivers (optional): Array of factors driving the decision
  • considered_options (optional): Array of alternatives considered
  • authors (optional): Array of decision authors

Example:

{
  "requirement_ids": ["REQ-0001-FUNC-00"],
  "title": "Use JWT for authentication tokens",
  "context": "Need secure, stateless authentication for API access",
  "decision": "Implement JWT tokens with RS256 signing",
  "consequences": {
    "positive": ["Stateless authentication", "Industry standard"],
    "negative": ["Token size overhead", "Key management complexity"]
  },
  "decision_drivers": ["Security requirements", "Scalability needs"],
  "considered_options": ["Session cookies", "OAuth2", "JWT tokens"]
}

update_architecture_status

Update the status of an architecture decision with validation.

Parameters:

  • architecture_id (required): Architecture ID (e.g., "ADR-0001")
  • new_status (required): New status - "Proposed", "Accepted", "Rejected", "Deprecated", "Superseded", "Draft", "Under Review", "Approved", "Implemented"
  • comment (optional): Status change comment

query_architecture_decisions

Search and filter architecture decisions by various criteria.

Parameters:

  • status (optional): Filter by status
  • type (optional): Filter by type (ADR, TDD, INTG)
  • requirement_id (optional): Filter by linked requirement
  • search_text (optional): Text search in title and context

get_architecture_details

Get comprehensive architecture decision information including all relationships and reviews.

Parameters:

  • architecture_id (required): Architecture ID

Returns: Detailed report with basic info, context, decision details, drivers, options, consequences, linked requirements, and review history.

add_architecture_review

Add review comments to architecture decisions.

Parameters:

  • architecture_id (required): Architecture ID
  • comment (required): Review comment
  • reviewer (optional): Reviewer name (default: "MCP User")

Project Monitoring

get_project_status

Get comprehensive project health metrics and dashboards.

Parameters:

  • include_blocked (optional): Include blocked items analysis (default: true)

Returns: Dashboard with requirement overview, task statistics, completion percentages, and blocked items analysis.

Interactive Interview Tools

start_requirement_interview

Start an interactive requirement gathering interview session.

Parameters:

  • project_context (optional): Description of the project or system
  • stakeholder_role (optional): Role of the person being interviewed

Returns: Session ID and initial questions to guide requirement gathering.

Example:

{
  "project_context": "E-commerce platform modernization",
  "stakeholder_role": "Product Manager"
}

continue_requirement_interview

Continue an active interview session by providing answers to questions.

Parameters:

  • session_id (required): Interview session ID from start_requirement_interview
  • answers (required): Object containing answers to the current questions

Returns: Next set of questions or completion summary with created requirement.

Example:

{
  "session_id": "a1b2c3d4",
  "answers": {
    "current_problem": "Users struggle with complex checkout process",
    "desired_outcome": "Streamlined one-click checkout experience",
    "success_criteria": "Checkout completion rate increases by 25%"
  }
}

Interview Flow:

  1. Problem Identification: Understanding the current challenge
  2. Solution Definition: Defining the desired outcome and constraints
  3. Details Gathering: Collecting priority, type, and technical details
  4. Validation: Establishing acceptance criteria and success metrics
  5. Completion: Automatic requirement creation with interview summary

Documentation Export Tools

export_project_documentation

Export comprehensive project documentation in structured markdown format.

Parameters:

  • project_name (optional): Name for the project used in filenames (default: "project")
  • include_requirements (optional): Include requirements documentation (default: true)
  • include_tasks (optional): Include tasks documentation (default: true)
  • include_architecture (optional): Include architecture documentation (default: true)
  • output_directory (optional): Directory to save exported files (default: ".")

Returns: List of exported files with their paths.

Generated Files:

  • {project_name}-requirements.md - Complete requirements documentation grouped by type
  • {project_name}-tasks.md - Task documentation grouped by status with linked requirements
  • {project_name}-architecture.md - Architecture decisions with context, decisions, and consequences

Example:

{
  "project_name": "ecommerce-platform",
  "include_requirements": true,
  "include_tasks": true,
  "include_architecture": true,
  "output_directory": "./docs"
}

create_architectural_diagrams

Generate Mermaid diagrams for project architecture and relationships visualization.

Parameters:

  • diagram_type (optional): Type of diagram - "requirements", "tasks", "architecture", "full_project", "directory_structure", "dependencies" (default: "full_project")
  • requirement_ids (optional): Array of specific requirement IDs to include
  • include_relationships (optional): Include relationship arrows in diagrams (default: true)
  • output_format (optional): Output format - "mermaid", "markdown_with_mermaid" (default: "mermaid")
  • interactive (optional): Start interactive conversation for complex diagrams (default: false)

Returns: Mermaid diagram code or markdown-wrapped diagram.

Diagram Types:

  • requirements: Flowchart showing requirement hierarchy by type with status colors
  • tasks: Task hierarchy with parent-child relationships and status indicators
  • architecture: Architecture decisions with status-based styling
  • full_project: High-level overview showing relationships between requirements, tasks, and architecture
  • directory_structure: Project directory structure visualization
  • dependencies: Task dependency graph showing blocking relationships

Status Colors:

  • Requirements: Draft (red), Under Review (orange), Approved (blue), Ready (green), etc.
  • Tasks: Not Started (red), In Progress (orange), Blocked (dark red), Complete (green), etc.
  • Architecture: Proposed (orange), Accepted (green), Rejected (red), Deprecated (gray), etc.

Example:

{
  "diagram_type": "requirements",
  "include_relationships": true,
  "output_format": "markdown_with_mermaid"
}

Interactive Architectural Conversation Tools

start_architectural_conversation

Start an interactive conversation for complex architectural diagram generation.

Parameters:

  • project_context (optional): Description of the project or system
  • diagram_purpose (optional): Purpose and goals for the diagram
  • complexity_level (optional): Conversation complexity - "simple", "medium", "complex" (default: "medium")

Returns: Session ID and contextual questions based on complexity level.

Complexity Levels:

  • Simple: Basic component and relationship questions
  • Medium: Architectural challenges, stakeholders, and detail level questions
  • Complex: Deep architectural patterns, compliance, security, and performance considerations

continue_architectural_conversation

Continue an active architectural conversation session with responses.

Parameters:

  • session_id (required): Conversation session ID from start_architectural_conversation
  • responses (required): Object containing responses to current questions

Returns: Next questions or completion with generated diagram.

Conversation Flow:

  1. Context Gathering: Understanding architectural needs and stakeholders
  2. Diagram Specification: Determining optimal diagram type and focus
  3. Detail Refinement: Visual preferences and emphasis areas
  4. Completion: Automatic diagram generation with conversation summary

Example:

{
  "session_id": "a1b2c3d4",
  "responses": {
    "main_challenge": "Visualizing microservice dependencies for new team members",
    "stakeholders": "Development team and system architects",
    "detail_level": "High-level overview with key integration points"
  }
}

Database Schema

The server maintains a comprehensive SQLite database with the following key entities:

  • Requirements: Central entity with lifecycle states (Draft → Under Review → Approved → Architecture → Ready → Implemented → Validated → Deprecated)
  • Tasks: Implementation work items with hierarchical structure (TASK-XXXX-YY-ZZ format)
  • Architecture: ADRs and technical design documents
  • Relationships: Many-to-many links between requirements, tasks, and architecture
  • Events: Automatic logging of lifecycle events and status changes
  • Reviews: Comments and feedback on requirements and tasks

Entity ID Formats

  • Requirements: REQ-XXXX-TYPE-VV (e.g., REQ-0001-FUNC-00)
  • Tasks: TASK-XXXX-YY-ZZ (e.g., TASK-0001-00-00)
  • Architecture: ADR-XXXX (e.g., ADR-0001)

Environment Variables

  • LIFECYCLE_DB: Path to SQLite database file (default: "./lifecycle.db")

Development

Using uv (Recommended)

# Install dependencies
uv sync

# Run the server directly
uv run server.py

# Test with Claude Code
claude mcp add lifecycle $(which uv) -- --directory $(pwd) run server.py

Using pip (Traditional)

# Install in development mode
pip install -e .

# Run the server
lifecycle-mcp

# Test with Claude Code
claude mcp add lifecycle lifecycle-mcp

Building Desktop Extension (.dxt)

To create a Desktop Extension package for one-click installation:

# Build the .dxt file
make build-dxt
# or
python build_dxt.py

This creates lifecycle-mcp-1.0.0.dxt which users can double-click to install in Claude Desktop.