convez.ai
MCP ServerAutomaçãoIntermediário
sonht113

Foundry — Gerenciador de Tarefas Nativo para IA

sonht113/Foundry

Kanban + MCP server para humanos e agentes de IA colaborarem offline

Ver no GitHub
InicialPluginScore · de 0 a 100

Workspace de gerenciamento de tarefas híbrido onde humanos (UI desktop) e agentes de IA (MCP) são cidadãos de primeira classe. Construído sobre SQLite local com 28 ferramentas MCP, suportando Kanban, projetos, rastreamento de tarefas e síncrona com Claude, Cursor e outros agentes.

Instalação

$npx convez-ai sonht113/Foundry

1 comando no terminal: detecta o formato do repositório (marketplace ou plugin avulso) e instala via Claude Code. Requer Node 18+ e o Claude Code instalado.

Métricas

Estrelas
0
Forks
1
Acompanhando
0
Saúde
28%
Último commit
há 5 meses
Versão
v0.3.3
Issues abertas
0
Contribuidores
1

Casos de uso

  • Agentes de IA gerenciarem tarefas via MCP enquanto humanos usam UI desktop
  • Equipes híbridas coordenarem trabalho com rastreamento em tempo real
  • Automação de fluxos de trabalho com integração direta a agentes Claude/Cursor

Veredito

Projeto maduro (v0.3.3) que resolve um problema real: colaboração human-AI em tarefas. A arquitetura monorepo limpa, MCP completo com 28 tools e persistência SQLite local tornam-no sólido para produção. Recomendado para equipes que querem agentes de IA acessando genuinamente um workspace compartilhado.

README

A tradução para o português deste README ainda está na fila.

Foundry — AI-Native Task Manager

An AI-native task manager where both humans (UI) and AI agents (MCP) are first-class citizens. Built on SQLite (local-first, persisted to disk).

Screenshots

Features

  • Kanban board with drag-and-drop (dnd-kit) for task management
  • Full MCP server (28 tools) — AI agents like OpenCode, Claude Code, Cursor, Copilot interact directly with tasks
  • Project management — create, archive, delete projects with columns and tasks
  • Task tracking — statuses (todo → doing → review → done), priorities, assignees, dates, tags, notes
  • Desktop app — cross-platform Electron shell (Windows, macOS, Linux)
  • Offline-first — SQLite backed, fully offline; no cloud services required

Monorepo Structure

Foundry/
├── apps/
│   ├── electron/          # Electron desktop app (React 19 + Vite + TailwindCSS 4)
│   └── mcp-server/        # MCP server (28 tools, stdio transport)
└── packages/
    ├── database/          # SQLite (sql.js) — raw SQL queries + repositories
    ├── domain/            # Business logic + validators (Zod)
    └── shared/            # Shared types + utilities

Stack

LayerTechnology
Desktop shellElectron 33
UIReact 19 + TypeScript + Vite 6 + TailwindCSS 4
StateZustand 5
DatabaseSQLite (sql.js) — persisted to disk
MCP@modelcontextprotocol/sdk
Drag-drop@dnd-kit/core + @dnd-kit/sortable
Packagingelectron-builder
Monorepopnpm + Turborepo
Lint/formatESLint 9 + Prettier 3

Quick Start

Prerequisites

  • Node.js 18+
  • pnpm 10+

Setup

# 1. Clone and install
git clone <repo-url>
cd Task_Kanban/Foundry

# 2. Install dependencies
pnpm install

# 3. Start development
pnpm dev          # Electron + Vite dev mode

The database file is created automatically at:

  • Windows: %APPDATA%\Foundry\foundry.db
  • macOS: ~/Library/Application Support/Foundry/foundry.db
  • Linux: ~/.local/share/Foundry/foundry.db

To use a custom path, set the SQLITE_DATA_DIR environment variable.

Environment Variables

VariableDescription
SQLITE_DATA_DIRCustom file path for SQLite database (optional — auto-defaults per OS)

Commands

pnpm dev           # Vite + Electron dev mode
pnpm build         # Production build (Vite + tsc + tsc-alias)
pnpm lint          # ESLint check
pnpm format        # Prettier format
pnpm typecheck     # TypeScript check (NODE_OPTIONS="--max-old-space-size=4096" recommended)
pnpm mcp-server    # Start MCP server standalone

Packaging for Distribution

# From Foundry/apps/electron/:
npm run pack:win       # Windows NSIS installer
npm run pack:mac       # macOS DMG (requires macOS)
npm run pack:linux     # Linux AppImage (can build from any platform)

