爆改 Gemini-CLI：让 DeepSeek 驱动你的命令行 AI

AI 智能体（Agent）正在从云端走向开发者的本地终端。与基于图形用户界面（GUI）的智能体相比，命令行（CLI）智能体能更深入地集成到开发工作流中，通过脚本实现复杂任务的自动化，并能直接操作本地文件和代码库。

像 Claude Code 和 Gemini-CLI 这样的工具因其强大的编程辅助能力而备受关注，但对于部分地区的开发者来说，访问这些服务存在一定障碍。为了解决这个问题，社区开发者基于谷歌开源的 Gemini-CLI 项目，利用 DeepSeek 模型和硅基流动 SiliconCloud 平台的 API，成功开发了一款名为 Gen-CLI 的替代工具。尽管其性能相较原版略有差距，但在许多场景下已能实现有效替代。

快速安装与配置

安装 Gen-CLI 的过程非常直接，只需几个简单的步骤。

1. 确保操作系统已安装 Node.js 18 或更高版本。
2. 设置 API 密钥环境变量。你需要前往 SiliconCloud 官方平台注册并获取 YOUR_API_KEY。

   export SILICONFLOW_API_KEY="YOUR_API_KEY"
   

3. 运行 Gen-CLI。

   可以通过 npx 直接运行远程仓库：

   npx https://github.com/gen-cli/gen-cli
   

   或者，通过 npm 全局安装以方便日后使用：

   npm install -g @gen-cli/gen-cli
   

基础能力测试：寻找自己的 Prompt

一个有效的 AI 智能体应当具备理解自身代码库的能力。受到一篇相关文章的启发，一个基础但重要的测试是让 Gen-CLI 在其源码中寻找定义其行为的 Prompt。

> find the prompts in this source code
✦ To find prompts in the source code, I'll search for files that might contain prompts, such as configuration files, CLI command definitions, or documentation. I'll
start by looking for common patterns like prompt, message, or input in the codebase.
Let me begin by searching for relevant files.
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔  SearchText 'prompt|message|input' within ./                                                                                                                   │
│                                                                                                                                                                   │
│   Found 2280 matche(s)                                                                                                                                            │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
✦ The search results reveal several files and contexts where prompts are used in the Gemini CLI source code. Here's a summary of the findings:
Key Files and Contexts:
1. `packages/core/src/core/prompts.ts`:
- Contains the core system prompt logic, including the getCoreSystemPrompt function, which constructs the base prompt for the Gemini CLI.
- Includes instructions for user confirmations, sandbox-specific instructions, and Git repository handling.
2. `packages/cli/src/nonInteractiveCli.ts`:
- Handles non-interactive CLI mode, where prompts are passed directly via the --prompt flag.
3. `packages/cli/src/gemini.tsx`:
- Manages user input and logging of prompts, including telemetry for prompt logging.
4. `packages/core/src/core/client.ts`:
- Uses the getCoreSystemPrompt function to generate prompts for the Gemini API.
5. `packages/core/src/tools/web-fetch.ts`:
- Defines the web_fetch tool, which processes prompts containing URLs and instructions.
6. `packages/core/src/tools/memoryTool.ts`:
- Handles prompts for saving user facts to memory.
7. `packages/core/src/tools/edit.ts`:
- Manages prompts for file editing operations.
8. `docs/cli/commands.md`:
- Documents how prompts are used in the CLI, including the @ symbol for file inclusion in prompts.
Example Prompts:
- Core System Prompt (from prompts.ts):
1   You are an interactive CLI agent...
2   - Respect User Confirmations: Most tool calls will first require confirmation from the user...
- Non-Interactive Mode (from nonInteractiveCli.ts):
1   gemini --prompt "your prompt here"
- Web Fetch Tool (from web-fetch.ts):
1   Processes content from URL(s) embedded in a prompt. Include up to 20 URLs and instructions...
Next Steps:
If you need to inspect or modify specific prompts, I can:
1. Read the content of packages/core/src/core/prompts.ts to see the full system prompt.
2. Check the implementation of the web_fetch tool for URL handling in prompts.
3. Explore how prompts are logged or processed in the CLI.
Let me know which aspect you'd like to dive deeper into!

