gitforest 0.1.0

package/test/unit/hooks/useProjects.test.tsx

@@ -0,0 +1,186 @@
+/**
+ * Tests for useProjects hook
+ *
+ * These tests focus on testing the helper functions (sortProjects, filterProjects)
+ * that are used by the hook, since they can be tested in isolation.
+ * 
+ * The hook itself requires rendering in a React component context,
+ * which is done separately in integration tests.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { sortProjects, filterProjects } from "../../../src/utils/project-utils.ts";
+import {
+  createMockProject,
+  createDirtyProject,
+  createAheadProject,
+  createNonGitProject,
+} from "../mocks/index.ts";
+
+describe("useProjects helpers", () => {
+  describe("sortProjects", () => {
+    test("sorts by name ascending", () => {
+      const projects = [
+        createMockProject({ name: "zebra" }),
+        createMockProject({ name: "alpha" }),
+        createMockProject({ name: "mango" }),
+      ];
+
+      const sorted = sortProjects(projects, "name", "asc");
+
+      expect(sorted[0]?.name).toBe("alpha");
+      expect(sorted[1]?.name).toBe("mango");
+      expect(sorted[2]?.name).toBe("zebra");
+    });
+
+    test("sorts by name descending", () => {
+      const projects = [
+        createMockProject({ name: "alpha" }),
+        createMockProject({ name: "zebra" }),
+        createMockProject({ name: "mango" }),
+      ];
+
+      const sorted = sortProjects(projects, "name", "desc");
+
+      expect(sorted[0]?.name).toBe("zebra");
+      expect(sorted[1]?.name).toBe("mango");
+      expect(sorted[2]?.name).toBe("alpha");
+    });
+
+    test("sorts by status (dirty repos first)", () => {
+      const projects = [
+        createMockProject({ name: "clean" }),
+        createDirtyProject("dirty"),
+        createAheadProject("ahead"),
+      ];
+
+      const sorted = sortProjects(projects, "status", "desc");
+
+      // Dirty should come first, then ahead, then clean
+      expect(sorted[0]?.name).toBe("dirty");
+    });
+
+    test("sorts by status (ahead repos before clean)", () => {
+      const projects = [
+        createMockProject({ name: "clean" }),
+        createAheadProject("ahead"),
+      ];
+
+      const sorted = sortProjects(projects, "status", "desc");
+
+      expect(sorted[0]?.name).toBe("ahead");
+      expect(sorted[1]?.name).toBe("clean");
+    });
+
+    test("non-git projects sort last by status", () => {
+      const projects = [
+        createNonGitProject("non-git"),
+        createMockProject({ name: "git" }),
+        createDirtyProject("dirty"),
+      ];
+
+      const sorted = sortProjects(projects, "status", "desc");
+
+      // Non-git should be last
+      expect(sorted[sorted.length - 1]?.name).toBe("non-git");
+    });
+
+    test("sorts by lastActivity with recent first (desc)", () => {
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const lastWeek = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+      const projects = [
+        createMockProject({ name: "old", status: { ...createMockProject().status!, lastLocalCommit: lastWeek } }),
+        createMockProject({ name: "recent", status: { ...createMockProject().status!, lastLocalCommit: now } }),
+        createMockProject({ name: "yesterday", status: { ...createMockProject().status!, lastLocalCommit: yesterday } }),
+      ];
+
+      const sorted = sortProjects(projects, "lastActivity", "desc");
+
+      expect(sorted[0]?.name).toBe("recent");
+      expect(sorted[1]?.name).toBe("yesterday");
+      expect(sorted[2]?.name).toBe("old");
+    });
+
+    test("sorts by lastActivity with oldest first (asc)", () => {
+      const now = new Date();
+      const yesterday = new Date(now.getTime() - 24 * 60 * 60 * 1000);
+      const lastWeek = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+
+      const projects = [
+        createMockProject({ name: "recent", status: { ...createMockProject().status!, lastLocalCommit: now } }),
+        createMockProject({ name: "old", status: { ...createMockProject().status!, lastLocalCommit: lastWeek } }),
+        createMockProject({ name: "yesterday", status: { ...createMockProject().status!, lastLocalCommit: yesterday } }),
+      ];
+
+      const sorted = sortProjects(projects, "lastActivity", "asc");
+
+      expect(sorted[0]?.name).toBe("old");
+      expect(sorted[1]?.name).toBe("yesterday");
+      expect(sorted[2]?.name).toBe("recent");
+    });
+  });
+
+  describe("filterProjects", () => {
+    test("filters by name", () => {
+      const projects = [
+        createMockProject({ name: "my-project" }),
+        createMockProject({ name: "other-project" }),
+        createMockProject({ name: "my-app" }),
+      ];
+
+      const filtered = filterProjects(projects, "my");
+
+      expect(filtered).toHaveLength(2);
+      expect(filtered.map((p) => p.name)).toContain("my-project");
+      expect(filtered.map((p) => p.name)).toContain("my-app");
+    });
+
+    test("filters by path", () => {
+      const projects = [
+        createMockProject({ name: "project1", path: "/home/user/code/project1" }),
+        createMockProject({ name: "project2", path: "/home/user/work/project2" }),
+        createMockProject({ name: "project3", path: "/home/user/code/project3" }),
+      ];
+
+      const filtered = filterProjects(projects, "code");
+
+      expect(filtered).toHaveLength(2);
+    });
+
+    test("filters case-insensitively", () => {
+      const projects = [
+        createMockProject({ name: "MyProject" }),
+        createMockProject({ name: "other" }),
+      ];
+
+      const filtered = filterProjects(projects, "myproject");
+
+      expect(filtered).toHaveLength(1);
+      expect(filtered[0]?.name).toBe("MyProject");
+    });
+
+    test("returns all projects when filter is empty", () => {
+      const projects = [
+        createMockProject({ name: "project1" }),
+        createMockProject({ name: "project2" }),
+      ];
+
+      const filtered = filterProjects(projects, "");
+
+      expect(filtered).toHaveLength(2);
+    });
+
+    test("returns empty array when no matches", () => {
+      const projects = [
+        createMockProject({ name: "project1" }),
+        createMockProject({ name: "project2" }),
+      ];
+
+      const filtered = filterProjects(projects, "nonexistent");
+
+      expect(filtered).toHaveLength(0);
+    });
+  });
+});

package/test/unit/hooks/useUnifiedRepos-simple.test.tsx

@@ -0,0 +1,115 @@
+/**
+ * Simple tests for useUnifiedRepos related functionality
+ * 
+ * These tests focus on helper functions that can be tested in isolation.
+ * The actual hook behavior is tested in integration tests.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { createUnifiedView } from "../../../src/github/unified.ts";
+import type { Project, GitHubRepoInfo } from "../../../src/types/index";
+
+// Test helpers
+function createMockProject(name: string, remoteUrl?: string): Project {
+  return {
+    id: `project-${name}`,
+    name,
+    path: `/test/${name}`,
+    type: "git",
+    lastScanned: new Date(),
+    lastModified: new Date(),
+    status: {
+      hasUnstagedChanges: false,
+      hasStagedChanges: false,
+      hasUntrackedFiles: false,
+      modifiedCount: 0,
+      stagedCount: 0,
+      untrackedCount: 0,
+      currentBranch: "main",
+      trackingBranch: "origin/main",
+      unpushedCommits: 0,
+      unpulledCommits: 0,
+      hasRemote: true,
+      remoteUrl: remoteUrl ?? `git@github.com:user/${name}.git`,
+      lastLocalCommit: new Date(),
+      lastRemoteActivity: new Date(),
+      hasCommits: true,
+      isDirty: false,
+      isAhead: false,
+      isBehind: false,
+      isOutOfSync: false,
+    },
+    projectMarker: null,
+    submodule: null,
+  };
+}
+
+function createMockGitHubRepo(name: string, owner = "user"): GitHubRepoInfo {
+  return {
+    name,
+    fullName: `${owner}/${name}`,
+    owner,
+    description: `Test repo ${name}`,
+    htmlUrl: `https://github.com/${owner}/${name}`,
+    sshUrl: `git@github.com:${owner}/${name}.git`,
+    cloneUrl: `https://github.com/${owner}/${name}.git`,
+    isPrivate: false,
+    isArchived: false,
+    isFork: false,
+    pushedAt: new Date(),
+    updatedAt: new Date(),
+    defaultBranch: "main",
+    language: "TypeScript",
+    size: 1024,
+    stargazersCount: 10,
+    forksCount: 5,
+    openIssuesCount: 2,
+    watchersCount: 15,
+    topics: ["typescript", "test"],
+    license: "MIT",
+    hasIssues: true,
+    hasWiki: true,
+    hasDiscussions: false,
+  };
+}
+
+describe("useUnifiedRepos - Simple", () => {
+  describe("createUnifiedView", () => {
+    test("creates unified view from projects and github repos", () => {
+      const projects = [createMockProject("test-repo")];
+      const githubRepos = [createMockGitHubRepo("test-repo")];
+
+      const unified = createUnifiedView(projects, githubRepos);
+
+      expect(unified).toHaveLength(1);
+      expect(unified[0]?.name).toBe("test-repo");
+      expect(unified[0]?.isCloned).toBe(true);
+      expect(unified[0]?.isOnGitHub).toBe(true);
+    });
+
+    test("handles empty inputs", () => {
+      const unified = createUnifiedView([], []);
+      expect(unified).toHaveLength(0);
+    });
+
+    test("local only project has isOnGitHub false", () => {
+      const projects = [createMockProject("local-only")];
+      
+      const unified = createUnifiedView(projects, []);
+      
+      expect(unified).toHaveLength(1);
+      expect(unified[0]?.isCloned).toBe(true);
+      expect(unified[0]?.isOnGitHub).toBe(false);
+    });
+
+    test("github only repo has isCloned false", () => {
+      const githubRepos = [createMockGitHubRepo("github-only")];
+      
+      const unified = createUnifiedView([], githubRepos);
+      
+      expect(unified).toHaveLength(1);
+      expect(unified[0]?.isCloned).toBe(false);
+      expect(unified[0]?.isOnGitHub).toBe(true);
+    });
+  });
+});

package/test/unit/hooks/useUnifiedRepos.test.tsx

@@ -0,0 +1,177 @@
+/**
+ * Tests for useUnifiedRepos hook
+ * 
+ * These tests focus on testing the createUnifiedView helper function
+ * which can be tested in isolation without React rendering.
+ * 
+ * The hook itself requires rendering in a React component context,
+ * which is done separately in integration tests.
+ */
+
+import { describe, test, expect } from "bun:test";
+import { createUnifiedView } from "../../../src/github/unified.ts";
+import type { Project, GitHubRepoInfo } from "../../../src/types/index";
+
+// Test helpers
+function createMockProject(name: string, remoteUrl?: string): Project {
+  return {
+    id: `project-${name}`,
+    name,
+    path: `/test/${name}`,
+    type: "git",
+    lastScanned: new Date(),
+    lastModified: new Date(),
+    status: {
+      hasUnstagedChanges: false,
+      hasStagedChanges: false,
+      hasUntrackedFiles: false,
+      modifiedCount: 0,
+      stagedCount: 0,
+      untrackedCount: 0,
+      currentBranch: "main",
+      trackingBranch: "origin/main",
+      unpushedCommits: 0,
+      unpulledCommits: 0,
+      hasRemote: true,
+      remoteUrl: remoteUrl ?? `git@github.com:user/${name}.git`,
+      lastLocalCommit: new Date(),
+      lastRemoteActivity: new Date(),
+      hasCommits: true,
+      isDirty: false,
+      isAhead: false,
+      isBehind: false,
+      isOutOfSync: false,
+    },
+    projectMarker: null,
+    submodule: null,
+  };
+}
+
+function createMockGitHubRepo(name: string, owner = "user"): GitHubRepoInfo {
+  return {
+    name,
+    fullName: `${owner}/${name}`,
+    owner,
+    description: `Test repo ${name}`,
+    htmlUrl: `https://github.com/${owner}/${name}`,
+    sshUrl: `git@github.com:${owner}/${name}.git`,
+    cloneUrl: `https://github.com/${owner}/${name}.git`,
+    isPrivate: false,
+    isArchived: false,
+    isFork: false,
+    pushedAt: new Date(),
+    updatedAt: new Date(),
+    defaultBranch: "main",
+    language: "TypeScript",
+    size: 1024,
+    stargazersCount: 10,
+    forksCount: 5,
+    openIssuesCount: 2,
+    watchersCount: 15,
+    topics: ["typescript", "test"],
+    license: "MIT",
+    hasIssues: true,
+    hasWiki: true,
+    hasDiscussions: false,
+  };
+}
+
+describe("createUnifiedView", () => {
+  test("matches local projects with GitHub repos", () => {
+    const projects = [createMockProject("my-repo")];
+    const githubRepos = [createMockGitHubRepo("my-repo")];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.name).toBe("my-repo");
+    expect(unified[0]?.local).toBeDefined();
+    expect(unified[0]?.github).toBeDefined();
+  });
+
+  test("identifies local-only projects", () => {
+    const projects = [createMockProject("local-only")];
+    const githubRepos: GitHubRepoInfo[] = [];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.name).toBe("local-only");
+    expect(unified[0]?.local).toBeDefined();
+    expect(unified[0]?.github).toBeNull();
+  });
+
+  test("identifies GitHub-only repos", () => {
+    const projects: Project[] = [];
+    const githubRepos = [createMockGitHubRepo("github-only")];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.name).toBe("github-only");
+    expect(unified[0]?.local).toBeNull();
+    expect(unified[0]?.github).toBeDefined();
+  });
+
+  test("handles mixed projects correctly", () => {
+    const projects = [
+      createMockProject("matched"),
+      createMockProject("local-only"),
+    ];
+    const githubRepos = [
+      createMockGitHubRepo("matched"),
+      createMockGitHubRepo("github-only"),
+    ];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    expect(unified).toHaveLength(3);
+    
+    const matched = unified.find(u => u.name === "matched");
+    expect(matched?.local).toBeDefined();
+    expect(matched?.github).toBeDefined();
+    
+    const localOnly = unified.find(u => u.name === "local-only");
+    expect(localOnly?.local).toBeDefined();
+    expect(localOnly?.github).toBeNull();
+    
+    const githubOnly = unified.find(u => u.name === "github-only");
+    expect(githubOnly?.local).toBeNull();
+    expect(githubOnly?.github).toBeDefined();
+  });
+
+  test("matches HTTPS remote URLs", () => {
+    const projects = [createMockProject("https-repo", "https://github.com/user/https-repo.git")];
+    const githubRepos = [createMockGitHubRepo("https-repo")];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    expect(unified).toHaveLength(1);
+    expect(unified[0]?.local).toBeDefined();
+    expect(unified[0]?.github).toBeDefined();
+  });
+
+  test("handles case-insensitive matching", () => {
+    const projects = [createMockProject("MyRepo", "git@github.com:User/MyRepo.git")];
+    const githubRepos = [createMockGitHubRepo("myrepo", "user")];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    // The matching should work regardless of case
+    expect(unified.length).toBeGreaterThanOrEqual(1);
+  });
+
+  test("handles multiple GitHub repos with same name but different owners", () => {
+    const projects: Project[] = [];
+    const githubRepos = [
+      createMockGitHubRepo("common-name", "owner1"),
+      createMockGitHubRepo("common-name", "owner2"),
+    ];
+
+    const unified = createUnifiedView(projects, githubRepos);
+
+    expect(unified).toHaveLength(2);
+    expect(unified[0]?.github?.owner).toBe("owner1");
+    expect(unified[1]?.github?.owner).toBe("owner2");
+  });
+});

