gitforest 0.1.0 → 1.0.0

package/test/unit/git/status.test.ts

@@ -1,219 +0,0 @@
-/**
- * Tests for git status module
- */
-
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-import { getGitStatus, getQuickStatus, parseGitStatusPorcelain } from "../../../src/git/status.ts";
-import { createTempDir, cleanupTempDir, createMockGitRepo } from "../fixtures/setup.ts";
-import { writeFile } from "fs/promises";
-import { join } from "path";
-import { $ } from "bun";
-
-describe("Git Status", () => {
-  let tempDir: string;
-
-  beforeEach(() => {
-    tempDir = createTempDir("git-status");
-  });
-
-  afterEach(() => {
-    cleanupTempDir(tempDir);
-  });
-
-  describe("parseGitStatusPorcelain", () => {
-    test("parses clean status", () => {
-      const output = "";
-      
-      const result = parseGitStatusPorcelain(output);
-      
-      expect(result).toEqual({
-        modifiedCount: 0,
-        stagedCount: 0,
-        untrackedCount: 0,
-        hasUnstagedChanges: false,
-        hasStagedChanges: false,
-        hasUntrackedFiles: false,
-      });
-    });
-
-    test("parses modified files", () => {
-      const output = " M file1.txt\n M file2.txt\n?? file3.txt";
-      
-      const result = parseGitStatusPorcelain(output);
-      
-      expect(result).toEqual({
-        modifiedCount: 2,
-        stagedCount: 0,
-        untrackedCount: 1,
-        hasUnstagedChanges: true,
-        hasStagedChanges: false,
-        hasUntrackedFiles: true,
-      });
-    });
-
-    test("parses staged files", () => {
-      const output = "A file1.txt\nA file2.txt\n M file3.txt";
-      
-      const result = parseGitStatusPorcelain(output);
-      
-      expect(result).toEqual({
-        modifiedCount: 1,
-        stagedCount: 2,
-        untrackedCount: 0,
-        hasUnstagedChanges: true,
-        hasStagedChanges: true,
-        hasUntrackedFiles: false,
-      });
-    });
-
-    test("handles complex status", () => {
-      const output = `MM src/app.ts
-A src/new.ts
-?? src/temp.txt
- D src/old.ts
-`;
-      
-      const result = parseGitStatusPorcelain(output);
-      
-      expect(result).toEqual({
-        modifiedCount: 2,
-        stagedCount: 2,
-        untrackedCount: 1,
-        hasUnstagedChanges: true,
-        hasStagedChanges: true,
-        hasUntrackedFiles: true,
-      });
-    });
-
-    test("handles empty lines", () => {
-      const output = "\n\n\n";
-      
-      const result = parseGitStatusPorcelain(output);
-      
-      expect(result).toEqual({
-        modifiedCount: 0,
-        stagedCount: 0,
-        untrackedCount: 0,
-        hasUnstagedChanges: false,
-        hasStagedChanges: false,
-        hasUntrackedFiles: false,
-      });
-    });
-  });
-
-  describe("getQuickStatus", () => {
-    test("returns clean status for clean repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "clean");
-      
-      const result = await getQuickStatus(repoPath);
-      
-      expect(result.isDirty).toBe(false);
-      expect(result.hasRemote).toBe(false);
-    });
-
-    test("detects dirty repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "dirty");
-      
-      // Create untracked file
-      await writeFile(join(repoPath, "untracked.txt"), "content");
-      
-      const result = await getQuickStatus(repoPath);
-      
-      expect(result.isDirty).toBe(true);
-      expect(result.hasRemote).toBe(false);
-    });
-
-    test("handles repo with remote", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "with-remote");
-      
-      // Add a remote
-      await writeFile(join(repoPath, "test.txt"), "content");
-      
-      const result = await getQuickStatus(repoPath);
-      
-      expect(result.isDirty).toBe(true);
-      expect(result.hasRemote).toBe(false); // No actual remote added
-    });
-  });
-
-  describe("getGitStatus", () => {
-    test("returns status for clean repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "clean-status");
-      
-      const status = await getGitStatus(repoPath);
-      
-      expect(status.hasUnstagedChanges).toBe(false);
-      expect(status.hasStagedChanges).toBe(false);
-      expect(status.hasUntrackedFiles).toBe(false);
-      expect(status.modifiedCount).toBe(0);
-      expect(status.stagedCount).toBe(0);
-      expect(status.untrackedCount).toBe(0);
-      expect(status.currentBranch).toBe("master"); // Git default is master
-      expect(status.trackingBranch).toBeNull();
-      expect(status.unpushedCommits).toBe(0);
-      expect(status.unpulledCommits).toBe(0);
-      expect(status.hasRemote).toBe(false);
-      expect(status.remoteUrl).toBeNull();
-      expect(status.hasCommits).toBe(true);
-      expect(status.isDirty).toBe(false);
-      expect(status.isAhead).toBe(false);
-      expect(status.isBehind).toBe(false);
-      expect(status.isOutOfSync).toBe(false);
-      expect(status.lastLocalCommit).toBeInstanceOf(Date);
-      expect(status.lastRemoteActivity).toBeNull();
-    });
-
-    test("returns status for dirty repo", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "dirty-status");
-      
-      // Create initial file and commit it
-      await writeFile(join(repoPath, "base.txt"), "base content");
-      await $`git -C ${repoPath} add base.txt`.quiet();
-      await $`git -C ${repoPath} commit -m "Initial commit"`.quiet();
-      
-      // Create various changes
-      await writeFile(join(repoPath, "modified.txt"), "content");
-      await writeFile(join(repoPath, "staged.txt"), "content");
-      await writeFile(join(repoPath, "untracked.txt"), "content");
-      
-      // Stage one file
-      await $`git -C ${repoPath} add staged.txt`.quiet();
-      
-      const status = await getGitStatus(repoPath);
-      
-      expect(status.hasStagedChanges).toBe(true); // staged.txt is staged
-      expect(status.hasUntrackedFiles).toBe(true); // untracked.txt is untracked
-      expect(status.stagedCount).toBe(1); // staged.txt
-      expect(status.untrackedCount).toBe(2); // modified.txt and untracked.txt
-      expect(status.isDirty).toBe(true);
-    });
-
-    test("handles repo with tracking branch", async () => {
-      const repoPath = await createMockGitRepo(tempDir, "tracking-status");
-      
-      // Add a remote to simulate tracking
-      await writeFile(join(repoPath, "test.txt"), "content");
-      
-      const status = await getGitStatus(repoPath);
-      
-      // Should have tracking branch if remote exists
-      // Note: This test may need adjustment based on actual git setup
-      expect(status.currentBranch).toBeTruthy();
-      expect(status.hasCommits).toBe(true);
-      expect(status.lastLocalCommit).toBeInstanceOf(Date);
-    });
-
-    test("handles empty repo", async () => {
-      // Create empty repo without commits
-      const emptyRepoPath = join(tempDir, "empty");
-      await $`mkdir -p ${emptyRepoPath}`.quiet();
-      await writeFile(join(emptyRepoPath, "test.txt"), "content");
-      
-      const status = await getGitStatus(emptyRepoPath);
-      
-      // Should handle gracefully
-      expect(status.currentBranch).toBeTruthy();
-      expect(status.hasCommits).toBe(false);
-    });
-  });
-});

