test(cli): Add missing command tests for export, dir, and version

Add dedicated test files for CLI commands that were missing coverage:
- export.test.ts: 12 tests for GitHub export functionality
- dir.test.ts: 3 tests for storage/home directory output
- version.test.ts: 1 test verifying version matches package.json

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: dcramer

src/cli/dir.test.ts

@@ -0,0 +1,56 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { captureOutput, type CapturedOutput } from "./test-helpers.js";
+import { dirCommand } from "./dir.js";
+
+describe("dir command", () => {
+  let output: CapturedOutput;
+  let originalDexHome: string | undefined;
+  let originalStoragePath: string | undefined;
+
+  beforeEach(() => {
+    output = captureOutput();
+    originalDexHome = process.env.DEX_HOME;
+    originalStoragePath = process.env.DEX_STORAGE_PATH;
+  });
+
+  afterEach(() => {
+    output.restore();
+    if (originalDexHome !== undefined) {
+      process.env.DEX_HOME = originalDexHome;
+    } else {
+      delete process.env.DEX_HOME;
+    }
+    if (originalStoragePath !== undefined) {
+      process.env.DEX_STORAGE_PATH = originalStoragePath;
+    } else {
+      delete process.env.DEX_STORAGE_PATH;
+    }
+  });
+
+  it("prints storage path by default", () => {
+    process.env.DEX_STORAGE_PATH = "/tmp/test-storage";
+
+    dirCommand([]);
+
+    const out = output.stdout.join("\n");
+    expect(out).toBe("/tmp/test-storage");
+  });
+
+  it("prints dex home directory with --global flag", () => {
+    process.env.DEX_HOME = "/tmp/test-dex-home";
+
+    dirCommand(["--global"]);
+
+    const out = output.stdout.join("\n");
+    expect(out).toBe("/tmp/test-dex-home");
+  });
+
+  it("prints dex home directory with -g short flag", () => {
+    process.env.DEX_HOME = "/tmp/test-dex-home-short";
+
+    dirCommand(["-g"]);
+
+    const out = output.stdout.join("\n");
+    expect(out).toBe("/tmp/test-dex-home-short");
+  });
+});

src/cli/export.test.ts

