Claude Code — Source Code Documentation

Note: This repository does not contain Claude Code's source code. It is a documentation project — file-by-file and directory-level write-ups that explain the architecture, purpose, and behaviour of Claude Code, Anthropic's interactive AI-powered command-line interface. Each directory in the documented codebase has its own README.md, and individual source files have corresponding documentation entries. This repo exists purely for educational and reference purposes.

Claude Code itself is a TypeScript codebase (~1,300+ files) that powers the claude CLI tool — an AI assistant that can read files, write code, run commands, search codebases, and much more, all from your terminal.

---

Table of Contents

• What is Claude Code?
• Architecture Overview
• Technology Stack
• How a Conversation Works
• Project Structure
• Key Concepts
• Getting Started Reading the Code
• Directory Index

---

What is Claude Code?

Claude Code is a terminal-based AI assistant that:

1. Reads and understands code — It can read any file, search with grep/glob, and understand project structure
2. Writes and edits code — It can create files, make surgical edits, and refactor across a codebase
3. Runs commands — It executes shell commands (with user permission) to build, test, and deploy
4. Uses external tools — It connects to MCP servers, LSP servers, and other development tools
5. Manages sub-agents — It can spawn background agents for parallel work
6. Remembers context — It has a persistent memory system and conversation history

The user interacts via a terminal REPL (read-eval-print loop). They type natural language, Claude responds with text and tool calls, and the cycle repeats.

Platform Support

• CLI: Terminal on macOS, Linux, Windows
• Desktop App: Mac, Windows
• Web App: claude.ai/code
• IDE Extensions: VS Code, JetBrains

---

Architecture Overview

Claude Code is built with React + Ink (a React renderer for terminal UIs) and communicates with the Claude API for AI responses. Here's the high-level architecture:

┌─────────────────────────────────────────────────────────────┐
│                        Terminal UI                           │
│  ┌─────────────┐  ┌──────────────┐  ┌───────────────────┐  │
│  │ PromptInput │  │   Messages   │  │   Permissions     │  │
│  │ (user types)│  │  (responses) │  │  (approve/deny)   │  │
│  └──────┬──────┘  └──────▲───────┘  └────────▲──────────┘  │
│         │                │                    │             │
│  ┌──────▼────────────────┴────────────────────┴──────────┐  │
│  │                    React + Ink                         │  │
│  │              (Terminal UI Framework)                   │  │
│  └──────────────────────┬────────────────────────────────┘  │
├─────────────────────────┼───────────────────────────────────┤
│                   Core Engine                                │
│  ┌──────────────────────▼────────────────────────────────┐  │
│  │                 QueryEngine                            │  │
│  │         (Conversation loop orchestrator)               │  │
│  └───────┬──────────────┬──────────────────┬─────────────┘  │
│          │              │                  │                 │
│  ┌───────▼──────┐ ┌────▼─────────┐ ┌──────▼──────────┐     │
│  │  Claude API  │ │ Tool System  │ │  Hook System    │     │
│  │  (streaming) │ │ (42+ tools)  │ │ (20+ events)    │     │
│  └──────────────┘ └──────────────┘ └─────────────────┘     │
│                                                              │
│  ┌──────────────┐ ┌──────────────┐ ┌─────────────────┐     │
│  │  MCP Client  │ │ Permissions  │ │  State Store    │     │
│  │  (external   │ │ (rule-based  │ │  (Zustand-like) │     │
│  │   tools)     │ │  security)   │ │                 │     │
│  └──────────────┘ └──────────────┘ └─────────────────┘     │
└─────────────────────────────────────────────────────────────┘

Entry Points

Entry Points
├── cli.tsx          → Fast-path version check, feature gates
├── main.tsx         → Bootstrap, lazy loading, CLI dispatch (~19K LOC)
├── setup.ts         → Pre-session config (Node check, worktree, watchers)
└── replLauncher.tsx → Launch REPL or headless mode

Core Loop (QueryEngine.ts)