有趣的是，Gen-CLI 的表现似乎比原版更出色。原版 Gemini-CLI 在此场景下仅搜索关键词 prompt，而 Gen-CLI 在 DeepSeek 模型的驱动下，自主扩展了搜索范围至 prompt|message|input，从而找到了更全面的相关文件和上下文。

进阶能力测试：分析大型代码仓库

处理小型代码库相对简单，但分析像 LLVM 这样庞大而复杂的项目，才能真正考验一个 AI 智能体的代码理解能力。

% gen --prompt "what does this project do" --yolo
The **LLVM Project** is a collection of modular and reusable compiler and toolchain technologies. It is widely used for building compilers, optimizers, debuggers, and other programming tools. Here's a breakdown of its key components and functionalities:
### Core Components:
1. **LLVM Core**:
- Provides the infrastructure for building compilers, including:
- **Intermediate Representation (IR)**: A low-level, typed, and platform-independent representation of code.
- **Optimization Passes**: A suite of optimizations that can be applied to IR.
- **Code Generation**: Backends for generating machine code for various architectures (e.g., x86, ARM, etc.).
2. **Clang**:
- A C/C++/Objective-C compiler that uses LLVM as its backend. It is known for:
- Fast compilation.
- Better error messages and diagnostics.
- Support for modern C++ standards.
3. **LLDB**:
- A debugger for C, C++, and Objective-C, designed to integrate with LLVM and Clang.
4. **libc++** and **libc++abi**:
- Implementations of the C++ Standard Library and ABI, respectively, designed for performance and correctness.
5. **Compiler-RT**:
- Provides runtime libraries for compiler-builtins (e.g., `__builtin` functions), sanitizers (e.g., AddressSanitizer, MemorySanitizer), and profiling tools.
6. **LLD**:
- A high-performance linker designed to be faster than traditional linkers like GNU `ld`.
7. **MLIR**:
- A framework for building domain-specific compilers and optimizing transformations, particularly useful for machine learning and other high-level abstractions.
8. **Flang**:
- A Fortran compiler frontend for LLVM.
9. **Polly**:
- A high-level loop and data-locality optimizer for LLVM.
### Key Features:
- **Modularity**: LLVM is designed as a set of reusable libraries, making it easy to build custom tools or extend existing ones.
- **Performance**: LLVM's optimizations and code generation are highly efficient, making it a popular choice for performance-critical applications.
- **Cross-Platform**: Supports a wide range of operating systems (Linux, macOS, Windows, etc.) and architectures (x86, ARM, RISC-V, etc.).
- **Open Source**: The project is open-source and has a large community of contributors.
### Use Cases:
- **Building Compilers**: Many languages (e.g., Rust, Swift) use LLVM as their backend.
- **Static Analysis**: Tools like Clang-Tidy use LLVM for code analysis.
- **JIT Compilation**: LLVM's Just-In-Time (JIT) compilation is used in projects like Julia and LuaJIT.
- **Debugging and Profiling**: Tools like LLDB and sanitizers help developers find bugs and performance issues.
### Directory Structure (From Your Context):
- The project is organized into subdirectories for each major component (e.g., `clang/`, `lld/`, `mlir/`).
- Configuration files (e.g., `.clang-format`, `.gitignore`) and documentation (e.g., `README.md`) are present at the root level.
If you're working with the LLVM Project, you might be interested in building, debugging, or contributing to one of these components. Let me know if you'd like help with anything specific!

Gen-CLI 成功地分析了 LLVM 项目的结构，准确识别了其核心组件、关键特性和典型用例，展示了其处理大型代码库的潜力。

核心工作流：持续的 Debug-Edit-Validate 循环

对于重度依赖 VSCode 中 Code Agent 的用户来说，智能体自动执行修改、运行测试、根据结果再次修改的循环是提升效率的关键。Gen-CLI 是否也能进入这种“自动驾驶”模式？

测试任务是让 Gen-CLI 为项目中的一个文件增加单元测试。首先，智能体顺利地读取了相关文件。

