ralphctl 0.1.0

package/src/ai/session.ts

@@ -0,0 +1,319 @@
+import { spawn, spawnSync } from 'node:child_process';
+import { ProcessManager } from '@src/ai/process-manager.ts';
+import { assertSafeCwd } from '@src/utils/paths.ts';
+import { type ProviderAdapter } from '@src/providers/types.ts';
+import { getActiveProvider } from '@src/providers/index.ts';
+
+// Re-export types from providers for backward compatibility
+export type { HeadlessSpawnOptions, SpawnResult } from '@src/providers/types.ts';
+export type { SpawnSyncOptions, SpawnAsyncOptions } from '@src/providers/types.ts';
+
+// Local import aliases for use in function signatures
+import type { HeadlessSpawnOptions, SpawnResult, SpawnSyncOptions, SpawnAsyncOptions } from '@src/providers/types.ts';
+
+/** Parsed JSON result from provider CLI --output-format json */
+export interface ProviderJsonResult {
+  type: string;
+  subtype: string;
+  is_error: boolean;
+  result: string;
+  session_id: string;
+  duration_ms: number;
+  total_cost_usd: number;
+  num_turns: number;
+}
+
+export class SpawnError extends Error {
+  public readonly stderr: string;
+  public readonly exitCode: number;
+  public readonly rateLimited: boolean;
+  public readonly retryAfterMs: number | null;
+  /** Session ID if available (for resume after rate limit) */
+  public readonly sessionId: string | null;
+
+  constructor(
+    message: string,
+    stderr: string,
+    exitCode: number,
+    sessionId?: string | null,
+    provider?: ProviderAdapter
+  ) {
+    super(message);
+    this.name = 'SpawnError';
+    this.stderr = stderr;
+    this.exitCode = exitCode;
+    this.sessionId = sessionId ?? null;
+    const rl = provider ? provider.detectRateLimit(stderr) : detectRateLimitFallback(stderr);
+    this.rateLimited = rl.rateLimited;
+    this.retryAfterMs = rl.retryAfterMs;
+  }
+}
+
+/**
+ * Fallback rate limit detection (used when no provider is available).
+ */
+function detectRateLimitFallback(stderr: string): { rateLimited: boolean; retryAfterMs: number | null } {
+  const patterns = [/rate.?limit/i, /\b429\b/, /too many requests/i, /overloaded/i, /\b529\b/];
+  const isRateLimited = patterns.some((p) => p.test(stderr));
+  if (!isRateLimited) {
+    return { rateLimited: false, retryAfterMs: null };
+  }
+  const retryMatch = /retry.?after:?\s*(\d+)/i.exec(stderr);
+  const retryAfterMs = retryMatch?.[1] ? parseInt(retryMatch[1], 10) * 1000 : null;
+  return { rateLimited: true, retryAfterMs };
+}
+
+/**
+ * Detect rate limit signals in stderr output.
+ * @deprecated Use provider.detectRateLimit() instead.
+ */
+export function detectRateLimit(stderr: string): { rateLimited: boolean; retryAfterMs: number | null } {
+  return detectRateLimitFallback(stderr);
+}
+
+/**
+ * Parse JSON output from provider CLI --output-format json.
+ * @deprecated Use provider.parseJsonOutput() instead.
+ */
+export function parseJsonOutput(stdout: string): { result: string; sessionId: string | null } {
+  try {
+    const parsed = JSON.parse(stdout) as Partial<ProviderJsonResult>;
+    return {
+      result: parsed.result ?? stdout,
+      sessionId: parsed.session_id ?? null,
+    };
+  } catch {
+    return { result: stdout, sessionId: null };
+  }
+}
+
+/**
+ * Spawn AI CLI for interactive session.
+ *
+ * Starts a single interactive session with an optional initial prompt.
+ * The prompt is passed as a CLI argument, keeping everything in one session.
+ * User sees and interacts with the AI directly in the terminal.
+ *
+ * @param prompt - Optional initial prompt to start the session with.
+ * @param options - Spawn options (cwd, args, env).
+ * @param provider - Provider adapter (defaults to active provider resolved from config).
+ */
+export function spawnInteractive(
+  prompt: string,
+  options: SpawnSyncOptions,
+  provider?: ProviderAdapter
+): { code: number; error?: string } {
+  assertSafeCwd(options.cwd);
+
+  // If no provider given, use a synchronous fallback (claude) since we can't await here
+  const p =
+    provider ??
+    ({
+      binary: 'claude',
+      baseArgs: ['--permission-mode', 'acceptEdits'],
+      buildInteractiveArgs: (pr: string, extra: string[] = []) => [
+        ...['--permission-mode', 'acceptEdits'],
+        ...extra,
+        '--',
+        pr,
+      ],
+    } as Pick<ProviderAdapter, 'binary' | 'baseArgs' | 'buildInteractiveArgs'>);
+
+  const args = prompt ? p.buildInteractiveArgs(prompt, options.args ?? []) : [...p.baseArgs, ...(options.args ?? [])];
+
+  const env = options.env ? { ...process.env, ...options.env } : undefined;
+
+  const result = spawnSync(p.binary, args, {
+    cwd: options.cwd,
+    stdio: 'inherit',
+    env,
+  });
+
+  if (result.error) {
+    return { code: 1, error: `Failed to spawn ${p.binary} CLI: ${result.error.message}` };
+  }
+
+  return { code: result.status ?? 1 };
+}
+
+/**
+ * Spawn AI CLI in print mode for headless execution.
+ * Captures stdout and returns the text result.
+ *
+ * Uses --output-format json internally to capture session IDs.
+ * The returned string is the extracted `result` field from the JSON output.
+ */
+export async function spawnHeadless(
+  options: SpawnAsyncOptions & { prompt?: string },
+  provider?: ProviderAdapter
+): Promise<string> {
+  const result = await spawnHeadlessRaw(options as HeadlessSpawnOptions, provider);
+  return result.stdout;
+}
+
+/**
+ * Low-level headless spawn returning structured result.
+ *
+ * Uses --output-format json to capture session_id for resumability.
+ * Extracts the text result from JSON and returns it in stdout.
+ * Session ID is available in the returned SpawnResult.
+ *
+ * Throws SpawnError on non-zero exit (includes rate limit detection + session ID).
+ */
+export async function spawnHeadlessRaw(
+  options: HeadlessSpawnOptions,
+  provider?: ProviderAdapter
+): Promise<SpawnResult> {
+  assertSafeCwd(options.cwd);
+  const p = provider ?? (await getActiveProvider());
+
+  return new Promise((resolve, reject) => {
+    const allArgs = p.buildHeadlessArgs(options.args ?? []);
+
+    // Add --resume if resuming a session (validate format to prevent argument injection)
+    if (options.resumeSessionId) {
+      if (!/^[a-zA-Z0-9_][a-zA-Z0-9_-]{0,127}$/.test(options.resumeSessionId)) {
+        reject(new SpawnError('Invalid session ID format', '', 1, null, p));
+        return;
+      }
+      allArgs.push('--resume', options.resumeSessionId);
+    }
+
+    const child = spawn(p.binary, allArgs, {
+      cwd: options.cwd,
+      stdio: ['pipe', 'pipe', 'pipe'],
+      env: options.env ? { ...process.env, ...options.env } : undefined,
+    });
+
+    // Register child with ProcessManager for signal handling
+    const manager = ProcessManager.getInstance();
+    try {
+      manager.registerChild(child);
+    } catch {
+      reject(new SpawnError('Cannot spawn during shutdown', '', 1, null, p));
+      return;
+    }
+
+    // Write prompt to stdin if provided, then close
+    const MAX_PROMPT_SIZE = 1_000_000; // 1MB
+    if (options.prompt) {
+      if (options.prompt.length > MAX_PROMPT_SIZE) {
+        reject(new SpawnError('Prompt exceeds maximum size (1MB)', '', 1, null, p));
+        return;
+      }
+      child.stdin.write(options.prompt);
+    }
+    child.stdin.end();
+
+    let rawStdout = '';
+    let stderr = '';
+
+    child.stdout.on('data', (data: Buffer) => {
+      rawStdout += data.toString();
+    });
+
+    child.stderr.on('data', (data: Buffer) => {
+      stderr += data.toString();
+    });
+
+    child.on('close', (code) => {
+      void (async () => {
+        const exitCode = code ?? 1;
+
+        // Parse output to extract result text and session ID.
+        // For Claude: JSON output contains session_id directly.
+        // For Copilot: plain text output; session ID captured via --share file.
+        const { result, sessionId: parsedSessionId } = p.parseJsonOutput(rawStdout);
+        const sessionId = parsedSessionId ?? (await p.extractSessionId?.(options.cwd)) ?? null;
+
+        if (exitCode !== 0) {
+          reject(
+            new SpawnError(
+              `${p.displayName} CLI exited with code ${String(exitCode)}: ${stderr}`,
+              stderr,
+              exitCode,
+              sessionId,
+              p
+            )
+          );
+        } else {
+          resolve({ stdout: result, stderr, exitCode: 0, sessionId });
+        }
+      })().catch((err: unknown) => {
+        reject(new SpawnError(`Unexpected error in close handler: ${String(err)}`, '', 1, null, p));
+      });
+    });
+
+    child.on('error', (err) => {
+      reject(new SpawnError(`Failed to spawn ${p.binary} CLI: ${err.message}`, '', 1, null, p));
+    });
+  });
+}
+
+const DEFAULT_MAX_RETRIES = 5;
+const BASE_DELAY_MS = 2000;
+const MAX_DELAY_MS = 120_000;
+const DEFAULT_TOTAL_TIMEOUT_MS = 600_000; // 10 minutes across all retries
+
+function sleep(ms: number): Promise<void> {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function jitter(): number {
+  return Math.floor(Math.random() * 1000);
+}
+
+/**
+ * Spawn AI CLI with automatic retry on rate limit errors.
+ * Uses exponential backoff with jitter.
+ *
+ * On rate limit failures, automatically resumes the session using the
+ * captured session ID so the AI picks up where it left off.
+ */
+export async function spawnWithRetry(
+  options: HeadlessSpawnOptions,
+  retryOptions?: {
+    maxRetries?: number;
+    totalTimeoutMs?: number;
+    onRetry?: (attempt: number, delayMs: number, error: SpawnError) => void;
+  },
+  provider?: ProviderAdapter
+): Promise<SpawnResult> {
+  const p = provider ?? (await getActiveProvider());
+  const maxRetries = retryOptions?.maxRetries ?? DEFAULT_MAX_RETRIES;
+  const totalTimeoutMs = retryOptions?.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+  const startTime = Date.now();
+  let resumeSessionId = options.resumeSessionId;
+
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    // Check total elapsed time before each attempt
+    const elapsed = Date.now() - startTime;
+    if (attempt > 0 && elapsed >= totalTimeoutMs) {
+      throw new SpawnError(`Total retry timeout exceeded (${String(totalTimeoutMs)}ms)`, '', 1, resumeSessionId, p);
+    }
+
+    try {
+      return await spawnHeadlessRaw({ ...options, resumeSessionId }, p);
+    } catch (err) {
+      if (!(err instanceof SpawnError) || !err.rateLimited) {
+        throw err;
+      }
+
+      // Capture session ID for resume on next attempt
+      if (err.sessionId) {
+        resumeSessionId = err.sessionId;
+      }
+
+      if (attempt >= maxRetries) {
+        throw err;
+      }
+
+      const delay = Math.min(err.retryAfterMs ?? BASE_DELAY_MS * Math.pow(2, attempt), MAX_DELAY_MS) + jitter();
+      retryOptions?.onRetry?.(attempt + 1, delay, err);
+      await sleep(delay);
+    }
+  }
+
+  // Unreachable, but satisfies TypeScript
+  throw new Error('Max retries exceeded');
+}

