Download packages/cli/src/acp/acpCommandHandler.ts from SaylorTwift/gemini-cli: direct link, hf CLI and curl.
- Browser
- Download file 4.08 kB
-
https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/cli/src/acp/acpCommandHandler.ts
- Command line
-
hf download hf://SaylorTwift/gemini-cli/packages/cli/src/acp/acpCommandHandler.ts
-
curl -L -o acpCommandHandler.ts https://huggingface.co/SaylorTwift/gemini-cli/resolve/main/packages/cli/src/acp/acpCommandHandler.ts
4.08 kB
| /** | |
| * @license | |
| * Copyright 2026 Google LLC | |
| * SPDX-License-Identifier: Apache-2.0 | |
| */ | |
| import type { Command, CommandContext } from './commands/types.js'; | |
| import { CommandRegistry } from './commands/commandRegistry.js'; | |
| import { MemoryCommand } from './commands/memory.js'; | |
| import { ExtensionsCommand } from './commands/extensions.js'; | |
| import { InitCommand } from './commands/init.js'; | |
| import { RestoreCommand } from './commands/restore.js'; | |
| import { AboutCommand } from './commands/about.js'; | |
| import { HelpCommand } from './commands/help.js'; | |
| export class CommandHandler { | |
| private registry: CommandRegistry; | |
| constructor() { | |
| this.registry = CommandHandler.createRegistry(); | |
| } | |
| private static createRegistry(): CommandRegistry { | |
| const registry = new CommandRegistry(); | |
| registry.register(new MemoryCommand()); | |
| registry.register(new ExtensionsCommand()); | |
| registry.register(new InitCommand()); | |
| registry.register(new RestoreCommand()); | |
| registry.register(new AboutCommand()); | |
| registry.register(new HelpCommand(registry)); | |
| return registry; | |
| } | |
| getAvailableCommands(): Array<{ name: string; description: string }> { | |
| return this.registry.getAllCommands().map((cmd) => ({ | |
| name: cmd.name, | |
| description: cmd.description, | |
| })); | |
| } | |
| /** | |
| * Parses and executes a command string if it matches a registered command. | |
| * Returns true if a command was handled, false otherwise. | |
| */ | |
| async handleCommand( | |
| commandText: string, | |
| context: CommandContext, | |
| ): Promise<boolean> { | |
| const { commandToExecute, args } = this.parseSlashCommand(commandText); | |
| if (commandToExecute) { | |
| await this.runCommand(commandToExecute, args, context); | |
| return true; | |
| } | |
| return false; | |
| } | |
| private async runCommand( | |
| commandToExecute: Command, | |
| args: string, | |
| context: CommandContext, | |
| ): Promise<void> { | |
| try { | |
| const result = await commandToExecute.execute( | |
| context, | |
| args ? args.split(/\s+/) : [], | |
| ); | |
| let messageContent = ''; | |
| if (typeof result.data === 'string') { | |
| messageContent = result.data; | |
| } else if ( | |
| typeof result.data === 'object' && | |
| result.data !== null && | |
| 'content' in result.data | |
| ) { | |
| // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion, @typescript-eslint/no-explicit-any | |
| messageContent = (result.data as Record<string, any>)[ | |
| 'content' | |
| ] as string; | |
| } else { | |
| messageContent = JSON.stringify(result.data, null, 2); | |
| } | |
| await context.sendMessage(messageContent); | |
| } catch (error) { | |
| const errorMessage = | |
| error instanceof Error ? error.message : String(error); | |
| await context.sendMessage(`Error: ${errorMessage}`); | |
| } | |
| } | |
| /** | |
| * Parses a raw slash command string into its matching headless command and arguments. | |
| * Mirrors `packages/cli/src/utils/commands.ts` logic. | |
| */ | |
| private parseSlashCommand(query: string): { | |
| commandToExecute: Command | undefined; | |
| args: string; | |
| } { | |
| const trimmed = query.trim(); | |
| const parts = trimmed.substring(1).trim().split(/\s+/); | |
| const commandPath = parts.filter((p) => p); | |
| let currentCommands = this.registry.getAllCommands(); | |
| let commandToExecute: Command | undefined; | |
| let pathIndex = 0; | |
| for (const part of commandPath) { | |
| const foundCommand = currentCommands.find((cmd) => { | |
| const expectedName = commandPath.slice(0, pathIndex + 1).join(' '); | |
| return ( | |
| cmd.name === part || | |
| cmd.name === expectedName || | |
| cmd.aliases?.includes(part) || | |
| cmd.aliases?.includes(expectedName) | |
| ); | |
| }); | |
| if (foundCommand) { | |
| commandToExecute = foundCommand; | |
| pathIndex++; | |
| if (foundCommand.subCommands) { | |
| currentCommands = foundCommand.subCommands; | |
| } else { | |
| break; | |
| } | |
| } else { | |
| break; | |
| } | |
| } | |
| const args = parts.slice(pathIndex).join(' '); | |
| return { commandToExecute, args }; | |
| } | |
| } | |