Claw Code 项目架构万字解读

kcuwu.2026-06-07 14:04

1. 项目概述

1.1 项目定位

Claw Code 是 Claude Code 的开源 Rust 实现，是一个由 AI 代理自主构建的 CLI（Command Line Interface，命令行界面） 工具。

核心理念：

  • 人类设定方向，AI 执行劳动
  • 通过 Discord 作为人机接口，实现异步协作
  • 展示 自主软件开发和协调系统 的能力

1.2 项目特点

特点 说明
AI 自主构建 项目本身由 AI 代理（claws/lobsters）自主构建
多代理协作 支持多个 AI 代理并行工作、代码审查、自动修复
Rust 实现 核心代码使用 Rust 编写，性能高、安全性强
多提供商支持 支持 Anthropic、OpenAI、xAI、DashScope 等多个 AI 提供商
MCP 协议集成 支持 MCP（Model Context Protocol，模型上下文协议），可扩展外部工具
RAG 增强 集成 RAG（Retrieval-Augmented Generation，检索增强生成） 服务，结合代码搜索和 AI 生成

1.3 项目哲学

根据 PHILOSOPHY.md，项目的核心哲学是：

"Stop Staring at the Files"（别盯着文件看）

  • Python 重写是副产品，Rust 重写也是副产品
  • 真正的价值在于产生它们的系统：一个基于 clawhip 的协调循环
  • 人类提供清晰的方向，自主 claws 执行工作
  • 人类的接口是 Discord，而不是终端

三层系统：

  1. OmX（oh-my-codex）：工作流层，将短指令转换为结构化执行
  2. clawhip：事件和通知路由器，保持监控和传递在代理上下文窗口之外
  3. OmO（oh-my-openagent）：多代理协调，处理规划、交接、分歧解决

2. 技术栈

2.1 核心语言

语言 版本 用途
Rust edition 2021 主要实现语言（核心运行时、CLI、API 客户端）
Python 3.x 辅助移植工作区（TypeScript 版本移植参考）

2.2 Rust 主要依赖库

异步运行时与并发
依赖库 版本 用途
tokio 1.x 异步运行时，支持 async/await
tokio-stream 0.1 流式处理
序列化与数据交换
依赖库 版本 用途
serde 1.x 序列化/反序列化框架
serde_json 1.x JSON 支持
HTTP 与 API 通信
依赖库 版本 用途
reqwest 0.11 HTTP 客户端（支持异步）
eventsource-stream 0.4 SSE（Server-Sent Events，服务器推送事件） 解析
CLI 与终端
依赖库 版本 用途
clap 4.x CLI（Command Line Interface，命令行界面） 参数解析
crossterm 0.27 终端渲染和光标控制
工具库
依赖库 版本 用途
regex 1.x 正则表达式
sha2 0.10 哈希计算
walkdir 2.x 目录遍历
globset 0.4 文件名模式匹配
数据库与向量搜索
依赖库 版本 用途
rusqlite 0.31 SQLite 嵌入（RAG 服务）
qdrant-client 1.x Qdrant 向量数据库客户端（可选特性）
Web 框架（RAG 服务）
依赖库 版本 用途
axum 0.7 Web 框架（REST API 和 gRPC）
切面编程
依赖库 版本 用途
aspect-macros 0.1 AOP（Aspect-Oriented Programming，面向切面编程） 宏
aspect-std 0.1 AOP 标准库

2.3 架构模式

模式 说明
Workspace 管理 Cargo workspace 管理 11 个 crate（Rust 包）
Trait 抽象 ApiClient、ToolExecutor、Provider 等 trait 定义核心接口
事件驱动 Lane 事件系统管理 Agent 执行状态
MCP 协议 MCP（Model Context Protocol，模型上下文协议） 支持外部工具扩展
Hook 系统 工具执行前后可插入自定义逻辑
权限分层 多层权限检查（全局 → 项目 → 本地）

3. 目录结构及模块职责

3.1 完整目录树