Core Loop
├── Process user input (slash commands, attachments)
├── Build context (system prompt, git status, memory)
├── Load tools dynamically (MCP, plugins, skills)
├── Stream API call to Claude
├── Execute tools via StreamingToolExecutor
├── Auto-compact history if needed
└── Render results to UI

---

Technology Stack

Layer	Technology	Purpose
Language	TypeScript	~1,300+ files, 33MB source
Runtime	Bun	Fast startup, native APIs, build-time dead code elimination via feature() gates
UI Framework	React + Custom Ink	Terminal UI rendering with React component model
Layout Engine	Yoga	Flexbox-style layout for terminal
State	Zustand-style store	Global application state (450+ fields)
Validation	Zod	Runtime type validation for tool inputs, schemas, settings
API Client	@anthropic-ai/sdk	Claude API communication with streaming
MCP Client	@modelcontextprotocol/sdk	Connect to external tool servers
CLI Parsing	Commander.js	Command-line argument parsing

---

How a Conversation Works

Understanding this flow is key to understanding the entire codebase:

1. USER TYPES A MESSAGE
   └─▶ PromptInput component captures input
       └─▶ processUserInput() routes it (text, /command, or !shell)

2. MESSAGE SENT TO CLAUDE API
   └─▶ QueryEngine.submit() sends conversation history + system prompt
       └─▶ services/api/claude.ts handles streaming, retries, caching
           └─▶ Response streams back token-by-token

3. CLAUDE RESPONDS (text and/or tool calls)
   └─▶ Text is rendered immediately in the terminal
   └─▶ Tool calls enter the tool execution pipeline:

4. TOOL EXECUTION
   └─▶ Tool.checkPermissions() evaluates permission rules
       ├─▶ "allow" → execute immediately
       ├─▶ "deny" → reject with explanation
       └─▶ "ask" → render PermissionRequest component
           └─▶ User approves/denies in the terminal
   └─▶ Tool.call() executes the action (read file, run command, etc.)
   └─▶ Result sent back to Claude as a tool_result message

5. LOOP CONTINUES
   └─▶ Claude sees tool results, may call more tools or respond with text
   └─▶ Loop repeats until Claude has no more tool calls

6. POST-PROCESSING
   └─▶ Hooks fire (PostToolUse, Stop, etc.)
   └─▶ Memory extraction runs in background
   └─▶ Session is saved to disk

---

Project Structure

All source code lives in src/. There are no other top-level source directories.

Claude Code Source/
├── README.md              ← You are here (project entry point)
├── CLAUDE.md              ← Instructions for Claude itself
└── src/                   ← All source code
    ├── main.tsx           ← Main bootstrap (~19K LOC)
    ├── QueryEngine.ts     ← Core conversation loop
    ├── Tool.ts            ← Tool interface definition
    ├── tools.ts           ← Tool registry
    ├── commands.ts        ← Command registry
    ├── query.ts           ← Query logic
    ├── tasks.ts           ← Task system types
    │
    ├── entrypoints/       ← Application entry points (CLI, SDK, MCP)
    ├── bootstrap/         ← Startup initialization
    ├── state/             ← Global state store
    ├── context/           ← React contexts
    │
    ├── tools/             ← 42+ tool implementations
    ├── commands/          ← 90+ slash commands
    ├── skills/            ← Bundled skills (/commit, /review)
    ├── plugins/           ← Plugin system
    │
    ├── components/        ← 146+ terminal UI components
    ├── ink/               ← Custom terminal renderer
    ├── screens/           ← Top-level screen components
    │
    ├── services/          ← 20 core services (API, MCP, analytics...)
    ├── hooks/             ← 76+ React hooks
    ├── utils/             ← 331+ utility modules
    │
    ├── cli/               ← CLI infrastructure & transports
    ├── bridge/            ← Remote bridge mode
    ├── coordinator/       ← Multi-agent coordination
    ├── server/            ← Direct Connect server mode
    ├── tasks/             ← Background task types
    │
    ├── vim/               ← Vim mode implementation
    ├── voice/             ← Voice input support
    ├── keybindings/       ← Keybinding system
    ├── constants/         ← Application constants
    ├── types/             ← TypeScript type definitions
    ├── schemas/           ← Zod validation schemas
    ├── migrations/        ← Data migrations
    ├── native-ts/         ← Native TS ports (layout, search, diff)
    ├── memdir/            ← Persistent memory system
    ├── buddy/             ← Companion pet system
    └── ...                ← Additional modules

