Entire

https://docs.entire.io
Admin
Entire is a developer platform that integrates with Git workflows to capture and version AI agent...
Tokens:21,525
Snippets:341
Trust Score:5.3
Update:6 months ago
Show doc for...
Tokens:
Raw
### Example Workflow Setup

Source: https://docs.entire.io/integrations/copilot-cli

Initial setup steps for the Copilot CLI integration workflow, including navigating to the project directory and enabling the agent.

```bash
# 1. Setup
cd my-project
entire enable --agent copilot-cli
```

--------------------------------

### Example Workflow: Enable and Start Droid

Source: https://docs.entire.io/integrations/factory-droid

A sample workflow demonstrating how to enable Entire with the Factory Droid agent and then start the Droid agent.

```bash
# 1. Enable Entire with Factory Droid
cd my-project
entire enable --agent factoryai-droid

# 2. Start Droid
droid

# 3. Work with Droid
# Ask it to write code, make changes, etc.
```

--------------------------------

### Example Workflow for Gemini CLI and Entire

Source: https://docs.entire.io/integrations/gemini-cli

This workflow demonstrates the typical steps for setting up and using Gemini CLI within an Entire-enabled repository. It includes enabling Entire, starting Gemini CLI, working with the AI, checking status, rewinding if necessary, committing changes, and pushing to the remote repository.

```bash
# 1. Setup
cd my-project
entire enable

# 2. Start Gemini CLI
gemini

# 3. Work with Gemini
# Ask it to write code, make changes, etc.

# 4. Check session (in another terminal)
entire status

# 5. Rewind if needed
entire rewind

# 6. Commit when ready
git add .
git commit -m "Add feature with Gemini"

# 7. Push
git push
```

--------------------------------

### Project Settings Example

Source: https://docs.entire.io/cli/configuration

Example of project-specific Entire.io settings stored in `.entire/settings.json`, setting the log level to 'info'.

```json
{
  "log_level": "info"
}
```

--------------------------------

### Install Entire CLI from Source (Go)

Source: https://docs.entire.io/cli/installation

Build and install the Entire CLI from source using Go 1.21+. This method requires Go to be installed on your system.

```bash
go install github.com/entireio/cli/cmd/entire@latest
```

--------------------------------

### Example Claude Code and Entire Workflow

Source: https://docs.entire.io/integrations/claude-code

A comprehensive example demonstrating the typical workflow of enabling Entire, starting Claude Code, making changes, checking status, rewinding if necessary, and committing changes.

```bash
# 1. Enable Entire
cd my-project
entire enable

# 2. Start Claude Code
claude

# 3. Work with Claude (in Claude Code)
> Add user authentication with JWT tokens

# 4. Check status (in another terminal)
entire status

# 5. Made a mistake? Rewind
entire rewind

# 6. Commit when ready
git add .
git commit -m "Add JWT authentication"

# 7. Push to see on entire.io
git push
```

--------------------------------

### Local Settings Example

Source: https://docs.entire.io/cli/configuration

Example of local Entire.io overrides stored in `.entire/settings.local.json`, setting the log level to 'debug'.

```json
{
  "log_level": "debug"
}
```

--------------------------------

### Install Entire CLI with Install Script (Linux)

Source: https://docs.entire.io/cli/installation

Use the provided curl script to install the Entire CLI on Linux systems. This method is suitable for most Linux distributions.

```bash
curl -fsSL https://entire.io/install.sh | bash
```

--------------------------------

### Example Workflow

Source: https://docs.entire.io/integrations/opencode

A standard sequence for enabling, using, and managing an OpenCode session with Entire.

```bash
# 1. Enable Entire with OpenCode
cd my-project
entire enable --agent opencode

# 2. Start OpenCode
opencode

# 3. Work with OpenCode
# Ask it to write code, make changes, etc.

# 4. Rewind if needed
entire rewind

# 5. Commit when ready
git add .
git commit -m "Add feature with OpenCode"
```

--------------------------------

### Install Entire CLI with Homebrew (macOS)

Source: https://docs.entire.io/cli/installation

Use Homebrew to install the Entire CLI on macOS. This is the recommended method for macOS users.

```bash
brew install entireio/tap/entire
```

--------------------------------

### Enable Entire for OpenCode

Source: https://docs.entire.io/integrations/opencode

Install the Entire plugin for OpenCode to begin session tracking.

```bash
entire enable --agent opencode
```

--------------------------------

### Verify Entire CLI Installation

Source: https://docs.entire.io/cli/installation

Check if the Entire CLI is installed correctly by running the version command. Ensure the 'entire' binary is in your system's PATH.

```bash
entire version
```

--------------------------------

### Initialize Entire in a Git repository

