 |
Thask it, done. |  |
Map dependencies visually. Break nothing.
Dependency visualization for AI-assisted development teams.
Spreadsheets lose context. Linear issue trackers hide relationships. Thask maps your product as a living graph — so you can see what breaks before it breaks.
|
Ship with |
Every flow, task, and bug is a node. Every dependency is a visible edge. No more hidden connections. |
One click shows which nodes are affected by recent changes. Catch regressions before they ship. |
|
Drag-and-drop nodes with 7 types — Flow, Branch, Task, Bug, API, UI, and Group. Connect them by hovering and dragging the edge handle. Auto-layout with the fCOSE force-directed algorithm.
Toggle Impact Mode to instantly highlight changed nodes and their downstream dependencies. Dimmed nodes are safe; glowing nodes need attention.
Organize related nodes into collapsible groups. Drag nodes in and out. Resize groups freely. Double-click to collapse with a child count badge.
Track every node as PASS / FAIL / IN_PROGRESS / BLOCKED with color-coded visuals. Filter the graph by node type or status to focus on what matters.
Slide-out panel with full editing — title, description (with markdown rendering), type, status, tags, connected nodes, and a complete change history audit log.
Five edge types with distinct colors: depends_on, blocks, related, parent_child, triggers. Draggable waypoints for edge routing. Click any edge to change its type or delete it.
Full CLI for terminal workflows (npm install -g @thask-org/cli). MCP server mode for AI agent integration — Claude Code and Cursor can query and modify your graph directly. CLI Reference · MCP Guide
Scan Go codebases to auto-generate dependency graphs. thask scan --path . parses go.mod and imports, creating nodes and edges automatically. Extensible via plugin system.
Detect dependency cycles (Tarjan DFS) and find the critical path (longest depends_on/blocks chain). Toggle Analysis Mode (Shift+A) to visualize cycles and critical path on the canvas.
Versioned REST API at /api/v1/ for third-party integrations. OpenAPI 3.1 spec, interactive Scalar docs, structured error responses, and idempotency support. API Guide
Four team roles — Owner, Admin, Member, Viewer — with granular permissions. Per-project roles (Editor, Viewer). API key authentication for programmatic access.
Share projects via link with viewer or editor access. Manage per-project members with granular roles. Public shared views support realtime collaboration. Embeddable graph views and OG image generation.
Start new projects from built-in templates: API Flow, Microservice Map, Sprint Board. One-click apply from the project creation flow.
Light and dark mode with system detection. Persisted per user. Design system uses CSS variables throughout.
Thask has two parts:
| Server (self-hosted) | CLI (local) | |
|---|---|---|
| What | Web UI + REST API + PostgreSQL | Terminal commands + MCP server |
| Install | docker compose up |
npm install -g @thask-org/cli |
| Used by | Humans (browser) | Humans (terminal) + AI agents (MCP) |
| Data | Stores everything (nodes, edges, users) | Reads/writes via server API |
Browser ──→ Thask Server (Docker) ──→ PostgreSQL
↑
CLI / MCP ──────┘
The server runs your graph database and web UI. The CLI talks to the server's API — you can create nodes, run scans, and analyze graphs from the terminal. AI agents (Claude Code, Cursor) use the CLI's built-in MCP server.
Get Thask working with Claude Code in 3 minutes:
-
Start Thask (if not running):
make up
-
Create an API key in the web UI at http://localhost:7243 → Settings → API Keys
-
Install the CLI:
npm install -g @thask-org/cli
Or build from source:
cd cli && go build -o thask ./cmd/thask && ./thask install -
Configure:
thask config set url http://localhost:7244 thask config set token <your-api-key>
-
Add to Claude Code (
.claude/mcp.json):{ "mcpServers": { "thask": { "command": "thask", "args": ["mcp", "serve"] } } }
Now Claude Code can read and modify your dependency graph. See MCP Guide for details.
make up # auto-generates .env with SESSION_SECRET on first runOr manually:
cp .env.example .env
# Edit .env and set SESSION_SECRET (or let make generate it)
docker compose up --buildOpen http://localhost:7243 and create an account.
# 1. Start PostgreSQL
make dev-db
# 2. Set up backend
cd backend
cp .env.example .env
go run ./cmd/server
# 3. Set up frontend (in another terminal)
cd frontend
cp .env.example .env
npm install
npm run dev -- --port 7243Or simply:
make dev # starts DB, backend, and frontend togetherPrerequisites: Go 1.26+, Node.js 22+, Docker Desktop
# Terminal 1 — Start PostgreSQL
docker compose -f docker-compose.dev.yml up -d
# Terminal 2 — Start backend
cd backend
copy .env.example .env
go run ./cmd/server
# Terminal 3 — Start frontend
cd frontend
copy .env.example .env
npm install
npm run dev -- --port 7243Tip: To use
makeon Windows, install viascoop install makeorchoco install make.
| Layer | Technology |
|---|---|
| Backend | Go 1.26 (Echo v4) |
| Frontend | SvelteKit + Svelte 5 (runes) |
| CLI | Go (Cobra) + MCP server |
| Graph Engine | Cytoscape.js + fCOSE layout + edgehandles |
| Styling | Tailwind CSS v4 |
| State | Svelte 5 runes ($state, $derived, $effect) |
| Database | PostgreSQL 17 + pgx/v5 (raw SQL) |
| Auth | Session-based (bcrypt + HTTP-only cookies) |
| Testing | Go test (unit + bench) + Playwright (E2E) |
| Deploy | Docker Compose (3 services) |
| npm | @thask-org/cli (esbuild pattern, 5 platforms) |
backend/
cmd/server/ # Go entrypoint, route registration
internal/
config/ # Environment configuration
dto/ # Request/response structs, v1 errors, pagination
handler/ # HTTP handlers (auth, team, node, edge, impact,
# graph_analysis, activity, events, og_image, api_key)
middleware/ # Auth, role, project access, shared access,
# idempotency, v1 response
model/ # Domain models & enums
repository/ # Database access layer (pgx, 11 repos)
service/ # Business logic (waterfall, impact, graph_analysis,
# layout, eventhub, auth)
migrate/ # Migration runner
migrations/ # SQL migration files (001~005)
api/ # OpenAPI spec + API guide
frontend/
src/
routes/
login/ # Login page
register/ # Register page
dashboard/ # Dashboard & team pages
[teamSlug]/
[projectId]/ # Graph editor page
members/ # Team member management
settings/ # User settings
shared/[shareToken]/ # Public shared view
embed/[shareToken]/ # Embeddable graph
docs/ # Documentation page
lib/
api.ts # Typed API client
types.ts # TypeScript type definitions
markdown.ts # Markdown renderer (marked + DOMPurify)
stores/ # Svelte 5 rune stores (auth, graph, teams,
# members, realtime, theme, undo)
components/ # CytoscapeCanvas, GraphToolbar, DetailSidePanel,
# MarkdownEditor, ActivityFeed, TemplateSelector,
# ShareDialog, SearchBar, ProjectMenu, AddNodeModal
cytoscape/ # Styles, layouts, impact, sync, resize,
# portOverlay, groupHelpers, statusDot
managers/ # nodeCrud, edgeCrud
e2e/ # Playwright E2E tests
static/templates/ # Built-in project templates (3)
cli/
cmd/thask/ # CLI entrypoint
internal/
cmd/ # Cobra commands (node, edge, team, project,
# graph, impact, scan, mcp, auth, config,
# aliases, install, version)
mcp/ # MCP server (stdio protocol, 12+ tools)
scan/ # Go dependency scanner + plugin runner
client/ # HTTP client for backend API
config/ # Config file management (~/.config/thask/)
output/ # Output formatting (JSON, table, quiet)
npm/ # npm distribution (@thask-org/cli, 5 platforms)
Users ──< TeamMembers >── Teams ──< Projects ──< Nodes ──< NodeHistory
│ │ │
└──< ApiKeys │ └──< Edges
│
└──< ProjectMembers >── Users
Node types: FLOW BRANCH TASK BUG API UI GROUP
Node statuses: PASS FAIL IN_PROGRESS BLOCKED
Edge types: depends_on blocks related parent_child triggers
| Variable | Description | Default |
|---|---|---|
DATABASE_URL |
PostgreSQL connection string | postgresql://thask:thask_dev_password@localhost:7242/thask |
SESSION_SECRET |
Random string for session signing | — |
PORT |
Backend server port | 7244 |
FRONTEND_URL |
Frontend URL for CORS | http://localhost:7243 |
V1_ALLOWED_ORIGINS |
Comma-separated CORS origins for /api/v1/ |
* |
MAX_REQUEST_BODY_BYTES |
Max request body size for v1 routes (bytes) | 1048576 (1MB) |
| Variable | Description | Default |
|---|---|---|
BACKEND_URL |
Backend API URL (server-side proxy) | http://localhost:7244 |
| Variable | Description | Default |
|---|---|---|
SESSION_SECRET |
Required. Random 64+ char string for session signing | — |
APP_URL |
Public URL of the application | http://localhost:7243 |
BACKEND_URL |
Backend URL for frontend proxy | http://backend:7244 |
POSTGRES_PASSWORD |
PostgreSQL password | thask_password |
Set APP_URL in .env to your public URL:
# .env
APP_URL=https://thask.example.com
SESSION_SECRET=your-random-64-char-stringThis configures CORS and CSRF protection automatically. BACKEND_URL does not need to change — the frontend server proxies API requests to the backend over the internal Docker network.
Browser ──https──▶ Reverse Proxy (nginx/Cloudflare)
│
▼ :7243
Frontend (SvelteKit)
│
▼ http://backend:7244 (Docker internal)
Backend (Go)
│
▼ postgres:5432 (Docker internal)
PostgreSQL
Place a reverse proxy (e.g. nginx, Caddy, Cloudflare Tunnel) in front to handle SSL termination.
- Architecture — Layers, data flow, directory structure
- Database — ER diagram, tables, indexes, relations
- API Reference — 30+ endpoints with request/response examples
- Graph Engine — Node types, edge types, GROUP, impact mode
- Keyboard Shortcuts — All shortcuts and interactions
- CLI Reference — Installation, commands, shell aliases
- MCP Guide — AI agent integration (Claude Code, Cursor)
- Plugins — Scanner plugin system
- V1 API Guide — External API quickstart for third-party developers
| Command | Description |
|---|---|
make dev |
Start DB + backend + frontend |
make dev-db |
Start PostgreSQL only |
make dev-backend |
Start Go backend |
make dev-frontend |
Start SvelteKit frontend |
make build |
Build backend + frontend + CLI |
make build-cli |
Build CLI binary |
make release-cli |
Cross-compile CLI for 5 platforms |
make test |
Run Go unit tests + frontend checks |
make test-backend |
Run Go unit tests (verbose) |
make test-cli |
Run CLI tests |
make test-e2e |
Run Playwright E2E tests |
make bench |
Run scanner + graph analysis benchmarks |
make up |
Docker Compose full stack (auto-generates .env) |
make down |
Stop Docker Compose |
make clean |
Remove build artifacts |
- Graph CRUD (nodes, edges, groups)
- 7 node types & 4 statuses with visual styling
- fCOSE auto-layout & manual positioning
- Drag-and-drop grouping & compound nodes
- Node search & keyboard shortcuts
- QA impact analysis (BFS-based)
- Status waterfall propagation
- Session-based auth & team management
- Docker Compose one-command deploy
- Go backend with 18 unit tests
- Playwright E2E tests (13 tests)
- CLI tool with full graph operations
- MCP server for AI agent integration (12 tools)
- API key authentication (Bearer token)
- Role-based access control (owner/admin/member/viewer)
- Team member management (invite, roles, transfer)
- Project sharing with public links (viewer/editor modes)
- CLI sharing commands (share, unshare, invite, kick)
- Real-time collaboration via SSE
- Graph export as PNG / JSON
- Graph import (replace/merge mode)
- Versioned external API (
/api/v1/) with OpenAPI spec - Interactive API docs (Scalar UI at
/api/v1/docs) - Structured error responses for v1
- Idempotency support for API consumers
- CORS configuration for external domains
- Edge waypoints (draggable bend points)
- SVG edge rendering with snap guides
- Embeddable graph views (
/embed/:shareToken) - OG image generation for shared links
- Go dependency scanner (
thask scan) withgo/astparsing - Cycle detection (Tarjan DFS) and critical path analysis
- Analysis Mode frontend (Shift+A toggle, cycles/critical path highlighting)
- MCP tools:
thask.scan.run,thask.graph.analyze - GitHub Actions CI (backend tests, CLI tests, frontend check)
- Scanner plugin system with documentation
- npm distribution (
@thask-org/cli, 5 platform binaries, esbuild pattern) - Scanner plugin interface (any executable outputting ImportGraphRequest JSON)
- Homebrew formula template
- Performance benchmarks (scanner + graph analysis)
- Light/dark theme system with system detection
- Activity feed (recent changes with user attribution)
- Project templates (API Flow, Microservice Map, Sprint Board)
- Amber Precision design system fully applied
- Markdown description rendering (marked + DOMPurify)
- Graph version snapshots & diffing
- Node lifecycle analytics (time-in-status, bottleneck detection)
- Webhook triggers on graph changes
- GitHub repo sync (auto-update graph on push)
- Slack / Discord notifications
- Comment threads on nodes
- Mobile responsive layout
- Self-hosted SSO (SAML / OIDC)
We welcome contributions! See CONTRIBUTING.md for setup instructions and guidelines.