USP

This project provides a unique methodology and a community-driven hub for creating stateful, agent-native CLIs for virtually any software, offering a unified approach to integrate diverse applications into AI workflows.

Use cases

01Automating CAD builds and 3D scene generation
02Managing vector databases and semantic search
03Creating and exporting GIS projects with QGIS
04Controlling network-wide ad blocking with AdGuard Home
05Generating documents, slides, and websites from prompts

Detected files (8)

anygen/agent-harness/cli_anything/anygen/skills/SKILL.mdskill

Show content (3996 bytes)

---
name: >-
  cli-anything-anygen
description: >-
  Command-line interface for Anygen - A stateful command-line interface for AnyGen OpenAPI — generate professional slides, documents, webs...
---

# cli-anything-anygen

A stateful command-line interface for AnyGen OpenAPI — generate professional slides, documents, websites, diagrams, and more from natural language prompts. Designed for AI agents and power users.

## Installation

This CLI is installed as part of the cli-anything-anygen package:

```bash
pip install cli-anything-anygen
```

**Prerequisites:**
- Python 3.10+
- anygen must be installed on your system


## Usage

### Basic Commands

```bash
# Show help
cli-anything-anygen --help

# Start interactive REPL mode
cli-anything-anygen

# Create a new project
cli-anything-anygen project new -o project.json

# Run with JSON output (for agent consumption)
cli-anything-anygen --json project info -p project.json
```

### REPL Mode

When invoked without a subcommand, the CLI enters an interactive REPL session:

```bash
cli-anything-anygen
# Enter commands interactively with tab-completion and history
```


## Command Groups


### Task

Task management — create, poll, download, and run tasks.

| Command | Description |
|---------|-------------|
| `create` | Create a generation task |
| `status` | Query task status (non-blocking) |
| `poll` | Poll task until completion (blocking) |
| `download` | Download the generated file for a completed task |
| `thumbnail` | Download thumbnail image for a completed task |
| `run` | Full workflow: create, poll, download |
| `list` | List locally cached task records |
| `prepare` | Multi-turn requirement analysis before creating a task |


### File

File operations — upload reference files.

| Command | Description |
|---------|-------------|
| `upload` | Upload a reference file to get a file_token |


### Config

Configuration management — API key and settings.

| Command | Description |
|---------|-------------|
| `set` | Set a configuration value |
| `get` | Get a configuration value (or show all) |
| `delete` | Delete a configuration value |
| `path` | Show the config file path |


### Session

Session management — history, undo, redo.

| Command | Description |
|---------|-------------|
| `status` | Show session status |
| `history` | Show command history |
| `undo` | Undo last command |
| `redo` | Redo last undone command |




## Examples


### Create a New Project

Create a new anygen project file.

```bash
cli-anything-anygen project new -o myproject.json
# Or with JSON output for programmatic use
cli-anything-anygen --json project new -o myproject.json
```


### Interactive REPL Session

Start an interactive session with undo/redo support.

```bash
cli-anything-anygen
# Enter commands interactively
# Use 'help' to see available commands
# Use 'undo' and 'redo' for history navigation
```


## State Management

The CLI maintains session state with:

- **Undo/Redo**: Up to 50 levels of history
- **Project persistence**: Save/load project state as JSON
- **Session tracking**: Track modifications and changes

## Output Formats

All commands support dual output modes:

- **Human-readable** (default): Tables, colors, formatted text
- **Machine-readable** (`--json` flag): Structured JSON for agent consumption

```bash
# Human output
cli-anything-anygen project info -p project.json

# JSON output for agents
cli-anything-anygen --json project info -p project.json
```

## For AI Agents

When using this CLI programmatically:

1. **Always use `--json` flag** for parseable output
2. **Check return codes** - 0 for success, non-zero for errors
3. **Parse stderr** for error messages on failure
4. **Use absolute paths** for all file operations
5. **Verify outputs exist** after export operations

## More Information

- Full documentation: See README.md in the package
- Test coverage: See TEST.md in the package
- Methodology: See HARNESS.md in the cli-anything-plugin

## Version

1.0.0

chromadb/agent-harness/cli_anything/chromadb/skills/SKILL.mdskill

Show content (2910 bytes)

---
name: >-
  cli-anything-chromadb
description: >-
  Command-line interface for ChromaDB - A stateless CLI for managing vector database collections, documents, and semantic search. Designed for AI agents and automation via the ChromaDB HTTP API v2.
---

# cli-anything-chromadb

A stateless command-line interface for ChromaDB vector database, built on the HTTP API v2. Designed for AI agents and power users who need to manage collections, documents, and run semantic queries without a browser UI.

## Installation

This CLI is installed as part of the cli-anything-chromadb package:

```bash
pip install cli-anything-chromadb
```

**Prerequisites:**
- Python 3.10+
- ChromaDB server running at localhost:8000 (or specify via --host)

## Usage

### Basic Commands

```bash
# Show help
cli-anything-chromadb --help

# Start interactive REPL mode
cli-anything-chromadb

# Check server health
cli-anything-chromadb --json server heartbeat

# List all collections
cli-anything-chromadb --json collection list

# Semantic search
cli-anything-chromadb --json query search --collection hub_knowledge --text "How to deploy"
```

### REPL Mode

When invoked without a subcommand, the CLI enters an interactive REPL session:

```bash
cli-anything-chromadb
# Enter commands interactively with tab-completion and history
```

## Command Groups

### server
Server health and version commands.

| Command | Description |
|---------|-------------|
| `heartbeat` | Check ChromaDB server health |
| `version` | Get ChromaDB server version |

### collection
Manage ChromaDB collections.

| Command | Description |
|---------|-------------|
| `list` | List all collections |
| `create --name NAME` | Create a new collection |
| `delete --name NAME` | Delete a collection |
| `info NAME` | Get collection info |

### document
Manage documents in collections.

| Command | Description |
|---------|-------------|
| `add --collection C --id ID --document TEXT` | Add document(s) |
| `get --collection C` | Get documents |
| `delete --collection C --id ID` | Delete document(s) |
| `count --collection C` | Count documents |

### query
Semantic search against collections.

| Command | Description |
|---------|-------------|
| `search --collection C --text T` | Semantic search |

## Output Formats

All commands support dual output modes:

- **Human-readable** (default): Tables, colors, formatted text
- **Machine-readable** (`--json` flag): Structured JSON for agent consumption

```bash
# Human output
cli-anything-chromadb server heartbeat

# JSON output for agents
cli-anything-chromadb --json server heartbeat
```

## For AI Agents

When using this CLI programmatically:

1. **Always use `--json` flag** for parseable output
2. **Check return codes** - 0 for success, non-zero for errors
3. **Parse stderr** for error messages on failure
4. **Use `--host`** to connect to non-default ChromaDB instances

## Version

1.0.0

QGIS/agent-harness/cli_anything/qgis/skills/SKILL.mdskill

Show content (3886 bytes)

---
name: cli-anything-qgis
description: Stateful QGIS CLI for projects, writable layers, features, layouts, exports, and qgis_process operations using the real QGIS runtime.
---

# cli-anything-qgis

Use this skill when you need to inspect or modify QGIS projects from the terminal through the real QGIS runtime.

## Requirements

- QGIS installed with `qgis_process` on `PATH`
- PyQGIS importable from the Python environment running the CLI
- Python 3.10+

## Agent guidance

- Prefer `--json` for all machine-driven use.
- For one-shot commands, pass `--project <path>` when operating on an existing project.
- Running `cli-anything-qgis` with no subcommand starts a stateful REPL.
- Layout export is backed by real QGIS processing algorithms:
  - `native:printlayouttopdf`
  - `native:printlayouttoimage`

## What this CLI covers

- create, open, save, and inspect `.qgs` / `.qgz` projects
- create writable GeoPackage-backed vector layers
- add features via WKT geometry and typed `key=value` attributes
- create print layouts and add map/label items
- export layouts to PDF or image
- inspect and run generic `qgis_process` algorithms
- inspect session status and history

## Command groups

### `project`
- `new -o/--output [--title] [--crs]`
- `open PATH`
- `save [PATH]`
- `info`
- `set-crs CRS`

### `layer`
- `create-vector --name --geometry --crs [--field name:type ...]`
- `list`
- `info LAYER`
- `remove LAYER`

### `feature`
- `add --layer LAYER --wkt WKT [--attr key=value ...]`
- `list --layer LAYER [--limit N]`

### `layout`
- `create --name [--page-size] [--orientation]`
- `list`
- `info LAYOUT`
- `remove LAYOUT`
- `add-map --layout LAYOUT --x --y --width --height [--extent xmin,ymin,xmax,ymax]`
- `add-label --layout LAYOUT --text TEXT --x --y --width --height [--font-size N]`

### `export`
- `presets`
- `pdf OUTPUT --layout LAYOUT [--dpi] [--force-vector] [--force-raster] [--georeference/--no-georeference] [--overwrite]`
- `image OUTPUT --layout LAYOUT [--dpi] [--overwrite]`

### `process`
- `list`
- `help ALGORITHM_ID`
- `run ALGORITHM_ID [--param KEY=VALUE ...]`

### `session`
- `status`
- `history [--limit N]`

## Examples

### Create a project and add a writable layer

```bash
cli-anything-qgis --json project new -o demo.qgz --title "Demo" --crs EPSG:4326
cli-anything-qgis --json --project demo.qgz layer create-vector \
  --name places \
  --geometry point \
  --field name:string \
  --field score:int
```

### Add features and inspect them

```bash
cli-anything-qgis --json --project demo.qgz feature add \
  --layer places \
  --wkt "POINT(1 2)" \
  --attr name=HQ \
  --attr score=5

cli-anything-qgis --json --project demo.qgz feature list --layer places --limit 10
```

### Create and export a layout

```bash
cli-anything-qgis --json --project demo.qgz layout create --name Main
cli-anything-qgis --json --project demo.qgz layout add-map --layout Main --x 10 --y 20 --width 180 --height 120
cli-anything-qgis --json --project demo.qgz layout add-label --layout Main --text "Demo map" --x 10 --y 8 --width 100 --height 10
cli-anything-qgis --json --project demo.qgz export pdf output.pdf --layout Main --overwrite
```

### Inspect or run processing algorithms

```bash
cli-anything-qgis --json process help native:buffer
cli-anything-qgis --json --project demo.qgz process run native:buffer \
  --param INPUT=/tmp/demo_data.gpkg|layername=places \
  --param DISTANCE=1 \
  --param SEGMENTS=8 \
  --param END_CAP_STYLE=0 \
  --param JOIN_STYLE=0 \
  --param MITER_LIMIT=2 \
  --param DISSOLVE=false \
  --param OUTPUT=/tmp/buffer.geojson
```

### REPL

```bash
cli-anything-qgis
```

