# Ponytail VS Code Extension Commands: Complete Reference Guide

> Explore the complete Ponytail VS Code extension command reference. Discover six core commands for mode configuration and specialized skills via the Pi-assistant API.

- Repository: [DietrichGebert/ponytail](https://github.com/DietrichGebert/ponytail)
- Tags: api-reference
- Published: 2026-09-08

---

**The Ponytail VS Code extension registers six core commands in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js) that expose mode configuration and specialized skills through the Pi-assistant API.**

The Ponytail extension by DietrichGebert provides a streamlined command interface for developers working within the VS Code ecosystem. These **Ponytail VS Code extension commands** enable users to configure operational modes and execute domain-specific skills directly from the command palette or chat interface, with all handlers defined in the extension's main entry point.

## Core Command Structure

The extension exposes one primary configuration command and five specialized skill commands. Each registration occurs at specific line numbers in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js), creating a predictable API surface for automation scripts and manual invocation.

### Mode Management with `/ponytail`

The main **`ponytail`** command (registered at line 114) handles all mode-related interactions and configuration persistence. This command accepts sub-arguments to control the extension's behavior:

- **Mode switching**: Set active processing levels (`lite`, `full`, or `ultra`)
- **Status checks**: Display current mode and default settings
- **Default configuration**: Persist a specific mode as the startup default

Usage follows the pattern `/ponytail <subcommand>` where subcommands include the mode name directly, `status`, or `default <mode>`.

### Skill Execution Commands

The remaining five commands function as lightweight wrappers that forward requests to specific skills using the `sendAlias` helper. Each skill command maps to a distinct analysis or assistance capability:

| Command | Registration Line | VS Code Palette Name | Purpose |
|---------|-------------------|---------------------|---------|
| `ponytail-review` | Line 149 | Ponytail: Review | Execute code review skill |
| `ponytail-audit` | Line 154 | Ponytail: Audit | Run security/quality audit |
| `ponytail-gain` | Line 159 | Ponytail: Gain | Access gain optimization |
| `ponytail-debt` | Line 164 | Ponytail: Debt | Analyze technical debt |
| `ponytail-help` | Line 169 | Ponytail: Help | Display help documentation |

Each registration uses the VS Code commands API to bind the slash-command syntax to the corresponding skill handler.

## Invoking Commands in VS Code

Users can trigger these commands through two primary interfaces: the Pi-assistant chat input using slash commands, or the VS Code Command Palette by typing the friendly command names (e.g., `Ponytail: Review`).

### JavaScript API Examples

When interacting programmatically with the Pi-assistant extension API, use the following patterns:

```javascript
// Change Ponytail mode to "full"
pi.sendUserMessage('/ponytail full');

// Show current mode and default configuration
pi.sendUserMessage('/ponytail status');

// Set the persistent default mode to "lite"
pi.sendUserMessage('/ponytail default lite');

// Execute a specific skill directly
pi.sendUserMessage('/ponytail-audit');
pi.sendUserMessage('/ponytail-review');

```

These calls dispatch to the handlers defined in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js), which validate the input and route to the appropriate skill execution logic.

## Source Code Architecture

The command surface is centralized in two key files within the repository:

- **[`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js)**: Contains the command registration logic and handler implementations. Lines 114 through 169 define the six command entries that VS Code exposes to users.
- **[`pi-extension/package.json`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/package.json)**: Defines the extension manifest and npm metadata, marking the package as private and configuring test scripts.

The `sendAlias` helper function (referenced in skill command implementations) forwards standardized messages to the underlying skill engine, ensuring consistent behavior across all five specialized commands.

## Summary

- The Ponytail extension provides **six VS Code commands**: one mode manager and five skill executors.
- All commands register in **[`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js)** between lines 114 and 169.
- The **`/ponytail`** command supports `lite`, `full`, and `ultra` modes with subcommands for `status` and `default` configuration.
- Skill commands (`review`, `audit`, `gain`, `debt`, `help`) wrap the `sendAlias` helper for consistent skill invocation.
- Commands are accessible via slash syntax in chat or friendly names in the VS Code Command Palette.

## Frequently Asked Questions

### How do I change the Ponytail mode in VS Code?

Type `/ponytail` followed by the desired mode name (`lite`, `full`, or `ultra`) in the Pi-assistant chat input. To make the change persistent across sessions, use `/ponytail default <mode>` instead. You can verify the current configuration at any time by running `/ponytail status`.

### What skills does the Ponytail extension provide?

According to the source code in [`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js), the extension exposes five distinct skills: **Review** for code analysis, **Audit** for security and quality checks, **Gain** for optimization suggestions, **Debt** for technical debt assessment, and **Help** for documentation access. Each skill has a dedicated command registration between lines 149 and 169.

### Where are the command handlers defined in the source code?

All command handlers reside in **[`pi-extension/index.js`](https://github.com/DietrichGebert/ponytail/blob/main/pi-extension/index.js)** within the DietrichGebert/ponytail repository. The main `ponytail` command handler registers at line 114, while the skill-specific handlers (`ponytail-review`, `ponytail-audit`, `ponytail-gain`, `ponytail-debt`, and `ponytail-help`) register at lines 149, 154, 159, 164, and 169 respectively.

### Can I use these commands outside of the VS Code command palette?

Yes. While the commands appear in the VS Code Command Palette as "Ponytail: [Command Name]", they are primarily designed for the Pi-assistant API interface. You can invoke them programmatically using `pi.sendUserMessage('/command-name')` from any extension script or automation tool that has access to the Pi-assistant API object.