Claude Code Tools

claude-code

github

Claude Code is an agentic coding tool that lives in your terminal, understands your codebase, and helps you code faster by executing routine tasks, explaining complex code, and handling git workflows - all through natural language commands.

Stars
⭐ 2,672
License
NOASSERTION
Last Updated
2026-05-20
Source
github

Claude Code — Leaked Source

The full source code of Anthropic’s Claude Code CLI, leaked on March 31, 2026

TypeScript Bun React + Ink Files MCP Server npm Twitter Follow

The original unmodified leaked source is preserved in the backup branch.


Table of Contents


How It Leaked

Chaofan Shou (@Fried_rice) discovered that the published npm package for Claude Code included a .map file referencing the full, unobfuscated TypeScript source — downloadable as a zip from Anthropic’s R2 storage bucket.

“Claude code source code has been leaked via a map file in their npm registry!”

@Fried_rice, March 31, 2026


What Is Claude Code?

Claude Code is Anthropic’s official CLI tool for interacting with Claude directly from the terminal — editing files, running commands, searching codebases, managing git workflows, and more. This repository contains the leaked src/ directory.

Leaked2026-03-31
LanguageTypeScript (strict)
RuntimeBun
Terminal UIReact + Ink
Scale~1,900 files · 512,000+ lines of code

� Documentation

For in-depth guides, see the docs/ directory:

GuideDescription
ArchitectureCore pipeline, startup sequence, state management, rendering, data flow
Tools ReferenceComplete catalog of all ~40 agent tools with categories and permission model
Commands ReferenceAll ~85 slash commands organized by category
Subsystems GuideDeep dives into Bridge, MCP, Permissions, Plugins, Skills, Tasks, Memory, Voice
Exploration GuideHow to navigate the codebase — study paths, grep patterns, key files

Also see: CONTRIBUTING.md · MCP Server README


�🔍 Explore with MCP Server

This repo ships an MCP server that lets any MCP-compatible client (Claude Code, Claude Desktop, VS Code Copilot, Cursor) explore the full source interactively.

Install from npm

The MCP server is published as warrioraashuu-codemaster on npm — no need to clone the repo:

# Claude Code
claude mcp add warrioraashuu-codemaster -- npx -y warrioraashuu-codemaster

One-liner setup (from source)

git clone https://github.com/codeaashu/claude-code.git ~/claude-code \
  && cd ~/claude-code/mcp-server \
  && npm install && npm run build \
  && claude mcp add claude-code-explorer -- node ~/claude-code/mcp-server/dist/index.js
Step-by-step setup
# 1. Clone the repo
git clone https://github.com/codeaashu/claude-code.git
cd claude-code/mcp-server

# 2. Install & build
npm install && npm run build

# 3. Register with Claude Code
claude mcp add claude-code-explorer -- node /absolute/path/to/claude-code/mcp-server/dist/index.js

Replace /absolute/path/to/claude-code with your actual clone path.

VS Code / Cursor / Claude Desktop config

VS Code — add to .vscode/mcp.json:

{
  "servers": {
    "claude-code-explorer": {
      "type": "stdio",
      "command": "node",
      "args": ["${workspaceFolder}/mcp-server/dist/index.js"],
      "env": { "CLAUDE_CODE_SRC_ROOT": "${workspaceFolder}/src" }
    }
  }
}

Claude Desktop — add to your config file:

{
  "mcpServers": {
    "claude-code-explorer": {
      "command": "node",
      "args": ["/absolute/path/to/claude-code/mcp-server/dist/index.js"],
      "env": { "CLAUDE_CODE_SRC_ROOT": "/absolute/path/to/claude-code/src" }
    }
  }
}

Cursor — add to ~/.cursor/mcp.json (same format as Claude Desktop).

Available tools & prompts