复制代码 
claw-code-main/
│
📂 rust                              🔴 Rust 主实现（Workspace），~48,600 行代码
├── 📁 .claude          Rust 子项目级 AI 指令、会话规则、权限配置、todos 任务清单（覆盖根目录设置）
├── 📁 .claw            claw 项目专属配置：默认权限模式(dontAsk)、本地运行时参数覆盖
├── 📁 .omc             OmC(Oh-My-Codex) 工作流引擎的计划存储目录（plans/）
├── 📁 .sandbox-home    沙箱执行环境的用户主目录挂载点（用于隔离 Bash 命令执行环境）
├── 📁 crates           🔴 Rust 工作区核心：11 个 crate，约 48,600 行代码，完整的功能模块化架构
│   ├── 📁 api              AI API 客户端层：Anthropic/OpenAI/xAI/DashScope 多提供商 HTTP+SSE 流式通信（15 个 .rs 文件）
│   ├── 📁 claw-analog      轻量级代理工具：窄功能集 CLI，仅文件系统操作+显式权限模式，适用于 CI/脚本/外部 Agent（NDJSON 输出）
│   ├── 📁 claw-rag-service RAG 检索增强服务：Axum Web 服务器 + Qdrant 向量数据库集成，代码索引+语义搜索+Web UI（8 个 .rs 文件）
│   ├── 📁 commands         斜杠命令注册与解析系统：命令元数据定义、帮助文本生成、参数解析分发（~470 行）
│   ├── 📁 compat-harness  TypeScript 清单元数据提取工具：从原始 Claude Code 提取类型/命令清单用于对标验证
│   ├── 📁 mock-anthropic-service  API 模拟服务：确定性 Anthropic 兼容的 /v1/messages mock 端点，用于无真实 API 测试
│   ├── 📁 plugins          插件系统：外部工具加载机制、插件生命周期管理、钩子(hooks)注册框架
│   ├── 📁 runtime          ⭐核心运行时（最复杂模块）：对话循环、会话管理、权限系统、MCP 协议、事件系统(Lane Events)、配置加载、压缩策略（49 个 .rs 文件，~5,300 行）
│   ├── 📁 rusty-claude-cli ⭐主 CLI 二进制：REPL 交互循环、参数解析、Markdown 渲染、TUI 终端界面、所有斜杠命令处理器（~3,600 行，12 个 .rs 文件）
│   ├── 📁 telemetry        遥测与追踪：使用指标收集、错误上报、性能监控（可选遥测后端）
│   └── 📁 tools            内置工具执行引擎：18 个原生工具实现（Bash/Read/Write/Grep/Edit/Search/LS 等）、沙箱安全校验（~3,500 行，单文件 lib.rs 376KB）
├── 📁 scripts           构建与测试辅助脚本
│   ├── 📄 install.sh             一键安装脚本：依赖检查、编译 claw 二进制、配置 PATH 环境变量
│   ├── 🐍 run_mock_parity_diff.py  Mock 对标差异检测：Python 脚本，对比 Rust 实现与原始 Claude Code 的行为差异（12 个场景）
│   └── 📄 run_mock_parity_harness.sh  Mock 对标测试启动器：一键启动模拟服务+运行 12 个脚本场景的端到端测试
├── 🎭 .claw.json        claw 权限配置：定义默认权限模式（当前为 dontAsk，即不询问直接执行）
├── 🎭 .clawd-todos.json  clawd 开发任务清单（待办事项跟踪）
├── 🚫 .dockerignore     Docker 构建忽略规则：排除 target/、.git/、node_modules/ 等不需要打包的文件
├── 🚫 .gitignore        Git 版本控制忽略规则：编译产物、本地配置、敏感凭证、IDE 文件
├── 🔒 Cargo.lock       依赖锁定文件：精确记录所有第三方 crate 的版本哈希，确保可重现构建
├── 📦 Cargo.toml        ⭐Cargo 工作区配置：定义 11 个 crate 成员、共享依赖版本、编译 lints 规则（edition 2021, forbid unsafe_code）
├── 📘 CLAUDE.md         Rust 子项目的 AI 指令文件：Rust 格式化命令(clippy/cargo test)验证方式、编码规范约定
├── 📘 MOCK_PARITY_HARNESS.md  Mock 对标测试说明文档：12 个测试场景详解（streaming_text/bash_permission/token_cost 等）+ 运行方法
├── 🎭 mock_parity_scenarios.json  Mock 测试场景定义文件：JSON 格式的 12 个脚本场景输入/预期输出配置
├── 📘 PARITY.md         对标状态文档：9-lane checkpoint 进度、mock parity harness 里程碑、48,599 行 Rust 代码统计
├── 📘 README.md         Rust 子项目首页：快速开始、构建命令、OAuth 配置、REPL 使用示例
├── 📘 TUI-ENHANCEMENT-PLAN.md  TUI 终端界面增强计划：从当前 REPL 向现代化 TUI 转型的分阶段方案（组件分析+路线图）
└── 📘 USAGE.md          详细使用手册：CLI 命令全参数、AI 指令用法、配置修改教程、故障排查
│
📂 src                              🔴 Python 移植工作区：68 个 .py 文件 + 27 个子系统包 + 32 个参考 JSON，原始 Claude Code(TypeScript)的 1:1 镜像
├── 📁 assistant           AI 助手子系统：助手行为定义、响应策略、角色设定（TS 原档对应层）
├── 📁 bootstrap           启动引导子系统：初始化流程、环境检测、首轮会话引导逻辑
├── 📁 bridge              桥接子系统：Python↔Rust 跨语言调用接口、类型转换适配层
├── 📁 buddy               代码伙伴子系统：结对编程辅助、实时建议、代码审查规则
├── 📁 cli                 CLI 终端子系统：命令行参数解析、子命令路由、交互式输入处理
├── 📁 components          UI 组件子系统：终端界面渲染组件、Markdown 输出、交互式选择器
├── 📁 constants           常量定义子系统：全局魔法数字、配置默认值、枚举映射表
├── 📁 coordinator         协调器子系统：多 Agent 任务调度、lane 状态管理、事件分发中枢
├── 📁 entrypoints         入口点子系统：多启动模式分发（REPL/单次/远程/守护进程）
├── 📁 hooks               钩子子系统：生命周期钩子注册、事件拦截、工具执行前后回调
├── 📁 keybindings         快捷键子系统：终端按键绑定定义、Vim 模式映射、组合键配置
├── 📁 memdir              记忆目录子系统：持久化记忆存储、用户偏好记忆、项目上下文记忆
├── 📁 migrations          数据迁移子系统：版本升级时的数据格式迁移、配置兼容转换
├── 📁 moreright           权限扩展子系统：细粒度权限策略、审批链流程、安全策略注入
├── 📁 native_ts           TypeScript 原生引用：保留的 TS 代码片段，用于行为对标验证
├── 📁 outputStyles        输出样式子系统：终端颜色主题、Markdown 渲染风格、代码高亮配色
├── 📁 plugins             插件子系统：Python 侧插件加载器、Hook 注册、扩展点管理
├── 📁 reference_data      ⭐参考数据仓库：33 个文件(32 个 JSON+1 个 .py)，存放 207 条命令+184 个工具的原始清单快照（对标基线）
├── 📁 remote              远程通信子系统：远程 Agent 连接、消息序列化、网络传输协议
├── 📁 schemas             数据模式子系统：JSON Schema 定义、请求/响应类型校验、配置校验
├── 📁 screens             屏幕管理子系统：终端分屏布局、多面板切换、视图状态管理
├── 📁 server              服务端子系统：HTTP/WebSocket 服务、REST API 端点、流式响应
├── 📁 services            服务层子系统：业务逻辑封装、AI 提供商 API 适配、外部服务集成
├── 📁 skills              技能子系统：可插拔 AI 技能包定义、技能发现与加载、技能参数验证
├── 📁 state               状态管理子系统：全局应用状态、会话状态机、Redux 风格状态流转
├── 📁 types               类型定义子系统：TypeScript 类型→Python TypedDict/dataclass 映射，核心数据结构
├── 📁 upstreamproxy       上游代理子系统：API 请求代理转发、多提供商负载均衡、认证透传
├── 📁 utils               工具函数子系统：通用辅助函数（字符串处理、文件操作、日期时间等）
├── 📁 vim                 Vim 集成子系统：Vim/Neovim 编辑器嵌入、缓冲区同步、光标位置跟踪
├── 📁 voice               语音交互子系统：语音输入识别、TTS 输出、语音命令解析
├── 🐍 __init__.py              ⭐包导出表面：聚合 PortRuntime/QueryEnginePort/PORTED_COMMANDS 等公共 API
├── 🐍 _archive_helper.py       归档辅助：从 archive 目录提取 TypeScript 源码快照，构建对标基线
├── 🐍 bootstrap_graph.py       启动流程图：定义初始化阶段的有向无环依赖图（DAG）
├── 🐍 command_graph.py         命令流程图：207 条命令的调用关系图与依赖拓扑排序
├── 🐍 commands.py              命令清单加载器：从 reference_data 加载 207 条镜像命令，提供查找/过滤/执行
├── 🐍 context.py               工作区上下文：描述移植工作区的目录结构、文件统计、归档路径
├── 🐍 cost_tracker.py          Token 成本追踪：记录每次 API 调用的 token 消耗与费用估算
├── 🐍 costHook.py              成本钩子：在 API 请求前后注入成本计算逻辑，实时预算监控
├── 🐍 deferred_init.py         延迟初始化：按需加载模块，减少启动时的内存占用与导入时间
├── 🐍 dialogLaunchers.py       对话启动器：多种对话模式入口（快速问答/深度分析/代码审查等）
├── 🐍 direct_modes.py          直接模式：绕过 REPL 循环的单次指令执行模式（类似 claw prompt "..."）
├── 🐍 execution_registry.py    执行注册表：记录所有命令/工具的调用历史、参数快照、执行状态
├── 🐍 history.py               对话历史：消息列表管理、滚动窗口、历史搜索与回放
├── 🐍 ink.py                   终端墨水渲染：ANSI 颜色、光标控制、进度条、动态刷新效果
├── 🐍 interactiveHelpers.py    交互式辅助：用户确认弹窗、多选列表、表单输入等交互组件
├── 🐍 main.py                  ⭐CLI 主入口：argparse 参数解析，20+子命令(summary/manifest/parity-audit/route/bootstrap/turn-loop/remote-mode 等)
├── 🐍 models.py                AI 模型定义：提供商枚举、模型参数配置、最大 token/温度/top_p 等参数映射
├── 🐍 parity_audit.py          一致性审计引擎：Python 移植区 vs TypeScript 归档快照的覆盖率对比（根文件/目录/条目缺失报告）
├── 🐍 path_scope.py            路径作用域：工作区目录边界校验，防止工具越权访问 workspace 外文件
├── 🐍 permissions.py           权限上下文：工具级 deny/allow 策略，危险操作拦截（rm -rf / fork bomb 等），路径作用域验证
├── 🐍 port_manifest.py         移植清单构建器：扫描 Python 移植区，生成 PORTED_COMMANDS/PORTED_TOOLS 完整清单
├── 🐍 prefetch.py              预取优化：提前加载高频模块/配置到内存，降低首次调用延迟
├── 🐍 projectOnboardingState.py 项目入职状态：新成员首次使用时的引导流程、教程步骤、偏好设置向导
├── 🐍 query.py                 查询请求封装：用户消息结构体，包含 prompt/attachments/context/options
├── 🐍 QueryEngine.py           查询引擎（旧版）：与 query_engine.py 互补，提供向后兼容的 API 接口
├── 🐍 query_engine.py          ⭐查询引擎端口：会话消息循环核心，管理 token 预算、结构化输出、转录存储、会话持久化
├── 🐍 remote_runtime.py        远程运行时：连接远程 Agent 实例，消息代理转发，断线重连逻辑
├── 🐍 replLauncher.py          REPL 启动器：交互式 REPL 模式的初始化、提示符渲染、命令补全注册
├── 🐍 runtime.py               ⭐端口运行时核心：prompt 路由匹配(token 评分)、启动会话、turn-loop 执行、权限推断
├── 🐍 session_store.py         会话持久化：将 session_id/消息/token 统计保存到 .port_sessions/ 目录的 JSON 文件
├── 🐍 setup.py                 安装配置：pip 安装入口、依赖声明、包元数据(名称/版本/作者)
├── 🐍 system_init.py           系统初始化：系统级 prompt 构建，注入工具清单/权限策略/工作区上下文
├── 🐍 task.py                  任务规划结构：定义 PortingTask dataclass（移植任务名称+描述）
├── 🐍 tasks.py                 默认任务集：3 个预定义移植任务(root-module-parity/directory-parity/parity-audit)
├── 🐍 tool_pool.py             工具池组装器：合并工具清单+权限上下文+模式标志，生成可执行工具池
├── 🐍 Tool.py                  工具基类：定义工具接口(名称/描述/参数 Schema/执行方法)，所有工具的抽象父类
├── 🐍 tools.py                 工具清单加载器：从 reference_data 加载 184 条镜像工具，支持权限过滤和简单模式
└── 🐍 transcript.py            转录记录器：完整记录每轮对话的输入/输出/工具调用/权限决策，用于审计和回放
│
├── tests/                            # Python 测试文件
│   ├── test_porting_workspace.py    # 移植工作区测试
│   ├── test_security_scope.py       # 安全范围测试
│   ├── test_roadmap_helpers.py      # 路线图辅助函数测试
│   └── test_pre_push_hook_contract.py # 预推送钩子契约测试
│
├── docs/                             # 文档（25 个文件）
│   ├── USAGE.md                     # 主要使用文档
│   ├── container.md                 # 容器工作流
│   ├── windows-install-release.md    # Windows 安装
│   ├── MODEL_COMPATIBILITY.md      # 模型兼容性
│   ├── local-openai-compatible-providers.md # 本地提供商
│   ├── navigation-file-context.md    # 导航和文件上下文
│   ├── rag-web-ui.md                # RAG Web UI
│   ├── roadmap-pr-goals.md          # 路线图目标
│   ├── g004-events-reports-contract.md # 事件报告契约
│   └── ... (更多文档)
│
├── scripts/                          # 辅助脚本（根目录）
│   ├── fmt.sh                       # 代码格式化
│   └── ...
│
├── docker-compose.yml                # RAG 服务部署配置
├── Containerfile                     # 容器构建文件
├── .claude.json                     # Claude 配置
├── .claw.json                      # Claw 配置
├── prd.json                         # 产品需求文档
├── progress.txt                     # 开发进度
├── README.md                        # 项目说明
├── CLAUDE.md                        # Claude 特定配置
├── PHILOSOPHY.md                   # 项目哲学
├── CONTRIBUTING.md                  # 贡献指南
├── SECURITY.md                     # 安全策略
├── SUPPORT.md                      # 支持信息
├── CODE_OF_CONDUCT.md               # 行为准则
├── LICENSE                          # MIT 许可证
└── .github/
    └── workflows/
        ├── release.yml              # 多平台发布
        ├── rust-ci.yml              # Rust CI
        └── rust.yml                # Rust 测试

3.1.1 rust/ 目录统计

项目 数据
Crate 数量 11 个
Rust 源文件 ~101 个 .rs 文件
代码总行数 ~48,600 行（不含测试）
测试代码 ~2,568 行
最大模块 runtime（49 个文件，~5,300 行）
入口二进制 rusty-claude-cli（~3,600 行）

3.1.2 src/ 目录统计