Start here: src/README.md — detailed overview of every directory and file with navigation links.

---

Key Concepts

1. Tools

Tools are capabilities that Claude can invoke during a conversation. Each tool is defined with buildTool() and has:

• Input schema (Zod) — validated parameters
• Permission model — what requires user approval
• Execution logic — the actual implementation

42+ built-in tools including:

• File I/O: Read, Write, Edit, Glob, Grep
• Execution: Bash, PowerShell, REPL
• Web: WebSearch, WebFetch
• Code Intelligence: LSP (goToDefinition, findReferences, hover)
• Orchestration: Agent, Skill, TodoWrite, Task*
• MCP: MCPTool, ListMcpResources, ReadMcpResource
• Planning: EnterPlanMode, ExitPlanMode
• Worktree: EnterWorktree, ExitWorktree
• Interaction: AskUserQuestion, SendMessage
• Scheduling: CronCreate, CronDelete, CronList

Deep dive: src/tools/README.md

2. The Permission System

Every potentially dangerous action goes through a permission check:

• alwaysAllow — auto-approve (e.g., reading files in the project)
• alwaysDeny — auto-reject (e.g., blocked commands)
• alwaysAsk — prompt the user every time

Permissions support pattern matching: "Bash(npm test)" allows only npm test, "Bash(git:*)" allows all git commands, "FileWrite(src/**)" allows writing to src/.

Permission modes: default (ask), plan (pause before execution), bypassPermissions, auto.

Deep dive: src/utils/permissions/README.md

3. The Hook System

Hooks are user-configured automations that trigger on events:

• Lifecycle: SessionStart, Stop, SessionEnd, Setup
• Tool: PreToolUse, PostToolUse, PostToolUseFailure
• User: UserPromptSubmit, PermissionDenied, Notification
• MCP: ElicitationRequest, ElicitationResult
• Subagent: SubagentStart, SubagentStop, TeammateIdle

Hooks execute as shell commands, HTTP endpoints, or in-process TypeScript callbacks, configured in settings.json.

Deep dive: src/utils/hooks/README.md

4. MCP (Model Context Protocol)

MCP lets Claude connect to external tool servers. An MCP server might provide database access, API integrations, or specialized tools. Claude Code includes a full MCP client supporting 6 transport types (stdio, SSE, HTTP, WebSocket, SDK, SSE-IDE).

Deep dive: src/services/mcp/README.md

5. Commands (Slash Commands)

Users type /command in the REPL to trigger actions. There are 90+ commands supporting two types:

• PromptCommand — Injects a prompt into the conversation (e.g., /commit, /review)
• LocalJSXCommand — Renders local JSX UI (e.g., /config, /help)

Deep dive: src/commands/README.md

6. Skills

Skills are reusable prompts bundled as markdown files with YAML frontmatter. They can be invoked via /skill-name and inject specialized instructions into the conversation. Skills can come from:

• Bundled: batch, claudeApi, debug, loop, simplify, skillify, etc.
• User: ~/.claude/skills/
• Project: .claude/skills/
• Plugins: From installed plugins
• MCP: From connected MCP servers

Deep dive: src/skills/README.md

7. State Management

The app uses a Zustand-style store (AppStateStore) with 450+ fields covering settings, permissions, tasks, MCP connections, UI state, and more. React components subscribe to specific slices via useAppState().

Deep dive: src/state/README.md

8. The Terminal UI (Ink)

Claude Code uses a custom fork of Ink (React for terminals) with:

• Yoga layout engine — flexbox-style layout for terminal
• DOM-style event system — keyboard, click, focus events with capture/bubble
• Custom components — Box, Text, ScrollBox, Button, Link, etc.