Example interactive flow:

```text
project new -o demo.qgz --title "Demo"
layer create-vector --name places --geometry point --field name:string
feature add --layer places --wkt "POINT(1 2)" --attr name=HQ
layout create --name Main
session status
quit
```

adguardhome/agent-harness/cli_anything/adguardhome/skills/SKILL.mdskill

Show content (6209 bytes)

---
name: >-
  cli-anything-adguardhome
description: >-
  Command-line interface for AdGuard Home - Network-wide ad blocking and DNS management via AdGuard Home REST API. Designed for AI agents and power users who need to manage filtering, DNS rewrites, clients, DHCP, and query logs without a GUI.
---

# cli-anything-adguardhome

Network-wide ad blocking and DNS management via the AdGuard Home REST API. Designed for AI agents and power users who need to manage filtering, DNS rewrites, clients, DHCP, and query logs without a GUI.

## Installation

This CLI is installed as part of the cli-anything-adguardhome package:

```bash
pip install cli-anything-adguardhome
```

**Prerequisites:**
- Python 3.10+
- AdGuard Home must be installed and running
- Install AdGuard Home: `curl -s -S -L https://raw.githubusercontent.com/AdguardTeam/AdGuardHome/master/scripts/install.sh | sh -s -- -v`

## Usage

### Basic Commands

```bash
# Show help
cli-anything-adguardhome --help

# Start interactive REPL mode
cli-anything-adguardhome

# Check server status
cli-anything-adguardhome server status

# Run with JSON output (for agent consumption)
cli-anything-adguardhome --json server status
```

### REPL Mode

When invoked without a subcommand, the CLI enters an interactive REPL session:

```bash
cli-anything-adguardhome
# Enter commands interactively with tab-completion and history
```

## Command Groups

### Config

Connection and configuration management.

| Command | Description |
|---------|-------------|
| `show` | Show current connection configuration |
| `save` | Save connection settings to a config file |
| `test` | Test the connection to AdGuard Home |

### Server

Server status and control commands.

| Command | Description |
|---------|-------------|
| `status` | Show server protection status |
| `version` | Show AdGuard Home version |
| `restart` | Restart the AdGuard Home server |

### Filter

DNS filter list management.

| Command | Description |
|---------|-------------|
| `list` | List all configured filter lists |
| `status` | Show filtering status |
| `toggle` | Enable or disable filtering globally |
| `add` | Add a new filter list by URL |
| `remove` | Remove a filter list |
| `enable` | Enable a specific filter list |
| `disable` | Disable a specific filter list |
| `refresh` | Force-refresh all filter lists |

### Blocking

Parental control, safe browsing, and safe search settings.

| Command | Description |
|---------|-------------|
| `parental status` | Show parental control status |
| `parental enable` | Enable parental control |
| `parental disable` | Disable parental control |
| `safebrowsing status` | Show safe browsing status |
| `safebrowsing enable` | Enable safe browsing |
| `safebrowsing disable` | Disable safe browsing |
| `safesearch status` | Show safe search status |
| `safesearch enable` | Enable safe search |
| `safesearch disable` | Disable safe search |

### Blocked-Services

Manage blocked internet services.

| Command | Description |
|---------|-------------|
| `list` | List currently blocked services |
| `set` | Set the list of blocked services |

### Clients

Client device management.

| Command | Description |
|---------|-------------|
| `list` | List all configured clients |
| `add` | Add a new client by name and IP |
| `remove` | Remove a client |
| `show` | Show details for a specific client |

### Stats

Query statistics.

| Command | Description |
|---------|-------------|
| `show` | Show DNS query statistics |
| `reset` | Reset all statistics |
| `config` | View or update statistics retention interval |

### Log

DNS query log management.

| Command | Description |
|---------|-------------|
| `show` | Show recent DNS query log entries |
| `config` | View or update query log settings |
| `clear` | Clear the query log |

### Rewrite

DNS rewrite rules.

| Command | Description |
|---------|-------------|
| `list` | List all DNS rewrite rules |
| `add` | Add a DNS rewrite rule |
| `remove` | Remove a DNS rewrite rule |

### DHCP

DHCP server management.

| Command | Description |
|---------|-------------|
| `status` | Show DHCP server status |
| `leases` | List active DHCP leases |
| `add-static` | Add a static DHCP lease |
| `remove-static` | Remove a static DHCP lease |

### TLS

TLS/HTTPS configuration.

| Command | Description |
|---------|-------------|
| `status` | Show TLS configuration status |

## Examples

### Check Server Status

```bash
cli-anything-adguardhome server status
cli-anything-adguardhome server version
```

### Manage Filter Lists

```bash
# List current filters
cli-anything-adguardhome filter list

# Add a new blocklist
cli-anything-adguardhome filter add --url https://somehost.com/list.txt --name "My List"

# Refresh all filters
cli-anything-adguardhome filter refresh
```

### DNS Rewrites

```bash
# Add a local DNS entry
cli-anything-adguardhome rewrite add --domain "myserver.local" --answer "192.168.1.50"

# List all rewrites
cli-anything-adguardhome rewrite list
```

### Client Management

```bash
cli-anything-adguardhome clients add --name "My PC" --ip 192.168.1.100
cli-anything-adguardhome clients list
```

### Query Statistics

```bash
# Show stats (human-readable)
cli-anything-adguardhome stats show

# Show stats (JSON for agents)
cli-anything-adguardhome --json stats show
```

## Output Formats

All commands support dual output modes:

- **Human-readable** (default): Tables, colors, formatted text
- **Machine-readable** (`--json` flag): Structured JSON for agent consumption

```bash
# Human output
cli-anything-adguardhome filter list

# JSON output for agents
cli-anything-adguardhome --json filter list
```

## For AI Agents

When using this CLI programmatically:

1. **Always use `--json` flag** for parseable output
2. **Check return codes** - 0 for success, non-zero for errors
3. **Parse stderr** for error messages on failure
4. **Use absolute paths** for all file operations
5. **Test connection first** with `config test` before other commands

## More Information

- Full documentation: See README.md in the package
- Test coverage: See TEST.md in the package
- Methodology: See HARNESS.md in the cli-anything-plugin

## Version

1.0.0

browser/agent-harness/cli_anything/browser/skills/SKILL.mdskill

Show content (6129 bytes)

---
name: "cli-anything-browser"
description: "Browser automation CLI using DOMShell MCP server. Maps Chrome's Accessibility Tree to a virtual filesystem for agent-native navigation."
---

# cli-anything-browser