Source: https://docs.entire.io/cli/commands

Installs Git hooks to capture AI coding sessions.

```bash
entire enable [flags]
```

--------------------------------

### Install Hooks Command

Source: https://docs.entire.io/cli/external-agents

Called to install your hooks into the agent, for example, by writing hook config files. Supports local development and force installation.

```shell
install-hooks [--local-dev] [--force]
```

--------------------------------

### Effective Configuration Example

Source: https://docs.entire.io/cli/configuration

Demonstrates the effective configuration by merging global, project, and local settings, where local settings take precedence.

```json
{
  "log_level": "debug",         // from local (overrides project)
  "telemetry": true             // from global
}
```

--------------------------------

### Troubleshoot Entire Integration

Source: https://docs.entire.io/integrations/factory-droid

Diagnostic commands to verify repository configuration and hook installation.

```bash
entire status
```

```bash
ls .git/hooks
```

--------------------------------

### entire enable

Source: https://docs.entire.io/cli/commands

Initializes Entire in a Git repository by installing necessary Git hooks to capture AI coding sessions.

```APIDOC
## CLI COMMAND: entire enable

### Description
Initialize Entire in a Git repository. This installs the necessary Git hooks to capture AI coding sessions.

### Parameters
#### Flags
- **--absolute-git-hook-path** (string) - Optional - Embed full binary path in Git hooks.
- **--agent** (string) - Optional - Agent to setup hooks for: claude-code, codex, gemini, opencode, or factoryai-droid.
- **--checkpoint-remote** (string) - Optional - Push checkpoint branches to a separate repository.
- **-f, --force** (boolean) - Optional - Force reinstall hooks.
- **--local** (boolean) - Optional - Write settings to .entire/settings.local.json.
- **--project** (boolean) - Optional - Write settings to .entire/settings.json.
- **--skip-push-sessions** (boolean) - Optional - Disable automatic pushing of session logs on Git push.
- **--telemetry** (boolean) - Optional - Enable anonymous usage analytics.
```

--------------------------------

### Calculate token usage

Source: https://docs.entire.io/cli/external-agents

Example output for token calculation. Only input_tokens and output_tokens are mandatory.

```json
{
  "input_tokens": 1500,
  "output_tokens": 500,
  "cache_creation_tokens": 0,
  "cache_read_tokens": 200,
  "api_call_count": 3
}
```

--------------------------------

### Git Commit Trailer Example

Source: https://docs.entire.io/cli/checkpoints

Shows the format of a commit message containing an Entire-Checkpoint trailer.

```text
feat: Add user authentication

This commit adds OAuth2 login flow with Google and GitHub providers.

Entire-Checkpoint: a3b2c4d5e6f7
```

--------------------------------

### Start Copilot CLI Session

Source: https://docs.entire.io/integrations/copilot-cli

Initiates an interactive Copilot CLI session. This command is used after enabling the integration.

```bash
# 2. Start Copilot CLI
copilot
```

--------------------------------

### Verify Git Hooks Installation

Source: https://docs.entire.io/integrations/claude-code

Check if Git hooks are installed in your project's .git/hooks directory. This is necessary for certain Entire functionalities.

```bash
ls .git/hooks
```

--------------------------------

### GET info

Source: https://docs.entire.io/cli/external-agents

Returns metadata and declares which optional capabilities the plugin supports.

```APIDOC
## GET info

### Description
Returns metadata and declares which optional capabilities your plugin supports.

### Method
CLI Subcommand (info)

### Response
- **protocol_version** (integer) - Must match the CLI's expected version (currently 1)
- **name** (string) - Registry name
- **type** (string) - Display name / type identifier
- **description** (string) - Human-readable description
- **is_preview** (boolean) - Whether the agent is in preview
- **protected_dirs** (array) - Directories the CLI should not modify
- **hook_names** (array) - Agent lifecycle hooks this plugin handles
- **capabilities** (object) - Object declaring which optional capabilities are supported

### Response Example
{
  "protocol_version": 1,
  "name": "myagent",
  "type": "MyAgent",
  "description": "MyAgent - AI-powered code editor",
  "is_preview": true,
  "protected_dirs": [".myagent"],
  "hook_names": ["session-start", "session-end", "stop"],
  "capabilities": {
    "hooks": true,
    "transcript_analyzer": true,
    "transcript_preparer": false,
    "token_calculator": false,
    "text_generator": false,
    "hook_response_writer": false,
    "subagent_aware_extractor": false
  }
}
```

--------------------------------

### GET detect

Source: https://docs.entire.io/cli/external-agents

Returns whether the agent is available in the current environment.

