@office-ai/aioncli-core 0.26.0 → 0.30.0

package/dist/docs/cli/themes.md

@@ -16,12 +16,14 @@ using the `/theme` command within Gemini CLI:
   - `Default`
   - `Dracula`
   - `GitHub`
+  - `Solarized Dark`
 - **Light themes:**
   - `ANSI Light`
   - `Ayu Light`
   - `Default Light`
   - `GitHub Light`
   - `Google Code`
+  - `Solarized Light`
   - `Xcode`
 
 ### Changing themes
@@ -46,15 +48,15 @@ remembered across sessions.
 
 ## Custom color themes
 
-Gemini CLI allows you to create your own custom color themes by specifying them
-in your `settings.json` file. This gives you full control over the color palette
+Gemini CLI lets you create your own custom color themes by specifying them in
+your `settings.json` file. This gives you full control over the color palette
 used in the CLI.
 
 ### How to define a custom theme
 
 Add a `customThemes` block to your user, project, or system `settings.json`
 file. Each custom theme is defined as an object with a unique name and a set of
-color keys. For example:
+nested configuration objects. For example:
 
 ```json
 {
@@ -63,51 +65,52 @@ color keys. For example:
       "MyCustomTheme": {
         "name": "MyCustomTheme",
         "type": "custom",
-        "Background": "#181818",
-        ...
+        "background": {
+          "primary": "#181818"
+        },
+        "text": {
+          "primary": "#f0f0f0",
+          "secondary": "#a0a0a0"
+        }
       }
     }
   }
 }
 ```
 
-**Color keys:**
-
-- `Background`
-- `Foreground`
-- `LightBlue`
-- `AccentBlue`
-- `AccentPurple`
-- `AccentCyan`
-- `AccentGreen`
-- `AccentYellow`
-- `AccentRed`
-- `Comment`
-- `Gray`
-- `DiffAdded` (optional, for added lines in diffs)
-- `DiffRemoved` (optional, for removed lines in diffs)
-- `DiffModified` (optional, for modified lines in diffs)
-
-You can also override individual UI text roles by adding a nested `text` object.
-This object supports the keys `primary`, `secondary`, `link`, `accent`, and
-`response`. When `text.response` is provided it takes precedence over
-`text.primary` for rendering model responses in chat.
+**Configuration objects:**
+
+- **`text`**: Defines text colors.
+  - `primary`: The default text color.
+  - `secondary`: Used for less prominent text.
+  - `link`: Color for URLs and links.
+  - `accent`: Used for highlights and emphasis.
+  - `response`: Precedence over `primary` for rendering model responses.
+- **`background`**: Defines background colors.
+  - `primary`: The main background color of the UI.
+  - `diff.added`: Background for added lines in diffs.
+  - `diff.removed`: Background for removed lines in diffs.
+- **`border`**: Defines border colors.
+  - `default`: The standard border color.
+  - `focused`: Border color when an element is focused.
+- **`status`**: Colors for status indicators.
+  - `success`: Used for successful operations.
+  - `warning`: Used for warnings.
+  - `error`: Used for errors.
+- **`ui`**: Other UI elements.
+  - `comment`: Color for code comments.
+  - `symbol`: Color for code symbols and operators.
+  - `gradient`: An array of colors used for gradient effects.
 
 **Required properties:**
 
 - `name` (must match the key in the `customThemes` object and be a string)
 - `type` (must be the string `"custom"`)
-- `Background`
-- `Foreground`
-- `LightBlue`
-- `AccentBlue`
-- `AccentPurple`
-- `AccentCyan`
-- `AccentGreen`
-- `AccentYellow`
-- `AccentRed`
-- `Comment`
-- `Gray`
+
+While all sub-properties are technically optional, we recommend providing at
+least `background.primary`, `text.primary`, `text.secondary`, and the various
+accent colors via `text.link`, `text.accent`, and `status` to ensure a cohesive
+UI.
 
 You can use either hex codes (e.g., `#FF0000`) **or** standard CSS color names
 (e.g., `coral`, `teal`, `blue`) for any color value. See