Deep dive: src/ink/README.md

9. Background Tasks & Sub-Agents

Claude can spawn background tasks:

• LocalAgentTask — sub-agents that run queries in parallel
• LocalShellTask — long-running shell commands
• RemoteAgentTask — agents running on remote infrastructure
• DreamTask — memory consolidation tasks
• InProcessTeammateTask — swarm teammates with shared context

Deep dive: src/tasks/README.md

10. Feature Gates

Many features are gated behind build-time flags using Bun's dead code elimination:

import { feature } from "bun:bundle";
if (feature("BRIDGE_MODE")) { /* only in bridge builds */ }

Common gates: BRIDGE_MODE, KAIROS, COORDINATOR_MODE. Gated code may reference modules not present in this extraction.

---

Configuration

Settings are loaded from multiple sources with precedence:

1. Environment variables (highest priority)
2. MDM (macOS/Windows/Linux enterprise management)
3. Remote managed settings (cloud-based policies)
4. Project config: .claude/config.json
5. Global config: ~/.claude/config.json

Key config areas: model selection, permission mode, MCP servers, themes, keybindings, hooks, plugins.

Deep dive: src/utils/settings/README.md

---

Cost Tracking

Per-model pricing with cache-aware cost calculation:

cost = (inputTokens × inputRate) + (outputTokens × outputRate)
     + (cacheReadTokens × cacheReadRate) + (cacheWriteTokens × cacheWriteRate)
     + (webSearchRequests × $0.01)

---

Performance Optimizations

• Startup profiling: profileCheckpoint() tracks timing through startup
• Lazy loading: Dynamic imports for heavy modules
• Fast paths: --version, --dump-system-prompt skip full initialization
• LRU caches: File state cache, skill index cache
• Parallel I/O: Keychain, MDM reads run concurrently at startup
• Streaming execution: Generator-based tool execution with concurrency

---

Getting Started Reading the Code

Each topic below has a comprehensive deep-dive guide in the docs/ directory, plus quick-reference links to the relevant source directories.

"I want to understand how Claude processes a user message"

In-Depth Guide: Message Processing (~1600 lines)

1. Start at src/QueryEngine.ts — the main conversation loop
2. Then src/query.ts — lower-level query orchestration
3. Then src/services/api/README.md — how API calls are made

"I want to understand a specific tool (e.g., Bash)"

In-Depth Guide: Tool System (~700 lines)

1. Go to src/tools/BashTool/README.md
2. See also src/utils/bash/README.md for the security parser

"I want to understand the permission system"

In-Depth Guide: Permission System (~1000 lines)

1. Start at src/utils/permissions/README.md — rule engine
2. Then src/components/permissions/README.md — UI rendering
3. Then src/hooks/toolPermission/README.md — React integration

"I want to understand how the terminal UI works"

In-Depth Guide: Terminal UI (~1000 lines)

1. Start at src/ink/README.md — the custom renderer
2. Then src/components/README.md — all UI components
3. Then src/screens/README.md — top-level screens

"I want to understand MCP integration"

In-Depth Guide: MCP Integration (~1200 lines)

1. Start at src/services/mcp/README.md — the MCP client
2. Then src/tools/MCPTool/README.md — how MCP tools are proxied
3. Then src/components/mcp/README.md — the management UI

"I want to understand the command/skill system"

In-Depth Guide: Commands & Skills (~1000 lines)

1. Start at src/commands/README.md — slash command registry
2. Then src/skills/README.md — skill loading and invocation
3. Then src/plugins/README.md — plugin architecture

"I want to understand how settings and configuration work"

In-Depth Guide: Settings & Configuration (~1000 lines)

1. Start at src/utils/settings/README.md — settings hierarchy
2. Then src/utils/hooks/README.md — hook configuration
3. Then src/utils/memory/README.md — CLAUDE.md memory files

"I want to understand multi-agent coordination"

In-Depth Guide: Multi-Agent Coordination (~900 lines)