```APIDOC
## GET detect

### Description
Returns whether the agent is available in the current environment. Return {"present": false} if the agent's dependencies are not met.

### Method
CLI Subcommand (detect)

### Response
- **present** (boolean) - Whether the agent is available

### Response Example
{
  "present": true
}
```

--------------------------------

### Configure Entire CLI and Agent Hooks

Source: https://docs.entire.io/cli/commands

Use the 'configure' command to set up Entire and manage agent hooks. On the first run, it installs hooks. Subsequent runs allow enabling more agents.

```bash
entire configure [flags]
```

```bash
entire configure --remove claude-code
```

--------------------------------

### View Commit Trailer Linking

Source: https://docs.entire.io/core-concepts

Example of how Entire links a specific commit to a session checkpoint using a Git trailer.

```text
feat: Add login form validation

Entire-Checkpoint: a3b2c4d5e6f7
```

--------------------------------

### Example Codex and Entire Workflow

Source: https://docs.entire.io/integrations/codex

This bash script outlines a typical workflow for using Codex with Entire, from enabling the agent to committing and pushing changes. Ensure you are in the project directory before running.

```bash
cd my-project
entire enable --agent codex
codex
entire status
entire rewind
git add .
git commit -m "Add feature with Codex"
git push
```

--------------------------------

### Explain Commits and Checkpoints with Entire CLI

Source: https://docs.entire.io/integrations/gemini-cli

Utilize the 'entire explain' command to get explanations for specific commits or checkpoints. Use '--commit' for commit SHAs or '--checkpoint' for checkpoint IDs. The '--full' flag displays the complete transcript, while '--short' shows only the summary.

```bash
# Explain a specific commit
entire explain --commit abc1234

# Explain a specific checkpoint
entire explain --checkpoint a3b2c4d5

# Show full transcript
entire explain --full
```

--------------------------------

### Chunk transcript data

Source: https://docs.entire.io/cli/external-agents

Example output format for chunked transcript data.

```json
{"chunks": ["<base64-encoded-chunk>", "..."]}
```

--------------------------------

### Start Coding Session with AI Assistants

Source: https://docs.entire.io/quickstart

Initiate a coding session with your preferred AI assistant after enabling Entire. Entire will automatically capture checkpoints for commits made during these sessions.

```bash
# Example with Claude Code
claude
```

```bash
# Example with Codex
codex
```

```bash
# Example with Gemini CLI
gemini
```

```bash
# Example with OpenCode
opencode
```

```bash
# Example with Factory Droid
droid
```

--------------------------------

### Upgrade Entire CLI with Homebrew (macOS)

Source: https://docs.entire.io/cli/installation

Upgrade an existing Entire CLI installation to the latest version using Homebrew on macOS.

```bash
brew upgrade entire
```

--------------------------------

### Get Session Directory Command

Source: https://docs.entire.io/cli/external-agents

Return where sessions are stored. Requires the repository path as an argument.

```shell
get-session-dir --repo-path <path>
```

--------------------------------

### Commit Trailer for Line Attribution

Source: https://docs.entire.io/core-concepts

This example shows the `Entire-Attribution` trailer added to Git commits, indicating the percentage of code contributed by the agent versus a human.

```git
feat: Add user authentication

Entire-Checkpoint: a3b2c4d5e6f7
Entire-Attribution: 73% agent (146/200 lines)
```

--------------------------------

### Enable Entire with Codex Agent

Source: https://docs.entire.io/integrations/codex

Install Entire's Codex hooks and enable the required features flag. This command automatically configures `.codex/config.toml`.

```bash
entire enable --agent codex
```

--------------------------------

### Run Entire Doctor for Troubleshooting

Source: https://docs.entire.io/integrations/codex

Execute the Entire Doctor command to diagnose and identify potential issues with your Entire hook setup, especially when transcripts are not captured.

```bash
entire doctor
```

--------------------------------

### Enable Factory Droid Agent

Source: https://docs.entire.io/integrations/factory-droid

Enable the Factory Droid agent for Entire. This command installs the necessary hooks to track the session lifecycle.

```bash
entire enable --agent factoryai-droid
```

--------------------------------

### Uninstall Entire CLI Manually

Source: https://docs.entire.io/cli/installation

Remove the Entire CLI binary and its configuration files if installed manually. This involves deleting the binary and the configuration directory.

```bash
sudo rm /usr/local/bin/entire
rm -rf ~/.config/entire
```

--------------------------------

### AgentSession Data Structure

Source: https://docs.entire.io/cli/external-agents

Used as input to `write-session` and output from `read-session`. It contains session identifiers, repository path, session reference, start time, and lists of modified, new, and deleted files.

