pi-shell-completions 0.1.0

package/README.md

@@ -0,0 +1,70 @@
+# pi-shell-completions
+
+Adds native shell completions to pi's `!` and `!!` bash mode commands.
+
+## Installation
+
+```bash
+pi install npm:pi-shell-completions
+```
+
+Or for local development, place in `~/.pi/agent/extensions/shell-completions/`
+
+## How it works
+
+When you type `!git checkout ` in pi's prompt, this extension queries your shell's completion system and shows suggestions.
+
+### Shell support
+
+| Shell | How it works | Quality |
+|-------|--------------|---------|
+| **Fish** | Native `complete -C` command | ⭐⭐⭐ Excellent - all completions work |
+| **Bash** | Sources bash-completion scripts | ⭐⭐ Good - if bash-completion is installed |
+| **Zsh** | Fallback script for common tools | ⭐ Basic - see limitations |
+
+### Fish (recommended)
+
+Fish's completion system is designed to be queried programmatically via `complete -C "command "`. This means:
+
+- All your fish completions work automatically
+- Git branches, docker containers, ssh hosts, npm scripts — everything
+- Descriptions are included
+- Fast (10-30ms)
+
+Even if fish isn't your primary shell, installing it gives you great completions in pi.
+
+### Bash
+
+Bash-completion can be queried by setting up `COMP_*` environment variables and calling completion functions. This extension:
+
+- Sources completion scripts from standard locations (`/opt/homebrew/etc/bash_completion.d/`, `/usr/share/bash-completion/completions/`, etc.)
+- Calls the registered completion function for each command
+- Works if you have bash-completion installed
+
+### Zsh (limited)
+
+Zsh's completion system is tightly coupled to its line editor (ZLE) and cannot be easily queried programmatically. The `zpty` pseudo-terminal approach is complex and unreliable.
+
+**Current limitations:**
+- Does NOT use your full zsh completion config
+- Only handles common tools: git, ssh, make, npm/yarn/pnpm, docker
+- Falls back to file completion for other commands
+
+**Recommendation:** If you use zsh and want good completions in pi, install fish as a secondary shell. The extension will automatically prefer fish when available.
+
+## Shell priority
+
+1. Your `$SHELL` (if fish/zsh/bash)
+2. Fish (if available) — even if not your primary shell
+3. Zsh
+4. Bash
+
+## Requirements
+
+- One of: fish, zsh, or bash
+- For bash: bash-completion package installed
+- For best experience: fish
+
+## License
+
+MIT

package/bash.ts