项目 数据
Python 文件 68 个 .py 文件
子系统占位包 27 个（每个含 __init__.py）
参考数据 32 个 JSON + 1 个 .py（命令/工具快照）
核心入口 main.py（20+ 子命令）
最复杂模块 query_engine.py（会话循环核心）
对标命令 207 条（从 commands_snapshot.json）
对标工具 184 条（从 tools_snapshot.json）
定位 TypeScript→Python 1:1 移植镜像工作区

3.2 核心模块职责详解

3.2.1 rusty-claude-cli（CLI 入口）

位置 : rust/crates/rusty-claude-cli/src/

核心文件:

  • main.rs (620 行) - CLI 入口点

职责:

  1. 解析 CLI（Command Line Interface，命令行界面） 参数（--model, --permission-mode, -w 等）
  2. 加载多层配置（全局 → 项目 → 本地）
  3. 检测 AI 提供商（根据模型名自动路由）
  4. 加载 CLAUDE.md（项目指令文件）
  5. 构建系统提示词（SystemPromptBuilder）
  6. 初始化会话（新会话或恢复旧会话）
  7. 进入 REPL（Read-Eval-Print Loop，交互式循环） 对话循环

关键数据结构:

rust 复制代码 
/// 模型来源追踪
struct ModelProvenance {
    resolved: String,      // 解析后的模型字符串
    raw: Option<String>,   // 原始用户输入
    source: ModelSource,   // 来源（Flag/Env/Config/Default）
}

/// 模型来源枚举
enum ModelSource {
    Flag,    // --model 命令行标志
    Env,     // 环境变量
    Config,  // 配置文件
    Default, // 编译时默认值
}
3.2.2 api（AI API 提供商客户端）

位置 : rust/crates/api/src/

目录结构:

复制代码 
api/src/
├── lib.rs               (1.82 KB) - 模块导出
├── client.rs            (8.23 KB) - ProviderClient 实现
├── error.rs             (22.86 KB) - ApiError 定义
├── http_client.rs       (10.82 KB) - HTTP 客户端构建
├── prompt_cache.rs      (23.59 KB) - Prompt 缓存管理
├── sse.rs              (10.49 KB) - SSE 解析器
├── types.rs             (10.34 KB) - API 类型定义
└── providers/
    ├── mod.rs          (62.64 KB) - Provider 模块
    ├── anthropic.rs    (58.84 KB) - Anthropic 客户端
    └── openai_compat.rs (待探索) - OpenAI 兼容客户端

职责:

  • 提供统一的 API 客户端接口
  • 支持多个 AI 提供商（Anthropic、OpenAI、xAI、DashScope）
  • 处理 SSE（Server-Sent Events，服务器推送事件） 流式响应
  • 管理 Prompt 缓存（减少 token 消耗）

关键 trait:

rust 复制代码 
/// API 客户端 trait
pub trait ApiClient {
    /// 发送请求并获取流式响应
    fn stream(&mut self, request: ApiRequest) -> Result<Vec<AssistantEvent>, RuntimeError>;
}

/// 支持的提供商枚举
pub enum ProviderKind {
    Anthropic,  // Claude 系列
    Xai,        // Grok 系列
    OpenAi,     // GPT 系列 + 兼容接口
}

模型注册表:

rust 复制代码 
/// 模型注册表（部分）
const MODEL_REGISTRY: &[(&str, ProviderMetadata)] = &[
    ("opus", ProviderMetadata { provider: ProviderKind::Anthropic, ... }),
    ("sonnet", ProviderMetadata { provider: ProviderKind::Anthropic, ... }),
    ("haiku", ProviderMetadata { provider: ProviderKind::Anthropic, ... }),
    ("grok", ProviderMetadata { provider: ProviderKind::Xai, ... }),
    ("kimi", ProviderMetadata { provider: ProviderKind::OpenAi, ... }),
];
3.2.3 runtime（核心运行时）

位置 : rust/crates/runtime/src/

核心文件 (47+ 源文件):

文件 大小 职责
lib.rs 8.8 KB 公共 API 导出
conversation.rs 62.49 KB 对话运行时（核心！）
session.rs 65.1 KB 会话管理
permissions.rs 22.61 KB 权限系统
config.rs 77.98 KB 配置加载
hooks.rs 32.63 KB Hook 运行器
file_ops.rs 35.21 KB 文件操作
prompt.rs 36.93 KB 提示词构建
mcp_stdio.rs 106.38 KB MCP（Model Context Protocol，模型上下文协议） Stdio 通信
worker_boot.rs 86.53 KB Worker 启动
lane_events.rs 83.06 KB Lane 事件系统
permission_enforcer.rs 18.73 KB 权限强制执行
policy_engine.rs 27.46 KB 策略引擎
mcp_tool_bridge.rs 30.29 KB MCP 工具桥接
compact.rs 30.02 KB 会话压缩
recovery_recipes.rs 32 KB 恢复策略
bash.rs 15.81 KB Bash 命令执行
bash_validation.rs 28.15 KB Bash 命令验证
sandbox.rs 12.28 KB 沙箱隔离

职责:

  • 管理对话循环（REPL（Read-Eval-Print Loop，交互式循环））
  • 管理会话状态和持久化
  • 执行工具调用（Bash、文件操作、搜索等）
  • 权限检查和强制执行
  • MCP（Model Context Protocol，模型上下文协议） 客户端和服务器管理
  • 事件系统和 Hook 系统

核心 trait 和结构体:

rust 复制代码 
/// 对话运行时结构体
pub struct ConversationRuntime<C, T> {
    session: Session,
    api_client: C,
    tool_executor: T,
    permission_policy: PermissionPolicy,
    system_prompt: Vec<String>,
    max_iterations: usize,
    usage_tracker: UsageTracker,
    hook_runner: HookRunner,
    auto_compaction_input_tokens_threshold: u32,
    hook_abort_signal: HookAbortSignal,
    hook_progress_reporter: Option<Box<dyn HookProgressReporter>>,
    session_tracer: Option<SessionTracer>,
}

impl<C, T> ConversationRuntime<C, T>
where
    C: ApiClient,
    T: ToolExecutor,
{
    /// 对话循环主函数
    pub fn run_turn(
        &mut self,
        user_input: impl Into<String>,
        prompter: Option<&mut dyn PermissionPrompter>,
    ) -> Result<TurnSummary, RuntimeError> {
        // 1. 记录回合开始
        // 2. 将用户输入推入会话
        // 3. 循环：
        //    a. 构建 API 请求
        //    b. 调用 API 获取事件流
        //    c. 构建 assistant 消息
        //    d. 检查是否有待处理的工具调用
        //    e. 如果有工具调用：
        //       - 运行 pre-tool-use hook
        //       - 检查权限
        //       - 执行工具
        //       - 运行 post-tool-use hook
        //       - 将工具结果推入会话
        //    f. 如果没有工具调用，退出循环
        // 4. 返回 TurnSummary
    }
}
3.2.4 tools（内置工具执行）

位置 : rust/crates/tools/src/

核心文件:

  • lib.rs (~376 KB) - 所有内置工具的定义和注册

职责:

  • 注册所有内置工具（Bash、文件操作、搜索等）
  • 提供工具执行入口
  • 管理工具权限

关键数据结构:

rust 复制代码 
/// 工具规格
pub struct ToolSpec {
    pub name: &'static str,
    pub description: &'static str,
    pub input_schema: Value,
    pub required_permission: PermissionMode,
}

/// 全局工具注册表
pub struct GlobalToolRegistry {
    plugin_tools: Vec<PluginTool>,
    runtime_tools: Vec<RuntimeToolDefinition>,
    enforcer: Option<PermissionEnforcer>,
}

/// 运行时工具定义
pub struct RuntimeToolDefinition {
    pub name: String,
    pub description: Option<String>,
    pub input_schema: Value,
    pub required_permission: PermissionMode,
}

内置工具列表:

工具名 权限模式 描述
Bash DangerFullAccess 执行 shell 命令
read_file ReadOnly 读取文件
write_file WorkspaceWrite 写入文件
edit_file WorkspaceWrite 编辑文件
grep_search ReadOnly 正则搜索
glob_search ReadOnly 文件名模式匹配
web_search ReadOnly 网络搜索
web_fetch ReadOnly 抓取网页内容
Agent / Task WorkspaceWrite 启动子代理
TodoWrite ReadOnly 管理任务列表
Skill ReadOnly 加载领域技能包

工具执行入口:

rust 复制代码 
/// 工具执行入口函数
pub fn execute_tool(tool_name: &str, input: &str) -> Result<String, ToolError> {
    // 1. 标准化工具名称
    // 2. 查找工具定义
    // 3. 检查权限
    // 4. 执行工具
    // 5. 返回结果
}
3.2.5 plugins（插件系统）

位置 : rust/crates/plugins/src/

核心文件:

  • lib.rs (128.1 KB) - 插件管理
  • hooks.rs (17.36 KB) - Hook 系统

职责:

  • 插件的发现和加载
  • 插件生命周期管理
  • Hook 系统（工具执行前后插入自定义逻辑）

关键 trait:

rust 复制代码 
/// 插件 Hook trait
pub trait PluginHooks {
    /// 工具执行前调用
    fn pre_tool_use(&self, tool_name: &str, input: &str) -> HookRunResult {
        // 可以修改输入、拒绝执行、或允许执行
    }
    
    /// 工具执行后调用
    fn post_tool_use(&self, tool_name: &str, input: &str, output: &str, is_error: bool) -> HookRunResult {
        // 可以修改输出、记录日志、或触发通知
    }
}

/// 插件管理器
pub struct PluginManager {
    plugins: Vec<Box<dyn PluginHooks>>,
    config: PluginManagerConfig,
}

/// 插件注册表
pub struct PluginRegistry {
    // 插件注册表
}
3.2.6 claw-rag-service（RAG 服务）

位置 : rust/crates/claw-rag-service/src/

目录结构:

复制代码 
claw-rag-service/src/
├── lib.rs               (2.95 KB)
├── main.rs              (4.72 KB)
├── chunk.rs             (1.04 KB) - 文本分块
├── db.rs                (6.05 KB) - SQLite 数据库
├── embed.rs             (3.71 KB) - 嵌入向量
├── ingest.rs            (6.77 KB) - 文档摄取
├── qdrant_index.rs     (5.22 KB) - Qdrant 向量索引
└── search.rs            (2.26 KB) - 搜索接口

职责:

  • 提供 RAG（Retrieval-Augmented Generation，检索增强生成） 服务
  • 代码语义搜索（使用向量嵌入）
  • 支持 Qdrant 向量数据库（可选）

工作流程:

复制代码 
用户提问
    ↓
claw 发送搜索请求到 RAG 服务
    ↓
RAG 服务将问题转换为向量
    ↓
在 Qdrant 中搜索相似代码
    ↓
返回相关代码片段
    ↓
claw 将代码片段发给 AI
    ↓
AI 生成答案
3.2.7 telemetry（遥测与追踪）

位置 : rust/crates/telemetry/src/

职责:

  • 收集运行时指标
  • 追踪 API 调用和工具执行
  • 性能分析和调试
3.2.8 commands（命令注册与处理）

位置 : rust/crates/commands/src/

核心文件:

  • lib.rs (219.97 KB) - Slash 命令实现

职责:

  • 注册所有 斜杠命令 （如 /ultraplan、/teleport、/bughunter）
  • 处理命令逻辑
3.2.9 claw-analog（轻量级代理工具）

位置 : rust/crates/claw-analog/src/

核心文件:

  • lib.rs (101.33 KB) - 核心库
  • main.rs (15.32 KB) - CLI 入口
  • agents.rs (16.23 KB) - Agent 管理
  • doctor.rs (24.18 KB) - 诊断工具

职责:

  • 提供轻量级的 Agent 工具链
  • Agent 管理和诊断
3.2.10 mock-anthropic-service（Anthropic API 模拟服务）

位置 : rust/crates/mock-anthropic-service/src/

核心文件:

  • lib.rs (37.29 KB) - 模拟服务实现

职责:

  • 模拟 Anthropic API，用于测试
  • 支持离线开发和测试
3.2.11 compat-harness（兼容性工具）

位置 : rust/crates/compat-harness/src/

核心文件:

  • lib.rs (10.88 KB) - TypeScript 清单提取

职责:

  • 从 TypeScript 版本提取命令和工具清单
  • 用于一致性审计

4. 模块调用关系与数据流向

4.1 主流程：一次对话的完整生命周期