ToolDescription
list_toolsList all ~40 agent tools with source files
list_commandsList all ~50 slash commands with source files
get_tool_sourceRead full source of any tool (e.g. BashTool, FileEditTool)
get_command_sourceRead source of any slash command (e.g. review, mcp)
read_source_fileRead any file from src/ by path
search_sourceGrep across the entire source tree
list_directoryBrowse src/ directories
get_architectureHigh-level architecture overview
PromptDescription
explain_toolDeep-dive into how a specific tool works
explain_commandUnderstand a slash command’s implementation
architecture_overviewGuided tour of the full architecture
how_does_it_workExplain any subsystem (permissions, MCP, bridge, etc.)
compare_toolsSide-by-side comparison of two tools

Try asking: “How does the BashTool work?” · “Search for where permissions are checked” · “Show me the /review command source”

Custom source path / Remove

# Custom source location
claude mcp add claude-code-explorer -e CLAUDE_CODE_SRC_ROOT=/path/to/src -- node /path/to/mcp-server/dist/index.js

# Remove
claude mcp remove claude-code-explorer

Directory Structure

src/
├── main.tsx                 # Entrypoint — Commander.js CLI parser + React/Ink renderer
├── QueryEngine.ts           # Core LLM API caller (~46K lines)
├── Tool.ts                  # Tool type definitions (~29K lines)
├── commands.ts              # Command registry (~25K lines)
├── tools.ts                 # Tool registry
├── context.ts               # System/user context collection
├── cost-tracker.ts          # Token cost tracking

├── tools/                   # Agent tool implementations (~40)
├── commands/                # Slash command implementations (~50)
├── components/              # Ink UI components (~140)
├── services/                # External service integrations
├── hooks/                   # React hooks (incl. permission checks)
├── types/                   # TypeScript type definitions
├── utils/                   # Utility functions
├── screens/                 # Full-screen UIs (Doctor, REPL, Resume)

├── bridge/                  # IDE integration (VS Code, JetBrains)
├── coordinator/             # Multi-agent orchestration
├── plugins/                 # Plugin system
├── skills/                  # Skill system
├── server/                  # Server mode
├── remote/                  # Remote sessions
├── memdir/                  # Persistent memory directory
├── tasks/                   # Task management
├── state/                   # State management

├── voice/                   # Voice input
├── vim/                     # Vim mode
├── keybindings/             # Keybinding configuration
├── schemas/                 # Config schemas (Zod)
├── migrations/              # Config migrations
├── entrypoints/             # Initialization logic
├── query/                   # Query pipeline
├── ink/                     # Ink renderer wrapper
├── buddy/                   # Companion sprite (Easter egg 🐣)
├── native-ts/               # Native TypeScript utils
├── outputStyles/            # Output styling
└── upstreamproxy/           # Proxy configuration

Architecture

1. Tool System

src/tools/ — Every tool Claude can invoke is a self-contained module with its own input schema, permission model, and execution logic.

ToolDescription
File I/O
FileReadToolRead files (images, PDFs, notebooks)
FileWriteToolCreate / overwrite files
FileEditToolPartial modification (string replacement)
NotebookEditToolJupyter notebook editing
Search
GlobToolFile pattern matching
GrepToolripgrep-based content search
WebSearchToolWeb search
WebFetchToolFetch URL content
Execution
BashToolShell command execution
SkillToolSkill execution
MCPToolMCP server tool invocation
LSPToolLanguage Server Protocol integration
Agents & Teams
AgentToolSub-agent spawning
SendMessageToolInter-agent messaging
TeamCreateTool / TeamDeleteToolTeam management
TaskCreateTool / TaskUpdateToolTask management
Mode & State
EnterPlanModeTool / ExitPlanModeToolPlan mode toggle
EnterWorktreeTool / ExitWorktreeToolGit worktree isolation
ToolSearchToolDeferred tool discovery
SleepToolProactive mode wait
CronCreateToolScheduled triggers
RemoteTriggerToolRemote trigger
SyntheticOutputToolStructured output generation

2. Command System

src/commands/ — User-facing slash commands invoked with / in the REPL.

CommandDescriptionCommandDescription
/commitGit commit/memoryPersistent memory
/reviewCode review/skillsSkill management
/compactContext compression/tasksTask management
/mcpMCP server management/vimVim mode toggle
/configSettings/diffView changes
/doctorEnvironment diagnostics/costCheck usage cost
/login / /logoutAuth/themeChange theme
/contextContext visualization/shareShare session
/pr_commentsPR comments/resumeRestore session
/desktopDesktop handoff/mobileMobile handoff