@@ -0,0 +1,125 @@
+/**
+ * Bash shell completion provider.
+ *
+ * Uses bash's native completion system by running a script that sets up
+ * COMP_* environment variables and calls the registered completion function.
+ *
+ * Philosophy: Only provide completions if the user has bash-completion available.
+ */
+
+import type { AutocompleteItem } from "@mariozechner/pi-tui";
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { CompletionResult, ShellCompletionProvider } from "./types.js";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const COMPLETE_SCRIPT = path.join(__dirname, "scripts", "bash-complete.bash");
+
+/**
+ * Check if bash-completion is available.
+ * We check for the presence of completion scripts in standard locations.
+ */
+let completionCheckCache: boolean | null = null;
+
+function userHasBashCompletions(bashPath: string): boolean {
+	if (completionCheckCache !== null) {
+		return completionCheckCache;
+	}
+
+	try {
+		// Check if bash-completion framework or git completion exists
+		const result = spawnSync(
+			bashPath,
+			[
+				"-c",
+				`
+				for f in /usr/share/bash-completion/bash_completion /etc/bash_completion /opt/homebrew/etc/bash_completion /opt/homebrew/share/bash-completion/bash_completion; do
+					[[ -f "$f" ]] && { echo yes; exit 0; }
+				done
+				# Also check for individual completion files
+				for f in /opt/homebrew/etc/bash_completion.d/git* /usr/share/bash-completion/completions/git; do
+					[[ -f "$f" ]] && { echo yes; exit 0; }
+				done
+				echo no
+			`,
+			],
+			{
+				encoding: "utf-8",
+				timeout: 500,
+			}
+		);
+
+		completionCheckCache = result.stdout?.trim() === "yes";
+		return completionCheckCache;
+	} catch {
+		completionCheckCache = false;
+		return false;
+	}
+}
+
+/**
+ * Get completions using bash's native completion system.
+ */
+export function getBashCompletions(
+	commandLine: string,
+	cwd: string,
+	bashPath: string
+): CompletionResult | null {
+	// Check if bash completions are available
+	if (!userHasBashCompletions(bashPath)) {
+		return null;
+	}
+
+	// Check if completion script exists
+	if (!fs.existsSync(COMPLETE_SCRIPT)) {
+		return null;
+	}
+
+	// Extract prefix
+	const trimmed = commandLine.trimStart();
+	let prefix = "";
+	if (!trimmed.endsWith(" ")) {
+		const words = trimmed.split(/\s+/);
+		prefix = words[words.length - 1] || "";
+	}
+
+	try {
+		const result = spawnSync(bashPath, [COMPLETE_SCRIPT, commandLine, cwd], {
+			encoding: "utf-8",
+			timeout: 500,
+			maxBuffer: 1024 * 100,
+			cwd,
+		});
+
+		if (result.error || !result.stdout) {
+			return null;
+		}
+
+		const items: AutocompleteItem[] = result.stdout
+			.trim()
+			.split("\n")
+			.filter(Boolean)
+			.map((line) => {
+				// Remove trailing space that bash completion adds
+				const value = line.trimEnd();
+				return { value, label: value };
+			});
+
+		if (items.length === 0) {
+			return null;
+		}
+
+		return {
+			items: items.slice(0, 30),
+			prefix,
+		};
+	} catch {
+		return null;
+	}
+}
+
+export const bashCompletionProvider: ShellCompletionProvider = {
+	getCompletions: getBashCompletions,
+};

package/fish.ts

@@ -0,0 +1,84 @@
+/**
+ * Fish shell completion provider.
+ *
+ * Uses fish's native `complete -C` command which provides excellent completions
+ * for most tools automatically.
+ * 
+ * Fish always has completions available (it's a core feature), so this never
+ * returns null for "user hasn't configured completions".
+ */
+
+import type { AutocompleteItem } from "@mariozechner/pi-tui";
+import { spawnSync } from "node:child_process";
+import type { CompletionResult, ShellCompletionProvider } from "./types.js";
+
+/**
+ * Get completions using fish's native `complete -C` command.
+ * Fish completions are excellent and cover most tools automatically.
+ */
+export function getFishCompletions(
+	commandLine: string,
+	cwd: string,
+	fishPath: string
+): CompletionResult | null {
+	// Extract prefix
+	const trimmed = commandLine.trimStart();
+	let prefix = "";
+	if (!trimmed.endsWith(" ")) {
+		const words = trimmed.split(/\s+/);
+		prefix = words[words.length - 1] || "";
+	}
+
+	try {
+		// Fish's complete -C gives us completions directly
+		const result = spawnSync(
+			fishPath,
+			["-c", `complete -C ${JSON.stringify(commandLine)}`],
+			{
+				encoding: "utf-8",
+				timeout: 500,
+				maxBuffer: 1024 * 100,
+				cwd,
+			}
+		);
+
+		if (result.error || !result.stdout) {
+			return null;
+		}
+
+		// Fish output format: "completion\tdescription" (tab-separated)
+		const lines = result.stdout.trim().split("\n").filter(Boolean);
+		const items: AutocompleteItem[] = [];
+
+		for (const line of lines) {
+			const tabIndex = line.indexOf("\t");
+			if (tabIndex >= 0) {
+				const value = line.slice(0, tabIndex).trim();
+				const description = line.slice(tabIndex + 1).trim();
+				if (value) {
+					items.push({ value, label: value, description });
+				}
+			} else {
+				const value = line.trim();
+				if (value) {
+					items.push({ value, label: value });
+				}
+			}
+		}
+
+		if (items.length === 0) {
+			return null;
+		}
+
+		return {
+			items: items.slice(0, 30),
+			prefix,
+		};
+	} catch {
+		return null;
+	}
+}
+
+export const fishCompletionProvider: ShellCompletionProvider = {
+	getCompletions: getFishCompletions,
+};

