Explodindo a Gemini-CLI: deixe o DeepSeek conduzir sua IA de linha de comando

Os agentes de inteligência de IA estão se deslocando da nuvem para os pontos de extremidade locais dos desenvolvedores. As inteligências de linha de comando (CLI) podem ser mais profundamente integradas aos fluxos de trabalho de desenvolvimento do que as inteligências baseadas em interface gráfica de usuário (GUI), automatizar tarefas complexas por meio de scripts e manipular diretamente arquivos locais e bibliotecas de código.

assemelhar-se Claude Code responder cantando Gemini-CLI Essas ferramentas são muito procuradas por seus poderosos recursos de programação, mas existem barreiras ao acesso a esses serviços para desenvolvedores em algumas regiões. Para resolver esse problema, os desenvolvedores da comunidade criaram o código aberto do Google Gemini-CLI Projeto, usando DeepSeek Modelagem e fluxo baseado em silício SiliconCloud da plataforma, desenvolveu com sucesso uma nova API chamada Gen-CLI A ferramenta de substituição. Embora haja uma pequena diferença de desempenho em relação ao original, ele tem sido um substituto eficaz em muitos cenários.

Instalação e configuração rápidas

montagem Gen-CLI O processo é muito direto e requer apenas algumas etapas simples.

1. Certifique-se de que o sistema operacional esteja instalado Node.js 18 anos ou mais.
2. Defina a variável de ambiente da chave de API. Você precisa ir para a seção SiliconCloud Registre-se na plataforma oficial e obtenha YOUR_API_KEY.

   export SILICONFLOW_API_KEY="YOUR_API_KEY"
   

3. estar em movimento Gen-CLI.

   Isso pode ser feito por npx Execute o repositório remoto diretamente:

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

   Alternativamente, por npm Instalação global para uso futuro:

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

Teste de aptidão básica: como encontrar seu prompt

Uma inteligência de IA eficaz deve ter a capacidade de entender sua própria base de código. Inspirado em um artigo relacionado, um teste básico, mas importante, é fazer com que o Gen-CLI Procure o Prompt que define seu comportamento em seu código-fonte.

> 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!

Interessante.Gen-CLI O desempenho parece ser melhor do que o original. A versão original Gemini-CLI Pesquisar palavras-chave somente nesse cenário promptmas (não) Gen-CLI existir DeepSeek extensão autônoma e orientada por modelos da pesquisa para o prompt|message|inpute, assim, encontrar uma gama mais abrangente de documentos e contextos relevantes.

Teste de Proficiência Avançado: Analisando grandes repositórios de código

Lidar com bases de código pequenas é relativamente simples, mas analisar uma base de código como a do LLVM São projetos grandes e complexos como esse que realmente testam a capacidade de uma inteligência de IA de entender códigos.

% 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 Analisado com sucesso LLVM A estrutura do projeto, identificando com precisão seus componentes principais, os principais recursos e os casos de uso típicos, demonstra seu potencial para lidar com grandes bases de código.

Fluxo de trabalho principal: loop contínuo de depuração, edição e validação

Para dependência pesada VSCode Para os usuários do Code Agent, o ciclo de inteligências que executam alterações automaticamente, executam testes e fazem alterações novamente com base nos resultados é a chave para aumentar a eficiência.Gen-CLI Também é possível entrar nesse modo de "piloto automático"?

A tarefa do teste é fazer o Gen-CLI Adicione um teste de unidade para um arquivo no projeto. Em primeiro lugar, o corpo inteligente lê o arquivo em questão sem problemas.

> 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`                                                                                                           │
╰───────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╯

No caso de produtos não abertos --yolo(aprovação automática).Gen-CLI Ele solicitará que o usuário aprove as alterações no arquivo, assim como o Agente no editor.

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

No entanto, também foi constatado durante os testes queGen-CLI A chamada de ferramenta nem sempre é confiável. Às vezes, ele gera instruções erradas de chamada de ferramenta, causando a interrupção da tarefa.

╭─────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ✔  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.

Após alguma intervenção manual e muitas tentativasGen-CLI Por fim, você poderá entrar no loop Debug-Edit-Validate. Em contrapartida, o loopCursor talvez Aline Ferramentas como essas são mais fluentes no acionamento de loops automatizados. Isso pode ser devido ao seu tratamento superior da saída de linguagem natural não estruturada, tornando o acionamento de chamadas de ferramentas mais confiável em cenários de interação frequente, que é exatamente o que a Gen-CLI Orientações para aprimoramento futuro.

Aplicativo prático: Crie aplicativos Todo com um clique

aprovar (um projeto de lei ou inspeção etc.) --yolo O parâmetro aprova automaticamente todas as interações e pode testar Gen-CLI s de criação de projetos de ponta a ponta.

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

Depois que o comando for executado, você poderá ver que os arquivos relevantes foram criados com êxito:

% ls
app.js          index.html      styles.css

Abrir em seu navegador index.htmlUm aplicativo Todo com todos os recursos e tratamento de erros está pronto para ser executado.

Os não desenvolvedores também podem se beneficiar: automatizando as tarefas diárias

O valor do CLI Agent não se limita aos desenvolvedores. É uma grande conveniência para qualquer usuário que precise lidar com operações repetitivas de arquivos. Por exemplo, um cenário de reembolso financeiro envolve a combinação de PDFs de faturas próximas a um valor específico em uma pilha.

O uso de um GUI Agent pode exigir as seguintes etapas: abrir uma página da Web, inserir comandos, aguardar o processamento do modelo e verificar novamente os resultados, o que é um processo demorado e difícil de reutilizar. A vantagem do CLI Agent é sua capacidade de reutilização e programação. Uma série de comandos pode ser salva como um script, que pode ser executado com um único clique sempre que necessário, e o script pode até ser otimizado continuamente, o que não é possível com a operação manual da GUI.

seguintes Gen-CLI O processo real de lidar com essa tarefa:

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

Gen-CLI As etapas a seguir foram planejadas e implementadas de forma autônoma:

1. Ler o conteúdo da pastaLista de todos os documentos da fatura.
2. Aprender a usar ferramentasAprenda por conta própria e ligue para pdftotext para extrair texto de arquivos PDF.
3. processamento de dadosIdentificação de valores em diferentes moedas (USD e RMB) e conversão de taxas de câmbio.
4. análise combinatóriaCalcule todas as combinações possíveis de faturas e encontre a opção cujo valor total seja o mais próximo do valor-alvo de US$ 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)

Eventualmente.Gen-CLI Ele não apenas concluiu a tarefa com êxito, mas também forneceu uma combinação perfeita que estava apenas US$ 0,8 abaixo da meta. Esse exemplo demonstra o poder do CLI Agent na automação de tarefas diárias complexas.

Em conjunto, se o Claude Code e a capacidade do Estado Parte de cumprir suas obrigações nos termos da Convenção até o limite de 100 pontos.Gemini-CLI é de 80 pontos, então por DeepSeek orientado pela demanda Gen-CLI Atualmente, ele pode atingir uma pontuação de 70. Ele já é capaz de lidar com muitas tarefas complexas, embora ainda haja espaço para melhorias na estabilidade da invocação da ferramenta e na suavidade da interação, mas com a iteração contínua do modelo e da cadeia de ferramentas da CLI, vale a pena esperar seu desempenho futuro.

Gen-CLI O projeto é de código aberto no GitHub e planeja oferecer suporte a mais modelos no futuro. Usuários e desenvolvedores interessados são bem-vindos para contribuir.