gitforest 0.1.0

package/src/github/auth.ts

@@ -0,0 +1,311 @@
+/**
+ * GitHub Authentication via gh CLI
+ * 
+ * Uses the GitHub CLI (gh) for authentication, which handles:
+ * - Device flow OAuth
+ * - Token storage and refresh
+ * - SSO and enterprise GitHub
+ * - Secure credential storage
+ */
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface AuthResult {
+  success: boolean;
+  token?: string;
+  error?: string;
+  user?: string;
+}
+
+// ============================================================================
+// Token Management
+// ============================================================================
+
+/**
+ * Get token from environment or gh CLI
+ */
+export function getToken(): string | null {
+  // First check environment variables (highest priority)
+  // Treat empty strings as missing
+  const envToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
+  if (envToken) {
+    return envToken;
+  }
+
+  // Try to get token from gh CLI (synchronous check not possible, return null)
+  // Use getTokenAsync for full check
+  return null;
+}
+
+/**
+ * Set token in environment (for programmatic use)
+ * This does NOT persist the token - it only sets it for the current session
+ */
+export function setToken(token: string): void {
+  process.env.GITHUB_TOKEN = token;
+}
+
+/**
+ * Get token from environment or gh CLI (async version)
+ */
+export async function getTokenAsync(): Promise<string | null> {
+  // First check environment variables
+  const envToken = process.env.GITHUB_TOKEN || process.env.GH_TOKEN || null;
+  if (envToken) {
+    return envToken;
+  }
+
+  // Try to get token from gh CLI
+  if (process.env.GITTY_IGNORE_GH) return null;
+
+  try {
+    const result = await Bun.$`gh auth token`.quiet().nothrow();
+    if (result.exitCode === 0) {
+      const token = result.stdout.toString().trim();
+      if (token) {
+        // Cache in environment for this session
+        process.env.GITHUB_TOKEN = token;
+        return token;
+      }
+    }
+  } catch {
+    // gh not installed or not logged in
+  }
+
+  return null;
+}
+
+/**
+ * Check if gh CLI is installed
+ */
+export async function isGhInstalled(): Promise<boolean> {
+  if (process.env.GITTY_IGNORE_GH) return false;
+
+  try {
+    const result = await Bun.$`gh --version`.quiet().nothrow();
+    return result.exitCode === 0;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Check if authenticated (has valid token)
+ */
+export function isAuthenticated(): boolean {
+  return getToken() !== null;
+}
+
+/**
+ * Check if authenticated (async - includes gh CLI check)
+ */
+export async function isAuthenticatedAsync(): Promise<boolean> {
+  const token = await getTokenAsync();
+  return token !== null;
+}
+
+// ============================================================================
+// Login / Logout
+// ============================================================================
+
+/**
+ * Login to GitHub using gh CLI device flow
+ */
+export async function login(): Promise<AuthResult> {
+  // Check if gh is installed
+  const ghInstalled = await isGhInstalled();
+  if (!ghInstalled) {
+    return {
+      success: false,
+      error: "GitHub CLI (gh) is not installed. Install it from: https://cli.github.com",
+    };
+  }
+
+  try {
+    // Run gh auth login with web flow
+    // This will open browser and handle the OAuth flow
+    const result = await Bun.$`gh auth login --web -h github.com`.nothrow();
+
+    if (result.exitCode !== 0) {
+      const stderr = result.stderr.toString();
+      return {
+        success: false,
+        error: stderr || "Login failed",
+      };
+    }
+
+    // Get the token and user info
+    const tokenResult = await Bun.$`gh auth token`.quiet();
+    const token = tokenResult.stdout.toString().trim();
+
+    const userResult = await Bun.$`gh api user --jq .login`.quiet().nothrow();
+    const user = userResult.exitCode === 0 ? userResult.stdout.toString().trim() : undefined;
+
+    // Cache token in environment
+    process.env.GITHUB_TOKEN = token;
+
+    return {
+      success: true,
+      token,
+      user,
+    };
+  } catch (error) {
+    return {
+      success: false,
+      error: error instanceof Error ? error.message : "Login failed",
+    };
+  }
+}
+
+/**
+ * Logout from GitHub
+ */
+export async function logout(): Promise<AuthResult> {
+  // Check if gh is installed
+  const ghInstalled = await isGhInstalled();
+  if (!ghInstalled) {
+    // Just clear env
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.GH_TOKEN;
+    return { success: true };
+  }
+
+  try {
+    await Bun.$`gh auth logout -h github.com`.quiet().nothrow();
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.GH_TOKEN;
+    return { success: true };
+  } catch {
+    // Clear env anyway
+    delete process.env.GITHUB_TOKEN;
+    delete process.env.GH_TOKEN;
+    return { success: true };
+  }
+}
+
+/**
+ * Verify token by calling GitHub API directly
+ */
+async function verifyTokenWithApi(token: string): Promise<{ valid: boolean; user?: string }> {
+  try {
+    const response = await fetch("https://api.github.com/user", {
+      headers: {
+        "Accept": "application/vnd.github+json",
+        "Authorization": `Bearer ${token}`,
+        "X-GitHub-Api-Version": "2022-11-28",
+      },
+    });
+
+    if (response.ok) {
+      const data = await response.json() as { login: string };
+      return { valid: true, user: data.login };
+    }
+    return { valid: false };
+  } catch {
+    return { valid: false };
+  }
+}
+
+/**
+ * Get current auth status
+ */
+export async function getAuthStatus(): Promise<{
+  authenticated: boolean;
+  user?: string;
+  source?: "env" | "gh";
+}> {
+  // Check environment first
+  const envToken = process.env.GITHUB_TOKEN ?? process.env.GH_TOKEN;
+  if (envToken) {
+    // Verify token works using GitHub API directly
+    const result = await verifyTokenWithApi(envToken);
+    if (result.valid) {
+      return {
+        authenticated: true,
+        user: result.user,
+        source: "env",
+      };
+    }
+  }
+
+  // Check gh CLI
+  if (process.env.GITTY_IGNORE_GH) return { authenticated: false };
+
+  try {
+    const statusResult = await Bun.$`gh auth status -h github.com`.quiet().nothrow();
+    if (statusResult.exitCode === 0) {
+      // Get token from gh
+      const tokenResult = await Bun.$`gh auth token`.quiet().nothrow();
+      if (tokenResult.exitCode === 0) {
+        const token = tokenResult.stdout.toString().trim();
+        const result = await verifyTokenWithApi(token);
+        if (result.valid) {
+          // Cache token in environment
+          process.env.GITHUB_TOKEN = token;
+          return {
+            authenticated: true,
+            user: result.user,
+            source: "gh",
+          };
+        }
+      }
+    }
+  } catch {
+    // Not authenticated via gh
+  }
+
+  return { authenticated: false };
+}
+
+// ============================================================================
+// Ensure Authenticated
+// ============================================================================
+
+/**
+ * Ensure authenticated - prompt for login if needed
+ * Returns the token if authenticated, null otherwise
+ */
+export async function ensureAuthenticated(silent = false): Promise<string | null> {
+  // Try to get existing token
+  const token = await getTokenAsync();
+  if (token) {
+    return token;
+  }
+
+  if (silent) {
+    return null;
+  }
+
+  // Check if gh is installed
+  const ghInstalled = await isGhInstalled();
+  if (!ghInstalled) {
+    console.log("\nGitHub CLI (gh) is not installed.");
+    console.log("Install it from: https://cli.github.com");
+    console.log("\nOr set GITHUB_TOKEN environment variable manually.");
+    return null;
+  }
+
+  // Check if we are in an interactive TTY
+  if (!process.stdin.isTTY) {
+    console.log("\nNo GitHub token found. Non-interactive mode: skipping auto-login.");
+    return null;
+  }
+
+  // Prompt for login
+  console.log("\nNo GitHub token found. Starting authentication...\n");
+
+  const result = await login();
+
+  if (result.success && result.token) {
+    console.log(`\nLogged in as ${result.user ?? "unknown"}\n`);
+    return result.token;
+  }
+
+  if (result.error) {
+    console.error(`\nAuthentication failed: ${result.error}\n`);
+  }
+
+  return null;
+}

package/src/github/cache.ts

@@ -0,0 +1,231 @@
+/**
+ * GitHub caching utilities for unified repos
+ */
+
+import type { GitHubRepoInfo } from "../types/index.ts";
+import { initDb, schema, type DbInstance } from "../db/index.ts";
+import { defaultGitHubService, type GitHubService } from "../services/github.ts";
+import { toGitHubRepoInfo as defaultToGitHubRepoInfo } from "./unified.ts";
+import { errorToString } from "../utils/errors.ts";
+import { getTokenAsync } from "./auth.ts";
+
+/**
+ * Dependencies that can be injected for testing
+ */
+export interface CacheDeps {
+  db: DbInstance;
+  githubService: GitHubService;
+  toGitHubRepoInfo: (data: any) => GitHubRepoInfo;
+  /**
+   * Optional token provider used when no env token is set.
+   * Defaults to getTokenAsync which will call `gh auth token`.
+   */
+  tokenProvider: () => Promise<string | null>;
+}
+
+/**
+ * Check if GitHub repos cache is fresh based on TTL
+ */
+function isGitHubCacheFresh(lastFetched: Date | null, ttlSeconds: number): boolean {
+  if (!lastFetched) return false;
+  const now = Date.now();
+  const ttlMs = ttlSeconds * 1000;
+  return now - lastFetched.getTime() < ttlMs;
+}
+
+/**
+ * Save GitHub repos to cache
+ */
+export async function saveGitHubReposToCache(
+  repos: GitHubRepoInfo[],
+  deps?: { db?: DbInstance }
+): Promise<void> {
+  try {
+    const db = deps?.db ?? await initDb();
+    const now = new Date();
+
+    // Clear existing cache
+    await db.delete(schema.githubRepos).run();
+
+    // Insert all repos
+    for (const repo of repos) {
+      await db.insert(schema.githubRepos).values({
+        name: repo.name,
+        fullName: repo.fullName,
+        owner: repo.owner,
+        description: repo.description,
+        htmlUrl: repo.htmlUrl,
+        sshUrl: repo.sshUrl,
+        cloneUrl: repo.cloneUrl,
+        isPrivate: repo.isPrivate,
+        isArchived: repo.isArchived,
+        isFork: repo.isFork,
+        pushedAt: repo.pushedAt,
+        updatedAt: repo.updatedAt,
+        defaultBranch: repo.defaultBranch,
+        language: repo.language,
+        size: repo.size,
+        stargazersCount: repo.stargazersCount,
+        forksCount: repo.forksCount,
+        openIssuesCount: repo.openIssuesCount,
+        watchersCount: repo.watchersCount,
+        topics: JSON.stringify(repo.topics),
+        license: repo.license,
+        hasIssues: repo.hasIssues,
+        hasWiki: repo.hasWiki,
+        hasDiscussions: repo.hasDiscussions,
+        lastFetched: now,
+      });
+    }
+  } catch (error) {
+    console.error("Failed to save GitHub repos to cache:", error);
+  }
+}
+
+/**
+ * Load GitHub repos from cache
+ */
+export async function loadGitHubReposFromCache(
+  deps?: { db?: DbInstance }
+): Promise<GitHubRepoInfo[]> {
+  try {
+    const db = deps?.db ?? await initDb();
+    const rows = await db.select().from(schema.githubRepos).all();
+    
+    return rows.map(row => {
+      // Get the actual values from the row
+      const htmlUrl = row.htmlUrl;
+      const sshUrl = row.sshUrl;
+      const cloneUrl = row.cloneUrl;
+      const isPrivate = row.isPrivate;
+      const isArchived = row.isArchived;
+      const isFork = row.isFork;
+      const defaultBranch = row.defaultBranch;
+      const size = row.size;
+      const stargazersCount = row.stargazersCount;
+      const forksCount = row.forksCount;
+      const openIssuesCount = row.openIssuesCount;
+      const watchersCount = row.watchersCount;
+      const topics = row.topics;
+      const license = row.license;
+      const hasIssues = row.hasIssues;
+      const hasWiki = row.hasWiki;
+      const hasDiscussions = row.hasDiscussions;
+      
+      return {
+        name: row.name,
+        fullName: row.fullName,
+        owner: row.owner,
+        description: row.description,
+        htmlUrl: htmlUrl ?? '',
+        sshUrl: sshUrl ?? '',
+        cloneUrl: cloneUrl ?? '',
+        isPrivate: isPrivate ?? false,
+        isArchived: isArchived ?? false,
+        isFork: isFork ?? false,
+        pushedAt: row.pushedAt,
+        updatedAt: row.updatedAt,
+        defaultBranch: defaultBranch ?? 'main',
+        language: row.language,
+        size: size ?? 0,
+        stargazersCount: stargazersCount ?? 0,
+        forksCount: forksCount ?? 0,
+        openIssuesCount: openIssuesCount ?? 0,
+        watchersCount: watchersCount ?? 0,
+        topics: (() => {
+          try {
+            return topics ? JSON.parse(topics) : [];
+          } catch (e) {
+            console.warn(`Failed to parse topics JSON: "${topics}"`);
+            return [];
+          }
+        })(),
+        license: license,
+        hasIssues: hasIssues ?? false,
+        hasWiki: hasWiki ?? false,
+        hasDiscussions: hasDiscussions ?? false,
+      };
+    });
+  } catch (error) {
+    console.error("Failed to load GitHub repos from cache:", error);
+    return [];
+  }
+}
+
+/**
+ * Fetch GitHub repos with caching support
+ */
+export async function fetchGitHubReposWithCache(
+  options?: {
+    includeOrgs?: boolean;
+    includeArchived?: boolean;
+    includeForks?: boolean;
+  },
+  cacheTtlSeconds = 300,
+  deps?: Partial<CacheDeps>
+): Promise<{
+  repos: GitHubRepoInfo[];
+  fromCache: boolean;
+  error?: string;
+}> {
+  const githubService = deps?.githubService ?? defaultGitHubService;
+  const toGitHubRepoInfo = deps?.toGitHubRepoInfo ?? defaultToGitHubRepoInfo;
+  const tokenProvider = deps?.tokenProvider ?? getTokenAsync;
+
+  // Attempt to populate env token from gh CLI if none is set
+  if (!githubService.hasToken()) {
+    const token = await tokenProvider();
+    if (!token && !githubService.hasToken()) {
+      return { repos: [], fromCache: false, error: "GITHUB_TOKEN not set" };
+    }
+  }
+
+  // Try to load from cache first
+  try {
+    const cached = await loadGitHubReposFromCache({ db: deps?.db });
+    if (cached.length > 0 && isGitHubCacheFresh(cached[0]?.updatedAt || null, cacheTtlSeconds)) {
+      return { repos: cached, fromCache: true };
+    }
+  } catch (error) {
+    console.error("Failed to check GitHub cache:", error);
+  }
+
+  // Fetch fresh data
+  try {
+    const rawRepos = await githubService.getAllRepos(options);
+    const repos = rawRepos.map(toGitHubRepoInfo);
+
+    // Save to cache (don't await, let it happen in background)
+    saveGitHubReposToCache(repos, { db: deps?.db }).catch(console.error);
+
+    return { repos, fromCache: false };
+  } catch (error) {
+    const errorString = errorToString(error);
+    console.error("Failed to fetch GitHub repos:", errorString);
+
+    // On error, try to return stale cache if available
+    try {
+      const cached = await loadGitHubReposFromCache({ db: deps?.db });
+      if (cached.length > 0) {
+        console.log("Using stale cache due to fetch error");
+        return { repos: cached, fromCache: true, error: errorString };
+      }
+    } catch {
+      // No cache available
+    }
+
+    return { repos: [], fromCache: false, error: errorString };
+  }
+}
+
+/**
+ * Clear all GitHub repos from cache
+ */
+export async function clearGitHubCache(): Promise<void> {
+  try {
+    const db = await initDb();
+    await db.delete(schema.githubRepos).run();
+  } catch (error) {
+    console.error("Failed to clear GitHub cache:", error);
+  }
+}

package/src/github/cli.ts

@@ -0,0 +1,22 @@
+/**
+ * GitHub URL parsing utilities
+ */
+
+/**
+ * Get the GitHub repo name from a remote URL
+ */
+export function parseGitHubUrl(url: string): { owner: string; repo: string } | null {
+  // SSH format: git@github.com:owner/repo.git
+  const sshMatch = url.match(/git@github\.com:([^/]+)\/(.+?)(\.git)?$/);
+  if (sshMatch) {
+    return { owner: sshMatch[1]!, repo: sshMatch[2]! };
+  }
+
+  // HTTPS format: https://github.com/owner/repo.git
+  const httpsMatch = url.match(/https:\/\/github\.com\/([^/]+)\/(.+?)(\.git)?$/);
+  if (httpsMatch) {
+    return { owner: httpsMatch[1]!, repo: httpsMatch[2]! };
+  }
+
+  return null;
+}