@biggora/claude-plugins 1.2.0 → 1.2.2

package/gemini-cli-workspace/iteration-1/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-1/eval-3-custom-slash-command/with_skill/grading.json

@@ -1,32 +0,0 @@
-{
-  "eval_id": 3,
-  "eval_name": "custom-slash-command",
-  "configuration": "with_skill",
-  "expectations": [
-    {
-      "text": "Points to ~/.gemini/commands/ for global user-scoped commands",
-      "passed": true,
-      "evidence": "Correctly points to `~/.gemini/commands/commit.toml` for global scope"
-    },
-    {
-      "text": "Shows .toml file format with prompt field",
-      "passed": true,
-      "evidence": "Full .toml example with description and prompt fields"
-    },
-    {
-      "text": "Uses !{git diff --cached} shell execution syntax in the prompt",
-      "passed": true,
-      "evidence": "Correctly uses `!{git diff --cached}` in the prompt field"
-    },
-    {
-      "text": "Warns that custom slash commands don't work in headless/non-interactive mode",
-      "passed": true,
-      "evidence": "Explicitly warns: 'custom slash commands currently do not work in headless mode (`-p` flag)' and provides shell script alternative"
-    },
-    {
-      "text": "Provides a complete, copy-pasteable .toml file example",
-      "passed": true,
-      "evidence": "Multiple complete .toml examples including basic, namespaced, and with-arguments variants"
-    }
-  ]
-}

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

@@ -1,171 +0,0 @@
-# Creating a Global Custom Slash Command for AI Commit Messages in Gemini CLI
-
-You can create a custom slash command by writing a `.toml` file in the global commands directory. Since you want it available in all your projects, place it under `~/.gemini/commands/`.
-
-## Step 1: Create the Commands Directory
-
-```bash
-mkdir -p ~/.gemini/commands
-```
-
-## Step 2: Create the Slash Command TOML File
-
-Create the file `~/.gemini/commands/commit.toml`:
-
-```toml
-description = "Generate a commit message from staged changes"
-prompt = """
-Write a concise conventional commit message for the following staged changes.
-
-Use the format: <type>(<scope>): <description>
-
-Where type is one of: feat, fix, docs, style, refactor, test, chore
-
-Only output the commit message itself, nothing else.
-
-Staged diff:
-!{git diff --cached}
-"""
-```
-
-### How This Works
-
-- The `prompt` field defines the instruction sent to Gemini when the command is invoked.
-- `!{git diff --cached}` is a **shell execution block** -- Gemini CLI runs the shell command inside `!{...}` and inlines its output into the prompt before sending it to the model.
-- `description` is optional but shows up when you run `/help` in an interactive session.
-
-## Step 3: Use the Command
-
-Start Gemini CLI in any project that has staged git changes:
-
-```bash
-cd your-project
-git add -A   # or stage specific files
-gemini
-```
-
-Then in the interactive session, type:
-
-```
-/commit
-```
-
-Gemini will execute `git diff --cached`, include the diff in the prompt, and return a conventional commit message.
-
-## Namespaced Alternative
-
-If you prefer a namespaced command like `/git:commit`, use a subdirectory:
-
-```bash
-mkdir -p ~/.gemini/commands/git
-```
-
-Create `~/.gemini/commands/git/commit.toml`:
-
-```toml
-description = "Generate a commit message from staged changes"
-prompt = """
-Write a concise conventional commit message for the following staged changes.
-
-Use the format: <type>(<scope>): <description>
-
-Where type is one of: feat, fix, docs, style, refactor, test, chore
-
-Only output the commit message itself, nothing else.
-
-Staged diff:
-!{git diff --cached}
-"""
-```
-
-Then invoke it with:
-
-```
-/git:commit
-```
-
-## Using It with Arguments
-
-You can also make the command accept arguments with `{{args}}` to allow the user to pass additional context:
-
-```toml
-description = "Generate a commit message from staged changes with optional context"
-prompt = """
-Write a concise conventional commit message for the following staged changes.
-
-Use the format: <type>(<scope>): <description>
-
-Where type is one of: feat, fix, docs, style, refactor, test, chore
-
-Additional context from the user: {{args}}
-
-Only output the commit message itself, nothing else.
-
-Staged diff:
-!{git diff --cached}
-"""
-```
-
-This lets you provide extra hints:
-
-```
-/commit focus on the auth refactoring
-```
-
-## Fully Automated Shell Script (Bonus)
-
-If you want to go beyond interactive mode and automate the entire commit flow from your shell, you can create a shell script. Note that custom slash commands currently do **not** work in headless mode (`-p` flag), so for automation you need to embed the prompt directly:
-
-```bash
-#!/bin/bash
-# Save as ~/bin/ai-commit or anywhere on your PATH
-
-DIFF=$(git diff --cached)
-
-if [ -z "$DIFF" ]; then
-  echo "Error: Nothing staged. Run 'git add' first."
-  exit 1
-fi
-
-MSG=$(echo "$DIFF" | gemini -p "Write a concise conventional commit message (type(scope): description format, max 72 chars). Only output the message, nothing else." --output-format json | jq -r '.response')
-
-if [ -z "$MSG" ]; then
-  echo "Error: Failed to generate commit message."
-  exit 1
-fi
-
-echo "Proposed commit message:"
-echo "  $MSG"
-echo ""
-read -p "Commit with this message? [y/N] " confirm
-
-if [[ "$confirm" =~ ^[Yy]$ ]]; then
-  git commit -m "$MSG"
-  echo "Committed."
-else
-  echo "Aborted."
-fi
-```
-
-Make it executable:
-
-```bash
-chmod +x ~/bin/ai-commit
-```
-
-Then use it from any project:
-
-```bash
-git add -A
-ai-commit
-```
-
-## Summary of File Locations
-
-| Path | Scope | Invocation |
-|---|---|---|
-| `~/.gemini/commands/commit.toml` | Global (all projects) | `/commit` |
-| `~/.gemini/commands/git/commit.toml` | Global, namespaced | `/git:commit` |
-| `<project>/.gemini/commands/commit.toml` | Project only | `/commit` |
-
-The global location (`~/.gemini/commands/`) is what makes the command available across all your projects without any per-project setup.

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

