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

1.1 项目定位

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 核心特性对比

1.4 代码规模对比

1.5 启动性能对比

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 + 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 状态管理对比

2.4 依赖注入对比

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 对比

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 对比

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 对比总结

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

4.1 内置工具清单

Crush (19个)

Kimi Code CLI (13个)

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 文件操作对比

4.4 MCP集成

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 对比总结

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 对比总结

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

8.1 CLI框架

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+)

Kimi Code CLI (7+)

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 对比总结

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

12.1 全面对比总结

架构层面

功能层面

性能层面

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服务

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

11.1 启动性能

原因分析

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

11.2 内存占用

11.3 并发性能

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性能

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 对比总结