gitforest 0.1.0

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

@@ -0,0 +1,1116 @@
+/**
+ * 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("→");
+    });
+  });
+});