Skip to content
Back to search

taskflow

Lista de tareas Kanban con MCP server para que se puedan conectar y desarrollar por un agente externo

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/juancarbajal--taskflow/badge.svg)](/listings/juancarbajal--taskflow)

HTML

<a href="/listings/juancarbajal--taskflow"><img src="/api/listings/juancarbajal--taskflow/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 182 lines
  1. # Taskflow 📋🤖
  2. > **El tablero Kanban personal para terminal donde humanos y agentes de Inteligencia Artificial colaboran en tiempo real sobre la misma base de datos local.**
  3. ---
  4. ## 🎯 Visión de Producto (Product Overview)
  5. Bienvenido a **Taskflow**. Como desarrolladores y profesionales técnicos, a menudo nos encontramos en una encrucijada: queremos la velocidad y la concentración que brinda la terminal para gestionar nuestras tareas del día a día, pero al mismo tiempo queremos delegar trabajo repetitivo o de investigación a asistentes de IA como Claude, Cursor o scripts autónomos.
  6. **Taskflow** resuelve este desafío combinando dos mundos en un único binario ultra liviano:
  7. 1. **Un Tablero Kanban interactivo en consola:** Con soporte total para teclado y ratón (clic, scroll, botones interactivos) para gestionar tu flujo personal.
  8. 2. **Un Servidor MCP (Model Context Protocol) integrado:** Tus agentes de IA pueden inspeccionar las tareas pendientes marcadas como "Delegables a IA", reclamarlas de forma atómica para resolverlas, crear subtareas y reportar resultados en tiempo real.
  9. Tanto tú como tus agentes de IA trabajan sobre la misma base de datos SQLite local (`WAL` mode). Cualquier acción que realice un agente se refleja en tu pantalla en menos de 2 segundos.
  10. ---
  11. ## ✨ Características Principales
  12. - 🖱️ **TUI Dinámica con Ratón y Teclado:** Clic en tarjetas, doble clic para ver el detalle y notas de la IA, scroll con la rueda del ratón y botones de acción rápida.
  13. - 🔄 **Sincronización en Vivo:** Polling continuo a SQLite; si una IA reclama una tarea o la envía a revisión, la tarjeta se mueve sola entre columnas en tiempo real.
  14. - 🤖 **Diseñado para Delegar en IA:** Atributo `delegable_to_ai` por tarea y campo `ai_notes` para que la IA documente lo realizado.
  15. - ⚡ **Cero Dependencias Externas (CGO-free):** Compilado con driver SQLite nativo en Go puro (`modernc.org/sqlite`), garantizando portabilidad y velocidad.
  16. - 🔌 **Compatibilidad Nativa con MCP:** Expone Resources y Tools estándar vía `stdio` JSON-RPC 2.0.
  17. ---
  18. ## 🚀 Inicio Rápido para el Usuario
  19. ### 1. Compilación / Instalación
  20. Asegúrate de contar con Go 1.23 o superior:
  21. ```bash
  22. # Compilar el binario único
  23. go build -o taskflow ./cmd/taskflow
  24. # (Opcional) Mover al PATH del sistema
  25. sudo mv taskflow /usr/local/bin/
  26. ```
  27. ### 2. Uso de la Interfaz Interactiva (TUI)
  28. Para abrir tu tablero Kanban interactivo, ejecuta:
  29. ```bash
  30. taskflow
  31. ```
  32. *(Opcional: puedes indicar una base de datos específica con `taskflow --db /ruta/mi-tablero.db` o la variable de entorno `export TASKFLOW_DB=/ruta/mi-tablero.db`).*
  33. #### 🎮 Controles y Navegación
  34. | Acción | Ratón | Teclado |
  35. | :--- | :--- | :--- |
  36. | **Seleccionar Tarea / Columna** | Clic izquierdo sobre tarjeta o columna | Flechas direccionales (`←`, `→`, `↑`, `↓`) o `h`, `j`, `k`, `l` |
  37. | **Ver Detalles / Notas de IA** | Doble clic en tarjeta | `Enter` |
  38. | **Desplazar listas largas** | Rueda del ratón (Scroll Up / Down) | Flechas (`↑`, `↓`) / Viewport |
  39. | **Nueva Tarea** | Clic en `[+ Nueva Tarea]` | `n` |
  40. | **Editar Tarea** | — | `e` (permite editar título, descripción, tags y estado) |
  41. | **Mover a "En Proceso"** | Clic en `[En Proceso]` | `2` o `]` (avanzar columna) |
  42. | **Aprobar / Mover a "Done"** | Clic en `[Aprobar / Mover a Done]` | `a` o `4` |
  43. | **Devolver a "Pending"** | Clic en `[Devolver a Pending]` | `p` o `1` |
  44. | **Alternar Delegable a IA** | Clic en `[Toggle IA]` | `t` |
  45. | **Eliminar Tarea** | — | `d` (solicita confirmación) |
  46. | **Sincronizar Manualmente** | — | `r` (se sincroniza solo cada 2s) |
  47. | **Salir** | — | `q` o `Ctrl+C` |
  48. ---
  49. ## 🤖 Integración con Clientes de Inteligencia Artificial (MCP)
  50. Taskflow incluye un servidor **MCP (Model Context Protocol)** que opera sobre `stdio`. Cualquier herramienta compatible con MCP (Claude Desktop, Cursor, extensiones de VS Code, Goose, etc.) puede interactuar de forma segura con tu gestor de tareas.
  51. ### Modo Servidor MCP
  52. El subcomando `taskflow mcp` inicia el transporte JSON-RPC silenciando cualquier salida no perteneciente al protocolo:
  53. ```bash
  54. taskflow mcp --db /ruta/absoluta/a/taskflow.db
  55. ```
  56. ### Configuración en Claude Desktop
  57. Agrega lo siguiente en tu archivo de configuración de Claude Desktop (`claude_desktop_config.json`):
  58. - **Linux:** `~/.config/Claude/claude_desktop_config.json`
  59. - **macOS:** `~/Library/Application Support/Claude/claude_desktop_config.json`
  60. - **Windows:** `%APPDATA%\Claude\claude_desktop_config.json`
  61. ```json
  62. {
  63. "mcpServers": {
  64. "taskflow": {
  65. "command": "/ruta/absoluta/a/taskflow",
  66. "args": ["mcp", "--db", "/ruta/absoluta/a/taskflow.db"]
  67. }
  68. }
  69. }
  70. ```
  71. ### Configuración en Cursor / Otros Clientes MCP
  72. En los ajustes de tu cliente de IA agrega el servidor:
  73. - **Type / Transport:** `command` / `stdio`
  74. - **Command:** `/ruta/absoluta/a/taskflow`
  75. - **Args:** `["mcp", "--db", "/ruta/absoluta/a/taskflow.db"]`
  76. ---
  77. ## 🛠️ Capacidades Expuestas a los Agentes IA
  78. Cuando conectas Taskflow a un modelo de IA, este adquiere las siguientes capacidades controladas:
  79. ### 📖 Recursos de Lectura (Resources)
  80. - **`tasks://pending-for-ai`**: Permite al modelo leer en formato JSON todas las tareas actualmente en estado `pending` marcadas como `delegable_to_ai = 1`.
  81. ### ⚙️ Herramientas de Ejecución (Tools)
  82. 1. **`list_available_tasks`**
  83. - **Propósito:** Lista tareas delegables a IA, con opción de filtrar por etiqueta temática.
  84. - **Parámetros:**
  85. - `tag_filter` *(string, opcional)*: Ej. `"frontend"`, `"docs"`, `"go"`.
  86. 2. **`claim_task`**
  87. - **Propósito:** Reclama de forma atómica una tarea disponible y la mueve a `IN PROGRESS`, asignando el nombre del agente.
  88. - **Concurrencia:** Si dos agentes intentan reclamar la misma tarea a la vez, SQLite garantiza que solo uno tiene éxito y el otro recibe error sin bloqueos ni colisiones.
  89. - **Parámetros:**
  90. - `task_id` *(number, requerido)*: ID numérico de la tarea.
  91. - `agent_name` *(string, requerido)*: Identificador del agente (ej. `"Claude-Code"`).
  92. 3. **`submit_task_result`**
  93. - **Propósito:** Informa la resolución del trabajo, guarda las notas en `ai_notes` y transiciona la tarea a `REVIEW` (para tu aprobación humana) o `DONE`.
  94. - **Parámetros:**
  95. - `task_id` *(number, requerido)*: ID de la tarea que estaba en progreso.
  96. - `ai_notes` *(string, requerido)*: Explicación de los cambios realizados o enlaces a commits/archivos.
  97. - `requires_review` *(boolean, requerido)*: `true` para pasar a `REVIEW` y esperar el visto bueno humano; `false` para marcar como `DONE` directamente.
  98. 4. **`create_subtask`**
  99. - **Propósito:** Permite que un agente divida un requerimiento creando nuevas tareas dependientes en estado `pending`.
  100. - **Parámetros:**
  101. - `title` *(string, requerido)*
  102. - `description` *(string, opcional)*
  103. - `delegable_to_ai` *(boolean, requerido)*
  104. - `tags` *(array de strings, opcional)*
  105. ---
  106. ## 📁 Arquitectura y Desarrollo
  107. El proyecto sigue una arquitectura limpia (**Clean Architecture**) en Go:
  108. ```text
  109. .
  110. ├── cmd/
  111. │ └── taskflow/
  112. │ └── main.go # CLI Router (TUI vs MCP)
  113. ├── internal/
  114. │ ├── domain/ # Entidades, estados y validaciones puras
  115. │ ├── repository/ # SQLite (WAL, busy_timeout=5000, atomic updates)
  116. │ ├── mcp/ # Servidor JSON-RPC 2.0 y tools MCP
  117. │ └── tui/ # Bubble Tea, Lipgloss y gestión de eventos de ratón
  118. ├── docs/
  119. │ ├── specs/ # Especificaciones funcionales (SPEC-001, SPEC-002)
  120. │ ├── arqs/ # Decisiones arquitectónicas (ARCH-001, ARCH-002)
  121. │ └── plans/ # Planes de ejecución y checklists (PLAN-001, PLAN-002)
  122. └── go.mod
  123. ```
  124. ### Ejecutar Tests y Verificación de Concurrencia
  125. ```bash
  126. # Ejecutar todas las pruebas con detector de carreras (race detector)
  127. go test -v -race ./...
  128. ```
  129. ---
  130. ## 📄 Licencia
  131. Código abierto bajo la licencia MIT. ¡Siéntete libre de adaptarlo y usarlo para potenciar tus flujos de trabajo con IA!

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.