AI agents need work context — issue descriptions, acceptance criteria, design specs, PRDs. These live in Jira, GitHub, Figma, Notion, Linear, Confluence. cl collects them all and outputs markdown to stdout. Any LLM can consume it.

cl https://your-org.atlassian.net/browse/PROJ-123 | claude
cl https://github.com/org/repo/pull/42 | aider
cl https://www.figma.com/file/abc123/Design | codex

Install

npm i -g context-load

Usage

Paste a URL from your browser. That's it.

# Load from any supported source
cl https://github.com/org/repo/issues/42
cl https://org.atlassian.net/browse/PROJ-123
cl https://www.figma.com/file/abc123/Design
cl https://www.notion.so/PRD-abc123def456
cl https://linear.app/team/issue/LIN-456
cl https://org.atlassian.net/wiki/spaces/TEAM/pages/123

# Pipe to any LLM
cl https://github.com/org/repo/issues/42 | claude

# Multiple sources at once
cl https://org.atlassian.net/browse/PROJ-123 \
   https://www.figma.com/file/abc123/Design \
   https://github.com/org/repo/pull/42

# From stdin
echo "https://github.com/org/repo/issues/42" | cl

# JSON output with token estimate
cl https://github.com/org/repo/issues/42 --format json

# Extraction profiles
cl PROJ-123 --profile impl      # Implementation: description, AC, subtasks
cl PROJ-123 --profile review    # Review: comments, change history
cl PROJ-123 --profile design    # Design: full tokens, components

Supported Sources

| Source | URL Pattern | Status | |--------|-------------|--------| | GitHub Issue/PR/File | github.com/owner/repo/issues/N, /pull/N, /blob/... | OK | | Jira | *.atlassian.net/browse/KEY-N | OK | | Linear | linear.app/.../issue/KEY-N | OK | | Figma | figma.com/file/KEY/..., figma.com/design/KEY/... | OK | | Notion | notion.so/...-PAGEID | OK | | Confluence | *.atlassian.net/wiki/.../pages/ID | OK |

Context Management

Contexts let you compose text notes and external sources into a single document — like a Notion page for your AI agent. Each context is a canvas of text blocks and source blocks that you can freely arrange.

Create and Manage Contexts

# Create a context
cl context create "login-redesign" "Login flow redesign with TossPay"

# Add sources by layer (why/what/how/where/decided)
cl context bind login-redesign \
  --why "https://org.atlassian.net/browse/PAY-123" \
  --how "https://www.figma.com/file/abc123/Login"

# Remove a source
cl context unbind login-redesign "https://org.atlassian.net/browse/PAY-123"

# Snapshot — fetch all sources and freeze content
cl context snapshot login-redesign

# Load — output as markdown, filtered by profile
cl context load login-redesign --profile implement | claude
cl context load login-redesign --profile review
cl context load login-redesign --format json

# List all contexts
cl context list

# Delete a context
cl context delete login-redesign

Workspaces

Contexts are scoped to workspaces. The default workspace is default. The active workspace is shared between CLI and desktop app.

~/.cl/
├── active-workspace          # Current workspace name
├── settings.json             # Provider tokens
└── workspaces/
    ├── default/
    │   └── contexts/
    │       ├── login-redesign/
    │       │   ├── context.json
    │       │   └── snapshots/
    │       └── api-refactor/
    │           └── context.json
    └── my-project/
        └── contexts/

Block-Based Content Model

Each context is a sequence of blocks:

• Text blocks — Free-form markdown notes, instructions, or annotations
• Source blocks — External content loaded from URLs (Jira, GitHub, Figma, etc.)

Blocks can be reordered, edited, and mixed freely. Source blocks track their loaded content and can be reloaded when the external source changes.

Load Profiles

Same context, different views depending on what you're doing:

| Profile | Includes | Use Case | |---------|----------|----------| | implement | WHY + WHAT + HOW + WHERE | Building the feature | | review | WHAT + WHERE | Code review | | design | WHY + WHAT + DECIDED | Design discussion | | debug | WHAT + WHERE + DECIDED | Bug investigation | | full | Everything | Full context dump |

Follow — Auto-Discover Related Sources

--follow scans loaded content for linked issues, PRs, designs, and loads them automatically.

# One URL in, all related context out
cl https://org.atlassian.net/browse/PROJ-123 --follow
# -> Discovers subtasks, linked PRs, Figma URLs in description