package/index.ts

@@ -0,0 +1,330 @@
+/**
+ * Shell Completions Extension for Pi
+ *
+ * Adds native shell completions (fish/zsh/bash) to pi's `!` and `!!` bash mode.
+ * Uses the user's actual shell completion configuration - if they haven't
+ * set up completions, we don't provide them (no magic).
+ *
+ * Usage: Place in ~/.pi/agent/extensions/shell-completions/index.ts
+ *
+ * Shell priority:
+ * 1. User's $SHELL (if fish/zsh/bash) - uses their configured completions
+ * 2. Fish (if available) - always has completions (core feature)
+ * 3. Zsh (if compinit is configured)
+ * 4. Bash (if bash-completion is installed)
+ *
+ * Philosophy: Don't magically provide completions the user hasn't configured.
+ * This means completions respect the user's shell setup, aliases, and customizations.
+ */
+
+import { CustomEditor, type ExtensionAPI } from "@mariozechner/pi-coding-agent";
+import type { AutocompleteItem, AutocompleteProvider } from "@mariozechner/pi-tui";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+import type { ShellInfo, ShellType, CompletionResult } from "./types.js";
+import { getFishCompletions } from "./fish.js";
+import { getBashCompletions } from "./bash.js";
+import { getZshCompletions } from "./zsh.js";
+
+// ============================================================================
+// Shell Detection
+// ============================================================================
+
+/**
+ * Detect shell type from path.
+ */
+function detectShellType(shellPath: string): ShellType {
+	const name = path.basename(shellPath);
+	if (name === "fish" || name.startsWith("fish")) return "fish";
+	if (name === "zsh" || name.startsWith("zsh")) return "zsh";
+	return "bash";
+}
+
+/**
+ * Find a shell suitable for running completion scripts.
+ *
+ * Priority:
+ * 1. User's $SHELL if it's fish/zsh/bash (respects user's configured completions)
+ * 2. Fish if available (best completion UX)
+ * 3. Zsh if available
+ * 4. Bash as fallback
+ */
+function findCompletionShell(): ShellInfo {
+	// First, try user's $SHELL - they've configured their completions there
+	const userShell = process.env.SHELL;
+	if (userShell && fs.existsSync(userShell)) {
+		const shellType = detectShellType(userShell);
+		// Only use it if it's a shell we support (fish/zsh/bash)
+		if (shellType === "fish" || shellType === "zsh" || shellType === "bash") {
+			return { path: userShell, type: shellType };
+		}
+	}
+
+	// If user's shell isn't suitable, prefer fish for best completions
+	const fishPaths = [
+		"/opt/homebrew/bin/fish",
+		"/usr/local/bin/fish",
+		"/usr/bin/fish",
+		"/bin/fish",
+	];
+	for (const fishPath of fishPaths) {
+		if (fs.existsSync(fishPath)) {
+			return { path: fishPath, type: "fish" };
+		}
+	}
+
+	// Then zsh
+	const zshPaths = [
+		"/bin/zsh",
+		"/usr/bin/zsh",
+		"/usr/local/bin/zsh",
+		"/opt/homebrew/bin/zsh",
+	];
+	for (const zshPath of zshPaths) {
+		if (fs.existsSync(zshPath)) {
+			return { path: zshPath, type: "zsh" };
+		}
+	}
+
+	// Bash fallback
+	const bashPaths = [
+		"/bin/bash",
+		"/usr/bin/bash",
+		"/usr/local/bin/bash",
+		"/opt/homebrew/bin/bash",
+	];
+	for (const bashPath of bashPaths) {
+		if (fs.existsSync(bashPath)) {
+			return { path: bashPath, type: "bash" };
+		}
+	}
+
+	return { path: "/bin/bash", type: "bash" };
+}
+
+// ============================================================================
+// Completion Context Extraction
+// ============================================================================
+
+/**
+ * Extract the command line and completion prefix from editor text.
+ */
+function extractCompletionContext(text: string): {
+	commandLine: string;
+	prefix: string;
+} {
+	// Remove ! or !! prefix
+	let commandLine = text.trimStart();
+	if (commandLine.startsWith("!!")) {
+		commandLine = commandLine.slice(2);
+	} else if (commandLine.startsWith("!")) {
+		commandLine = commandLine.slice(1);
+	}
+
+	const trimmed = commandLine.trimStart();
+
+	// If ends with space, completing a new word
+	if (trimmed.endsWith(" ")) {
+		return { commandLine: trimmed, prefix: "" };
+	}
+
+	// Last word is the prefix
+	const words = trimmed.split(/\s+/);
+	const prefix = words[words.length - 1] || "";
+
+	return { commandLine: trimmed, prefix };
+}
+
+// ============================================================================
+// Shell Completion Dispatcher
+// ============================================================================
+
+/**
+ * Get shell completions for a command line.
+ * Returns null if the user hasn't configured completions for their shell.
+ */
+function getShellCompletions(
+	text: string,
+	cwd: string,
+	shell: ShellInfo
+): CompletionResult | null {
+	const { commandLine } = extractCompletionContext(text);
+
+	if (!commandLine.trim()) {
+		return null;
+	}
+
+	// Each shell provider checks if user has completions configured
+	// and returns null if not
+	switch (shell.type) {
+		case "fish":
+			// Fish always has completions (it's a core feature)
+			return getFishCompletions(commandLine, cwd, shell.path);
+		case "bash":
+			// Bash: only works if bash-completion is available
+			return getBashCompletions(commandLine, cwd, shell.path);
+		case "zsh":
+			// Zsh: only works if user has compinit in their .zshrc
+			return getZshCompletions(commandLine, cwd, shell.path);
+		default:
+			return null;
+	}
+}
+
+// ============================================================================
+// Shell-Aware Autocomplete Provider Wrapper
+// ============================================================================
+
+/**
+ * Wraps an existing autocomplete provider to add shell completion support
+ * when in bash mode (text starts with ! or !!).
+ */
+function wrapWithShellCompletion(
+	baseProvider: AutocompleteProvider,
+	shell: ShellInfo
+): AutocompleteProvider {
+	const isBashMode = (lines: string[]): boolean => {
+		const text = lines.join("\n").trimStart();
+		return text.startsWith("!") || text.startsWith("!!");
+	};
+
+	const getTextUpToCursor = (
+		lines: string[],
+		cursorLine: number,
+		cursorCol: number
+	): string => {
+		const textLines = lines.slice(0, cursorLine + 1);
+		if (textLines.length > 0) {
+			textLines[textLines.length - 1] = textLines[textLines.length - 1].slice(0, cursorCol);
+		}
+		return textLines.join("\n");
+	};
+
+	return {
+		getSuggestions(
+			lines: string[],
+			cursorLine: number,
+			cursorCol: number
+		): { items: AutocompleteItem[]; prefix: string } | null {
+			if (isBashMode(lines)) {
+				const text = getTextUpToCursor(lines, cursorLine, cursorCol);
+				const result = getShellCompletions(text, process.cwd(), shell);
+				if (result && result.items.length > 0) {
+					return result;
+				}
+			}
+			return baseProvider.getSuggestions(lines, cursorLine, cursorCol);
+		},
+
+		applyCompletion(
+			lines: string[],
+			cursorLine: number,
+			cursorCol: number,
+			item: AutocompleteItem,
+			prefix: string
+		): { lines: string[]; cursorLine: number; cursorCol: number } {
+			if (isBashMode(lines)) {
+				const currentLine = lines[cursorLine] || "";
+				const prefixStart = cursorCol - prefix.length;
+				const beforePrefix = currentLine.slice(0, prefixStart);
+				const afterCursor = currentLine.slice(cursorCol);
+
+				// Don't add space after directories
+				const isDirectory = item.value.endsWith("/");
+				const suffix = isDirectory ? "" : " ";
+
+				const newLine = beforePrefix + item.value + suffix + afterCursor;
+				const newLines = [...lines];
+				newLines[cursorLine] = newLine;
+
+				return {
+					lines: newLines,
+					cursorLine,
+					cursorCol: prefixStart + item.value.length + suffix.length,
+				};
+			}
+
+			return baseProvider.applyCompletion(lines, cursorLine, cursorCol, item, prefix);
+		},
+
+		// Forward optional methods
+		getForceFileSuggestions(
+			lines: string[],
+			cursorLine: number,
+			cursorCol: number
+		): { items: AutocompleteItem[]; prefix: string } | null {
+			if (isBashMode(lines)) {
+				const text = getTextUpToCursor(lines, cursorLine, cursorCol);
+				return getShellCompletions(text, process.cwd(), shell);
+			}
+			if ("getForceFileSuggestions" in baseProvider) {
+				return (baseProvider as any).getForceFileSuggestions(lines, cursorLine, cursorCol);
+			}
+			return this.getSuggestions(lines, cursorLine, cursorCol);
+		},
+
+		shouldTriggerFileCompletion(
+			lines: string[],
+			cursorLine: number,
+			cursorCol: number
+		): boolean {
+			if (isBashMode(lines)) {
+				return true;
+			}
+			if ("shouldTriggerFileCompletion" in baseProvider) {
+				return (baseProvider as any).shouldTriggerFileCompletion(lines, cursorLine, cursorCol);
+			}
+			return true;
+		},
+	};
+}
+
+// ============================================================================
+// Custom Editor with Shell Completion
+// ============================================================================
+
+/**
+ * Custom editor that intercepts setAutocompleteProvider to wrap with shell completion.
+ */
+class ShellCompletionEditor extends CustomEditor {
+	private shell: ShellInfo;
+	private wrappedProvider = false;
+
+	constructor(tui: any, theme: any, keybindings: any, shell: ShellInfo) {
+		super(tui, theme, keybindings);
+		this.shell = shell;
+	}
+
+	// Override setAutocompleteProvider to wrap the base provider
+	setAutocompleteProvider(provider: AutocompleteProvider): void {
+		if (!this.wrappedProvider && provider) {
+			// Wrap the provider with shell completion support
+			const wrapped = wrapWithShellCompletion(provider, this.shell);
+			super.setAutocompleteProvider(wrapped);
+			this.wrappedProvider = true;
+		} else {
+			super.setAutocompleteProvider(provider);
+		}
+	}
+}
+
+// ============================================================================
+// Extension Entry Point
+// ============================================================================
+
+export default function (pi: ExtensionAPI) {
+	const shell = findCompletionShell();
+	const shellName = path.basename(shell.path);
+
+	pi.on("session_start", (_event, ctx) => {
+		ctx.ui.setEditorComponent((tui, theme, keybindings) => {
+			return new ShellCompletionEditor(tui, theme, keybindings, shell);
+		});
+
+		ctx.ui.notify(`Shell completions enabled (${shellName})`, "info");
+	});
+}
+
+// Re-export types for potential external use
+export type { ShellInfo, ShellType, CompletionResult } from "./types.js";