3. Service Layer

src/services/ — External integrations and core infrastructure.

ServiceDescription
api/Anthropic API client, file API, bootstrap
mcp/Model Context Protocol connection & management
oauth/OAuth 2.0 authentication
lsp/Language Server Protocol manager
analytics/GrowthBook feature flags & analytics
plugins/Plugin loader
compact/Conversation context compression
extractMemories/Automatic memory extraction
teamMemorySync/Team memory synchronization
tokenEstimation.tsToken count estimation
policyLimits/Organization policy limits
remoteManagedSettings/Remote managed settings

4. Bridge System

src/bridge/ — Bidirectional communication layer connecting IDE extensions (VS Code, JetBrains) with the CLI.

Key files: bridgeMain.ts (main loop) · bridgeMessaging.ts (protocol) · bridgePermissionCallbacks.ts (permission callbacks) · replBridge.ts (REPL session) · jwtUtils.ts (JWT auth) · sessionRunner.ts (session execution)

5. Permission System

src/hooks/toolPermission/ — Checks permissions on every tool invocation.

Prompts the user for approval/denial or auto-resolves based on the configured permission mode: default, plan, bypassPermissions, auto, etc.

6. Feature Flags

Dead code elimination at build time via Bun’s bun:bundle:

import { feature } from 'bun:bundle'

const voiceCommand = feature('VOICE_MODE')
  ? require('./commands/voice/index.js').default
  : null

Notable flags: PROACTIVE · KAIROS · BRIDGE_MODE · DAEMON · VOICE_MODE · AGENT_TRIGGERS · MONITOR_TOOL


Key Files

FileLinesPurpose
QueryEngine.ts~46KCore LLM API engine — streaming, tool loops, thinking mode, retries, token counting
Tool.ts~29KBase types/interfaces for all tools — input schemas, permissions, progress state
commands.ts~25KCommand registration & execution with conditional per-environment imports
main.tsxCLI parser + React/Ink renderer; parallelizes MDM, keychain, and GrowthBook on startup

Tech Stack

CategoryTechnology
RuntimeBun
LanguageTypeScript (strict)
Terminal UIReact + Ink
CLI ParsingCommander.js (extra-typings)
Schema ValidationZod v4
Code Searchripgrep (via GrepTool)
ProtocolsMCP SDK · LSP
APIAnthropic SDK
TelemetryOpenTelemetry + gRPC
Feature FlagsGrowthBook
AuthOAuth 2.0 · JWT · macOS Keychain

Design Patterns

Parallel Prefetch — Startup optimization

MDM settings, keychain reads, and API preconnect fire in parallel as side-effects before heavy module evaluation:

// main.tsx
startMdmRawRead()
startKeychainPrefetch()
Lazy Loading — Deferred heavy modules

OpenTelemetry (~400KB) and gRPC (~700KB) are loaded via dynamic import() only when needed.

Agent Swarms — Multi-agent orchestration

Sub-agents spawn via AgentTool, with coordinator/ handling orchestration. TeamCreateTool enables team-level parallel work.

Skill System — Reusable workflows

Defined in skills/ and executed through SkillTool. Users can add custom skills.

Plugin Architecture — Extensibility

Built-in and third-party plugins loaded through the plugins/ subsystem.


GitPretty Setup

Show per-file emoji commit messages in GitHub's file UI
# Apply emoji commits
bash ./gitpretty-apply.sh .

# Optional: install hooks for future commits
bash ./gitpretty-apply.sh . --hooks

# Push as usual
git push origin main

Contributing

Contributions to documentation, the MCP server, and exploration tooling are welcome. See CONTRIBUTING.md for guidelines.

Note: The src/ directory is the original leaked source and should not be modified.


Disclaimer

This repository archives source code leaked from Anthropic’s npm registry on 2026-03-31. All original source code is the property of Anthropic. This is not an official release and is not licensed for redistribution. Contact aashuu ✦ for any comments.


Star History Chart