gitforest 0.1.0

package/test/unit/github/unified.test.ts

@@ -0,0 +1,1201 @@
+import { describe, test, expect } from "bun:test";
+import {
+  toGitHubRepoInfo,
+  createUnifiedView,
+  filterByViewMode,
+  sortUnifiedRepos,
+  filterUnifiedRepos,
+  getUnifiedStats,
+  cloneGitHubRepo,
+} from "../../../src/github/unified.ts";
+import type { Project, GitHubRepoInfo } from "../../../src/types/index.ts";
+import type { GitHubRepoData } from "../../../src/services/github.ts";
+import type { GitService } from "../../../src/services/git.ts";
+import {
+  createMockProject,
+  createMockGitHubRepoInfo,
+  createMockUnifiedRepo,
+} from "../mocks/index.ts";
+
+describe("toGitHubRepoInfo", () => {
+  test("converts GitHubRepoData to GitHubRepoInfo", () => {
+    const repo: GitHubRepoData = {
+      id: 123,
+      name: "my-repo",
+      fullName: "user/my-repo",
+      description: "A test repo",
+      htmlUrl: "https://github.com/user/my-repo",
+      sshUrl: "git@github.com:user/my-repo.git",
+      cloneUrl: "https://github.com/user/my-repo.git",
+      isPrivate: true,
+      isArchived: false,
+      isFork: false,
+      createdAt: "2024-01-01T00:00:00Z",
+      updatedAt: "2024-06-01T00:00:00Z",
+      pushedAt: "2024-06-15T00:00:00Z",
+      size: 1024,
+      stargazersCount: 10,
+      forksCount: 5,
+      openIssuesCount: 2,
+      watchersCount: 15,
+      topics: ["typescript", "test"],
+      license: { name: "MIT" },
+      hasIssues: true,
+      hasWiki: true,
+      hasDiscussions: false,
+      language: "TypeScript",
+      defaultBranch: "main",
+      owner: {
+        login: "user",
+        type: "User",
+      },
+    };
+
+    const result = toGitHubRepoInfo(repo);
+
+    expect(result.name).toBe("my-repo");
+    expect(result.fullName).toBe("user/my-repo");
+    expect(result.owner).toBe("user");
+    expect(result.description).toBe("A test repo");
+    expect(result.isPrivate).toBe(true);
+    expect(result.isArchived).toBe(false);
+    expect(result.isFork).toBe(false);
+    expect(result.language).toBe("TypeScript");
+    expect(result.pushedAt).toBeInstanceOf(Date);
+  });
+
+  test("handles null pushed_at", () => {
+    const repo: GitHubRepoData = {
+      id: 123,
+      name: "empty-repo",
+      fullName: "user/empty-repo",
+      description: null,
+      htmlUrl: "https://github.com/user/empty-repo",
+      sshUrl: "git@github.com:user/empty-repo.git",
+      cloneUrl: "https://github.com/user/empty-repo.git",
+      isPrivate: false,
+      isArchived: false,
+      isFork: false,
+      createdAt: "2024-01-01T00:00:00Z",
+      updatedAt: "2024-01-01T00:00:00Z",
+      pushedAt: null,
+      size: 0,
+      stargazersCount: 0,
+      forksCount: 0,
+      openIssuesCount: 0,
+      watchersCount: 0,
+      topics: [],
+      license: null,
+      hasIssues: true,
+      hasWiki: true,
+      hasDiscussions: false,
+      language: null,
+      defaultBranch: "main",
+      owner: {
+        login: "user",
+        type: "User",
+      },
+    };
+
+    const result = toGitHubRepoInfo(repo);
+
+    expect(result.pushedAt).toBeNull();
+    expect(result.description).toBeNull();
+    expect(result.language).toBeNull();
+  });
+
+  test("handles missing optional fields", () => {
+    const repo: GitHubRepoData = {
+      id: 123,
+      name: "minimal-repo",
+      fullName: "user/minimal-repo",
+      description: "Minimal repo",
+      htmlUrl: "https://github.com/user/minimal-repo",
+      sshUrl: "git@github.com:user/minimal-repo.git",
+      cloneUrl: "https://github.com/user/minimal-repo.git",
+      isPrivate: false,
+      isArchived: false,
+      isFork: false,
+      createdAt: "2024-01-01T00:00:00Z",
+      updatedAt: "2024-01-01T00:00:00Z",
+      pushedAt: "2024-01-01T00:00:00Z",
+      size: 100,
+      stargazersCount: 0,
+      forksCount: 0,
+      openIssuesCount: 0,
+      watchersCount: 0,
+      topics: [],
+      license: null,
+      hasIssues: false,
+      hasWiki: false,
+      hasDiscussions: false,
+      language: null,
+      defaultBranch: "main",
+      owner: {
+        login: "user",
+        type: "User",
+      },
+    };
+
+    const result = toGitHubRepoInfo(repo);
+
+    expect(result.license).toBeNull();
+    expect(result.hasIssues).toBe(false);
+    expect(result.hasWiki).toBe(false);
+    expect(result.hasDiscussions).toBe(false);
+  });
+});
+
+describe("createUnifiedView", () => {
+  test("matches local projects with GitHub repos", () => {
+    const local = [
+      createMockProject({ 
+        name: "my-repo", 
+        status: { 
+          ...createMockProject().status!, 
+          remoteUrl: "git@github.com:user/my-repo.git", 
+          hasRemote: true 
+        } 
+      }),
+    ];
+    const github = [createMockGitHubRepoInfo({ name: "my-repo", owner: "user" })];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.source).toBe("both");
+    expect(unified[0]?.isCloned).toBe(true);
+    expect(unified[0]?.isOnGitHub).toBe(true);
+  });
+
+  test("identifies local-only projects", () => {
+    const local = [createMockProject({ 
+      name: "local-only", 
+      status: { 
+        ...createMockProject().status!, 
+        remoteUrl: null, 
+        hasRemote: false 
+      } 
+    })];
+    const github: GitHubRepoInfo[] = [];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.source).toBe("local");
+    expect(unified[0]?.isCloned).toBe(true);
+    expect(unified[0]?.isOnGitHub).toBe(false);
+  });
+
+  test("identifies GitHub-only repos", () => {
+    const local: Project[] = [];
+    const github = [createMockGitHubRepoInfo({ name: "github-only" })];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.source).toBe("github");
+    expect(unified[0]?.isCloned).toBe(false);
+    expect(unified[0]?.isOnGitHub).toBe(true);
+  });
+
+  test("handles mixed projects correctly", () => {
+    const local = [
+      createMockProject({ 
+        name: "synced", 
+        status: { 
+          ...createMockProject().status!, 
+          remoteUrl: "git@github.com:user/synced.git", 
+          hasRemote: true 
+        } 
+      }),
+      createMockProject({ 
+        name: "local-only", 
+        status: { 
+          ...createMockProject().status!, 
+          remoteUrl: null, 
+          hasRemote: false 
+        } 
+      }),
+    ];
+    const github = [
+      createMockGitHubRepoInfo({ name: "synced", owner: "user" }),
+      createMockGitHubRepoInfo({ name: "github-only" }),
+    ];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(3);
+
+    const synced = unified.find((r) => r.name === "synced");
+    const localOnly = unified.find((r) => r.name === "local-only");
+    const githubOnly = unified.find((r) => r.name === "github-only");
+
+    expect(synced?.source).toBe("both");
+    expect(localOnly?.source).toBe("local");
+    expect(githubOnly?.source).toBe("github");
+  });
+
+  test("matches HTTPS remote URLs", () => {
+    const local = [
+      createMockProject({ 
+        name: "https-repo", 
+        status: { 
+          ...createMockProject().status!, 
+          remoteUrl: "https://github.com/user/https-repo.git", 
+          hasRemote: true 
+        } 
+      }),
+    ];
+    const github = [createMockGitHubRepoInfo({ name: "https-repo", owner: "user" })];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.source).toBe("both");
+  });
+
+  test("handles case-insensitive matching", () => {
+    const local = [
+      createMockProject({ 
+        name: "MyRepo", 
+        status: { 
+          ...createMockProject().status!, 
+          remoteUrl: "git@github.com:user/MyRepo.git", 
+          hasRemote: true 
+        } 
+      }),
+    ];
+    const github = [createMockGitHubRepoInfo({ name: "myrepo", fullName: "user/myrepo" })];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.source).toBe("both");
+  });
+
+  test("handles empty arrays", () => {
+    const local: Project[] = [];
+    const github: GitHubRepoInfo[] = [];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(0);
+  });
+
+  test("handles multiple GitHub repos with same name but different owners", () => {
+    const local = [
+      createMockProject({ 
+        name: "test-repo", 
+        status: { 
+          ...createMockProject().status!, 
+          remoteUrl: "git@github.com:user1/test-repo.git", 
+          hasRemote: true 
+        } 
+      }),
+    ];
+    const github = [
+      createMockGitHubRepoInfo({ name: "test-repo", owner: "user1", fullName: "user1/test-repo" }),
+      createMockGitHubRepoInfo({ name: "test-repo", owner: "user2", fullName: "user2/test-repo" }),
+    ];
+
+    const unified = createUnifiedView(local, github);
+
+    expect(unified).toHaveLength(2);
+    const matched = unified.find(r => r.source === "both");
+    expect(matched?.github?.owner).toBe("user1");
+  });
+});
+
+describe("filterByViewMode", () => {
+  test("filters to local view", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "synced", source: "both", isCloned: true, isOnGitHub: true }),
+      createMockUnifiedRepo({ name: "local-only", source: "local", isCloned: true, isOnGitHub: false }),
+      createMockUnifiedRepo({ name: "github-only", source: "github", isCloned: false, isOnGitHub: true }),
+    ];
+
+    const filtered = filterByViewMode(repos, "local");
+
+    expect(filtered).toHaveLength(2);
+    expect(filtered.every((r) => r.isCloned)).toBe(true);
+  });
+
+  test("filters to github view", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "synced", source: "both", isCloned: true, isOnGitHub: true }),
+      createMockUnifiedRepo({ name: "local-only", source: "local", isCloned: true, isOnGitHub: false }),
+      createMockUnifiedRepo({ name: "github-only", source: "github", isCloned: false, isOnGitHub: true }),
+    ];
+
+    const filtered = filterByViewMode(repos, "github");
+
+    expect(filtered).toHaveLength(2);
+    expect(filtered.every((r) => r.isOnGitHub)).toBe(true);
+  });
+
+  test("returns all for combined view", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "synced", source: "both", isCloned: true, isOnGitHub: true }),
+      createMockUnifiedRepo({ name: "local-only", source: "local", isCloned: true, isOnGitHub: false }),
+      createMockUnifiedRepo({ name: "github-only", source: "github", isCloned: false, isOnGitHub: true }),
+    ];
+
+    const filtered = filterByViewMode(repos, "combined");
+
+    expect(filtered).toHaveLength(3);
+  });
+});
+
+describe("sortUnifiedRepos", () => {
+  test("sorts by name ascending", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "zebra" }),
+      createMockUnifiedRepo({ name: "alpha" }),
+    ];
+
+    const sorted = sortUnifiedRepos(repos, "name", "asc");
+
+    expect(sorted[0]?.name).toBe("alpha");
+    expect(sorted[1]?.name).toBe("zebra");
+  });
+
+  test("sorts by name descending", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "zebra" }),
+      createMockUnifiedRepo({ name: "alpha" }),
+    ];
+
+    const sorted = sortUnifiedRepos(repos, "name", "desc");
+
+    expect(sorted[0]?.name).toBe("zebra");
+    expect(sorted[1]?.name).toBe("alpha");
+  });
+
+  test("sorts by status (github-only first in desc)", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "zebra", source: "both" }),
+      createMockUnifiedRepo({ name: "alpha", source: "github", isCloned: false }),
+    ];
+
+    const sorted = sortUnifiedRepos(repos, "status", "desc");
+
+    // GitHub-only repos should come first (not cloned = needs attention)
+    expect(sorted[0]?.name).toBe("alpha");
+    expect(sorted[0]?.source).toBe("github");
+  });
+
+  test("sorts by lastActivity (Date objects)", () => {
+    const localProject = createMockProject({ name: "old-repo" });
+    const repos = [
+      createMockUnifiedRepo({
+        name: "old-repo",
+        source: "both",
+        local: localProject,
+      }),
+      createMockUnifiedRepo({
+        name: "new-repo",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "new-repo", pushedAt: new Date("2024-06-01") }),
+      }),
+    ];
+
+    // Set local commit date for old-repo
+    if (repos[0]?.local?.status) {
+      repos[0].local.status.lastLocalCommit = new Date("2024-01-01");
+    }
+
+    const sorted = sortUnifiedRepos(repos, "lastActivity", "desc");
+
+    // Newer repo should come first
+    expect(sorted[0]?.name).toBe("new-repo");
+    expect(sorted[1]?.name).toBe("old-repo");
+  });
+
+  test("sorts by lastActivity (string dates)", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "old-repo",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "old-repo", pushedAt: new Date("2024-01-01") }),
+      }),
+      createMockUnifiedRepo({
+        name: "new-repo",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "new-repo", pushedAt: new Date("2024-06-01") }),
+      }),
+    ];
+
+    const sorted = sortUnifiedRepos(repos, "lastActivity", "desc");
+
+    // Newer repo should come first
+    expect(sorted[0]?.name).toBe("new-repo");
+    expect(sorted[1]?.name).toBe("old-repo");
+  });
+
+  test("sorts by stars", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "low-stars",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "low-stars", stargazersCount: 10 }),
+      }),
+      createMockUnifiedRepo({
+        name: "high-stars",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "high-stars", stargazersCount: 1000 }),
+      }),
+    ];
+
+    const sorted = sortUnifiedRepos(repos, "stars", "desc");
+
+    // Higher stars should come first
+    expect(sorted[0]?.name).toBe("high-stars");
+    expect(sorted[0]?.github?.stargazersCount).toBe(1000);
+    expect(sorted[1]?.name).toBe("low-stars");
+    expect(sorted[1]?.github?.stargazersCount).toBe(10);
+  });
+
+  test("sorts by size", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "small-repo",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "small-repo", size: 100 }),
+      }),
+      createMockUnifiedRepo({
+        name: "large-repo",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "large-repo", size: 10000 }),
+      }),
+    ];
+
+    const sorted = sortUnifiedRepos(repos, "size", "desc");
+
+    // Larger size should come first
+    expect(sorted[0]?.name).toBe("large-repo");
+    expect(sorted[0]?.github?.size).toBe(10000);
+    expect(sorted[1]?.name).toBe("small-repo");
+    expect(sorted[1]?.github?.size).toBe(100);
+  });
+
+  test("does not mutate original array", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "zebra" }),
+      createMockUnifiedRepo({ name: "alpha" }),
+    ];
+    const originalFirst = repos[0]?.name;
+    sortUnifiedRepos(repos, "name", "asc");
+    expect(repos[0]?.name).toBe(originalFirst);
+  });
+
+  test("handles missing github data for stars and size sorts", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "local-only",
+        source: "local",
+        local: createMockProject({ name: "local-only" }),
+        github: null,
+      }),
+      createMockUnifiedRepo({
+        name: "github-repo",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "github-repo", size: 1000, stargazersCount: 100 }),
+      }),
+    ];
+
+    const sortedByStars = sortUnifiedRepos(repos, "stars", "desc");
+    expect(sortedByStars[0]?.name).toBe("github-repo");
+    expect(sortedByStars[1]?.name).toBe("local-only");
+
+    const sortedBySize = sortUnifiedRepos(repos, "size", "desc");
+    expect(sortedBySize[0]?.name).toBe("github-repo");
+    expect(sortedBySize[1]?.name).toBe("local-only");
+  });
+});
+
+describe("filterUnifiedRepos", () => {
+  test("filters by name", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-awesome-project",
+        source: "both",
+        local: createMockProject({ name: "my-awesome-project" }),
+        github: createMockGitHubRepoInfo({
+          name: "my-awesome-project",
+          description: "An awesome TypeScript project",
+          language: "TypeScript",
+        }),
+      }),
+      createMockUnifiedRepo({
+        name: "rust-lib",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({
+          name: "rust-lib",
+          description: "A Rust library",
+          language: "Rust",
+        }),
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "awesome");
+
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("my-awesome-project");
+  });
+
+  test("filters by description", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-awesome-project",
+        source: "both",
+        local: createMockProject({ name: "my-awesome-project" }),
+        github: createMockGitHubRepoInfo({
+          name: "my-awesome-project",
+          description: "An awesome TypeScript project",
+          language: "TypeScript",
+        }),
+      }),
+      createMockUnifiedRepo({
+        name: "rust-lib",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({
+          name: "rust-lib",
+          description: "A Rust library",
+          language: "Rust",
+        }),
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "library");
+
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("rust-lib");
+  });
+
+  test("filters by language", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-awesome-project",
+        source: "both",
+        local: createMockProject({ name: "my-awesome-project" }),
+        github: createMockGitHubRepoInfo({
+          name: "my-awesome-project",
+          description: "An awesome TypeScript project",
+          language: "TypeScript",
+        }),
+      }),
+      createMockUnifiedRepo({
+        name: "rust-lib",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({
+          name: "rust-lib",
+          description: "A Rust library",
+          language: "Rust",
+        }),
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "rust");
+
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("rust-lib");
+  });
+
+  test("filters by path", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-project",
+        source: "local",
+        local: createMockProject({ name: "my-project", path: "/home/user/projects/my-project" }),
+        localPath: "/home/user/projects/my-project",
+      }),
+      createMockUnifiedRepo({
+        name: "other-project",
+        source: "local",
+        local: createMockProject({ name: "other-project", path: "/home/user/other/other-project" }),
+        localPath: "/home/user/other/other-project",
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "projects");
+
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("my-project");
+  });
+
+  test("filters by full name", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-project",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "my-project", fullName: "user1/my-project" }),
+      }),
+      createMockUnifiedRepo({
+        name: "other-project",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "other-project", fullName: "user2/other-project" }),
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "user1");
+
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("my-project");
+  });
+
+  test("filters by source type", () => {
+    const repos = [
+      createMockUnifiedRepo({ name: "local-repo", source: "local" }),
+      createMockUnifiedRepo({ name: "github-repo", source: "github" }),
+      createMockUnifiedRepo({ name: "synced-repo", source: "both" }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "local");
+
+    // Should only match "local" repos (exact match)
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("local-repo");
+    expect(filtered[0]?.source).toBe("local");
+  });
+
+  test("filter is case-insensitive", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-awesome-project",
+        source: "both",
+        local: createMockProject({ name: "my-awesome-project" }),
+        github: createMockGitHubRepoInfo({
+          name: "my-awesome-project",
+          description: "An awesome TypeScript project",
+          language: "TypeScript",
+        }),
+      }),
+      createMockUnifiedRepo({
+        name: "rust-lib",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({
+          name: "rust-lib",
+          description: "A Rust library",
+          language: "Rust",
+        }),
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "TYPESCRIPT");
+
+    expect(filtered).toHaveLength(1);
+    expect(filtered[0]?.name).toBe("my-awesome-project");
+  });
+
+  test("returns all when filter is empty", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "my-awesome-project",
+        source: "both",
+        local: createMockProject({ name: "my-awesome-project" }),
+        github: createMockGitHubRepoInfo({
+          name: "my-awesome-project",
+          description: "An awesome TypeScript project",
+          language: "TypeScript",
+        }),
+      }),
+      createMockUnifiedRepo({
+        name: "rust-lib",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({
+          name: "rust-lib",
+          description: "A Rust library",
+          language: "Rust",
+        }),
+      }),
+    ];
+
+    const filtered = filterUnifiedRepos(repos, "");
+
+    expect(filtered).toHaveLength(2);
+  });
+
+  test("handles null values in github data", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "no-description",
+        source: "github",
+        local: null,
+        github: createMockGitHubRepoInfo({ name: "no-description", description: null, language: null }),
+      }),
+    ];
+
+    const filteredByDescription = filterUnifiedRepos(repos, "something");
+    expect(filteredByDescription).toHaveLength(0);
+
+    const filteredByLanguage = filterUnifiedRepos(repos, "javascript");
+    expect(filteredByLanguage).toHaveLength(0);
+  });
+});
+
+describe("getUnifiedStats", () => {
+  test("calculates stats correctly", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "synced",
+        source: "both",
+        local: createMockProject({ name: "synced", status: { ...createMockProject().status!, isDirty: true, isAhead: true } }),
+      }),
+      createMockUnifiedRepo({
+        name: "local-only",
+        source: "local",
+        local: createMockProject({ name: "local-only" }),
+      }),
+      createMockUnifiedRepo({
+        name: "github-only",
+        source: "github",
+        local: null,
+      }),
+    ];
+
+    const stats = getUnifiedStats(repos);
+
+    expect(stats.total).toBe(3);
+    expect(stats.both).toBe(1);
+    expect(stats.localOnly).toBe(1);
+    expect(stats.githubOnly).toBe(1);
+    expect(stats.dirty).toBe(1);
+    expect(stats.unpushed).toBe(1);
+    expect(stats.unpulled).toBe(0);
+  });
+
+  test("handles empty repos", () => {
+    const stats = getUnifiedStats([]);
+
+    expect(stats.total).toBe(0);
+    expect(stats.both).toBe(0);
+    expect(stats.localOnly).toBe(0);
+    expect(stats.githubOnly).toBe(0);
+  });
+
+  test("counts multiple dirty repos", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "dirty1",
+        source: "local",
+        local: createMockProject({ name: "dirty1", status: { ...createMockProject().status!, isDirty: true } }),
+      }),
+      createMockUnifiedRepo({
+        name: "dirty2",
+        source: "local",
+        local: createMockProject({ name: "dirty2", status: { ...createMockProject().status!, isDirty: true } }),
+      }),
+      createMockUnifiedRepo({
+        name: "clean",
+        source: "local",
+        local: createMockProject({ name: "clean", status: { ...createMockProject().status!, isDirty: false } }),
+      }),
+    ];
+
+    const stats = getUnifiedStats(repos);
+
+    expect(stats.dirty).toBe(2);
+  });
+
+  test("counts repos that are both ahead and behind", () => {
+    const repos = [
+      createMockUnifiedRepo({
+        name: "ahead-repo",
+        source: "local",
+        local: createMockProject({ name: "ahead-repo", status: { ...createMockProject().status!, isAhead: true } }),
+      }),
+      createMockUnifiedRepo({
+        name: "behind-repo",
+        source: "local",
+        local: createMockProject({ name: "behind-repo", status: { ...createMockProject().status!, isBehind: true } }),
+      }),
+      createMockUnifiedRepo({
+        name: "synced-repo",
+        source: "local",
+        local: createMockProject({ name: "synced-repo", status: { ...createMockProject().status!, isAhead: false, isBehind: false } }),
+      }),
+    ];
+
+    const stats = getUnifiedStats(repos);
+
+    expect(stats.unpushed).toBe(1);
+    expect(stats.unpulled).toBe(1);
+  });
+});
+
+describe("cloneGitHubRepo", () => {
+  test("successfully clones a GitHub repo", async () => {
+    const mockGitService: GitService = {
+      clone: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "clone",
+        duration: 100
+      }),
+      isGitRepo: async () => true,
+      getGitRoot: async () => "/test/repo",
+      isSubmodule: async () => false,
+      getSubmoduleParent: async () => null,
+      getStatus: async () => ({
+        isDirty: false,
+        hasUnstagedChanges: false,
+        hasStagedChanges: false,
+        hasUntrackedFiles: false,
+        modifiedCount: 0,
+        stagedCount: 0,
+        untrackedCount: 0,
+        currentBranch: "main",
+        trackingBranch: null,
+        unpushedCommits: 0,
+        unpulledCommits: 0,
+        hasRemote: true,
+        remoteUrl: null,
+        lastLocalCommit: new Date(),
+        lastRemoteActivity: null,
+        hasCommits: true,
+        isAhead: false,
+        isBehind: false,
+        isOutOfSync: false,
+      }),
+      getStatusPorcelain: async () => "",
+      getCurrentBranch: async () => "main",
+      getTrackingBranch: async () => null,
+      countUnpushedCommits: async () => 0,
+      countUnpulledCommits: async () => 0,
+      getRemoteUrl: async () => null,
+      getLastCommitDate: async () => new Date(),
+      getRemoteLastCommitDate: async () => new Date(),
+      listSubmodules: async () => [],
+      init: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "init",
+        duration: 100
+      }),
+      pull: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "pull",
+        duration: 100
+      }),
+      push: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "push",
+        duration: 100
+      }),
+      fetch: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetch",
+        duration: 100
+      }),
+      fetchAll: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetchAll",
+        duration: 100
+      }),
+      addRemote: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "addRemote",
+        duration: 100
+      }),
+    };
+
+    const repo = createMockUnifiedRepo({ name: "test-repo", source: "github" });
+    const result = await cloneGitHubRepo(repo, "/tmp", true, mockGitService);
+
+    expect(result.success).toBe(true);
+    expect(result.path).toBe("/tmp/test-repo");
+  });
+
+  test("handles clone failure", async () => {
+    const mockGitService: GitService = {
+      clone: async () => ({ 
+        success: false, 
+        error: "Clone failed",
+        projectPath: "/tmp/test-repo",
+        operation: "clone",
+        duration: 100
+      }),
+      isGitRepo: async () => true,
+      getGitRoot: async () => "/test/repo",
+      isSubmodule: async () => false,
+      getSubmoduleParent: async () => null,
+      getStatus: async () => ({
+        isDirty: false,
+        hasUnstagedChanges: false,
+        hasStagedChanges: false,
+        hasUntrackedFiles: false,
+        modifiedCount: 0,
+        stagedCount: 0,
+        untrackedCount: 0,
+        currentBranch: "main",
+        trackingBranch: null,
+        unpushedCommits: 0,
+        unpulledCommits: 0,
+        hasRemote: true,
+        remoteUrl: null,
+        lastLocalCommit: new Date(),
+        lastRemoteActivity: null,
+        hasCommits: true,
+        isAhead: false,
+        isBehind: false,
+        isOutOfSync: false,
+      }),
+      getStatusPorcelain: async () => "",
+      getCurrentBranch: async () => "main",
+      getTrackingBranch: async () => null,
+      countUnpushedCommits: async () => 0,
+      countUnpulledCommits: async () => 0,
+      getRemoteUrl: async () => null,
+      getLastCommitDate: async () => new Date(),
+      getRemoteLastCommitDate: async () => new Date(),
+      listSubmodules: async () => [],
+      init: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "init",
+        duration: 100
+      }),
+      pull: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "pull",
+        duration: 100
+      }),
+      push: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "push",
+        duration: 100
+      }),
+      fetch: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetch",
+        duration: 100
+      }),
+      fetchAll: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetchAll",
+        duration: 100
+      }),
+      addRemote: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "addRemote",
+        duration: 100
+      }),
+    };
+
+    const repo = createMockUnifiedRepo({ name: "test-repo", source: "github" });
+    const result = await cloneGitHubRepo(repo, "/tmp", true, mockGitService);
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("Clone failed");
+  });
+
+  test("returns error when repo has no GitHub info", async () => {
+    const repo = createMockUnifiedRepo({ name: "test-repo", source: "local", github: null });
+    const result = await cloneGitHubRepo(repo, "/tmp");
+
+    expect(result.success).toBe(false);
+    expect(result.error).toBe("No GitHub info available for this repo");
+  });
+
+  test("uses HTTPS URL when useSSH is false", async () => {
+    const mockGitService: GitService = {
+      clone: async (url: string, targetDir: string) => {
+        // Verify HTTPS URL is used
+        expect(url).toBe("https://github.com/user/test-repo.git");
+        return { 
+          success: true,
+          projectPath: targetDir,
+          operation: "clone",
+          duration: 100
+        };
+      },
+      isGitRepo: async () => true,
+      getGitRoot: async () => "/test/repo",
+      isSubmodule: async () => false,
+      getSubmoduleParent: async () => null,
+      getStatus: async () => ({
+        isDirty: false,
+        hasUnstagedChanges: false,
+        hasStagedChanges: false,
+        hasUntrackedFiles: false,
+        modifiedCount: 0,
+        stagedCount: 0,
+        untrackedCount: 0,
+        currentBranch: "main",
+        trackingBranch: null,
+        unpushedCommits: 0,
+        unpulledCommits: 0,
+        hasRemote: true,
+        remoteUrl: null,
+        lastLocalCommit: new Date(),
+        lastRemoteActivity: null,
+        hasCommits: true,
+        isAhead: false,
+        isBehind: false,
+        isOutOfSync: false,
+      }),
+      getStatusPorcelain: async () => "",
+      getCurrentBranch: async () => "main",
+      getTrackingBranch: async () => null,
+      countUnpushedCommits: async () => 0,
+      countUnpulledCommits: async () => 0,
+      getRemoteUrl: async () => null,
+      getLastCommitDate: async () => new Date(),
+      getRemoteLastCommitDate: async () => new Date(),
+      listSubmodules: async () => [],
+      init: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "init",
+        duration: 100
+      }),
+      pull: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "pull",
+        duration: 100
+      }),
+      push: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "push",
+        duration: 100
+      }),
+      fetch: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetch",
+        duration: 100
+      }),
+      fetchAll: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetchAll",
+        duration: 100
+      }),
+      addRemote: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "addRemote",
+        duration: 100
+      }),
+    };
+
+    const repo = createMockUnifiedRepo({ name: "test-repo", source: "github" });
+    await cloneGitHubRepo(repo, "/tmp", false, mockGitService);
+  });
+
+  test("uses SSH URL when useSSH is true", async () => {
+    const mockGitService: GitService = {
+      clone: async (url: string, targetDir: string) => {
+        // Verify SSH URL is used
+        expect(url).toBe("git@github.com:user/test-repo.git");
+        return { 
+          success: true,
+          projectPath: targetDir,
+          operation: "clone",
+          duration: 100
+        };
+      },
+      isGitRepo: async () => true,
+      getGitRoot: async () => "/test/repo",
+      isSubmodule: async () => false,
+      getSubmoduleParent: async () => null,
+      getStatus: async () => ({
+        isDirty: false,
+        hasUnstagedChanges: false,
+        hasStagedChanges: false,
+        hasUntrackedFiles: false,
+        modifiedCount: 0,
+        stagedCount: 0,
+        untrackedCount: 0,
+        currentBranch: "main",
+        trackingBranch: null,
+        unpushedCommits: 0,
+        unpulledCommits: 0,
+        hasRemote: true,
+        remoteUrl: null,
+        lastLocalCommit: new Date(),
+        lastRemoteActivity: null,
+        hasCommits: true,
+        isAhead: false,
+        isBehind: false,
+        isOutOfSync: false,
+      }),
+      getStatusPorcelain: async () => "",
+      getCurrentBranch: async () => "main",
+      getTrackingBranch: async () => null,
+      countUnpushedCommits: async () => 0,
+      countUnpulledCommits: async () => 0,
+      getRemoteUrl: async () => null,
+      getLastCommitDate: async () => new Date(),
+      getRemoteLastCommitDate: async () => new Date(),
+      listSubmodules: async () => [],
+      init: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "init",
+        duration: 100
+      }),
+      pull: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "pull",
+        duration: 100
+      }),
+      push: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "push",
+        duration: 100
+      }),
+      fetch: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetch",
+        duration: 100
+      }),
+      fetchAll: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "fetchAll",
+        duration: 100
+      }),
+      addRemote: async () => ({ 
+        success: true,
+        projectPath: "/tmp/test-repo",
+        operation: "addRemote",
+        duration: 100
+      }),
+    };
+
+    const repo = createMockUnifiedRepo({ name: "test-repo", source: "github" });
+    await cloneGitHubRepo(repo, "/tmp", true, mockGitService);
+  });
+});