package/test/unit/mocks/config.ts

@@ -0,0 +1,109 @@
+/**
+ * Mock factory for configuration objects
+ * Provides configurable mocks for GitforestConfig and related types
+ */
+
+import type { 
+  GitforestConfig, 
+  DirectoryConfig, 
+  CommandConfig 
+} from "../../../src/types/index";
+import { GitforestConfigSchema } from "../../../src/types/index";
+
+/**
+ * Create a mock directory config
+ */
+export function createMockDirectoryConfig(overrides?: Partial<DirectoryConfig>): DirectoryConfig {
+  return {
+    path: overrides?.path ?? "/test/projects",
+    maxDepth: overrides?.maxDepth ?? 2,
+    label: overrides?.label ?? "Test Projects",
+    ...overrides,
+  };
+}
+
+/**
+ * Create a mock command config
+ */
+export function createMockCommandConfig(overrides?: Partial<CommandConfig>): CommandConfig {
+  const key = overrides?.key ?? "t";
+  
+  const config: CommandConfig = {
+    name: overrides?.name ?? "Test Command",
+    key,
+    command: overrides?.command ?? "echo 'test command'",
+    confirm: overrides?.confirm ?? false,
+    background: overrides?.background ?? false,
+  };
+
+  // Merge overrides to ensure we respect any provided values
+  return { ...config, ...overrides };
+}
+
+/**
+ * Create a mock GitforestConfig
+ */
+export function createMockConfig(overrides?: Partial<GitforestConfig>): GitforestConfig {
+  const baseConfig: GitforestConfig = {
+    directories: overrides?.directories ?? [
+      createMockDirectoryConfig(),
+    ],
+    scan: overrides?.scan ?? {
+      ignore: ["node_modules", ".git", "vendor", "__pycache__", "target", "dist", "build"],
+      includeHidden: false,
+      concurrency: 5,
+    },
+    github: overrides?.github ?? {
+      defaultVisibility: "private",
+    },
+    display: overrides?.display ?? {
+      showSubmodules: true,
+      showNonGitProjects: true,
+      sortBy: "status",
+      sortDirection: "desc",
+    },
+    cache: overrides?.cache ?? {
+      ttlSeconds: 300,
+      githubTtlSeconds: 600,
+      enableBackgroundRefresh: true,
+      backgroundRefreshIntervalSeconds: 300,
+    },
+    commands: overrides?.commands ?? [],
+  };
+
+  // Validate the config against the schema
+  const validated = GitforestConfigSchema.parse({ ...baseConfig, ...overrides });
+  return validated;
+}
+
+/**
+ * Create a minimal config with just one directory
+ */
+export function createMinimalConfig(path?: string): GitforestConfig {
+  return createMockConfig({
+    directories: [
+      createMockDirectoryConfig({ path: path ?? "/test/projects" }),
+    ],
+  });
+}
+
+/**
+ * Create a config with custom commands
+ */
+export function createConfigWithCommands(commands: CommandConfig[]): GitforestConfig {
+  return createMockConfig({ commands });
+}
+
+/**
+ * Create a config with multiple directories
+ */
+export function createMultiDirectoryConfig(paths: string[]): GitforestConfig {
+  return createMockConfig({
+    directories: paths.map((path, index) => 
+      createMockDirectoryConfig({ 
+        path,
+        label: `Directory ${index + 1}`
+      })
+    ),
+  });
+}