@mmmbuto/gemini-cli-termux 0.30.3-termux → 0.30.5-termux

package/packages/core/dist/docs/cli/uninstall.md

@@ -1,65 +0,0 @@
-# Uninstalling the CLI
-
-Your uninstall method depends on how you ran the CLI. Follow the instructions
-for either npx or a global npm installation.
-
-## Method 1: Using npx
-
-npx runs packages from a temporary cache without a permanent installation. To
-"uninstall" the CLI, you must clear this cache, which will remove gemini-cli and
-any other packages previously executed with npx.
-
-The npx cache is a directory named `_npx` inside your main npm cache folder. You
-can find your npm cache path by running `npm config get cache`.
-
-**For macOS / Linux**
-
-```bash
-# The path is typically ~/.npm/_npx
-rm -rf "$(npm config get cache)/_npx"
-```
-
-**For Windows**
-
-_Command Prompt_
-
-```cmd
-:: The path is typically %LocalAppData%\npm-cache\_npx
-rmdir /s /q "%LocalAppData%\npm-cache\_npx"
-```
-
-_PowerShell_
-
-```powershell
-# The path is typically $env:LocalAppData\npm-cache\_npx
-Remove-Item -Path (Join-Path $env:LocalAppData "npm-cache\_npx") -Recurse -Force
-```
-
-## Method 2: Using npm (global install)
-
-If you installed the CLI globally (e.g., `npm install -g @google/gemini-cli`),
-use the `npm uninstall` command with the `-g` flag to remove it.
-
-```bash
-npm uninstall -g @google/gemini-cli
-```
-
-This command completely removes the package from your system.
-
-## Method 3: Homebrew
-
-If you installed the CLI globally using Homebrew (e.g.,
-`brew install gemini-cli`), use the `brew uninstall` command to remove it.
-
-```bash
-brew uninstall gemini-cli
-```
-
-## Method 4: MacPorts
-
-If you installed the CLI globally using MacPorts (e.g.,
-`sudo port install gemini-cli`), use the `port uninstall` command to remove it.
-
-```bash
-sudo port uninstall gemini-cli
-```

package/packages/core/dist/docs/core/memport.md