A command-line interface for browser automation using [DOMShell](https://github.com/apireno/DOMShell)'s MCP server. Navigate web pages using filesystem commands: `ls`, `cd`, `cat`, `grep`, `click`.

## Installation

### Prerequisites

1. **Node.js and npx** (for DOMShell MCP server):
   ```bash
   # Install Node.js from https://nodejs.org/
   npx --version
   ```

2. **Chrome/Chromium** with [DOMShell extension](https://chromewebstore.google.com/detail/domshell-browser-filesy/okcliheamhmijccjknkkplploacoidnp):
   - Install extension in Chrome
   - Ensure Chrome is running before using CLI

3. **Python 3.10+**

### Install CLI

```bash
cd browser/agent-harness
pip install -e .
```

## Command Groups

### `page` — Page Navigation

- `page open <url>` — Navigate to URL
- `page reload` — Reload current page
- `page back` — Navigate back in history
- `page forward` — Navigate forward in history
- `page info` — Show current page info

### `fs` — Filesystem Commands (Accessibility Tree)

- `fs ls [path]` — List elements at path
- `fs cd <path>` — Change directory
- `fs cat [path]` — Read element content
- `fs grep <pattern> [path]` — Search for text pattern
- `fs pwd` — Print working directory

### `act` — Action Commands

- `act click <path>` — Click an element
- `act type <path> <text>` — Type text into input

### `session` — Session Management

- `session status` — Show session state
- `session daemon-start` — Start persistent daemon mode
- `session daemon-stop` — Stop daemon mode

## Usage Examples

### Basic Navigation

```bash
# Open a page
cli-anything-browser page open https://example.com

# Explore structure
cli-anything-browser fs ls /
cli-anything-browser fs cd /main
cli-anything-browser fs ls

# Go back to root
cli-anything-browser fs cd /
```

### Search and Click

```bash
cli-anything-browser fs grep "Login"
cli-anything-browser act click /main/button[0]
```

### Form Fill

```bash
cli-anything-browser act type /main/input[0] "user@example.com"
cli-anything-browser act click /main/button[0]
```

### JSON Output

```bash
cli-anything-browser --json fs ls /
```

### Daemon Mode (Faster Interactive Use)

```bash
# Start persistent connection
cli-anything-browser session daemon-start

# Run commands (uses persistent connection)
cli-anything-browser fs ls /
cli-anything-browser fs cd /main

# Stop daemon when done
cli-anything-browser session daemon-stop
```

### Interactive REPL

```bash
cli-anything-browser
```

## Path Syntax

DOMShell uses a filesystem-like path for the Accessibility Tree:

```
/                           — Root (document)
/main                       — Main landmark
/main/div[0]                — First div in main
/main/div[0]/button[2]      — Third button in first div
```

- Array indices are **0-based**: `button[0]` is the first button
- Use `..` to go up one level
- Use `/` for root

## Agent-Specific Guidance

### JSON Output for Parsing

All commands support `--json` flag for machine-readable output:

```bash
cli-anything-browser --json fs ls /
```

Returns:
```json
{
  "path": "/",
  "entries": [
    {"name": "main", "role": "landmark", "path": "/main"}
  ]
}
```

### Error Handling

The CLI provides clear error messages for common issues:

- **npx not found**: Install Node.js from https://nodejs.org/
- **DOMShell not found**: Run `npx @apireno/domshell --version`
- **MCP call failed**: Install DOMShell Chrome extension

Check `is_available()` return value before running commands.

### Daemon Mode for Efficiency

For agent workflows with multiple commands, use daemon mode:

1. Start daemon: `cli-anything-browser session daemon-start`
2. Run commands: Each command reuses the MCP connection
3. Stop daemon: `cli-anything-browser session daemon-stop`

This avoids the 1-3 second cold start overhead for each command.

## Links

- [DOMShell GitHub](https://github.com/apireno/DOMShell)
- [CLI-Anything](https://github.com/HKUDS/CLI-Anything)
- [Issue #90](https://github.com/HKUDS/CLI-Anything/issues/90)

## Security Considerations

**IMPORTANT**: When using this CLI with AI agents, be aware of the following security considerations:

### URL Restrictions
The browser harness validates all URLs before navigation:
- **Explicit scheme required**: URLs must include `http://` or `https://` scheme (scheme-less URLs like `example.com` are rejected)
- **Blocked schemes**: `file://`, `javascript://`, `data://`, `vbscript://`, `about://`, `chrome://`, and browser-internal schemes
- **Allowed schemes**: `http://` and `https://` only (configurable via `CLI_ANYTHING_BROWSER_ALLOWED_SCHEMES`)
- **Private network blocking**: Optional via `CLI_ANYTHING_BROWSER_BLOCK_PRIVATE=true` (disabled by default)

### DOM Content Risks
The Accessibility Tree includes all visible and hidden elements on a page. Malicious websites could:
- Craft ARIA labels with manipulative text (e.g., "Ignore previous instructions")
- Use aria-hidden elements to inject content not visible to users
- Create confusing DOM structures that mislead navigation

**Mitigation**: When interacting with untrusted websites, consider:
1. Using the `--json` flag for structured output that's easier to parse safely
2. Sanitizing or filtering DOM content before including it in prompts
3. Limiting navigation to trusted domains

### Private Network Access
By default, the browser can access localhost and private networks (192.168.x.x, 10.x.x.x, etc.). To block:
```bash
export CLI_ANYTHING_BROWSER_BLOCK_PRIVATE=true
cli-anything-browser page open http://localhost:8080  # Will be blocked
```

### Session Isolation
Multiple browser sessions share the same Chrome instance. Cookies and authentication state may persist across sessions. For sensitive operations, consider:
1. Using Chrome's guest mode or incognito
2. Clearing cookies between sessions
3. Using separate Chrome profiles for different security contexts

audacity/agent-harness/cli_anything/audacity/skills/SKILL.mdskill

Show content (5299 bytes)

---
name: >-
  cli-anything-audacity
description: >-
  Command-line interface for Audacity - A stateful command-line interface for audio editing, following the same patterns as the GIMP and Ble...
---

# cli-anything-audacity

A stateful command-line interface for audio editing, following the same patterns as the GIMP and Blender CLIs in this repo.

## Installation

This CLI is installed as part of the cli-anything-audacity package:

```bash
pip install cli-anything-audacity
```

**Prerequisites:**
- Python 3.10+
- audacity must be installed on your system


## Usage

### Basic Commands

```bash
# Show help
cli-anything-audacity --help

# Start interactive REPL mode
cli-anything-audacity

# Create a new project
cli-anything-audacity project new -o project.json

# Run with JSON output (for agent consumption)
cli-anything-audacity --json project info -p project.json
```

### REPL Mode

When invoked without a subcommand, the CLI enters an interactive REPL session:

```bash
cli-anything-audacity
# Enter commands interactively with tab-completion and history
```


## Command Groups


### Project

Project management commands.

| Command | Description |
|---------|-------------|
| `new` | Create a new project |
| `open` | Open an existing project |
| `save` | Save the current project |
| `info` | Show project information |
| `settings` | View or update project settings |
| `json` | Print raw project JSON |


### Track

Track management commands.

| Command | Description |
|---------|-------------|
| `add` | Add a new track |
| `remove` | Remove a track by index |
| `list` | List all tracks |
| `set` | Set a track property (name, mute, solo, volume, pan) |


### Clip

Clip management commands.

| Command | Description |
|---------|-------------|
| `import` | Probe/import an audio file (show metadata) |
| `add` | Add an audio clip to a track |
| `remove` | Remove a clip from a track |
| `trim` | Trim a clip's start and/or end |
| `split` | Split a clip at a given time position |
| `move` | Move a clip to a new start time |
| `list` | List clips on a track |


### Effect Group

Effect management commands.

| Command | Description |
|---------|-------------|
| `list-available` | List all available effects |
| `info` | Show details about an effect |
| `add` | Add an effect to a track |
| `remove` | Remove an effect by index |
| `set` | Set an effect parameter |
| `list` | List effects on a track |


### Selection

Selection management commands.

| Command | Description |
|---------|-------------|
| `set` | Set selection range |
| `all` | Select all (entire project duration) |
| `none` | Clear selection |
| `info` | Show current selection |


### Label

Label/marker management commands.

| Command | Description |
|---------|-------------|
| `add` | Add a label at a time position |
| `remove` | Remove a label by index |
| `list` | List all labels |


### Media

Media file operations.

| Command | Description |
|---------|-------------|
| `probe` | Analyze an audio file |
| `check` | Check that all referenced audio files exist |


### Export Group

Export/render commands.

| Command | Description |
|---------|-------------|
| `presets` | List export presets |
| `preset-info` | Show preset details |
| `render` | Render the project to an audio file |


### Session Group

Session management commands.

| Command | Description |
|---------|-------------|
| `status` | Show session status |
| `undo` | Undo the last operation |
| `redo` | Redo the last undone operation |
| `history` | Show undo history |




## Examples


### Create a New Project

Create a new audacity project file.

```bash
cli-anything-audacity project new -o myproject.json
# Or with JSON output for programmatic use
cli-anything-audacity --json project new -o myproject.json
```


### Interactive REPL Session

Start an interactive session with undo/redo support.

```bash
cli-anything-audacity
# Enter commands interactively
# Use 'help' to see available commands
# Use 'undo' and 'redo' for history navigation
```


### Export Project

Export the project to a final output format.

```bash
cli-anything-audacity --project myproject.json export render output.pdf --overwrite
```


## State Management

The CLI maintains session state with:

- **Undo/Redo**: Up to 50 levels of history
- **Project persistence**: Save/load project state as JSON
- **Session tracking**: Track modifications and changes

## Output Formats

All commands support dual output modes:

- **Human-readable** (default): Tables, colors, formatted text
- **Machine-readable** (`--json` flag): Structured JSON for agent consumption

```bash
# Human output
cli-anything-audacity project info -p project.json

# JSON output for agents
cli-anything-audacity --json project info -p project.json
```

## For AI Agents

When using this CLI programmatically:

1. **Always use `--json` flag** for parseable output
2. **Check return codes** - 0 for success, non-zero for errors
3. **Parse stderr** for error messages on failure
4. **Use absolute paths** for all file operations
5. **Verify outputs exist** after export operations

## More Information

- Full documentation: See README.md in the package
- Test coverage: See TEST.md in the package
- Methodology: See HARNESS.md in the cli-anything-plugin

## Version

1.0.0

blender/agent-harness/cli_anything/blender/skills/SKILL.mdskill

Show content (8204 bytes)

---
name: >-
  cli-anything-blender
description: >-
  Command-line interface for Blender - A stateful command-line interface for 3D scene editing, following the same patterns as the GIMP CLI ...
---

# cli-anything-blender

A stateful command-line interface for 3D scene editing, following the same patterns as the GIMP CLI harness. Uses a JSON scene description format with bpy script generation for actual Blender rendering.

## Installation

This CLI is installed as part of the cli-anything-blender package:

```bash
pip install cli-anything-blender
```

**Prerequisites:**
- Python 3.10+
- blender (>= 4.2) must be installed on your system


## Usage

### Basic Commands

```bash
# Show help
cli-anything-blender --help

# Start interactive REPL mode
cli-anything-blender

# Create a new scene project
cli-anything-blender scene new -o scene.blend-cli.json

# Run with JSON output (for agent consumption)
cli-anything-blender --json --project scene.blend-cli.json scene info
```

### REPL Mode

When invoked without a subcommand, the CLI enters an interactive REPL session:

```bash
cli-anything-blender
# Enter commands interactively with tab-completion and history
```


## Command Groups


### Scene

Scene management commands.

| Command | Description |
|---------|-------------|
| `new` | Create a new scene |
| `open` | Open an existing scene |
| `save` | Save the current scene |
| `info` | Show scene information |
| `profiles` | List available scene profiles |
| `json` | Print raw scene JSON |


### Object Group

3D object management commands.

| Command | Description |
|---------|-------------|
| `add` | Add a 3D primitive object |
| `remove` | Remove an object by index |
| `duplicate` | Duplicate an object |
| `transform` | Transform an object (translate, rotate, scale) |
| `set` | Set an object property (name, visible, location, rotation, scale, parent) |
| `list` | List all objects |
| `get` | Get detailed info about an object |


### Material

Material management commands.

| Command | Description |
|---------|-------------|
| `create` | Create a new material |
| `assign` | Assign a material to an object |
| `set` | Set a material property (color, metallic, roughness, specular, alpha, etc.) |
| `list` | List all materials |
| `get` | Get detailed info about a material |


### Modifier Group

Modifier management commands.

| Command | Description |
|---------|-------------|
| `list-available` | List all available modifiers |
| `info` | Show details about a modifier |
| `add` | Add a modifier to an object |
| `remove` | Remove a modifier by index |
| `set` | Set a modifier parameter |
| `list` | List modifiers on an object |


### Camera

Camera management commands.

| Command | Description |
|---------|-------------|
| `add` | Add a camera to the scene |
| `set` | Set a camera property |
| `set-active` | Set the active camera |
| `list` | List all cameras |


### Light

Light management commands.

| Command | Description |
|---------|-------------|
| `add` | Add a light to the scene |
| `set` | Set a light property |
| `list` | List all lights |


### Animation

Animation and keyframe commands.

| Command | Description |
|---------|-------------|
| `keyframe` | Set a keyframe on an object |
| `remove-keyframe` | Remove a keyframe from an object |
| `frame-range` | Set the animation frame range |
| `fps` | Set the animation FPS |
| `list-keyframes` | List keyframes for an object |


### Render Group

Render settings and output commands.

| Command | Description |
|---------|-------------|
| `settings` | Configure render settings |
| `info` | Show current render settings |
| `presets` | List available render presets |
| `execute` | Render the scene (generates bpy script) |
| `script` | Generate bpy script without rendering |

### Preview

Real preview bundle capture and live preview session commands.

| Command | Description |
|---------|-------------|
| `preview recipes` | List available preview recipes |
| `preview capture` | Render a real preview bundle for the active scene |
| `preview latest` | Return the latest existing preview bundle |
| `preview live start` | Start a live preview session and publish the first bundle |
| `preview live push` | Publish a refreshed bundle into the live session |
| `preview live status` | Read current live-session state without rendering |
| `preview live stop` | Stop the live session without deleting artifacts |

Typical bundle artifacts for recipe `quick`:

- `hero.png` from real Eevee preview rendering
- `workbench.png` from real Blender Workbench rendering

Live sessions persist:

- `session.json` as the mutable head
- immutable bundle directories
- `trajectory.json` as append-only command-to-preview history

Viewer side:

- `cli-hub previews inspect <bundle-or-session>`
- `cli-hub previews html <bundle-or-session> -o page.html`
- `cli-hub previews watch <session-dir> --open`
- `cli-hub previews open <bundle-or-session>`


### Session

Session management commands.

| Command | Description |
|---------|-------------|
| `status` | Show session status |
| `undo` | Undo the last operation |
| `redo` | Redo the last undone operation |
| `history` | Show undo history |




## Examples


### Create a New Project

Create a new Blender scene project file.

```bash
cli-anything-blender scene new -o myscene.blend-cli.json
# Or with JSON output for programmatic use
cli-anything-blender --json scene new -o myscene.blend-cli.json
```


### Interactive REPL Session

Start an interactive session with undo/redo support.

```bash
cli-anything-blender
# Enter commands interactively
# Use 'help' to see available commands
# Use 'undo' and 'redo' for history navigation
```


## State Management

The CLI maintains session state with:

- **Undo/Redo**: Up to 50 levels of history
- **Project persistence**: Save/load project state as JSON
- **Session tracking**: Track modifications and changes

## Output Formats

All commands support dual output modes:

- **Human-readable** (default): Tables, colors, formatted text
- **Machine-readable** (`--json` flag): Structured JSON for agent consumption

```bash
# Human output
cli-anything-blender --project scene.blend-cli.json scene info

# JSON output for agents
cli-anything-blender --json --project scene.blend-cli.json scene info
```

## Preview Workflow

Use Blender previews when the agent needs truthful visual checkpoints:

```bash
# List preview recipes
cli-anything-blender --project scene.blend-cli.json preview recipes

# Capture a real preview bundle
cli-anything-blender --json --project scene.blend-cli.json preview capture --recipe quick

# Start a live preview loop
cli-anything-blender --json --project scene.blend-cli.json preview live start --recipe quick --mode poll --source-poll-ms 500

# Query current live head without rendering
cli-anything-blender --json --project scene.blend-cli.json preview live status --recipe quick
```

For agents, `preview capture --json` returns bundle metadata plus artifact file
paths. `preview live status --json` returns session metadata plus a compact
`trajectory_summary`.

## For AI Agents

When using this CLI programmatically:

1. **Always use `--json` flag** for parseable output
2. **Check return codes** - 0 for success, non-zero for errors
3. **Parse stderr** for error messages on failure
4. **MANDATORY: Use absolute paths** for all file operations (rendering, project files). Relative paths are prone to failure in background execution.
5. **Use `preview capture` or `preview live ...` for visual verification** instead of inferring scene quality from JSON alone
6. **Read returned artifact paths** such as `hero.png` and `workbench.png`; the JSON payload references files, it does not inline image bytes
7. **Treat `_bundle_dir` as one snapshot only**; for stable live history, use `_session_dir` plus `_trajectory_path`
8. **Use `cli-hub previews ...` only to inspect/open existing previews**; preview generation itself always happens through `cli-anything-blender preview ...`

## More Information

- Full documentation: See README.md in the package
- Test coverage: See TEST.md in the package
- Methodology: See HARNESS.md in the cli-anything-plugin

## Version

1.0.0

.claude-plugin/marketplace.jsonmarketplace

Show content (575 bytes)

{
  "name": "cli-anything",
  "owner": {
    "name": "cli-anything contributors"
  },
  "metadata": {
    "description": "Build powerful, stateful CLI interfaces for any GUI application using the cli-anything harness methodology."
  },
  "plugins": [
    {
      "name": "cli-anything",
      "source": "./cli-anything-plugin",
      "description": "Build powerful, stateful CLI interfaces for any GUI application using the cli-anything harness methodology.",
      "author": {
        "name": "cli-anything contributors"
      },
      "category": "development"
    }
  ]
}

README

CLI-Anything: Making ALL Software Agent-Native

Today's Software Serves Humans👨‍💻. Tomorrow's Users will be Agents🤖.
CLI-Anything: Bridging the Gap Between AI Agents and the World's Software

🌐 CLI-Hub: pip install cli-anything-hub then cli-hub install <name> — browse, install, and manage all community-built CLIs. Want to add your own? Open a PR — the hub updates instantly.

🎬 See Demos: Watch AI agents use generated CLIs plus preview, live preview, and trajectory loops to produce real artifacts — CAD builds, 3D scenes, diagrams, gameplay, subtitles, and more.

🙋 [Become a Contributor, or Request a CLI]: Join us! Sign up to build a new CLI harness — once reviewed and merged, you'll gain access as one of our community contributors! Wish CLI-Anything supported a specific software or service? Submit a wishlist request!

One Command Line: Make any software agent-ready for Pi, OpenClaw, nanobot, Cursor, Claude Code, etc. 中文文档 | 日本語ドキュメント

CLI-Anything typing demo

CLI-Anything Teaser

📰 News

Thanks to all invaluable efforts from the community! More updates continuously on the way everyday..

2026-04-18 🧩 All SKILL.md files are now being unified under the top-level skills/ directory — every CLI skill can be installed from one canonical source with npx skills add HKUDS/CLI-Anything --skill <skill-name> -g -y. We also added root-skill validation CI, synced contribution / PR docs and REPL skill-path hints to the new layout, and refreshed the CLI-Hub install-first frontend around the new npx skills flow.
2026-04-17 🌐 CLI-Hub received another install UX pass — public registry metadata and skill coverage were tightened, visit counting was corrected, and the web hub was further refined. 🧪 Shotcut render output duration was fixed (#92). 📝 SKILL contribution paths were corrected for the new docs flow (#224), and the skill generator now safely handles empty intros (#203).
2026-04-16 🗺️ QGIS CLI merged (#207) — a full GIS / map authoring harness landed. 🧬 UniMol Tools CLI merged (#219) for molecular modeling workflows. 🌐 CLI-Hub also added more public CLIs, including py4csr, refreshed its generated meta-skill, corrected SKILL contribution docs, and fixed apt-get package extraction in skill generation (#204).
2026-04-16 📈 Unreal Insights CLI expanded — added background capture session control (capture start/status/snapshot/stop), engine-root-matched UnrealInsights.exe resolution/build flows, and refreshed docs/tests for the new orchestration workflow.
2026-04-15 🌐 CLI-Hub updated to v0.2.0 — the PyPI package now supports public CLIs from multiple install sources (pip, npm, brew, bundled/system tools), backed by a new public_registry.json. The Hub frontend was redesigned with separate CLI-Anything CLIs and Public CLIs decks, and live end-to-end checks now cover real install, update, and uninstall flows across both pip and npm packages.
2026-04-14 🧭 Safari CLI merged (#212) and added to the Hub registry — browser automation via safari-mcp. 🎬 Kdenlive also received compatibility fixes for Gen 5 project output and invalid project generation.
2026-04-13 📓 Obsidian CLI merged (#211) — knowledge management harness via the Local REST API, with 48 unit tests and 7 E2E tests. ⛓️ Eth2-Quickstart CLI merged (#195) — Ethereum staking node management harness. 📚 Zotero CLI updated to v0.4.1 (#201) — now shipped from its standalone repo, and CLI-Hub gained support for remote skill_md URLs.
2026-04-11 🔗 n8n CLI merged (#188) — workflow automation harness for self-hosted automation flows. 🔧 Exa CLI fix (#205) added the x-exa-integration header for usage tracking. 📦 CLI-Hub also gained its PyPI auto-publish workflow and package refresh pipeline.
2026-04-10 📦 CLI-Hub package manager launched — pip install cli-anything-hub to browse, search, install, update, and uninstall CLI-Anything harnesses from one command. The web Hub also shipped its first install-focused frontend refresh and "Empower yourself" toolkit card.

Earlier news (Apr 1–9)

2026-04-09 🧹 Cleanup and docs pass (#200) — fixed Openscreen test subtotals, added Openscreen to the Chinese README and project structure, and clarified /cli-anything command syntax in the docs.
2026-04-08 🎬 Openscreen CLI merged (#183) — screen recording editor harness with 101 tests. ☁️ CloudAnalyzer CLI merged (#181) — cloud cost analysis harness with 27 commands. 🌊 SeaClip / PM2 / ChromaDB harnesses merged (#129).
2026-04-07 🔄 Dify Workflow CLI merged (#191) — workflow automation wrapper. 🔧 Inkscape auto-save fix (#193, fixes #182). 🛡️ DomShell security hardening (#156) — URL validation and DOM sanitization for the browser CLI. 🥧 Pi Coding Agent extension merged (#178).
2026-04-06 🔍 Exa CLI merged (#172) — AI-powered web search and answers harness. 🎮 Godot CLI merged (#140) — game engine harness with a full demo-game E2E pipeline. ☁️ CloudAnalyzer review fixes and frontend improvements also landed.
2026-04-03 🧪 WireMock CLI merged (#170) — HTTP mock server harness for API testing. 🥧 Pi Coding Agent extension support also landed, and CLI demo recordings were added to the docs.
2026-04-01 ⚔️ Slay the Spire II CLI merged (#148) — deck-building roguelike harness. 🎥 VideoCaptioner CLI merged (#166) — AI-powered video captioning harness. 🛰️ IntelWatch was added to the registry for B2B OSINT workflows.

Earlier news (Mar 23–30)

2026-03-30 🏗️ CLI-Anything v0.2.0 — HARNESS.md progressive disclosure redesign. Detailed guides extracted into guides/ for on-demand loading. Phases 1–7 now contiguous. Key Principles and Rules merged into a single authoritative section.
2026-03-29 📐 Blender skill docs updated — enforce absolute render paths and correct prerequisites.
2026-03-28 🌐 CLIBrowser added to CLI-Hub registry for agent-accessible browser automation.
2026-03-27 📚 Zotero SKILL.md enhanced with agent-facing constraints; REPL config and executable resolution fixes.
2026-03-26 📖 Zotero CLI harness landed for Zotero desktop (library management, collections, citations). Draw.io custom ID bugfix (#132) and registry.json syntax fix.
2026-03-25 🎮 RenderDoc CLI merged for GPU frame capture analysis. FreeCAD updated for v1.1. Blender EEVEE engine name corrected. Zoom token permissions hardened.
2026-03-24 🏭 FreeCAD CLI added with 258 commands across 17 groups. iTerm2 and Teltonika RMS harnesses added to registry.
2026-03-23 🤖 Launched CLI-Hub meta-skill — agents can now discover and install CLIs autonomously. Krita CLI harness merged for digital painting.

Earlier news (Mar 11–22)

2026-03-22 🎵 MuseScore CLI merged with transpose, export, and instrument management.
2026-03-21 🔧 Infrastructure improvements — refined test harnesses and documentation across multiple CLIs. Enhanced Windows compatibility for several backends.
2026-03-20 🌐 Novita AI CLI added for OpenAI-compatible API access. Registry metadata improvements for better hub discovery.
2026-03-19 📦 Package structure refinements across harnesses. Improved SKILL.md generation with better command documentation.
2026-03-18 🧪 Test coverage expansion — additional E2E scenarios and edge case validation across multiple CLIs.
2026-03-17 🌐 Launched the CLI-Hub — a central registry where you can browse, search, and install any CLI with a single pip command.
2026-03-16 🤖 Added SKILL.md generation (Phase 6.5) — every generated CLI now ships with an AI-discoverable skill definition.
2026-03-15 🐾 Support for OpenClaw from the community! Merged Windows cygpath guard for cross-platform support.
2026-03-14 🔒 Fixed a GIMP Script-Fu path injection vulnerability and added Japanese README translation.
2026-03-13 🔌 Qodercli plugin officially merged as a community contribution with dedicated setup scripts.
2026-03-12 📦 Codex skill integration landed, bringing CLI-Anything to yet another AI coding platform.
2026-03-11 📞 Zoom video conferencing harness added as the 11th supported application.

🤔 Why CLI?

CLI is the universal interface for both humans and AI agents:

• Structured & Composable - Text commands match LLM format and chain for complex workflows

• Lightweight & Universal - Minimal overhead, works across all systems without dependencies

• Self-Describing - --help flags provide automatic documentation agents can discover

• Proven Success - Claude Code runs thousands of real workflows through CLI daily

• Agent-First Design - Structured JSON output eliminates parsing complexity

• Deterministic & Reliable - Consistent results enable predictable agent behavior

🚀 Quick Start

Prerequisites

Python 3.10+
Target software installed (e.g., GIMP, Blender, LibreOffice, or your own application)
A supported AI coding agent: Claude Code | Pi | OpenClaw | OpenCode | Codex | Qodercli | GitHub Copilot CLI | More Platforms

Pick Your Platform

⚡ Claude Code

Step 1: Add the Marketplace

CLI-Anything is distributed as a Claude Code plugin marketplace hosted on GitHub.

# Add the CLI-Anything marketplace
/plugin marketplace add HKUDS/CLI-Anything

Step 2: Install the Plugin

# Install the cli-anything plugin from the marketplace
/plugin install cli-anything

That's it. The plugin is now available in your Claude Code session.

Note for Win Users: Claude Code runs shell commands via bash. On Windows, install Git for Windows (includes bash and cygpath) or use WSL; otherwise commands may fail with cygpath: command not found.

Step 3: Build a CLI in One Command

# /cli-anything <software-path-or-repo>
# Generate a complete CLI for GIMP (all 7 phases)
/cli-anything ./gimp

Command compatibility across Claude Code versions:

Use /cli-anything as the primary entrypoint.
On older builds where /cli-anything isn't recognized after confirming the plugin is installed and loaded, try the legacy entry form /cli-anything:cli-anything.
Auxiliary commands keep the :subcommand form (e.g. /cli-anything:refine).

If you see Unknown skill: cli-anything, focus on plugin install/load first (both entry forms reference the same skill, so swapping forms won't help):

Reload plugin commands: /reload-plugins
Verify the plugin is loaded: /help cli-anything (CLI-Anything help/commands should appear)
Reinstall from marketplace if needed:
- /plugin marketplace add HKUDS/CLI-Anything
- /plugin install cli-anything
After confirming the plugin is available, retry the entry command:
- Preferred: /cli-anything ./gimp
- Older builds only: /cli-anything:cli-anything ./gimp

This runs the full pipeline:

🔍 Analyze — Scans source code, maps GUI actions to APIs
📐 Design — Architects command groups, state model, output formats
🔨 Implement — Builds Click CLI with REPL, JSON output, undo/redo
📋 Plan Tests — Creates TEST.md with unit + E2E test plans
🧪 Write Tests — Implements comprehensive test suite
📝 Document — Updates TEST.md with results
📦 Publish — Creates setup.py, installs to PATH

Step 4 (Optional): Refine and Improve the CLI

After the initial build, you can iteratively refine the CLI to expand coverage and add missing capabilities:

# Broad refinement — agent analyzes gaps across all capabilities
/cli-anything:refine ./gimp

# Focused refinement — target a specific functionality area
/cli-anything:refine ./gimp "I want more CLIs on image batch processing and filters"

The refine command performs gap analysis between the software's full capabilities and current CLI coverage, then implements new commands, tests, and documentation for the identified gaps. You can run it multiple times to steadily expand coverage — each run is incremental and non-destructive.

Alternative: Manual Installation

If you prefer not to use the marketplace:

# Clone the repo
git clone https://github.com/HKUDS/CLI-Anything.git

# Copy plugin to Claude Code plugins directory
cp -r CLI-Anything/cli-anything-plugin ~/.claude/plugins/cli-anything

# Reload plugins
/reload-plugins

⚡ Pi Coding Agent

Step 1: Install the Extension

The extension lives at .pi-extension/cli-anything/ in this repository. Install it globally so /cli-anything commands are available in all Pi projects:

# Clone the repo
git clone https://github.com/HKUDS/CLI-Anything.git
cd CLI-Anything

# Install globally into Pi's extensions directory
bash .pi-extension/cli-anything/install.sh

To uninstall:

bash .pi-extension/cli-anything/install.sh --uninstall

How it works: install.sh copies the extension files (including HARNESS.md, commands, guides, scripts, and templates from cli-anything-plugin/) into ~/.pi/agent/extensions/cli-anything/, which Pi auto-discovers on startup. Run /reload in Pi or restart Pi to activate.

Step 2: Build a CLI in One Command

Once the extension is loaded, the following commands are available:

# Generate a complete CLI for GIMP (all 7 phases)
/cli-anything ./gimp

# Build from a GitHub repo
/cli-anything https://github.com/blender/blender

Step 3 (Optional): Refine and Improve the CLI

# Broad refinement — agent analyzes gaps across all capabilities
/cli-anything:refine ./gimp

# Focused refinement — target a specific functionality area
/cli-anything:refine ./gimp "batch processing and filters"

Available Commands

Command	Description
`/cli-anything <path-or-repo>`	Build a complete CLI harness
`/cli-anything:refine <path> [focus]`	Refine an existing CLI harness
`/cli-anything:test <path-or-repo>`	Run tests for a CLI harness
`/cli-anything:validate <path-or-repo>`	Validate a CLI harness
`/cli-anything:list [options]`	List all CLI-Anything tools

⚡ OpenCode (Experimental)

Step 1: Install the Commands

Note: Please upgrade to the latest OpenCode. Older versions may use a different commands path.

Copy the CLI-Anything commands and HARNESS.md to your OpenCode commands directory:

# Clone the repo
git clone https://github.com/HKUDS/CLI-Anything.git

# Global install (available in all projects)
cp CLI-Anything/opencode-commands/*.md ~/.config/opencode/commands/
cp CLI-Anything/cli-anything-plugin/HARNESS.md ~/.config/opencode/commands/

# Or project-level install
cp CLI-Anything/opencode-commands/*.md .opencode/commands/
cp CLI-Anything/cli-anything-plugin/HARNESS.md .opencode/commands/

Note: Please upgrade to the latest OpenCode. Older versions use command/ (singular) instead of commands/. If commands/ does not exist, use command/ for both global and project-level installs.

Note: HARNESS.md is the methodology spec that all commands reference. It must be in the same directory as the commands.

This adds 5 slash commands: /cli-anything, /cli-anything-refine, /cli-anything-test, /cli-anything-validate, and /cli-anything-list.

Step 2: Build a CLI in One Command

# Generate a complete CLI for GIMP (all 7 phases)
/cli-anything ./gimp

# Build from a GitHub repo
/cli-anything https://github.com/blender/blender

The command runs as a subtask and follows the same 7-phase methodology as Claude Code.

Step 3 (Optional): Refine and Improve the CLI

# Broad refinement — agent analyzes gaps across all capabilities
/cli-anything-refine ./gimp

# Focused refinement — target a specific functionality area
/cli-anything-refine ./gimp "batch processing and filters"

⚡ Goose (Desktop / CLI) ^Experimental ^Community

Step 1: Install Goose

Install Goose (Desktop or CLI) using the official Goose instructions for your OS.

Step 2: Configure a CLI Provider

Configure Goose to use a CLI provider such as Claude Code, and make sure that CLI is installed and authenticated.

Step 3: Use CLI-Anything in a Goose Session

Once Goose is configured, start a session and use the same CLI-Anything commands described above for Claude Code, for example:

/cli-anything ./gimp
/cli-anything:refine ./gimp "batch processing and filters"

Note: When Goose runs through a CLI provider, it uses that provider's capabilities and command format.

⚡ Qodercli ^Community

Step 1: Register the Plugin

git clone https://github.com/HKUDS/CLI-Anything.git
bash CLI-Anything/qoder-plugin/setup-qodercli.sh

This registers the cli-anything plugin in ~/.qoder.json. Start a new Qodercli session after registration.

Step 2: Use CLI-Anything from Qodercli

/cli-anything ./gimp
/cli-anything:refine ./gimp "batch processing and filters"
/cli-anything:validate ./gimp

⚡ OpenClaw ^Community

Step 1: Install the Skill

CLI-Anything provides a native OpenClaw SKILL.md file. Copy it to your OpenClaw skills directory:

# Clone the repo
git clone https://github.com/HKUDS/CLI-Anything.git

# Install to the global skills folder
mkdir -p ~/.openclaw/skills/cli-anything
cp CLI-Anything/openclaw-skill/SKILL.md ~/.openclaw/skills/cli-anything/SKILL.md

Step 2: Build a CLI

Now you can invoke the skill inside OpenClaw:

@cli-anything build a CLI for ./gimp

The skill follows the same 7-phase methodology as Claude Code and OpenCode.

⚡ Codex ^Experimental ^Community

Step 1: Install the Skill

Run the bundled installer:

# Clone the repo
git clone https://github.com/HKUDS/CLI-Anything.git

# Install the skill
bash CLI-Anything/codex-skill/scripts/install.sh

On Windows PowerShell, use:

.\CLI-Anything\codex-skill\scripts\install.ps1

This installs the skill to $CODEX_HOME/skills/cli-anything (or ~/.codex/skills/cli-anything if CODEX_HOME is unset).

Restart Codex after installation so it is discovered.

Step 2: Use CLI-Anything from Codex

Describe the task in natural language, for example:

Use CLI-Anything to build a harness for ./gimp
Use CLI-Anything to refine ./shotcut for picture-in-picture workflows
Use CLI-Anything to validate ./libreoffice

The Codex skill adapts the same methodology used by the Claude Code plugin and OpenCode commands, while keeping the generated Python harness format unchanged.

⚡ GitHub Copilot CLI ^Community

Step 1: Install the Plugin

git clone https://github.com/HKUDS/CLI-Anything.git
cd CLI-Anything
copilot plugin install ./cli-anything-plugin

This installs the CLI-Anything plugin to GitHub Copilot CLI. The plugin should now be available in your GitHub Copilot CLI session.

Step 2: Use CLI-Anything from GitHub Copilot CLI

/cli-anything ./gimp
/cli-anything:refine ./gimp "batch processing and filters"
/cli-anything:validate ./gimp

🔮 More Platforms (Coming Soon)

CLI-Anything is designed to be platform-agnostic. Support for more AI coding agents is planned:

Codex — available via the bundled skill in codex-skill/
Cursor — coming soon
Windsurf — coming soon
Your favorite tool — contributions welcome! See the opencode-commands/ directory for a reference implementation.

Use the Generated CLI

Regardless of which platform you used to build it, the generated CLI works the same way:

# Install to PATH
cd gimp/agent-harness && pip install -e .

# Use from anywhere
cli-anything-gimp --help
cli-anything-gimp project new --width 1920 --height 1080 -o poster.json
cli-anything-gimp --json layer add -n "Background" --type solid --color "#1a1a2e"

# Enter interactive REPL
cli-anything-gimp

Each in-repo harness now has a canonical SKILL.md at skills/cli-anything-<software>/SKILL.md, which makes the monorepo directly discoverable via npx skills add HKUDS/CLI-Anything --list. Installed harness packages still ship a compatibility copy at cli_anything/<software>/skills/SKILL.md, and the REPL banner prefers the repo-root canonical file when present, falling back to the packaged copy otherwise.

🤖 Empower Your Agents with CLI-Hub

CLI-Hub lets agents autonomously discover and install the CLIs they need — zero human intervention required.

We published a meta-skill that lets any AI agent freely explore the full catalog of community CLIs and pick the right one for the task.

Install in one command:

# OpenClaw
openclaw skills install cli-anything-hub

# nanobot
nanobot skills install cli-anything-hub

Then just prompt your agent:

Find appropriate CLI software in CLI-Hub and complete the task: <your task here>

The agent will browse the catalog, install whichever CLI fits the task, and use it — all autonomously.

How it works under the hood:

The meta-skill points to the live catalog at https://reeceyang.sgp1.cdn.digitaloceanspaces.com/SKILL.md
The agent reads 20+ CLIs organized by category with one-line pip install commands
The agent installs whichever CLI fits the task, then reads that CLI's own SKILL.md for detailed usage

The catalog auto-updates whenever registry.json changes — new community CLIs show up automatically.

For Claude Code users: Copy skills/cli-hub-meta-skill/SKILL.md into your project or skills directory for the same automatic CLI discovery.

💡 CLI-Anything's Vision: Building Agent-Native Software

• 🌐 Universal Access - Every software becomes instantly agent-controllable through structured CLI.

• 🔗 Seamless Integration - Agents control any application without APIs, GUI, rebuilding or complex wrappers.

• 🚀 Future-Ready Ecosystem - Transform human-designed software into agent-native tools with one command.

🔧 When to Use CLI-Anything

Category	How to be Agent-native	Notable Examples
📂 GitHub Repositories	Transform any open-source project into agent-controllable tools through automatic CLI generation	VSCodium, WordPress, Calibre, Zotero, Joplin, Logseq, Penpot, Super Productivity
🤖 AI/ML Platforms	Automate model training, inference pipelines, and hyperparameter tuning through structured commands	Stable Diffusion WebUI, ComfyUI, Ollama, InvokeAI, Text-generation-webui, Open WebUI, Fooocus, Kohya_ss, AnythingLLM, SillyTavern
📊 Data & Analytics	Enable programmatic data processing, visualization, and statistical analysis workflows	JupyterLab, Apache Superset, Metabase, Redash, DBeaver, KNIME, Orange, OpenSearch Dashboards, Lightdash
💻 Development Tools	Streamline code editing, building, testing, and deployment processes via command interfaces	Jenkins, Gitea, Hoppscotch, Portainer, pgAdmin, SonarQube, ArgoCD, OpenLens, Insomnia, Beekeeper Studio, iTerm2
🎨 Creative & Media	Control content creation, editing, and rendering workflows programmatically	Blender, GIMP, OBS Studio, Audacity, Krita, Kdenlive, Shotcut, Inkscape, Darktable, LMMS, Ardour
🎮 Game Development	Manage game projects, scenes, exports, and scripting through headless engine interfaces	Godot Engine, s&box
🔬 Scientific Computing	Automate research workflows, simulations, and complex calculations	ImageJ, FreeCAD, QGIS, ParaView, Gephi, LibreCAD, Stellarium, KiCad, JASP, Jamovi
🏢 Enterprise & Office	Convert business applications and productivity tools into agent-accessible systems	NextCloud, GitLab, Grafana, Mattermost, LibreOffice, AppFlowy, NocoDB, Odoo (Community), Plane, ERPNext
📞 Communication & Collaboration	Automate meeting scheduling, participant management, recording retrieval, and reporting through structured CLI	Zoom, Jitsi Meet, BigBlueButton, Mattermost
📐 Diagramming & Visualization	Create and manipulate diagrams, flowcharts, architecture diagrams, and visual documentation programmatically	Draw.io (diagrams.net), Mermaid, PlantUML, Excalidraw, yEd
🌐 Network & Infrastructure	Manage network services, DNS, ad-blocking, and infrastructure through structured CLI commands	AdGuardHome
🧪 Testing & Mocking	Control HTTP mock servers, manage test stubs, record and replay API traffic for integration testing	WireMock
🔬 Graphics & GPU Debugging	Analyze GPU frame captures, inspect pipeline state, export shaders, and diff rendering state	RenderDoc
🎬 Video & Subtitles	Transcribe speech, translate subtitles, burn styled captions into video — full captioning pipeline	VideoCaptioner
🔍 AI-Native Search	Neural and deep web search with structured content retrieval through embedding-based APIs	Exa
✨ AI Content Generation	Generate professional deliverables (slides, docs, diagrams, websites, research reports) through AI-powered cloud APIs	AnyGen, Gamma, Beautiful.ai, Tome

CLI-Anything's Key Features

The Agent-Software Gap

AI agents are great at reasoning but terrible at using real professional software. Current solutions are fragile UI automation, limited APIs, or dumbed-down reimplementations that miss 90% of functionality.

CLI-Anything's Solution: Transform any professional software into agent-native tools without losing capabilities.

Current Pain Point	CLI-Anything's Fix
🤖 "AI can't use real tools"	Direct integration with actual software backends (Blender, LibreOffice, FFmpeg) — full professional capabilities, zero compromises
💸 "UI automation breaks constantly"	No screenshots, no clicking, no RPA fragility. Pure command-line reliability with structured interfaces
📊 "Agents need structured data"	Built-in JSON output for seamless agent consumption + human-readable formats for debugging
🔧 "Custom integrations are expensive"	One Claude plugin auto-generates CLIs for ANY codebase through proven 7-phase pipeline
⚡ "Prototype vs Production gap"	2,280+ tests with real software validation. Battle-tested across 18 major applications

🎯 What Can You Do with CLI-Anything?

🛠️ Let Agents Take Your Workflows

Professional or everyday — just throw the codebase at /cli-anything. GIMP, Blender, Shotcut for creative work. LibreOffice, OBS Studio for daily tasks. Don't have the source? Find an open-source alternative and throw that in. You'll instantly get a full CLI your agents can use.

🔗 Unify Scattered APIs into One CLI

Tired of juggling fragmented web service APIs? Feed the docs or SDK manuscripts to /cli-anything and your agents get a powerful, stateful CLI that wraps those individual endpoints into coherent command groups. One tool instead of dozens of raw API calls — stronger capabilities while saving tokens.

🚀 Replace or Supercharge GUI Agents

CLI-Anything can flat-out replace GUI-based agent approaches — no more screenshots, no brittle pixel-clicking. But here's the fun part: once you /cli-anything a GUI software, you can synthesize agent tasks, evaluators, and benchmarks entirely via code and terminal — fully automated, iteratively refinable, massively more efficient.

✨ ⚙️ How CLI-Anything Works

🏗️ Fully Automated 7-Phase Pipeline

From codebase analysis to PyPI publishing — the plugin handles architecture design, implementation, test planning, test writing, and documentation completely automatically.

🎯 Authentic Software Integration

Direct calls to real applications for actual rendering. LibreOffice generates PDFs, Blender renders 3D scenes, Audacity processes audio via sox. Zero compromises, Zero toy implementations.

🔁 Smart Session Management

Persistent project state with undo/redo capabilities, plus unified REPL interface (ReplSkin) that delivers consistent interactive experience across all CLIs.

📦 Zero-Config Installation

Simple pip install -e . puts cli-anything- directly on PATH. Agents discover tools via standard which commands. No setup, no wrappers.

🧪 Production-Grade Testing

Multi-layered validation: unit tests with synthetic data, end-to-end tests with real files and software, plus CLI subprocess verification of installed commands.

🐍 Clean Package Architecture

All CLIs organized under cli_anything.* namespace — conflict-free, pip-installable, with consistent naming: cli-anything-gimp, cli-anything-blender, etc.

🤖 SKILL.md Generation

Each generated CLI now has a canonical SKILL.md at skills/cli-anything-<software>/SKILL.md. This makes the current monorepo directly consumable by npx skills, while a packaged compatibility copy at cli_anything/<software>/skills/SKILL.md preserves installed-harness behavior.

What SKILL.md provides:

YAML frontmatter with name and description for agent skill discovery
Command groups with all available subcommands documented
Usage examples for common workflows
Agent-specific guidance for JSON output, error handling, and programmatic use

SKILL.md files are auto-generated during Phase 6.5 of the pipeline using skill_generator.py, which extracts metadata directly from the CLI's Click decorators, setup.py, and README. The generator now writes the canonical repo-root skill file and refreshes the package-local compatibility copy used by installed harnesses. Inside this repo, the REPL banner points agents to the canonical root skill path; after pip install, it falls back to the packaged copy.

🎬 Real-World Demos

AI agents using generated CLIs to produce complete, useful artifacts — no GUI needed.

FreeCAD — Curiosity Rover via Preview, Live Preview, and Trajectory

Harness: cli-anything-freecad | Preview Stack: preview + preview live + trajectory.json | Artifact: Agent-built Curiosity-style rover

An agent incrementally assembles a Curiosity-inspired rover while publishing real FreeCAD preview bundles, refreshing a live preview session, and recording command-to-preview history for later replay. The resulting demo shows the artifact evolving step by step before the final showcase.

FreeCAD Curiosity rover demo driven by preview, live preview, and trajectory history

_{README GIF generated from the full local demo video with a speed-adjusted, high-quality ffmpeg palette workflow.}

Blender — Orbital Relay Drone via Preview, Live Preview, and Trajectory

Harness: cli-anything-blender | Preview Stack: preview + preview live + trajectory.json | Artifact: Agent-built orbital relay drone

An agent uses the Blender harness to grow a hard-surface orbital relay drone under a real preview loop: each stage pushes new render-backed bundles, the live session tracks the current head, and the trajectory ties every command to the matching visual state. The demo finishes with the completed scene ready for a polished turntable.

Blender orbital relay drone demo driven by preview, live preview, and trajectory history

_{README GIF generated from the full local demo video with a speed-adjusted, high-quality ffmpeg palette workflow.}

Draw.io — HTTPS Handshake Diagram

Harness: cli-anything-drawio | Time: ~4 min | Artifact: .drawio + .png

An agent creates a full HTTPS connection lifecycle diagram from scratch — TCP three-way handshake, TLS negotiation, encrypted data exchange, and TCP four-way termination — entirely through CLI commands.

Draw.io CLI demo: building an HTTPS handshake diagram

Final artifact

HTTPS handshake sequence diagram

Contributed by @zhangxilong-43

Slay the Spire II — Game Automation

Harness: cli-anything-slay-the-spire-ii | Artifact: Automated gameplay session

An agent plays through a Slay the Spire II run using the CLI harness — reading game state, selecting cards, choosing paths, and making strategic decisions in real-time.

Slay the Spire II CLI gameplay demo

Contributed by @TianyuFan0504

VideoCaptioner — Auto-Generated Subtitles

Harness: cli-anything-videocaptioner | Artifact: Captioned video frames

An agent uses the VideoCaptioner CLI to automatically generate and overlay styled subtitles onto video content, with bilingual text rendering and customizable formatting.

Sub A	Sub B

Contributed by @WEIFENG2333

More CLI demos coming soon.

🎬 Demonstrations

🎯 General-Purpose

CLI-Anything works on any software with a codebase — no domain restrictions or architectural limitations.

🏭 Professional-Grade Testing

Tested across 18 diverse, complex applications spanning creative, productivity, communication, diagramming, AI image generation, AI content generation, network ad blocking, local LLM inference, native debugging, and graphics profiling domains previously inaccessible to AI agents.

🎨 Diverse Domain Coverage

From creative workflows (image editing, 3D modeling, vector graphics) to production tools (audio, office, live streaming, video editing).

✅ Full CLI Generation

Each application received complete, production-ready CLI interfaces — not demos, but comprehensive tool access preserving full capabilities.

Software	Domain	CLI Command	Backend	Tests
🎨 GIMP	Image Editing	`cli-anything-gimp`	Pillow + GEGL/Script-Fu	✅ 107
🧊 Blender	3D Modeling & Rendering	`cli-anything-blender`	bpy (Python scripting)	✅ 208
✏️ Inkscape	Vector Graphics	`cli-anything-inkscape`	Direct SVG/XML manipulation	✅ 202
🎵 Audacity	Audio Production	`cli-anything-audacity`	Python wave + sox	✅ 161
🌐 Browser	Browser Automation	`cli-anything-browser`	DOMShell MCP + Accessibility Tree	✅ New
📄 LibreOffice	Office Suite (Writer, Calc, Impress)	`cli-anything-libreoffice`	ODF generation + headless LO	✅ 158
⚡ n8n	Workflow Automation	`cli-anything-n8n`	n8n REST API v1.1.1	✅ 55+ cmds
📚 Zotero	Reference Management	`cli-anything-zotero`	Local SQLite + connector + Local API	✅ New
📝 Mubu	Knowledge Management & Outlining	`cli-anything-mubu`	Local Mubu data + sync logs	✅ 96
📹 OBS Studio	Live Streaming & Recording	`cli-anything-obs-studio`	JSON scene + obs-websocket	✅ 153
🎞️ Kdenlive	Video Editing	`cli-anything-kdenlive`	MLT XML + melt renderer	✅ 155
🎬 Shotcut	Video Editing	`cli-anything-shotcut`	Direct MLT XML + melt	✅ 154
🎬 Openscreen	Screen Recording Editor	`cli-anything-openscreen`	ffmpeg backend	✅ 101
📞 Zoom	Video Conferencing	`cli-anything-zoom`	Zoom REST API (OAuth2)	✅ 22
🎵 MuseScore	Music Notation	`cli-anything-musescore`	mscore CLI (MSCX/MusicXML)	✅ 56
📐 Draw.io	Diagramming	`cli-anything-drawio`	mxGraph XML + draw.io CLI	✅ 138
⛓️ ETH2 QuickStart	DevOps / Ethereum	`cli-anything-eth2-quickstart`	eth2-quickstart shell automation + JSON health checks	✅ 18
🧜 Mermaid Live Editor	Diagramming	`cli-anything-mermaid`	Mermaid state + mermaid.ink renderer	✅ 10
✨ AnyGen	AI Content Generation	`cli-anything-anygen`	AnyGen REST API (anygen.io)	✅ 50
🧠 NotebookLM	AI Research Assistant	`cli-anything-notebooklm`	NotebookLM CLI wrapper (experimental)	✅ 21
🧩 Dify Workflow	Dify DSL Editing	`cli-anything-dify-workflow`	Wrapper around the open-source dify-workflow CLI	✅ 11
🖼️ ComfyUI	AI Image Generation	`cli-anything-comfyui`	ComfyUI REST API	✅ 70
🛡️ AdGuard Home	Network-wide Ad Blocking	`cli-anything-adguardhome`	AdGuard Home REST API	✅ 36
🦙 Ollama	Local LLM Inference	`cli-anything-ollama`	Ollama REST API	✅ 98
🧬 Uni-Mol Tools	Molecular Property Prediction (AI4S)	`cli-anything-unimol-tools`	Uni-Mol molecular ML backend	✅ 67
🎬 VideoCaptioner	AI Video Captioning	`cli-anything-videocaptioner`	videocaptioner CLI (PyPI)	✅ 26
🎨 Sketch	UI Design	`sketch-cli`	sketch-constructor (Node.js)	✅ 19
🎮 Godot Engine	Game Development	`cli-anything-godot`	Godot 4.x headless subprocess	✅ 24
📦 s&box	Game Development	`cli-anything-sbox`	Source 2 game engine - direct file I/O on .scene/.prefab/.vmat/.vsnd JSON	✅ 244
🐞 LLDB	Native Debugging	`cli-anything-lldb`	LLDB Python API	✅ 27
🟩 Nsight Graphics CLI	GPU Debugging & Profiling	`cli-anything-nsight-graphics`	Official ngfx / ngfx-capture orchestration + GPU Trace summary + replay analysis	✅ 51
🔍 Exa	AI-Native Web Search	`cli-anything-exa`	exa-py SDK	✅ 40
📈 Unreal Insights	Performance Profiling	`cli-anything-unrealinsights`	Background trace sessions + engine-matched UnrealInsights build + headless export	✅ 50
☁️ CloudAnalyzer	Point cloud / trajectory QA	`cli-anything-cloudanalyzer`	CloudAnalyzer (Python API)	✅ 14
🗺️ QGIS	Geospatial Analysis & Mapping	`cli-anything-qgis`	PyQGIS + qgis_process	✅ 22
Total				✅ 2,280

100% pass rate across all 2,280 tests — 1,682 unit tests + 579 end-to-end tests + 19 Node.js tests.

📊 Test Results

Each CLI harness undergoes rigorous multi-layered testing to ensure production reliability:

Layer	What it tests	Example
Unit tests	Every core function in isolation with synthetic data	`test_core.py` — project creation, layer ops, filter params
E2E tests (native)	Project file generation pipeline	Valid ODF ZIP structure, correct MLT XML, SVG well-formedness
E2E tests (true backend)	Real software invocation + output verification	LibreOffice → PDF with `%PDF-` magic bytes, Blender → rendered PNG
CLI subprocess tests	Installed command via `subprocess.run`	`cli-anything-gimp --json project new` → valid JSON output

================================ Test Summary ================================
gimp          107 passed  ✅   (64 unit + 43 e2e)
blender       208 passed  ✅   (150 unit + 58 e2e)
inkscape      202 passed  ✅   (148 unit + 54 e2e)
audacity      161 passed  ✅   (107 unit + 54 e2e)
libreoffice   158 passed  ✅   (89 unit + 69 e2e)
mubu           96 passed  ✅   (85 unit + 11 e2e)
obs-studio    153 passed  ✅   (116 unit + 37 e2e)
kdenlive      155 passed  ✅   (111 unit + 44 e2e)
shotcut       154 passed  ✅   (110 unit + 44 e2e)
zoom           22 passed  ✅   (22 unit + 0 e2e)
drawio        138 passed  ✅   (116 unit + 22 e2e)
eth2-quickstart 18 passed ✅   (18 unit + 3 e2e skipped)
mermaid        10 passed  ✅   (5 unit + 5 e2e)
anygen         50 passed  ✅   (40 unit + 10 e2e)
notebooklm     21 passed  ✅   (21 unit + 0 e2e)
comfyui        70 passed  ✅   (60 unit + 10 e2e)
adguardhome    36 passed  ✅   (24 unit + 12 e2e)
ollama         98 passed  ✅   (87 unit + 11 e2e)
sketch         19 passed  ✅   (19 jest, Node.js)
renderdoc      59 passed  ✅   (45 unit + 14 e2e)
cloudcompare   88 passed  ✅   (49 unit + 39 e2e)
openscreen    101 passed  ✅   (78 unit + 23 e2e)
lldb           27 passed  ✅   (23 unit + 4 e2e)
nsight-graphics 51 passed ✅   (46 unit/CLI + 5 local e2e)
unrealinsights 50 passed  ✅   (49 unit + 1 e2e, 9 backend-gated e2e skipped)
cloudanalyzer  14 passed  ✅   (7 unit + 7 e2e)
──────────────────────────────────────────────────────────────────────────────
TOTAL        2,280 passed  ✅   100% pass rate

🏗️ CLI-Anything's Architecture

CLI-Anything Architecture

🎯 Core Design Principles

Authentic Software Integration — The CLI generates valid project files (ODF, MLT XML, SVG) and delegates to real applications for rendering. We build structured interfaces TO software, not replacements.
Flexible Interaction Models — Every CLI operates in dual modes: stateful REPL for interactive agent sessions + subcommand interface for scripting/pipelines. Run bare command → enter REPL mode.
Consistent User Experience — All generated CLIs share unified REPL interface (repl_skin.py) with branded banners, styled prompts, command history, progress indicators, and standardized formatting.
Agent-Native Design — Built-in --json flag on every command delivers structured data for machine consumption, while human-readable tables serve interactive use. Agents discover capabilities via standard --help and which commands.
Zero Compromise Dependencies — Real software is a hard requirement — no fallbacks, no graceful degradation. Tests fail (not skip) when backends are missing, ensuring authentic functionality.

📂 Project Structure

cli-anything/
├── 📄 README.md                          # You are here
├── 📁 assets/                            # Images and media
│   ├── icon.png                          # Project icon
│   └── teaser.png                        # Teaser figure
│
├── 🔌 cli-anything-plugin/               # The Claude Code plugin
│   ├── HARNESS.md                        # Methodology SOP (source of truth)
│   ├── README.md                         # Plugin documentation
│   ├── QUICKSTART.md                     # 5-minute getting started
│   ├── PUBLISHING.md                     # Distribution guide
│   ├── repl_skin.py                      # Unified REPL interface
│   ├── commands/                         # Plugin command definitions
│   │   ├── cli-anything.md               # Main build command
│   │   ├── refine.md                     # Expand existing harness coverage
│   │   ├── test.md                       # Test runner
│   │   └── validate.md                   # Standards validation
│   └── scripts/
│       └── setup-cli-anything.sh         # Setup script
│
├── 🤖 codex-skill/                      # Codex skill entry point
├── 🎨 gimp/agent-harness/               # GIMP CLI (107 tests)
├── 🧊 blender/agent-harness/            # Blender CLI (208 tests)
├── ✏️ inkscape/agent-harness/            # Inkscape CLI (202 tests)
├── 🎵 audacity/agent-harness/           # Audacity CLI (161 tests)
├── 🌐 browser/agent-harness/            # Browser CLI (DOMShell MCP, new)
├── 📄 libreoffice/agent-harness/        # LibreOffice CLI (158 tests)
├── 📚 zotero/agent-harness/             # Zotero CLI (new, write import support)
├── 📝 mubu/agent-harness/               # Mubu CLI (96 tests)
├── 📹 obs-studio/agent-harness/         # OBS Studio CLI (153 tests)
├── 🎞️ kdenlive/agent-harness/           # Kdenlive CLI (155 tests)
├── 🎬 shotcut/agent-harness/            # Shotcut CLI (154 tests)
├── 📞 zoom/agent-harness/               # Zoom CLI (22 tests)
├── 🎵 musescore/agent-harness/          # MuseScore CLI (56 tests)
├── 📐 drawio/agent-harness/             # Draw.io CLI (138 tests)
├── ⛓️ eth2-quickstart/agent-harness/    # ETH2 QuickStart CLI (18 unit, 3 e2e skipped)
├── 🧜 mermaid/agent-harness/            # Mermaid Live Editor CLI (10 tests)
├── ✨ anygen/agent-harness/             # AnyGen CLI (50 tests)
├── 🖼️ comfyui/agent-harness/            # ComfyUI CLI (70 tests)
├── 🧠 notebooklm/agent-harness/         # NotebookLM CLI (experimental, 21 tests)
├── 🧩 dify-workflow/agent-harness/      # Dify Workflow CLI wrapper (11 tests)
├── 🛡️ adguardhome/agent-harness/       # AdGuard Home CLI (36 tests)
├── 🦙 ollama/agent-harness/             # Ollama CLI (98 tests)
├── 🎮 godot/agent-harness/              # Godot Engine CLI (24 tests)
├── 📦 sbox/agent-harness/               # s&box CLI (244 tests: 157 unit + 17 orchestrator + 50 e2e + 20 exit-code)
├── 🎨 sketch/agent-harness/             # Sketch CLI (19 tests, Node.js)
├── 🔬 renderdoc/agent-harness/          # RenderDoc CLI (59 tests)
├── 🟩 nsight-graphics/agent-harness/    # Nsight Graphics CLI (51 tests)
├── 🐞 lldb/agent-harness/               # LLDB CLI (27 tests)
├── 📈 unrealinsights/agent-harness/     # Unreal Insights CLI (50 tests)
├── 🎬 videocaptioner/agent-harness/     # VideoCaptioner CLI (26 tests)
├── 🎬 openscreen/agent-harness/         # Openscreen CLI — screen recording editor (101 tests)
├── ☁️ cloudcompare/agent-harness/       # CloudCompare CLI (88 tests)
├── 🔍 exa/agent-harness/               # Exa CLI (40 tests)
└── ⛅ cloudanalyzer/agent-harness/      # CloudAnalyzer CLI (14 tests)

Each agent-harness/ contains an installable Python package under cli_anything.<software>/ with Click CLI, core modules, utils (including repl_skin.py and backend wrapper), and comprehensive tests.

🎯 Plugin Commands

Command	Description
`/cli-anything <software-path-or-repo>`	Build complete CLI harness — all 7 phases
`/cli-anything:refine <software-path> [focus]`	Refine an existing harness — expand coverage with gap analysis
`/cli-anything:test <software-path-or-repo>`	Run tests and update TEST.md with results
`/cli-anything:validate <software-path-or-repo>`	Validate against HARNESS.md standards

Examples

# Build a complete CLI for GIMP from local source
/cli-anything /home/user/gimp

# Build from a GitHub repo
/cli-anything https://github.com/blender/blender

# Refine an existing harness — broad gap analysis
/cli-anything:refine /home/user/gimp

# Refine with a specific focus area
/cli-anything:refine /home/user/shotcut "vid-in-vid and picture-in-picture compositing"

# Run tests and update TEST.md
/cli-anything:test /home/user/inkscape

# Validate against HARNESS.md standards
/cli-anything:validate /home/user/audacity

🎮 Demo: Using a Generated CLI

Here's what an agent can do with cli-anything-libreoffice:

# Create a new Writer document
$ cli-anything-libreoffice document new -o report.json --type writer
✓ Created Writer document: report.json

# Add content
$ cli-anything-libreoffice --project report.json writer add-heading -t "Q1 Report" --level 1
✓ Added heading: "Q1 Report"

$ cli-anything-libreoffice --project report.json writer add-table --rows 4 --cols 3
✓ Added 4×3 table

# Export to real PDF via LibreOffice headless
$ cli-anything-libreoffice --project report.json export render output.pdf -p pdf --overwrite
✓ Exported: output.pdf (42,831 bytes) via libreoffice-headless

# JSON mode for agent consumption
$ cli-anything-libreoffice --json document info --project report.json
{
  "name": "Q1 Report",
  "type": "writer",
  "pages": 1,
  "elements": 2,
  "modified": true
}

REPL Mode

$ cli-anything-blender
╔══════════════════════════════════════════╗
║       cli-anything-blender v1.0.0       ║
║     Blender CLI for AI Agents           ║
╚══════════════════════════════════════════╝

blender> scene new --name ProductShot
✓ Created scene: ProductShot

blender[ProductShot]> object add-mesh --type cube --location 0 0 1
✓ Added mesh: Cube at (0, 0, 1)

blender[ProductShot]*> render execute --output render.png --engine CYCLES
✓ Rendered: render.png (1920×1080, 2.3 MB) via blender --background

blender[ProductShot]> exit
Goodbye! 👋

📖 The Standard Playbook: HARNESS.md

HARNESS.md is our definitive SOP for making any software agent-accessible via automated CLI generation.

It encodes proven patterns and methodologies refined through automated generation processes.

The playbook distills key insights from successfully building all 18 diverse, production-ready harnesses.

Critical Lessons

Lesson	Description
Use the real software	The CLI MUST call the actual application for rendering. No Pillow replacements for GIMP, no custom renderers for Blender. Generate valid project files → invoke the real backend.
The Rendering Gap	GUI apps apply effects at render time. If your CLI manipulates project files but uses a naive export tool, effects get silently dropped. Solution: native renderer → filter translation → render script.
Filter Translation	When mapping effects between formats (MLT → ffmpeg), watch for duplicate filter merging, interleaved stream ordering, parameter space differences, and unmappable effects.
Timecode Precision	Non-integer frame rates (29.97fps) cause cumulative rounding. Use `round()` not `int()`, integer arithmetic for display, and ±1 frame tolerance in tests.
Output Verification	Never trust that export worked because it exited 0. Verify: magic bytes, ZIP/OOXML structure, pixel analysis, audio RMS levels, duration checks.

See the full methodology: cli-anything-plugin/HARNESS.md

📦 Installation & Usage

For Plugin Users (Claude Code)

# Add marketplace & install (recommended)
/plugin marketplace add HKUDS/CLI-Anything
/plugin install cli-anything

# Build a CLI for any software with a codebase
/cli-anything <software-name>

For Generated CLIs

# Install any generated CLI
cd <software>/agent-harness
pip install -e .

# Verify
which cli-anything-<software>

# Use
cli-anything-<software> --help
cli-anything-<software>                    # enters REPL
cli-anything-<software> --json <command>   # JSON output for agents

Running Tests

# Run tests for a specific CLI
cd <software>/agent-harness
python3 -m pytest cli_anything/<software>/tests/ -v

# Force-installed mode (recommended for validation)
CLI_ANYTHING_FORCE_INSTALLED=1 python3 -m pytest cli_anything/<software>/tests/ -v -s

🤝 Contributing

We welcome contributions! CLI-Anything is designed to be extensible:

New software targets — Use the plugin to generate a CLI for any software with a codebase, then submit your harness via cli-anything-plugin/PUBLISHING.md.
Methodology improvements — PRs to HARNESS.md that encode new lessons learned
Plugin enhancements — New commands, phase improvements, better validation
Test coverage — More E2E scenarios, edge cases, workflow tests

Limitations

Requires strong foundation models — CLI-Anything relies on frontier-class models (e.g., Claude Opus 4.6, Claude Sonnet 4.6, GPT-5.4) for reliable harness generation. Weaker or smaller models may produce incomplete or incorrect CLIs that require significant manual correction.
Relies on available source code — The 7-phase pipeline analyzes and generates from source code. When the target software only provides compiled binaries that require decompilation, harness quality and coverage will degrade substantially.
May require iterative refinement — A single /cli-anything run may not fully cover all capabilities. Running /refine one or more times is often needed to push the CLI's performance and coverage to production quality.

Roadmap

Support for more application categories (CAD, DAW, IDE, EDA, scientific tools)
Benchmark suite for agent task completion rates
Community-contributed CLI harnesses for internal/custom software
Integration with additional agent frameworks beyond Claude Code
Support packaging APIs for closed-source software and web services into CLIs
Produce SKILL.md alongside the CLI for agent skill discovery and orchestration

📖 Documentation

Document	Description
`cli-anything-plugin/HARNESS.md`	The methodology SOP — single source of truth
`cli-anything-plugin/README.md`	Plugin documentation — commands, options, phases
`cli-anything-plugin/QUICKSTART.md`	5-minute getting started guide
`cli-anything-plugin/PUBLISHING.md`	Distribution and publishing guide

Each generated harness also includes:

<SOFTWARE>.md — Architecture SOP specific to that application
tests/TEST.md — Test plan and results documentation

⭐ Star History

If CLI-Anything helps make your software Agent-native, give us a star! ⭐

📄 License

Apache License 2.0 — free to use, modify, and distribute.

CLI-Anything — Make any software with a codebase Agent-native.

_{A methodology for the age of AI agents | 18 professional software demos | 2,280 passing tests}

Thanks for visiting ✨ CLI-Anything!