Thask

Thask it, done.

Map dependencies visually. Break nothing.
Dependency visualization for AI-assisted development teams.

Why Thask?

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.

AI-Native

Ship with thask mcp serve — Claude Code and Cursor read your dependency graph as a tool. Ask "what breaks if I change this?" and get real answers.

Graph-first Thinking

Every flow, task, and bug is a node. Every dependency is a visible edge. No more hidden connections.

Impact at a Glance

One click shows which nodes are affected by recent changes. Catch regressions before they ship.

Self-hosted

docker compose up — that's it. Your data stays on your infrastructure. No vendor lock-in.

Features

Interactive Graph Editor

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.

QA Impact Mode

Toggle Impact Mode to instantly highlight changed nodes and their downstream dependencies. Dimmed nodes are safe; glowing nodes need attention.

Group Nodes

Organize related nodes into collapsible groups. Drag nodes in and out. Resize groups freely. Double-click to collapse with a child count badge.

Status Tracking & Filters

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.

Node Detail Panel

Slide-out panel with full editing — title, description, type, status, tags, connected nodes, and a complete change history audit log.

Edge Relationships

Five edge types with distinct colors: depends_on, blocks, related, parent_child, triggers. Click any edge to change its type or delete it.

CLI & MCP Integration

Full CLI for terminal workflows (thask node list --pretty). MCP server mode for AI agent integration — Claude Code and Cursor can query and modify your graph directly. CLI Reference · MCP Guide

Role-Based Access

Four team roles — Owner, Admin, Member, Viewer — with granular permissions. API key authentication for programmatic access.

Quick Start for AI Agents

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:

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.

Quick Start

Docker (recommended)

make up   # auto-generates .env with SESSION_SECRET on first run

Or manually:

cp .env.example .env
# Edit .env and set SESSION_SECRET (or let make generate it)
docker compose up --build

Open http://localhost:7243 and create an account.

Local Development (macOS / Linux)

# 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 7243

Or simply:

make dev   # starts DB, backend, and frontend together

Local Development (Windows)

Prerequisites: 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 7243

Tip: To use make on Windows, install via scoop install make or choco install make.

Open http://localhost:7243

Tech Stack

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) + Playwright (E2E)
Deploy	Docker Compose (3 services)

Project Structure

backend/
  cmd/server/           # Go entrypoint
  internal/
    config/             # Environment configuration
    dto/                # Request/response structs
    handler/            # HTTP handlers (auth, team, node, edge, impact)
    middleware/         # Auth & project access middleware
    model/              # Domain models & enums
    repository/         # Database access layer (pgx)
    service/            # Business logic (waterfall, impact, auth)
  migrations/           # SQL migration files

frontend/
  src/
    routes/
      login/            # Login page
      register/         # Register page
      dashboard/        # Dashboard & team pages
        [teamSlug]/
          [projectId]/  # Graph editor page
    lib/
      api.ts            # Typed API client
      types.ts          # TypeScript type definitions
      stores/           # Svelte 5 rune stores (auth, graph)
      components/       # CytoscapeCanvas, GraphToolbar, AddNodeModal,
                        # EdgeColorPopover, NodeDetailPanel
      cytoscape/        # Styles, layouts, impact mode, group helpers
  e2e/                  # Playwright E2E tests

cli/
  cmd/thask/            # CLI entrypoint
  internal/
    cmd/                # Cobra commands (node, edge, team, etc.)
    mcp/                # MCP server (stdio protocol, 12 tools)
    client/             # HTTP client for backend API
    config/             # Config file management (~/.config/thask/)
    output/             # Output formatting (JSON, table, quiet)

Data Model

Users ──< TeamMembers >── Teams ──< Projects ──< Nodes ──< NodeHistory
                                                    │
                                                    └──< Edges

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

Environment Variables

Backend (`backend/.env`)

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`

Frontend (`frontend/.env`)

Variable	Description	Default
`BACKEND_URL`	Backend API URL (server-side proxy)	`http://localhost:7244`

Docker Compose (`.env`)

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`

Deploying to a Custom Domain

Set APP_URL in .env to your public URL:

# .env
APP_URL=https://thask.example.com
SESSION_SECRET=your-random-64-char-string

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

Documentation

Architecture — Layers, data flow, directory structure
Database — ER diagram, tables, indexes, relations
API Reference — 22+ 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)

Makefile Commands

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
`make test`	Run Go unit tests + frontend checks
`make test-backend`	Run Go unit tests (verbose)
`make test-e2e`	Run Playwright E2E tests
`make up`	Docker Compose full stack (auto-generates `.env`)
`make down`	Stop Docker Compose
`make clean`	Remove build artifacts

Roadmap

v0.1 — Foundation (Done)

v0.2 — Collaboration & Export

Real-time collaboration (WebSocket / SSE)
Graph snapshot — export as PNG / SVG
PDF report generation (impact summary)
Activity feed (recent changes across team)
Comment threads on nodes

v0.3 — Automation & Integration

API token auth for CI/CD pipelines
Webhook triggers on status change
GitHub / GitLab issue sync
Slack / Discord notifications
Bulk import / export (JSON, CSV)

v0.4 — UX & Templates

Future

Version history & graph diffing
Role-based permissions (view-only, edit, admin)
Plugin system for custom node types
AI-assisted impact prediction
Self-hosted SSO (SAML / OIDC)

Contributing

We welcome contributions! See CONTRIBUTING.md for setup instructions and guidelines.

License

Thask it, done.

Report Bug · Request Feature

Name		Name	Last commit message	Last commit date
Latest commit History 38 Commits
backend		backend
cli		cli
docs		docs
frontend		frontend
public		public
.env.example		.env.example
.gitignore		.gitignore
CHANGELOG.md		CHANGELOG.md
CONTRIBUTING.md		CONTRIBUTING.md
LICENSE		LICENSE
Makefile		Makefile
README.md		README.md
docker-compose.dev.yml		docker-compose.dev.yml
docker-compose.yml		docker-compose.yml

Folders and files

Latest commit

History

Repository files navigation

Thask

Why Thask?

AI-Native

Graph-first Thinking

Impact at a Glance

Self-hosted

Features

Interactive Graph Editor

QA Impact Mode

Group Nodes

Status Tracking & Filters

Node Detail Panel

Edge Relationships

CLI & MCP Integration

Role-Based Access

Quick Start for AI Agents

Quick Start

Docker (recommended)

Local Development (macOS / Linux)

Local Development (Windows)

Tech Stack

Project Structure

Data Model

Environment Variables

Backend (backend/.env)

Frontend (frontend/.env)

Docker Compose (.env)

Deploying to a Custom Domain

Documentation

Makefile Commands

Roadmap

v0.1 — Foundation (Done)

v0.2 — Collaboration & Export

v0.3 — Automation & Integration

v0.4 — UX & Templates

Future

Contributing

License

About

Resources

License

Contributing

Uh oh!

Stars

Watchers

Forks

Releases

Packages 0

Uh oh!

Contributors

Uh oh!

Languages

Backend (`backend/.env`)

Frontend (`frontend/.env`)

Docker Compose (`.env`)

Packages