@@ -1,246 +0,0 @@
-# Memory Import Processor
-
-The Memory Import Processor is a feature that allows you to modularize your
-GEMINI.md files by importing content from other files using the `@file.md`
-syntax.
-
-## Overview
-
-This feature enables you to break down large GEMINI.md files into smaller, more
-manageable components that can be reused across different contexts. The import
-processor supports both relative and absolute paths, with built-in safety
-features to prevent circular imports and ensure file access security.
-
-## Syntax
-
-Use the `@` symbol followed by the path to the file you want to import:
-
-```markdown
-# Main GEMINI.md file
-
-This is the main content.
-
-@./components/instructions.md
-
-More content here.
-
-@./shared/configuration.md
-```
-
-## Supported path formats
-
-### Relative paths
-
-- `@./file.md` - Import from the same directory
-- `@../file.md` - Import from parent directory
-- `@./components/file.md` - Import from subdirectory
-
-### Absolute paths
-
-- `@/absolute/path/to/file.md` - Import using absolute path
-
-## Examples
-
-### Basic import
-
-```markdown
-# My GEMINI.md
-
-Welcome to my project!
-
-@./get-started.md
-
-## Features
-
-@./features/overview.md
-```
-
-### Nested imports
-
-The imported files can themselves contain imports, creating a nested structure:
-
-```markdown
-# main.md
-
-@./header.md @./content.md @./footer.md
-```
-
-```markdown
-# header.md
-
-# Project Header
-
-@./shared/title.md
-```
-
-## Safety features
-
-### Circular import detection
-
-The processor automatically detects and prevents circular imports:
-
-```markdown
-# file-a.md
-
-@./file-b.md
-```
-
-```markdown
-# file-b.md
-
-@./file-a.md <!-- This will be detected and prevented -->
-```
-
-### File access security
-
-The `validateImportPath` function ensures that imports are only allowed from
-specified directories, preventing access to sensitive files outside the allowed
-scope.
-
-### Maximum import depth
-
-To prevent infinite recursion, there's a configurable maximum import depth
-(default: 5 levels).
-
-## Error handling
-
-### Missing files
-
-If a referenced file doesn't exist, the import will fail gracefully with an
-error comment in the output.
-
-### File access errors
-
-Permission issues or other file system errors are handled gracefully with
-appropriate error messages.
-
-## Code region detection
-
-The import processor uses the `marked` library to detect code blocks and inline
-code spans, ensuring that `@` imports inside these regions are properly ignored.
-This provides robust handling of nested code blocks and complex Markdown
-structures.
-
-## Import tree structure
-
-The processor returns an import tree that shows the hierarchy of imported files,
-similar to Claude's `/memory` feature. This helps users debug problems with
-their GEMINI.md files by showing which files were read and their import
-relationships.
-
-Example tree structure:
-
-```
-Memory Files
- L project: GEMINI.md
-            L a.md
-              L b.md
-                L c.md
-              L d.md
-                L e.md
-                  L f.md
-            L included.md
-```
-
-The tree preserves the order that files were imported and shows the complete
-import chain for debugging purposes.
-
-## Comparison to Claude Code's `/memory` (`claude.md`) approach
-
-Claude Code's `/memory` feature (as seen in `claude.md`) produces a flat, linear
-document by concatenating all included files, always marking file boundaries
-with clear comments and path names. It does not explicitly present the import
-hierarchy, but the LLM receives all file contents and paths, which is sufficient
-for reconstructing the hierarchy if needed.
-
-> [!NOTE] The import tree is mainly for clarity during development and has
-> limited relevance to LLM consumption.
-
-## API reference
-
-### `processImports(content, basePath, debugMode?, importState?)`
-
-Processes import statements in GEMINI.md content.
-
-**Parameters:**
-
-- `content` (string): The content to process for imports
-- `basePath` (string): The directory path where the current file is located
-- `debugMode` (boolean, optional): Whether to enable debug logging (default:
-  false)
-- `importState` (ImportState, optional): State tracking for circular import
-  prevention
-
-**Returns:** Promise&lt;ProcessImportsResult&gt; - Object containing processed
-content and import tree
-
-### `ProcessImportsResult`
-
-```typescript
-interface ProcessImportsResult {
-  content: string; // The processed content with imports resolved
-  importTree: MemoryFile; // Tree structure showing the import hierarchy
-}
-```
-
-### `MemoryFile`
-
-```typescript
-interface MemoryFile {
-  path: string; // The file path
-  imports?: MemoryFile[]; // Direct imports, in the order they were imported
-}
-```
-
-### `validateImportPath(importPath, basePath, allowedDirectories)`
-
-Validates import paths to ensure they are safe and within allowed directories.
-
-**Parameters:**
-
-- `importPath` (string): The import path to validate
-- `basePath` (string): The base directory for resolving relative paths
-- `allowedDirectories` (string[]): Array of allowed directory paths
-
-**Returns:** boolean - Whether the import path is valid
-
-### `findProjectRoot(startDir)`
-
-Finds the project root by searching for a `.git` directory upwards from the
-given start directory. Implemented as an **async** function using non-blocking
-file system APIs to avoid blocking the Node.js event loop.
-
-**Parameters:**
-
-- `startDir` (string): The directory to start searching from
-
-**Returns:** Promise&lt;string&gt; - The project root directory (or the start
-directory if no `.git` is found)
-
-## Best Practices
-
-1. **Use descriptive file names** for imported components
-2. **Keep imports shallow** - avoid deeply nested import chains
-3. **Document your structure** - maintain a clear hierarchy of imported files
-4. **Test your imports** - ensure all referenced files exist and are accessible
-5. **Use relative paths** when possible for better portability
-
-## Troubleshooting
-
-### Common issues
-
-1. **Import not working**: Check that the file exists and the path is correct
-2. **Circular import warnings**: Review your import structure for circular
-   references
-3. **Permission errors**: Ensure the files are readable and within allowed
-   directories
-4. **Path resolution issues**: Use absolute paths if relative paths aren't
-   resolving correctly
-
-### Debug mode
-
-Enable debug mode to see detailed logging of the import process:
-
-```typescript
-const result = await processImports(content, basePath, true);
-```

package/packages/core/dist/docs/core/tools-api.md