1. Start at src/coordinator/README.md — coordinator architecture
2. Then src/utils/swarm/README.md — swarm coordination
3. Then src/tasks/README.md — task types

"I want to understand remote/bridge mode"

In-Depth Guide: Remote & Bridge Mode (~700 lines)

1. Start at src/bridge/README.md — bridge protocol
2. Then src/server/README.md — Direct Connect server
3. Then src/remote/README.md — remote execution

---

Directory Index

Every directory in the project has its own README.md with detailed documentation. Click any link to dive deeper.

Core Engine

• src/ — Source root overview
• src/entrypoints/ — Application entry points (CLI, SDK, MCP server)
• src/entrypoints/sdk/ — SDK type exports
• src/bootstrap/ — Startup initialization
• src/query/ — Query system modules
• src/state/ — Global state store (450+ fields)
• src/context/ — React contexts (9 context files)
• src/schemas/ — Zod validation schemas

Tools (42+)

• src/tools/ — Tool system overview and registry
• src/tools/AgentTool/ — Sub-agent spawning
• src/tools/AgentTool/built-in/ — Built-in agent types
• src/tools/AskUserQuestionTool/ — Interactive questions
• src/tools/BashTool/ — Shell command execution
• src/tools/BriefTool/ — Brief responses
• src/tools/ConfigTool/ — Configuration access
• src/tools/EnterPlanModeTool/ — Plan mode entry
• src/tools/EnterWorktreeTool/ — Git worktree isolation
• src/tools/ExitPlanModeTool/ — Plan mode exit
• src/tools/ExitWorktreeTool/ — Worktree cleanup
• src/tools/FileEditTool/ — Surgical file edits
• src/tools/FileReadTool/ — File reading
• src/tools/FileWriteTool/ — File creation
• src/tools/GlobTool/ — File pattern matching
• src/tools/GrepTool/ — Content search (ripgrep)
• src/tools/LSPTool/ — Language server integration
• src/tools/ListMcpResourcesTool/ — MCP resource listing
• src/tools/MCPTool/ — MCP tool proxy
• src/tools/McpAuthTool/ — MCP authentication
• src/tools/NotebookEditTool/ — Jupyter notebook editing
• src/tools/PowerShellTool/ — PowerShell execution
• src/tools/REPLTool/ — REPL execution
• src/tools/ReadMcpResourceTool/ — MCP resource reading
• src/tools/RemoteTriggerTool/ — Remote trigger management
• src/tools/ScheduleCronTool/ — Cron scheduling
• src/tools/SendMessageTool/ — Inter-agent messaging
• src/tools/SkillTool/ — Skill invocation
• src/tools/SleepTool/ — Sleep/delay
• src/tools/SyntheticOutputTool/ — Synthetic output
• src/tools/TaskCreateTool/ — Task creation
• src/tools/TaskGetTool/ — Task status
• src/tools/TaskListTool/ — Task listing
• src/tools/TaskOutputTool/ — Task output retrieval
• src/tools/TaskStopTool/ — Task stopping
• src/tools/TaskUpdateTool/ — Task updating
• src/tools/TeamCreateTool/ — Team creation
• src/tools/TeamDeleteTool/ — Team deletion
• src/tools/TodoWriteTool/ — Task list management
• src/tools/ToolSearchTool/ — Tool search
• src/tools/WebFetchTool/ — Web page fetching
• src/tools/WebSearchTool/ — Web search
• src/tools/shared/ — Shared tool utilities
• src/tools/testing/ — Testing utilities

Commands (90+)

