Task Manager (Go)

An intelligent task and project management server with LLM-driven complexity analysis and smart subtask creation, using file-based markdown storage.

A powerful Go implementation of the Model Context Protocol (MCP) server for intelligent task and project management. This server integrates seamlessly with LLM applications to provide advanced task management capabilities with automatic complexity analysis and smart subtask creation.

- Project-Based Organization: Create and manage multiple projects with markdown-based task files
- Hierarchical Tasks: Support for tasks with subtasks and dependencies
- Status Tracking: Comprehensive status management (todo, in_progress, done, blocked)
- Smart Navigation: Get next uncompleted tasks automatically
- File-Based Storage: Human-readable markdown files for easy version control

- Complexity Analysis: LLM evaluates task complexity and suggests breakdowns
- Smart Subtask Creation: Automatically break down complex tasks (recursive up to 3 levels)
- Choice Management: Handle multiple implementation approaches with structured user input
- Decision Tracking: Remember and track user decisions in project files

- Categories: [MVP], [AI], [UX], [INFRA] for organized task classification
- Priorities: P0 (Critical), P1 (High), P2 (Medium), P3 (Low)
- Complexity Levels: Low, Medium, High with estimated hours
- Dependencies: Track task relationships and prerequisites

- Go 1.21+:Download Go
- Git: For cloning the repository
- MCP Client: Any MCP-compatible client (Claude Desktop, etc.)

# Clone the repository git clone https://github.com/gosvig123/mcp-task-manager-go.git cd mcp-task-manager-go # Install dependencies go mod tidy # Build the server go build -o task-manager-go main.go # Test the installation go run cmd/test/main.go

# Transport type (stdio or sse) TRANSPORT=stdio # For SSE transport (web-based clients) HOST=0.0.0.0 PORT=8050 # Task storage directory (relative to project root) TASKS_DIR=./tasks # Task management settings MAX_RECURSION_DEPTH=3 AUTO_SUBTASK_CREATION=true

# Run with stdio transport (default) ./task-manager-go # Or with Go run go run main.go

# Set environment variable and run TRANSPORT=sse ./task-manager-go # Or export and run export TRANSPORT=sse ./task-manager-go

{ "mcpServers": { "task-manager-go": { "command": "/path/to/your/task-manager-go", "env": { "TRANSPORT": "stdio", "TASKS_DIR": "tasks" } } } }

{ "mcpServers": { "task-manager-go": { "command": "go", "args": ["run", "main.go"], "cwd": "/path/to/mcp-task-manager-go", "env": { "TRANSPORT": "stdio" } } } }

{ "mcpServers": { "task-manager-go": { "transport": "sse", "url": "http://localhost:8050/sse" } } }

-

create_task_file- Create new project task files

Parameters: project_name (string) Returns: Confirmation with file path

list_projects- List all available projects

Parameters: None Returns: Array of project names

-

add_task- Add tasks with descriptions and subtasks

Parameters: - project_name (string) - title (string) - description (string) - subtasks (array, optional) - batch_mode (boolean, optional) Returns: Confirmation message

update_task_status- Update task/subtask status

Parameters: - project_name (string) - task_title (string) - subtask_title (string, optional) - status (enum: todo|in_progress|done|blocked) Returns: Status update confirmation

get_next_task- Get next uncompleted task

Parameters: project_name (string) Returns: JSON with task and subtask details

- parse_prd- Convert PRDs into structured tasks
- expand_task- Break down tasks into subtasks
- estimate_task_complexity- LLM-based complexity analysis
- suggest_next_actions- AI-powered suggestions
- get_task_dependencies- Track task relationships
- generate_task_file- Generate file templates

LLM: "Create a task file for my web app project" → Calls: create_task_file(project_name="web-app")

LLM: "Add a task to implement user authentication" → LLM analyzes complexity → High complexity detected → Calls: add_task(project_name="web-app", title="User Authentication", description="Implement secure user login/logout system", subtasks=["Set up auth middleware", "Create login endpoints", ...])

LLM: "What should I work on next?" → Calls: get_next_task(project_name="web-app") → Returns: {"task": "User Authentication", "subtask": "Set up auth middleware"}

LLM: "Mark the auth middleware as completed" → Calls: update_task_status(project_name="web-app", task_title="User Authentication", subtask_title="Set up auth middleware", status="done")

# Project Tasks ## Categories - [MVP] Core functionality tasks - [AI] AI-related features - [UX] User experience improvements - [INFRA] Infrastructure and setup ## Priority Levels - P0: Blocker/Critical - P1: High Priority - P2: Medium Priority - P3: Low Priority ## Task 1: [MVP] User Authentication (P0) Implement secure user login/logout system with session management ### Dependencies: - Task 2 ### Complexity: high Estimated hours: 16 ### Subtasks: - [x] Set up auth middleware - [ ] Create login endpoints - [ ] Add password hashing - [ ] Implement session management ---

mcp-task-manager-go/ ├── main.go # Entry point ├── cmd/ │ └── test/ # Test utilities ├── internal/ │ ├── server/ # MCP server implementation │ │ └── server.go # Tool handlers and server setup │ └── task/ # Task management core │ ├── models.go # Data structures │ ├── manager.go # File operations │ ├── markdown.go # Markdown processing │ └── validation.go # Input validation ├── tasks/ # Task files storage (created at runtime) ├── go.mod # Go module definition └── README.md # This file

The system intelligently breaks down complex tasks:
- LLM Complexity Analysis: The calling LLM evaluates task descriptions
- Automatic Breakdown: High complexity tasks get broken into manageable subtasks
- Recursive Processing: Subtasks are also analyzed (up to 3 levels deep)
- Smart Thresholds: Configurable complexity detection

Handle multiple implementation approaches:
- Approach Detection: LLM identifies when multiple approaches exist
- Structured Choices: Present options in a clear format
- Decision Tracking: Store user selections in project files
- Context Preservation: Remember decisions for future reference

Choice: Choose authentication method Options: - [ ] JWT tokens - [x] Session-based auth - [ ] OAuth integration Reasoning: Session-based auth is simpler for MVP and provides better security for this use case.

# Build for current platform go build -o task-manager-go main.go # Build for different platforms GOOS=linux GOARCH=amd64 go build -o task-manager-go-linux main.go GOOS=windows GOARCH=amd64 go build -o task-manager-go.exe main.go

# Run basic functionality test go run cmd/test/main.go # Run all tests (when implemented) go test ./... # Test with a real MCP client ./task-manager-go

- Fork the repository
- Create a feature branch:git checkout -b feature-name
- Make your changes and test thoroughly
- Commit with clear messages:git commit -m "Add feature X"
- Push and create a Pull Request

- Core Task Management- Basic CRUD operations
- MCP Server Integration- Stdio and SSE transports
- Markdown Storage- Human-readable task files
- PRD Parsing- Convert requirements to tasks
- Advanced Tools- Complexity analysis, suggestions
- Choice Workflows- Interactive decision making
- Dependencies- Task relationship management
- Templates- File generation from tasks

MIT License - seeLICENSEfile for details.

- Issues:GitHub Issues
- Discussions:GitHub Discussions
- Documentation: This README and inline code comments

Comprehensive Trello integration: 46 tools covering boards, cards, lists, labels, checklists, attachments, members, custom fields, and search. Read-only mode, image attachment auto-download. Active fork of kocakli/Trello-Desktop-MCP integrating contributions from across the Trello MCP fork ecosystem