Capture — Save LLM Conversations as Context

Close the feedback loop: save LLM output back as context for future sessions.

# Pipe LLM output to capture
claude "Analyze this PR" | cl capture "pr-42-analysis"

# From clipboard
cl capture "meeting-notes" --clipboard

# From file
cl capture "design-spec" --file ./spec.md

# List and view captures
cl capture ls
cl capture view pr-42-analysis

Desktop App

Native desktop application (Electron) with a Notion-style block editor for visual context management.

# From source
cd desktop && bun run build && bun run start

# Or download from GitHub Releases

Features:

• Block editor — mix text and source blocks freely
• Slash commands — type /jira, /github, /figma to add source blocks
• Drag-and-drop block reordering
• Source reload with dirty state tracking
• Workspace switcher
• Light/dark theme
• Clipboard copy for any LLM
• Keyboard shortcuts (Cmd+K search, Cmd+B sidebar, Cmd+N new context)

The desktop app and CLI share the same data directory (~/.cl/workspaces/), so contexts created in the CLI appear in the app and vice versa.

Dashboard

Web UI for context management (same UI as the desktop app, served via browser).

cl dashboard
# -> Opens http://localhost:3200

Authentication

# Interactive setup
cl auth github --token ghp_xxx
cl auth jira --token xxx --base-url https://org.atlassian.net --email [email protected]
cl auth linear --token lin_api_xxx
cl auth figma --token figd_xxx
cl auth notion --token ntn_xxx

# Or use environment variables
export GITHUB_TOKEN=ghp_xxx
export JIRA_TOKEN=xxx
export LINEAR_API_KEY=lin_api_xxx
export FIGMA_TOKEN=figd_xxx
export NOTION_TOKEN=ntn_xxx

# Or configure in the desktop app's Settings page
# (tokens are stored in ~/.cl/settings.json)

# Check status
cl auth status

GitHub also auto-detects gh auth login.

MCP Server

For AI tools that support Model Context Protocol:

{
  "mcpServers": {
    "context-load": {
      "command": "npx",
      "args": ["context-load", "mcp"]
    }
  }
}

Available tools: context_load (URL-based), context_list, load_context.

Project Scoping

Initialize a project to scope config per-repository.

cl init
# -> Creates .context-load.yml + .cl/ directory

cl status
# Project: my-app
# Providers: github OK, jira OK, figma --
# Scope: project (/path/to/my-app/.cl/)

CLI Reference

cl <url-or-key...> [options]

Options:
  -f, --format <md|json>   Output format (default: md)
  -o, --output <dir>       Save to directory
  --profile <profile>      impl | review | design (default: impl)
  --model <name>           LLM model for token budget
  --max-tokens <n>         Max output tokens
  --follow                 Auto-discover related sources
  --save                   Save to context store
  --name <n>               Name for --save
  --global                 Use global scope (ignore project)
  --depth <n>              Sub-item load depth (default: 1)
  --verbose                Show API calls on stderr

Subcommands:
  cl context <create|list|show|delete|bind|unbind|snapshot|load>
  cl capture <name|ls|view|delete>
  cl serve [--port 8080]
  cl init / cl status / cl auth
  cl dashboard / cl mcp

How It Works

+-------------------------------------------------+
|                   cl CLI                        |
|                                                 |
|  URL -> URL Resolver -> Provider -> Formatter   |
|                                                 |
|  Providers:                                     |
|  GitHub . Jira . Linear . Figma                 |
|  Notion . Confluence                            |
|                                                 |
|  Features:                                      |
|  Context . Workspace . Follow . Capture         |
|  Cache . MCP . Dashboard . Desktop              |
+-------------------------------------------------+
         | stdout (markdown | json)
         v
   Any LLM: claude | aider | codex | cursor

Project Structure

context-load/
├── cli/           # CLI entry point (cl command)
├── lib/           # Shared core library
│   ├── core/      # Orchestrator, providers, context, cache
│   ├── formatters/
│   ├── mcp/       # MCP server
│   ├── providers/ # GitHub, Jira, Linear, Figma, Notion, Confluence
│   └── tests/
├── dashboard/     # Web UI (React + Hono server)
│   ├── server/    # Hono API server
│   └── src/       # React frontend
├── desktop/       # Electron desktop app
│   └── src/main/  # Electron main process
└── skills/        # LLM skill files for AI agents

License

Apache-2.0