• src/commands/ — Command system overview
• src/commands/add-dir/ — Add working directories
• src/commands/agents/ — Agent management
• src/commands/ant-trace/ — Internal tracing
• src/commands/autofix-pr/ — PR auto-fix
• src/commands/backfill-sessions/ — Session backfill
• src/commands/branch/ — Conversation forking
• src/commands/break-cache/ — Cache clearing
• src/commands/bridge/ — Bridge connection
• src/commands/btw/ — Side questions
• src/commands/bughunter/ — Bug hunting
• src/commands/chrome/ — Chrome extension
• src/commands/clear/ — Session reset
• src/commands/color/ — Prompt color
• src/commands/compact/ — Context compression
• src/commands/config/ — Settings panel
• src/commands/context/ — Context visualization
• src/commands/copy/ — Clipboard copy
• src/commands/cost/ — Session cost
• src/commands/ctx_viz/ — Context visualization (internal)
• src/commands/debug-tool-call/ — Tool call debugging
• src/commands/desktop/ — Desktop handoff
• src/commands/diff/ — Diff viewer
• src/commands/doctor/ — Installation diagnostics
• src/commands/effort/ — Effort level
• src/commands/env/ — Environment info
• src/commands/exit/ — Exit REPL
• src/commands/export/ — Conversation export
• src/commands/extra-usage/ — Overage billing
• src/commands/fast/ — Fast mode toggle
• src/commands/feedback/ — Bug reports
• src/commands/files/ — Files in context
• src/commands/good-claude/ — Positive feedback
• src/commands/heapdump/ — Heap dump (debug)
• src/commands/help/ — Help screen
• src/commands/hooks/ — Hook configuration
• src/commands/ide/ — IDE integration
• src/commands/install-github-app/ — GitHub Actions setup
• src/commands/install-slack-app/ — Slack app install
• src/commands/issue/ — Issue tracking
• src/commands/keybindings/ — Keybinding config
• src/commands/login/ — Authentication
• src/commands/logout/ — Sign out
• src/commands/mcp/ — MCP server management
• src/commands/memory/ — Memory management
• src/commands/mobile/ — Mobile setup
• src/commands/mock-limits/ — Mock rate limits
• src/commands/model/ — Model selection
• src/commands/oauth-refresh/ — OAuth refresh
• src/commands/onboarding/ — Onboarding
• src/commands/output-style/ — Output formatting
• src/commands/passes/ — Guest passes
• src/commands/perf-issue/ — Performance issues
• src/commands/permissions/ — Permission rules
• src/commands/plan/ — Plan mode
• src/commands/plugin/ — Plugin management
• src/commands/pr_comments/ — PR comments
• src/commands/privacy-settings/ — Privacy settings
• src/commands/rate-limit-options/ — Rate limits
• src/commands/release-notes/ — Release notes
• src/commands/reload-plugins/ — Reload plugins
• src/commands/remote-env/ — Remote environment
• src/commands/remote-setup/ — Remote setup
• src/commands/rename/ — Session rename
• src/commands/reset-limits/ — Reset rate limits
• src/commands/resume/ — Resume session
• src/commands/review/ — Code review
• src/commands/rewind/ — Conversation rewind
• src/commands/sandbox-toggle/ — Sandbox toggle
• src/commands/session/ — Session management
• src/commands/share/ — Session sharing
• src/commands/skills/ — Skills browser
• src/commands/stats/ — Usage statistics
• src/commands/status/ — Status display
• src/commands/stickers/ — Stickers
• src/commands/summary/ — Session summary
• src/commands/tag/ — Session tagging
• src/commands/tasks/ — Task management
• src/commands/teleport/ — Session teleport
• src/commands/terminalSetup/ — Terminal setup
• src/commands/theme/ — Theme selection
• src/commands/thinkback/ — Think-back
• src/commands/thinkback-play/ — Think-back playback
• src/commands/upgrade/ — Upgrade Claude Code
• src/commands/usage/ — Usage info
• src/commands/vim/ — Vim mode toggle
• src/commands/voice/ — Voice input toggle

User Interface