Output goes to apps/electron/dist/installers/.

CI/CD (GitHub Actions)

Push to main or trigger manually via Actions tab — builds artifacts for all 3 platforms:

  • macOS: .dmg
  • Linux: .AppImage
  • Windows: .exe (NSIS installer)

Download artifacts from the workflow run summary page.

MCP Server

The MCP server exposes 28 tools via stdio transport:

CategoryTools
Projectlist_projects, get_project, create_project, update_project, delete_project, archive_project, unarchive_project
Tasklist_tasks, get_task, create_task, update_task, delete_task, move_task, search_tasks
Taglist_tags, create_tag, delete_tag
Notelist_notes, create_note, update_note, delete_note
Columnlist_columns, create_column, delete_column, reorder_columns
AIanalyze_project, generate_tasks_from_prompt, breakdown_task

Connecting AI Clients

The Foundry MCP server uses SQLite (local, persisted to disk) via stdio transport.

Development vs Installed: When running from source, the server path is apps/mcp-server/dist/server.js. When Foundry is installed (via NSIS/DMG/AppImage), the MCP server is bundled at resources/mcp-server/server.js and dependencies live at resources/app/node_modules. Open the app and go to Settings → MCP Server to see and copy the exact config for your environment.

Build first: pnpm build, then configure your MCP client:

Development (source checkout):

{
  "mcpServers": {
    "foundry": {
      "command": "node",
      "args": ["/absolute/path/to/Foundry/apps/mcp-server/dist/server.js"]
    }
  }
}

Optionally set a custom data directory:

{
  "mcpServers": {
    "foundry": {
      "command": "node",
      "args": ["/absolute/path/to/Foundry/apps/mcp-server/dist/server.js"],
      "env": {
        "SQLITE_DATA_DIR": "/path/to/foundry.db"
      }
    }
  }
}

Installed (Windows example):

{
  "mcpServers": {
    "foundry": {
      "command": "node",
      "args": [
        "C:\\Program Files\\Foundry\\resources\\mcp-server\\server.js"
      ],
      "env": {
        "NODE_PATH": "C:\\Program Files\\Foundry\\resources\\app\\node_modules"
      }
    }
  }
}

Paths vary by OS and install location. Open Settings → MCP Server in the Foundry app to get the exact config.

Client-Specific Config Paths

ClientWindowsmacOS / LinuxNotes
OpenCode%APPDATA%\opencode\opencode.json~/.config/opencode/opencode.jsonOr opencode.json in project root. Uses mcp key with type: "local"
Claude Code%APPDATA%\Claude Code\settings.json~/.claude/settings.jsonStandard mcpServers format
Claude Desktop%APPDATA%\Claude\claude_desktop_config.json~/Library/Application Support/Claude/claude_desktop_config.json (macOS) / ~/.config/Claude/claude_desktop_config.json (Linux)Standard mcpServers format
CursorUI: Settings → MCP → Add serverSame + .cursor/mcp.json per projectStandard mcpServers format
GitHub Copilot%USERPROFILE%\.copilot\mcp.json~/.copilot/mcp.jsonUses "servers" key instead of "mcpServers"
Windsurf%APPDATA%\windsurf\mcp.json~/.windsurf/mcp.jsonStandard mcpServers format

Architecture

  • Local-first: SQLite (sql.js) — data persisted to disk, fully offline, no cloud services required
  • Process model: Electron main process hosts services; renderer talks via IPC (contextBridge); MCP server runs as stdio child process
  • ID format: nanoid with prefixes (proj_, task_, tag_, note_, hist_)
  • Error handling: Zod validation + custom AppError hierarchy + Zustand error states + toast notifications

Data Model

TableDescription
projectsTop-level container with name, description
tasksCards with title, status, priority, dates, assignee
tagsCase-insensitive labels
task_tagsMany-to-many join table
notesMarkdown notes attached to tasks
task_historyAudit trail for task changes
settingsUser/app configuration key-value pairs

Task statuses: todo → doing → review → done Priorities: low, medium, high, critical

Roadmap

PhaseStatusScope
Phase 1DoneElectron + Project/Task CRUD + dashboard UI
Phase 2DoneMCP server (28 tools) + SQLite migration
Phase 3In progressAI roadmap generator, sprint planner, task breakdown
Phase 4PlannedReal-time sync, team workspace, multi-agent support

License

MIT

Ver o original no GitHub

Bom para

Relacionados