01. 概述对比：Crush vs Kimi Code CLI

1.1 项目定位

维度	Crush	Kimi Code CLI
开发者	Charmbracelet	Moonshot AI (月之暗面)
核心定位	通用AI编程助手CLI	Kimi生态专属编程助手
目标用户	Go开发者、追求性能的用户	Python开发者、Kimi用户
许可证	MIT	MIT

1.2 技术栈对比

Crush 技术栈

语言:        Go 1.26
CLI框架:     Cobra
TUI框架:     Bubble Tea v2 + Bubbles v2
样式:        Lip Gloss v2 + Glamour v2
LLM抽象:     Fantasy (自研)
数据库:      SQLite (modernc.org/sqlite + sqlc)
MCP:        go-sdk (官方)
构建:       GoReleaser + Taskfile

Kimi Code CLI 技术栈

语言:        Python 3.12+ (目标3.14)
CLI框架:     Typer
TUI框架:     prompt-toolkit + Rich
样式:        Rich
LLM抽象:     Kosong (自研) + Pydantic
数据库:      无内置，文件持久化
MCP:        fastmcp
构建:       uv + PyInstaller
Web:        FastAPI + Uvicorn

1.3 核心特性对比

特性	Crush	Kimi Code CLI
交互模式	TUI (Bubble Tea)	Shell + TUI + Web
多模型支持	OpenAI/Anthropic/Google/Bedrock/Azure等	Kimi/OpenAI/Anthropic/Google等
MCP支持	stdio/HTTP/SSE	stdio/HTTP
IDE集成	无原生支持	ACP 0.7.0 + VSCode扩展
会话持久化	SQLite	文件JSON
上下文压缩	自动摘要	手动/自动compact
子Agent	agent_tool	Task工具 + LaborMarket
Skills	YAML文件	YAML + Flow技能
权限控制	Permission服务 + 自动批准	Approval交互确认
OAuth	支持	支持 (Kimi专属)
Web界面	无	FastAPI + React

1.4 代码规模对比

指标	Crush	Kimi Code CLI
核心代码行数	~15,000行 Go	~12,000行 Python
文件数量	~240个	~200个
依赖数量	~25个 Go模块	~40+ PyPI包

1.5 启动性能对比

指标	Crush	Kimi Code CLI
冷启动时间	<100ms (原生二进制)	~500ms (Python解释器)
内存占用	较低 (Go GC)	较高 (Python + 依赖)
分发方式	单二进制	Python包 + 可选打包

1.6 选型建议

选择 Crush 的场景

• 追求极致性能和启动速度
• 偏好 Go 生态和编译型语言
• 需要跨平台单二进制分发
• 重视类型安全和编译期检查

选择 Kimi Code CLI 的场景

• 需要 IDE 集成 (VSCode)
• 偏好 Python 生态
• 需要灵活的扩展机制
• 使用 Kimi 模型服务
• 需要 Web 界面支持

02. 架构对比：Crush vs Kimi Code CLI

2.1 整体架构对比

Crush 分层架构

CLI Layer (cmd/)           → Cobra命令
Application Layer (app/)   → 应用编排
Agent/Orchestration (agent/) → Agent协调
Service Layer              → 业务服务
Infrastructure             → 基础设施(db, lsp, config)

Kimi Code CLI 分层架构

CLI Layer (Typer)          → Typer命令
App Layer (app.py)         → KimiCLI编排
Soul Layer (soul/)         → Agent循环
Tool Layer (tools/)        → 工具实现
LLM Abstraction (Kosong)   → LLM抽象
OS Abstraction (Kaos)      → OS抽象

2.2 并发模型对比

维度	Crush (Goroutine)	Kimi Code CLI (asyncio)
并行性	真并行 (多核)	伪并行 (单线程)
调度	Go运行时抢占式	Python事件循环协作式
阻塞容忍	高 (可阻塞独立线程)	低 (阻塞整个循环)
内存开销	KB级每goroutine	字节级每协程

Crush: Goroutine + Channel

type Value[T any] struct {
    mu    sync.RWMutex
    value T
}

type Broker[T any] struct {
    subscribers map[int]*subscriber[T]
}

Kimi Code CLI: asyncio 协程

class Wire:
    def __init__(self):
        self._queue: asyncio.Queue[WireMessage] = asyncio.Queue()

class KimiSoul:
    async def run(self, user_input):
        await self._turn(user_message)

2.3 状态管理对比

维度	Crush	Kimi Code CLI
模式	响应式 (PubSub)	消息传递 (Wire)
解耦度	中	高
延迟	低	中

2.4 依赖注入对比