```json
{
  "session_id": "abc123",
  "agent_name": "myagent",
  "repo_path": "/path/to/repo",
  "session_ref": "/path/to/transcript.jsonl",
  "start_time": "2026-01-13T12:00:00Z",
  "native_data": null,
  "modified_files": ["src/main.go"],
  "new_files": [],
  "deleted_files": []
}
```

--------------------------------

### Enable Absolute Git Hook Path

Source: https://docs.entire.io/cli/configuration

Use the `--absolute-git-hook-path` flag during initial setup or configuration to ensure GUI Git clients can find the 'entire' binary by embedding its full path in Git hooks.

```bash
# During initial setup
entire enable --absolute-git-hook-path
```

```bash
# Or if Entire is already configured
entire configure --absolute-git-hook-path
```

--------------------------------

### Initialize Entire.io Configuration

Source: https://docs.entire.io/cli/configuration

When running `entire enable`, a `.entire` directory is created containing default settings files for project and local overrides, along with a `.gitignore` file.

```bash
# Example directory structure
.entire/
├── settings.json        # Project settings (committed)
├── settings.local.json  # Local overrides (gitignored)
└── .gitignore          # Ensures local settings aren't committed
```

--------------------------------

### GET get-session-dir

Source: https://docs.entire.io/cli/external-agents

Returns the directory where agent sessions are stored.

```APIDOC
## GET get-session-dir

### Description
Returns where agent sessions are stored based on the provided repository path.

### Method
CLI Subcommand (get-session-dir)

### Parameters
#### Query Parameters
- **repo-path** (string) - Required - The path to the repository

### Response
- **session_dir** (string) - The path to the session directory

### Response Example
{
  "session_dir": "/path/to/sessions"
}
```

--------------------------------

### entire help

Source: https://docs.entire.io/cli/commands

Displays help information about any command.

```APIDOC
## CLI COMMAND: entire help

### Description
Display help information about any command.

### Parameters
#### Arguments
- **command** (string) - Optional - The command to get help for.
```

--------------------------------

### Workflow with Cursor IDE

Source: https://docs.entire.io/integrations/cursor

Standard workflow for enabling Entire.io, running the Cursor IDE, and syncing changes to Entire.io.

```bash
# 1. Enable Entire
cd my-project
entire enable --agent cursor

# 2. Start Cursor IDE
cursor

# 3. Work with Cursor IDE
# Use @ mentions to attach files for context
# Ask the AI to implement features

# 4. Check status (in another terminal)
entire status

# 5. Commit when ready
git add .
git commit -m "Add feature with Cursor"

# 6. Push to see on entire.io
git push
```

--------------------------------

### Display help information

Source: https://docs.entire.io/cli/commands

Provides usage instructions for the CLI or specific commands.

```bash
entire help [command]
```

```bash
# Show general help
entire help

# Get help for a specific command
entire help enable
entire enable --help
```

--------------------------------

### entire version

Source: https://docs.entire.io/cli/commands

Show build information including the CLI version, Git commit, Go version, and OS/architecture.

```APIDOC
## entire version

### Description
Show build information including the CLI version, Git commit, Go version, and OS/architecture.
```

--------------------------------

### Enable Entire in Project

Source: https://docs.entire.io/integrations/claude-code

Initialize Entire in your project directory. This command must be run from within the repository.

```bash
cd my-project
entire enable
```

--------------------------------

### Checkpoint Sync Warning

Source: https://docs.entire.io/cli/checkpoints

Example of the warning message displayed when a checkpoint remote is unreachable.

```text
[entire] Pushing entire/checkpoints/v1 to checkpoint remote...
[entire] Warning: couldn't sync entire/checkpoints/v1: ...
[entire] A checkpoint remote is configured in Entire settings but could not be reached.
[entire] Checkpoints are saved locally but not synced. Ensure you have access to the checkpoint remote.
```

--------------------------------

### Get Session ID Command

Source: https://docs.entire.io/cli/external-agents

Extract the session ID from the hook input (stdin).

```shell
get-session-id
```

--------------------------------

### Download Entire CLI Binary (Linux ARM64)

Source: https://docs.entire.io/cli/installation

Download the Entire CLI binary specifically for Linux ARM64 systems. This is for systems with ARM architecture.

```bash
curl -LO https://github.com/entireio/cli/releases/latest/download/entire-linux-arm64.tar.gz
```

--------------------------------

### Write Hook Response Command

Source: https://docs.entire.io/cli/external-agents

Optionally write a startup message in your agent's native format. Requires the 'hook_response_writer' capability.

```shell
write-hook-response --message <msg>
```

--------------------------------

### Build Entire CLI Manually from Source

Source: https://docs.entire.io/cli/installation

Clone the Entire CLI repository and build the binary manually. This method provides more control over the build process.