@@ -0,0 +1,266 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
+import { runCli } from "./index.js";
+import type { CliTestFixture, GitHubMock } from "./test-helpers.js";
+import {
+  createCliTestFixture,
+  createTaskAndGetId,
+  setupGitHubMock,
+  cleanupGitHubMock,
+  createIssueFixture,
+} from "./test-helpers.js";
+
+// Mock git remote detection
+vi.mock("../core/github/remote.js", async (importOriginal) => {
+  const original =
+    await importOriginal<typeof import("../core/github/remote.js")>();
+  return {
+    ...original,
+    getGitHubRepo: vi.fn(() => ({ owner: "test-owner", repo: "test-repo" })),
+  };
+});
+
+// Mock execSync for git operations
+vi.mock("node:child_process", async (importOriginal) => {
+  const original = await importOriginal<typeof import("node:child_process")>();
+  return {
+    ...original,
+    execSync: vi.fn((cmd: string) => {
+      if (cmd.includes("gh auth token")) {
+        throw new Error("gh not authenticated");
+      }
+      if (cmd.includes("git check-ignore")) {
+        throw new Error("not ignored");
+      }
+      if (cmd.includes("git show origin/HEAD")) {
+        throw new Error("not on remote");
+      }
+      return "";
+    }),
+  };
+});
+
+describe("export command", () => {
+  let fixture: CliTestFixture;
+  let githubMock: GitHubMock;
+  let originalEnv: string | undefined;
+
+  beforeEach(() => {
+    fixture = createCliTestFixture();
+    originalEnv = process.env.GITHUB_TOKEN;
+    process.env.GITHUB_TOKEN = "test-token";
+    githubMock = setupGitHubMock();
+  });
+
+  afterEach(() => {
+    fixture.cleanup();
+    cleanupGitHubMock();
+    if (originalEnv !== undefined) {
+      process.env.GITHUB_TOKEN = originalEnv;
+    } else {
+      delete process.env.GITHUB_TOKEN;
+    }
+  });
+
+  async function createTask(
+    name: string,
+    opts: { description?: string; parent?: string } = {},
+  ): Promise<string> {
+    return createTaskAndGetId(fixture, name, {
+      description: opts.description ?? "ctx",
+      parent: opts.parent,
+    });
+  }
+
+  it.each([["--help"], ["-h"]])("shows help with %s flag", async (flag) => {
+    await runCli(["export", flag], { storage: fixture.storage });
+    const out = fixture.output.stdout.join("\n");
+    expect(out).toContain("dex export");
+    expect(out).toContain("Export tasks to GitHub Issues");
+  });
+
+  it("fails when no task IDs provided", async () => {
+    await expect(
+      runCli(["export"], { storage: fixture.storage }),
+    ).rejects.toThrow("process.exit");
+    expect(fixture.output.stderr.join("\n")).toContain(
+      "At least one task ID is required",
+    );
+  });
+
+  it("fails when task not found", async () => {
+    githubMock.listIssues("test-owner", "test-repo", []);
+
+    await runCli(["export", "nonexist"], { storage: fixture.storage });
+
+    expect(fixture.output.stderr.join("\n")).toContain("not found");
+  });
+
+  describe("dry-run mode", () => {
+    it("previews export without creating issues", async () => {
+      const taskId = await createTask("Test task", { description: "context" });
+
+      await runCli(["export", taskId, "--dry-run"], {
+        storage: fixture.storage,
+      });
+
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("Would export");
+      expect(out).toContain("test-owner/test-repo");
+      expect(out).toContain("[create]");
+      expect(out).toContain(taskId);
+    });
+  });
+
+  describe("export specific task", () => {
+    it("exports a task to GitHub", async () => {
+      const taskId = await createTask("Task to export", {
+        description: "Some context",
+      });
+
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({
+          number: 101,
+          title: "Task to export",
+        }),
+      );
+
+      await runCli(["export", taskId], { storage: fixture.storage });
+
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("Exported");
+      expect(out).toContain(taskId);
+      expect(out).toContain("test-owner/test-repo");
+      expect(out).toContain("issues/101");
+    });
+
+    it("skips task already synced to GitHub", async () => {
+      const taskId = await createTask("Synced task", {
+        description: "context",
+      });
+
+      // First sync to create GitHub metadata
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({
+          number: 42,
+          title: "Synced task",
+        }),
+      );
+      await runCli(["sync", taskId], { storage: fixture.storage });
+      fixture.output.stdout.length = 0;
+
+      // Export should skip because task already has GitHub metadata
+      await runCli(["export", taskId], { storage: fixture.storage });
+
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("Skipped");
+      expect(out).toContain("already synced");
+    });
+
+    it("finds root task when exporting subtask", async () => {
+      const parentId = await createTask("Parent task");
+      const subtaskId = await createTask("Subtask", { parent: parentId });
+
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({
+          number: 102,
+          title: "Parent task",
+        }),
+      );
+
+      await runCli(["export", subtaskId], { storage: fixture.storage });
+
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("Exported");
+      expect(out).toContain(parentId);
+    });
+  });
+
+  describe("export multiple tasks", () => {
+    it("exports multiple tasks with summary", async () => {
+      const taskId1 = await createTask("Task 1", { description: "ctx1" });
+      const taskId2 = await createTask("Task 2", { description: "ctx2" });
+
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({ number: 201, title: "Task 1" }),
+      );
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({ number: 202, title: "Task 2" }),
+      );
+
+      await runCli(["export", taskId1, taskId2], { storage: fixture.storage });
+
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("Exported");
+      expect(out).toContain("2 exported");
+    });
+
+    it("shows combined summary with skipped tasks", async () => {
+      const taskId1 = await createTask("Task 1", { description: "ctx1" });
+      const taskId2 = await createTask("Task 2", { description: "ctx2" });
+
+      // Sync first task so it gets skipped
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({ number: 301, title: "Task 1" }),
+      );
+      await runCli(["sync", taskId1], { storage: fixture.storage });
+      fixture.output.stdout.length = 0;
+
+      // Export both - first should be skipped, second exported
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue(
+        "test-owner",
+        "test-repo",
+        createIssueFixture({ number: 302, title: "Task 2" }),
+      );
+
+      await runCli(["export", taskId1, taskId2], { storage: fixture.storage });
+
+      const out = fixture.output.stdout.join("\n");
+      expect(out).toContain("1 exported");
+      expect(out).toContain("1 skipped");
+    });
+  });
+
+  describe("error handling", () => {
+    it("fails when GitHub token is missing", async () => {
+      delete process.env.GITHUB_TOKEN;
+      const taskId = await createTask("Task");
+
+      await expect(
+        runCli(["export", taskId], { storage: fixture.storage }),
+      ).rejects.toThrow("process.exit");
+      expect(fixture.output.stderr.join("\n")).toMatch(
+        /GitHub token|GITHUB_TOKEN/i,
+      );
+    });
+
+    it("handles GitHub API error gracefully", async () => {
+      const taskId = await createTask("Task");
+
+      githubMock.listIssues("test-owner", "test-repo", []);
+      githubMock.createIssue500("test-owner", "test-repo");
+
+      await runCli(["export", taskId], { storage: fixture.storage });
+
+      expect(fixture.output.stderr.join("\n")).toContain("Error");
+    });
+  });
+});

src/cli/version.test.ts

@@ -0,0 +1,26 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { captureOutput, type CapturedOutput } from "./test-helpers.js";
+import { versionCommand } from "./version.js";
+import { createRequire } from "node:module";
+
+const require = createRequire(import.meta.url);
+const pkg = require("../../package.json") as { version: string };
+
+describe("version command", () => {
+  let output: CapturedOutput;
+
+  beforeEach(() => {
+    output = captureOutput();
+  });
+
+  afterEach(() => {
+    output.restore();
+  });
+
+  it("outputs version matching package.json", () => {
+    versionCommand();
+
+    const out = output.stdout.join("\n");
+    expect(out).toBe(`dex v${pkg.version}`);
+  });
+});