@butlerw/vellum 0.1.0

package/src/commands/__tests__/completion.test.ts

@@ -0,0 +1,238 @@
+/**
+ * Shell Completion Generator Tests (T-047)
+ *
+ * @module cli/commands/__tests__/completion.test
+ */
+
+import { describe, expect, it } from "vitest";
+
+import {
+  BashCompletionGenerator,
+  FishCompletionGenerator,
+  generateCompletionFromCommands,
+  getAvailableShells,
+  getGenerator,
+  isValidShell,
+  PowerShellCompletionGenerator,
+  type ShellType,
+  ZshCompletionGenerator,
+} from "../completion/index.js";
+import type { SlashCommand } from "../types.js";
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+const mockCommands: SlashCommand[] = [
+  {
+    name: "help",
+    description: "Display help information",
+    kind: "builtin",
+    category: "system",
+    namedArgs: [
+      { name: "verbose", type: "boolean", description: "Show verbose output", required: false },
+    ],
+    execute: async () => ({ kind: "success" }),
+  },
+  {
+    name: "login",
+    description: "Login to a provider",
+    kind: "builtin",
+    category: "auth",
+    namedArgs: [
+      { name: "provider", type: "string", description: "Provider name", required: true },
+      { name: "store", type: "string", description: "Credential store", required: false },
+    ],
+    execute: async () => ({ kind: "success" }),
+  },
+  {
+    name: "clear",
+    description: "Clear the screen",
+    kind: "builtin",
+    category: "system",
+    execute: async () => ({ kind: "success" }),
+  },
+];
+
+// =============================================================================
+// Shell Type Utilities Tests
+// =============================================================================
+
+describe("Shell Type Utilities", () => {
+  describe("getAvailableShells", () => {
+    it("should return all supported shells", () => {
+      const shells = getAvailableShells();
+      expect(shells).toContain("bash");
+      expect(shells).toContain("zsh");
+      expect(shells).toContain("fish");
+      expect(shells).toContain("powershell");
+    });
+  });
+
+  describe("isValidShell", () => {
+    it("should return true for valid shells", () => {
+      expect(isValidShell("bash")).toBe(true);
+      expect(isValidShell("zsh")).toBe(true);
+      expect(isValidShell("fish")).toBe(true);
+      expect(isValidShell("powershell")).toBe(true);
+    });
+
+    it("should return false for invalid shells", () => {
+      expect(isValidShell("cmd")).toBe(false);
+      expect(isValidShell("sh")).toBe(false);
+      expect(isValidShell("")).toBe(false);
+    });
+  });
+
+  describe("getGenerator", () => {
+    it("should return correct generator for each shell", () => {
+      expect(getGenerator("bash")).toBeInstanceOf(BashCompletionGenerator);
+      expect(getGenerator("zsh")).toBeInstanceOf(ZshCompletionGenerator);
+      expect(getGenerator("fish")).toBeInstanceOf(FishCompletionGenerator);
+      expect(getGenerator("powershell")).toBeInstanceOf(PowerShellCompletionGenerator);
+    });
+
+    it("should throw for unsupported shell", () => {
+      expect(() => getGenerator("invalid" as ShellType)).toThrow("Unsupported shell");
+    });
+  });
+});
+
+// =============================================================================
+// Bash Completion Generator Tests
+// =============================================================================
+
+describe("BashCompletionGenerator", () => {
+  const generator = new BashCompletionGenerator();
+
+  it("should have correct shell type", () => {
+    expect(generator.shell).toBe("bash");
+  });
+
+  it("should generate bash completion script", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("# Bash completion for vellum");
+    expect(script).toContain("_vellum_completions");
+    expect(script).toContain('commands="help login clear"');
+    expect(script).toContain("complete -F _vellum_completions vellum");
+  });
+
+  it("should include command flags", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("--verbose");
+    expect(script).toContain("--provider");
+    expect(script).toContain("--store");
+  });
+});
+
+// =============================================================================
+// Zsh Completion Generator Tests
+// =============================================================================
+
+describe("ZshCompletionGenerator", () => {
+  const generator = new ZshCompletionGenerator();
+
+  it("should have correct shell type", () => {
+    expect(generator.shell).toBe("zsh");
+  });
+
+  it("should generate zsh completion script", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("#compdef vellum");
+    expect(script).toContain("_vellum()");
+    expect(script).toContain("/help:Display help information");
+    expect(script).toContain("/login:Login to a provider");
+  });
+
+  it("should include flag descriptions", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("--verbose");
+    expect(script).toContain("--provider");
+  });
+});
+
+// =============================================================================
+// Fish Completion Generator Tests
+// =============================================================================
+
+describe("FishCompletionGenerator", () => {
+  const generator = new FishCompletionGenerator();
+
+  it("should have correct shell type", () => {
+    expect(generator.shell).toBe("fish");
+  });
+
+  it("should generate fish completion script", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("# Fish completion for vellum");
+    expect(script).toContain("complete -c vellum -f");
+    expect(script).toContain('/help" -d');
+    expect(script).toContain("Display help information");
+  });
+
+  it("should include flag completions", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("-l verbose");
+    expect(script).toContain("-l provider");
+  });
+});
+
+// =============================================================================
+// PowerShell Completion Generator Tests
+// =============================================================================
+
+describe("PowerShellCompletionGenerator", () => {
+  const generator = new PowerShellCompletionGenerator();
+
+  it("should have correct shell type", () => {
+    expect(generator.shell).toBe("powershell");
+  });
+
+  it("should generate powershell completion script", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("# PowerShell completion for vellum");
+    expect(script).toContain("$vellumCommands");
+    expect(script).toContain("Register-ArgumentCompleter");
+    expect(script).toContain("/help");
+  });
+
+  it("should include flags array", () => {
+    const script = generator.generate(mockCommands, "vellum");
+
+    expect(script).toContain("'--verbose'");
+    expect(script).toContain("'--provider'");
+    expect(script).toContain("'--store'");
+  });
+});
+
+// =============================================================================
+// generateCompletionFromCommands Tests
+// =============================================================================
+
+describe("generateCompletionFromCommands", () => {
+  it("should generate completion for specified shell", () => {
+    const script = generateCompletionFromCommands(
+      { shell: "bash", programName: "test-cli" },
+      mockCommands
+    );
+
+    expect(script).toContain("# Bash completion for test-cli");
+    expect(script).toContain("help login clear");
+  });
+
+  it("should use program name in output", () => {
+    const shells: ShellType[] = ["bash", "zsh", "fish", "powershell"];
+
+    for (const shell of shells) {
+      const script = generateCompletionFromCommands({ shell, programName: "myapp" }, mockCommands);
+      expect(script).toContain("myapp");
+    }
+  });
+});