@@ -1,131 +0,0 @@
-# Gemini CLI core: Tools API
-
-The Gemini CLI core (`packages/core`) features a robust system for defining,
-registering, and executing tools. These tools extend the capabilities of the
-Gemini model, allowing it to interact with the local environment, fetch web
-content, and perform various actions beyond simple text generation.
-
-## Core concepts
-
-- **Tool (`tools.ts`):** An interface and base class (`BaseTool`) that defines
-  the contract for all tools. Each tool must have:
-  - `name`: A unique internal name (used in API calls to Gemini).
-  - `displayName`: A user-friendly name.
-  - `description`: A clear explanation of what the tool does, which is provided
-    to the Gemini model.
-  - `parameterSchema`: A JSON schema defining the parameters that the tool
-    accepts. This is crucial for the Gemini model to understand how to call the
-    tool correctly.
-  - `validateToolParams()`: A method to validate incoming parameters.
-  - `getDescription()`: A method to provide a human-readable description of what
-    the tool will do with specific parameters before execution.
-  - `shouldConfirmExecute()`: A method to determine if user confirmation is
-    required before execution (e.g., for potentially destructive operations).
-  - `execute()`: The core method that performs the tool's action and returns a
-    `ToolResult`.
-
-- **`ToolResult` (`tools.ts`):** An interface defining the structure of a tool's
-  execution outcome:
-  - `llmContent`: The factual content to be included in the history sent back to
-    the LLM for context. This can be a simple string or a `PartListUnion` (an
-    array of `Part` objects and strings) for rich content.
-  - `returnDisplay`: A user-friendly string (often Markdown) or a special object
-    (like `FileDiff`) for display in the CLI.
-
-- **Returning rich content:** Tools are not limited to returning simple text.
-  The `llmContent` can be a `PartListUnion`, which is an array that can contain
-  a mix of `Part` objects (for images, audio, etc.) and `string`s. This allows a
-  single tool execution to return multiple pieces of rich content.
-
-- **Tool registry (`tool-registry.ts`):** A class (`ToolRegistry`) responsible
-  for:
-  - **Registering tools:** Holding a collection of all available built-in tools
-    (e.g., `ReadFileTool`, `ShellTool`).
-  - **Discovering tools:** It can also discover tools dynamically:
-    - **Command-based discovery:** If `tools.discoveryCommand` is configured in
-      settings, this command is executed. It's expected to output JSON
-      describing custom tools, which are then registered as `DiscoveredTool`
-      instances.
-    - **MCP-based discovery:** If `mcp.serverCommand` is configured, the
-      registry can connect to a Model Context Protocol (MCP) server to list and
-      register tools (`DiscoveredMCPTool`).
-  - **Providing schemas:** Exposing the `FunctionDeclaration` schemas of all
-    registered tools to the Gemini model, so it knows what tools are available
-    and how to use them.
-  - **Retrieving tools:** Allowing the core to get a specific tool by name for
-    execution.
-
-## Built-in tools
-
-The core comes with a suite of pre-defined tools, typically found in
-`packages/core/src/tools/`. These include:
-
-- **File system tools:**
-  - `LSTool` (`ls.ts`): Lists directory contents.
-  - `ReadFileTool` (`read-file.ts`): Reads the content of a single file.
-  - `WriteFileTool` (`write-file.ts`): Writes content to a file.
-  - `GrepTool` (`grep.ts`): Searches for patterns in files.
-  - `GlobTool` (`glob.ts`): Finds files matching glob patterns.
-  - `EditTool` (`edit.ts`): Performs in-place modifications to files (often
-    requiring confirmation).
-  - `ReadManyFilesTool` (`read-many-files.ts`): Reads and concatenates content
-    from multiple files or glob patterns (used by the `@` command in CLI).
-- **Execution tools:**
-  - `ShellTool` (`shell.ts`): Executes arbitrary shell commands (requires
-    careful sandboxing and user confirmation).
-- **Web tools:**
-  - `WebFetchTool` (`web-fetch.ts`): Fetches content from a URL.
-  - `WebSearchTool` (`web-search.ts`): Performs a web search.
-- **Memory tools:**
-  - `MemoryTool` (`memoryTool.ts`): Interacts with the AI's memory.
-
-Each of these tools extends `BaseTool` and implements the required methods for
-its specific functionality.
-
-## Tool execution flow
-
-1.  **Model request:** The Gemini model, based on the user's prompt and the
-    provided tool schemas, decides to use a tool and returns a `FunctionCall`
-    part in its response, specifying the tool name and arguments.
-2.  **Core receives request:** The core parses this `FunctionCall`.
-3.  **Tool retrieval:** It looks up the requested tool in the `ToolRegistry`.
-4.  **Parameter validation:** The tool's `validateToolParams()` method is
-    called.
-5.  **Confirmation (if needed):**
-    - The tool's `shouldConfirmExecute()` method is called.
-    - If it returns details for confirmation, the core communicates this back to
-      the CLI, which prompts the user.
-    - The user's decision (e.g., proceed, cancel) is sent back to the core.
-6.  **Execution:** If validated and confirmed (or if no confirmation is needed),
-    the core calls the tool's `execute()` method with the provided arguments and
-    an `AbortSignal` (for potential cancellation).
-7.  **Result processing:** The `ToolResult` from `execute()` is received by the
-    core.
-8.  **Response to model:** The `llmContent` from the `ToolResult` is packaged as
-    a `FunctionResponse` and sent back to the Gemini model so it can continue
-    generating a user-facing response.
-9.  **Display to user:** The `returnDisplay` from the `ToolResult` is sent to
-    the CLI to show the user what the tool did.
-
-## Extending with custom tools
-
-While direct programmatic registration of new tools by users isn't explicitly
-detailed as a primary workflow in the provided files for typical end-users, the
-architecture supports extension through:
-
-- **Command-based discovery:** Advanced users or project administrators can
-  define a `tools.discoveryCommand` in `settings.json`. This command, when run
-  by the Gemini CLI core, should output a JSON array of `FunctionDeclaration`
-  objects. The core will then make these available as `DiscoveredTool`
-  instances. The corresponding `tools.callCommand` would then be responsible for
-  actually executing these custom tools.
-- **MCP server(s):** For more complex scenarios, one or more MCP servers can be
-  set up and configured via the `mcpServers` setting in `settings.json`. The
-  Gemini CLI core can then discover and use tools exposed by these servers. As
-  mentioned, if you have multiple MCP servers, the tool names will be prefixed
-  with the server name from your configuration (e.g.,
-  `serverAlias__actualToolName`).
-
-This tool system provides a flexible and powerful way to augment the Gemini
-model's capabilities, making the Gemini CLI a versatile assistant for a wide
-range of tasks.