package/test/unit/github/auth.test.ts

@@ -1,317 +0,0 @@
-import { describe, test, expect, beforeEach, afterEach } from "bun:test";
-
-import {
-  getToken,
-  setToken,
-  getTokenAsync,
-  isAuthenticated,
-  isAuthenticatedAsync,
-  isGhInstalled,
-  logout,
-  getAuthStatus,
-  ensureAuthenticated,
-} from "../../../src/github/auth.ts";
-
-describe("GitHub Auth Module", () => {
-  // Store original env
-  const originalGithubToken = process.env.GITHUB_TOKEN;
-  const originalGhToken = process.env.GH_TOKEN;
-
-  beforeEach(() => {
-    // Clean env
-    delete process.env.GITHUB_TOKEN;
-    delete process.env.GH_TOKEN;
-    process.env.GITTY_IGNORE_GH = "true";
-  });
-
-  afterEach(() => {
-    // Restore env
-    if (originalGithubToken !== undefined) {
-      process.env.GITHUB_TOKEN = originalGithubToken;
-    } else {
-      delete process.env.GITHUB_TOKEN;
-    }
-    if (originalGhToken !== undefined) {
-      process.env.GH_TOKEN = originalGhToken;
-    } else {
-      delete process.env.GH_TOKEN;
-    }
-  });
-
-  describe("getToken (sync)", () => {
-    test("returns GITHUB_TOKEN from environment", () => {
-      process.env.GITHUB_TOKEN = "ghp_test123456789012345678901234567890ab";
-      expect(getToken()).toBe("ghp_test123456789012345678901234567890ab");
-    });
-
-    test("treats empty env token as missing", () => {
-      process.env.GITHUB_TOKEN = "";
-      expect(getToken()).toBeNull();
-    });
-
-    test("returns GH_TOKEN from environment if GITHUB_TOKEN not set", () => {
-      process.env.GH_TOKEN = "ghp_test123456789012345678901234567890cd";
-      expect(getToken()).toBe("ghp_test123456789012345678901234567890cd");
-    });
-
-    test("prefers GITHUB_TOKEN over GH_TOKEN", () => {
-      process.env.GITHUB_TOKEN = "ghp_github_token";
-      process.env.GH_TOKEN = "ghp_gh_token";
-      expect(getToken()).toBe("ghp_github_token");
-    });
-
-    test("returns null when no token in env", () => {
-      // Synchronous getToken only checks env, not gh CLI
-      expect(getToken()).toBeNull();
-    });
-  });
-
-  describe("setToken", () => {
-    test("sets GITHUB_TOKEN in environment", () => {
-      setToken("ghp_my_new_token");
-      expect(process.env.GITHUB_TOKEN).toBe("ghp_my_new_token");
-    });
-
-    test("token is retrievable via getToken after setting", () => {
-      setToken("ghp_set_and_get_token");
-      expect(getToken()).toBe("ghp_set_and_get_token");
-    });
-
-    test("overwrites existing token", () => {
-      process.env.GITHUB_TOKEN = "ghp_old_token";
-      setToken("ghp_new_token");
-      expect(getToken()).toBe("ghp_new_token");
-    });
-  });
-
-  describe("getTokenAsync", () => {
-    test("returns GITHUB_TOKEN from environment", async () => {
-      process.env.GITHUB_TOKEN = "ghp_async_test_token";
-      const token = await getTokenAsync();
-      expect(token).toBe("ghp_async_test_token");
-    });
-
-    test("treats empty env token as missing (async)", async () => {
-      process.env.GITHUB_TOKEN = "";
-      const token = await getTokenAsync();
-      expect(token).toBeNull();
-    });
-
-    test("returns GH_TOKEN if GITHUB_TOKEN not set", async () => {
-      process.env.GH_TOKEN = "ghp_async_gh_token";
-      const token = await getTokenAsync();
-      expect(token).toBe("ghp_async_gh_token");
-    });
-
-    test("prefers env token over gh CLI", async () => {
-      process.env.GITHUB_TOKEN = "ghp_env_token";
-      const token = await getTokenAsync();
-      // Should return env token without calling gh CLI
-      expect(token).toBe("ghp_env_token");
-    });
-  });
-
-  describe("isAuthenticated (sync)", () => {
-    test("returns true when GITHUB_TOKEN is set", () => {
-      process.env.GITHUB_TOKEN = "ghp_testtoken";
-      expect(isAuthenticated()).toBe(true);
-    });
-
-    test("returns true when GH_TOKEN is set", () => {
-      process.env.GH_TOKEN = "ghp_testtoken";
-      expect(isAuthenticated()).toBe(true);
-    });
-
-    test("returns false when no token in env", () => {
-      expect(isAuthenticated()).toBe(false);
-    });
-  });
-
-  describe("isAuthenticatedAsync", () => {
-    test("returns true when GITHUB_TOKEN is set", async () => {
-      process.env.GITHUB_TOKEN = "ghp_testtoken";
-      expect(await isAuthenticatedAsync()).toBe(true);
-    });
-
-    test("returns true when GH_TOKEN is set", async () => {
-      process.env.GH_TOKEN = "ghp_testtoken";
-      expect(await isAuthenticatedAsync()).toBe(true);
-    });
-  });
-
-  describe("isGhInstalled", () => {
-    test("returns boolean", async () => {
-      const result = await isGhInstalled();
-      expect(typeof result).toBe("boolean");
-    });
-
-    // Note: This test depends on whether gh is installed on the test machine
-    // In CI, gh might not be installed, so we just check it doesn't throw
-    test("does not throw", async () => {
-      const result = await isGhInstalled();
-      expect(typeof result).toBe("boolean");
-    });
-  });
-
-  describe("logout", () => {
-    test("clears GITHUB_TOKEN from environment", async () => {
-      process.env.GITHUB_TOKEN = "ghp_testtoken";
-      await logout();
-      expect(process.env.GITHUB_TOKEN).toBeUndefined();
-    });
-
-    test("clears GH_TOKEN from environment", async () => {
-      process.env.GH_TOKEN = "ghp_testtoken";
-      await logout();
-      expect(process.env.GH_TOKEN).toBeUndefined();
-    });
-
-    test("returns success even when not logged in", async () => {
-      const result = await logout();
-      expect(result.success).toBe(true);
-    });
-  });
-
-  describe("getAuthStatus", () => {
-    test("returns authenticated: false when no token", async () => {
-      const status = await getAuthStatus();
-      // This might return true if gh CLI is logged in on the test machine
-      // So we just check it returns a valid structure
-      expect(status).toHaveProperty("authenticated");
-      expect(typeof status.authenticated).toBe("boolean");
-    });
-
-    test("returns source: env when using env token", async () => {
-      // Only test this if we have a valid token that works
-      const existingToken = originalGithubToken ?? originalGhToken;
-      if (existingToken) {
-        process.env.GITHUB_TOKEN = existingToken;
-        const status = await getAuthStatus();
-        if (status.authenticated) {
-          expect(status.source).toBe("env");
-        }
-      }
-    });
-  });
-
-  describe("ensureAuthenticated", () => {
-    test("returns token when GITHUB_TOKEN is set", async () => {
-      process.env.GITHUB_TOKEN = "ghp_ensure_test_token";
-      const token = await ensureAuthenticated(true); // silent mode
-      expect(token).toBe("ghp_ensure_test_token");
-    });
-
-    test("returns null in silent mode when no token", async () => {
-      const token = await ensureAuthenticated(true);
-      // Will be null if no env token and gh CLI not logged in
-      // Just check it doesn't throw
-      expect(token === null || typeof token === "string").toBe(true);
-    });
-  });
-});
-
-describe("Token validation patterns", () => {
-  // Test the token patterns used in the service
-  const patterns = [
-    /^ghp_[a-zA-Z0-9]{36}$/,                           // Personal access tokens (new)
-    /^github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}$/,    // Fine-grained PATs
-    /^gho_[a-zA-Z0-9]{35,40}$/,                         // OAuth tokens (flexible length)
-    /^ghs_[a-zA-Z0-9]{36}$/,                           // GitHub App tokens
-    /^ghr_[a-zA-Z0-9]{36}$/,                           // Refresh tokens
-    /^[a-f0-9]{40}$/,                                  // Classic tokens (40 hex chars)
-  ];
-
-  function validateToken(token: string): boolean {
-    return patterns.some(pattern => pattern.test(token));
-  }
-
-  test("validates personal access token (ghp_)", () => {
-    expect(validateToken("ghp_123456789012345678901234567890123456")).toBe(true);
-  });
-
-  test("validates fine-grained PAT (github_pat_)", () => {
-    const fineGrainedPat = "github_pat_" + "a".repeat(22) + "_" + "b".repeat(59);
-    expect(validateToken(fineGrainedPat)).toBe(true);
-  });
-
-  test("validates OAuth token (gho_)", () => {
-    expect(validateToken("gho_12345678901234567890123456789012345")).toBe(true);
-    expect(validateToken("gho_1234567890123456789012345678901234567890")).toBe(true);
-  });
-
-  test("validates GitHub App token (ghs_)", () => {
-    expect(validateToken("ghs_123456789012345678901234567890123456")).toBe(true);
-  });
-
-  test("validates refresh token (ghr_)", () => {
-    expect(validateToken("ghr_123456789012345678901234567890123456")).toBe(true);
-  });
-
-  test("validates classic token (40 hex)", () => {
-    expect(validateToken("1234567890abcdef1234567890abcdef12345678")).toBe(true);
-  });
-
-  test("rejects invalid tokens", () => {
-    expect(validateToken("invalid")).toBe(false);
-    expect(validateToken("ghp_tooshort")).toBe(false);
-    expect(validateToken("")).toBe(false);
-    expect(validateToken("ghp_")).toBe(false);
-    expect(validateToken("not_a_token_at_all")).toBe(false);
-  });
-
-  test("rejects tokens with wrong prefix length", () => {
-    // ghp_ needs exactly 36 chars after prefix
-    expect(validateToken("ghp_12345")).toBe(false);
-    expect(validateToken("ghp_" + "a".repeat(35))).toBe(false);
-    expect(validateToken("ghp_" + "a".repeat(37))).toBe(false);
-  });
-});
-
-describe("Auth module integration", () => {
-  const originalGithubToken = process.env.GITHUB_TOKEN;
-  const originalGhToken = process.env.GH_TOKEN;
-
-  afterEach(() => {
-    if (originalGithubToken !== undefined) {
-      process.env.GITHUB_TOKEN = originalGithubToken;
-    } else {
-      delete process.env.GITHUB_TOKEN;
-    }
-    if (originalGhToken !== undefined) {
-      process.env.GH_TOKEN = originalGhToken;
-    } else {
-      delete process.env.GH_TOKEN;
-    }
-  });
-
-  test("full flow: set token, check auth, get token", () => {
-    delete process.env.GITHUB_TOKEN;
-    delete process.env.GH_TOKEN;
-
-    // Initially not authenticated (via env)
-    expect(isAuthenticated()).toBe(false);
-
-    // Set token
-    setToken("ghp_integration_test_token_123456789012");
-
-    // Now authenticated
-    expect(isAuthenticated()).toBe(true);
-
-    // Can retrieve token
-    expect(getToken()).toBe("ghp_integration_test_token_123456789012");
-  });
-
-  test("async flow: set token, check auth async, get token async", async () => {
-    delete process.env.GITHUB_TOKEN;
-    delete process.env.GH_TOKEN;
-
-    // Set token
-    setToken("ghp_async_integration_test_1234567890");
-
-    // Check async auth
-    expect(await isAuthenticatedAsync()).toBe(true);
-
-    // Get token async
-    expect(await getTokenAsync()).toBe("ghp_async_integration_test_1234567890");
-  });
-});