Claude Code Book

English | 简体中文

We have automatically generated the Claude Code Book: ClaudeCodeBook-中文.pdf | ClaudeCodeBook-English.pdf

Overview

Claude Code: An AI-powered CLI agent for software development, built by Anthropic.

Claude Code is a command-line interface tool that brings Claude's reasoning capabilities directly into the development workflow. It provides an interactive REPL with AI assistance, a comprehensive tool system for file operations and command execution, Vim-style modal editing, and deep integration with development workflows (Git, shell commands, editors).

The project is written in TypeScript with Bun as the runtime and build tool. It targets multiple platforms (macOS, Linux, Windows) and supports multiple authentication methods including OAuth, API keys, and cloud provider integrations (AWS Bedrock, Google Vertex AI).

Repository Structure

claude-code/
├── src/                          # Main application source code
│   ├── index.ts                  # Application entry point
│   ├── commands.ts               # Slash command registry and loading
│   ├── context.ts                # AI context preparation (system/user prompts)
│   ├── cost-tracker.ts           # API usage tracking and cost reporting
│   ├── tools.ts                  # Tool registry and MCP integration
│   │
│   ├── commands/                  # Slash command implementations (~40 commands)
│   │   ├── add.ts                 # Add/edit code with AI
│   │   ├── autofixPr.ts          # Auto-fix pull requests
│   │   ├── bash.ts               # Shell command execution
│   │   ├── config.ts             # Configuration management
│   │   ├── diff.ts               # Git diff viewer
│   │   ├── git.ts                # Git operations
│   │   └── ...
│   │
│   ├── tools/                     # Tool implementations for AI agent
│   │   ├── BashTool.ts
│   │   ├── FileReadTool.ts
│   │   ├── WebSearchTool.ts
│   │   ├── AgentTool.ts
│   │   └── ...
│   │
│   ├── utils/                     # Shared utilities (~40 subdirectories)
│   │   ├── bash/                  # Shell parsing, security, execution
│   │   │   ├── exec.ts           # Command execution engine
│   │   │   ├── parser.ts         # Shell parser utilities
│   │   │   ├── security.ts       # Command security validation
│   │   │   └── shellSnapshot.ts  # Shell state capture
│   │   ├── git/                  # Git operations
│   │   ├── settings/             # Configuration persistence
│   │   ├── analytics/            # Session analytics and BigQuery export
│   │   ├── telemetry/            # OpenTelemetry tracing and metrics
│   │   ├── teleport/             # Remote session API client
│   │   ├── vim/                  # Vim emulation layer
│   │   ├── todo/                 # Todo data types
│   │   ├── ultraplan/            # Ultra-plan workflow
│   │   └── ...
│   │
│   ├── bootstrap/                 # Application initialization
│   │   └── state.ts              # Global STATE singleton
│   │
│   ├── bridge/                    # Remote control infrastructure
│   │   ├── bridgeApi.ts          # Environments REST API client
│   │   ├── bridgeConfig.ts       # Configuration with OAuth/keychain
│   │   ├── bridgeDebug.ts        # Fault injection for testing
│   │   └── workSecret.ts        # Work secret decoding and session routing
│   │
│   ├── buddy/                     # Companion mascot system
│   │   ├── companion.js          # Creature generation (seeded PRNG)
│   │   ├── sprites.ts           # ASCII art rendering
│   │   └── CompanionSprite.tsx  # React sprite component
│   │
│   ├── assistant/                # Teleport Agent SDK
│   │   ├── entrypoints/         # SDK entry points and types
│   │   └── utils/               # API client with OAuth support
│   │
│   ├── voice/                     # Voice mode feature gating
│   │   └── voice-mode.ts        # GrowthBook + OAuth auth checks
│   │
│   └── vim/                       # Vim emulation
│       ├── transitions.ts        # State machine (NORMAL/INSERT modes)
│       ├── motions.ts           # Cursor movement functions
│       ├── operators.ts         # Edit operations (delete, yank, etc.)
│       ├── textObjects.ts       # Text object boundaries
│       └── types.ts             # TypeScript interfaces and constants
│
├── src/commands.ts               # Command registry entry
├── src/tools.ts                  # Tool registry entry
├── src/context.ts                # Context preparation entry
├── src/cost-tracker.ts           # Cost tracking entry
├── src/index.ts                   # Main entry point
│
├── package.json                  # Node.js dependencies
├── bunfig.toml                   # Bun build configuration
├── tsconfig.json                 # TypeScript configuration
└── ...

