# Copilot CLI vs Gemini CLI Tool Names for OpenAI Plugins: Complete Mapping Guide

> Understand Copilot CLI vs Gemini CLI tool names for OpenAI plugins. This guide maps actions like view/create/edit to read_file/write_file/replace, clarifying their function.

- Repository: [OpenAI/plugins](https://github.com/openai/plugins)
- Tags: comparison-guide
- Published: 2026-06-19

---

**Copilot CLI uses `view`, `create`, and `edit` while Gemini CLI uses `read_file`, `write_file`, and `replace` for the same generic plugin actions defined in the OpenAI Plugins repository.**

The OpenAI Plugins repository defines skills using generic Claude Code tool names like `Read`, `Write`, and `Bash`. When these plugins execute on specific platforms, the Superpowers framework translates these generic commands into platform-specific CLI tool names automatically using data-driven mapping tables.

## Generic Tool Names in OpenAI Plugins

Plugin skills in the OpenAI Plugins repository are authored once using standardized **Claude Code** tool names. These generic abstractions include common operations like `Read` for file access, `Write` for file creation, `Edit` for modifications, and `Bash` for command execution.

According to the source code in [`plugins/superpowers/skills/using-superpowers/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/using-superpowers/SKILL.md), these generic names serve as the universal interface for skill definitions. When a skill runs on a specific platform, the Superpowers framework inspects the active CLI environment and substitutes the generic tool calls with the appropriate platform-specific equivalents.

## Copilot CLI Tool Name Mapping

The GitHub Copilot CLI mapping lives in [`plugins/superpowers/skills/using-superpowers/references/copilot-tools.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/using-superpowers/references/copilot-tools.md). Key translations include:

- **`Read`** → `view` (file reading)
- **`Write`** → `create` (file creation)
- **`Edit`** → `edit` (file editing)
- **`Bash`** → `bash` (command execution)
- **`Grep`** → `grep` (content search)
- **`Glob`** → `glob` (filename search)
- **`Task`** → `task` (sub-agent dispatch)
- **`TodoWrite`** → `sql` (SQLite operations on todos table)
- **`WebSearch`** → `web_fetch` with search-engine URLs

Copilot CLI also supports **async shell sessions** through additional tools like `write_bash` and `read_bash`, allowing long-running commands to execute without blocking the skill.

## Gemini CLI Tool Name Mapping

The Gemini CLI mapping is maintained in [`plugins/superpowers/skills/using-superpowers/references/gemini-tools.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/using-superpowers/references/gemini-tools.md). The platform uses more verbose, descriptive tool names:

- **`Read`** → `read_file`
- **`Write`** → `write_file`
- **`Edit`** → `replace`
- **`Bash`** → `run_shell_command`
- **`Grep`** → `grep_search`
- **`Glob`** → `glob`
- **`Task`** → `@agent-name` syntax (e.g., `@generalist`)
- **`TodoWrite`** → `write_todos`
- **`WebSearch`** → `google_web_search`

Unlike Copilot CLI, Gemini CLI **does not support async shell sessions**—all commands run synchronously.

## Key Differences Between Copilot CLI and Gemini CLI

Several functional gaps exist beyond simple naming conventions:

**Sub-agent Dispatch**: Copilot CLI uses the `task` tool with a skill identifier, while Gemini CLI requires the `@agent-name` syntax (e.g., `@generalist`) with the prompt passed as an argument.

**Todo Management**: Copilot CLI translates `TodoWrite` into raw SQLite statements against a `todos` table, whereas Gemini CLI provides the dedicated `write_todos` command.

**Web Search**: Copilot CLI has no native web search tool; the Superpowers framework falls back to `web_fetch` with search-engine URLs. Gemini CLI exposes `google_web_search` directly.

**Async Operations**: Only Copilot CLI supports asynchronous shell execution through `write_bash` and `read_bash`. Gemini CLI lacks async shell capabilities entirely.

## How Tool Name Translation Works at Runtime

The translation mechanism follows a four-step architectural flow implemented in the Superpowers skill:

1. **Platform Detection**: The framework identifies whether the skill is running on Copilot CLI, Gemini CLI, or another supported platform.

2. **Table Lookup**: Based on the detected platform, the system loads either [`copilot-tools.md`](https://github.com/openai/plugins/blob/main/copilot-tools.md) or [`gemini-tools.md`](https://github.com/openai/plugins/blob/main/gemini-tools.md) from the `references` directory.

3. **Name Substitution**: Generic Claude Code tool names are replaced with platform-specific equivalents before command execution.

4. **Execution**: The translated command runs in the target CLI environment, with results returned to the skill's prompt context.

Because the mapping is data-driven, adding support for a new CLI only requires creating a new reference table; the core skill code in [`SKILL.md`](https://github.com/openai/plugins/blob/main/SKILL.md) remains unchanged.

## Code Examples: Generic Skills to Platform-Specific Commands

### Reading a File

Generic skill request:

```text
Read path/to/file.txt

```

Copilot CLI translation:

```bash
view path/to/file.txt

```

Gemini CLI translation:

```bash
read_file path/to/file.txt

```

### Writing a File

Generic skill request:

```text
Write path/to/file.txt "Content here"

```

Copilot CLI execution:

```bash
create path/to/file.txt "Content here"

```

Gemini CLI execution:

```bash
write_file path/to/file.txt "Content here"

```

### Running Shell Commands

Generic skill request:

```text
Bash echo "Hello, world!"

```

Copilot CLI (with async support):

```bash
bash async:true "echo 'Hello, world!'"

```

Gemini CLI (synchronous only):

```bash
run_shell_command "echo 'Hello, world!'"

```

### Dispatching Sub-agents

Generic skill request:

```text
Task superpowers:code-reviewer <<PROMPT>>

```

Copilot CLI translation:

```bash
task superpowers:code-reviewer <<PROMPT>>

```

Gemini CLI translation:

```bash
@generalist "You are a code reviewer. <<PROMPT>>"

```

### Updating Task Tracking

Generic skill request:

```text
TodoWrite "Fix typo in README"

```

Copilot CLI (SQLite approach):

```bash
sql "INSERT INTO todos (title) VALUES ('Fix typo in README')"

```

Gemini CLI (dedicated tool):

```bash
write_todos "Fix typo in README"

```

## Summary

- **Copilot CLI** uses short commands like `view`, `create`, and `edit`, while **Gemini CLI** uses descriptive names like `read_file`, `write_file`, and `replace`.
- The OpenAI Plugins repository stores canonical mappings in [`copilot-tools.md`](https://github.com/openai/plugins/blob/main/copilot-tools.md) and [`gemini-tools.md`](https://github.com/openai/plugins/blob/main/gemini-tools.md) within the `references` directory.
- Skills are authored once using generic Claude Code tool names, then translated at runtime by the Superpowers skill.
- Copilot CLI supports async shell sessions (`write_bash`, `read_bash`) and SQLite-based todos, while Gemini CLI runs commands synchronously and uses dedicated tools like `write_todos` and `google_web_search`.

## Frequently Asked Questions

### Where are the Copilot CLI and Gemini CLI tool mappings stored?

The mappings live in the `references` directory of the Superpowers skill. Specifically, [`plugins/superpowers/skills/using-superpowers/references/copilot-tools.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/using-superpowers/references/copilot-tools.md) contains the Copilot CLI translations, and [`plugins/superpowers/skills/using-superpowers/references/gemini-tools.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/using-superpowers/references/gemini-tools.md) contains the Gemini CLI equivalents.

### Why do the same plugin skills use different commands on different CLIs?

The OpenAI Plugins architecture uses generic **Claude Code** tool names (like `Read` and `Write`) as a universal abstraction. When skills execute, the Superpowers framework consults platform-specific lookup tables to translate these generic names into the actual CLI commands available on Copilot CLI or Gemini CLI, ensuring compatibility without rewriting skill logic.

### How does async bash execution differ between Copilot CLI and Gemini CLI?

Copilot CLI supports asynchronous shell sessions through dedicated tools like `write_bash` and `read_bash`, allowing skills to execute long-running commands without blocking. Gemini CLI lacks async shell capabilities entirely—all commands run synchronously using `run_shell_command`.

### Where is the translation logic implemented in the source code?

The runtime translation logic is implemented in [`plugins/superpowers/skills/using-superpowers/SKILL.md`](https://github.com/openai/plugins/blob/main/plugins/superpowers/skills/using-superpowers/SKILL.md). This file handles platform detection, loads the appropriate reference table (either Copilot or Gemini), and performs the substitution of generic tool names to platform-specific CLI commands before execution.