gitforest 0.1.0 → 1.1.0

package/test/unit/cli/formatters.test.ts

@@ -1,1116 +0,0 @@
-/**
- * Tests for CLI formatters
- */
-
-import { describe, test, expect } from "bun:test";
-import {
-  getProjectTypeIcon,
-  formatProjectStatus,
-  formatProject,
-  formatBatchResult,
-  formatProgress,
-  formatWarning,
-  formatError,
-  formatInfo,
-  formatSuccess,
-  formatScanning,
-  formatOperationItem,
-  formatOperationSummary,
-  calculateStatusSummary,
-  calculateProjectStats,
-  formatProjectStats,
-  formatProjectList,
-  formatStatusSummary,
-  formatStatusSummaryJson,
-  formatDirtyRepos,
-  getSourceIcon,
-  formatUnifiedRepoStatus,
-  formatUnifiedRepo,
-  formatUnifiedStats,
-  formatAuthSuccess,
-  formatAuthFailure,
-  formatNoToken,
-  formatCloneItem,
-} from "../../../src/cli/formatters.ts";
-import {
-  createMockProject,
-  createDirtyProject,
-  createAheadProject,
-  createNonGitProject,
-  createSubmoduleProject,
-  defaultMockStatus,
-  createDirtyStatus,
-  createBehindStatus,
-  createNoRemoteStatus,
-} from "../mocks/index.ts";
-
-describe("CLI formatters", () => {
-  describe("getProjectTypeIcon", () => {
-    test("returns green dot for git", () => {
-      const icon = getProjectTypeIcon("git");
-      expect(icon).toContain("●");
-    });
-
-    test("returns magenta circle for submodule", () => {
-      const icon = getProjectTypeIcon("git-submodule");
-      expect(icon).toContain("○");
-    });
-
-    test("returns gray dash for non-git", () => {
-      const icon = getProjectTypeIcon("non-git");
-      expect(icon).toContain("-");
-    });
-  });
-
-  describe("formatProjectStatus", () => {
-    test("returns 'clean' for clean project", () => {
-      const project = createMockProject();
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("clean");
-    });
-
-    test("includes modified count for dirty project", () => {
-      const project = createDirtyProject();
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("M");
-    });
-
-    test("includes unpushed indicator for ahead project", () => {
-      const project = createAheadProject("test", 3);
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("↑");
-      expect(status).toContain("3");
-    });
-
-    test("includes unpulled indicator for behind project", () => {
-      const project = createMockProject({
-        status: createBehindStatus(2),
-      });
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("↓");
-      expect(status).toContain("2");
-    });
-
-    test("includes no-remote for project without remote", () => {
-      const project = createMockProject({
-        status: createNoRemoteStatus(),
-      });
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("no-remote");
-    });
-
-    test("handles non-git project", () => {
-      const project = createNonGitProject("npm-project");
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("clean");
-    });
-
-    test("includes untracked files count", () => {
-      const project = createMockProject({
-        status: {
-          ...defaultMockStatus,
-          untrackedCount: 5,
-          hasUntrackedFiles: true,
-        },
-      });
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("5?");
-    });
-
-    test("combines multiple status indicators", () => {
-      const project = createMockProject({
-        status: {
-          ...createDirtyStatus(),
-          unpushedCommits: 2,
-          isAhead: true,
-          unpulledCommits: 1,
-          isBehind: true,
-          untrackedCount: 3,
-          hasUntrackedFiles: true,
-        },
-      });
-      const status = formatProjectStatus(project);
-
-      expect(status).toContain("2M");
-      expect(status).toContain("3?");
-      expect(status).toContain("↑2");
-      expect(status).toContain("↓1");
-    });
-  });
-
-  describe("formatProject", () => {
-    test("includes project name", () => {
-      const project = createMockProject({ name: "my-project" });
-      const output = formatProject(project);
-
-      expect(output).toContain("my-project");
-    });
-
-    test("includes type icon", () => {
-      const project = createMockProject();
-      const output = formatProject(project);
-
-      expect(output).toContain("●");
-    });
-
-    test("includes path in verbose mode", () => {
-      const project = createMockProject({
-        name: "test",
-        path: "/home/user/test",
-      });
-      const output = formatProject(project, true);
-
-      expect(output).toContain("/home/user/test");
-    });
-
-    test("includes branch in verbose mode", () => {
-      const project = createMockProject({
-        name: "test",
-        status: {
-          ...defaultMockStatus,
-          currentBranch: "feature-branch",
-        },
-      });
-      const output = formatProject(project, true);
-
-      expect(output).toContain("feature-branch");
-    });
-
-    test("handles missing branch in verbose mode", () => {
-      const project = createNonGitProject("test");
-      const output = formatProject(project, true);
-
-      expect(output).toContain("N/A");
-    });
-  });
-
-  describe("formatBatchResult", () => {
-    test("formats successful batch", () => {
-      const result = {
-        total: 5,
-        successful: 5,
-        failed: 0,
-        results: [],
-        duration: 1000,
-      };
-
-      const output = formatBatchResult(result, "Pull");
-
-      expect(output).toContain("Pull");
-      expect(output).toContain("5/5");
-      expect(output).toContain("1000ms");
-    });
-
-    test("formats batch with failures", () => {
-      const result = {
-        total: 5,
-        successful: 3,
-        failed: 2,
-        results: [],
-        duration: 2000,
-      };
-
-      const output = formatBatchResult(result, "Push");
-
-      expect(output).toContain("Push");
-      expect(output).toContain("3/5");
-      expect(output).toContain("2 failed");
-      expect(output).toContain("2000ms");
-    });
-
-    test("formats all failed batch", () => {
-      const result = {
-        total: 3,
-        successful: 0,
-        failed: 3,
-        results: [],
-        duration: 500,
-      };
-
-      const output = formatBatchResult(result, "Fetch");
-
-      expect(output).toContain("Fetch");
-      expect(output).toContain("0/3");
-      expect(output).toContain("3 failed");
-      expect(output).toContain("500ms");
-    });
-
-    test("includes error details for failed operations", () => {
-      const result = {
-        total: 2,
-        successful: 1,
-        failed: 1,
-        results: [
-          { projectPath: "/project1", success: true, operation: "pull", message: "Success", duration: 100 },
-          { projectPath: "/project2", success: false, operation: "pull", error: "Permission denied", duration: 50 },
-        ],
-        duration: 150,
-      };
-
-      const output = formatBatchResult(result, "Pull");
-
-      expect(output).toContain("Permission denied");
-      expect(output).toContain("/project2");
-    });
-  });
-
-  describe("formatProgress", () => {
-    test("formats progress with completed and total", () => {
-      const output = formatProgress(50, 100);
-
-      expect(output).toContain("50");
-      expect(output).toContain("100");
-      expect(output).toContain("Progress:");
-    });
-
-    test("handles zero total", () => {
-      const output = formatProgress(0, 0);
-
-      expect(output).toContain("0/0");
-    });
-
-    test("handles completion", () => {
-      const output = formatProgress(100, 100);
-
-      expect(output).toContain("100/100");
-    });
-  });
-
-  describe("message formatters", () => {
-    test("formatWarning includes warning text", () => {
-      const output = formatWarning("This is a warning");
-
-      expect(output).toContain("This is a warning");
-    });
-
-    test("formatError includes error text", () => {
-      const output = formatError("Something went wrong");
-
-      expect(output).toContain("Something went wrong");
-    });
-
-    test("formatInfo includes info text", () => {
-      const output = formatInfo("Information message");
-
-      expect(output).toContain("Information message");
-    });
-
-    test("formatSuccess includes success text", () => {
-      const output = formatSuccess("Operation completed");
-
-      expect(output).toContain("Operation completed");
-    });
-
-    test("formatScanning includes scanning text", () => {
-      const output = formatScanning("Scanning repositories...");
-
-      expect(output).toContain("Scanning repositories...");
-    });
-
-    test("formatScanning uses default message", () => {
-      const output = formatScanning();
-
-      expect(output).toContain("Scanning directories...");
-    });
-  });
-
-  describe("formatOperationItem", () => {
-    test("formats successful operation", () => {
-      const output = formatOperationItem("Deploy", true);
-
-      expect(output).toContain("✓");
-      expect(output).toContain("Deploy");
-    });
-
-    test("formats failed operation", () => {
-      const output = formatOperationItem("Deploy", false, "Connection timeout");
-
-      expect(output).toContain("✗");
-      expect(output).toContain("Deploy");
-      expect(output).toContain("Connection timeout");
-    });
-
-    test("formats failed operation without error", () => {
-      const output = formatOperationItem("Deploy", false);
-
-      expect(output).toContain("✗");
-      expect(output).toContain("Deploy");
-      expect(output).not.toContain(":");
-    });
-  });
-
-  describe("formatOperationSummary", () => {
-    test("formats summary with single item", () => {
-      const output = formatOperationSummary("Deploy", 1, 1);
-
-      expect(output).toContain("Deploy");
-      expect(output).toContain("1/1");
-      expect(output).toContain("item");
-    });
-
-    test("formats summary with multiple items", () => {
-      const output = formatOperationSummary("Deploy", 5, 5);
-
-      expect(output).toContain("Deploy");
-      expect(output).toContain("5/5");
-      expect(output).toContain("items");
-    });
-  });
-
-  describe("calculateStatusSummary", () => {
-    test("calculates summary for mixed projects", () => {
-      const projects = [
-        createMockProject({ name: "clean" }),
-        createDirtyProject("dirty"),
-        createAheadProject("ahead", 2),
-        createNonGitProject("npm"),
-      ];
-
-      const summary = calculateStatusSummary(projects);
-
-      expect(summary.total).toBe(4);
-      expect(summary.dirty).toHaveLength(1);
-      expect(summary.unpushed).toHaveLength(1);
-      expect(summary.nonGit).toHaveLength(1);
-    });
-
-    test("identifies no-remote projects", () => {
-      const projects = [
-        createMockProject({ status: createNoRemoteStatus() }),
-        createMockProject(), // Has remote
-      ];
-
-      const summary = calculateStatusSummary(projects);
-
-      expect(summary.noRemote).toHaveLength(1);
-    });
-
-    test("identifies unpulled projects", () => {
-      const projects = [
-        createMockProject({ status: createBehindStatus(3) }),
-        createMockProject(), // Up to date
-      ];
-
-      const summary = calculateStatusSummary(projects);
-
-      expect(summary.unpulled).toHaveLength(1);
-    });
-
-    test("handles empty project list", () => {
-      const summary = calculateStatusSummary([]);
-
-      expect(summary.total).toBe(0);
-      expect(summary.dirty).toHaveLength(0);
-      expect(summary.unpushed).toHaveLength(0);
-      expect(summary.unpulled).toHaveLength(0);
-      expect(summary.noRemote).toHaveLength(0);
-      expect(summary.nonGit).toHaveLength(0);
-    });
-  });
-
-  describe("calculateProjectStats", () => {
-    test("counts project types correctly", () => {
-      const projects = [
-        createMockProject(), // git
-        createMockProject(), // git
-        createSubmoduleProject("sub"),
-        createNonGitProject("npm"),
-      ];
-
-      const stats = calculateProjectStats(projects);
-
-      expect(stats.total).toBe(4);
-      expect(stats.gitCount).toBe(2);
-      expect(stats.submoduleCount).toBe(1);
-      expect(stats.nonGitCount).toBe(1);
-    });
-
-    test("counts dirty and sync status", () => {
-      const projects = [
-        createDirtyProject(),
-        createAheadProject("ahead"),
-        createMockProject({ status: createBehindStatus() }),
-      ];
-
-      const stats = calculateProjectStats(projects);
-
-      expect(stats.dirtyCount).toBe(1);
-      expect(stats.unpushedCount).toBe(1);
-      expect(stats.unpulledCount).toBe(1);
-    });
-
-    test("handles empty project list", () => {
-      const stats = calculateProjectStats([]);
-
-      expect(stats.total).toBe(0);
-      expect(stats.gitCount).toBe(0);
-      expect(stats.submoduleCount).toBe(0);
-      expect(stats.nonGitCount).toBe(0);
-      expect(stats.dirtyCount).toBe(0);
-      expect(stats.unpushedCount).toBe(0);
-      expect(stats.unpulledCount).toBe(0);
-    });
-  });
-
-  describe("formatProjectStats", () => {
-    test("formats stats with all counts", () => {
-      const stats = {
-        total: 10,
-        gitCount: 6,
-        submoduleCount: 2,
-        nonGitCount: 2,
-        dirtyCount: 3,
-        unpushedCount: 1,
-        unpulledCount: 2,
-      };
-
-      const output = formatProjectStats(stats);
-
-      expect(output).toContain("6 git");
-      expect(output).toContain("2 submodules");
-      expect(output).toContain("2 non-git");
-      expect(output).toContain("3 dirty");
-      expect(output).toContain("1 unpushed");
-    });
-
-    test("formats stats with zero counts", () => {
-      const stats = {
-        total: 0,
-        gitCount: 0,
-        submoduleCount: 0,
-        nonGitCount: 0,
-        dirtyCount: 0,
-        unpushedCount: 0,
-        unpulledCount: 0,
-      };
-
-      const output = formatProjectStats(stats);
-
-      expect(output).toContain("0 git");
-      expect(output).toContain("0 submodules");
-      expect(output).toContain("0 non-git");
-      expect(output).toContain("0 dirty");
-      expect(output).toContain("0 unpushed");
-    });
-  });
-
-  describe("formatProjectList", () => {
-    test("formats project list in default mode", () => {
-      const projects = [
-        createMockProject({ name: "project1" }),
-        createDirtyProject("project2"),
-        createNonGitProject("project3"),
-      ];
-
-      const output = formatProjectList(projects);
-
-      expect(output).toContain("Found 3 projects");
-      expect(output).toContain("project1");
-      expect(output).toContain("project2");
-      expect(output).toContain("project3");
-      expect(output).toContain("---");
-      expect(output).toContain("2 git");
-      expect(output).toContain("1 non-git");
-      expect(output).toContain("1 dirty");
-    });
-
-    test("formats project list in verbose mode", () => {
-      const projects = [
-        createMockProject({ name: "project1", path: "/path/to/project1" }),
-      ];
-
-      const output = formatProjectList(projects, { verbose: true });
-
-      expect(output).toContain("Path: /path/to/project1");
-      expect(output).toContain("Status:");
-      expect(output).toContain("Branch:");
-    });
-
-    test("formats project list as JSON", () => {
-      const projects = [
-        createMockProject({ name: "project1" }),
-        createMockProject({ name: "project2" }),
-      ];
-
-      const output = formatProjectList(projects, { json: true });
-
-      const parsed = JSON.parse(output);
-      expect(parsed).toHaveLength(2);
-      expect(parsed[0].name).toBe("project1");
-      expect(parsed[1].name).toBe("project2");
-    });
-  });
-
-  describe("formatStatusSummary", () => {
-    test("formats summary with all categories", () => {
-      const summary = calculateStatusSummary([
-        createMockProject({ name: "clean" }),
-        createDirtyProject("dirty1"),
-        createDirtyProject("dirty2"),
-        createAheadProject("ahead1", 2),
-        createAheadProject("ahead2", 5),
-        createMockProject({ name: "behind", status: createBehindStatus(3) }),
-        createMockProject({ name: "no-remote", status: createNoRemoteStatus() }),
-        createNonGitProject("npm"),
-      ]);
-
-      const output = formatStatusSummary(summary);
-
-      expect(output).toContain("Status Summary (8 projects)");
-      expect(output).toContain("Dirty (2)");
-      expect(output).toContain("dirty1");
-      expect(output).toContain("dirty2");
-      expect(output).toContain("Unpushed (2)");
-      expect(output).toContain("ahead1 (↑2)");
-      expect(output).toContain("Unpulled (1)");
-      expect(output).toContain("behind (↓3)");
-      expect(output).toContain("No Remote (1)");
-      expect(output).toContain("no-remote");
-    });
-
-    test("shows clean message when all repos are clean", () => {
-      const summary = calculateStatusSummary([
-        createMockProject({ name: "clean1" }),
-        createMockProject({ name: "clean2" }),
-      ]);
-
-      const output = formatStatusSummary(summary);
-
-      expect(output).toContain("Status Summary (2 projects)");
-      expect(output).toContain("All repositories are clean and in sync!");
-    });
-
-    test("handles empty summary", () => {
-      const summary = calculateStatusSummary([]);
-
-      const output = formatStatusSummary(summary);
-
-      expect(output).toContain("Status Summary (0 projects)");
-    });
-  });
-
-  describe("formatStatusSummaryJson", () => {
-    test("formats summary as JSON", () => {
-      const summary = calculateStatusSummary([
-        createMockProject({ name: "clean" }),
-        createDirtyProject("dirty"),
-        createAheadProject("ahead", 2),
-        createNonGitProject("npm"),
-      ]);
-
-      const output = formatStatusSummaryJson(summary);
-      const parsed = JSON.parse(output);
-
-      expect(parsed.total).toBe(4);
-      expect(parsed.dirty).toEqual(["dirty"]);
-      expect(parsed.unpushed).toEqual(["ahead"]);
-      expect(parsed.nonGit).toEqual(["npm"]);
-    });
-  });
-
-  describe("formatDirtyRepos", () => {
-    test("formats empty dirty list", () => {
-      const output = formatDirtyRepos([]);
-
-      expect(output).toContain("All repositories are clean!");
-    });
-
-    test("formats dirty repos list", () => {
-      const dirty = [
-        createDirtyProject("project1"),
-        createMockProject({
-          name: "project2",
-          status: {
-            ...createDirtyStatus(),
-            stagedCount: 2,
-            untrackedCount: 1,
-          },
-        }),
-      ];
-
-      const output = formatDirtyRepos(dirty);
-
-      expect(output).toContain("2 dirty repositories");
-      expect(output).toContain("project1");
-      expect(output).toContain("project2");
-      expect(output).toContain("2 modified");
-      expect(output).toContain("2 staged");
-      expect(output).toContain("1 untracked");
-    });
-
-    test("formats as JSON", () => {
-      const dirty = [
-        createDirtyProject("project1"),
-        createDirtyProject("project2"),
-      ];
-
-      const output = formatDirtyRepos(dirty, true);
-      const parsed = JSON.parse(output);
-
-      expect(parsed).toHaveLength(2);
-      expect(parsed[0].name).toBe("project1");
-      expect(parsed[1].name).toBe("project2");
-    });
-  });
-
-  describe("getSourceIcon", () => {
-    test("returns L for local", () => {
-      const icon = getSourceIcon("local");
-      expect(icon).toContain("L");
-    });
-
-    test("returns G for github", () => {
-      const icon = getSourceIcon("github");
-      expect(icon).toContain("G");
-    });
-
-    test("returns checkmark for both", () => {
-      const icon = getSourceIcon("both");
-      expect(icon).toContain("✓");
-    });
-  });
-
-  describe("formatUnifiedRepoStatus", () => {
-    test("shows not cloned for github-only repo", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "github" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: null,
-        isCloned: false,
-        isOnGitHub: true,
-        localPath: null,
-      };
-
-      const status = formatUnifiedRepoStatus(repo);
-
-      expect(status).toContain("not cloned");
-    });
-
-    test("shows local-only for repo not on GitHub", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "local" as const,
-        github: null,
-        local: createMockProject({ name: "test-repo" }),
-        isCloned: true,
-        isOnGitHub: false,
-        localPath: "/path/to/repo",
-      };
-
-      const status = formatUnifiedRepoStatus(repo);
-
-      expect(status).toContain("local-only");
-    });
-
-    test("shows synced for clean synced repo", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createMockProject({ name: "test-repo" }),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const status = formatUnifiedRepoStatus(repo);
-
-      expect(status).toContain("synced");
-    });
-
-    test("shows dirty status", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createDirtyProject("test-repo"),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const status = formatUnifiedRepoStatus(repo);
-
-      expect(status).toContain("2M");
-    });
-
-    test("shows ahead status", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createAheadProject("test-repo", 3),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const status = formatUnifiedRepoStatus(repo);
-
-      expect(status).toContain("↑3");
-    });
-
-    test("shows behind status", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createMockProject({ 
-          name: "test-repo",
-          status: createBehindStatus(2)
-        }),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const status = formatUnifiedRepoStatus(repo);
-
-      expect(status).toContain("↓2");
-    });
-  });
-
-  describe("formatUnifiedRepo", () => {
-    test("formats basic repo", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createMockProject({ name: "test-repo" }),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const output = formatUnifiedRepo(repo);
-
-      expect(output).toContain("test-repo");
-      expect(output).toContain("synced");
-    });
-
-    test("formats with private indicator", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo",
-          owner: "user",
-          description: null,
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: true,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createMockProject({ name: "test-repo" }),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const output = formatUnifiedRepo(repo);
-
-      expect(output).toContain("test-repo");
-      expect(output).toContain("(private)");
-    });
-
-    test("formats in verbose mode", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "both" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo", 
-          owner: "user",
-          description: "A test repository for formatting",
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: createMockProject({ name: "test-repo" }),
-        isCloned: true,
-        isOnGitHub: true,
-        localPath: "/path/to/repo",
-      };
-
-      const output = formatUnifiedRepo(repo, true);
-
-      expect(output).toContain("test-repo");
-      expect(output).toContain("Local: /path/to/repo");
-      expect(output).toContain("GitHub: user/test-repo");
-      expect(output).toContain("Desc: A test repository for formatting");
-      expect(output).toContain("Status: synced");
-    });
-
-    test("handles github-only repo in verbose mode", () => {
-      const repo = {
-        id: "test-repo",
-        name: "test-repo",
-        source: "github" as const,
-        github: { 
-          name: "test-repo",
-          fullName: "user/test-repo", 
-          owner: "user",
-          description: "Not cloned yet",
-          htmlUrl: "https://github.com/user/test-repo",
-          sshUrl: "git@github.com:user/test-repo.git",
-          cloneUrl: "https://github.com/user/test-repo.git",
-          isPrivate: false,
-          isArchived: false,
-          isFork: false,
-          pushedAt: new Date(),
-          updatedAt: new Date(),
-          defaultBranch: "main",
-          language: "TypeScript",
-          size: 1024,
-        },
-        local: null,
-        isCloned: false,
-        isOnGitHub: true,
-        localPath: null,
-      };
-
-      const output = formatUnifiedRepo(repo, true);
-
-      expect(output).toContain("test-repo");
-      expect(output).not.toContain("Local:");
-      expect(output).toContain("GitHub: user/test-repo");
-      expect(output).toContain("Desc: Not cloned yet");
-    });
-  });
-
-  describe("formatUnifiedStats", () => {
-    test("formats stats with all counts", () => {
-      const stats = {
-        total: 10,
-        both: 5,
-        localOnly: 2,
-        githubOnly: 3,
-        dirty: 1,
-        unpushed: 2,
-        unpulled: 1,
-      };
-
-      const output = formatUnifiedStats(stats);
-
-      expect(output).toContain("5 synced");
-      expect(output).toContain("2 local-only");
-      expect(output).toContain("3 github-only");
-      expect(output).toContain("1 dirty");
-      expect(output).toContain("2 unpushed");
-    });
-
-    test("formats stats with zero counts", () => {
-      const stats = {
-        total: 0,
-        both: 0,
-        localOnly: 0,
-        githubOnly: 0,
-        dirty: 0,
-        unpushed: 0,
-        unpulled: 0,
-      };
-
-      const output = formatUnifiedStats(stats);
-
-      expect(output).toContain("0 synced");
-      expect(output).toContain("0 local-only");
-      expect(output).toContain("0 github-only");
-      expect(output).toContain("0 dirty");
-      expect(output).toContain("0 unpushed");
-    });
-  });
-
-  describe("formatAuthSuccess", () => {
-    test("formats success with login only", () => {
-      const output = formatAuthSuccess("johndoe");
-
-      expect(output).toContain("✓");
-      expect(output).toContain("Authenticated as johndoe");
-      expect(output).not.toContain("Name:");
-    });
-
-    test("formats success with login and name", () => {
-      const output = formatAuthSuccess("johndoe", "John Doe");
-
-      expect(output).toContain("✓");
-      expect(output).toContain("Authenticated as johndoe");
-      expect(output).toContain("Name: John Doe");
-    });
-  });
-
-  describe("formatAuthFailure", () => {
-    test("formats failure without error", () => {
-      const output = formatAuthFailure();
-
-      expect(output).toContain("✗");
-      expect(output).toContain("Authentication failed");
-      expect(output).not.toContain(":");
-    });
-
-    test("formats failure with error", () => {
-      const output = formatAuthFailure("Invalid token");
-
-      expect(output).toContain("✗");
-      expect(output).toContain("Authentication failed: Invalid token");
-    });
-  });
-
-  describe("formatNoToken", () => {
-    test("formats no token message", () => {
-      const output = formatNoToken();
-
-      expect(output).toContain("✗");
-      expect(output).toContain("GITHUB_TOKEN not set");
-      expect(output).toContain("gitforest login");
-      expect(output).toContain("export GITHUB_TOKEN=your_token");
-    });
-  });
-
-  describe("formatCloneItem", () => {
-    test("formats successful clone", () => {
-      const output = formatCloneItem("user/repo", true, "/path/to/repo");
-
-      expect(output).toContain("✓");
-      expect(output).toContain("user/repo");
-      expect(output).toContain("→ /path/to/repo");
-    });
-
-    test("formats failed clone", () => {
-      const output = formatCloneItem("user/repo", false, undefined, "Already exists");
-
-      expect(output).toContain("✗");
-      expect(output).toContain("user/repo");
-      expect(output).toContain("Already exists");
-      expect(output).not.toContain("→");
-    });
-  });
-});