@@ -142,23 +145,35 @@ custom theme defined in `settings.json`.
 
 ```json
 {
-  "name": "My File Theme",
+  "name": "Gruvbox Dark",
   "type": "custom",
-  "Background": "#282A36",
-  "Foreground": "#F8F8F2",
-  "LightBlue": "#82AAFF",
-  "AccentBlue": "#61AFEF",
-  "AccentPurple": "#BD93F9",
-  "AccentCyan": "#8BE9FD",
-  "AccentGreen": "#50FA7B",
-  "AccentYellow": "#F1FA8C",
-  "AccentRed": "#FF5555",
-  "Comment": "#6272A4",
-  "Gray": "#ABB2BF",
-  "DiffAdded": "#A6E3A1",
-  "DiffRemoved": "#F38BA8",
-  "DiffModified": "#89B4FA",
-  "GradientColors": ["#4796E4", "#847ACE", "#C3677F"]
+  "background": {
+    "primary": "#282828",
+    "diff": {
+      "added": "#2b3312",
+      "removed": "#341212"
+    }
+  },
+  "text": {
+    "primary": "#ebdbb2",
+    "secondary": "#a89984",
+    "link": "#83a598",
+    "accent": "#d3869b"
+  },
+  "border": {
+    "default": "#3c3836",
+    "focused": "#458588"
+  },
+  "status": {
+    "success": "#b8bb26",
+    "warning": "#fabd2f",
+    "error": "#fb4934"
+  },
+  "ui": {
+    "comment": "#928374",
+    "symbol": "#8ec07c",
+    "gradient": ["#cc241d", "#d65d0e", "#d79921"]
+  }
 }
 ```
 
@@ -182,6 +197,15 @@ untrusted sources.
   same [configuration precedence](../get-started/configuration.md) as other
   settings.
 
