@biggora/claude-plugins 1.2.0 → 1.3.0

package/gemini-cli-workspace/iteration-2/eval-2-mcp-server-config/without_skill/outputs/response.md

@@ -1,164 +0,0 @@
-# Connecting a Custom Python MCP Server to Gemini CLI
-
-## Configuration File Location
-
-Gemini CLI reads MCP server configuration from `settings.json` at two levels:
-
-- **Global (user-level):** `~/.gemini/settings.json` -- applies to all Gemini CLI sessions
-- **Project-level:** `.gemini/settings.json` in your project root -- applies only when running from that project
-
-Project-level settings override global ones.
-
-## Full Configuration Example
-
-Here is how to configure a custom Python MCP server with an API key from your environment and tool filtering:
-
-```json
-{
-  "mcpServers": {
-    "my-python-server": {
-      "command": "python",
-      "args": ["path/to/your/server.py"],
-      "env": {
-        "API_KEY": "$MY_API_KEY"
-      },
-      "cwd": "/path/to/server/directory",
-      "timeout": 30000,
-      "includeTools": ["allowed_tool_1", "allowed_tool_2", "allowed_tool_3"]
-    }
-  }
-}
-```
-
-## Explanation of Each Property
-
-### Required (choose one transport)
-
-| Property | Description |
-|----------|-------------|
-| `command` | Path to the executable for stdio transport (e.g., `"python"`, `"node"`) |
-| `url` | SSE endpoint URL for remote servers (e.g., `"http://localhost:8080/sse"`) |
-| `httpUrl` | HTTP streaming endpoint URL |
-
-### Optional Properties
-
-| Property | Type | Description |
-|----------|------|-------------|
-| `args` | string[] | Command-line arguments passed to the server process |
-| `env` | object | Environment variables to pass to the server (supports expansion) |
-| `cwd` | string | Working directory for the server process |
-| `timeout` | number | Request timeout in milliseconds (default: 600,000ms / 10 minutes) |
-| `trust` | boolean | When `true`, bypasses tool confirmation prompts |
-| `includeTools` | string[] | Allowlist -- only these tools will be available |
-| `excludeTools` | string[] | Blocklist -- these tools will be hidden from the model |
-| `headers` | object | Custom HTTP headers (for remote transports) |
-
-## Passing the API Key via Environment Variables
-
-Gemini CLI supports environment variable expansion in the `env` block using two syntaxes:
-
-```json
-"env": {
-  "API_KEY": "$MY_API_KEY",
-  "OTHER_SECRET": "${ANOTHER_ENV_VAR}"
-}
-```
-
-Both `$VAR_NAME` and `${VAR_NAME}` are supported. At runtime, Gemini CLI reads the value of `MY_API_KEY` from your host shell environment and passes it to the MCP server process.
-
-**Security note:** Gemini CLI automatically redacts environment variables to prevent leakage. However, variables you explicitly declare in the `env` block are considered trusted (since you intentionally configured them) and will not be redacted when passed to that specific server. You must explicitly list any environment variable that the server needs -- variables are not inherited automatically.
-
-## Restricting Exposed Tools
-
-Gemini CLI provides two complementary mechanisms for tool filtering:
-
-### Allowlist with `includeTools`
-
-Only the tools listed here will be available from that server. All other tools the server exposes will be hidden:
-
-```json
-"includeTools": ["query_data", "get_status", "run_analysis"]
-```
-
-### Blocklist with `excludeTools`
-
-Tools listed here will be hidden, even if the server exposes them:
-
-```json
-"excludeTools": ["delete_records", "admin_reset"]
-```
-
-### Precedence Rule
-
-`excludeTools` takes precedence over `includeTools`. If a tool appears in both lists, it will be excluded.
-
-### Choosing an Approach
-
-- Use `includeTools` when your server exposes many tools but you only want a specific subset available (allowlist approach).
-- Use `excludeTools` when you want most tools available but need to block a few dangerous ones (blocklist approach).
-- You can combine both for fine-grained control.
-
-## Complete Practical Example
-
-Suppose you built a Python MCP server at `~/mcp-servers/my_api_server.py` that exposes tools `fetch_data`, `analyze`, `delete_all`, and `export_csv`. You want to pass your API key and only allow `fetch_data` and `analyze`.
-
-Create or edit `~/.gemini/settings.json`:
-
-```json
-{
-  "mcpServers": {
-    "my-api-server": {
-      "command": "python",
-      "args": ["/home/user/mcp-servers/my_api_server.py"],
-      "env": {
-        "API_KEY": "$MY_API_KEY"
-      },
-      "timeout": 30000,
-      "includeTools": ["fetch_data", "analyze"]
-    }
-  }
-}
-```
-
-Make sure `MY_API_KEY` is set in your shell environment (e.g., in `~/.bashrc` or `~/.zshrc`):
-
-```bash
-export MY_API_KEY="your-secret-key-here"
-```
-
-### Using FastMCP
-
-If your Python server uses FastMCP (the recommended approach for Python MCP servers), the configuration would look like:
-
-```json
-{
-  "mcpServers": {
-    "my-api-server": {
-      "command": "uv",
-      "args": ["run", "--with", "fastmcp", "fastmcp", "run", "my_server.py"],
-      "cwd": "/home/user/mcp-servers",
-      "env": {
-        "API_KEY": "$MY_API_KEY"
-      },
-      "includeTools": ["fetch_data", "analyze"]
-    }
-  }
-}
-```
-
-### Using the CLI to Add a Server
-
-You can also add a server via the command line instead of editing `settings.json` manually:
-
-```bash
-gemini mcp add my-api-server -e API_KEY=$MY_API_KEY python /home/user/mcp-servers/my_api_server.py
-```
-
-Note: Tool filtering (`includeTools`/`excludeTools`) must be configured by editing `settings.json` directly, as the CLI `add` command may not support these options as flags.
-
-## Sources
-
-- [MCP servers with the Gemini CLI (official docs)](https://google-gemini.github.io/gemini-cli/docs/tools/mcp-server.html)
-- [Gemini CLI configuration reference](https://google-gemini.github.io/gemini-cli/docs/get-started/configuration.html)
-- [Gemini CLI + FastMCP integration (Google Developers Blog)](https://developers.googleblog.com/en/gemini-cli-fastmcp-simplifying-mcp-server-development/)
-- [MCP server docs on GitHub](https://github.com/google-gemini/gemini-cli/blob/main/docs/tools/mcp-server.md)

package/gemini-cli-workspace/iteration-2/eval-2-mcp-server-config/without_skill/timing.json

@@ -1,5 +0,0 @@
-{
-  "total_tokens": 61417,
-  "duration_ms": 86655,
-  "total_duration_seconds": 86.7
-}

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/eval_metadata.json

@@ -1,32 +0,0 @@
-{
-  "eval_id": 3,
-  "eval_name": "custom-slash-command",
-  "prompt": "How do I create a custom slash command in gemini cli that runs git diff --cached and asks the AI to write a commit message? I want it available in all my projects.",
-  "assertions": [
-    {
-      "id": "correct-file-location",
-      "text": "Points to ~/.gemini/commands/ for global user-scoped commands",
-      "type": "content_check"
-    },
-    {
-      "id": "toml-format",
-      "text": "Shows .toml file format with prompt field",
-      "type": "content_check"
-    },
-    {
-      "id": "shell-execution-syntax",
-      "text": "Uses !{git diff --cached} shell execution syntax in the prompt",
-      "type": "content_check"
-    },
-    {
-      "id": "mentions-headless-limitation",
-      "text": "Warns that custom slash commands don't work in headless/non-interactive mode",
-      "type": "content_check"
-    },
-    {
-      "id": "complete-working-example",
-      "text": "Provides a complete, copy-pasteable .toml file example",
-      "type": "content_check"
-    }
-  ]
-}

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/with_skill/grading.json

@@ -1,32 +0,0 @@
-{
-  "eval_id": 3,
-  "eval_name": "custom-slash-command",
-  "config": "with_skill",
-  "expectations": [
-    {
-      "text": "Points to ~/.gemini/commands/ for global user-scoped commands",
-      "passed": true,
-      "evidence": "States 'Create the file ~/.gemini/commands/commit.toml' and explains ~/.gemini/commands/ is user-scoped"
-    },
-    {
-      "text": "Shows .toml file format with prompt field",
-      "passed": true,
-      "evidence": "Complete .toml example with description and prompt fields using triple-quoted string"
-    },
-    {
-      "text": "Uses !{git diff --cached} shell execution syntax in the prompt",
-      "passed": true,
-      "evidence": "Uses !{git diff --cached} in the prompt field and explains the !{...} syntax is shell execution interpolation"
-    },
-    {
-      "text": "Warns that custom slash commands don't work in headless/non-interactive mode",
-      "passed": true,
-      "evidence": "Important notes section: 'Custom slash commands work in interactive mode only. They are not available in headless mode (-p flag).'"
-    },
-    {
-      "text": "Provides a complete, copy-pasteable .toml file example",
-      "passed": true,
-      "evidence": "Complete commit.toml file with description and prompt fields, ready to copy-paste"
-    }
-  ]
-}

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/with_skill/outputs/response.md

@@ -1,91 +0,0 @@
-# Creating a Global Custom Slash Command for Commit Messages in Gemini CLI
-
-To create a custom slash command that runs `git diff --cached` and asks the AI to write a commit message, available across all your projects, create a single `.toml` file in your user-scoped commands directory.
-
-## Step-by-Step
-
-### 1. Create the commands directory (if it doesn't exist)
-
-```bash
-mkdir -p ~/.gemini/commands
-```
-
-### 2. Create the slash command file
-
-Create the file `~/.gemini/commands/commit.toml`:
-
-```toml
-description = "Generate a commit message from staged changes"
-prompt = """
-Based on the following staged git diff, write a concise and descriptive commit message following conventional commit format (e.g., feat:, fix:, refactor:, docs:, chore:).
-
-The first line should be a short summary (50 chars or less). If needed, add a blank line followed by a more detailed explanation.
-
-Staged changes:
-!{git diff --cached}
-"""
-```
-
-### How it works
-
-- **File location**: `~/.gemini/commands/commit.toml` -- placing it under `~/.gemini/commands/` makes it user-scoped, meaning it is available in every project you open with Gemini CLI.
-- **`!{git diff --cached}`**: The `!{...}` syntax is shell execution interpolation. When the slash command runs, Gemini CLI executes `git diff --cached` and substitutes the output directly into the prompt before sending it to the model.
-- **`description`**: Optional but recommended. It shows up when you run `/help` to list available commands.
-- **`prompt`**: The full prompt template sent to the model, with the shell output injected.
-
-### 3. Use the command
-
-Start an interactive Gemini CLI session in any git repository:
-
-```bash
-gemini
-```
-
-Then stage your changes and invoke the command:
-
-```
-> /commit
-```
-
-Gemini will run `git diff --cached`, inject the diff into the prompt, and return a suggested commit message.
-
-## Variations
-
-### Accept an argument for extra context
-
-If you want to optionally pass additional context (e.g., a ticket number or description):
-
-```toml
-description = "Generate a commit message from staged changes"
-prompt = """
-Based on the following staged git diff, write a concise commit message.
-
-Additional context from the user: {{args}}
-
-Staged changes:
-!{git diff --cached}
-"""
-```
-
-Usage: `/commit JIRA-1234 add user validation`
-
-The `{{args}}` placeholder captures everything typed after `/commit`.
-
-### Namespaced command
-
-If you prefer organizing under a `git` namespace, place the file at:
-
-```
-~/.gemini/commands/git/commit.toml
-```
-
-Then invoke it as `/git:commit` in the interactive session.
-
-## Important notes
-
-- Custom slash commands work in **interactive mode only**. They are not available in headless mode (`-p` flag). For headless commit message generation, pipe the diff directly:
-  ```bash
-  git diff --cached | gemini -p "Write a concise commit message" --output-format json | jq -r '.response'
-  ```
-- The command runs in whatever directory you launched `gemini` from, so `git diff --cached` will pick up the correct repository context automatically.
-- If there are no staged changes, the diff output will be empty, and the model will tell you there is nothing to generate a message for.

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/with_skill/timing.json

@@ -1,5 +0,0 @@
-{
-  "total_tokens": 63047,
-  "duration_ms": 43718,
-  "total_duration_seconds": 43.7
-}

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/without_skill/grading.json

@@ -1,32 +0,0 @@
-{
-  "eval_id": 3,
-  "eval_name": "custom-slash-command",
-  "config": "without_skill",
-  "expectations": [
-    {
-      "text": "Points to ~/.gemini/commands/ for global user-scoped commands",
-      "passed": true,
-      "evidence": "States '~/.gemini/commands/' as global location in both instructions and summary table"
-    },
-    {
-      "text": "Shows .toml file format with prompt field",
-      "passed": true,
-      "evidence": "Complete .toml example with description and prompt fields"
-    },
-    {
-      "text": "Uses !{git diff --cached} shell execution syntax in the prompt",
-      "passed": true,
-      "evidence": "Uses !{git diff --cached} in the prompt field and explains the shell command injection block syntax"
-    },
-    {
-      "text": "Warns that custom slash commands don't work in headless/non-interactive mode",
-      "passed": false,
-      "evidence": "No mention of headless mode limitations anywhere in the response. Missing this critical caveat."
-    },
-    {
-      "text": "Provides a complete, copy-pasteable .toml file example",
-      "passed": true,
-      "evidence": "Complete commit.toml file at ~/.gemini/commands/commit.toml with description and prompt fields"
-    }
-  ]
-}

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/without_skill/outputs/response.md

@@ -1,112 +0,0 @@
-# Creating a Custom Slash Command in Gemini CLI for Commit Messages
-
-Gemini CLI supports custom slash commands defined as `.toml` files. To make a command available across all your projects, place the file in the **global** commands directory: `~/.gemini/commands/`.
-
-## Step-by-Step Setup
-
-### 1. Create the commands directory (if it does not exist)
-
-```bash
-mkdir -p ~/.gemini/commands
-```
-
-### 2. Create the command file
-
-Create the file `~/.gemini/commands/commit.toml`:
-
-```toml
-description = "Generate a commit message from staged changes"
-prompt = """Review the following staged git diff and write a clear, conventional commit message for it. Follow the Conventional Commits format (e.g., feat:, fix:, refactor:, docs:, chore:). Include a concise subject line (max 72 characters) and, if the changes are non-trivial, a body that explains the "why" behind the changes.
-
-```diff
-!{git diff --cached}
-```"""
-```
-
-This creates the slash command `/commit`.
-
-### How It Works
-
-- **`description`** -- A one-line summary shown when you run `/help` inside Gemini CLI.
-- **`prompt`** -- The full prompt sent to the Gemini model. The `!{git diff --cached}` syntax is a **shell command injection block**. When the command runs, Gemini CLI executes `git diff --cached` in your shell, captures the output, and injects it directly into the prompt at that location.
-- **Security note** -- The first time a shell command inside `!{...}` runs, Gemini CLI will prompt you for confirmation before executing it.
-
-### 3. Reload commands (if Gemini CLI is already running)
-
-Inside an active Gemini CLI session, run:
-
-```
-/commands reload
-```
-
-This picks up new or modified `.toml` files without restarting the CLI.
-
-### 4. Usage
-
-Stage your changes and invoke the command:
-
-```bash
-git add -p                # stage your changes
-gemini                    # start Gemini CLI
-```
-
-Then inside the Gemini CLI session:
-
-```
-/commit
-```
-
-Gemini will read your staged diff, analyze the changes, and generate a commit message for you.
-
-## Namespaced Variant
-
-If you prefer organizing your commands by category, use subdirectories. For example, placing the file at:
-
-```
-~/.gemini/commands/git/commit.toml
-```
-
-makes it available as `/git:commit` instead of `/commit`. Subdirectory separators are converted to colons in the command name.
-
-## Adding Arguments Support
-
-You can extend the command to accept optional context using `{{args}}`:
-
-```toml
-description = "Generate a commit message from staged changes with optional context"
-prompt = """Review the following staged git diff and write a clear, conventional commit message. Follow the Conventional Commits format (e.g., feat:, fix:, refactor:).
-
-Additional context from the developer: {{args}}
-
-```diff
-!{git diff --cached}
-```"""
-```
-
-This allows you to provide extra context when invoking the command:
-
-```
-/commit This change addresses the performance regression in the auth module
-```
-
-The `{{args}}` placeholder gets replaced with whatever text you type after the command name. Inside `!{...}` blocks, arguments are automatically shell-escaped for safety.
-
-## Summary of Key Concepts
-
-| Concept | Detail |
-|---|---|
-| Global location | `~/.gemini/commands/` |
-| Project location | `<project-root>/.gemini/commands/` |
-| File format | TOML (`.toml` extension) |
-| Shell execution | `!{command}` syntax, requires confirmation |
-| Arguments | `{{args}}` placeholder |
-| File injection | `@{path/to/file}` syntax |
-| Namespacing | Subdirectories map to colon-separated names |
-| Precedence | Project commands override global commands with the same name |
-
-## Sources
-
-- [Custom commands - Gemini CLI Documentation](https://geminicli.com/docs/cli/custom-commands/)
-- [Gemini CLI: Custom slash commands - Google Cloud Blog](https://cloud.google.com/blog/topics/developers-practitioners/gemini-cli-custom-slash-commands)
-- [CLI Commands - Gemini CLI](https://google-gemini.github.io/gemini-cli/docs/cli/commands.html)
-- [Gemini CLI Tutorial Series Part 7: Custom slash commands - Medium](https://medium.com/google-cloud/gemini-cli-tutorial-series-part-7-custom-slash-commands-64c06195294b)

package/gemini-cli-workspace/iteration-2/eval-3-custom-slash-command/without_skill/timing.json

@@ -1,5 +0,0 @@
-{
-  "total_tokens": 59908,
-  "duration_ms": 73576,
-  "total_duration_seconds": 73.6
-}