package/src/commands/__tests__/core.test.ts

@@ -0,0 +1,363 @@
+/**
+ * Core Commands Integration Tests
+ *
+ * Tests for help, clear, and exit commands including:
+ * - Help command output formatting
+ * - Clear command clearScreen flag
+ * - Exit command immediate exit behavior
+ *
+ * @module cli/commands/__tests__/core
+ */
+
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { clearCommand, exitCommand, helpCommand, setHelpRegistry } from "../core/index.js";
+import { CommandRegistry } from "../registry.js";
+import type { CommandContext, CommandSuccess, ParsedArgs, SlashCommand } from "../types.js";
+
+// =============================================================================
+// Test Fixtures
+// =============================================================================
+
+/**
+ * Create a mock CommandContext for testing
+ */
+function createMockContext(overrides: Partial<ParsedArgs> = {}): CommandContext {
+  return {
+    session: {
+      id: "test-session",
+      provider: "anthropic",
+      cwd: "/test",
+    },
+    credentials: {
+      resolve: vi.fn(),
+      store: vi.fn(),
+      delete: vi.fn(),
+      list: vi.fn(),
+    } as unknown as CommandContext["credentials"],
+    toolRegistry: {
+      get: vi.fn(),
+      list: vi.fn(),
+    } as unknown as CommandContext["toolRegistry"],
+    parsedArgs: {
+      command: overrides.command ?? "test",
+      positional: overrides.positional ?? [],
+      named: overrides.named ?? {},
+      raw: overrides.raw ?? "/test",
+    },
+    emit: vi.fn(),
+  };
+}
+
+/**
+ * Create a mock SlashCommand for testing
+ */
+function createMockCommand(overrides: Partial<SlashCommand> & { name: string }): SlashCommand {
+  return {
+    description: `Mock command: ${overrides.name}`,
+    kind: "builtin",
+    category: "system",
+    execute: async () => ({ kind: "success" as const }),
+    ...overrides,
+  };
+}
+
+// =============================================================================
+// T031: Help Command Tests
+// =============================================================================
+
+describe("helpCommand", () => {
+  let registry: CommandRegistry;
+
+  beforeEach(() => {
+    registry = new CommandRegistry();
+    setHelpRegistry(registry);
+  });
+
+  describe("/help (no arguments)", () => {
+    it("should return list of all commands grouped by category", async () => {
+      // Register some test commands
+      registry.register(
+        createMockCommand({
+          name: "test1",
+          category: "system",
+          description: "Test system command",
+        })
+      );
+      registry.register(
+        createMockCommand({
+          name: "login",
+          category: "auth",
+          description: "Login to a provider",
+        })
+      );
+
+      const ctx = createMockContext({
+        command: "help",
+        positional: [],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("success");
+      const successResult = result as CommandSuccess;
+      expect(successResult.message).toContain("Available Commands");
+      expect(successResult.message).toContain("System:");
+      expect(successResult.message).toContain("/test1");
+      expect(successResult.message).toContain("Authentication:");
+      expect(successResult.message).toContain("/login");
+      expect(successResult.data).toEqual({
+        type: "help-list",
+        categories: expect.any(Array),
+      });
+    });
+
+    it("should show command aliases", async () => {
+      registry.register(
+        createMockCommand({
+          name: "help",
+          aliases: ["h", "?"],
+          description: "Show help",
+        })
+      );
+
+      const ctx = createMockContext({
+        command: "help",
+        positional: [],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("success");
+      const successResult = result as CommandSuccess;
+      expect(successResult.message).toContain("(h, ?)");
+    });
+  });
+
+  describe("/help <command>", () => {
+    it("should return detailed help for a specific command", async () => {
+      registry.register(
+        createMockCommand({
+          name: "login",
+          description: "Login to a provider",
+          category: "auth",
+          aliases: ["signin"],
+          positionalArgs: [
+            {
+              name: "provider",
+              type: "string",
+              description: "Provider name",
+              required: true,
+            },
+          ],
+          namedArgs: [
+            {
+              name: "store",
+              shorthand: "s",
+              type: "string",
+              description: "Credential store",
+              required: false,
+              default: "keychain",
+            },
+          ],
+          examples: ["/login anthropic", "/login openai --store file"],
+        })
+      );
+
+      const ctx = createMockContext({
+        command: "help",
+        positional: ["login"],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("success");
+      const successResult = result as CommandSuccess;
+      expect(successResult.message).toContain("/login");
+      expect(successResult.message).toContain("Login to a provider");
+      expect(successResult.message).toContain("Aliases: /signin");
+      expect(successResult.message).toContain("Category: Authentication");
+      expect(successResult.message).toContain("Usage:");
+      expect(successResult.message).toContain("<provider>");
+      expect(successResult.message).toContain("Arguments:");
+      expect(successResult.message).toContain("Options:");
+      expect(successResult.message).toContain("--store");
+      expect(successResult.message).toContain("-s");
+      expect(successResult.message).toContain("Examples:");
+      expect(successResult.data).toEqual({
+        type: "help-command",
+        command: "login",
+      });
+    });
+
+    it("should resolve command by alias", async () => {
+      registry.register(
+        createMockCommand({
+          name: "help",
+          aliases: ["h"],
+          description: "Show help",
+        })
+      );
+
+      const ctx = createMockContext({
+        command: "help",
+        positional: ["h"],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("success");
+      const successResult = result as CommandSuccess;
+      expect(successResult.message).toContain("/help");
+      expect(successResult.data).toEqual({
+        type: "help-command",
+        command: "help",
+      });
+    });
+  });
+
+  describe("/help <category>", () => {
+    it("should return commands in the specified category", async () => {
+      registry.register(
+        createMockCommand({
+          name: "login",
+          category: "auth",
+          description: "Login",
+        })
+      );
+      registry.register(
+        createMockCommand({
+          name: "logout",
+          category: "auth",
+          description: "Logout",
+        })
+      );
+
+      const ctx = createMockContext({
+        command: "help",
+        positional: ["auth"],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("success");
+      const successResult = result as CommandSuccess;
+      expect(successResult.message).toContain("Authentication Commands");
+      expect(successResult.message).toContain("/login");
+      expect(successResult.message).toContain("/logout");
+      expect(successResult.data).toEqual({
+        type: "help-category",
+        category: "auth",
+      });
+    });
+  });
+
+  describe("error handling", () => {
+    it("should return error for unknown command", async () => {
+      const ctx = createMockContext({
+        command: "help",
+        positional: ["nonexistent"],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("error");
+      expect(result).toMatchObject({
+        kind: "error",
+        code: "COMMAND_NOT_FOUND",
+        message: expect.stringContaining("nonexistent"),
+      });
+    });
+
+    it("should suggest similar commands when not found", async () => {
+      registry.register(
+        createMockCommand({
+          name: "login",
+          description: "Login",
+        })
+      );
+      registry.register(
+        createMockCommand({
+          name: "logout",
+          description: "Logout",
+        })
+      );
+
+      const ctx = createMockContext({
+        command: "help",
+        positional: ["log"],
+      });
+
+      const result = await helpCommand.execute(ctx);
+
+      expect(result.kind).toBe("error");
+      expect(result).toMatchObject({
+        kind: "error",
+        code: "COMMAND_NOT_FOUND",
+        suggestions: expect.arrayContaining(["/login", "/logout"]),
+      });
+    });
+  });
+});
+
+// =============================================================================
+// T031: Clear Command Tests
+// =============================================================================
+
+describe("clearCommand", () => {
+  it("should return success with clearScreen: true", async () => {
+    const ctx = createMockContext({
+      command: "clear",
+      positional: [],
+    });
+
+    const result = await clearCommand.execute(ctx);
+
+    expect(result.kind).toBe("success");
+    expect(result).toMatchObject({
+      kind: "success",
+      clearScreen: true,
+    });
+  });
+
+  it("should have correct metadata", () => {
+    expect(clearCommand.name).toBe("clear");
+    expect(clearCommand.kind).toBe("builtin");
+    expect(clearCommand.category).toBe("system");
+    expect(clearCommand.aliases).toContain("cls");
+  });
+});
+
+// =============================================================================
+// T031: Exit Command Tests
+// =============================================================================
+
+describe("exitCommand", () => {
+  it("should emit app:exit event and return success immediately", async () => {
+    const ctx = createMockContext({
+      command: "exit",
+      positional: [],
+      named: {},
+    });
+
+    const result = await exitCommand.execute(ctx);
+
+    expect(result.kind).toBe("success");
+    expect(ctx.emit).toHaveBeenCalledWith("app:exit", {
+      reason: "user-command",
+    });
+    expect(result).toMatchObject({
+      kind: "success",
+      data: { exit: true },
+    });
+  });
+
+  it("should have correct metadata", () => {
+    expect(exitCommand.name).toBe("exit(quit)");
+    expect(exitCommand.kind).toBe("builtin");
+    expect(exitCommand.category).toBe("system");
+    expect(exitCommand.aliases).toContain("exit");
+    expect(exitCommand.aliases).toContain("quit");
+    expect(exitCommand.aliases).toContain("q");
+  });
+});