Reading Claude Code 2.1.88 through its own source map

Recovering 70w lines from a 57MB source map

The npm package `@anthropic-ai/claude-code` went out as version 2.1.88 on 2026.03.31 carrying a `cli.js.map` of 57MB. That map was not stripped at publish time, and its `sourcesContent` field holds the original code rather than a pointer to it. The accident is the raw material here: read the `sources` list for the original file paths, read the matching `sourcesContent` strings for the text, write both back out to disk. What comes out is a directory described as a close reconstruction of the original code organisation, some 70w lines of TypeScript laid out under `src/`, which is Chinese shorthand for seven hundred thousand lines. Nobody retyped this and nobody had to unminify anything, so the recovered files read like ordinary application code with ordinary imports between them.

The audience is deliberately narrow. Engineers who want to understand how the CLI is put together, how its command system is shaped, and how the Model Context Protocol is wired into a terminal agent. Nobody is expected to run it.

Seven directories that split the CLI by role

Reading starts at the top level, which holds five entries: `README.md`, `claude-code-2.1.88.tgz`, `node_modules/`, `src/` and `vendor/`. Underneath, the recovered files are separated by role across seven directories. `src/entrypoints/` holds CLI entry and initialisation logic. `src/commands/` holds the command system, with named commands including `login`, `mcp`, `review` and `tasks`. `src/components/` holds terminal UI components built on React and Ink, while `src/ink/` holds the custom terminal rendering infrastructure those components sit on. `src/services/` carries business logic around strategy, sync and remote capabilities, `src/hooks/` handles interactive terminal state management, and `src/utils/` gathers authentication, file operation and process management helpers.

That split is the main argument for using this repository rather than the map itself. A flat extraction gives you hundreds of paths and no hint about which one boots the program and which one is a helper.

One loader mixes built-ins, skills, plugins and MCP

The first of four design points the README picks out is the command loader, described as a hybrid that mounts built-in commands together with dynamic skills, plugins and MCP commands in one place. That seam is where most readers arrive, because it decides what a terminal agent may do at all and lets a third-party server have a say in the answer.

Second comes the terminal interface: React components rendered through Ink rather than a line-oriented framework, with `src/components/` and `src/ink/` kept apart so the rendering substrate can be read without any one screen in view. The third is the Model Context Protocol implementation. The fourth is feature flags, which the README says run through the source as feature trimming and build-time control logic. A reader chasing the answer to how capabilities get switched off will find that thread early, and it explains a good deal about why the code has the shape it has.

Feature flags and bun:bundle block a clean build

The fourth point is also the practical obstacle. Build notes, filed by the author as still to be completed, list four steps for anyone who wants this tree to run: add `package.json` and configure dependencies, fill in the build toolchain, deal with the `bun:bundle` macro and the feature flags, then verify that the core commands work. None of the four is marked done. A macro name points at Bun's bundler macros, so any recovered module that calls it needs a build-time replacement before plain Node execution can reach it, and the flags then decide which branches survive into the output.

This is where the project stops being useful to most people. A tree recovered from a source map is a reading artefact, and the author frames running it as an experiment rather than a supported mode. That is an honest position, given the starting point: there was no repository here, only a compiler's side output that happened to survive packaging.

Getting 2.1.88 back after npm removed the version

Obtaining the original artefact takes a detour, because the official npm page for 2.1.88 has been removed. Asking npm for that exact version returns an error:

npm install @anthropic-ai/[email protected]

The README routes around the removal with a Tencent mirror and one global install:

npm install -g https://mirrors.cloud.tencent.com/npm/@anthropic-ai/claude-code/-/claude-code-2.1.88.tgz

Run that and npm fetches the same 2.1.88 tarball out of a third-party cache. Two limits deserve plain statement. The lifetime of that cache belongs to nobody involved in this repository, and the README warns in blunt terms that it may be gone at some point, with slow arrivals getting nothing. Because that URL is the only published route to the version, the install path disappears along with the cache. The next thing the README offers is the author's WeChat account for first-hand notices, which is not something you can pin a version against.

The tarball already sits inside the repository tree

Now the part that only turns up on a careful read. The top level already contains `claude-code-2.1.88.tgz`, the same artefact the mirror command downloads, so cloning this repository gives you the package the install section is chasing. Beside it sit `node_modules/` and `vendor/`, committed directories of dependency code. Yet the build notes in the same file tell you to add `package.json` and configure dependencies, and `package.json` is not one of the five top-level entries. So the tree either carries its dependency tree without a manifest, or it expects you to supply one, and nothing in the README settles which.

The practical consequence for a reader: clone first, then look. The mirror detour matters only if you want the running binary rather than the source, and the README does not describe a build output, a test or a run script anywhere.

An advertising block sits above the copyright notice

The README opens with a promotional block for DataEyesAI, an aggregator linked out with a `promoter_code=4qx9suz3` parameter, and it sits above the project's own important notice rather than after it. Everything below is more careful. The notice marks the repository as unofficial and says it does not speak for Anthropic, states that copyright, trademarks and related rights in the recovered code belong to Anthropic, limits the purpose to archival, structural analysis and source reading, and says republishing or commercial use means assessing the terms and legal risk yourself. GitHub reports no licence for this repository, which leaves default copyright in place over the recovered files, and the last push was on 2026-04-15. The one entry in the release record is 2.1.88 at 2026-04-01T03:38:25Z, a day later than the upload date the README gives.

Reading the map yourself skips the rebuilt layout

A second route to the same code exists, and it deserves naming because the project credits it in its closing acknowledgement. That acknowledgement is directed at the source map that shipped instead of being removed, which makes the map the real artefact and this repository one reading of it. Anyone holding the tarball can open `cli.js.map` and write the `sourcesContent` entries out as files, skipping this layout, skipping `node_modules/`, skipping the notes.

What differs is arrangement rather than bytes. Here the tree is grouped by role, so the command loader, the Ink substrate and the MCP wiring sit in separate directories a reader can open in turn. A direct extraction reproduces paths exactly as the bundler recorded them, which is faithful and says nothing about what a file is for. Another alternative is behavioural rather than textual: install 2.1.88 from the mirror and use the CLI, which answers what a command does and never how.

Editorial conclusion

This is a reading tool, not a runtime. Engineers who want to see how the Claude Code 2.1.88 CLI resolves commands, renders Ink components or wires up MCP get a genuinely useful tree here, and grouping the files by role beats what a raw map extraction gives. Anyone expecting a fork they can run should stop: no package.json, an unresolved bun:bundle macro, and a mirror that can vanish without warning. Clone the repository, check whether src/ holds the complete set of paths, and treat the Tencent mirror as a temporary route rather than a permanent install source.

Frequently asked questions

Official sources

1. Issues
2. ponponon/claude_code_src on GitHub
3. README
4. Releases