维度	Crush	Kimi Code CLI
方式	显式构造函数	反射+类型推断
类型安全	编译期检查	运行时检查
灵活性	中等	高

2.5 架构优劣分析

Crush 优势

1. 类型安全: 编译期检查 2. 性能优越: Goroutine真并行 3. 部署简单: 单二进制 4. 内存效率: Go GC成熟

Kimi Code CLI 优势

1. 开发效率: Python语法简洁 2. 灵活性: 动态类型 3. 生态丰富: PyPI包海量 4. 扩展性: Agent继承、Flow技能

03. 核心模块对比：Crush vs Kimi Code CLI

3.1 Agent/Session/Message 三层模型

Crush 核心模型

Coordinator (协调 Agent、Session、Message、Tools)
    ↓
SessionAgent → Session → Message

Kimi Code CLI 核心模型

KimiCLI (编排 Runtime、Soul、Agent、Session)
    ↓
KimiSoul → Context → Message

3.2 Agent 实现对比

Crush: SessionAgent (Go)

type SessionAgent interface {
    Run(context.Context, SessionAgentCall) (*fantasy.AgentResult, error)
    SetModels(large Model, small Model)
    SetTools(tools []fantasy.AgentTool)
    SetSystemPrompt(systemPrompt string)
    Cancel(sessionID string)
    Summarize(context.Context, string, fantasy.ProviderOptions) error
}

Kimi Code CLI: KimiSoul (Python)

class KimiSoul:
    async def run(self, user_input: str | list[ContentPart]):
        await self._turn(user_input)
    
    async def _agent_loop(self) -> TurnOutcome:
        while True:
            if self._context.token_count >= limit:
                await self.compact_context()
            step_outcome = await self._step()

3.3 Session/Context 对比

维度	Crush (Session)	Kimi Code CLI (Context)
存储	SQLite	文件JSON
事件	PubSub通知	无内置
Token跟踪	精确 (LLM返回)	估算
检查点	无	支持
Cost	跟踪	不跟踪

3.4 Tool 基础结构对比

Crush: fantasy.AgentTool

func NewBashTool(permissions, workingDir, shell, cfg) fantasy.AgentTool {
    return fantasy.NewAgentTool("bash", description,
        func(ctx context.Context, params BashParams) (ToolResponse, error) {
            return executeBash(ctx, params)
        })
}

Kimi Code CLI: CallableTool2

class Shell(CallableTool2[Params]):
    name: str = "Shell"
    params: type[Params] = Params
    
    async def __call__(self, params: Params) -> ToolReturnValue:
        if not await self._approval.request(...):
            return ToolRejectedError()
        return ToolOk(output=result.stdout)

3.5 Runtime/Coordinator 对比

维度	Crush (Coordinator)	Kimi Code CLI (Runtime)
摘要	内置方法	Soul的compact_context
时间旅行	不支持	DenwaRenji
子Agent	agent_tool	LaborMarket
技能	Skills系统	skills字典

05. 配置管理对比：Crush vs Kimi Code CLI

5.1 配置文件格式

Crush: JSON

{
  "$schema": "https://charm.land/crush.json",
  "models": {
    "large": {"model": "claude-sonnet-4", "provider": "anthropic"},
    "small": {"model": "gpt-4o-mini", "provider": "openai"}
  },
  "providers": {
    "anthropic": {"type": "anthropic", "api_key": "$ANTHROPIC_API_KEY"}
  },
  "mcp": { "filesystem": {"type": "stdio", "command": "npx", ...} },
  "lsp": { "gopls": {"command": "gopls", "options": {...}} }
}

Kimi Code CLI: TOML

default_model = "kimi-for-coding"

[models.kimi-for-coding]
provider = "kimi"
model = "kimi-for-coding"
max_context_size = 128000

[providers.kimi]
type = "kimi"
api_key = "${KIMI_API_KEY}"

5.2 配置层级

Crush

1. 命令行参数 (最高)
2. .crush.json (项目)
3. crush.json (项目)
4. ~/.config/crush/crush.json (全局)
5. 默认值

Kimi Code CLI

1. 命令行参数 (最高)
2. 指定配置文件 (--config)
3. 项目配置 (<work_dir>/.kimi/)
4. 全局配置 (~/.kimi/)
5. 默认值

5.3 对比总结

维度	Crush	Kimi Code CLI
格式	JSON	TOML (支持JSON)
全局路径	~/.config/crush/	~/.kimi/
环境变量	$VAR, ${VAR}	${VAR}, ${VAR:-default}
热加载	支持 (fsnotify)	不支持
Schema验证	schema.json	Pydantic
MCP管理	配置文件	CLI命令
LSP配置	内置	无