package/package.json

@@ -0,0 +1,20 @@
+{
+  "name": "pi-shell-completions",
+  "version": "0.1.0",
+  "description": "Pi extension that adds native shell completions (fish/zsh/bash) to ! and !! bash mode commands",
+  "type": "module",
+  "keywords": ["pi-package"],
+  "license": "MIT",
+  "author": "laulauland",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/laulauland/dotfiles"
+  },
+  "pi": {
+    "extensions": ["./index.ts"]
+  },
+  "peerDependencies": {
+    "@mariozechner/pi-coding-agent": "*",
+    "@mariozechner/pi-tui": "*"
+  }
+}

package/scripts/bash-complete.bash

@@ -0,0 +1,47 @@
+#!/bin/bash
+# Gets completions using bash's native completion system
+# Usage: bash-complete.bash "command line" "/path/to/cwd"
+
+__cmdline="$1"
+__cwd="$2"
+
+cd "$__cwd" 2>/dev/null || exit 1
+
+# Extract command name
+__cmd=${__cmdline%% *}
+
+# Source bash-completion framework if available
+for f in /usr/share/bash-completion/bash_completion /etc/bash_completion /opt/homebrew/etc/bash_completion /opt/homebrew/share/bash-completion/bash_completion; do
+    [[ -f "$f" ]] && { source "$f" 2>/dev/null; break; }
+done
+
+# Also try to source command-specific completions directly (macOS/Homebrew)
+for dir in /opt/homebrew/etc/bash_completion.d /usr/share/bash-completion/completions /etc/bash_completion.d; do
+    for f in "$dir/$__cmd" "$dir/$__cmd.bash" "$dir/${__cmd}-completion.bash"; do
+        [[ -f "$f" ]] && source "$f" 2>/dev/null
+    done
+done
+
+# Set up completion environment
+COMP_LINE="$__cmdline"
+COMP_POINT=${#COMP_LINE}
+eval set -- "$COMP_LINE"
+COMP_WORDS=("$@")
+
+# Add empty word if line ends with space (completing new word)
+[[ "${COMP_LINE: -1}" = ' ' ]] && COMP_WORDS+=('')
+
+COMP_CWORD=$(( ${#COMP_WORDS[@]} - 1 ))
+
+# Load completion for the command if available
+declare -F _completion_loader &>/dev/null && _completion_loader "$__cmd" 2>/dev/null
+
+# Get the completion function
+completion=$(complete -p "$__cmd" 2>/dev/null | awk '{print $(NF-1)}')
+
+if [[ -n "$completion" ]] && declare -F "$completion" &>/dev/null; then
+    # Call the completion function
+    "$completion" 2>/dev/null
+    # Output unique results
+    printf '%s\n' "${COMPREPLY[@]}" | sort -u | head -30
+fi

package/scripts/zsh-capture.zsh

@@ -0,0 +1,148 @@
+#!/bin/zsh
+# Simple zsh completion capture using _complete_help
+# Usage: zsh-capture.zsh "command line" "/path/to/cwd"
+
+emulate -L zsh
+setopt no_beep
+
+local cmdline="$1"
+local cwd="$2"
+
+cd "$cwd" 2>/dev/null || exit 1
+
+# Initialize completion system (use user's zcompdump)
+autoload -Uz compinit
+compinit -C 2>/dev/null
+
+# Parse command line
+local -a words
+words=("${(@Q)${(z)cmdline}}")
+
+# If line ends with space, we're completing a new word
+if [[ "$cmdline" == *" " ]]; then
+    words+=("")
+fi
+
+local cmd="${words[1]}"
+local current="${words[-1]}"
+
+# Helper to output completions
+output() {
+    local val="$1" desc="$2"
+    if [[ -n "$desc" ]]; then
+        print -r -- "${val}"$'\t'"${desc}"
+    else
+        print -r -- "${val}"
+    fi
+}
+
+# Git completions
+if [[ "$cmd" == "git" ]]; then
+    if (( ${#words} == 2 )); then
+        # Git subcommands
+        git --list-cmds=main,others 2>/dev/null | while read -r subcmd; do
+            [[ -z "$current" || "$subcmd" == "$current"* ]] && output "$subcmd"
+        done
+    else
+        local subcmd="${words[2]}"
+        case "$subcmd" in
+            checkout|switch|merge|rebase|branch|log)
+                # Branches
+                git for-each-ref --format='%(refname:short)' refs/heads 2>/dev/null | while read -r b; do
+                    [[ -z "$current" || "$b" == "$current"* ]] && output "$b" "branch"
+                done
+                git for-each-ref --format='%(refname:short)' refs/remotes 2>/dev/null | while read -r b; do
+                    [[ "$b" == */HEAD ]] && continue
+                    local short="${b#*/}"
+                    [[ -z "$current" || "$short" == "$current"* ]] && output "$short" "remote"
+                done
+                ;;
+            add|diff|restore|reset)
+                # Modified files
+                git diff --name-only 2>/dev/null | while read -r f; do
+                    [[ -z "$current" || "$f" == "$current"* ]] && output "$f" "modified"
+                done
+                git diff --cached --name-only 2>/dev/null | while read -r f; do
+                    [[ -z "$current" || "$f" == "$current"* ]] && output "$f" "staged"
+                done
+                ;;
+            push|pull|fetch)
+                if (( ${#words} == 3 )); then
+                    git remote 2>/dev/null | while read -r r; do
+                        [[ -z "$current" || "$r" == "$current"* ]] && output "$r" "remote"
+                    done
+                fi
+                ;;
+            stash)
+                for sub in apply drop list pop show push; do
+                    [[ -z "$current" || "$sub" == "$current"* ]] && output "$sub"
+                done
+                ;;
+        esac
+    fi
+    exit 0
+fi
+
+# SSH/SCP completions - hosts
+if [[ "$cmd" == "ssh" || "$cmd" == "scp" || "$cmd" == "sftp" ]]; then
+    {
+        [[ -f ~/.ssh/config ]] && awk '/^Host / && !/\*/{for(i=2;i<=NF;i++)print $i}' ~/.ssh/config
+        [[ -f ~/.ssh/known_hosts ]] && awk -F'[, ]' '{print $1}' ~/.ssh/known_hosts
+    } 2>/dev/null | sort -u | while read -r h; do
+        [[ -z "$current" || "$h" == "$current"* ]] && output "$h" "host"
+    done
+    exit 0
+fi
+
+# Make completions
+if [[ "$cmd" == "make" ]]; then
+    local mf
+    for f in GNUmakefile Makefile makefile; do
+        [[ -f "$f" ]] && mf="$f" && break
+    done
+    if [[ -n "$mf" ]]; then
+        awk -F: '/^[a-zA-Z_][a-zA-Z0-9_-]*:/ && !/^\./{print $1}' "$mf" 2>/dev/null | while read -r t; do
+            [[ -z "$current" || "$t" == "$current"* ]] && output "$t" "target"
+        done
+    fi
+    exit 0
+fi
+
+# NPM/Yarn/PNPM completions
+if [[ "$cmd" == "npm" || "$cmd" == "yarn" || "$cmd" == "pnpm" ]]; then
+    if (( ${#words} == 2 )); then
+        for sub in install add remove run build test start dev publish; do
+            [[ -z "$current" || "$sub" == "$current"* ]] && output "$sub"
+        done
+    elif [[ "${words[2]}" == "run" && -f package.json ]]; then
+        jq -r '.scripts // {} | keys[]' package.json 2>/dev/null | while read -r s; do
+            [[ -z "$current" || "$s" == "$current"* ]] && output "$s" "script"
+        done
+    fi
+    exit 0
+fi
+
+# Docker completions
+if [[ "$cmd" == "docker" ]]; then
+    if (( ${#words} == 2 )); then
+        for sub in build compose exec images logs ps pull push rm rmi run start stop; do
+            [[ -z "$current" || "$sub" == "$current"* ]] && output "$sub"
+        done
+    fi
+    exit 0
+fi
+
+# Fallback: file completion
+if [[ -n "$current" ]]; then
+    local -a matches
+    matches=( ${current}*(N) )
+    for f in "${matches[@]:0:20}"; do
+        [[ -d "$f" ]] && output "${f}/" "directory" || output "$f" "file"
+    done
+else
+    local -a matches
+    matches=( *(N) )
+    for f in "${matches[@]:0:20}"; do
+        [[ -d "$f" ]] && output "${f}/" "directory" || output "$f" "file"
+    done
+fi

package/types.ts

@@ -0,0 +1,30 @@
+/**
+ * Shared types for shell completions extension.
+ */
+
+import type { AutocompleteItem } from "@mariozechner/pi-tui";
+
+export type ShellType = "fish" | "zsh" | "bash";
+
+export interface ShellInfo {
+	path: string;
+	type: ShellType;
+}
+
+export interface CompletionContext {
+	commandLine: string;
+	prefix: string;
+}
+
+export interface CompletionResult {
+	items: AutocompleteItem[];
+	prefix: string;
+}
+
+/**
+ * Interface for shell-specific completion providers.
+ * Returns null if the user hasn't configured completions for this shell.
+ */
+export interface ShellCompletionProvider {
+	getCompletions(commandLine: string, cwd: string, shellPath: string): CompletionResult | null;
+}

package/zsh.ts

@@ -0,0 +1,110 @@
+/**
+ * Zsh completion support
+ *
+ * Unfortunately, zsh's completion system is tightly coupled to its line editor
+ * (ZLE) and cannot be easily queried programmatically without a pseudo-terminal.
+ * The zpty approach is complex and fragile.
+ *
+ * This implementation uses a simple fallback script that handles common cases
+ * (git, ssh, make, npm, docker) but does NOT tap into the user's full zsh
+ * completion configuration.
+ *
+ * For the best experience, install fish (even as a secondary shell) - its
+ * `complete -C` command provides excellent completions without complexity.
+ */
+
+import { spawnSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+import { fileURLToPath } from "node:url";
+import type { CompletionResult } from "./types.js";
+import type { AutocompleteItem } from "@mariozechner/pi-tui";
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const CAPTURE_SCRIPT = path.join(__dirname, "scripts", "zsh-capture.zsh");
+
+/**
+ * Parse completion output (tab-separated: value\tdescription)
+ */
+function parseOutput(output: string): AutocompleteItem[] {
+	const lines = output.trim().split("\n").filter(Boolean);
+	const items: AutocompleteItem[] = [];
+	const seen = new Set<string>();
+
+	for (const line of lines) {
+		const tabIndex = line.indexOf("\t");
+		let value: string;
+		let description: string | undefined;
+
+		if (tabIndex >= 0) {
+			value = line.slice(0, tabIndex).trim();
+			description = line.slice(tabIndex + 1).trim() || undefined;
+		} else {
+			value = line.trim();
+		}
+
+		if (!value || seen.has(value)) continue;
+		seen.add(value);
+
+		// Skip internal refs
+		if (value.startsWith("refs/jj/keep/")) continue;
+
+		items.push({ value, label: value, description });
+	}
+
+	return items;
+}
+
+/**
+ * Get completions using zsh fallback script.
+ * Note: This does NOT use the user's full zsh completion config.
+ */
+export function getZshCompletions(
+	commandLine: string,
+	cwd: string,
+	zshPath: string
+): CompletionResult | null {
+	// Check if capture script exists
+	if (!fs.existsSync(CAPTURE_SCRIPT)) {
+		return null;
+	}
+
+	// Extract prefix
+	const trimmed = commandLine.trimStart();
+	let prefix = "";
+	if (!trimmed.endsWith(" ")) {
+		const words = trimmed.split(/\s+/);
+		prefix = words[words.length - 1] || "";
+	}
+
+	try {
+		const result = spawnSync(zshPath, [CAPTURE_SCRIPT, commandLine, cwd], {
+			encoding: "utf-8",
+			timeout: 500,
+			maxBuffer: 1024 * 100,
+			cwd,
+		});
+
+		if (result.error || !result.stdout) {
+			return null;
+		}
+
+		const items = parseOutput(result.stdout);
+
+		if (items.length === 0) {
+			return null;
+		}
+
+		return {
+			items: items.slice(0, 30),
+			prefix,
+		};
+	} catch {
+		return null;
+	}
+}
+
+export const zshCompletionProvider = {
+	name: "zsh" as const,
+	getCompletions: getZshCompletions,
+};