Cero dependencias locales — solo Docker. Levantás el stack completo con datos de demo precargados:

git clone https://github.com/YamilEzequiel/jitre.git
cd jitre
docker compose -f compose.demo.yml up

Abrí http://localhost:8080 y entrá con:

Si querés hackear el código (no solo probarlo), saltá al Dev setup abajo.

Jitre viene con dos piezas pensadas para que los developers trabajen sin abrir la web:

┌─────────────────────────────────────────────────────────────┐
│  ADMIN (una vez)                                            │
│  ▸ Clona el repo y deploya el backend en un server interno  │
│  ▸ Comparte la URL: https://jitre.miempresa.com             │
└─────────────────────────────────────────────────────────────┘
                              │
                              ▼
┌─────────────────────────────────────────────────────────────┐
│  CADA DEV (una vez por máquina, ~2 minutos)                 │
│  ▸ git clone <repo>                                         │
│  ▸ npm install                                              │
│  ▸ npm run vscode:install        ← instala la extensión     │
│  ▸ npm run mcp:setup             ← registra el MCP server   │
│  (apuntando a https://jitre.miempresa.com)                  │
└─────────────────────────────────────────────────────────────┘

git clone https://github.com/YamilEzequiel/jitre.git
cd jitre
npm install
npm run setup        # postgres + redis + migraciones + seed
npm run build        # build de los 3 packages
# … deployar el backend (docker / k8s / VM / lo que prefieras) …

El admin termina con un endpoint público interno tipo https://jitre.miempresa.com que va a compartir con su equipo.

git clone <repo>
cd jitre
npm install
npm run vscode:install              # detecta tu editor e instala el .vsix
npm run mcp:setup                   # registra el MCP en Claude / Cursor

Te va a preguntar por la URL del backend (https://jitre.miempresa.com), email y password. Después abrís VS Code → ícono J → Sign in y listo.

¿No querés prompts? Pasale flags:

npm run vscode:install -- --editor=code
npm run mcp:setup -- --client=claude-code \
  --api=https://jitre.miempresa.com \
  --email=dev@miempresa.com \
  --password='...'

npm run vscode:install -- --help y npm run mcp:setup -- --help para ver todos los flags.

🤖 ¿Sos un agente IA (Claude Code / Cursor / Aider) corriendo en este repo? Leé AGENTS.md — tiene la receta paso a paso para que la IA instale todo sola, sin que el dev tipee comandos.

Importante: ningún dev necesita docker, postgres ni redis locales para esto — solo Node 20+. El backend lo corre el admin en un servidor compartido.

Una vez registrado en Claude Code / Claude Desktop / Cursor, el LLM puede leer y actuar sobre Jitre sin que el dev abra la web:

Pregunta natural → el LLM encadena tool calls y devuelve una tabla.

"Creá una tarea en MKT" → jitre_create_task, devuelve la key generada.

> Listame mis tareas pendientes en Jitre ordenadas por prioridad.

  Claude llama jitre_whoami → jitre_list_projects → jitre_list_tasks
  (filtradas a tu userId), te devuelve la lista ordenada.

> Creá una tarea en el proyecto JIT con título "Fix login bug"
  y como descripción el último error que vimos.

  Claude llama jitre_create_task con projectId=JIT, title, description
  armada con el contexto de la conversación.

> Para JIT-3, ¿qué se discutió en los comentarios? Resumime.

  Claude llama jitre_get_task('JIT-3') + jitre_list_comments(taskId)
  y te tira un bullet de las decisiones tomadas.

> Marcá JIT-5 como done y dejá un comentario con el resumen del fix.

  Claude llama jitre_add_comment + jitre_complete_task en una sola tirada.

15 tools expuestas en total: jitre_whoami, list_workspaces, list_projects, get_project, list_project_statuses, list_tasks, get_task, create_task, update_task, change_task_status, complete_task, assign_task, list_comments, add_comment, search.

_{Las 4 vistas de la extensión en la activity bar de VS Code.}

• 4 vistas en la activity bar: Workspace, Projects, My Tasks, Notifications.
• Drag-and-drop entre statuses, filtros por prioridad / due date.
• Webview de detalle de tarea con cambio de status, prioridad, comentarios.
• Git integration: detecta feat/JIT-123-foo y muestra la tarea activa; comando para crear branch desde tarea (feat/<kind>-<key>-<slug>); prefijo automático del commit con [JIT-123].
• CodeLens: cualquier JIT-123 en un archivo → lens "View task".
• Timer: status bar con cronómetro en vivo.
• Realtime: Socket.IO al gateway /ws, refresca cuando alguien comenta o cambia status.
• AI: "Suggest subtasks" y "Regenerate description" llaman al /ai del backend.
• Atajos: Ctrl+Alt+J + K/O/T/N/C para search / open / timer / new / commit.

Detalles completos: packages/vscode-extension/README.md. Detalles del MCP: packages/mcp-server/README.md.

Jitre es una plataforma de gestión de proyectos pensada para equipos que valoran la productividad y la simplicidad. La diferencia: la IA está integrada como una pieza más del workflow — no como un chatbot pegado arriba.

Pensada para reemplazar el combo "Jira + Confluence + Slack + tablero de tiempos" con una sola herramienta coherente.

Las herramientas existentes están infladas: 30 menús para hacer 5 cosas. Jitre arranca desde cero con un criterio de UX firme:

• Atajos de teclado de primera clase — command palette estilo Linear/Raycast
• Signals + OnPush en todo — la UI no se siente como un SPA, se siente como una app
• AI-first donde aporta — sub-tareas, priorización, resúmenes, búsqueda semántica
• Realtime real — Socket.IO para cambios colaborativos sin recargar

Las capturas se actualizan a medida que avanza el desarrollo. Si querés ver el estado actual, levantá el proyecto siguiendo el quick start.

Dashboard — AI daily digest, sugerencias de prioridad y stats del workspace	Board — Kanban con tipos, prioridades, vencimientos y drag-and-drop
Task detail — comentarios, adjuntos, subtareas, links y time tracking	AI assist — generación de tareas con prompts y contexto del proyecto
Chat — canales por proyecto, DMs, threads y menciones en tiempo real	Time reports — distribución por usuario/proyecto/tarea con export CSV
Docs — base de conocimiento con árbol jerárquico y autosave	Org chart — organigrama por áreas con zoom, pan y filtros
Analytics — velocity, throughput, workload y consumo de IA	Notification settings — control granular de notificaciones in-app y email

• Workflows estilo Jira con statuses, transiciones y reglas
• Custom fields por proyecto (texto, número, fecha, select, multi-select)
• Labels, prioridades y assignees
• Planning view, board view, list view
• Filtros avanzados y búsqueda full-text
• Checklist de QA por tarea — criterios de aceptación como entidad de primera clase (pending / passed / failed / blocked) con trazabilidad real: quién aprobó cada criterio y cuándo

• Comentarios con menciones (@user) y notificaciones en tiempo real
• Attachments (drivers de storage abstraídos: local / S3-ready)
• Documentos colaborativos por proyecto
• Chat por proyecto (Slack-style threads)
• Activity feed y audit log completo

• Time tracking integrado en la tarea
• Analytics por proyecto, usuario y workspace
• Búsqueda semántica (no solo keyword matching)
• Command palette global con atajos Ctrl+K

• Generación de sub-tareas a partir de una descripción
• Priorización asistida de tareas
• Resúmenes automáticos de comentarios largos
• Abstracción multi-proveedor: Gemini 2.0 Flash hoy, lista para Anthropic / OpenAI

• Multi-tenant con workspaces y roles
• Realtime con Socket.IO
• Jobs en background con BullMQ + Redis
• Migraciones versionadas con TypeORM
• Health checks listos para Kubernetes

• Node.js 20+
• npm 10+
• Docker (para Postgres + Redis locales)

# 1. Clonar e instalar
git clone https://github.com/YamilEzequiel/jitre.git
cd jitre
npm install

# 2. Setup automatizado (copia .env, levanta Postgres + Redis,
#    corre migraciones y siembra datos de demo)
npm run setup

# 3. Arrancar backend y frontend (en dos terminales)
npm run dev:backend    # http://localhost:3000/api/v1/docs (Swagger)
npm run dev:frontend   # http://localhost:4200

El frontend proxea automáticamente /api/v1/* al backend en :3000.

Si preferís el camino sin instalación local de Node, mirá la sección Probar en 60 segundos que usa docker compose para todo.

Los scripts del root son aliases finos sobre los scripts de cada workspace. Si te conviene correrlos directo desde la carpeta del paquete (o si tu IDE necesita los comandos "crudos" tipo ng serve / nest start), acá están los equivalentes:

¿Cuándo necesitás el watch de shared? Solo si estás tocando enums, DTOs o interfaces de packages/shared. Si solo trabajás en backend o frontend, alcanza con dos terminales (backend + frontend). Si tocás shared, abrí una tercera terminal con npm run dev:shared para que TS recompile los tipos en vivo y backend/frontend los recojan automáticamente.

Puertos por defecto (sin tocar nada):

jitre/
├── packages/
│   ├── shared/      → DTOs, enums e interfaces compartidas (backend + frontend)
│   ├── backend/     → NestJS 11 API
│   └── frontend/    → Angular 21 UI
├── docker-compose.yml
└── package.json     → npm workspaces

packages/frontend/src/app/
├── core/         → servicios: auth, http interceptors, realtime, keyboard, toast, ai, analytics
├── stores/       → factoría createEntityStore<T> + TaskStore / ProjectStore / NotificationStore
├── shared/       → UI primitives: skeleton, toast, virtual-list, markdown pipe, command palette
├── layouts/      → MainLayoutComponent (auth shell), AuthLayoutComponent
├── features/     → auth, dashboard, projects, tasks, settings, analytics, notifications
├── app.routes.ts → rutas lazy con authGuard
└── app.config.ts → interceptors, providers, app initializer

Convenciones del frontend (no negociables):

• ✓ Standalone components — sin NgModules
• ✓ Signals + computed() — RxJS solo en interceptors
• ✓ OnPush en todo — ChangeDetectionStrategy.OnPush
• ✓ inject() — nada de constructor injection
• ✓ Reactive Forms — sin template-driven forms
• ✓ Control flow nativo — @if, @for, @switch

# Dev
npm run dev:backend           # NestJS en watch mode
npm run dev:frontend          # Angular dev server

# Build
npm run build                 # build de los 3 packages
npm run build:backend
npm run build:frontend

# Database
npm run db:migration:generate  # generar migración a partir de cambios en entities
npm run db:migration:create    # crear migración vacía
npm run db:migration:run       # aplicar migraciones pendientes
npm run db:migration:revert    # revertir la última
npm run db:migration:show      # ver estado

# Setup
npm run setup                 # one-shot: .env + docker + migrate + seed
npm run vscode:install        # buildea + instala la extensión de VS Code
npm run mcp:setup             # registra el MCP server en Claude / Cursor

# Docker (dev)
npm run docker:up             # levantar Postgres + Redis
npm run docker:down           # bajarlos
npm run docker:logs           # logs en vivo

# Demo stack (todo el producto en Docker)
npm run demo:up               # postgres + redis + backend + frontend + seed
npm run demo:down             # bajar el stack demo

# Testing
npm run test                  # tests de todos los workspaces
npm run test -w @jitre/backend     # Jest
npm run test -w @jitre/frontend    # Vitest 4 + Angular TestBed (jsdom)
npm run test:e2e:backend

¡Las contribuciones son bienvenidas! Vía Pull Request y comentarios en issues.

1. Abrí un issue primero si el cambio es grande (feature, refactor, nuevo módulo). Alineamos enfoque antes de que codees.
2. PRs chicos y enfocados. Commits convencionales, tests pasando, sin atribución de IA en los commits.
3. Comentá tu implementación en el PR. Decisiones, tradeoffs, qué descartaste — facilita la review y ayuda a otros a aprender.

La UX está pensada con un criterio específico (minimalista, AI-first, productividad). No aceptamos PRs que cambien la UX a grandes rasgos sin discusión previa: rediseños globales, restructuras de navegación, cambios de information architecture, sustitución del sistema de diseño, etc. → abrir issue primero.

Sí son bienvenidos sin discusión previa: fixes de UI rotos, mejoras de accesibilidad, ajustes finos de copy/spacing, traducciones nuevas, micro-interacciones que no alteren el flow.

• Mejoras de accesibilidad (ARIA, contraste, focus states)
• Traducciones (i18n)
• Tests faltantes en módulos existentes
• Documentación de endpoints en Swagger
• Performance: memoizaciones, OnPush misses, queries N+1

Hecho con cariño por Yamil Lazzari — Senior Software Architect.

• 💼 LinkedIn: linkedin.com/in/yamil-lazzari
• 🐙 GitHub: @YamilEzequiel
• 📦 Repo: github.com/YamilEzequiel/jitre

Si querés contactarme por consultorías, mentorías de arquitectura o licenciamiento comercial de Jitre (reventa / SaaS gestionado / white-label), por LinkedIn está perfecto.

Copyright © Yamil Lazzari. Todos los derechos reservados.

Jitre se distribuye bajo la Elastic License 2.0 (ELv2) — una licencia source-available (no es OSS según OSI). En una línea: podés usarlo, modificarlo, distribuirlo y desplegarlo dentro de tu empresa sin pagar nada; lo que no podés hacer es ofrecerlo como servicio gestionado a terceros, eludir el licenciamiento ni remover los avisos de copyright.

• Uso interno en empresas: correrlo dentro de tu organización como herramienta operacional, incluso con fines comerciales.
• Uso personal y educativo: hobby, estudio, investigación, cursos.
• Organizaciones sin fines de lucro: ONGs, caridad, gobierno.
• Fork y modificación: tocar el código y distribuir tus cambios — siempre que respetes las limitaciones.
• Distribución: copiar y compartir el software con los términos adjuntos.

• SaaS de terceros / managed service: ofrecer Jitre (modificado o no) como servicio hosteado donde otros accedan a una parte sustancial de sus features. Si querés vender un Jitre-as-a-Service, hablamos.
• Eludir el licensing: mover, cambiar, deshabilitar o evadir la funcionalidad de licenciamiento.
• Re-branding sin avisos: remover u ofuscar los avisos de copyright, marca o licencia.

Texto legal completo en LICENSE. Para licencias comerciales distintas (reventa / SaaS / white-label) contactar al autor.

El software se entrega "AS IS", sin garantías de ningún tipo. El autor no se hace responsable de daños derivados de su uso.