gitforest 0.1.0

package/src/components/onboarding/DirectoriesStep.unit.test.ts

@@ -0,0 +1,345 @@
+import { describe, test, expect, beforeEach, afterEach } from "bun:test";
+import { mkdirSync, rmSync, existsSync } from "fs";
+import * as fs from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { readDirectory, validateDirectoryPath, getCompletions, formatDisplayPath } from "./DirectoriesStep.tsx";
+
+// Import the functions we want to test
+// Note: We'll need to export these from DirectoriesStep.tsx first
+
+describe("Directory Browser Utility Functions", () => {
+  let testDir: string;
+
+  function createTestDir() {
+    testDir = join(tmpdir(), `gitforest-utils-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+
+    // Create test structure
+    mkdirSync(join(testDir, "projects"));
+    mkdirSync(join(testDir, "code"));
+    mkdirSync(join(testDir, "documents"));
+    mkdirSync(join(testDir, "test-folder"));
+    mkdirSync(join(testDir, ".hidden"));
+
+    // Create files (should not appear in directory listing)
+    Bun.write(join(testDir, "file.txt"), "test");
+  }
+
+  function cleanupTestDir() {
+    if (existsSync(testDir)) {
+      rmSync(testDir, { recursive: true, force: true });
+    }
+  }
+
+  beforeEach(() => {
+    createTestDir();
+  });
+
+  afterEach(() => {
+    cleanupTestDir();
+  });
+
+  describe("readDirectory", () => {
+    test("should return only directories, excluding files", () => {
+      const dirs = readDirectory(testDir);
+      const dirNames = dirs.map(d => d.name);
+
+      // Should contain directories
+      expect(dirNames).toContain("projects");
+      expect(dirNames).toContain("code");
+      expect(dirNames).toContain("documents");
+      expect(dirNames).toContain("test-folder");
+
+      // Should NOT contain files
+      expect(dirNames).not.toContain("file.txt");
+    });
+
+    test("should exclude hidden directories starting with .", () => {
+      const dirs = readDirectory(testDir);
+      const dirNames = dirs.map(d => d.name);
+
+      // Should not include .hidden
+      expect(dirNames).not.toContain(".hidden");
+    });
+
+    test("should sort results alphabetically", () => {
+      const dirs = readDirectory(testDir);
+      const dirNames = dirs.map(d => d.name);
+
+      // Check if sorted (code, documents, projects, test-folder)
+      expect(dirNames[0]).toBe("code");
+      expect(dirNames[1]).toBe("documents");
+      expect(dirNames[2]).toBe("projects");
+      expect(dirNames[3]).toBe("test-folder");
+    });
+
+    test("should return empty array for non-existent directory", () => {
+      const dirs = readDirectory("/non-existent-path-12345");
+      expect(dirs).toEqual([]);
+    });
+  });
+
+  describe("validateDirectoryPath", () => {
+    test("should return valid: true for existing directory", () => {
+      const result = validateDirectoryPath(testDir);
+      expect(result.valid).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    test("should return valid: false for non-existent path", () => {
+      const result = validateDirectoryPath("/fake-path-12345");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Path does not exist");
+    });
+
+    test("should return valid: false for file instead of directory", () => {
+      const result = validateDirectoryPath(join(testDir, "file.txt"));
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Not a directory");
+    });
+
+    test("should return valid: false for empty path", () => {
+      const result = validateDirectoryPath("");
+      expect(result.valid).toBe(false);
+      expect(result.error).toBe("Path is required");
+    });
+
+    test("should expand tilde before validating", () => {
+      const homeDir = require("os").homedir();
+      // Create a test directory in home
+      // For now just test the expansion logic
+      const result = validateDirectoryPath("~/");
+      // After expansion, ~/ becomes /home/user, which exists
+      // The validation should handle the expansion
+      expect(result).toBeDefined();
+    });
+  });
+
+  describe("getCompletions", () => {
+    test("should complete absolute paths starting with /", () => {
+      const completions = getCompletions("/proj", testDir);
+      // Should return nothing since we're not in root
+      expect(Array.isArray(completions)).toBe(true);
+    });
+
+    test("should complete relative paths from current directory", () => {
+      const completions = getCompletions("proj", testDir);
+      expect(completions.length).toBeGreaterThan(0);
+      expect(completions[0]).toContain("projects");
+    });
+
+    test("should be case-insensitive for matching", () => {
+      const completions = getCompletions("PROJ", testDir);
+      expect(completions.length).toBeGreaterThan(0);
+      expect(completions[0]).toContain("projects");
+    });
+
+    test("should strip trailing slash before processing", () => {
+      // Test that /proj and /proj/ give same results
+      const c1 = getCompletions("/proj", testDir);
+      const c2 = getCompletions("/proj/", testDir);
+      expect(c1).toEqual(c2);
+    });
+
+    test("should return empty array for invalid base directory", () => {
+      const completions = getCompletions("test", "/non-existent-12345");
+      expect(completions).toEqual([]);
+    });
+  });
+
+  describe("formatDisplayPath", () => {
+    test("should replace home directory prefix with ~", () => {
+      const homeDir = require("os").homedir();
+      const testPath = join(homeDir, "projects");
+      const formatted = formatDisplayPath(testPath);
+      expect(formatted).toBe("~/projects");
+    });
+
+    test("should not modify paths not in home directory", () => {
+      const formatted = formatDisplayPath("/Volumes/Storage");
+      expect(formatted).toBe("/Volumes/Storage");
+    });
+
+    test("should handle paths that exactly equal home directory", () => {
+      const homeDir = require("os").homedir();
+      const formatted = formatDisplayPath(homeDir);
+      expect(formatted).toBe("~");
+    });
+  });
+
+  describe("Edge Cases", () => {
+    test("should handle paths with trailing slash", () => {
+      const result1 = validateDirectoryPath(join(testDir, "projects"));
+      const result2 = validateDirectoryPath(join(testDir, "projects/"));
+
+      // Both should be valid
+      expect(result1.valid).toBe(true);
+      expect(result2.valid).toBe(true);
+    });
+
+    test("should handle case-insensitive folder filtering", () => {
+      const completions = getCompletions("PROJ", testDir);
+      expect(completions.length).toBeGreaterThan(0);
+      expect(completions.some(c => c.includes("projects"))).toBe(true);
+    });
+
+    test("should handle empty input for completions", () => {
+      // Empty input from testDir should list all entries
+      const completions = getCompletions("", testDir);
+      expect(Array.isArray(completions)).toBe(true);
+    });
+
+    test("should handle paths with spaces", () => {
+      // Create a directory with spaces in the name
+      const spacedDir = join(testDir, "folder with spaces");
+      mkdirSync(spacedDir, { recursive: true });
+
+      const dirs = readDirectory(testDir);
+      const dirNames = dirs.map(d => d.name);
+
+      expect(dirNames).toContain("folder with spaces");
+
+      // Validate the path with spaces
+      const result = validateDirectoryPath(spacedDir);
+      expect(result.valid).toBe(true);
+
+      // Format display path should preserve spaces
+      const formatted = formatDisplayPath(spacedDir);
+      expect(formatted).toContain("folder with spaces");
+    });
+
+    test("should handle non-ascii characters in folder names", () => {
+      // Create directories with non-ASCII characters
+      const unicodeDir1 = join(testDir, "café");
+      const unicodeDir2 = join(testDir, "проект");
+      mkdirSync(unicodeDir1, { recursive: true });
+      mkdirSync(unicodeDir2, { recursive: true });
+
+      const dirs = readDirectory(testDir);
+      const dirNames = dirs.map(d => d.name);
+
+      expect(dirNames).toContain("café");
+      expect(dirNames).toContain("проект");
+    });
+
+    test("should handle symlinks to directories", () => {
+      // Skip on Windows if symlinks require admin privileges
+      if (process.platform === "win32") {
+        // Symlink behavior varies on Windows
+        expect(true).toBe(true);
+        return;
+      }
+
+      // Create a target directory
+      const targetDir = join(testDir, "target");
+      mkdirSync(targetDir, { recursive: true });
+
+      // Create a symlink to the directory
+      const symlinkPath = join(testDir, "symlink-to-target");
+      try {
+        fs.symlinkSync(targetDir, symlinkPath, "dir");
+      } catch (e) {
+        // Symlink creation might fail due to permissions
+        // Skip test if we can't create symlinks
+        expect(true).toBe(true);
+        return;
+      }
+
+      const dirs = readDirectory(testDir);
+      const dirNames = dirs.map(d => d.name);
+
+      // Symlink should appear in listing (it's a directory entry)
+      expect(dirNames).toContain("symlink-to-target");
+    });
+
+    // These tests require specific platform or permission setups
+    // Mark them as todo since they're environment-dependent
+    test.todo("should handle very long paths gracefully");
+    test.todo("should handle paths with special characters");
+    test.todo("should handle permission denied errors gracefully");
+  });
+});
+
+describe("Browser State Management", () => {
+  describe("input buffer changes", () => {
+    test.todo("should reset selection when input changes");
+    test.todo("should reset scroll offset when input changes");
+    test.todo("should not reset when typing same character");
+  });
+
+  describe("currentPath changes", () => {
+    test.todo("should reset scroll offset when navigating to new directory");
+    test.todo("should reset selection when navigating to new directory");
+    test.todo("should reload directory entries for new path");
+  });
+
+  describe("tab completion", () => {
+    test.todo("should cycle through completions when pressing Tab repeatedly");
+    test.todo("should add trailing slash after completing directory");
+    test.todo("should update currentPath to completed directory");
+    test.todo("should update folder list to show completed directory's contents");
+  });
+
+  describe("backspace handling", () => {
+    test.todo("should allow backspacing initial tilde");
+    test.todo("should allow backspacing to empty input");
+    test.todo("should reset selection when backspacing");
+    test.todo("should reset scroll offset when backspacing");
+  });
+
+  describe("escape key handling", () => {
+    test.todo("should go to parent directory when input ends with /");
+    test.todo("should clear input when input has text beyond ~");
+    test.todo("should cancel when input is just ~");
+    test.todo("should reset all state when going back");
+  });
+
+  describe("Ctrl+U handling", () => {
+    test.todo("should reset input to ~");
+    test.todo("should reset selection");
+    test.todo("should reset scroll offset");
+    test.todo("should clear errors");
+  });
+
+  describe("folder filtering logic", () => {
+    test.todo("should filter by name when input has no slashes");
+    test.todo("should NOT filter when input starts with /");
+    test.todo("should NOT filter when input contains /");
+    test.todo("should show all folders when typing /Volumes");
+    test.todo("should show all folders when typing ~/code/proj");
+  });
+
+  describe("dynamic currentPath updates", () => {
+    test.todo("should update currentPath when input is valid directory");
+    test.todo("should expand ~ before validating");
+    test.todo("should reload entries when currentPath changes");
+    test.todo("should default to startingPath when input is empty");
+  });
+});
+
+describe("Integration Scenarios", () => {
+  test.todo("scenario: User types /Volumes/Storage/code and selects it", () => {
+    // Full workflow test
+  });
+
+  test.todo("scenario: User filters by typing 'proj' and navigates", () => {
+    // Filter workflow
+  });
+
+  test.todo("scenario: User starts with ~, backspaces, types absolute path", () => {
+    // Home to absolute path workflow
+  });
+
+  test.todo("scenario: User navigates deep into hierarchy, uses Esc to go back", () => {
+    // Navigation and back workflow
+  });
+
+  test.todo("scenario: User tabs through completions, cycles correctly", () => {
+    // Tab completion workflow
+  });
+
+  test.todo("scenario: Many folders, user scrolls through list", () => {
+    // Scrolling workflow
+  });
+});

package/src/components/onboarding/GitHubAuthStep.tsx

@@ -0,0 +1,268 @@
+import { useState, useEffect } from "react";
+import { Box, Text, useInput } from "ink";
+import { getAuthStatus, login, isGhInstalled } from "../../github/auth.ts";
+
+export interface GitHubAuthStepProps {
+  onComplete: (auth: { authenticated: boolean; user?: string; skipped: boolean }) => void;
+  onBack: () => void;
+  onCancel: () => void;
+}
+
+type AuthStatus = "checking" | "authenticated" | "not_authenticated" | "gh_not_installed" | "login_failed";
+
+export function GitHubAuthStep({ onComplete, onBack, onCancel }: GitHubAuthStepProps) {
+  const [status, setStatus] = useState<AuthStatus>("checking");
+  const [user, setUser] = useState<string | undefined>();
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+
+  useEffect(() => {
+    checkAuth();
+  }, []);
+
+  const checkAuth = async () => {
+    setStatus("checking");
+    setError(null);
+
+    const ghInstalled = await isGhInstalled();
+
+    if (!ghInstalled) {
+      setStatus("gh_not_installed");
+      return;
+    }
+
+    try {
+      const authStatus = await getAuthStatus();
+      if (authStatus.authenticated) {
+        setStatus("authenticated");
+        setUser(authStatus.user);
+      } else {
+        setStatus("not_authenticated");
+      }
+    } catch {
+      setStatus("not_authenticated");
+    }
+  };
+
+  const handleLogin = async () => {
+    setLoading(true);
+    setError(null);
+
+    try {
+      const result = await login();
+      if (result.success) {
+        setStatus("authenticated");
+        setUser(result.user);
+      } else {
+        setStatus("login_failed");
+        setError(result.error || "Login failed");
+      }
+    } catch {
+      setStatus("login_failed");
+      setError("An unexpected error occurred");
+    } finally {
+      setLoading(false);
+    }
+  };
+
+  useInput((input, key) => {
+    if (loading) return;
+
+    if (key.escape || input === "q" || input === "Q") {
+      onCancel();
+      return;
+    }
+
+    if (key.backspace || key.delete) {
+      onBack();
+      return;
+    }
+
+    if (key.return) {
+      // Complete with current auth state
+      onComplete({
+        authenticated: status === "authenticated",
+        user,
+        skipped: false,
+      });
+      return;
+    }
+
+    // Login
+    if ((input === "l" || input === "L") && (status === "not_authenticated" || status === "login_failed")) {
+      handleLogin();
+      return;
+    }
+
+    // Re-login
+    if ((input === "r" || input === "R") && status === "authenticated") {
+      handleLogin();
+      return;
+    }
+
+    // Skip
+    if (input === "s" || input === "S") {
+      onComplete({
+        authenticated: false,
+        user: undefined,
+        skipped: true,
+      });
+      return;
+    }
+  });
+
+  return (
+    <Box
+      flexDirection="column"
+      borderStyle="round"
+      borderColor="cyan"
+      paddingX={2}
+      paddingY={1}
+      width={80}
+    >
+      {/* Title */}
+      <Box marginBottom={1}>
+        <Text bold color="cyan">
+          GitHub Authentication
+        </Text>
+      </Box>
+
+      {/* Description */}
+      <Box marginBottom={1}>
+        <Text>GitHub integration is optional but recommended for full functionality.</Text>
+      </Box>
+
+      {/* Checking status */}
+      {status === "checking" && (
+        <Box marginBottom={1}>
+          <Text dimColor>Checking authentication status...</Text>
+        </Box>
+      )}
+
+      {/* Authenticated */}
+      {status === "authenticated" && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Box marginBottom={1}>
+            <Text color="green">✓ </Text>
+            <Text color="green" bold>
+              Authenticated{user ? ` as ${user}` : ""}
+            </Text>
+          </Box>
+          <Text dimColor>You're all set! GitHub features are ready to use.</Text>
+        </Box>
+      )}
+
+      {/* Not authenticated */}
+      {status === "not_authenticated" && !loading && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Box marginBottom={1}>
+            <Text color="yellow">○ </Text>
+            <Text color="yellow">Not authenticated</Text>
+          </Box>
+          <Text dimColor>GitHub CLI (gh) is installed and ready.</Text>
+        </Box>
+      )}
+
+      {/* gh not installed */}
+      {status === "gh_not_installed" && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Box marginBottom={1}>
+            <Text color="red">✗ </Text>
+            <Text color="red">GitHub CLI (gh) is not installed</Text>
+          </Box>
+          <Box flexDirection="column" marginBottom={1}>
+            <Text dimColor>To enable GitHub features:</Text>
+            <Text dimColor>  1. Install gh CLI from https://cli.github.com</Text>
+            <Text dimColor>  2. Run 'gitforest login' to authenticate</Text>
+            <Text dimColor>  3. Or set GITHUB_TOKEN environment variable</Text>
+          </Box>
+        </Box>
+      )}
+
+      {/* Login failed */}
+      {status === "login_failed" && !loading && (
+        <Box flexDirection="column" marginBottom={1}>
+          <Box marginBottom={1}>
+            <Text color="red">✗ </Text>
+            <Text color="red">Authentication failed</Text>
+          </Box>
+          {error && (
+            <Box marginBottom={1}>
+              <Text color="red">{error}</Text>
+            </Box>
+          )}
+          <Text dimColor>You can try again or skip for now.</Text>
+        </Box>
+      )}
+
+      {/* Loading */}
+      {loading && (
+        <Box marginBottom={1}>
+          <Text dimColor>Opening browser for authentication...</Text>
+        </Box>
+      )}
+
+      {/* Actions */}
+      {!loading && status !== "checking" && (
+        <Box flexDirection="column" marginTop={1}>
+          {status === "not_authenticated" || status === "login_failed" ? (
+            <Box gap={2}>
+              <Text dimColor>Press </Text>
+              <Text color="green" bold>
+                l
+              </Text>
+              <Text dimColor>Login</Text>
+              <Text color="green" bold>
+                s
+              </Text>
+              <Text dimColor>Skip</Text>
+              <Text color="green" bold>
+                Enter
+              </Text>
+              <Text dimColor>Continue</Text>
+            </Box>
+          ) : status === "authenticated" ? (
+            <Box gap={2}>
+              <Text dimColor>Press </Text>
+              <Text color="green" bold>
+                r
+              </Text>
+              <Text dimColor>Re-login</Text>
+              <Text color="green" bold>
+                s
+              </Text>
+              <Text dimColor>Skip</Text>
+              <Text color="green" bold>
+                Enter
+              </Text>
+              <Text dimColor>Continue</Text>
+            </Box>
+          ) : status === "gh_not_installed" ? (
+            <Box gap={2}>
+              <Text dimColor>Press </Text>
+              <Text color="green" bold>
+                s
+              </Text>
+              <Text dimColor>Skip</Text>
+              <Text color="green" bold>
+                Enter
+              </Text>
+              <Text dimColor>Continue</Text>
+            </Box>
+          ) : null}
+          <Box gap={2}>
+            <Text dimColor></Text>
+            <Text color="red" bold>
+              Backspace
+            </Text>
+            <Text dimColor>Back</Text>
+            <Text color="red" bold>
+              q
+            </Text>
+            <Text dimColor>Quit</Text>
+          </Box>
+        </Box>
+      )}
+    </Box>
+  );
+}