package/src/ai/task-context.ts

@@ -0,0 +1,270 @@
+import { execSync } from 'node:child_process';
+import { writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { muted, warning } from '@src/theme/index.ts';
+import { checkTaskPermissions } from '@src/ai/permissions.ts';
+import { getProject, ProjectNotFoundError } from '@src/store/project.ts';
+import type { AiProvider, Project, Sprint, Task } from '@src/schemas/index.ts';
+import { assertSafeCwd } from '@src/utils/paths.ts';
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+export interface TaskContext {
+  sprint: Sprint;
+  task: Task;
+  project?: Project;
+}
+
+/** Outcome of a check script for a single project path. */
+export type CheckStatus = { ran: true; script: string } | { ran: false; reason: 'no-script' };
+
+/** Map from projectPath → CheckStatus, populated by runCheckScripts. */
+export type CheckResults = Map<string, CheckStatus>;
+
+// ============================================================================
+// UTILITY FUNCTIONS
+// ============================================================================
+
+/**
+ * Get recent git history for a project path.
+ */
+export function getRecentGitHistory(projectPath: string, count = 20): string {
+  try {
+    assertSafeCwd(projectPath);
+    const result = execSync(`git log -${String(count)} --oneline --no-decorate`, {
+      cwd: projectPath,
+      encoding: 'utf-8',
+      stdio: ['pipe', 'pipe', 'pipe'],
+    });
+    return result.trim();
+  } catch {
+    return '(Unable to retrieve git history)';
+  }
+}
+
+/**
+ * Get check script from explicit repository config only.
+ * Returns null if no check script is configured — no runtime auto-detection.
+ * Heuristic detection is used only as suggestions during `project add`.
+ */
+export function getEffectiveCheckScript(project: Project | undefined, projectPath: string): string | null {
+  if (project) {
+    const repo = project.repositories.find((r) => r.path === projectPath);
+    if (repo?.checkScript) {
+      return repo.checkScript;
+    }
+  }
+  return null;
+}
+
+export function formatTask(ctx: TaskContext): string {
+  const lines: string[] = [];
+
+  // ═══ TASK DIRECTIVE (highest attention) ═══
+  lines.push('## Task Directive');
+  lines.push('');
+  lines.push(`**Task:** ${ctx.task.name}`);
+  lines.push(`**ID:** ${ctx.task.id}`);
+  lines.push(`**Project:** ${ctx.task.projectPath}`);
+  lines.push('');
+  lines.push('**ONE TASK ONLY.** Complete THIS task and nothing else. Do not continue to other tasks.');
+
+  if (ctx.task.description) {
+    lines.push('');
+    lines.push(ctx.task.description);
+  }
+
+  // ═══ TASK STEPS (primary content — positioned first for maximum attention) ═══
+  if (ctx.task.steps.length > 0) {
+    lines.push('');
+    lines.push('## Implementation Steps');
+    lines.push('');
+    lines.push('Follow these steps precisely and in order:');
+    lines.push('');
+    ctx.task.steps.forEach((step, i) => {
+      lines.push(`${String(i + 1)}. ${step}`);
+    });
+  }
+
+  return lines.join('\n');
+}
+
+/**
+ * Build the full task context with primacy/recency optimization.
+ *
+ * Layout applies the primacy/recency effect:
+ * - HIGH ATTENTION (start): Task directive, steps, check script
+ * - REFERENCE (middle): Prior learnings, ticket requirements, git history
+ * - HIGH ATTENTION (end): Instructions (appended by writeTaskContextFile)
+ */
+export function buildFullTaskContext(
+  ctx: TaskContext,
+  progressSummary: string | null,
+  gitHistory: string,
+  checkScript: string | null,
+  checkStatus?: CheckStatus
+): string {
+  const lines: string[] = [];
+
+  // ═══ HIGH ATTENTION ZONE (beginning) ═══
+
+  lines.push(formatTask(ctx));
+
+  // Branch awareness — tell the agent which branch it's on
+  if (ctx.sprint.branch) {
+    lines.push('');
+    lines.push('## Branch');
+    lines.push('');
+    lines.push(
+      `You are working on branch \`${ctx.sprint.branch}\`. All commits go to this branch. Do not switch branches.`
+    );
+  }
+
+  // Check script — near the top so it's easy to find
+  lines.push('');
+  lines.push('## Check Script');
+  lines.push('');
+  if (checkScript) {
+    lines.push('The harness runs this command at sprint start and after every task as a post-task gate:');
+    lines.push('');
+    lines.push('```bash');
+    lines.push(checkScript);
+    lines.push('```');
+    lines.push('');
+    lines.push('Your task is NOT marked done unless this command passes after completion.');
+  } else {
+    lines.push('No check script is configured. Read CLAUDE.md in the project root to find verification commands.');
+  }
+
+  // Check status awareness — tell the agent what happened during stage zero
+  if (checkStatus) {
+    lines.push('');
+    lines.push('## Environment Status');
+    lines.push('');
+    if (checkStatus.ran) {
+      lines.push('The check script ran successfully at sprint start. Dependencies are current.');
+      lines.push('Do not re-run the install portion unless you encounter dependency errors.');
+    } else {
+      lines.push(
+        'No check script is configured for this repository. ' +
+          'Read CLAUDE.md or project configuration files (package.json, pyproject.toml, etc.) ' +
+          'to discover build, test, and lint commands.'
+      );
+    }
+  }
+
+  // ═══ REFERENCE ZONE (middle — lower attention is OK) ═══
+
+  lines.push('');
+  lines.push('---');
+  lines.push('');
+
+  // Prior task learnings (summarized, not raw progress dump)
+  if (progressSummary) {
+    lines.push('## Prior Task Learnings');
+    lines.push('');
+    lines.push('_Reference — consult when relevant to your implementation._');
+    lines.push('');
+    lines.push(progressSummary);
+    lines.push('');
+  }
+
+  // Ticket requirements (reference only, explicitly deprioritized)
+  if (ctx.task.ticketId) {
+    const ticket = ctx.sprint.tickets.find((t) => t.id === ctx.task.ticketId);
+    if (ticket?.requirements) {
+      lines.push('## Ticket Requirements');
+      lines.push('');
+      lines.push(
+        '_Reference — these describe the full ticket scope. This task implements a specific part. ' +
+          'Use to validate your work and understand constraints, but follow the Implementation Steps above. ' +
+          'Do not expand scope beyond declared steps._'
+      );
+      lines.push('');
+      lines.push(ticket.requirements);
+      lines.push('');
+    }
+  }
+
+  // Git history — awareness of recent changes
+  lines.push('## Git History (recent commits)');
+  lines.push('');
+  lines.push('```');
+  lines.push(gitHistory);
+  lines.push('```');
+
+  // ═══ HIGH ATTENTION ZONE (end) — Instructions appended by writeTaskContextFile ═══
+
+  return lines.join('\n');
+}
+
+export function getContextFileName(sprintId: string, taskId: string): string {
+  return `.ralphctl-sprint-${sprintId}-task-${taskId}-context.md`;
+}
+
+export async function writeTaskContextFile(
+  projectPath: string,
+  taskContent: string,
+  instructions: string,
+  sprintId: string,
+  taskId: string
+): Promise<string> {
+  const contextFile = join(projectPath, getContextFileName(sprintId, taskId));
+  const warning = `<!-- TEMPORARY FILE - DO NOT COMMIT -->
+<!-- This file is auto-generated by ralphctl for task execution context -->
+<!-- It will be automatically cleaned up after task completion -->
+
+`;
+  const fullContent = `${warning}${taskContent}\n\n---\n\n## Instructions\n\n${instructions}`;
+  await writeFile(contextFile, fullContent, { encoding: 'utf-8', mode: 0o600 });
+  return contextFile;
+}
+
+/**
+ * Try to get the project for a task (via ticket reference).
+ */
+export async function getProjectForTask(task: Task, sprint: Sprint): Promise<Project | undefined> {
+  if (!task.ticketId) return undefined;
+
+  const ticket = sprint.tickets.find((t) => t.id === task.ticketId);
+  if (!ticket) return undefined;
+
+  try {
+    return await getProject(ticket.projectName);
+  } catch (err) {
+    if (err instanceof ProjectNotFoundError) {
+      return undefined;
+    }
+    throw err;
+  }
+}
+
+// ============================================================================
+// PERMISSION CHECKS
+// ============================================================================
+
+/**
+ * Run permission checks and display any warnings.
+ *
+ * For Claude: warns about operations that may need approval in settings files.
+ * For Copilot: no-op — all tools are granted via --allow-all-tools.
+ */
+export function runPermissionCheck(ctx: TaskContext, noCommit: boolean, provider?: AiProvider): void {
+  const checkScript = getEffectiveCheckScript(ctx.project, ctx.task.projectPath);
+
+  const warnings = checkTaskPermissions(ctx.task.projectPath, {
+    checkScript,
+    needsCommit: !noCommit,
+    provider,
+  });
+
+  if (warnings.length > 0) {
+    console.log(warning('\n  Permission warnings:'));
+    for (const w of warnings) {
+      console.log(muted(`    - ${w.message}`));
+    }
+    console.log(muted('  Consider adjusting tool permissions for your AI provider\n'));
+  }
+}

package/src/cli-metadata.ts

@@ -0,0 +1,7 @@
+import pkg from '../package.json' with { type: 'json' };
+
+export const cliMetadata = {
+  name: 'ralphctl',
+  version: pkg.version,
+  description: "I'm helping! Plan sprints and execute tasks with AI",
+} as const;

package/src/cli.ts

@@ -0,0 +1,65 @@
+import { Command } from 'commander';
+import { showBanner } from '@src/theme/ui.ts';
+import { interactiveMode } from '@src/interactive/index.ts';
+import { registerProjectCommands } from '@src/commands/project/index.ts';
+import { registerSprintCommands } from '@src/commands/sprint/index.ts';
+import { registerTaskCommands } from '@src/commands/task/index.ts';
+import { registerTicketCommands } from '@src/commands/ticket/index.ts';
+import { registerProgressCommands } from '@src/commands/progress/index.ts';
+import { registerDashboardCommands } from '@src/commands/dashboard/index.ts';
+import { registerConfigCommands } from '@src/commands/config/index.ts';
+import { registerCompletionCommands } from '@src/commands/completion/index.ts';
+import { registerDoctorCommands } from '@src/commands/doctor/index.ts';
+import { error } from '@src/theme/index.ts';
+import { cliMetadata } from '@src/cli-metadata.ts';
+
+const program = new Command();
+program
+  .name(cliMetadata.name)
+  .description(cliMetadata.description)
+  .version(cliMetadata.version)
+  .addHelpText(
+    'after',
+    `
+Examples:
+  $ ralphctl                              # Interactive mode
+  $ ralphctl status                       # Show current sprint status
+  $ ralphctl sprint create --name "v1.0"  # Create sprint
+  $ ralphctl ticket add --project api     # Add ticket
+  $ ralphctl task list -b                 # Brief task list
+
+Run any command with --help for details.
+`
+  );
+
+registerProjectCommands(program);
+registerSprintCommands(program);
+registerTaskCommands(program);
+registerTicketCommands(program);
+registerProgressCommands(program);
+registerDashboardCommands(program);
+registerConfigCommands(program);
+registerCompletionCommands(program);
+registerDoctorCommands(program);
+
+async function main(): Promise<void> {
+  // Shell completion: intercept before any output (banner, interactive mode)
+  if (process.env['COMP_CWORD'] && process.env['COMP_POINT'] && process.env['COMP_LINE']) {
+    const { handleCompletionRequest } = await import('@src/completion/handle.ts');
+    if (await handleCompletionRequest(program)) return;
+  }
+
+  // No args or 'interactive' → interactive mode
+  if (process.argv.length <= 2 || process.argv[2] === 'interactive') {
+    // Interactive mode shows its own banner
+    await interactiveMode();
+  } else {
+    showBanner();
+    await program.parseAsync(process.argv);
+  }
+}
+
+main().catch((err: unknown) => {
+  console.error(error('Fatal error:'), err);
+  process.exit(1);
+});

package/src/commands/completion/index.ts

@@ -0,0 +1,33 @@
+import type { Command } from 'commander';
+import { showSuccess } from '@src/theme/ui.ts';
+
+export function registerCompletionCommands(program: Command): void {
+  const completion = program.command('completion').description('Manage shell tab-completion');
+
+  completion.addHelpText(
+    'after',
+    `
+Examples:
+  $ ralphctl completion install       # Enable tab-completion for your shell
+  $ ralphctl completion uninstall     # Remove tab-completion
+`
+  );
+
+  completion
+    .command('install')
+    .description('Install shell tab-completion (bash, zsh, fish)')
+    .action(async () => {
+      const tabtab = (await import('tabtab')).default;
+      await tabtab.install({ name: 'ralphctl', completer: 'ralphctl' });
+      showSuccess('Shell completion installed. Restart your shell or source your profile to activate.');
+    });
+
+  completion
+    .command('uninstall')
+    .description('Remove shell tab-completion')
+    .action(async () => {
+      const tabtab = (await import('tabtab')).default;
+      await tabtab.uninstall({ name: 'ralphctl' });
+      showSuccess('Shell completion removed.');
+    });
+}