• src/components/ — All 146+ components
• src/components/ui/ — UI primitives
• src/components/Settings/ — Settings dialog
• src/components/LspRecommendation/ — LSP recommendations
• src/components/tasks/ — Task monitoring
• src/components/messages/ — Message renderers (30+)
• src/components/messages/UserToolResultMessage/ — Tool result display
• src/components/memory/ — Memory UI
• src/components/ClaudeCodeHint/ — Plugin hints
• src/components/ManagedSettingsSecurityDialog/ — Security dialogs
• src/components/shell/ — Shell output rendering
• src/components/FeedbackSurvey/ — Feedback collection
• src/components/Passes/ — Guest passes UI
• src/components/grove/ — Terms of service
• src/components/wizard/ — Multi-step wizard
• src/components/agents/ — Agent management UI
• src/components/agents/new-agent-creation/ — Agent creation wizard
• src/components/agents/new-agent-creation/wizard-steps/ — Wizard steps
• src/components/diff/ — Diff viewing
• src/components/mcp/ — MCP management UI
• src/components/mcp/utils/ — MCP utilities
• src/components/Spinner/ — Animated spinners
• src/components/sandbox/ — Sandbox UI
• src/components/permissions/ — Permission dialogs
• src/components/permissions/BashPermissionRequest/ — Bash approval
• src/components/permissions/PowerShellPermissionRequest/ — PowerShell approval
• src/components/permissions/SedEditPermissionRequest/ — Sed edit approval
• src/components/permissions/FileEditPermissionRequest/ — File edit approval
• src/components/permissions/FileWritePermissionRequest/ — File write approval
• src/components/permissions/FilesystemPermissionRequest/ — Filesystem access
• src/components/permissions/NotebookEditPermissionRequest/ — Notebook approval
• src/components/permissions/ComputerUseApproval/ — Computer use
• src/components/permissions/AskUserQuestionPermissionRequest/ — Question approval
• src/components/permissions/WebFetchPermissionRequest/ — Web fetch approval
• src/components/permissions/FilePermissionDialog/ — File permission dialog
• src/components/permissions/SkillPermissionRequest/ — Skill approval
• src/components/permissions/EnterPlanModePermissionRequest/ — Plan mode entry
• src/components/permissions/ExitPlanModePermissionRequest/ — Plan mode exit
• src/components/permissions/rules/ — Rule management UI
• src/components/DesktopUpsell/ — Desktop promotion
• src/components/TrustDialog/ — Trust verification
• src/components/hooks/ — Hooks browser
• src/components/StructuredDiff/ — Word-level diffs
• src/components/HelpV2/ — Help dialog
• src/components/teams/ — Team management
• src/components/skills/ — Skills browser
• src/components/CustomSelect/ — Selection input
• src/components/PromptInput/ — User input area
• src/components/design-system/ — Design system primitives
• src/components/LogoV2/ — Startup logo
• src/components/HighlightedCode/ — Syntax highlighting

Terminal Renderer (Ink)

• src/ink/ — Custom Ink overview
• src/ink/layout/ — Yoga layout engine
• src/ink/components/ — Core Ink components
• src/ink/hooks/ — Ink hooks (12 hooks)
• src/ink/events/ — DOM-style event system
• src/ink/termio/ — Terminal I/O (ANSI, CSI, SGR, etc.)

Services (20)

• src/services/ — Service overview
• src/services/api/ — Claude API client (4 providers)
• src/services/mcp/ — MCP client (6 transports)
• src/services/analytics/ — Event analytics
• src/services/compact/ — Conversation compaction
• src/services/extractMemories/ — Memory extraction
• src/services/lsp/ — Language Server Protocol
• src/services/oauth/ — OAuth 2.0 PKCE
• src/services/plugins/ — Plugin installation
• src/services/policyLimits/ — Enterprise policies
• src/services/remoteManagedSettings/ — Managed settings
• src/services/AgentSummary/ — Agent progress summaries
• src/services/SessionMemory/ — Session notes
• src/services/PromptSuggestion/ — Follow-up suggestions
• src/services/settingsSync/ — Settings sync
• src/services/tips/ — Contextual tips
• src/services/tools/ — Tool execution orchestration
• src/services/autoDream/ — Memory consolidation
• src/services/teamMemorySync/ — Team memory sync
• src/services/toolUseSummary/ — Tool batch summaries
• src/services/MagicDocs/ — Auto-updating docs