package/packages/core/dist/docs/faq.md

@@ -1,154 +0,0 @@
-# Frequently asked questions (FAQ)
-
-This page provides answers to common questions and solutions to frequent
-problems encountered while using Gemini CLI.
-
-## General issues
-
-### Why am I getting an `API error: 429 - Resource exhausted`?
-
-This error indicates that you have exceeded your API request limit. The Gemini
-API has rate limits to prevent abuse and ensure fair usage.
-
-To resolve this, you can:
-
-- **Check your usage:** Review your API usage in the Google AI Studio or your
-  Google Cloud project dashboard.
-- **Optimize your prompts:** If you are making many requests in a short period,
-  try to batch your prompts or introduce delays between requests.
-- **Request a quota increase:** If you consistently need a higher limit, you can
-  request a quota increase from Google.
-
-### Why am I getting an `ERR_REQUIRE_ESM` error when running `npm run start`?
-
-This error typically occurs in Node.js projects when there is a mismatch between
-CommonJS and ES Modules.
-
-This is often due to a misconfiguration in your `package.json` or
-`tsconfig.json`. Ensure that:
-
-1.  Your `package.json` has `"type": "module"`.
-2.  Your `tsconfig.json` has `"module": "NodeNext"` or a compatible setting in
-    the `compilerOptions`.
-
-If the problem persists, try deleting your `node_modules` directory and
-`package-lock.json` file, and then run `npm install` again.
-
-### Why don't I see cached token counts in my stats output?
-
-Cached token information is only displayed when cached tokens are being used.
-This feature is available for API key users (Gemini API key or Google Cloud
-Vertex AI) but not for OAuth users (such as Google Personal/Enterprise accounts
-like Google Gmail or Google Workspace, respectively). This is because the Gemini
-Code Assist API does not support cached content creation. You can still view
-your total token usage using the `/stats` command in Gemini CLI.
-
-## Installation and updates
-
-### How do I update Gemini CLI to the latest version?
-
-If you installed it globally via `npm`, update it using the command
-`npm install -g @google/gemini-cli@latest`. If you compiled it from source, pull
-the latest changes from the repository, and then rebuild using the command
-`npm run build`.
-
-## Platform-specific issues
-
-### Why does the CLI crash on Windows when I run a command like `chmod +x`?
-
-Commands like `chmod` are specific to Unix-like operating systems (Linux,
-macOS). They are not available on Windows by default.
-
-To resolve this, you can:
-
-- **Use Windows-equivalent commands:** Instead of `chmod`, you can use `icacls`
-  to modify file permissions on Windows.
-- **Use a compatibility layer:** Tools like Git Bash or Windows Subsystem for
-  Linux (WSL) provide a Unix-like environment on Windows where these commands
-  will work.
-
-## Configuration
-
-### How do I configure my `GOOGLE_CLOUD_PROJECT`?
-
-You can configure your Google Cloud Project ID using an environment variable.
-
-Set the `GOOGLE_CLOUD_PROJECT` environment variable in your shell:
-
-```bash
-export GOOGLE_CLOUD_PROJECT="your-project-id"
-```
-
-To make this setting permanent, add this line to your shell's startup file
-(e.g., `~/.bashrc`, `~/.zshrc`).
-
-### What is the best way to store my API keys securely?
-
-Exposing API keys in scripts or checking them into source control is a security
-risk.
-
-To store your API keys securely, you can:
-
-- **Use a `.env` file:** Create a `.env` file in your project's `.gemini`
-  directory (`.gemini/.env`) and store your keys there. Gemini CLI will
-  automatically load these variables.
-- **Use your system's keyring:** For the most secure storage, use your operating
-  system's secret management tool (like macOS Keychain, Windows Credential
-  Manager, or a secret manager on Linux). You can then have your scripts or
-  environment load the key from the secure storage at runtime.
-
-### Where are the Gemini CLI configuration and settings files stored?
-
-The Gemini CLI configuration is stored in two `settings.json` files:
-
-1.  In your home directory: `~/.gemini/settings.json`.
-2.  In your project's root directory: `./.gemini/settings.json`.
-
-Refer to [Gemini CLI Configuration](./get-started/configuration.md) for more
-details.
-
-## Google AI Pro/Ultra and subscription FAQs
-
-### Where can I learn more about my Google AI Pro or Google AI Ultra subscription?
-
-To learn more about your Google AI Pro or Google AI Ultra subscription, visit
-**Manage subscription** in your [subscription settings](https://one.google.com).
-
-### How do I know if I have higher limits for Google AI Pro or Ultra?
-
-If you're subscribed to Google AI Pro or Ultra, you automatically have higher
-limits to Gemini Code Assist and Gemini CLI. These are shared across Gemini CLI
-and agent mode in the IDE. You can confirm you have higher limits by checking if
-you are still subscribed to Google AI Pro or Ultra in your
-[subscription settings](https://one.google.com).
-
-### What is the privacy policy for using Gemini Code Assist or Gemini CLI if I've subscribed to Google AI Pro or Ultra?
-
-To learn more about your privacy policy and terms of service governed by your
-subscription, visit
-[Gemini Code Assist: Terms of Service and Privacy Policies](https://developers.google.com/gemini-code-assist/resources/privacy-notices).
-
-### I've upgraded to Google AI Pro or Ultra but it still says I am hitting quota limits. Is this a bug?
-
-The higher limits in your Google AI Pro or Ultra subscription are for Gemini 2.5
-across both Gemini 2.5 Pro and Flash. They are shared quota across Gemini CLI
-and agent mode in Gemini Code Assist IDE extensions. You can learn more about
-quota limits for Gemini CLI, Gemini Code Assist and agent mode in Gemini Code
-Assist at
-[Quotas and limits](https://developers.google.com/gemini-code-assist/resources/quotas).
-
-### If I upgrade to higher limits for Gemini CLI and Gemini Code Assist by purchasing a Google AI Pro or Ultra subscription, will Gemini start using my data to improve its machine learning models?
-
-Google does not use your data to improve Google's machine learning models if you
-purchase a paid plan. Note: If you decide to remain on the free version of
-Gemini Code Assist, Gemini Code Assist for individuals, you can also opt out of
-using your data to improve Google's machine learning models. See the
-[Gemini Code Assist for individuals privacy notice](https://developers.google.com/gemini-code-assist/resources/privacy-notice-gemini-code-assist-individuals)
-for more information.
-
-## Not seeing your question?
-
-Search the
-[Gemini CLI Q&A discussions on GitHub](https://github.com/google-gemini/gemini-cli/discussions/categories/q-a)
-or
-[start a new discussion on GitHub](https://github.com/google-gemini/gemini-cli/discussions/new?category=q-a)