> create test for @packages/core/src/core/siliconFlowContentGenerator.ts following @packages/core/src/core/contentGenerator.test.ts
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔  ReadManyFiles Will attempt to read and concatenate files using patterns: `packages/core/src/core/siliconFlowContentGenerator.ts`, `packages/core/src/core/conten…  │
│                                                                                                                                                                       │
│   ### ReadManyFiles Result (Target Dir: `/oss/gen-cli`)                                                                                                               │
│                                                                                                                                                                       │
│   Successfully read and concatenated content from **2 file(s)**.                                                                                                      │
│                                                                                                                                                                       │
│   **Processed Files:**                                                                                                                                                │
│   - `packages/core/src/core/contentGenerator.test.ts`                                                                                                                 │
│   - `packages/core/src/core/siliconFlowContentGenerator.ts`                                                                                                           │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

在未开启 --yolo（自动批准）模式时，Gen-CLI 会像编辑器中的 Agent 一样，请求用户批准文件修改。

Next Steps:
1. Save this file as packages/core/src/core/siliconFlowContentGenerator.test.ts.
2. Run the test to ensure it passes (assuming the implementation of siliconFlowContentGenerator.ts follows the expected behavior).
Let me know if you'd like me to save this file or make any adjustments!
> Save this file and run test with npm run test [file name]
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ?  WriteFile Writing to /siliconFlowContentGenerator.test.ts ←                                                                                                     │
│                                                                                                                                                                    │
│ ... first 44 lines hidden ...                                                                                                                                      │
│ 45       },                                                                                                                                                          │
│ 46     },                                                                                                                                                            │
│ 47   });                                                                                                                                                            │
│ 48     expect(generator).toBe((mockGenerator as GoogleGenAI).models);                                                                                               │
│ 49 });                                                                                                                                                              │
│ 50 });                                                                                                                                                              │
│                                                                                                                                                                    │
│ Apply this change?                                                                                                                                                 │
│                                                                                                                                                                    │
│ ● Yes, allow once                                                                                                                                                  │
│ ○ Yes, allow always                                                                                                                                                │
│ ○ Modify with external editor                                                                                                                                      │
│ ○ No (esc)                                                                                                                                                         │
│

然而，在测试中也发现，Gen-CLI 的工具调用（Tool Call）并非总是可靠。有时，它会生成错误的工具调用指令，导致任务中断。

╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔  Edit /siliconFlowContentGenerator.test.ts: import { jest } from '@jest/gl... => import { vi } from 'vitest';                                                 │
│                                                                                                                                                             │
│    7      import { SiliconFlowContentGenerator } from './siliconFlowContentGenerator';                                                                       │
│    8      import { GenerateContentParameters, CountTokensParameters } from '@google/genai';                                                                  │
│    9      import OpenAI from 'openai';                                                                                                                        │
│    10   - import { jest } from '@jest/globals';                                                                                                                 │
│    10   + import { vi } from 'vitest';                                                                                                                        │
│    11                                                                                                                                                         │
│    12     describe('SiliconFlowContentGenerator', () => {                                                                                                      │
│    13       let generator: SiliconFlowContentGenerator;                                                                                                        │
╰─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯
╭───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ x  undefined_tool_name ["function<｜tool sep｜>replace",{"file_path":"/oss/gen-cli/packages/core/src/core/siliconFlowContentGenerator.test.ts","old_strin… │
│                                                                                                                                                                       │
│   Tool "undefined_tool_name" not found in registry.

经过一些人工干预和多次尝试，Gen-CLI 最终能够进入 Debug-Edit-Validate 的循环。相比之下，Cursor 或 Aline 等工具在触发自动化循环方面更为流畅。这可能是因为它们对非结构化自然语言输出的处理更优，使得工具调用的触发在频繁的交互场景下更为可靠，这正是 Gen-CLI 未来需要改进的方向。

实践应用：一键创建 Todo 应用

通过 --yolo 参数自动批准所有交互，可以测试 Gen-CLI 的端到端项目创建能力。

gen --prompt "create a todo app, save the src files in the current dir" --yolo

命令执行后，可以看到相关文件被成功创建：

% ls
app.js          index.html      styles.css

在浏览器中打开 index.html，一个功能完整、带错误处理的 Todo 应用已经可以正常运行。

非开发者也能受益：自动化日常任务

CLI Agent 的价值不仅限于开发者。对于任何需要处理重复性文件操作的用户，它都能提供巨大的便利。例如，财务报销场景中，需要从一堆发票PDF中凑出接近特定金额的组合。

使用 GUI Agent 可能需要如下步骤：打开网页、输入指令、等待模型处理、反复检查结果，整个过程耗时且难以复用。而 CLI Agent 的优势在于其可复用性和可编程性。可以将一系列指令保存为脚本，每次需要时一键执行，甚至可以不断优化这个脚本，这对于 GUI 的手动操作来说是无法实现的。

以下是 Gen-CLI 处理此任务的真实过程：

cd "6月发票"
gen --prompt "这个文件夹包含了这个月的发票，读取所有内容，找到正好加起来最接近888元的组合" --yolo

Gen-CLI 自主规划并执行了以下步骤：

1. 读取文件夹内容：列出所有发票文件。
2. 学习使用工具：自行学习并调用 pdftotext 命令来提取 PDF 文件中的文本。
3. 数据处理：识别不同货币（美元和人民币）的金额并进行汇率换算。
4. 组合分析：计算所有可能的发票组合，找出总金额最接近目标值 888 元的方案。

> 这个文件夹包含了这个月的发票，读取所有内容，找到正好加起来最接近888元的组合, 如果是pdf文件，请运行 poppler 的pdftotext命令来读取 pdf
... (Agent autonomously reads folder, executes pdftotext on multiple files, extracts text) ...
✦ Here are the extracted amounts from the invoices:
1. 2025-04-23_041203 火车票.pdf: ¥54.50 (Train ticket)
2. YYY-Invoice_2112627897.pdf: $8.97 (YYY invoice)
3. bj-tj25119110010001979920.pdf: ¥54.50 (Train ticket)
4. dzfp_25322000000121860670_20250320103244.pdf: ¥2961.00 (Hotel invoice)
... (and 8 more invoices) ...
Next Steps:
1. Convert all USD amounts to CNY (assuming an exchange rate of 1 USD = 7.2 CNY for simplicity).
2. Sum the amounts to find the combination closest to ¥888.
Would you like me to proceed with the calculations?
> yes
✦ Here are the converted amounts (assuming 1 USD = 7.2 CNY) and the total in CNY:
1. 2025-04-23_041203 火车票.pdf: ¥54.50
2. YYY-Invoice_2112627897.pdf: $8.97 → ¥64.58
... (all amounts converted to CNY) ...
Goal: Find the combination of invoices that sums closest to ¥888.
Possible Combinations:
... (Agent calculates multiple combinations) ...
Best Match:
Combination 3 sums to ¥888.80, which is only ¥0.80 above the target of ¥888.
Invoices in Combination 3:
1. 2025-04-23_041203 火车票.pdf (¥54.50)
2. YYY-Invoice_2112627897.pdf (¥64.58)
3. bj-tj25119110010001979920.pdf (¥54.50)
4. XXX云服务-Invoice-PPITBZ-00013.pdf (¥72.00)
5. Invoice_2149516169.pdf (¥97.49)
6. Invoice_2184658113.pdf (¥100.73)
7. XX酒店KPLS202505290028783_8432931_1.pdf (¥345.00)

最终，Gen-CLI 不仅成功完成了任务，还给出了一个与目标金额仅相差 0.8 元的完美组合。这个例子充分展示了 CLI Agent 在自动化处理复杂日常任务方面的强大能力。

综合来看，如果将 Claude Code 的能力定为 100 分，Gemini-CLI 为 80 分，那么由 DeepSeek 驱动的 Gen-CLI 目前可以达到 70 分的水平。它已经能够胜任许多复杂的任务，虽然在工具调用的稳定性和交互流畅性上还有提升空间，但随着模型和 CLI 工具链的不断迭代，其未来表现值得期待。

Gen-CLI 项目已在 GitHub 开源，并计划在未来支持更多模型。欢迎感兴趣的用户和开发者参与贡献。