```bash
git clone https://github.com/entireio/cli.git
cd cli
go build -o entire ./cmd/entire
sudo mv entire /usr/local/bin/
```

--------------------------------

### Uninstall Entire CLI with Homebrew

Source: https://docs.entire.io/cli/installation

Remove the Entire CLI from your system if it was installed using Homebrew on macOS.

```bash
brew uninstall entire
```

--------------------------------

### Troubleshooting Commands

Source: https://docs.entire.io/integrations/cursor

Commands used to verify Entire.io status, configuration, and system health.

```bash
entire status
```

```bash
cat .cursor/hooks.json
```

```bash
entire doctor
```

```bash
git status
```

```bash
git add
```

```bash
git commit
```

```bash
git diff
```

--------------------------------

### Explain Commits and Checkpoints

Source: https://docs.entire.io/integrations/factory-droid

View or generate explanations of code changes using the 'entire explain' command. Specify a commit, checkpoint, or request the full transcript.

```bash
# Explain a specific commit
entire explain --commit abc1234
```

```bash
# Explain a specific checkpoint
entire explain --checkpoint a3b2c4d5
```

```bash
# Show full transcript
entire explain --full
```

--------------------------------

### Explain Claude Code Commits and Checkpoints

Source: https://docs.entire.io/integrations/claude-code

Use the `entire explain` command to view or generate explanations for commits or checkpoints. Use `--generate` to create an AI summary. The `--full` flag shows the complete transcript.

```bash
# Explain a specific commit
entire explain --commit abc1234

# Explain a specific checkpoint
entire explain --checkpoint a3b2c4d5

# Generate an AI summary
entire explain --checkpoint a3b2c4d5 --generate

# Show full transcript
entire explain --full
```

--------------------------------

### View Committed Checkpoint Metadata

Source: https://docs.entire.io/core-concepts

Example of a Git commit message containing the Entire-Checkpoint trailer used for permanent checkpoint linking.

```text
Add user authentication

Entire-Checkpoint: a3b2c4d5e6f7
```

--------------------------------

### Get Session Directory Response

Source: https://docs.entire.io/cli/external-agents

The 'get-session-dir' command returns a JSON object specifying the path to the agent's session directory.

```json
{"session_dir": "/path/to/sessions"}
```

--------------------------------

### Basic Entire CLI Command Structure

Source: https://docs.entire.io/cli/commands

This is the general syntax for all Entire CLI commands. Replace [command] with the specific command and [flags] with any applicable options.

```bash
entire [command] [flags]
```

--------------------------------

### Get Session ID Input

Source: https://docs.entire.io/cli/external-agents

The 'get-session-id' subcommand extracts a session ID from the provided HookInput JSON, which is passed via stdin.

```json
{"session_id": "abc123"}
```

--------------------------------

### Environment Variable Overrides

Source: https://docs.entire.io/cli/configuration

Override Entire settings using environment variables. For example, set `ENTIRE_LOG_LEVEL` to control log verbosity globally.

```bash
# Example: Set log level via environment variable
export ENTIRE_LOG_LEVEL=debug
```

--------------------------------

### Manually Edit Settings Files

Source: https://docs.entire.io/cli/configuration

Project and local settings for Entire.io can be manually edited using a text editor like `vim`.

```bash
# Edit project settings
vim .entire/settings.json
```

```bash
# Edit local settings
vim .entire/settings.local.json
```

--------------------------------

### entire explain

Source: https://docs.entire.io/cli/commands

Generates an AI-powered explanation of a session or commit.

```APIDOC
## CLI COMMAND: entire explain

### Description
Generate an AI-powered explanation of a session or commit.

### Parameters
#### Flags
- **-c, --checkpoint** (string) - Optional - Explain a specific checkpoint (ID or prefix).
- **--commit** (string) - Optional - Explain a specific commit (SHA or ref).
- **--force** (boolean) - Optional - Regenerate summary even if one already exists.
- **--full** (boolean) - Optional - Show full parsed transcript.
- **--generate** (boolean) - Optional - Generate an AI summary for the checkpoint.
- **--no-pager** (boolean) - Optional - Disable pager output.
- **--raw-transcript** (boolean) - Optional - Show raw transcript file (JSONL format).
- **--search-all** (boolean) - Optional - Search all commits.
- **--session** (string) - Optional - Filter checkpoints by session ID.
- **-s, --short** (boolean) - Optional - Show summary only.
```

--------------------------------

### entire configure

Source: https://docs.entire.io/cli/commands

Configures Entire and manages agent hooks for the repository.