复制代码 
┌─────────────────────────────────────────────────────────────────────┐
│                        用户输入提示词                              │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    CLI 参数解析 (main.rs)                         │
│  - 解析 --model, --permission-mode 等参数                        │
│  - 加载配置文件 (.claw.json, .claude.json)                     │
│  - 检测 AI 提供商 (根据模型名自动路由)                          │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    构建系统提示词 (prompt.rs)                      │
│  - 读取 CLAUDE.md                                                │
│  - 发现指令文件 (CLAUDE.md, .claw/instructions/*.md)           │
│  - 获取 Git 上下文                                               │
│  - 构建 ProjectContext                                           │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│             初始化 ConversationRuntime (conversation.rs)            │
│  - 创建 Session                                                 │
│  - 创建 ApiClient (根据 ProviderKind 选择)                      │
│  - 创建 ToolExecutor (GlobalToolRegistry)                        │
│  - 设置 PermissionPolicy                                         │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│                  run_turn() - 对话循环                            │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 1. 将用户输入添加到会话历史                                 │  │
│  └───────────────────────┬─────────────────────────────────┘  │
│                          │                                     │
│                          ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 2. 构建 ApiRequest                                          │  │
│  │    - system_prompt: Vec<String>                             │  │
│  │    - messages: Vec<ConversationMessage>                     │  │
│  └───────────────────────┬─────────────────────────────────┘  │
│                          │                                     │
│                          ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 3. 调用 ApiClient.stream(request)                          │  │
│  │    - 发送 HTTP POST 到 AI API                             │  │
│  │    - 解析 SSE 事件流                                      │  │
│  │    - 返回 Vec<AssistantEvent>                             │  │
│  └───────────────────────┬─────────────────────────────────┘  │
│                          │                                     │
│                          ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 4. 构建 Assistant 消息                                     │  │
│  │    - 文本增量 (TextDelta)                                  │  │
│  │    - 思考过程 (Thinking)                                   │  │
│  │    - 工具调用 (ToolUse)                                    │  │
│  └───────────────────────┬─────────────────────────────────┘  │
│                          │                                     │
│                          ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 5. 检查是否有工具调用                                      │  │
│  │    - 如果没有 → 结束回合，返回 TurnSummary                 │  │
│  │    - 如果有 → 继续                                         │  │
│  └───────────────────────┬─────────────────────────────────┘  │
│                          │                                     │
│                          ▼                                     │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 6. 执行工具调用 (循环处理每个工具)                         │  │
│  │                                                          │  │
│  │    ┌─────────────────────────────────────────────────────┐  │  │
│  │    │ a. 运行 PreToolUse Hook                            │  │  │
│  │    └───────────────────────┬─────────────────────────┘  │  │
│  │                            │                             │  │  │
│  │                            ▼                             │  │  │
│  │    ┌─────────────────────────────────────────────────────┐  │  │
│  │    │ b. 检查权限 (PermissionEnforcer)                 │  │  │
│  │    │    - default: 首次使用工具时询问用户              │  │  │
│  │    │    - acceptEdits: 自动接受文件编辑                │  │  │
│  │    │    - bypassPermissions: 跳过所有确认               │  │  │
│  │    │    - plan: 只允许只读操作                         │  │  │
│  │    └───────────────────────┬─────────────────────────┘  │  │
│  │                            │                             │  │  │
│  │                            ▼                             │  │  │
│  │    ┌─────────────────────────────────────────────────────┐  │  │
│  │    │ c. 执行工具 (ToolExecutor.execute)                │  │  │
│  │    │    - Bash: 执行 shell 命令 (bash.rs)             │  │  │
│  │    │    - ReadFile: 读取文件 (file_ops.rs)            │  │  │
│  │    │    - WriteFile: 写入文件 (file_ops.rs)           │  │  │
│  │    │    - EditFile: 编辑文件 (file_ops.rs)            │  │  │
│  │    │    - GrepSearch: 正则搜索 (file_ops.rs)          │  │  │
│  │    │    - GlobSearch: 文件名匹配 (file_ops.rs)        │  │  │
│  │    └───────────────────────┬─────────────────────────┘  │  │
│  │                            │                             │  │  │
│  │                            ▼                             │  │  │
│  │    ┌─────────────────────────────────────────────────────┐  │  │
│  │    │ d. 运行 PostToolUse Hook                          │  │  │
│  │    └───────────────────────┬─────────────────────────┘  │  │
│  │                            │                             │  │  │
│  │                            ▼                             │  │  │
│  │    ┌─────────────────────────────────────────────────────┐  │  │
│  │    │ e. 将工具结果添加到会话历史                       │  │  │
│  │    └───────────────────────┬─────────────────────────┘  │  │
│  │                            │                             │  │  │
│  │                            ▼                             │  │  │
│  │    ┌─────────────────────────────────────────────────────┐  │  │
│  │    │ f. 检查是否需要自动压缩会话                       │  │  │
│  │    │    - 如果 token 数超过阈值 → 压缩历史消息        │  │  │
│  │    └───────────────────────┬─────────────────────────┘  │  │
│  │                            │                             │  │  │
│  │                            └─────────────────────────────▶  │  │
│  │                              回到步骤 2，继续下一轮迭代  │  │
│  └─────────────────────────────────────────────────────────────┘  │
│                                                                 │
│  ┌─────────────────────────────────────────────────────────────┐  │
│  │ 7. 返回 TurnSummary                                        │  │
│  │    - assistant_messages: Vec<ConversationMessage>           │  │
│  │    - tool_results: Vec<ConversationMessage>               │  │
│  │    - usage: TokenUsage                                    │  │
│  │    - iterations: usize                                    │  │
│  └─────────────────────────────────────────────────────────────┘  │
│                                                                 │
└─────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    渲染结果给用户                                 │
│  - 打印 assistant 文本                                          │
│  - 显示工具执行结果                                             │
│  - 显示 token 使用统计                                          │
└─────────────────────────────────────────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│                    保存会话到磁盘                                 │
│  - 路径: ~/.claw/sessions/<session_id>.jsonl                   │
│  - 格式: JSONL (每行一个 JSON 对象)                            │
└─────────────────────────────────────────────────────────────────────┘

4.2 工具执行详细流程（以 Bash 工具为例）

复制代码 
用户要求 AI 执行 shell 命令
                │
                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ AI 返回 ToolUse 事件:                                           │
│ {                                                                 │
│   "id": "toolu_abc123",                                          │
│   "name": "Bash",                                                │
│   "input": "{\"command\": \"ls -la\"}"                           │
│ }                                                                 │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ **权限检查** (permission_enforcer.rs)                            │
│  - 检查 PermissionMode                                           │
│  - 如果在沙箱中，检查沙箱状态                                    │
│  - 如果命令危险，拒绝执行                                        │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ **命令验证** (bash_validation.rs)                                │
│  - 解析命令                                                     │
│  - 检查危险操作 (rm -rf /, curl | sh)                          │
│  - 检查路径限制 (是否访问工作区外的路径)                        │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ **执行命令** (bash.rs)                                          │
│  - 如果不 in 沙箱，检查是否在容器中                              │
│  - 执行命令                                                     │
│  - 捕获 stdout, stderr, exit code                                │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ **返回结果**                                                     │
│ {                                                                 │
│   "tool_use_id": "toolu_abc123",                                │
│   "output": "...",                                               │
│   "is_error": false                                               │
│ }                                                                 │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ **将结果添加到会话历史**                                         │
│   session.push_message(ConversationMessage {                      │
│       role: Tool,                                                │
│       blocks: [ContentBlock::ToolResult { ... }],                │
│   })                                                             │
└───────────────────────────────┬─────────────────────────────────┘
                                │
                                ▼
┌─────────────────────────────────────────────────────────────────────┐
│ **将工具结果发给 AI**                                            │
│   - 构建新的 ApiRequest                                          │
│   - messages 包含：                                              │
│     * 原始用户消息                                               │
│     * AI 的 ToolUse 请求                                         │
│     * 工具的 ToolResult 响应                                      │
│   - 调用 ApiClient.stream(request)                                │
│   - AI 根据工具结果继续思考或返回最终答案                       │
└─────────────────────────────────────────────────────────────────────┘

4.3 MCP 协议工作流程

复制代码 
┌─────────────────────────────────────────────────────────────────────┐
│                    MCP 协议集成架构                               │
├─────────────────────────────────────────────────────────────────────┤
│                                                                   │
│  claw (主程序)                                                    │
│    │                                                              │
│    │ 使用工具                                                     │
│    ▼                                                              │
│  MCP Client (mcp_stdio.rs)                                       │
│    │                                                              │
│    │ JSON-RPC 通过 stdin/stdout                                   │
│    ▼                                                              │
│  MCP Server (第三方工具服务器)                                    │
│    │                                                              │
│    │ 例如：                                                       │
│    │ - sqlite: 数据库查询                                         │
│    │ - brave-search: 网页搜索                                     │
│    │ - github: GitHub API 操作                                    │
│                                                                   │
└─────────────────────────────────────────────────────────────────────┘

MCP 工作流程:

  1. 启动 MCP 服务器 : mcp_stdio.rs 启动 MCP 服务器进程
  2. 发现工具: 查询 MCP 服务器支持的工具列表
  3. 注册工具 : 将 MCP 工具注册到 GlobalToolRegistry
  4. 工具调用 : AI 调用 MCP 工具时，mcp_tool_bridge.rs 转发请求
  5. 返回结果: MCP 服务器执行工具，返回结果给 claw

4.4 事件系统（Lane Events）状态转换

复制代码 
┌─────────────────────────────────────────────────────────────────────┐
│                    Lane 事件系统状态机                            │
├─────────────────────────────────────────────────────────────────────┤
│                                                                   │
│  ┌─────────┐                                                    │
│  │ 启动     │                                                    │
│  └────┬────┘                                                    │
│       │                                                          │
│       ▼                                                          │
│  ┌─────────┐                                                    │
│  │ 就绪     │◀────────────────────────────────────────────┐       │
│  └────┬────┘                                             │       │
│       │                                                  │       │
│       ▼                                                  │       │
│  ┌─────────┐     ┌─────────┐     ┌─────────┐           │       │
│  │ 执行中   │────▶│  阻塞   │────▶│  恢复   │───────────┘       │
│  └────┬────┘     └─────────┘     └─────────┘                   │
│       │                                                          │
│       └───────────────────┬──────────────────┐                  │
│                           │                  │                  │
│                           ▼                  ▼                  │
│                      ┌─────────┐        ┌─────────┐           │
│                      │ 完成     │        │ 失败     │           │
│                      └─────────┘        └─────────┘           │
│                                                                   │
└─────────────────────────────────────────────────────────────────────┘

事件类型:

  • 启动: Agent 开始执行
  • 就绪: Agent 准备好接受新任务
  • 执行中: Agent 正在执行工具
  • 阻塞: Agent 等待外部输入（如用户确认）
  • 恢复: Agent 从阻塞状态恢复
  • 完成: Agent 成功完成任务
  • 失败: Agent 执行失败

5. 关键数据结构与函数设计

5.1 会话管理（session.rs）

rust 复制代码 
/// 消息角色
pub enum MessageRole {
    System,
    User,
    Assistant,
    Tool,
}

/// 内容块
pub enum ContentBlock {
    Text { text: String },
    Thinking { thinking: String, signature: Option<String> },
    ToolUse { id: String, name: String, input: String },
    ToolResult { tool_use_id: String, tool_name: String, output: String, is_error: bool },
}

/// 会话结构体
pub struct Session {
    pub version: u32,
    pub session_id: String,
    pub created_at_ms: u64,
    pub updated_at_ms: u64,
    pub messages: Vec<ConversationMessage>,
    pub compaction: Option<SessionCompaction>,
    pub fork: Option<SessionFork>,
    pub workspace_root: Option<PathBuf>,
    pub prompt_history: Vec<SessionPromptEntry>,
    pub last_health_check_ms: Option<u64>,
    pub model: Option<String>,
    // ...
}

会话持久化:

  • 路径: ~/.claw/sessions/<session_id>.jsonl
  • 格式: JSONL（JSON Lines，JSON 行格式）（每行一个 JSON 对象）

5.2 提示词构建（prompt.rs）

rust 复制代码 
/// 系统提示词构建器
pub struct SystemPromptBuilder {
    // ...
}

impl SystemPromptBuilder {
    /// 构建系统提示词
    pub fn build(&self, context: &ProjectContext) -> Vec<String> {
        // 构建系统提示词，包含：
        // 1. 静态提示词脚手架
        // 2. 项目上下文（CWD, 日期, Git 状态）
        // 3. 指令文件内容
        // 4. 动态边界标记
    }
}

/// 项目上下文
pub struct ProjectContext {
    pub cwd: PathBuf,
    pub current_date: String,
    pub git_status: Option<String>,
    pub git_diff: Option<String>,
    pub git_context: Option<GitContext>,
    pub instruction_files: Vec<ContextFile>,
}

5.3 权限系统（permissions.rs）

rust 复制代码 
/// 权限模式
pub enum PermissionMode {
    ReadOnly,           // 只读模式
    WorkspaceWrite,     // 工作区写入
    DangerFullAccess,   // 危险完全访问
    Prompt,             // 提示模式
    Allow,              // 允许所有
}

/// 权限规则
pub struct PermissionRule {
    pub pattern: String,
    pub mode: PermissionMode,
}

/// 权限检查器
pub struct PermissionEnforcer {
    rules: Vec<PermissionRule>,
    mode: PermissionMode,
}

权限检查流程:

复制代码 
1. 检查 denied_tools (无条件拒绝列表)
   ↓
2. 检查 deny 规则 (模式匹配拒绝)
   ↓
3. 检查 hook override (钩子覆盖决策)
   - Deny → 拒绝
   - Ask → 需要提示
   - Allow → 继续检查
   ↓
4. 检查 ask 规则 (需要确认的规则)
   ↓
5. 检查 allow 规则和当前权限模式
   ↓
6. 根据当前模式决定

5.4 配置加载（config.rs）

rust 复制代码 
/// 运行时配置
pub struct RuntimeConfig {
    merged: BTreeMap<String, JsonValue>,           // 合并后的配置
    loaded_entries: Vec<ConfigEntry>,              // 加载的配置文件列表
    feature_config: RuntimeFeatureConfig           // 解析后的功能配置
}

/// 功能配置
pub struct RuntimeFeatureConfig {
    hooks: RuntimeHookConfig,                    // Hook配置
    plugins: RuntimePluginConfig,                 // 插件配置
    mcp: McpConfigCollection,                   // MCP服务器配置
    oauth: Option<OAuthConfig>,                 // OAuth配置
    model: Option<String>,                       // 模型配置
    aliases: BTreeMap<String, String>,          // 模型别名
    permission_mode: Option<ResolvedPermissionMode>,
    permission_rules: RuntimePermissionRuleConfig,
    sandbox: SandboxConfig,                      // 沙箱配置
    provider_fallbacks: ProviderFallbackConfig,  // 提供商回退链
    trusted_roots: Vec<String>,                  // 可信根目录
}

配置加载优先级（从低到高）:

复制代码 
1. 用户级遗留配置 (~/.claw.json)
   ConfigSource::User (最低优先级)
   
2. 用户级配置 (~/.claw/settings.json)
   ConfigSource::User
   
3. 项目级遗留配置 (<cwd>/.claw.json)
   ConfigSource::Project
   
4. 项目级配置 (<cwd>/.claw/settings.json)
   ConfigSource::Project
   
5. 本地配置 (<cwd>/.claw/settings.local.json)
   ConfigSource::Local (最高优先级)

配置合并策略:

  • 嵌套对象: 递归合并子字段
  • 数组: 后面配置的数组会完全覆盖前面的
  • Hooks : 使用 extend_unique 合并，保持唯一性

6. 配置与扩展机制

6.1 配置文件格式

6.1.1 .claw.json（项目级配置）
json 复制代码 
{
  "aliases": {
    "quick": "haiku"
  },
  "model": "opus",
  "permissionMode": "default",
  "allowedTools": ["read_file", "grep_search"],
  "plugins": {
    "maxOutputTokens": 12345
  }
}

字段解释:

  • aliases: 命令别名映射
  • model: 默认模型
  • permissionMode: 权限模式（default, acceptEdits, bypassPermissions, plan）
  • allowedTools: 允许的工具列表
  • plugins: 插件配置
6.1.2 .claude.json（Claude 配置）
json 复制代码 
{
  "permissions": {
    "defaultMode": "dontAsk"
  }
}

字段解释:

  • permissions.defaultMode: 权限默认模式
6.1.3 .claw/settings.json（项目设置）
json 复制代码 
{
  "permissions": {
    "allow": ["Bash", "read_file"],
    "deny": ["write_file"]
  },
  "env": {
    "ANTHROPIC_API_KEY": "sk-ant-..."
  }
}

字段解释:

  • permissions.allow: 允许的工具
  • permissions.deny: 拒绝的工具
  • env: 环境变量
6.1.4 MCP 配置 (.claw/mcp.json)
json 复制代码 
{
  "mcpServers": {
    "sqlite": {
      "command": "mcp-server-sqlite",
      "args": ["--db", "./data.db"]
    },
    "brave-search": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-brave-search"]
    }
  }
}

字段解释:

  • mcpServers: MCP 服务器配置
  • command: 启动命令
  • args: 命令参数

6.2 插件机制

6.2.1 插件发现
  • 插件存储在 .claw/plugins/ 目录
  • 每个插件是一个独立的 WASM（WebAssembly，网页汇编） 模块或 native 动态库
  • PluginManager 在启动时扫描并加载插件
6.2.2 插件钩子（Hooks）
rust 复制代码 
/// 插件 Hook trait
pub trait PluginHooks {
    /// 工具执行前调用
    /// 可以修改输入、拒绝执行、或允许执行
    fn pre_tool_use(&self, tool_name: &str, input: &str) -> HookRunResult {
        // 返回值：
        // - HookRunResult::Allow → 允许执行
        // - HookRunResult::Deny → 拒绝执行
        // - HookRunResult::Modify(input) → 修改输入后执行
    }
    
    /// 工具执行后调用
    /// 可以修改输出、记录日志、或触发通知
    fn post_tool_use(&self, tool_name: &str, input: &str, output: &str, is_error: bool) -> HookRunResult {
        // 返回值：
        // - HookRunResult::Allow → 允许输出
        // - HookRunResult::Deny → 拒绝输出
        // - HookRunResult::Modify(output) → 修改输出
    }
}
6.2.3 内置 Hook 类型
Hook 类型 说明
PreToolUse 工具执行前调用
PostToolUse 工具执行后调用
PreSession 会话开始前调用
PostSession 会话结束后调用

6.3 MCP 扩展点

6.3.1 MCP 协议简介

MCP（Model Context Protocol，模型上下文协议） 是 Anthropic 提出的标准协议，允许 AI 连接外部工具服务器。

核心概念:

  • MCP Client: 运行在 claw 中，负责与 MCP Server 通信
  • MCP Server: 独立的进程，提供工具给 AI 使用
  • 通信方式 : JSON-RPC 通过 stdin/stdout
6.3.2 MCP 工具桥接
  • mcp_tool_bridge.rs 将 MCP 服务器提供的工具桥接到 claw 的工具系统
  • MCP 工具看起来和内置工具一样，AI 可以无缝调用
6.3.3 MCP 配置示例
json 复制代码 
{
  "mcpServers": {
    "sqlite": {
      "command": "mcp-server-sqlite",
      "args": ["--db", "./data.db"]
    }
  }
}

工作流程:

  1. claw 启动 MCP Server 进程
  2. 查询 MCP Server 支持的工具
  3. 将工具注册到 claw 的工具系统
  4. AI 调用工具时，claw 通过 JSON-RPC 发送给 MCP Server
  5. MCP Server 执行工具，返回结果

7. Python 辅助代码分析

7.1 定位

src/ 目录包含 68 个 Python 文件 ，是 TypeScript 版本 Claude Code 的移植工作区。

用途:

  • 作为 TypeScript → Python/Rust 的移植参考层
  • 提供功能镜像（命令和工具快照）
  • 用于一致性审计（Parity Audit）

7.2 核心文件

7.2.1 main.py - CLI 入口
python 复制代码 
def build_parser() -> argparse.ArgumentParser:
    parser = argparse.ArgumentParser(description='Python porting workspace for the Claude Code rewrite effort')
    subparsers = parser.add_subparsers(dest='command', required=True)
    
    # 子命令
    subparsers.add_parser('summary', help='render a Markdown summary of the Python porting workspace')
    subparsers.add_parser('manifest', help='print the current Python workspace manifest')
    subparsers.add_parser('parity-audit', help='compare the Python workspace against the local ignored TypeScript archive')
    # ... 更多子命令

子命令:

  • summary: 渲染 Python 移植工作区的 Markdown 摘要
  • manifest: 打印当前 Python 工作区清单
  • parity-audit: 对比 Python 工作区和本地忽略的 TypeScript 存档
  • setup-report: 生成设置报告
  • route: 路由命令
  • turn-loop: 运行对话循环
7.2.2 query_engine.py - 查询引擎

职责:

  • 模拟 AI 查询引擎
  • 管理会话状态、消息历史、token 预算
  • 处理流式输出

关键类:

python 复制代码 
class QueryEnginePort:
    def __init__(self):
        self.sessions = {}
        self.message_history = []
        self.token_budget = 100000
    
    def submit_message(self, message: str) -> str:
        # 提交消息到会话
        pass
    
    def stream_response(self) -> Iterator[str]:
        # 流式返回 AI 响应
        pass
7.2.3 runtime.py - 运行时模拟

职责:

  • 处理提示路由
  • 会话引导
  • turn 循环

关键类:

python 复制代码 
class PortRuntime:
    def __init__(self):
        self.session = None
        self.context = {}
    
    def bootstrap_session(self, initial_prompt: str):
        # 引导会话
        pass
    
    def run_turn(self, user_input: str) -> TurnSummary:
        # 运行一轮对话
        pass
7.2.4 tools.py / commands.py - 工具/命令镜像

职责:

  • 从 reference_data/tools_snapshot.json / commands_snapshot.json 加载镜像工具/命令条目
  • 提供工具/命令查找、过滤和执行功能

关键函数:

python 复制代码 
def load_tools_snapshot() -> List[ToolSpec]:
    # 从 tools_snapshot.json 加载工具快照
    pass

def find_tool(tool_name: str) -> Optional[ToolSpec]:
    # 查找工具
    pass

def execute_tool(tool_name: str, input: str) -> str:
    # 执行工具（模拟）
    pass

7.3 核心设计思路：三层架构

复制代码 
┌─────────────────────────────────────────────────────────────────────┐
│                      src/ 三层架构                                  │
├─────────────────────────────────────────────────────────────────────┤
│                                                                   │
│  第 1 层：入口调度层                                              │
│  main.py → 20+ 子命令分发                                          │
│  (summary / manifest / parity-audit / route /                      │
│   bootstrap / turn-loop / remote-mode ...)                         │
│                                                                   │
├─────────────────────────────────────────────────────────────────────┤
│                                                                   │
│  第 2 层：核心运行时层                                            │
│  runtime.py (prompt 路由) → query_engine.py (会话循环)            │
│  → commands.py + tools.py (命令/工具执行)                          │
│  → permissions.py (权限拦截) → session_store.py (持久化)           │
│                                                                   │
├─────────────────────────────────────────────────────────────────────┤
│                                                                   │
│  第 3 层：27 个子系统包（按 TS 原档结构镜像）                     │
│  assistant / cli / hooks / plugins / skills /                      │
│  server / state / types / utils / vim / voice ...                  │
│                                                                   │
└─────────────────────────────────────────────────────────────────────┘

7.4 27 个子系统占位包

所有子系统包（assistant, bootstrap, bridge, buddy, cli, ...）都遵循相同的模式：

python 复制代码 
"""Python package placeholder for the archived `<subsystem>` subsystem."""
from src._archive_helper import load_archive_metadata

_SNAPSHOT = load_archive_metadata("<subsystem>")

ARCHIVE_NAME = _SNAPSHOT["archive_name"]
MODULE_COUNT = _SNAPSHOT["module_count"]
SAMPLE_FILES = tuple(_SNAPSHOT["sample_files"])
PORTING_NOTE = f"Python placeholder package for '{ARCHIVE_NAME}' with {MODULE_COUNT} archived module references."

__all__ = ["ARCHIVE_NAME", "MODULE_COUNT", "PORTING_NOTE", "SAMPLE_FILES"]

子系统包详细列表:

子系统包 作用描述 TS 原档对应
assistant/ AI 助手子系统：助手行为定义、响应策略、角色设定 assistant 层
bootstrap/ 启动引导子系统：初始化流程、环境检测、首轮会话引导逻辑 bootstrap 层
bridge/ 桥接子系统：Python↔Rust 跨语言调用接口、类型转换适配层（31 个模块） bridge 层
buddy/ 代码伙伴子系统：结对编程辅助、实时建议、代码审查规则 buddy 层
cli/ CLI 终端子系统：命令行参数解析、子命令路由、交互式输入处理 cli 层
components/ UI 组件子系统：终端界面渲染组件、Markdown 输出、交互式选择器 components 层
constants/ 常量定义子系统：全局魔法数字、配置默认值、枚举映射表 constants 层
coordinator/ 协调器子系统：多 Agent 任务调度、lane 状态管理、事件分发中枢 coordinator 层
entrypoints/ 入口点子系统：多启动模式分发（REPL/单次/远程/守护进程） entrypoints 层
hooks/ 钩子子系统：生命周期钩子注册、事件拦截、工具执行前后回调 hooks 层
keybindings/ 快捷键子系统：终端按键绑定定义、Vim 模式映射、组合键配置 keybindings 层
memdir/ 记忆目录子系统：持久化记忆存储、用户偏好记忆、项目上下文记忆 memdir 层
migrations/ 数据迁移子系统：版本升级时的数据格式迁移、配置兼容转换 migrations 层
moreright/ 权限扩展子系统：细粒度权限策略、审批链流程、安全策略注入 moreright 层
native_ts/ TypeScript 原生引用：保留的 TS 代码片段，用于行为对标验证 native 层
outputStyles/ 输出样式子系统：终端颜色主题、Markdown 渲染风格、代码高亮配色 outputStyles 层
plugins/ 插件子系统：Python 侧插件加载器、Hook 注册、扩展点管理 plugins 层
remote/ 远程通信子系统：远程 Agent 连接、消息序列化、网络传输协议 remote 层
schemas/ 数据模式子系统：JSON Schema 定义、请求/响应类型校验、配置校验 schemas 层
screens/ 屏幕管理子系统：终端分屏布局、多面板切换、视图状态管理 screens 层
server/ 服务端子系统：HTTP/WebSocket 服务、REST API 端点、流式响应 server 层
services/ 服务层子系统：业务逻辑封装、AI 提供商 API 适配、外部服务集成 services 层
skills/ 技能子系统：可插拔 AI 技能包定义、技能发现与加载、技能参数验证 skills 层
state/ 状态管理子系统：全局应用状态、会话状态机、Redux 风格状态流转 state 层
types/ 类型定义子系统：TypeScript 类型→Python TypedDict/dataclass 映射，核心数据结构 types 层
upstreamproxy/ 上游代理子系统：API 请求代理转发、多提供商负载均衡、认证透传 upstreamproxy 层
utils/ 工具函数子系统：通用辅助函数（字符串处理、文件操作、日期时间等，100+ 模块） utils 层
vim/ Vim 集成子系统：Vim/Neovim 编辑器嵌入、缓冲区同步、光标位置跟踪 vim 层
voice/ 语音交互子系统：语音输入识别、TTS 输出、语音命令解析 voice 层

7.5 与 Rust 实现的关系

Python 代码是 Claude Code 重写工作的移植层，具有以下特点：

  1. 镜像快照机制 : 通过 commands_snapshot.json（150+ 命令）和 tools_snapshot.json（100+ 工具）来镜像 TypeScript 原始实现的功能表面
  2. 对等审计（Parity Audit） : parity_audit.py 对比 Python 工作区和本地存档的 TypeScript 实现，确保移植完整性
  3. 运行时模拟 : runtime.py 和 query_engine.py 模拟 Rust/TypeScript 运行时的核心行为
  4. 参考数据结构 : reference_data/ 目录存储子系统元数据快照

8. 部署架构

8.1 RAG 服务部署（docker-compose.yml）

yaml 复制代码 
services:
  qdrant:              # 向量数据库
    image: qdrant/qdrant:latest
    ports:
      - "6333:6333"   # REST API
      - "6334:6334"   # gRPC
    volumes:
      - qdrant-storage:/qdrant/storage

  rag-serve:            # RAG 服务
    build:
      context: ./rust
      dockerfile: crates/claw-rag-service/Dockerfile
    command: ["serve", "--db", "/data/index.sqlite"]
    environment:
      CLAW_RAG_MOCK_PROVIDERS: "1"           # 使用 mock embeddings
      CLAW_RAG_QDRANT_URL: "http://qdrant:6334"
    ports:
      - "8787:8787"
    depends_on:
      - qdrant

  rag-ingest:           # RAG 摄入服务
    build:
      context: ./rust
      dockerfile: crates/claw-rag-service/Dockerfile
    command: ["ingest", "--db", "/data/index.sqlite"]
    volumes:
      - ./:/workspace/main:ro
    depends_on:
      - qdrant

服务说明:

服务名 镜像/构建 端口 说明
qdrant qdrant/qdrant:latest 6333, 6334 Qdrant 向量数据库
rag-serve 本地构建（claw-rag-service） 8787 RAG 服务（提供搜索接口）
rag-ingest 本地构建（claw-rag-service） - RAG 摄入服务（索引代码）

环境变量:

  • CLAW_RAG_MOCK_PROVIDERS: 使用 mock 嵌入向量（开发环境）
  • CLAW_RAG_QDRANT_URL: Qdrant 服务地址
  • CLAW_RAG_DB: SQLite 数据库路径
  • CLAW_RAG_QDRANT_COLLECTION: Qdrant 集合名称

8.2 容器构建（Containerfile）

复制代码 
FROM rust:1.91-bookworm
WORKDIR /app
COPY . .
RUN cargo build --workspace --release
EXPOSE 8787
CMD ["./target/release/claw-rag-service", "serve"]

构建说明:

  • 基础镜像: Rust on Debian Bookworm
  • 构建目标: 发布模式（--release）
  • 暴露端口: 8787（RAG 服务）
  • 启动命令: claw-rag-service serve

8.3 CI/CD 流程

GitHub Actions 工作流:

工作流文件 说明
.github/workflows/release.yml 多平台发布（Linux, macOS, Windows）
.github/workflows/rust-ci.yml Rust CI（cargo test, cargo clippy）
.github/workflows/rust.yml Rust 测试（cargo test --workspace）

CI 步骤:

  1. 代码格式化检查 : scripts/fmt.sh --check
  2. Lint 检查 : cargo clippy --workspace --all-targets -- -D warnings
  3. 单元测试 : cargo test --workspace
  4. 构建发布 : cargo build --workspace --release
  5. 上传二进制: 上传到 GitHub Releases

9. 附录：关键文件清单

源码地址：claude-code github

9.1 Rust 核心文件

文件路径 大小 说明
rust/crates/rusty-claude-cli/src/main.rs 620 行 CLI 入口
rust/crates/runtime/src/conversation.rs 62.49 KB 对话运行时
rust/crates/runtime/src/session.rs 65.1 KB 会话管理
rust/crates/runtime/src/config.rs 77.98 KB 配置加载
rust/crates/runtime/src/mcp_stdio.rs 106.38 KB MCP Stdio 通信
rust/crates/runtime/src/worker_boot.rs 86.53 KB Worker 启动
rust/crates/runtime/src/lane_events.rs 83.06 KB Lane 事件系统
rust/crates/tools/src/lib.rs ~376 KB 工具系统
rust/crates/api/src/providers/mod.rs 62.64 KB 提供商模块
rust/crates/api/src/providers/anthropic.rs 58.84 KB Anthropic 客户端

9.2 Python 辅助文件

文件路径 大小 说明
src/main.py 10.25 KB CLI 入口
src/query_engine.py 7.87 KB 查询引擎
src/runtime.py 9.01 KB 运行时模拟
src/tools.py 4.09 KB 镜像工具
src/commands.py 3.09 KB 镜像命令
src/permissions.py 2 KB 工具权限上下文
src/path_scope.py 5.76 KB 工作区路径范围验证
tests/test_porting_workspace.py 13.58 KB 移植工作区测试
tests/test_security_scope.py 6.11 KB 安全范围测试

9.3 配置文件

文件路径 说明
.claw.json Claw 配置（别名等）
.claude.json Claude 配置（权限等）
docker-compose.yml RAG 服务部署配置
rust/Cargo.toml Workspace 配置
rust/crates/*/Cargo.toml 各 crate 配置

9.4 文档文件

文件路径 大小 说明
README.md - 项目说明
USAGE.md 23.64 KB 主要使用文档
PHILOSOPHY.md - 项目哲学
CONTRIBUTING.md - 贡献指南
SECURITY.md - 安全策略
docs/windows-install-release.md 6.12 KB Windows 安装
docs/MODEL_COMPATIBILITY.md 9.39 KB 模型兼容性
docs/local-openai-compatible-providers.md 6.23 KB 本地提供商
docs/navigation-file-context.md 3.41 KB 导航和文件上下文
docs/rag-web-ui.md 5.8 KB RAG Web UI

10. 术语表

缩写 完整英文名称 中文解释
MCP Model Context Protocol 模型上下文协议，Anthropic 提出的标准协议，允许 AI 连接外部工具服务器
CI/CD Continuous Integration/Continuous Deployment 持续集成/持续部署，自动化代码测试和发布的流程
CLI Command Line Interface 命令行界面，通过终端输入命令与程序交互的方式
API Application Programming Interface 应用程序编程接口，程序之间通信的标准方式
SSE Server-Sent Events 服务器推送事件，服务器向客户端实时推送数据的技术
RAG Retrieval-Augmented Generation 检索增强生成，结合搜索和 AI 生成的技术
REST Representational State Transfer 表现层状态转移，一种 Web API 设计风格
gRPC - Google 开发的高性能远程过程调用框架
WASM WebAssembly 网页汇编，在浏览器中运行高性能代码的技术
AOP Aspect-Oriented Programming 面向切面编程，一种编程范式
JSONL JSON Lines JSON 行格式，每行一个独立 JSON 对象的文件格式
REPL Read-Eval-Print Loop 交互式循环，一种交互式编程环境
JSON-RPC JSON Remote Procedure Call JSON 远程过程调用，使用 JSON 格式的远程调用协议
HTTP HyperText Transfer Protocol 超文本传输协议，Web 通信的基础协议
POST - HTTP 方法之一，用于提交数据
GET - HTTP 方法之一，用于获取数据
stdin Standard Input 标准输入，程序接收输入的默认渠道
stdout Standard Output 标准输出，程序输出结果的默认渠道
stderr Standard Error 标准错误，程序输出错误信息的默认渠道
POSIX Portable Operating System Interface 可移植操作系统接口，一套操作系统标准
Windows - 微软开发的操作系统
Linux - 开源的类 Unix 操作系统
macOS - 苹果公司的操作系统
Git - 分布式版本控制系统
GitHub - 基于 Git 的代码托管平台
Discord - 一款语音和文字聊天软件（项目用它作为人机接口）
Anthropic - AI 公司，开发了 Claude 模型
OpenAI - AI 公司，开发了 GPT 模型
xAI - Elon Musk 创立的 AI 公司，开发了 Grok 模型
DashScope - 阿里云提供的 AI 服务（Qwen 模型）
Qwen - 阿里云的大型语言模型
Qdrant - 开源向量数据库，用于语义搜索
SQLite - 嵌入式关系型数据库
Axum - Rust 的 Web 框架
Tokio - Rust 的异步运行时
Serde - Rust 的序列化/反序列化框架
Reqwest - Rust 的 HTTP 客户端
Clap - Rust 的 CLI 参数解析库
Crossterm - Rust 的终端操作库
Regex - 正则表达式库
SHA-2 Secure Hash Algorithm 2 安全哈希算法 2，一种哈希函数
MD5 Message Digest Algorithm 5 消息摘要算法 5，一种哈希函数（已不安全）
URL Uniform Resource Locator 统一资源定位符，网址
JSON JavaScript Object Notation JavaScript 对象表示法，一种数据交换格式
YAML YAML Ain't Markup Language 另一种标记语言，一种数据序列化格式
TOML Tom's Obvious, Minimal Language Tom 的显而易见的极简语言，一种配置文件格式
XML eXtensible Markup Language 可扩展标记语言，一种数据交换格式
HTML HyperText Markup Language 超文本标记语言，网页的标准语言
CSS Cascading Style Sheets 层叠样式表，用于描述网页样式
JS JavaScript JavaScript，一种脚本语言
TS TypeScript TypeScript，JavaScript 的超集，添加了类型系统
Python - 一种高级编程语言
Rust - 一种系统编程语言，注重安全性和性能
C - 一种经典的编程语言
C++ - C 语言的扩展，添加了面向对象特性
Java - 一种面向对象的编程语言
Go - Google 开发的编程语言
Zig - 一种系统编程语言
C# C Sharp 微软开发的编程语言
F# F Sharp 微软开发的函数式编程语言
Ruby - 一种动态的面向对象编程语言
PHP Hypertext Preprocessor 一种用于 Web 开发的脚本语言
Perl - 一种古老的脚本语言
Shell - 命令行解释器
Bash Bourne Again Shell Bourne Again Shell，Linux/macOS 默认的 Shell
PowerShell - Windows 的 Shell
CMD Command Prompt 命令提示符，Windows 的传统 Shell
Terminal - 终端，用户输入命令的界面
Console - 控制台，类似于终端
IDE Integrated Development Environment 集成开发环境，如 VSCode、IntelliJ
VSCode Visual Studio Code 微软开发的代码编辑器
Vim - 一种命令行文本编辑器
Emacs - 一种可扩展的文本编辑器
Nano - 一种简单的命令行文本编辑器
Git Bash - Windows 上的 Git 命令行
WSL Windows Subsystem for Linux Windows Linux 子系统
Docker - 容器化平台
Podman - 类似于 Docker 的容器引擎
Kubernetes - 容器编排平台
Qdrant - 向量数据库
Milvus - 向量数据库
Pinecone - 向量数据库（云服务）
Weaviate - 向量数据库
Chroma - 向量数据库
OpenAI - AI 公司
Anthropic - AI 公司
Google - 谷歌公司
Microsoft - 微软公司
Amazon - 亚马逊公司
Meta - Meta 公司（Facebook）
Alibaba - 阿里巴巴公司
Baidu - 百度公司
Tencent - 腾讯公司
Huawei - 华为公司
ByteDance - 字节跳动公司
DeepSeek - 深度求索公司
Moonshot - 月之暗面公司（Kimi）
Zhipu - 智谱 AI 公司
Baichuan - 百川智能公司
MiniMax - MiniMax 公司
SenseTime - 商汤科技公司
Meituan - 美团公司
Didi - 滴滴公司
DiDi - 滴滴公司
Kuaishou - 快手公司
Bilibili - B 站
iQiyi - 爱奇艺
Youku - 优酷
Tencent Video - 腾讯视频
Douyin - 抖音
TikTok - 国际版抖音
Twitter - 推特（X）
Reddit - 红迪网
Hacker News - 黑客新闻
Stack Overflow - 栈溢出（编程问答网站）
GitHub - 代码托管平台
GitLab - 代码托管平台
Bitbucket - 代码托管平台
Gitee - 码云（中国版 GitHub）
Coding - 腾讯 Coding（代码托管平台）
Jira - 项目管理工具
Confluence - 文档协作工具
Notion - 笔记和协作工具
Slack - 团队沟通工具
Discord - 语音和文字聊天软件
Teams - 微软团队沟通工具
Zoom - 视频会议工具
Google Meet - 谷歌视频会议工具
Skype - 微软视频通话工具
WhatsApp - WhatsApp（Meta 的通讯软件）
WeChat - 微信
QQ - QQ
Telegram - 电报（通讯软件）
Signal - 信号（加密通讯软件）
Line - Line（日本通讯软件）
KakaoTalk - 韩国通讯软件
Viber - Viber（通讯软件）
Weibo - 微博
Zhihu - 知乎
Douban - 豆瓣
Tieba - 贴吧
Tianya - 天涯
Maimai - 脉脉
LinkedIn - 领英
Facebook - 脸书
Instagram - 照片墙
Snapchat - 色拉布
Pinterest - 拼趣
Tumblr - 汤博乐
Flickr - Flickr（图片分享网站）
Vimeo - Vimeo（视频网站）
Dailymotion - Dailymotion（法国视频网站）
Youku - 优酷
iQiyi - 爱奇艺
Tencent Video - 腾讯视频
Bilibili - B 站
Douyin - 抖音
Kuaishou - 快手
Huya - 虎牙
Douyu - 斗鱼
YY - YY（欢聚时代）
Momo - 陌陌
Soul - Soul（社交软件）
Tantan - 探探
Blued - Blued（同志社交软件）
Grindr - Grindr（同志社交软件）
Her - Her（女同社交软件）
Taimi - Taimi（LGBTQ+ 社交软件）
OkCupid - OkCupid（约会网站）
Match - Match（约会网站）
eHarmony - eHarmony（约会网站）
Plenty of Fish - POF（约会网站）
Bumble - Bumble（约会软件）
Hinge - Hinge（约会软件）
Coffee Meets Bagel - CMB（约会软件）
Hily - Hily（约会软件）
The League - The League（高端约会软件）
Raya - Raya（明星约会软件）
Tinder - Tinder（约会软件）
Grindr - Grindr（同志约会软件）
Scruff - Scruff（同志约会软件）
Jack'd - Jack'd（同志约会软件）
Hornet - Hornet（同志社交软件）
Zoosk - Zoosk（约会网站）
EliteSingles - EliteSingles（高端约会网站）
SilverSingles - SilverSingles（老年人约会网站）
OurTime - OurTime（老年人约会网站）
SeniorMatch - SeniorMatch（老年人约会网站）
SeniorPeopleMeet - SeniorPeopleMeet（老年人约会网站）
SeniorFriendsDate - SeniorFriendsDate（老年人约会网站）
SeniorDating - SeniorDating（老年人约会网站）
SeniorMatch - SeniorMatch（老年人约会网站）
SeniorPeopleMeet - SeniorPeopleMeet（老年人约会网站）
SeniorFriendsDate - SeniorFriendsDate（老年人约会网站）
SeniorDating - SeniorDating（老年人约会网站）

11. 总结

本文档详细分析了 Claw Code 项目的架构，包括：

  1. 项目概述: 了解项目的定位、特点和哲学
  2. 技术栈: 了解项目使用的语言、框架和依赖库
  3. 目录结构: 了解项目的完整目录树和每个模块的职责
  4. 模块调用关系: 了解模块之间的交互和数据流向（ASCII 流程图）
  5. 关键设计: 了解重要的数据结构、函数签名和设计模式
  6. 配置与扩展: 了解配置文件格式、插件机制和 MCP 扩展点
  7. Python 辅助代码: 了解 Python 代码的用途和与 Rust 实现的关系
  8. 部署架构: 了解 RAG 服务的 Docker 部署和 CI/CD 流程
  9. 术语表: 了解所有专业术语的详细解释

项目核心价值:

  • 高性能: Rust 实现，零运行时依赖，单二进制部署
  • 多提供商: 支持 Anthropic、OpenAI、xAI、DashScope 等多个 AI 提供商
  • 可扩展: MCP 协议支持无限扩展外部工具
  • 安全: 多层权限检查、沙箱隔离、路径验证
  • 自主构建: 展示 AI 代理自主构建软件的能力

文档结束

如果你对某个模块有更深入的兴趣，可以参考"附录：关键文件清单"中的文件路径，直接查看源码。

相关推荐
keykey6.1 小时前
卷积神经网络（CNN）：让AI学会“看“
开发语言·人工智能·深度学习·机器学习
qq7422349841 小时前
从“感知”到“决断”：测评百度伐谋产业决策智能体的端到端推理与行动机制
人工智能·算法·百度·大模型·运筹优化
暗夜猎手-大魔王1 小时前
转载--Hermes Agent 11 | 智能审批与平台化安全：当 AI 来守护 AI
人工智能·python·安全
feiwuw1 小时前
氛围编程是什么？以及为什么它又分出了“规划”和“严肃”模式
人工智能·氛围编程
是烨笙啊1 小时前
如何获取 dify-deploy skill 所需要的三个key值
人工智能·ai编程·dify
龙腾AI白云1 小时前
智能体+大模型=新生产力
人工智能·plotly·知识图谱
智塑未来1 小时前
AI耳机哪个牌子好？EARWEISS听智慧凭硬核技术脱颖而出
人工智能
辣香牛肉面1 小时前
Stable Diffusion本地部署教程及模型包
人工智能
升鲜宝供应链及收银系统源代码服务1 小时前
升鲜宝AI助手 E-R 图与操作说明书(三）---升鲜宝生鲜配送供应链管理系统源代码服务
大数据·人工智能·机器学习·生鲜供应链源代码·供应链源代码出售·生鲜配送源代码服务·门店连锁系统源代码
热门推荐
01GitHub 镜像站点02【AI】2026 年具身智能模型和世界模型总结032026 年 AI 编程工具终极横评：Cursor vs Claude Code vs Copilot vs Windsurf04Codex 下载安装指南：Windows 和 macOS 官方版下载05Codex 桌面端更新后 Chrome 插件和 Computer Use 不可用，怎么排查和修复06CC-Switch 下载、安装与使用配置指南【2026.5.29】07【踩坑记录 | 第一篇】微软商店无法使用时，如何手动安装 OpenAI Codex？附`.msix`文件系统错误解决方法08CC-Switch & Claude 基于 Linux 服务器安装使用指南09Codex 接入 DeepSeek API 完整配置文档10裂开！ChatGPT 居然开始要手机号验证，附详细解决方法