procsi 0.2.6 → 0.3.1

package/README.md

@@ -4,48 +4,31 @@
 [![CI](https://github.com/mtford90/procsi/actions/workflows/ci.yml/badge.svg)](https://github.com/mtford90/procsi/actions/workflows/ci.yml)
 [![License: AGPL v3](https://img.shields.io/badge/License-AGPL_v3-blue.svg)](https://www.gnu.org/licenses/agpl-3.0)
 
-HTTP interception for the terminal. Each project gets its own proxy, its own traffic database, its own mocks — all in a `.procsi/` directory that lives alongside your code.
+Procsi is a terminal-based HTTP proxy with a powerful MCP server. Quickly intercept, inspect & rewrite HTTP traffic.
 
 ![procsi demo](demo.gif)
 
-No browser extensions, no global system proxy, no separate apps. A MITM proxy captures your traffic, a lazygit-style TUI lets you browse it, TypeScript files let you mock it, and AI agents can query and manipulate all of it via MCP.
+## Feature Highlights
+
+- **Project isolation** — each project gets its own `.procsi/` directory with a separate daemon, database, CA cert and interceptors. 
+- **MCP server** — AI agents get full access to your captured traffic and can write interceptor files for you. Search, filter, inspect, mock — all via tool calls.
+- **Interceptors** — mock, modify or observe traffic with `.ts` files. Match on anything, query past traffic from within handlers, compose complex scenarios.
 
 ## Quick Start
 
 ```bash
 npm install -g procsi
 
-# One-time shell setup
-eval "$(procsi init)"
+# Configure environment e.g. HTTP_PROXY
+eval "$(procsi on)"
 
-# In your project directory
-procsi on
+# Send a request
 curl https://api.example.com/users
-procsi tui
-```
-
-Requires Node.js 20+.
 
-### Shell Setup
-
-Run this once per shell session (or add it to your shell profile):
-
-```bash
-eval "$(procsi init)"
+# Open UI
+procsi tui
 ```
 
-This creates a shell function that lets `procsi on`/`procsi off` set proxy environment variables in your current session.
-
-## Features
-
-- **Project-scoped** — each project gets its own `.procsi/` directory with a separate daemon, database, CA cert and interceptors. No cross-project bleed.
-- **TypeScript interceptors** — mock, modify or observe traffic with `.ts` files. Match on anything, query past traffic from within handlers, compose complex scenarios.
-- **MCP server** — AI agents get full access to your captured traffic and can write interceptor files for you. Search, filter, inspect, mock — all via tool calls.
-- **Terminal TUI** — vim-style keybindings, mouse support, JSON explorer, filtering. Stays in your terminal where you're already working.
-- **HTTPS** — automatic CA certificate generation and trust
-- **Export** — copy as curl, export as HAR, save bodies to disk
-- **Zero config** — works with curl, wget, Node.js, Python, Go, Rust and anything else that respects `HTTP_PROXY`
-
 ## Project Isolation
 
 procsi doesn't use a global system proxy. Each project gets its own `.procsi/` directory in the project root (detected by `.git` or an existing `.procsi/`):
@@ -63,7 +46,120 @@ your-project/
 └── src/...
 ```
 
-Separate daemon, separate database, separate certificates. You can run procsi in multiple projects at the same time without them interfering with each other.
+Separate daemon, database, certificates etc. You can run procsi in multiple projects at the same time without them interfering with each other.
+
+## Use cases
+
+- AI analysis
+- Chaos monkey
+- Mock out APIs that do not yet exist
+
+## MCP Integration
+
+procsi has a built-in [MCP](https://modelcontextprotocol.io/) server that gives AI agents full access to your captured traffic and interceptor system. Agents can search through requests, inspect headers and bodies, and write interceptor files directly into `.procsi/interceptors/`.
+
+This means you can ask things like:
+
+- "Find all failing requests to the payments API and write mocks that return valid responses"
+- "Make every 5th request to /api/users return a 429 so I can test rate limiting"
+- "What's the average response time for requests to the auth service in the last hour?"
+- "Write an interceptor that logs all requests with missing auth headers"
+- "Send me a notification whenever an api request fails"
+
+The agent reads your traffic, writes the TypeScript, and procsi hot-reloads it.
+
+### Setup
+
+Add procsi to your MCP client config:
+
+```json
+{
+  "mcpServers": {
+    "procsi": {
+      "command": "procsi",
+      "args": ["mcp"]
+    }
+  }
+}
+```
+
+The proxy must be running (`eval "$(procsi on)"`) — the MCP server connects to the same daemon as the TUI.
+
+### Agent Skill
+
+procsi also ships an agent skill that teaches AI assistants how to use the MCP tools properly. Gets you better results out of the box.
+
+**Claude Code:**
+
+```bash
+/plugin marketplace add mtford90/procsi
+/plugin install procsi
+```
+
+**npm-agentskills** (works with Cursor, Copilot, Codex, etc.):
+
+```bash
+npx agents export --target claude
+```
+
+### Available Tools
+
+| Tool | Description |
+|------|-------------|
+| `procsi_get_status` | Daemon status, proxy port, request count |
+| `procsi_list_requests` | Search and filter captured requests |
+| `procsi_get_request` | Full request details by ID (headers, bodies, timing) |
+| `procsi_search_bodies` | Full-text search through body content |
+| `procsi_query_json` | Extract values from JSON bodies via JSONPath |
+| `procsi_count_requests` | Count matching requests |
+| `procsi_clear_requests` | Delete all captured requests |
+| `procsi_list_sessions` | List active proxy sessions |
+| `procsi_list_interceptors` | List loaded interceptors with status and errors |
+| `procsi_reload_interceptors` | Reload interceptors from disk |
+
+### Filtering
+
+Most tools accept these filters:
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `method` | HTTP method(s), comma-separated | `"GET,POST"` |
+| `status_range` | Status code, Nxx pattern, or range | `"4xx"`, `"401"`, `"500-503"` |
+| `search` | Substring match on URL/path | `"api/users"` |
+| `host` | Exact or suffix match (prefix with `.`) | `"api.example.com"`, `".example.com"` |
+| `path` | Path prefix match | `"/api/v2"` |
+| `since` / `before` | Time window (ISO 8601) | `"2024-01-15T10:30:00Z"` |
+| `header_name` | Filter by header existence or value | `"content-type"` |
+| `header_value` | Exact header value (requires `header_name`) | `"application/json"` |
+| `header_target` | Which headers to search | `"request"`, `"response"`, `"both"` |
+| `intercepted_by` | Filter by interceptor name | `"mock-users"` |
+| `offset` | Pagination offset (0-based) | `0` |
+| `limit` | Max results (default 50, max 500) | `100` |
+
+`procsi_get_request` accepts comma-separated IDs for batch fetching (e.g. `"id1,id2,id3"`).
+
+`procsi_query_json` also takes:
+
+| Parameter | Description | Example |
+|-----------|-------------|---------|
+| `target` | Which body to query: `"request"`, `"response"`, or `"both"` (default) | `"response"` |
+| `value` | Exact value match after JSONPath extraction | `"active"` |
+
+### Output Formats
+
+All query tools accept a `format` parameter:
+
+- `text` (default) — markdown summaries, readable by humans and AI
+- `json` — structured JSON for programmatic use
+
+### Examples
+
+```
+procsi_list_requests({ status_range: "5xx", path: "/api" })
+procsi_search_bodies({ query: "error_code", method: "POST" })
+procsi_query_json({ json_path: "$.user.id", target: "response" })
+procsi_list_requests({ header_name: "authorization", header_target: "request" })
+```
 
 ## Interceptors
 
@@ -189,112 +285,6 @@ export default {
 - `ctx.log()` writes to `.procsi/procsi.log` since `console.log` goes nowhere in the daemon
 - Use `satisfies Interceptor` for full intellisense
 
-## MCP Integration
-
-procsi has a built-in [MCP](https://modelcontextprotocol.io/) server that gives AI agents full access to your captured traffic and interceptor system. Agents can search through requests, inspect headers and bodies, and write interceptor files directly into `.procsi/interceptors/`.
-
-This means you can ask things like:
-
-- "Find all failing requests to the payments API and write mocks that return valid responses"
-- "Make every 5th request to /api/users return a 429 so I can test rate limiting"
-- "What's the average response time for requests to the auth service in the last hour?"
-- "Write an interceptor that logs all requests with missing auth headers"
-
-The agent reads your traffic, writes the TypeScript, and procsi hot-reloads it.
-
-### Setup
-
-Add procsi to your MCP client config:
-
-```json
-{
-  "mcpServers": {
-    "procsi": {
-      "command": "procsi",
-      "args": ["mcp"]
-    }
-  }
-}
-```
-
-The proxy must be running (`procsi on` or `eval "$(procsi vars)"`) — the MCP server connects to the same daemon as the TUI.
-
-### Agent Skill
-
-procsi also ships an agent skill that teaches AI assistants how to use the MCP tools properly. Gets you better results out of the box.
-
-**Claude Code:**
-
-```bash
-/plugin marketplace add mtford90/procsi
-/plugin install procsi
-```
-
-**npm-agentskills** (works with Cursor, Copilot, Codex, etc.):
-
-```bash
-npx agents export --target claude
-```
-
-### Available Tools
-
-| Tool | Description |
-|------|-------------|
-| `procsi_get_status` | Daemon status, proxy port, request count |
-| `procsi_list_requests` | Search and filter captured requests |
-| `procsi_get_request` | Full request details by ID (headers, bodies, timing) |
-| `procsi_search_bodies` | Full-text search through body content |
-| `procsi_query_json` | Extract values from JSON bodies via JSONPath |
-| `procsi_count_requests` | Count matching requests |
-| `procsi_clear_requests` | Delete all captured requests |
-| `procsi_list_sessions` | List active proxy sessions |
-| `procsi_list_interceptors` | List loaded interceptors with status and errors |
-| `procsi_reload_interceptors` | Reload interceptors from disk |
-
-### Filtering
-
-Most tools accept these filters:
-
-| Parameter | Description | Example |
-|-----------|-------------|---------|
-| `method` | HTTP method(s), comma-separated | `"GET,POST"` |
-| `status_range` | Status code, Nxx pattern, or range | `"4xx"`, `"401"`, `"500-503"` |
-| `search` | Substring match on URL/path | `"api/users"` |
-| `host` | Exact or suffix match (prefix with `.`) | `"api.example.com"`, `".example.com"` |
-| `path` | Path prefix match | `"/api/v2"` |
-| `since` / `before` | Time window (ISO 8601) | `"2024-01-15T10:30:00Z"` |
-| `header_name` | Filter by header existence or value | `"content-type"` |
-| `header_value` | Exact header value (requires `header_name`) | `"application/json"` |
-| `header_target` | Which headers to search | `"request"`, `"response"`, `"both"` |
-| `intercepted_by` | Filter by interceptor name | `"mock-users"` |
-| `offset` | Pagination offset (0-based) | `0` |
-| `limit` | Max results (default 50, max 500) | `100` |
-
-`procsi_get_request` accepts comma-separated IDs for batch fetching (e.g. `"id1,id2,id3"`).
-
-`procsi_query_json` also takes:
-
-| Parameter | Description | Example |
-|-----------|-------------|---------|
-| `target` | Which body to query: `"request"`, `"response"`, or `"both"` (default) | `"response"` |
-| `value` | Exact value match after JSONPath extraction | `"active"` |
-
-### Output Formats
-
-All query tools accept a `format` parameter:
-
-- `text` (default) — markdown summaries, readable by humans and AI
-- `json` — structured JSON for programmatic use
-
-### Examples
-
-```
-procsi_list_requests({ status_range: "5xx", path: "/api" })
-procsi_search_bodies({ query: "error_code", method: "POST" })
-procsi_query_json({ json_path: "$.user.id", target: "response" })
-procsi_list_requests({ header_name: "authorization", header_target: "request" })
-```
-
 ## How It Works
 
 ```
@@ -330,11 +320,11 @@ procsi_list_requests({ header_name: "authorization", header_target: "request" })
 └─────────────────────────────────────────────────────────────┘
 ```
 
-`procsi on` (via the shell wrapper) starts a daemon, sets `HTTP_PROXY`/`HTTPS_PROXY` in your shell, and captures everything that flows through. `procsi off` unsets them. The TUI connects to the daemon via Unix socket.
+`eval "$(procsi on)"` starts a daemon, sets `HTTP_PROXY`/`HTTPS_PROXY` in your shell, and captures everything that flows through. `eval "$(procsi off)"` unsets them. The TUI connects to the daemon via Unix socket.
 
 ### Environment Variables
 
-`procsi on` sets these in your shell (`procsi off` unsets them). Without the shell wrapper, use `eval "$(procsi vars)"` and `eval "$(procsi vars --clear)"`:
+`eval "$(procsi on)"` sets these in your shell (`eval "$(procsi off)"` unsets them):
 
 | Variable | Purpose |
 |----------|---------|
@@ -472,25 +462,28 @@ Mouse support: click to select, scroll to navigate, click panels to focus.
 | `-v, --verbose` | Increase log verbosity (stackable: `-vv`, `-vvv`) |
 | `-d, --dir <path>` | Override project root directory |
 
-### `procsi init`
-
-Output shell wrapper function. Enables `procsi on`/`procsi off` to set environment variables in the current shell.
-
-### `procsi vars`
+### `procsi on`
 
-Output shell `export` statements to set proxy environment variables. Use with `eval`:
+Output shell `export` statements to start intercepting HTTP traffic. Use with `eval`:
 
 ```bash
-eval "$(procsi vars)"
+eval "$(procsi on)"
 ```
 
-With the shell wrapper from `procsi init`, you can use the simpler `procsi on` instead.
+If run directly in a TTY (without `eval`), shows usage instructions.
 
 | Flag | Description |
 |------|-------------|
 | `-l, --label <label>` | Label this session (visible in TUI and MCP) |
 | `--no-restart` | Don't auto-restart daemon on version mismatch |
-| `--clear` | Output `unset` statements to stop interception |
+
+### `procsi off`
+
+Output shell `unset` statements to stop intercepting HTTP traffic. Use with `eval`:
+
+```bash
+eval "$(procsi off)"
+```
 
 ### `procsi tui`
 
@@ -512,6 +505,94 @@ Stop the daemon.
 
 Restart the daemon (or start it if not running).
 
+### `procsi requests`
+
+List and filter captured requests. Output is a colour-coded table with short IDs — pipe to other tools or use `--json` for structured output.
+
+```bash
+procsi requests                              # list recent (default limit 50)
+procsi requests --method GET,POST            # filter by method
+procsi requests --status 4xx                 # filter by status range
+procsi requests --host api.example.com       # filter by host
+procsi requests --path /api/v2               # filter by path prefix
+procsi requests --search "keyword"           # substring match on URL
+procsi requests --since 5m                   # last 5 minutes
+procsi requests --since yesterday            # since midnight yesterday
+procsi requests --since 10am --before 11am   # time window
+procsi requests --header "content-type:application/json"  # header filter
+procsi requests --intercepted-by mock-users  # interceptor filter
+procsi requests --limit 100 --offset 50      # pagination
+procsi requests --json                       # JSON output
+```
+
+| Flag | Description |
+|------|-------------|
+| `--method <methods>` | Filter by HTTP method (comma-separated) |
+| `--status <range>` | Status range: `2xx`, `4xx`, exact `401`, etc. |
+| `--host <host>` | Filter by hostname |
+| `--path <prefix>` | Filter by path prefix |
+| `--search <text>` | Substring match on URL |
+| `--since <time>` | Since time (5m, 2h, 10am, yesterday, monday, 2024-01-01) |
+| `--before <time>` | Before time (same formats as --since) |
+| `--header <spec>` | Header name or name:value |
+| `--header-target <target>` | `request`, `response`, or `both` (default) |
+| `--intercepted-by <name>` | Filter by interceptor name |
+| `--limit <n>` | Max results (default 50) |
+| `--offset <n>` | Skip results (default 0) |
+| `--json` | JSON output |
+
+#### `procsi requests search <query>`
+
+Full-text search through request and response bodies.
+
+#### `procsi requests query <jsonpath>`
+
+Query JSON bodies using JSONPath expressions (e.g. `$.data.id`). Supports `--value`, `--target` (request/response/both).
+
+#### `procsi requests count`
+
+Count requests matching the current filters.
+
+#### `procsi requests clear`
+
+Clear all captured requests. Prompts for confirmation unless `--yes` is passed.
+
+### `procsi request <id>`
+
+View a single request in detail. Accepts full UUIDs or abbreviated prefixes (first 7+ characters).
+
+```bash
+procsi request a1b2c3d              # full detail view
+procsi request a1b2c3d --json       # JSON output
+```
+
+#### `procsi request <id> body`
+
+Dump the response body to stdout (raw, pipeable). Use `--request` for the request body instead.
+
+```bash
+procsi request a1b2c3d body                # response body
+procsi request a1b2c3d body --request      # request body
+procsi request a1b2c3d body | jq .         # pipe to jq
+```
+
+#### `procsi request <id> export <format>`
+
+Export a request as `curl` or `har`.
+
+```bash
+procsi request a1b2c3d export curl
+procsi request a1b2c3d export har
+```
+
+### `procsi sessions`
+
+List active proxy sessions.
+
+| Flag | Description |
+|------|-------------|
+| `--json` | JSON output |
+
 ### `procsi clear`
 
 Clear all captured requests.
@@ -540,6 +621,41 @@ Scaffold an example interceptor in `.procsi/interceptors/`.
 
 Reload interceptors from disk without restarting the daemon.
 
+### `procsi interceptors logs`
+
+View the interceptor event log. Events include match results, mock responses, errors, timeouts, and `ctx.log()` output.
+
+```bash
+procsi interceptors logs                         # recent events
+procsi interceptors logs --name mock-users       # filter by interceptor
+procsi interceptors logs --level error           # filter by level
+procsi interceptors logs --limit 100             # more results
+procsi interceptors logs --follow                # live tail (Ctrl+C to stop)
+procsi interceptors logs --follow --json         # live tail as NDJSON
+```
+
+| Flag | Description |
+|------|-------------|
+| `--name <interceptor>` | Filter by interceptor name |
+| `--level <level>` | Filter by level (info, warn, error) |
+| `--limit <n>` | Max events (default 50) |
+| `--follow` | Live tail — poll for new events |
+| `--json` | JSON output |
+
+#### `procsi interceptors logs clear`
+
+Clear the interceptor event log.
+
+### `procsi completions <shell>`
+
+Generate shell completion scripts. Supports `zsh`, `bash`, and `fish`.
+
+```bash
+eval "$(procsi completions zsh)"    # add to .zshrc
+eval "$(procsi completions bash)"   # add to .bashrc
+procsi completions fish | source    # add to fish config
+```
+
 ## Development
 
 ```bash
@@ -571,7 +687,7 @@ Check if something else is using the socket:
 ```bash
 procsi status
 procsi daemon stop
-procsi on  # or: eval "$(procsi vars)"
+eval "$(procsi on)"
 ```
 
 ### Terminal too small
@@ -580,7 +696,7 @@ The TUI needs at least 60 columns by 10 rows.
 
 ### Requests not appearing
 
-Your HTTP client needs to respect proxy environment variables. Browsers typically don't — use curl, wget, or language-level HTTP clients instead.
+Your HTTP client needs to respect proxy environment variables. 
 
 ## Licence
 

package/dist/cli/commands/completions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * `procsi completions <shell>` — generate shell completion scripts.
+ *
+ * Outputs a completion script that the user sources in their shell config.
+ * Generated by walking the Commander program tree.
+ */
+import { Command } from "commander";
+export declare const completionsCommand: Command;
+//# sourceMappingURL=completions.d.ts.map

package/dist/cli/commands/completions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completions.d.ts","sourceRoot":"","sources":["../../../src/cli/commands/completions.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AA8KpC,eAAO,MAAM,kBAAkB,SAuB3B,CAAC"}

package/dist/cli/commands/completions.js

@@ -0,0 +1,170 @@
+/**
+ * `procsi completions <shell>` — generate shell completion scripts.
+ *
+ * Outputs a completion script that the user sources in their shell config.
+ * Generated by walking the Commander program tree.
+ */
+import { Command } from "commander";
+const SUPPORTED_SHELLS = ["zsh", "bash", "fish"];
+/**
+ * Escape a string for use inside a single-quoted shell string.
+ * Replaces ' with '\'' (end quote, escaped quote, start quote).
+ */
+function escapeForShell(str) {
+    return str.replace(/'/g, "'\\''");
+}
+function collectCommands(cmd) {
+    return cmd.commands.map((sub) => ({
+        name: sub.name(),
+        description: sub.description(),
+        options: sub.options.map((opt) => ({
+            flags: opt.long ?? opt.short ?? "",
+            description: opt.description,
+        })),
+        subcommands: collectCommands(sub),
+    }));
+}
+/**
+ * Generate a zsh completion script.
+ */
+function generateZshCompletions(program) {
+    const commands = collectCommands(program);
+    const globalOptions = program.options.map((opt) => `'${escapeForShell(opt.long ?? opt.short ?? "")}[${escapeForShell(opt.description)}]'`);
+    const subcmdCases = commands
+        .map((cmd) => {
+        const opts = cmd.options
+            .map((o) => `'${escapeForShell(o.flags)}[${escapeForShell(o.description)}]'`)
+            .join(" \\\n          ");
+        const subs = cmd.subcommands
+            .map((s) => `'${escapeForShell(s.name)}:${escapeForShell(s.description)}'`)
+            .join(" ");
+        const subsSection = subs
+            ? `\n        local -a ${cmd.name}_subcommands\n        ${cmd.name}_subcommands=(${subs})\n        _describe -t commands '${escapeForShell(cmd.name)} subcommand' ${cmd.name}_subcommands`
+            : "";
+        return `      ${cmd.name})\n        _arguments ${opts}${subsSection}\n        ;;`;
+    })
+        .join("\n");
+    const cmdList = commands
+        .map((c) => `'${escapeForShell(c.name)}:${escapeForShell(c.description)}'`)
+        .join(" \\\n    ");
+    return `#compdef procsi
+
+# Auto-generated by procsi completions zsh
+# Add to your .zshrc: eval "$(procsi completions zsh)"
+
+_procsi() {
+  local -a commands
+  commands=(
+    ${cmdList}
+  )
+
+  _arguments -C \\
+    ${globalOptions.join(" \\\n    ")} \\
+    '1:command:->command' \\
+    '*::arg:->args'
+
+  case "$state" in
+    command)
+      _describe -t commands 'procsi command' commands
+      ;;
+    args)
+      case "$words[1]" in
+${subcmdCases}
+      esac
+      ;;
+  esac
+}
+
+compdef _procsi procsi
+`;
+}
+/**
+ * Generate a bash completion script.
+ */
+function generateBashCompletions(program) {
+    const commands = collectCommands(program);
+    const cmdNames = commands.map((c) => c.name).join(" ");
+    const subcmdCases = commands
+        .map((cmd) => {
+        const opts = cmd.options.map((o) => escapeForShell(o.flags)).join(" ");
+        const subs = cmd.subcommands.map((s) => escapeForShell(s.name)).join(" ");
+        return `    ${cmd.name})\n      COMPREPLY=($(compgen -W "${opts} ${subs}" -- "$cur"))\n      ;;`;
+    })
+        .join("\n");
+    return `# Auto-generated by procsi completions bash
+# Add to your .bashrc: eval "$(procsi completions bash)"
+
+_procsi() {
+  local cur prev words cword
+  _init_completion || return
+
+  local commands="${cmdNames}"
+
+  if [[ $cword -eq 1 ]]; then
+    COMPREPLY=($(compgen -W "$commands" -- "$cur"))
+    return
+  fi
+
+  case "\${words[1]}" in
+${subcmdCases}
+  esac
+}
+
+complete -F _procsi procsi
+`;
+}
+/**
+ * Generate a fish completion script.
+ */
+function generateFishCompletions(program) {
+    const commands = collectCommands(program);
+    const lines = [
+        "# Auto-generated by procsi completions fish",
+        "# Add to your config: procsi completions fish | source",
+        "",
+        "# Disable file completions by default",
+        "complete -c procsi -f",
+        "",
+    ];
+    // Top-level commands
+    for (const cmd of commands) {
+        lines.push(`complete -c procsi -n '__fish_use_subcommand' -a '${escapeForShell(cmd.name)}' -d '${escapeForShell(cmd.description)}'`);
+    }
+    lines.push("");
+    // Subcommand options
+    for (const cmd of commands) {
+        for (const opt of cmd.options) {
+            const flag = opt.flags.replace(/^--/, "");
+            lines.push(`complete -c procsi -n '__fish_seen_subcommand_from ${cmd.name}' -l '${escapeForShell(flag)}' -d '${escapeForShell(opt.description)}'`);
+        }
+        for (const sub of cmd.subcommands) {
+            lines.push(`complete -c procsi -n '__fish_seen_subcommand_from ${cmd.name}' -a '${escapeForShell(sub.name)}' -d '${escapeForShell(sub.description)}'`);
+        }
+    }
+    return lines.join("\n") + "\n";
+}
+export const completionsCommand = new Command("completions")
+    .description("Generate shell completion scripts")
+    .argument("<shell>", `shell type (${SUPPORTED_SHELLS.join(", ")})`)
+    .action((shell, _opts, command) => {
+    if (!SUPPORTED_SHELLS.includes(shell)) {
+        console.error(`Unsupported shell: "${shell}"`);
+        console.error(`Supported shells: ${SUPPORTED_SHELLS.join(", ")}`);
+        process.exit(1);
+    }
+    // Walk up to the root program
+    let root = command;
+    while (root.parent) {
+        root = root.parent;
+    }
+    if (shell === "zsh") {
+        console.log(generateZshCompletions(root));
+    }
+    else if (shell === "bash") {
+        console.log(generateBashCompletions(root));
+    }
+    else if (shell === "fish") {
+        console.log(generateFishCompletions(root));
+    }
+});
+//# sourceMappingURL=completions.js.map