@machina.ai/cell-cli-core 1.20.2-rc1 → 1.25.0-rc1

package/dist/docs/ide-integration/ide-companion-spec.md

@@ -0,0 +1,267 @@
+# Cell CLI companion plugin: Interface specification
+
+> Last Updated: September 15, 2025
+
+This document defines the contract for building a companion plugin to enable
+Cell CLI's IDE mode. For VS Code, these features (native diffing, context
+awareness) are provided by the official extension
+([marketplace](https://marketplace.visualstudio.com/items?itemName=Google.cell-cli-cli-vscode-ide-companion)).
+This specification is for contributors who wish to bring similar functionality
+to other editors like JetBrains IDEs, Sublime Text, etc.
+
+## I. The communication interface
+
+Cell CLI and the IDE plugin communicate through a local communication channel.
+
+### 1. Transport layer: MCP over HTTP
+
+The plugin **MUST** run a local HTTP server that implements the **Model Context
+Protocol (MCP)**.
+
+- **Protocol:** The server must be a valid MCP server. We recommend using an
+  existing MCP SDK for your language of choice if available.
+- **Endpoint:** The server should expose a single endpoint (e.g., `/mcp`) for
+  all MCP communication.
+- **Port:** The server **MUST** listen on a dynamically assigned port (i.e.,
+  listen on port `0`).
+
+### 2. Discovery mechanism: The port file
+
+For Cell CLI to connect, it needs to discover which IDE instance it's running in
+and what port your server is using. The plugin **MUST** facilitate this by
+creating a "discovery file."
+
+- **How the CLI finds the file:** The CLI determines the Process ID (PID) of the
+  IDE it's running in by traversing the process tree. It then looks for a
+  discovery file that contains this PID in its name.
+- **File location:** The file must be created in a specific directory:
+  `os.tmpdir()/gemini/ide/`. Your plugin must create this directory if it
+  doesn't exist.
+- **File naming convention:** The filename is critical and **MUST** follow the
+  pattern: `cell-ide-server-${PID}-${PORT}.json`
+  - `${PID}`: The process ID of the parent IDE process. Your plugin must
+    determine this PID and include it in the filename.
+  - `${PORT}`: The port your MCP server is listening on.
+- **File content and workspace validation:** The file **MUST** contain a JSON
+  object with the following structure:
+
+  ```json
+  {
+    "port": 12345,
+    "workspacePath": "/path/to/project1:/path/to/project2",
+    "authToken": "a-very-secret-token",
+    "ideInfo": {
+      "name": "vscode",
+      "displayName": "VS Code"
+    }
+  }
+  ```
+  - `port` (number, required): The port of the MCP server.
+  - `workspacePath` (string, required): A list of all open workspace root paths,
+    delimited by the OS-specific path separator (`:` for Linux/macOS, `;` for
+    Windows). The CLI uses this path to ensure it's running in the same project
+    folder that's open in the IDE. If the CLI's current working directory is not
+    a sub-directory of `workspacePath`, the connection will be rejected. Your
+    plugin **MUST** provide the correct, absolute path(s) to the root of the
+    open workspace(s).
+  - `authToken` (string, required): A secret token for securing the connection.
+    The CLI will include this token in an `Authorization: Bearer <token>` header
+    on all requests.
+  - `ideInfo` (object, required): Information about the IDE.
+    - `name` (string, required): A short, lowercase identifier for the IDE
+      (e.g., `vscode`, `jetbrains`).
+    - `displayName` (string, required): A user-friendly name for the IDE (e.g.,
+      `VS Code`, `JetBrains IDE`).
+
+- **Authentication:** To secure the connection, the plugin **MUST** generate a
+  unique, secret token and include it in the discovery file. The CLI will then
+  include this token in the `Authorization` header for all requests to the MCP
+  server (e.g., `Authorization: Bearer a-very-secret-token`). Your server
+  **MUST** validate this token on every request and reject any that are
+  unauthorized.
+- **Tie-breaking with environment variables (recommended):** For the most
+  reliable experience, your plugin **SHOULD** both create the discovery file and
+  set the `CELL_CLI_IDE_SERVER_PORT` environment variable in the integrated
+  terminal. The file serves as the primary discovery mechanism, but the
+  environment variable is crucial for tie-breaking. If a user has multiple IDE
+  windows open for the same workspace, the CLI uses the
+  `CELL_CLI_IDE_SERVER_PORT` variable to identify and connect to the correct
+  window's server.
+
+## II. The context interface
+
+To enable context awareness, the plugin **MAY** provide the CLI with real-time
+information about the user's activity in the IDE.
+
+### `ide/contextUpdate` notification
+
+The plugin **MAY** send an `ide/contextUpdate`
+[notification](https://modelcontextprotocol.io/specification/2025-06-18/basic/index#notifications)
+to the CLI whenever the user's context changes.
+
+- **Triggering events:** This notification should be sent (with a recommended
+  debounce of 50ms) when:
+  - A file is opened, closed, or focused.
+  - The user's cursor position or text selection changes in the active file.
+- **Payload (`IdeContext`):** The notification parameters **MUST** be an
+  `IdeContext` object:
+
+  ```typescript
+  interface IdeContext {
+    workspaceState?: {
+      openFiles?: File[];
+      isTrusted?: boolean;
+    };
+  }
+
+  interface File {
+    // Absolute path to the file
+    path: string;
+    // Last focused Unix timestamp (for ordering)
+    timestamp: number;
+    // True if this is the currently focused file
+    isActive?: boolean;
+    cursor?: {
+      // 1-based line number
+      line: number;
+      // 1-based character number
+      character: number;
+    };
+    // The text currently selected by the user
+    selectedText?: string;
+  }
+  ```
+
+  **Note:** The `openFiles` list should only include files that exist on disk.
+  Virtual files (e.g., unsaved files without a path, editor settings pages)
+  **MUST** be excluded.
+
+### How the CLI uses this context
+
+After receiving the `IdeContext` object, the CLI performs several normalization
+and truncation steps before sending the information to the model.
+
+- **File ordering:** The CLI uses the `timestamp` field to determine the most
+  recently used files. It sorts the `openFiles` list based on this value.
+  Therefore, your plugin **MUST** provide an accurate Unix timestamp for when a
+  file was last focused.
+- **Active file:** The CLI considers only the most recent file (after sorting)
+  to be the "active" file. It will ignore the `isActive` flag on all other files
+  and clear their `cursor` and `selectedText` fields. Your plugin should focus
+  on setting `isActive: true` and providing cursor/selection details only for
+  the currently focused file.
+- **Truncation:** To manage token limits, the CLI truncates both the file list
+  (to 10 files) and the `selectedText` (to 16KB).
+
+While the CLI handles the final truncation, it is highly recommended that your
+plugin also limits the amount of context it sends.
+
+## III. The diffing interface
+
+To enable interactive code modifications, the plugin **MAY** expose a diffing
+interface. This allows the CLI to request that the IDE open a diff view, showing
+proposed changes to a file. The user can then review, edit, and ultimately
+accept or reject these changes directly within the IDE.
+
+### `openDiff` tool
+
+The plugin **MUST** register an `openDiff` tool on its MCP server.
+
+- **Description:** This tool instructs the IDE to open a modifiable diff view
+  for a specific file.
+- **Request (`OpenDiffRequest`):** The tool is invoked via a `tools/call`
+  request. The `arguments` field within the request's `params` **MUST** be an
+  `OpenDiffRequest` object.
+
+  ```typescript
+  interface OpenDiffRequest {
+    // The absolute path to the file to be diffed.
+    filePath: string;
+    // The proposed new content for the file.
+    newContent: string;
+  }
+  ```
+
+- **Response (`CallToolResult`):** The tool **MUST** immediately return a
+  `CallToolResult` to acknowledge the request and report whether the diff view
+  was successfully opened.
+  - On Success: If the diff view was opened successfully, the response **MUST**
+    contain empty content (i.e., `content: []`).
+  - On Failure: If an error prevented the diff view from opening, the response
+    **MUST** have `isError: true` and include a `TextContent` block in the
+    `content` array describing the error.
+
+  The actual outcome of the diff (acceptance or rejection) is communicated
+  asynchronously via notifications.
+
+### `closeDiff` tool
+
+The plugin **MUST** register a `closeDiff` tool on its MCP server.
+
+- **Description:** This tool instructs the IDE to close an open diff view for a
+  specific file.
+- **Request (`CloseDiffRequest`):** The tool is invoked via a `tools/call`
+  request. The `arguments` field within the request's `params` **MUST** be an
+  `CloseDiffRequest` object.
+
+  ```typescript
+  interface CloseDiffRequest {
+    // The absolute path to the file whose diff view should be closed.
+    filePath: string;
+  }
+  ```
+
+- **Response (`CallToolResult`):** The tool **MUST** return a `CallToolResult`.
+  - On Success: If the diff view was closed successfully, the response **MUST**
+    include a single **TextContent** block in the content array containing the
+    file's final content before closing.
+  - On Failure: If an error prevented the diff view from closing, the response
+    **MUST** have `isError: true` and include a `TextContent` block in the
+    `content` array describing the error.
+
+### `ide/diffAccepted` notification
+
+When the user accepts the changes in a diff view (e.g., by clicking an "Apply"
+or "Save" button), the plugin **MUST** send an `ide/diffAccepted` notification
+to the CLI.
+
+- **Payload:** The notification parameters **MUST** include the file path and
+  the final content of the file. The content may differ from the original
+  `newContent` if the user made manual edits in the diff view.
+
+  ```typescript
+  {
+    // The absolute path to the file that was diffed.
+    filePath: string;
+    // The full content of the file after acceptance.
+    content: string;
+  }
+  ```
+
+### `ide/diffRejected` notification
+
+When the user rejects the changes (e.g., by closing the diff view without
+accepting), the plugin **MUST** send an `ide/diffRejected` notification to the
+CLI.
+
+- **Payload:** The notification parameters **MUST** include the file path of the
+  rejected diff.
+
+  ```typescript
+  {
+    // The absolute path to the file that was diffed.
+    filePath: string;
+  }
+  ```
+
+## IV. The lifecycle interface
+
+The plugin **MUST** manage its resources and the discovery file correctly based
+on the IDE's lifecycle.
+
+- **On activation (IDE startup/plugin enabled):**
+  1.  Start the MCP server.
+  2.  Create the discovery file.
+- **On deactivation (IDE shutdown/plugin disabled):**
+  1.  Stop the MCP server.
+  2.  Delete the discovery file.

package/dist/docs/ide-integration/index.md

@@ -0,0 +1,201 @@
+# IDE integration
+
+Cell CLI can integrate with your IDE to provide a more seamless and
+context-aware experience. This integration allows the CLI to understand your
+workspace better and enables powerful features like native in-editor diffing.
+
+Currently, the supported IDEs are [Antigravity](https://antigravity.google),
+[Visual Studio Code](https://code.visualstudio.com/), and other editors that
+support VS Code extensions. To build support for other editors, see the
+[IDE Companion Extension Spec](./ide-companion-spec.md).
+
+## Features
+
+- **Workspace context:** The CLI automatically gains awareness of your workspace
+  to provide more relevant and accurate responses. This context includes:
+  - The **10 most recently accessed files** in your workspace.
+  - Your active cursor position.
+  - Any text you have selected (up to a 16KB limit; longer selections will be
+    truncated).
+
+- **Native diffing:** When Gemini suggests code modifications, you can view the
+  changes directly within your IDE's native diff viewer. This allows you to
+  review, edit, and accept or reject the suggested changes seamlessly.
+
+- **VS Code commands:** You can access Cell CLI features directly from the VS
+  Code Command Palette (`Cmd+Shift+P` or `Ctrl+Shift+P`):
+  - `Cell CLI: Run`: Starts a new Cell CLI session in the integrated terminal.
+  - `Cell CLI: Accept Diff`: Accepts the changes in the active diff editor.
+  - `Cell CLI: Close Diff Editor`: Rejects the changes and closes the active
+    diff editor.
+  - `Cell CLI: View Third-Party Notices`: Displays the third-party notices for
+    the extension.
+
+## Installation and setup
+
+There are three ways to set up the IDE integration:
+
+### 1. Automatic nudge (recommended)
+
+When you run Cell CLI inside a supported editor, it will automatically detect
+your environment and prompt you to connect. Answering "Yes" will automatically
+run the necessary setup, which includes installing the companion extension and
+enabling the connection.
+
+### 2. Manual installation from CLI
+
+If you previously dismissed the prompt or want to install the extension
+manually, you can run the following command inside Cell CLI:
+
+```
+/ide install
+```
+
+This will find the correct extension for your IDE and install it.
+
+### 3. Manual installation from a marketplace
+
+You can also install the extension directly from a marketplace.
+
+- **For Visual Studio Code:** Install from the
+  [VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=google.cell-cli-vscode-ide-companion).
+- **For VS Code forks:** To support forks of VS Code, the extension is also
+  published on the
+  [Open VSX Registry](https://open-vsx.org/extension/google/cell-cli-vscode-ide-companion).
+  Follow your editor's instructions for installing extensions from this
+  registry.
+
+> NOTE: The "Cell CLI Companion" extension may appear towards the bottom of
+> search results. If you don't see it immediately, try scrolling down or sorting
+> by "Newly Published".
+>
+> After manually installing the extension, you must run `/ide enable` in the CLI
+> to activate the integration.
+
+## Usage
+
+### Enabling and disabling
+
+You can control the IDE integration from within the CLI:
+
+- To enable the connection to the IDE, run:
+  ```
+  /ide enable
+  ```
+- To disable the connection, run:
+  ```
+  /ide disable
+  ```
+
+When enabled, Cell CLI will automatically attempt to connect to the IDE
+companion extension.
+
+### Checking the status
+
+To check the connection status and see the context the CLI has received from the
+IDE, run:
+
+```
+/ide status
+```
+
+If connected, this command will show the IDE it's connected to and a list of
+recently opened files it is aware of.
+
+> [!NOTE] The file list is limited to 10 recently accessed files within your
+> workspace and only includes local files on disk.)
+
+### Working with diffs
+
+When you ask Gemini to modify a file, it can open a diff view directly in your
+editor.
+
+**To accept a diff**, you can perform any of the following actions:
+
+- Click the **checkmark icon** in the diff editor's title bar.
+- Save the file (e.g., with `Cmd+S` or `Ctrl+S`).
+- Open the Command Palette and run **Cell CLI: Accept Diff**.
+- Respond with `yes` in the CLI when prompted.
+
+**To reject a diff**, you can:
+
+- Click the **'x' icon** in the diff editor's title bar.
+- Close the diff editor tab.
+- Open the Command Palette and run **Cell CLI: Close Diff Editor**.
+- Respond with `no` in the CLI when prompted.
+
+You can also **modify the suggested changes** directly in the diff view before
+accepting them.
+
+If you select ‘Allow for this session’ in the CLI, changes will no longer show
+up in the IDE as they will be auto-accepted.
+
+## Using with sandboxing
+
+If you are using Cell CLI within a sandbox, please be aware of the following:
+
+- **On macOS:** The IDE integration requires network access to communicate with
+  the IDE companion extension. You must use a Seatbelt profile that allows
+  network access.
+- **In a Docker container:** If you run Cell CLI inside a Docker (or Podman)
+  container, the IDE integration can still connect to the VS Code extension
+  running on your host machine. The CLI is configured to automatically find the
+  IDE server on `host.docker.internal`. No special configuration is usually
+  required, but you may need to ensure your Docker networking setup allows
+  connections from the container to the host.
+
+## Troubleshooting
+
+If you encounter issues with IDE integration, here are some common error
+messages and how to resolve them.
+
+### Connection errors
+
+- **Message:**
+  `🔴 Disconnected: Failed to connect to IDE companion extension in [IDE Name]. Please ensure the extension is running. To install the extension, run /ide install.`
+  - **Cause:** Cell CLI could not find the necessary environment variables
+    (`CELL_CLI_IDE_WORKSPACE_PATH` or `CELL_CLI_IDE_SERVER_PORT`) to connect to
+    the IDE. This usually means the IDE companion extension is not running or
+    did not initialize correctly.
+  - **Solution:**
+    1.  Make sure you have installed the **Cell CLI Companion** extension in
+        your IDE and that it is enabled.
+    2.  Open a new terminal window in your IDE to ensure it picks up the correct
+        environment.
+
+- **Message:**
+  `🔴 Disconnected: IDE connection error. The connection was lost unexpectedly. Please try reconnecting by running /ide enable`
+  - **Cause:** The connection to the IDE companion was lost.
+  - **Solution:** Run `/ide enable` to try and reconnect. If the issue
+    continues, open a new terminal window or restart your IDE.
+
+### Configuration errors
+
+- **Message:**
+  `🔴 Disconnected: Directory mismatch. Cell CLI is running in a different location than the open workspace in [IDE Name]. Please run the CLI from one of the following directories: [List of directories]`
+  - **Cause:** The CLI's current working directory is outside the workspace you
+    have open in your IDE.
+  - **Solution:** `cd` into the same directory that is open in your IDE and
+    restart the CLI.
+
+- **Message:**
+  `🔴 Disconnected: To use this feature, please open a workspace folder in [IDE Name] and try again.`
+  - **Cause:** You have no workspace open in your IDE.
+  - **Solution:** Open a workspace in your IDE and restart the CLI.
+
+### General errors
+
+- **Message:**
+  `IDE integration is not supported in your current environment. To use this feature, run Cell CLI in one of these supported IDEs: [List of IDEs]`
+  - **Cause:** You are running Cell CLI in a terminal or environment that is not
+    a supported IDE.
+  - **Solution:** Run Cell CLI from the integrated terminal of a supported IDE,
+    like Antigravity or VS Code.
+
+- **Message:**
+  `No installer is available for IDE. Please install the Cell CLI Companion extension manually from the marketplace.`
+  - **Cause:** You ran `/ide install`, but the CLI does not have an automated
+    installer for your specific IDE.
+  - **Solution:** Open your IDE's extension marketplace, search for "Cell CLI
+    Companion", and
+    [install it manually](#3-manual-installation-from-a-marketplace).

package/dist/docs/index.md

@@ -0,0 +1,147 @@
+# Welcome to Cell CLI documentation
+
+This documentation provides a comprehensive guide to installing, using, and
+developing Cell CLI, a tool that lets you interact with Gemini models through a
+command-line interface.
+
+## Cell CLI overview
+
+Cell CLI brings the capabilities of Gemini models to your terminal in an
+interactive Read-Eval-Print Loop (REPL) environment. Cell CLI consists of a
+client-side application (`packages/cli`) that communicates with a local server
+(`packages/core`), which in turn manages requests to the Gemini API and its AI
+models. Cell CLI also contains a variety of tools for tasks such as performing
+file system operations, running shells, and web fetching, which are managed by
+`packages/core`.
+
+## Navigating the documentation
+
+This documentation is organized into the following sections:
+
+### Overview
+
+- **[Architecture overview](./architecture.md):** Understand the high-level
+  design of Cell CLI, including its components and how they interact.
+- **[Contribution guide](../CONTRIBUTING.md):** Information for contributors and
+  developers, including setup, building, testing, and coding conventions.
+
+### Get started
+
+- **[Cell CLI quickstart](./get-started/index.md):** Let's get started with Cell
+  CLI.
+- **[Gemini 3 Pro on Cell CLI](./get-started/gemini-3.md):** Learn how to enable
+  and use Gemini 3.
+- **[Authentication](./get-started/authentication.md):** Authenticate to Gemini
+  CLI.
+- **[Configuration](./get-started/configuration.md):** Learn how to configure
+  the CLI.
+- **[Installation](./get-started/installation.md):** Install and run Cell CLI.
+- **[Examples](./get-started/examples.md):** Example usage of Cell CLI.
+
+### CLI
+
+- **[Introduction: Cell CLI](./cli/index.md):** Overview of the command-line
+  interface.
+- **[Commands](./cli/commands.md):** Description of available CLI commands.
+- **[Checkpointing](./cli/checkpointing.md):** Documentation for the
+  checkpointing feature.
+- **[Custom commands](./cli/custom-commands.md):** Create your own commands and
+  shortcuts for frequently used prompts.
+- **[Enterprise](./cli/enterprise.md):** Cell CLI for enterprise.
+- **[Headless mode](./cli/headless.md):** Use Cell CLI programmatically for
+  scripting and automation.
+- **[Keyboard shortcuts](./cli/keyboard-shortcuts.md):** A reference for all
+  keyboard shortcuts to improve your workflow.
+- **[Model selection](./cli/model.md):** Select the model used to process your
+  commands with `/model`.
+- **[Sandbox](./cli/sandbox.md):** Isolate tool execution in a secure,
+  containerized environment.
+- **[Settings](./cli/settings.md):** Configure various aspects of the CLI's
+  behavior and appearance with `/settings`.
+- **[Telemetry](./cli/telemetry.md):** Overview of telemetry in the CLI.
+- **[Themes](./cli/themes.md):** Themes for Cell CLI.
+- **[Token caching](./cli/token-caching.md):** Token caching and optimization.
+- **[Trusted Folders](./cli/trusted-folders.md):** An overview of the Trusted
+  Folders security feature.
+- **[Tutorials](./cli/tutorials.md):** Tutorials for Cell CLI.
+- **[Uninstall](./cli/uninstall.md):** Methods for uninstalling the Cell CLI.
+
+### Core
+
+- **[Introduction: Cell CLI core](./core/index.md):** Information about Gemini
+  CLI core.
+- **[Memport](./core/memport.md):** Using the Memory Import Processor.
+- **[Tools API](./core/tools-api.md):** Information on how the core manages and
+  exposes tools.
+- **[System Prompt Override](./cli/system-prompt.md):** Replace built-in system
+  instructions using `CELL_SYSTEM_MD`.
+
+- **[Policy Engine](./core/policy-engine.md):** Use the Policy Engine for
+  fine-grained control over tool execution.
+
+### Tools
+
+- **[Introduction: Cell CLI tools](./tools/index.md):** Information about Cell
+  CLI's tools.
+- **[File system tools](./tools/file-system.md):** Documentation for the
+  `read_file` and `write_file` tools.
+- **[Shell tool](./tools/shell.md):** Documentation for the `run_shell_command`
+  tool.
+- **[Web fetch tool](./tools/web-fetch.md):** Documentation for the `web_fetch`
+  tool.
+- **[Web search tool](./tools/web-search.md):** Documentation for the
+  `google_web_search` tool.
+- **[Memory tool](./tools/memory.md):** Documentation for the `save_memory`
+  tool.
+- **[Todo tool](./tools/todos.md):** Documentation for the `write_todos` tool.
+- **[MCP servers](./tools/mcp-server.md):** Using MCP servers with Cell CLI.
+
+### Extensions
+
+- **[Introduction: Extensions](./extensions/index.md):** How to extend the CLI
+  with new functionality.
+- **[Get Started with extensions](./extensions/getting-started-extensions.md):**
+  Learn how to build your own extension.
+- **[Extension releasing](./extensions/extension-releasing.md):** How to release
+  Cell CLI extensions.
+
+### Hooks
+
+- **[Hooks](./hooks/index.md):** Intercept and customize Cell CLI behavior at
+  key lifecycle points.
+- **[Writing Hooks](./hooks/writing-hooks.md):** Learn how to create your first
+  hook with a comprehensive example.
+- **[Best Practices](./hooks/best-practices.md):** Security, performance, and
+  debugging guidelines for hooks.
+
+### IDE integration
+
+- **[Introduction to IDE integration](./ide-integration/index.md):** Connect the
+  CLI to your editor.
+- **[IDE companion extension spec](./ide-integration/ide-companion-spec.md):**
+  Spec for building IDE companion extensions.
+
+### Development
+
+- **[NPM](./npm.md):** Details on how the project's packages are structured.
+- **[Releases](./releases.md):** Information on the project's releases and
+  deployment cadence.
+- **[Changelog](./changelogs/index.md):** Highlights and notable changes to Cell
+  CLI.
+- **[Integration tests](./integration-tests.md):** Information about the
+  integration testing framework used in this project.
+- **[Issue and PR automation](./issue-and-pr-automation.md):** A detailed
+  overview of the automated processes we use to manage and triage issues and
+  pull requests.
+
+### Support
+
+- **[FAQ](./faq.md):** Frequently asked questions.
+- **[Troubleshooting guide](./troubleshooting.md):** Find solutions to common
+  problems.
+- **[Quota and pricing](./quota-and-pricing.md):** Learn about the free tier and
+  paid options.
+- **[Terms of service and privacy notice](./tos-privacy.md):** Information on
+  the terms of service and privacy notices applicable to your use of Cell CLI.
+
+We hope this documentation helps you make the most of Cell CLI!