04. 工具系统对比：Crush vs Kimi Code CLI

4.1 内置工具清单

Crush (19个)

工具	功能
bash	Shell命令执行
view	读取文件
edit/multiedit	文件编辑
write	写入文件
ls	目录列表
glob/grep	文件搜索
fetch/web_fetch/web_search	Web操作
todos	任务管理
lsp_diagnostics/references	LSP工具
agent	子Agent调用

Kimi Code CLI (13个)

工具	功能
Shell	Shell执行
ReadFile/ReadMediaFile	文件读取
WriteFile	文件写入
StrReplaceFile	字符串替换
Glob/Grep	文件搜索
SearchWeb/FetchURL	Web工具
Task	子Agent任务
Think	扩展思考
SendDMail	时间旅行

4.2 Shell工具安全策略

Crush: 60+禁用命令

var bannedCommands = []string{
    "curl", "wget", "sudo", "su", "npm", "pip", "ssh", "scp",
    "docker", "kubectl", "chmod", "chown", "systemctl",
    // ... 约60个命令
}

func isBanned(command string) bool {
    for _, banned := range bannedCommands {
        if cmd == banned { return true }
    }
    return false
}

Kimi Code CLI: Approval确认

async def __call__(self, params: Params):
    approved = await self._approval.request(
        tool=self.name,
        action="run command",
        details=f"Run `{params.command}`"
    )
    if not approved:
        return ToolRejectedError()

4.3 文件操作对比

维度	Crush	Kimi Code CLI
默认行数	2000	1000
最大文件	5MB	无限制
编辑前读检查	强制(fileTracker)	无
修改检测	有	无
LSP通知	有	无

4.4 MCP集成

维度	Crush	Kimi Code CLI
客户端库	go-sdk (官方)	fastmcp
传输类型	stdio/HTTP/SSE	stdio/HTTP
工具命名	mcp_{server}_{tool}	mcp_{server}_{tool}

07. 文件操作对比：Crush vs Kimi Code CLI

7.1 文件读取

Crush view工具

const (
    MaxReadSize      = 5 * 1024 * 1024 // 5MB
    DefaultReadLimit = 2000
    MaxLineLength    = 2000
)

// 输出格式
"     1: package main\n"
"     2: import \"fmt\"\n"

Kimi Code CLI ReadFile

MAX_LINES = 1000
MAX_LINE_LENGTH = 2000

# 自动检测媒体文件并委托给ReadMediaFile

7.2 文件编辑安全策略

Crush: 文件跟踪

// 必须先读取才能编辑
if !fileTracker.HasRead(path) {
    return "You must read the file before editing"
}

// 检查是否被修改
if fileTracker.WasModified(path) {
    return "File was modified. Please read it again."
}

Kimi Code CLI: 唯一匹配

# old_str必须唯一
count = content.count(params.old_str)
if count > 1:
    return ToolError("Found {count} occurrences. Must be unique.")

7.3 对比总结

维度	Crush	Kimi Code CLI
读取行数	2000	1000
最大文件	5MB	无限制
编辑前读检查	强制	无
修改检测	有	无
批量编辑	multiedit	不支持
追加模式	不支持	支持
LSP通知	有	无
安全策略	文件跟踪	Approval

06. 提示词系统对比：Crush vs Kimi Code CLI

6.1 模板引擎

Crush: Go text/template

// coder.md.tpl
You are Crush, a powerful AI Assistant.

<env>
Working directory: {{.WorkingDir}}
Platform: {{.Platform}}
Today's date: {{.Date}}
</env>

{{if .ContextFiles}}
<memory>
{{range .ContextFiles}}
<file path="{{.Path}}">{{.Content}}</file>
{{end}}
</memory>
{{end}}

Kimi Code CLI: Jinja2风格

The current date and time is ${KIMI_NOW}.
The current working directory is ${KIMI_WORK_DIR}.

The project level AGENTS.md:
${KIMI_AGENTS_MD}

Available skills:
${KIMI_SKILLS}

6.2 Agent继承系统

Crush: 不支持

// crush 没有Agent继承机制
// 仅通过Skills扩展能力

Kimi Code CLI: 完整继承

# custom/agent.yaml
agent:
  extend: default  # 继承默认Agent
  name: "Custom Agent"
  tools:
    - "custom.tools:MyTool"
  exclude_tools:
    - "kimi_cli.tools.web:SearchWeb"

6.3 Skills系统

Crush: YAML指令

---
name: code-review
description: Perform thorough code reviews
---
When reviewing code...

