codex-create-claude

KO | EN

gitlite — search

#javascript #hacktoberfest #react #go #machine-learning #rust #docker #windows #awesome #cli #vue #pytorch #mcp #openai

codex-create-claude

(★ 18)

Local isolated launcher for the public Claude Code package

codex-create-claude 최신버젼 다운로드

최종 버전 다운로드 (.zip)

// repository documentation

Was this content helpful?

★ 0 (0 ratings)

# codex-create-claude

[中文说明](./README.zh-CN.md)

Claude Code local deployment build based on the `2026-03-31` leaked code / source-map restoration.

This repository is unofficial. It is intended for local deployment and research.

## Requirements

- Node.js 18 or newer
- An Anthropic-compatible API endpoint

## Deploy

```bash
git clone https://github.com/sansanyuchen/codex-create-claude.git
cd codex-create-claude
chmod +x claude-local
./claude-local --init-env
```

## Configure API

The file you need to edit is:

```text
claude-local.env
```

Run this first:

```bash
./claude-local --init-env
```

This command will create `claude-local.env` automatically.

Then open `claude-local.env` and replace this placeholder with your real API key:

```bash
ANTHROPIC_AUTH_TOKEN=paste_your_api_key_here
```

Kimi example:

```bash
CLAUDE_LOCAL_PROVIDER=kimi
ANTHROPIC_AUTH_TOKEN=your_token_here
```

If you use Kimi, these 2 lines are enough. You do not need to fill `ANTHROPIC_BASE_URL` or model names manually.

## Start from command line

Check the launcher:

```bash
./claude-local --version
```

Start interactive mode:

```bash
./claude-local --bare
```

Run a single prompt:

```bash
./claude-local -p "Reply with exactly: hello" --bare --output-format text
```

## Project structure

```text
codex-create-claude
├── claude-local
├── package/
│   ├── cli.js
│   └── package.json
├── restored-src/
│   └── src/
│       ├── main.tsx
│       ├── QueryEngine.ts
│       ├── Tool.ts
│       ├── commands.ts
│       ├── tools.ts
│       ├── commands/
│       ├── tools/
│       ├── components/
│       ├── services/
│       └── utils/
└── extract-sources.js
```

## Claude Code architecture

At a high level, Claude Code is not just “a CLI wrapped around a model”. It is a layered agent runtime. The main layers are below.

### 1. Startup and assembly layer

`package/cli.js` is the packed runtime entrypoint used for actual execution.

`restored-src/src/main.tsx` is the real startup path. It is responsible for:

- parsing CLI arguments
- loading auth, policy, remote settings, and feature flags
- initializing plugins, skills, MCP, and agent definitions
- building the command registry and tool registry
- entering either interactive REPL mode or headless print mode

This layer acts like a system bootstrapper.

### 2. Command layer

`restored-src/src/commands.ts` and `restored-src/src/commands/` implement the slash-command system.

This is much more than a few helper commands. It includes commands such as:

- `/review`
- `/mcp`
- `/permissions`
- `/plan`
- `/tasks`
- `/skills`
- `/plugin`
- `/resume`

These commands can also change session behavior, such as model selection, permission mode, plugin state, or follow-up query context. That means Claude Code is not purely prompt-driven. It is command-driven and model-driven at the same time.

### 3. Tool layer

`restored-src/src/tools.ts` and `restored-src/src/tools/` assemble the model-facing tool system.

Core tools include:

- `BashTool`
- `FileReadTool`
- `FileEditTool`
- `FileWriteTool`
- `GlobTool`
- `GrepTool`
- `WebFetchTool`
- `WebSearchTool`
- `LSPTool`
- `AgentTool`
- `SkillTool`
- MCP resource tools
- plan / task / worktree / team / message collaboration tools

This layer organizes environment capabilities into a controlled tool pool before the model can use them.

### 4. Tool protocol layer

`restored-src/src/Tool.ts` defines the unified tool protocol.

This is one of the most important architectural layers. Tools are not simple function calls. Each tool runs with structured context, including:

- permission context
- AppState access
- abort control
- MCP clients and resources
- file caches
- notification and UI hooks
- transcript, file history, and thinking configuration

So the important engineering idea is not only “what tools exist”, but “how tool execution is controlled”.

### 5. Conversation execution layer

`restored-src/src/QueryEngine.ts` is the session-level execution core.

`QueryEngine.submitMessage()` turns one user input into a full agent turn. It:

- builds system prompt and context
- calls `processUserInput(...)` for slash commands, attachments, memory, and permission changes
- emits the system init message
- calls the lower-level `query(...)` loop
- maintains session-scoped messages, usage, cost, and permission denials
- records transcripts, flushes session storage, and updates file history

So `QueryEngine` is better understood as a conversation controller than a thin API wrapper.

### 6. Model sampling and tool orchestration layer

`restored-src/src/query.ts` is the low-level agent loop.

It handles:

- message normalization and context injection
- attachments and memory handling
- auto compact, reactive compact, and context collapse
- model sampling
- `tool_use` block detection
- tool execution and `tool_result` reinsertion
- `max_output_tokens` recovery
- token budget, tool summary, and stop-hook management

This layer is effectively Claude Code's orchestration engine.

### 7. UI and infrastructure layer

`restored-src/src/components/` contains the terminal UI.

`restored-src/src/services/` and `restored-src/src/utils/` provide:

- API integrations
- MCP integrations
- session persistence and recovery
- permissions and safety policy
- git/worktree helpers
- analytics, hooks, compaction, and token budgeting

Interactive mode and headless mode share the same execution core, but present different outputs on top of it.

### Main execution path

```mermaid
flowchart TD
    A["claude-local"] --> B["package/cli.js"]
    B --> C["main.tsx"]
    C --> D["Assemble runtime environment"]
    D --> E["commands.ts + commands/"]
    D --> F["tools.ts + tools/"]
    E --> G["processUserInput()"]
    F --> H["Tool.ts protocol layer"]
    G --> I["QueryEngine.submitMessage()"]
    H --> I
    I --> J["query() main loop"]
    J --> K["Model sampling"]
    J --> L["Tool orchestration and result reinsertion"]
    L --> J
    J --> M["transcript / file history / usage / compact"]
    I --> N["REPL / SDK / print output"]
```

### One-line summary

The architectural core of Claude Code is not a single `cli.js` file. It is the collaboration of three layers:

- `main.tsx`: assembles the system
- `QueryEngine.ts`: manages the session
- `query.ts`: runs the agent loop

From a systems perspective, it behaves more like an agent operating system inside the terminal than a simple chat CLI with Bash access.

codex-create-claude

codex-create-claude 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

codex-create-claude

codex-create-claude 최신버젼 다운로드

오늘의 추천 프로젝트

Was this content helpful?

Recent Feedback

Download README