Infrastructure

• src/cli/ — CLI infrastructure
• src/cli/transports/ — Transport layer (SSE, WebSocket, Hybrid)
• src/cli/handlers/ — Subcommand handlers
• src/bridge/ — Remote bridge mode (CCR)
• src/coordinator/ — Multi-agent coordinator
• src/server/ — Direct Connect server
• src/remote/ — Remote execution

Task System

• src/tasks/ — Task system overview
• src/tasks/LocalAgentTask/ — Local sub-agents
• src/tasks/LocalShellTask/ — Shell tasks
• src/tasks/RemoteAgentTask/ — Remote agents
• src/tasks/DreamTask/ — Memory consolidation
• src/tasks/InProcessTeammateTask/ — Teammate tasks

Skills & Plugins

• src/skills/ — Skills system
• src/skills/bundled/ — Bundled skills
• src/plugins/ — Plugin system
• src/plugins/bundled/ — Bundled plugins

React Hooks (76+)

• src/hooks/ — All React hooks
• src/hooks/notifs/ — Notification hooks (16)
• src/hooks/toolPermission/ — Permission checking
• src/hooks/toolPermission/handlers/ — Permission handlers

Utilities (331+)

• src/utils/ — Utility overview
• src/utils/background/ — Background tasks
• src/utils/background/remote/ — Remote sessions
• src/utils/bash/ — Bash parser & security
• src/utils/bash/specs/ — Command specs
• src/utils/claudeInChrome/ — Chrome extension
• src/utils/computerUse/ — Computer use
• src/utils/deepLink/ — Deep links
• src/utils/dxt/ — DXT manifest validation
• src/utils/filePersistence/ — File upload
• src/utils/git/ — Git utilities
• src/utils/github/ — GitHub CLI auth
• src/utils/hooks/ — Hook execution engine (26 events)
• src/utils/memory/ — Memory types & CLAUDE.md
• src/utils/messages/ — Message mapping
• src/utils/mcp/ — MCP utilities
• src/utils/model/ — Model selection
• src/utils/nativeInstaller/ — Self-update system
• src/utils/permissions/ — Permission rule engine
• src/utils/plugins/ — Plugin loading
• src/utils/powershell/ — PowerShell parsing
• src/utils/processUserInput/ — Input routing
• src/utils/sandbox/ — Sandbox adapter
• src/utils/secureStorage/ — Credential storage
• src/utils/settings/ — Settings hierarchy
• src/utils/settings/mdm/ — MDM profiles
• src/utils/shell/ — Shell provider
• src/utils/skills/ — Skill file watching
• src/utils/suggestions/ — Fuzzy command search
• src/utils/swarm/ — Multi-agent swarm
• src/utils/swarm/backends/ — Swarm backends (tmux, iTerm2)
• src/utils/task/ — Task framework
• src/utils/telemetry/ — OpenTelemetry
• src/utils/teleport/ — Session teleporting
• src/utils/todo/ — Todo schemas
• src/utils/ultraplan/ — Remote planning

Data & Types

• src/constants/ — Application constants (21 files)
• src/types/ — TypeScript types
• src/types/generated/ — Generated protobuf types
• src/migrations/ — Data migrations (11 files)
• src/native-ts/ — Native TS ports

Specialized Features

• src/screens/ — Top-level screens (REPL, Doctor, Resume)
• src/outputStyles/ — Output formatting
• src/vim/ — Vim mode
• src/voice/ — Voice input
• src/keybindings/ — Keybinding system
• src/buddy/ — Companion pet system
• src/memdir/ — Persistent memory
• src/assistant/ — Session history client
• src/upstreamproxy/ — Upstream proxy
• src/moreright/ — Internal feature stub

---

License

This documentation is licensed under Creative Commons Attribution 4.0 International (CC BY 4.0).

You are free to share and adapt the material for any purpose, even commercially, as long as you give appropriate credit.

Disclaimer: This license covers the original documentation only. Claude Code and all related software are the property of Anthropic, PBC and are not covered by this license.