```APIDOC
## entire configure

### Description
Configures Entire and installs agent hooks. On subsequent runs, it allows enabling or removing specific agents.

### Method
CLI Command

### Endpoint
entire configure [flags]

### Parameters
#### Flags
- **--absolute-git-hook-path** (flag) - Optional - Embed full binary path in Git hooks.
- **--agent <name>** (flag) - Optional - Enable a specific agent (e.g., claude-code, codex, gemini).
- **-f, --force** (flag) - Optional - Force reinstall hooks.
- **--local** (flag) - Optional - Write settings to .entire/settings.local.json.
- **--project** (flag) - Optional - Write settings to .entire/settings.json.
- **--remove <name>** (flag) - Optional - Remove a specific agent's hooks.
- **--skip-push-sessions** (flag) - Optional - Disable automatic pushing of session logs.
- **--telemetry** (flag) - Optional - Enable anonymous usage analytics.
```

--------------------------------

### Workflow with Cursor CLI

Source: https://docs.entire.io/integrations/cursor

Workflow for using the Cursor CLI with Entire.io, supporting parallel sessions and manual instruction.

```bash
# 1. Enable Entire
cd my-project
entire enable --agent cursor

# 2. Run Cursor CLI
agent

# 2.1 Instruct Cursor CLI
"refactor the authentication module"

# 3. In parallel terminal, run another Cursor CLI
agent

# 3.1 Instruct the other CLI
"update database schema"

# 4. Check both sessions
entire status

# 5. Commit all changes
git add .
git commit -m "Parallel refactoring with Cursor CLI"

# 6. Push to see on entire.io
git push
```

--------------------------------

### Enable Telemetry via CLI

Source: https://docs.entire.io/cli/configuration

Telemetry can be enabled for Entire.io using the `entire enable --telemetry` command.

```bash
# Enable telemetry
entire enable --telemetry
```

--------------------------------

### entire resume

Source: https://docs.entire.io/cli/commands

Switch to a local branch and resume the agent session from its last commit.

```APIDOC
## entire resume

### Description
Switch to a local branch and resume the agent session from its last commit. This command checks out the branch, finds the session ID, and restores the session log.

### Parameters
#### Arguments
- **branch** (string) - Required - The branch to resume the agent session from

#### Flags
- **-f, --force** (boolean) - Optional - Resume from older checkpoint without confirmation
```

--------------------------------

### Download Entire CLI Binary (Linux)

Source: https://docs.entire.io/cli/installation

Manually download the latest Entire CLI binary for Linux (amd64 architecture). Ensure the binary is added to your system's PATH.

```bash
# Download the latest release
curl -LO https://github.com/entireio/cli/releases/latest/download/entire-linux-amd64.tar.gz

# Extract and install
tar -xzf entire-linux-amd64.tar.gz
sudo mv entire /usr/local/bin/
```

--------------------------------

### Generate AI-powered explanations

Source: https://docs.entire.io/cli/commands

Creates summaries or displays transcripts for specific sessions or commits.

```bash
entire explain [flags]
```

--------------------------------

### Explain Commits and Checkpoints

Source: https://docs.entire.io/integrations/copilot-cli

View or generate explanations for specific commits or checkpoints within Copilot CLI sessions. Use flags to control the output detail.

```bash
# Explain a specific commit
entire explain --commit abc1234
```

```bash
# Explain a specific checkpoint
entire explain --checkpoint a3b2c4d5
```

```bash
# Generate an AI summary
entire explain --checkpoint a3b2c4d5 --generate
```

```bash
# Show full transcript
entire explain --full
```

--------------------------------

### Enable Auto-Summarize Configuration

Source: https://docs.entire.io/cli/checkpoints

JSON configuration to enable automatic session summarization.

```json
{
  "strategy_options": {
    "summarize": {
      "enabled": true
    }
  }
}
```

--------------------------------

### Add and Commit Changes with Git

Source: https://docs.entire.io/integrations/copilot-cli

Use these Git commands to stage all changes and create a commit with a descriptive message.

```git
git add .
git commit -m "Add feature with Copilot"
```

--------------------------------

### Configure Checkpoint Remote

Source: https://docs.entire.io/cli/checkpoints

Methods for setting up a remote repository for checkpoint storage.

```bash
entire enable --checkpoint-remote github:myorg/checkpoints-private
```

```json
{
  "strategy_options": {
    "checkpoint_remote": {
      "provider": "github",
      "repo": "myorg/checkpoints-private"
    }
  }
}
```

--------------------------------

### View Detailed Configuration Status

Source: https://docs.entire.io/cli/configuration

Use the `entire status --detailed` command to view the effective configuration, including the source of each setting.

```bash
entire status --detailed
```

--------------------------------

### Enable Entire in Repository

Source: https://docs.entire.io/quickstart