Getting Started

Prerequisites

• Bun ≥ 1.0 (install via bun.sh)
• Node.js ≥ 18 (for fallback)
• macOS / Linux / Windows (WSL supported)

Installation

# Clone the repository
git clone https://github.com/anthropics/claude-code.git
cd claude-code

# Install dependencies with Bun
bun install

# Build the project
bun run build

# Link for development
bun link

Development Setup

# Run in development mode with hot reload
bun run dev

# Run tests
bun test

# Run with debug output
DEBUG=* bun run start

Environment Variables

Usage

Basic Commands

# Start an interactive session
claude

# Start with a specific task
claude "Explain this codebase"

# Start with auto-approve mode (for automation)
claude --approve-all "Review and fix bugs"

# Resume a previous session
claude --resume <session-id>

Slash Commands

Available in the interactive REPL:

Configuration

# View current config
claude config list

# Set a config value
claude config set model claude-opus-4-5

# Set an environment variable
claude config set --env API_KEY your_key

Key Modules & Scripts

Core Entry Points

State Management

Security & Bash Execution

Telemetry & Analytics

Vim Emulation

Remote & Cloud Features

Architecture

System Architecture

┌─────────────────────────────────────────────────────────────────┐
│                         CLI Interface                           │
│   User Input → Slash Commands → REPL → Vim Mode                 │
└────────────────────────────┬────────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────────┐
│                    Command Registry (commands.ts)               │
│   Resolves slash commands, checks feature flags, validates perms  │
└────────────────────────────┬────────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────────┐
│                     Tool Registry (tools.ts)                    │
│   Built-in tools + MCP tools + permission-filtered tools        │
└────────────────────────────┬────────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────────┐
│                    Tool Implementations                          │
│   BashTool, FileReadTool, WebSearchTool, AgentTool, ...         │
└────────────────────────────┬────────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────────┐
│                    AI Model (Claude API)                         │
│   Context prepared by context.ts                                │
└────────────────────────────┬────────────────────────────────────┘
                             │
┌────────────────────────────▼────────────────────────────────────┐
│                    Cost Tracking (cost-tracker.ts)              │
│                    Telemetry (telemetry/)                        │
│                    Analytics (analytics/)                       │
└─────────────────────────────────────────────────────────────────┘

Authentication Model

Claude Code supports multiple authentication methods:

1. OAuth — User login via claude auth login (stored in macOS Keychain)
2. API Key — Set via ANTHROPIC_API_KEY environment variable
3. Cloud Providers — AWS Bedrock, Google Vertex AI, AWS IAM
4. Trusted Device — Device tokens for remote control (CCR v2)

Feature Gating

Features are gated via:

• GrowthBook (growthbook.js) — Remote feature flags for A/B testing
• Bundle constants (bun:bundle) — Dead-code elimination for disabled features
• Platform checks — macOS-only features (Keychain, speech synthesis)

Data Pipeline

Context Preparation Flow

1. User input received
       │
2. context.ts → getUserContext()
       │        ├── Reads .claude/CLAUDE.md
       │        ├── Reads .claude/instructions.md
       │        └── Memoized per session
       │
3. context.ts → getSystemContext()
       │        ├── Git status (branch, recent commits)
       │        ├── Current directory info
       │        └── Cache breaker injection
       │
4. Combined into system prompt injection

Telemetry Flow

Tool execution / LLM call
       │
Span created by sessionTracing.ts
       │
Events logged by events.ts (logOTelEvent)
       │
Metrics accumulated by OpenTelemetry SDK
       │
bigqueryExporter.ts → POST to BigQuery API
       │
(Optionally) Perfetto trace file written

Session Analytics Flow

Session starts
       │
Analytics initialized with session ID
       │
Per-tool/per-command metrics accumulated
       │
Session ends
       │
bigqueryExporter.ts → POST to BigQuery
       │
STATE.sessionAnalytics cleared

Dependencies

Runtime Dependencies

Development Dependencies

License

Proprietary — Claude Code is developed and maintained by Anthropic PBC. Usage is subject to Anthropic's Acceptable Use Policy and Terms of Service. For commercial licensing or enterprise deployments, contact Anthropic at anthropic.com. This repo does not contain any original Claude Code source code.