mirror of
https://github.com/QwenLM/qwen-code.git
synced 2025-12-19 09:33:53 +00:00
add233c504
This commit introduces the initial codebase for the Gemini Code CLI, a command-line interface designed to facilitate interaction with the Gemini API for software engineering tasks.
The code was migrated from a previous git repository as a single squashed commit.
Core Features & Components:
* **Gemini Integration:** Leverages the `@google/genai` SDK to interact with the Gemini models, supporting chat history, streaming responses, and function calling (tools).
* **Terminal UI:** Built with Ink (React for CLIs) providing an interactive chat interface within the terminal, including input prompts, message display, loading indicators, and tool interaction elements.
* **Tooling Framework:** Implements a robust tool system allowing Gemini to interact with the local environment. Includes tools for:
* File system listing (`ls`)
* File reading (`read-file`)
* Content searching (`grep`)
* File globbing (`glob`)
* File editing (`edit`)
* File writing (`write-file`)
* Executing bash commands (`terminal`)
* **State Management:** Handles the streaming state of Gemini responses and manages the conversation history.
* **Configuration:** Parses command-line arguments (`yargs`) and loads environment variables (`dotenv`) for setup.
* **Project Structure:** Organized into `core`, `ui`, `tools`, `config`, and `utils` directories using TypeScript. Includes basic build (`tsc`) and start scripts.
This initial version establishes the foundation for a powerful CLI tool enabling developers to use Gemini for coding assistance directly in their terminal environment.
---
Created by yours truly: __Gemini Code__
73 lines
2.5 KiB
TypeScript
73 lines
2.5 KiB
TypeScript
import type { FunctionDeclaration, Schema } from '@google/genai';
|
|
import { ToolResult } from './ToolResult.js';
|
|
import { Tool } from './Tool.js';
|
|
import { ToolCallConfirmationDetails } from '../ui/types.js';
|
|
|
|
/**
|
|
* Base implementation for tools with common functionality
|
|
*/
|
|
export abstract class BaseTool<TParams = unknown, TResult extends ToolResult = ToolResult> implements Tool<TParams, TResult> {
|
|
/**
|
|
* Creates a new instance of BaseTool
|
|
* @param name Internal name of the tool (used for API calls)
|
|
* @param displayName User-friendly display name of the tool
|
|
* @param description Description of what the tool does
|
|
* @param parameterSchema JSON Schema defining the parameters
|
|
*/
|
|
constructor(
|
|
public readonly name: string,
|
|
public readonly displayName: string,
|
|
public readonly description: string,
|
|
public readonly parameterSchema: Record<string, unknown>
|
|
) {}
|
|
|
|
/**
|
|
* Function declaration schema computed from name, description, and parameterSchema
|
|
*/
|
|
get schema(): FunctionDeclaration {
|
|
return {
|
|
name: this.name,
|
|
description: this.description,
|
|
parameters: this.parameterSchema as Schema
|
|
};
|
|
}
|
|
|
|
/**
|
|
* Validates the parameters for the tool
|
|
* This is a placeholder implementation and should be overridden
|
|
* @param params Parameters to validate
|
|
* @returns An error message string if invalid, null otherwise
|
|
*/
|
|
invalidParams(params: TParams): string | null {
|
|
// Implementation would typically use a JSON Schema validator
|
|
// This is a placeholder that should be implemented by derived classes
|
|
return null;
|
|
}
|
|
|
|
/**
|
|
* Gets a pre-execution description of the tool operation
|
|
* Default implementation that should be overridden by derived classes
|
|
* @param params Parameters for the tool execution
|
|
* @returns A markdown string describing what the tool will do
|
|
*/
|
|
getDescription(params: TParams): string {
|
|
return JSON.stringify(params);
|
|
}
|
|
|
|
/**
|
|
* Determines if the tool should prompt for confirmation before execution
|
|
* @param params Parameters for the tool execution
|
|
* @returns Whether or not execute should be confirmed by the user.
|
|
*/
|
|
shouldConfirmExecute(params: TParams): Promise<ToolCallConfirmationDetails | false> {
|
|
return Promise.resolve(false);
|
|
}
|
|
|
|
/**
|
|
* Abstract method to execute the tool with the given parameters
|
|
* Must be implemented by derived classes
|
|
* @param params Parameters for the tool execution
|
|
* @returns Result of the tool execution
|
|
*/
|
|
abstract execute(params: TParams): Promise<TResult>;
|
|
} |