Enable Entire in your local Git repository to automatically capture AI coding session checkpoints. Navigate to your project directory first.

```bash
cd your-project
entire enable
```

--------------------------------

### Strategy Options Configuration

Source: https://docs.entire.io/cli/configuration

Configure options for how Entire captures and stores session data, such as automatically pushing sessions or enabling AI summaries at commit time. This is part of the project settings.

```json
{
  "strategy_options": {
    "push_sessions": true,
    "checkpoint_remote": {
      "provider": "github",
      "repo": "myorg/checkpoints-private"
    }
  }
}
```

--------------------------------

### Agent Info Command

Source: https://docs.entire.io/cli/external-agents

Use the 'info' subcommand to retrieve metadata about your agent and declare its supported capabilities. This is a required subcommand for all plugins.

```bash
entire-agent-myagent info
```

--------------------------------

### Enable Copilot CLI Integration

Source: https://docs.entire.io/integrations/copilot-cli

Enable Entire's integration with Copilot CLI. This command sets up the necessary hooks for Entire to capture session data.

```bash
entire enable --agent copilot-cli
```

--------------------------------

### Project Settings Configuration

Source: https://docs.entire.io/cli/configuration

Define project-wide settings like enabled status, log level, and telemetry. These settings are stored in .entire/settings.json and committed to your repository.

```json
{
  "enabled": true,
  "log_level": "info",
  "telemetry": true,
  "strategy_options": {}
}
```

--------------------------------

### Manage Entire Sessions via CLI

Source: https://docs.entire.io/integrations/factory-droid

Commands for checking session status, rewinding, and committing changes to the repository.

```bash
entire status
```

```bash
entire rewind
```

```bash
git add .
git commit -m "Add feature with Droid"
```

```bash
git push
```

--------------------------------

### Configure Manual Commit Strategy

Source: https://docs.entire.io/integrations/opencode

Set the commit strategy to manual to control when checkpoints are created.

```bash
entire enable --agent opencode --strategy manual-commit
```

```bash
git add .
git commit -m "Implement feature with OpenCode"
```

--------------------------------

### entire trace

Source: https://docs.entire.io/cli/commands

Show hook performance traces for debugging slow Git operations.

```APIDOC
## entire trace

### Description
Show hook performance traces for debugging slow Git operations. Requires DEBUG log level.

### Parameters
#### Flags
- **--last** (integer) - Optional - Show last N hook invocations (default: 1)
- **--hook** (string) - Optional - Filter by hook type (e.g., post-commit, prepare-commit-msg, pre-push)
```

--------------------------------

### Agent Info JSON Response

Source: https://docs.entire.io/cli/external-agents

The 'info' subcommand returns a JSON object detailing the agent's protocol version, name, type, description, preview status, protected directories, supported hooks, and capabilities. Ensure the protocol version matches the CLI's expected version.

```json
{
  "protocol_version": 1,
  "name": "myagent",
  "type": "MyAgent",
  "description": "MyAgent - AI-powered code editor",
  "is_preview": true,
  "protected_dirs": [".myagent"],
  "hook_names": ["session-start", "session-end", "stop"],
  "capabilities": {
    "hooks": true,
    "transcript_analyzer": true,
    "transcript_preparer": false,
    "token_calculator": false,
    "text_generator": false,
    "hook_response_writer": false,
    "subagent_aware_extractor": false
  }
}
```

--------------------------------

### Format resume command

Source: https://docs.entire.io/cli/external-agents

Returns the command string required to resume a specific session.

```json
{"command": "myagent --resume abc123"}
```

--------------------------------

### Global Settings Configuration

Source: https://docs.entire.io/cli/configuration

Set default configuration values that apply to all repositories on your system. These are stored in ~/.config/entire/settings.json.

```json
{
  "telemetry": true
}
```

--------------------------------

### Push code to entire.io

Source: https://docs.entire.io/integrations/opencode

Use this command to push your current code changes to your entire.io session. Ensure you are in an Entire-enabled repository.

```bash
git push
```

--------------------------------

### Hook Management

Source: https://docs.entire.io/cli/external-agents

Commands for managing agent lifecycle hooks for Entire integration.