@@ -1,5 +0,0 @@
-{
-  "total_tokens": 70530,
-  "duration_ms": 49534,
-  "total_duration_seconds": 49.5
-}

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

@@ -1,32 +0,0 @@
-{
-  "eval_id": 3,
-  "eval_name": "custom-slash-command",
-  "configuration": "without_skill",
-  "expectations": [
-    {
-      "text": "Points to ~/.gemini/commands/ for global user-scoped commands",
-      "passed": false,
-      "evidence": "Points to `~/.gemini/extensions/commit-message/` instead. Does not know about the commands/ directory or .toml approach."
-    },
-    {
-      "text": "Shows .toml file format with prompt field",
-      "passed": false,
-      "evidence": "Uses gemini_extension.json manifest with commands array instead of .toml format"
-    },
-    {
-      "text": "Uses !{git diff --cached} shell execution syntax in the prompt",
-      "passed": false,
-      "evidence": "Creates a separate shell script to execute git diff. Does not know about the !{...} inline shell execution syntax."
-    },
-    {
-      "text": "Warns that custom slash commands don't work in headless/non-interactive mode",
-      "passed": false,
-      "evidence": "No mention of headless mode limitation for slash commands"
-    },
-    {
-      "text": "Provides a complete, copy-pasteable .toml file example",
-      "passed": false,
-      "evidence": "Provides a complete extension example, but it uses the wrong mechanism entirely (extensions vs custom commands)"
-    }
-  ]
-}

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