+### Themes from extensions
+
+[Extensions](../extensions/reference.md#themes) can also provide custom themes.
+Once an extension is installed and enabled, its themes are automatically added
+to the selection list in the `/theme` command.
+
+Themes from extensions appear with the extension name in parentheses to help you
+identify their source, for example: `shades-of-green (green-extension)`.
+
 ---
 
 ## Dark themes
@@ -210,6 +234,10 @@ untrusted sources.
 
 <img src="/assets/theme-github.png" alt="GitHub theme" width="600">
 
+### Solarized Dark
+
+<img src="/assets/theme-solarized-dark.png" alt="Solarized Dark theme" width="600">
+
 ## Light themes
 
 ### ANSI Light
@@ -232,6 +260,10 @@ untrusted sources.
 
 <img src="/assets/theme-google-light.png" alt="Google Code theme" width="600">
 
+### Solarized Light
+
+<img src="/assets/theme-solarized-light.png" alt="Solarized Light theme" width="600">
+
 ### Xcode
 
 <img src="/assets/theme-xcode-light.png" alt="Xcode Light theme" width="600">

package/dist/docs/cli/tutorials/automation.md

@@ -0,0 +1,187 @@
+# Automate tasks with headless mode
+
+Automate tasks with Gemini CLI. Learn how to use headless mode, pipe data into
+Gemini CLI, automate workflows with shell scripts, and generate structured JSON
+output for other applications.
+
+## Prerequisites
+
+- Gemini CLI installed and authenticated.
+- Familiarity with shell scripting (Bash/Zsh).
+
+## Why headless mode?
+
+Headless mode runs Gemini CLI once and exits. It's perfect for:
+
+- **CI/CD:** Analyzing pull requests automatically.
+- **Batch processing:** Summarizing a large number of log files.
+- **Tool building:** Creating your own "AI wrapper" scripts.
+
+## How to use headless mode
+
+Run Gemini CLI in headless mode by providing a prompt as a positional argument.
+This bypasses the interactive chat interface and prints the response to standard
+output (stdout).
+
+Run a single command:
+
+```bash
+gemini "Write a poem about TypeScript"
+```
+
+## How to pipe input to Gemini CLI
+
+Feed data into Gemini using the standard Unix pipe `|`. Gemini reads the
+standard input (stdin) as context and answers your question using standard
+output.
+
+Pipe a file:
+
+```bash
+cat error.log | gemini "Explain why this failed"
+```
+
+Pipe a command:
+
+```bash
+git diff | gemini "Write a commit message for these changes"
+```
+
+## Use Gemini CLI output in scripts
+
+Because Gemini prints to stdout, you can chain it with other tools or save the
+results to a file.
+
+### Scenario: Bulk documentation generator
+
+You have a folder of Python scripts and want to generate a `README.md` for each
+one.
+
+1.  Save the following code as `generate_docs.sh`:
+
+    ```bash
+    #!/bin/bash
+
+    # Loop through all Python files
+    for file in *.py; do
+      echo "Generating docs for $file..."
+
+      # Ask Gemini CLI to generate the documentation and print it to stdout
+      gemini "Generate a Markdown documentation summary for @$file. Print the
+      result to standard output." > "${file%.py}.md"
+    done
+    ```
+
+2.  Make the script executable and run it in your directory:
+
+    ```bash
+    chmod +x generate_docs.sh
+    ./generate_docs.sh
+    ```
+
+    This creates a corresponding Markdown file for every Python file in the
+    folder.
+
+## Extract structured JSON data
+
+When writing a script, you often need structured data (JSON) to pass to tools
+like `jq`. To get pure JSON data from the model, combine the
+`--output-format json` flag with `jq` to parse the response field.
+
+### Scenario: Extract and return structured data
+
+1.  Save the following script as `generate_json.sh`:
+
+    ```bash
+    #!/bin/bash
+
+    # Ensure we are in a project root
+    if [ ! -f "package.json" ]; then
+      echo "Error: package.json not found."
+      exit 1
+    fi
+
+    # Extract data
+    gemini --output-format json "Return a raw JSON object with keys 'version' and 'deps' from @package.json" | jq -r '.response' > data.json
+    ```
+
+2.  Run `generate_json.sh`:
+
+    ```bash
+    chmod +x generate_json.sh
+    ./generate_json.sh
+    ```
+
+3.  Check `data.json`. The file should look like this:
+
+    ```json
+    {
+      "version": "1.0.0",
+      "deps": {
+        "react": "^18.2.0"
+      }
+    }
+    ```
+
+## Build your own custom AI tools
+
+Use headless mode to perform custom, automated AI tasks.
+
+### Scenario: Create a "Smart Commit" alias
+
+You can add a function to your shell configuration (like `.zshrc` or `.bashrc`)
+to create a `git commit` wrapper that writes the message for you.
+
+1.  Open your `.zshrc` file (or `.bashrc` if you use Bash) in your preferred
+    text editor.
+
+    ```bash
+    nano ~/.zshrc
+    ```
+
+    **Note**: If you use VS Code, you can run `code ~/.zshrc`.
+
+2.  Scroll to the very bottom of the file and paste this code:
+
+    ```bash
+    function gcommit() {
+      # Get the diff of staged changes
+      diff=$(git diff --staged)
+
+      if [ -z "$diff" ]; then
+        echo "No staged changes to commit."
+        return 1
+      fi
+
+      # Ask Gemini to write the message
+      echo "Generating commit message..."
+      msg=$(echo "$diff" | gemini "Write a concise Conventional Commit message for this diff. Output ONLY the message.")
+
+      # Commit with the generated message
+      git commit -m "$msg"
+    }
+    ```
+
+    Save your file and exit.
+
+3.  Run this command to make the function available immediately:
+
+    ```bash
+    source ~/.zshrc
+    ```
+
+4.  Use your new command:
+
+    ```bash
+    gcommit
+    ```
+
+    Gemini CLI will analyze your staged changes and commit them with a generated
+    message.
+
+## Next steps
+
+- Explore the [Headless mode reference](../../cli/headless.md) for full JSON
+  schema details.
+- Learn about [Shell commands](shell-commands.md) to let the agent run scripts
+  instead of just writing them.

package/dist/docs/cli/tutorials/file-management.md

@@ -0,0 +1,142 @@
+# File management with Gemini CLI
+
+Explore, analyze, and modify your codebase using Gemini CLI. In this guide,
+you'll learn how to provide Gemini CLI with files and directories, modify and
+create files, and control what Gemini CLI can see.
+
+## Prerequisites
+
+- Gemini CLI installed and authenticated.
+- A project directory to work with (e.g., a git repository).
+
+## How to give the agent context (Reading files)
+
+Gemini CLI will generally try to read relevant files, sometimes prompting you
+for access (depending on your settings). To ensure that Gemini CLI uses a file,
+you can also include it directly.
+
+### Direct file inclusion (`@`)
+
+If you know the path to the file you want to work on, use the `@` symbol. This
+forces the CLI to read the file immediately and inject its content into your
+prompt.
+
+```bash
+`@src/components/UserProfile.tsx Explain how this component handles user data.`
+```
+
+### Working with multiple files
+
+Complex features often span multiple files. You can chain `@` references to give
+the agent a complete picture of the dependencies.
+
+```bash
+`@src/components/UserProfile.tsx @src/types/User.ts Refactor the component to use the updated User interface.`
+```
+
+### Including entire directories
+
+For broad questions or refactoring, you can include an entire directory. Be
+careful with large folders, as this consumes more tokens.
+
+```bash
+`@src/utils/ Check these utility functions for any deprecated API usage.`
+```
+
+## How to find files (Exploration)
+
+If you _don't_ know the exact file path, you can ask Gemini CLI to find it for
+you. This is useful when navigating a new codebase or looking for specific
+logic.
+
+### Scenario: Find a component definition
+
+You know there's a `UserProfile` component, but you don't know where it lives.
+
+```none
+`Find the file that defines the UserProfile component.`
+```
+
+Gemini uses the `glob` or `list_directory` tools to search your project
+structure. It will return the specific path (e.g.,
+`src/components/UserProfile.tsx`), which you can then use with `@` in your next
+turn.
+
+> **Tip:** You can also ask for lists of files, like "Show me all the TypeScript
+> configuration files in the root directory."
+
+## How to modify code
+
+Once Gemini CLI has context, you can direct it to make specific edits. The agent
+is capable of complex refactoring, not just simple text replacement.
+
+```none
+`Update @src/components/UserProfile.tsx to show a loading spinner if the user data is null.`
+```
+
+Gemini CLI uses the `replace` tool to propose a targeted code change.
+
+### Creating new files
+
+You can also ask the agent to create entirely new files or folder structures.
+
+```none
+`Create a new file @src/components/LoadingSpinner.tsx with a simple Tailwind CSS spinner.`
+```
+
+Gemini CLI uses the `write_file` tool to generate the new file from scratch.
+
+## Review and confirm changes
+
+Gemini CLI prioritizes safety. Before any file is modified, it presents a
+unified diff of the proposed changes.
+
+```diff
+- if (!user) return null;
++ if (!user) return <LoadingSpinner />;
+```
+
+- **Red lines (-):** Code that will be removed.
+- **Green lines (+):** Code that will be added.
+
+Press **y** to confirm and apply the change to your local file system. If the
+diff doesn't look right, press **n** to cancel and refine your prompt.
+
+## Verify the result
+
+After the edit is complete, verify the fix. You can simply read the file again
+or, better yet, run your project's tests.
+
+```none
+`Run the tests for the UserProfile component.`
+```
+
+Gemini CLI uses the `run_shell_command` tool to execute your test runner (e.g.,
+`npm test` or `jest`). This ensures the changes didn't break existing
+functionality.
+
+## Advanced: Controlling what Gemini sees
+
+By default, Gemini CLI respects your `.gitignore` file. It won't read or search
+through `node_modules`, build artifacts, or other ignored paths.
+
+If you have sensitive files (like `.env`) or large assets that you want to keep
+hidden from the AI _without_ ignoring them in Git, you can create a
+`.geminiignore` file in your project root.
+
+**Example `.geminiignore`:**
+
+```text
+.env
+local-db-dump.sql
+private-notes.md
+```
+
+## Next steps
+
+- Learn how to [Manage context and memory](memory-management.md) to keep your
+  agent smarter over long sessions.
+- See [Execute shell commands](shell-commands.md) for more on running tests and
+  builds.
+- Explore the technical [File system reference](../../tools/file-system.md) for
+  advanced tool parameters.

package/dist/docs/cli/tutorials/mcp-setup.md

@@ -0,0 +1,105 @@
+# Set up an MCP server
+
+Connect Gemini CLI to your external databases and services. In this guide,
+you'll learn how to extend Gemini CLI's capabilities by installing the GitHub
+MCP server and using it to manage your repositories.
+
+## Prerequisites
+
+- Gemini CLI installed.
+- **Docker:** Required for this specific example (many MCP servers run as Docker
+  containers).
+- **GitHub token:** A Personal Access Token (PAT) with repo permissions.
+
+## How to prepare your credentials
+
+Most MCP servers require authentication. For GitHub, you need a PAT.
+
+1.  Create a [fine-grained PAT](https://github.com/settings/tokens?type=beta).
+2.  Grant it **Read** access to **Metadata** and **Contents**, and
+    **Read/Write** access to **Issues** and **Pull Requests**.
+3.  Store it in your environment:
+
+```bash
+export GITHUB_PERSONAL_ACCESS_TOKEN="github_pat_..."
+```
+
+## How to configure Gemini CLI
+
+You tell Gemini about new servers by editing your `settings.json`.
+
+1.  Open `~/.gemini/settings.json` (or the project-specific
+    `.gemini/settings.json`).
+2.  Add the `mcpServers` block. This tells Gemini: "Run this docker container
+    and talk to it."
+
+```json
+{
+  "mcpServers": {
+    "github": {
+      "command": "docker",
+      "args": [
+        "run",
+        "-i",
+        "--rm",
+        "-e",
+        "GITHUB_PERSONAL_ACCESS_TOKEN",
+        "ghcr.io/modelcontextprotocol/servers/github:latest"
+      ],
+      "env": {
+        "GITHUB_PERSONAL_ACCESS_TOKEN": "${GITHUB_PERSONAL_ACCESS_TOKEN}"
+      }
+    }
+  }
+}
+```
+
+> **Note:** The `command` is `docker`, and the rest are arguments passed to it.
+> We map the local environment variable into the container so your secret isn't
+> hardcoded in the config file.
+
+## How to verify the connection
+
+Restart Gemini CLI. It will automatically try to start the defined servers.
+
+**Command:** `/mcp list`
+
+You should see: `✓ github: docker ... - Connected`
+
+If you see `Disconnected` or an error, check that Docker is running and your API
+token is valid.
+
+## How to use the new tools
+
+Now that the server is running, the agent has new capabilities ("tools"). You
+don't need to learn special commands; just ask in natural language.
+
+### Scenario: Listing pull requests
+
+**Prompt:** `List the open PRs in the google/gemini-cli repository.`
+
+The agent will:
+
+1.  Recognize the request matches a GitHub tool.
+2.  Call `github_list_pull_requests`.
+3.  Present the data to you.
+
+### Scenario: Creating an issue
+
+**Prompt:**
+`Create an issue in my repo titled "Bug: Login fails" with the description "See logs".`
+
+## Troubleshooting
+
+- **Server won't start?** Try running the docker command manually in your
+  terminal to see if it prints an error (e.g., "image not found").
+- **Tools not found?** Run `/mcp refresh` to force the CLI to re-query the
+  server for its capabilities.
+
+## Next steps
+
+- Explore the [MCP servers reference](../../tools/mcp-server.md) to learn about
+  SSE and HTTP transports for remote servers.
+- Browse the
+  [official MCP server list](https://github.com/modelcontextprotocol/servers) to
+  find connectors for Slack, Postgres, Google Drive, and more.