Task Manager (Go)

Un servidor inteligente de gestión de tareas y proyectos con análisis de complejidad impulsado por LLM y creación inteligente de subtareas, que utiliza almacenamiento basado en archivos markdown.

GitHub

Documentación

🚀 Servidor MCP de Gestión de Tareas (Go)

Una potente implementación en Go del servidor del Protocolo de Contexto de Modelos (MCP) para la gestión inteligente de tareas y proyectos. Este servidor se integra perfectamente con aplicaciones LLM para proporcionar capacidades avanzadas de gestión de tareas con análisis automático de complejidad y creación inteligente de subtareas.

✨ Características

📋 Gestión Básica de Tareas

  • Organización por Proyectos: Crea y gestiona múltiples proyectos con archivos de tareas basados en Markdown
  • Tareas Jerárquicas: Soporte para tareas con subtareas y dependencias
  • Seguimiento de Estados: Gestión integral de estados (pendiente, en progreso, completado, bloqueado)
  • Navegación Inteligente: Obtén automáticamente las siguientes tareas no completadas
  • Almacenamiento Basado en Archivos: Archivos Markdown legibles para un control de versiones sencillo

🧠 Inteligencia Mejorada (Impulsada por LLM)

  • Análisis de Complejidad: El LLM evalúa la complejidad de las tareas y sugiere desgloses
  • Creación Inteligente de Subtareas: Desglosa automáticamente tareas complejas (recursivo hasta 3 niveles)
  • Gestión de Opciones: Maneja múltiples enfoques de implementación con entrada estructurada del usuario
  • Seguimiento de Decisiones: Recuerda y rastrea las decisiones del usuario en los archivos del proyecto

🏷️ Metadatos Enriquecidos

  • Categorías: [MVP], [AI], [UX], [INFRA] para una clasificación organizada de tareas
  • Prioridades: P0 (Crítica), P1 (Alta), P2 (Media), P3 (Baja)
  • Niveles de Complejidad: Baja, Media, Alta con horas estimadas
  • Dependencias: Rastrea relaciones y requisitos previos de tareas

🚀 Inicio Rápido

Requisitos Previos

  • Go 1.21+: Descargar Go
  • Git: Para clonar el repositorio
  • Cliente MCP: Cualquier cliente compatible con MCP (Claude Desktop, etc.)

Instalación

# 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

Configuración

Crea un archivo .env (opcional):

# 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

🔧 Uso

Ejecutar el Servidor

Método 1: Ejecución Directa (Stdio)

# Run with stdio transport (default)
./task-manager-go

# Or with Go run
go run main.go

Método 2: Transporte SSE (Basado en Web)

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

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

🔌 Integración con Clientes MCP

Configuración de Claude Desktop

Añade a tu claude_desktop_config.json de Claude Desktop:

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

Alternativa: Usando Go Run

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

Configuración SSE (para clientes web)

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

🛠️ Herramientas MCP Disponibles

📁 Gestión de Proyectos

  • create_task_file - Crea nuevos archivos de tareas de proyecto

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

  • list_projects - Lista todos los proyectos disponibles

    Parameters: None
Returns: Array of project names

✅ Operaciones de Tareas

  • add_task - Añade tareas con descripciones y subtareas

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

  • update_task_status - Actualiza el estado de tareas/subtareas

    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 - Obtiene la siguiente tarea no completada

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

🧠 Características Avanzadas (Próximamente)

  • parse_prd - Convierte PRDs en tareas estructuradas
  • expand_task - Desglosa tareas en subtareas
  • estimate_task_complexity - Análisis de complejidad basado en LLM
  • suggest_next_actions - Sugerencias impulsadas por IA
  • get_task_dependencies - Rastrea relaciones entre tareas
  • generate_task_file - Genera plantillas de archivos

📖 Ejemplos de Uso

Flujo de Trabajo Básico

  1. Crea un nuevo proyecto:

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

  2. Añade tareas con análisis de complejidad:

    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", ...])

  3. Realiza seguimiento del progreso:

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

  4. Actualiza el estado:

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

Ejemplo de Salida de Archivo de Tareas

# 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

---

🏗️ Estructura del Proyecto

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

🧠 Sistema de Reglas Mejorado

Creación Automática de Subtareas

El sistema desglosa inteligentemente tareas complejas:

  1. Análisis de Complejidad del LLM: El LLM que realiza la llamada evalúa las descripciones de las tareas
  2. Desglose Automático: Las tareas de alta complejidad se dividen en subtareas manejables
  3. Procesamiento Recursivo: Las subtareas también se analizan (hasta 3 niveles de profundidad)
  4. Umbrales Inteligentes: Detección de complejidad configurable

Gestión de Opciones

Maneja múltiples enfoques de implementación:

  1. Detección de Enfoques: El LLM identifica cuándo existen múltiples enfoques
  2. Opciones Estructuradas: Presenta opciones en un formato claro
  3. Seguimiento de Decisiones: Almacena las selecciones del usuario en los archivos del proyecto
  4. Preservación del Contexto: Recuerda decisiones para referencia futura

Ejemplo de Flujo de Opciones

**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.

🔧 Desarrollo

Compilación

# 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

Pruebas

# 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

Contribuciones

  1. Haz un fork del repositorio
  2. Crea una rama de características: git checkout -b feature-name
  3. Realiza tus cambios y prueba exhaustivamente
  4. Haz commit con mensajes claros: git commit -m "Add feature X"
  5. Haz push y crea una Solicitud de Extracción (Pull Request)

📋 Hoja de Ruta

  • Gestión Básica de Tareas - Operaciones CRUD básicas
  • Integración del Servidor MCP - Transportes Stdio y SSE
  • Almacenamiento en Markdown - Archivos de tareas legibles
  • Análisis de PRDs - Convierte requisitos en tareas
  • Herramientas Avanzadas - Análisis de complejidad, sugerencias
  • Flujos de Opciones - Toma de decisiones interactiva
  • Dependencias - Gestión de relaciones entre tareas
  • Plantillas - Generación de archivos a partir de tareas

📄 Licencia

Licencia MIT - consulta el archivo LICENSE para más detalles.

🤝 Soporte

Hecho con ❤️ para el ecosistema MCP