@@ -1,199 +0,0 @@
-# Creating a Custom Slash Command in Gemini CLI for Commit Messages
-
-## Overview
-
-Gemini CLI supports custom slash commands through its extensions system. To make a command available across all your projects, you place it in the global configuration directory at `~/.gemini/extensions/`. Extensions are defined using `gemini_extension.json` manifest files that describe the command and its behavior.
-
-## Step-by-Step Setup
-
-### 1. Create the Global Extensions Directory
-
-```bash
-mkdir -p ~/.gemini/extensions/commit-message
-```
-
-### 2. Create the Shell Script
-
-Create `~/.gemini/extensions/commit-message/generate-commit-msg.sh`:
-
-```bash
-#!/bin/bash
-# generate-commit-msg.sh
-# Gets the staged diff and outputs it for the AI to process
-
-DIFF=$(git diff --cached)
-
-if [ -z "$DIFF" ]; then
-  echo "ERROR: No staged changes found. Stage your changes with 'git add' first."
-  exit 1
-fi
-
-echo "Here is the staged git diff:"
-echo ""
-echo '```diff'
-echo "$DIFF"
-echo '```'
-echo ""
-echo "Please write a concise, conventional commit message for these changes."
-echo "Follow the Conventional Commits format: type(scope): description"
-echo ""
-echo "Types: feat, fix, docs, style, refactor, perf, test, build, ci, chore"
-echo ""
-echo "Provide:"
-echo "1. A single-line subject (max 72 chars)"
-echo "2. A blank line"
-echo "3. An optional body explaining the 'why' behind the changes"
-```
-
-Make it executable:
-
-```bash
-chmod +x ~/.gemini/extensions/commit-message/generate-commit-msg.sh
-```
-
-### 3. Create the Extension Manifest
-
-Create `~/.gemini/extensions/commit-message/gemini_extension.json`:
-
-```json
-{
-  "name": "commit-message",
-  "description": "Generate a commit message from staged changes using git diff --cached",
-  "version": "1.0.0",
-  "commands": [
-    {
-      "name": "commit-msg",
-      "description": "Analyze staged git changes and generate a conventional commit message",
-      "action": {
-        "type": "shell",
-        "command": "~/.gemini/extensions/commit-message/generate-commit-msg.sh"
-      }
-    }
-  ]
-}
-```
-
-### 4. Usage
-
-Once configured, open Gemini CLI in any project and type:
-
-```
-/commit-msg
-```
-
-The command will:
-1. Run `git diff --cached` to capture your staged changes
-2. Pass the diff output into the conversation context
-3. Ask Gemini to generate a conventional commit message based on the diff
-
-## Alternative Approach: Using GEMINI.md with a Prompt-Based Workflow
-
-If extensions are not behaving as expected in your version of Gemini CLI, you can achieve a similar result using a global `GEMINI.md` instruction file combined with a simple shell alias.
-
-### 1. Create a Global GEMINI.md
-
-Create or edit `~/.gemini/GEMINI.md`:
-
-```markdown
-# Custom Commands
-
-## Commit Message Generation
-
-When I say "generate commit message" or provide a git diff, follow these rules:
-
-1. Analyze the diff carefully
-2. Write a commit message in Conventional Commits format
-3. Use the format: type(scope): short description
-4. Include a body if the changes are complex
-5. Keep the subject line under 72 characters
-6. Use imperative mood ("add feature" not "added feature")
-```
-
-### 2. Create a Shell Helper Script
-
-Add to your `~/.bashrc` or `~/.zshrc`:
-
-```bash
-# Gemini CLI commit message helper
-gcm() {
-  local diff
-  diff=$(git diff --cached)
-
-  if [ -z "$diff" ]; then
-    echo "No staged changes. Use 'git add' to stage files first."
-    return 1
-  fi
-
-  echo "Staged diff:"
-  echo '```diff'
-  echo "$diff"
-  echo '```'
-  echo ""
-  echo "Generate a conventional commit message for the above changes."
-}
-```
-
-Then in Gemini CLI, you can run:
-
-```
-@run gcm
-```
-
-Or pipe the output directly:
-
-```bash
-# From your regular terminal, pipe into gemini
-gcm | gemini
-```
-
-## Alternative Approach: Inline Tool Use
-
-Gemini CLI allows you to invoke shell commands inline. You can simply type within a Gemini CLI session:
-
-```
-Please run `git diff --cached` and write me a commit message based on the output.
-```
-
-Since Gemini CLI has the ability to execute shell commands (with your approval), it will run the diff, read the output, and generate a commit message. This requires no configuration at all, but it is a manual process each time rather than a single slash command.
-
-## Applying the Generated Commit Message
-
-Once Gemini generates a commit message you like, you can apply it directly:
-
-```bash
-git commit -m "feat(auth): add OAuth2 token refresh logic
-
-Implement automatic token refresh when access tokens expire.
-Uses refresh token rotation for improved security."
-```
-
-Or ask Gemini CLI to run the commit for you:
-
-```
-Please commit with that message.
-```
-
-## Directory Structure Summary
-
-```
-~/.gemini/
-  GEMINI.md                          # Global instructions (optional)
-  extensions/
-    commit-message/
-      gemini_extension.json          # Extension manifest
-      generate-commit-msg.sh         # Shell script for the command
-```
-
-## Tips
-
-- **Scope control**: Placing extensions in `~/.gemini/extensions/` makes them global. For project-specific commands, place them in `.gemini/extensions/` within the project root.
-- **Customizing the prompt**: Edit the echo statements at the end of `generate-commit-msg.sh` to adjust the instructions given to the AI (e.g., require a specific commit style, add ticket number references, etc.).
-- **Large diffs**: If the staged diff is very large, consider truncating it or summarizing file-level changes to stay within context limits. You can modify the script to include `--stat` output alongside a truncated diff.
-- **Security**: The shell script only reads data (via `git diff --cached`). It does not modify your repository or make commits on its own.
-
-## Troubleshooting
-
-- **"Command not found"**: Make sure the shell script is executable (`chmod +x`) and the path in `gemini_extension.json` is correct.
-- **"No staged changes"**: Run `git add <files>` before invoking the command.
-- **Extension not loading**: Verify the JSON manifest is valid (`cat ~/.gemini/extensions/commit-message/gemini_extension.json | python3 -m json.tool`) and restart Gemini CLI.
-- **Path issues on Windows**: Use forward slashes or the `%USERPROFILE%` equivalent in paths. The extensions directory would be at `%USERPROFILE%\.gemini\extensions\`.

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

@@ -1,5 +0,0 @@
-{
-  "total_tokens": 57648,
-  "duration_ms": 56702,
-  "total_duration_seconds": 56.7
-}