Kimi Code CLI: YAML + Flow

---
name: deploy
type: flow  # 可执行流程
flow:
  steps:
    - tool: "Shell"
      params: {command: "npm test"}
    - tool: "Shell"
      params: {command: "npm run build"}

6.4 对比总结

维度	Crush	Kimi Code CLI
模板引擎	Go template	Jinja2风格
变量语法	{{.Var}}	${VAR}
Agent继承	不支持	extend字段
Skills	XML注入	XML + Flow
子Agent	agent_tool	Task + LaborMarket

08. 命令处理对比：Crush vs Kimi Code CLI

8.1 CLI框架

维度	Crush	Kimi Code CLI
框架	Cobra	Typer
语言	Go	Python

Crush 命令

crush          → 启动TUI
crush run      → 非交互模式
crush login    → OAuth登录
crush models   → 列出模型

Kimi Code CLI 命令

kimi           → 启动Shell
kimi acp       → ACP服务器
kimi web       → Web UI
kimi mcp add   → 添加MCP

8.2 斜杠命令

Crush: 无

// crush 没有内置斜杠命令

Kimi Code CLI: 丰富

/init     → 生成AGENTS.md
/compact  → 压缩上下文
/clear    → 清空上下文
/yolo     → 切换自动批准
/checkpoint → 创建检查点
/rollback <id> → 回滚
/skill:*  → 执行Skill
/flow:*   → 执行Flow

8.3 IDE集成

Crush: 无ACP支持

// 目前不支持ACP协议

Kimi Code CLI: ACP 0.7.0

# kimi acp --port 13338
# VSCode扩展可连接
class ACPServer:
    async def _handle_prompt(self, request):
        soul = self._sessions[request.session_id]
        await run_soul(soul, request.prompt)

8.4 Web UI

Crush: 无

Kimi Code CLI: FastAPI + React

# kimi web --port 8000
@app.websocket("/ws")
async def websocket_endpoint(websocket):
    soul = await create_soul()
    async for msg in run_soul(soul, prompt):
        await websocket.send_json(msg)

09. LLM集成对比：Crush vs Kimi Code CLI

9.1 LLM抽象层

Crush: Fantasy

charm.land/fantasy
- fantasy.Generate()
- fantasy.Stream()
- fantasy.AgentTool

Kimi Code CLI: Kosong

packages/kosong/
- ChatProvider Protocol
- step()
- generate()
- Toolset

9.2 支持的Provider

Crush (10+)

Provider	类型
OpenAI	openai
Anthropic	anthropic
OpenRouter	openrouter
Azure	azure
Bedrock	bedrock
Google	google
Vertex	google-vertex

Kimi Code CLI (7+)

Provider	类型
Kimi	kimi
OpenAI	openai_legacy
Anthropic	anthropic
Google	google_genai
Gemini	gemini
Vertex AI	vertexai

9.3 流式处理

Crush: 回调函数

fantasy.Stream(ctx, fantasy.AgentStreamCall{
    OnTextDelta: func(delta string) { ... },
    OnToolCall: func(tc ToolCall) { ... },
    OnReasoningDelta: func(delta string) { ... },
})

Kimi Code CLI: 异步迭代器

async for part in result:
    if part.text:
        wire_send(ContentPart(part=part))
    if part.tool_call:
        result = await toolset.handle(part.tool_call)

9.4 上下文压缩

Crush: 自动摘要

func (a *sessionAgent) Summarize(...) {
    // 使用小模型生成摘要
    // 保留最后N条消息
    // 替换历史为摘要
}

Kimi Code CLI: compact + checkpoint

async def compact_context(self):
    summary = await self._summarize(history)
    self._context._history = [
        Message(content=f"[Summary]\n{summary}"),
        last_msg,
    ]

9.5 对比总结

维度	Crush	Kimi Code CLI
抽象库	Fantasy	Kosong
流式处理	回调函数	异步迭代器
Kimi支持	无	原生
成本跟踪	精确计算	无
缓存	Provider级	Session级

12. 总结与建议：Crush vs Kimi Code CLI

12.1 全面对比总结

架构层面

维度	Crush	Kimi Code CLI
语言	Go	Python
并发	Goroutine真并行	asyncio伪并行
类型安全	编译期检查	运行时Pydantic
部署	单二进制	需Python环境

功能层面

维度	Crush	Kimi Code CLI
内置工具	19个	13个
LSP支持	✅ 完整	❌ 无
IDE集成	❌ 无	✅ ACP协议
Web UI	❌ 无	✅ FastAPI
Agent继承	❌ 无	✅ 支持
时间旅行	❌ 无	✅ D-Mail