```APIDOC
## hooks

### Description
Manage agent lifecycle hooks for Entire integration.

#### parse-hook --hook <name>

### Description
Parse a raw hook payload (stdin) into an [Event](#event). Return `null` if not relevant.

### Method
CLI Command

### Endpoint
parse-hook

### Parameters
#### Query Parameters
- **hook** (string) - Required - The name of the hook to parse.

#### Request Body
- **stdin** (JSON) - Required - Raw hook payload.

## install-hooks [--local-dev] [--force]

### Description
Install hooks. `--local-dev` installs hooks pointing to a local development build. `--force` overwrites existing hook files.

### Method
CLI Command

### Endpoint
install-hooks

### Parameters
#### Query Parameters
- **local-dev** (boolean) - Optional - Install hooks pointing to a local development build.
- **force** (boolean) - Optional - Overwrite existing hook files.

### Response Example
```json
{
  "hooks_installed": 3
}
```

## uninstall-hooks

### Description
Remove installed hooks.

### Method
CLI Command

### Endpoint
uninstall-hooks

### Response
#### Success Response
Exit `0` on success.

## are-hooks-installed

### Description
Check hook status.

### Method
CLI Command

### Endpoint
are-hooks-installed

### Response Example
```json
{
  "installed": true
}
```
```

--------------------------------

### Resume Previous Gemini CLI Sessions

Source: https://docs.entire.io/integrations/gemini-cli

Use the 'entire resume <branch>' command to switch to a previous Gemini CLI session's branch. This command checks out the branch, identifies the session ID, restores the session log if necessary, and provides instructions to resume the session.

```bash
entire resume <branch>
```

--------------------------------

### Enable Entire for Cursor

Source: https://docs.entire.io/integrations/cursor

Configures the necessary hooks for Entire to track Cursor sessions.

```bash
entire enable --agent cursor
```

--------------------------------

### Enable Zsh Shell Completion for Entire CLI

Source: https://docs.entire.io/cli/installation

Add Entire CLI shell completion for Zsh by sourcing the completion script in your ~/.zshrc file.

```bash
source <(entire completion zsh)
```

--------------------------------

### Local Settings Override

Source: https://docs.entire.io/cli/configuration

Override project settings for personal preferences using local settings. These are stored in .entire/settings.local.json and are automatically ignored by Git.

```json
{
  "log_level": "debug",
  "telemetry": false
}
```

--------------------------------

### Checkpoint and Session Folder Structure

Source: https://docs.entire.io/core-concepts

This structure shows how checkpoint and session data is organized on the `entire/checkpoints/v1` branch, sharded by the first two characters of the checkpoint ID.

```tree
entire/checkpoints/v1 (branch)
├── 0b/                              # Shard (first 2 chars of checkpoint ID)
├── 0c/
├── 0f/                              # Checkpoint (remaining chars)
│   ├── 45ffa1b752/                  
│   ├── 4637ba1146/                  
│   └── f8ca6db1c9/                  # Full ID: 0ff8ca6db1c9
│       ├── metadata.json            # Checkpoint metadata
│       └── 0/                       # Session folder (numbered)
│           ├── content_hash.txt     # Hash of the content
│           ├── context.md           # Markdown of your prompts
│           ├── full.jsonl           # Full transcript with agent
│           ├── metadata.json        # Token usage, attribution, etc.
│           └── prompt.txt           # Raw prompts submitted
├── 10/
├── 11/
└── ...
```

--------------------------------

### Enable Bash Shell Completion for Entire CLI

Source: https://docs.entire.io/cli/installation

Add Entire CLI shell completion for Bash by sourcing the completion script in your ~/.bashrc file.

```bash
source <(entire completion bash)
```

--------------------------------

### Commit Changes in an Entire-Enabled Repository

Source: https://docs.entire.io/integrations/gemini-cli

Follow best practices by committing changes at logical points when using Gemini CLI with Entire. Ensure all modifications are staged using 'git add .' before committing with a descriptive message.

```bash
git add .
git commit -m "Implement feature with Gemini assistance"
```

--------------------------------

### Rewind Repository to Checkpoint using CLI

Source: https://docs.entire.io/web/checkpoints

Use this command to restore your local repository to the state of a specific checkpoint. Ensure you commit or stash uncommitted changes before running this command, as it discards them.

```bash
entire rewind --to <checkpoint-id>
```

--------------------------------

### Write Session Command

Source: https://docs.entire.io/cli/external-agents

Persist updated session data.

```shell
write-session
```

--------------------------------

### Commit Changes with Droid Assistance

Source: https://docs.entire.io/integrations/factory-droid

Commit meaningful progress made with Droid's assistance. Ensure code is staged before committing.

```bash
git add .
git commit -m "Implement feature with Droid assistance"
```

--------------------------------

### Export session data

Source: https://docs.entire.io/integrations/opencode

Use this command to export session data, which can help in troubleshooting issues with checkpoints not being created. Replace `<session-id>` with your actual session ID.

```bash
opencode export <session-id>
```

--------------------------------

### Read Session Command

Source: https://docs.entire.io/cli/external-agents

Read existing session data from stdin.

```shell
read-session
```
Tokens:
Raw