gitforest 0.1.0 → 1.1.0

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

@@ -1,1201 +0,0 @@
-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);
-  });
-});