性能层面

维度	Crush	Kimi Code CLI
启动时间	~50ms	~400ms (8x慢)
内存占用	~80MB	~250MB (3x多)
持久化	SQLite	文件

12.2 选型建议

✅ 选择 Crush

• 追求性能和效率
• 偏好Go语言生态
• 需要LSP代码智能
• 资源受限环境
• 需要快速启动
• 重视类型安全

✅ 选择 Kimi Code CLI

• 需要IDE集成 (VSCode)
• 使用Kimi模型服务
• 偏好Python语言
• 需要Web界面
• 需要灵活扩展
• 多Agent协作场景

12.3 改进建议

对 Crush

1. 添加ACP协议支持 (IDE集成) 2. 实现Agent继承系统 3. 添加Web界面 4. 支持Flow Skills

对 Kimi Code CLI

1. 性能优化 (uvloop、懒加载) 2. 添加LSP支持 3. SQLite持久化 4. 增强安全策略

12.4 结论

两个项目都是优秀的AI编程助手CLI工具：

• Crush → 性能、稳定性、单机部署
• Kimi Code CLI → IDE集成、灵活扩展、Kimi服务

选择取决于具体需求和技术栈偏好。

--- *Generated by GrokTeam 智囊会议*

11. 性能对比：Crush vs Kimi Code CLI

11.1 启动性能

测试项	Crush	Kimi Code CLI	倍数
冷启动	50ms	400ms	8x
热启动	30ms	200ms	6.7x

原因分析

• Crush: 原生二进制，无解释器
• Kimi: Python解释器 + 依赖加载

11.2 内存占用

测试项	Crush	Kimi Code CLI	倍数
空闲	40MB	150MB	3.75x
运行中	80MB	250MB	3.1x
峰值	200MB	500MB	2.5x

11.3 并发性能

测试项	Crush	Kimi Code CLI
并行模型	真并行 (多核)	伪并行 (单线程)
10个工具并行	100ms	200ms
CPU密集任务	不阻塞	阻塞事件循环

Crush: Goroutine

// 真正的并行执行
for i, call := range calls {
    go func(idx int, c ToolCall) {
        results[idx] = executeTool(c)
    }(i, call)
}

Kimi Code CLI: asyncio

# 协程并发，受GIL限制
results = await asyncio.gather(*tasks)

11.4 I/O性能

测试项	Crush	Kimi Code CLI
文件读取(1MB)	5ms	15ms
工具调用	2ms	5ms
UI更新	1ms	3ms

11.5 性能选型建议

选择 Crush

• 性能敏感应用
• 资源受限环境
• 高并发场景
• 大文件处理

选择 Kimi Code CLI

• 开发效率优先
• 快速原型开发
• 灵活扩展需求

10. 扩展机制对比：Crush vs Kimi Code CLI

10.1 扩展架构

Crush

Skills (YAML) + MCP (go-sdk) + LSP + Catwalk

Kimi Code CLI

Skills (YAML+Flow) + MCP (fastmcp) + Agent继承 + Subagents + 自定义工具

10.2 Agent继承

Crush: 不支持

// 所有Agent使用相同模板
// 仅通过Skills扩展

Kimi Code CLI: 完整继承

agent:
  extend: default
  tools:
    - "custom.tools:MyTool"
  exclude_tools:
    - "kimi_cli.tools.web:SearchWeb"
  subagents:
    coder:
      path: ./coder.yaml

10.3 子Agent系统

Crush: agent_tool

// 创建子会话
childSession := coordinator.sessions.Create(ctx, "Sub-task")
result, _ := coordinator.Run(ctx, childSession.ID, prompt)

Kimi Code CLI: Task + LaborMarket

class Task(CallableTool2[Params]):
    async def __call__(self, params):
        agent = self._labor_market.get_agent(params.agent)
        soul = KimiSoul(agent, context=isolated_context)
        await run_soul(soul, params.prompt)

class LaborMarket:
    def register(self, name: str, agent: Agent)
    def get_agent(self, name: str) -> Agent

10.4 LSP支持

Crush: 完整

type Manager struct {
    clients map[string]*Client
}

// 工具: lsp_diagnostics, lsp_references, lsp_restart

Kimi Code CLI: 无

// 目前不支持LSP

10.5 对比总结

维度	Crush	Kimi Code CLI
Skills	YAML指令	YAML + Flow
Agent继承	不支持	extend字段
子Agent	agent_tool	Task + LaborMarket
MCP客户端	go-sdk	fastmcp
LSP支持	完整	无
自定义工具	Go编译	Python类