gitforest 0.1.0

package/src/git/service.ts

@@ -0,0 +1,539 @@
+/**
+ * GitService interface and Bun implementation
+ * Abstracts git operations for testability
+ */
+
+import { $ } from "bun";
+import type { GitStatus, OperationResult } from "../types/index.js";
+import type { SubmoduleEntry } from "../services/types.js";
+import { errorToString } from "../utils/errors.js";
+import { withTimeout, TimeoutError } from "../utils/timeout.js";
+import { GIT_TIMEOUTS } from "../constants.js";
+
+// ============================================================================
+// GitService Interface
+// ============================================================================
+
+export interface GitService {
+  // Repository info
+  isGitRepo(path: string): Promise<boolean>;
+  getGitRoot(path: string): Promise<string | null>;
+  isSubmodule(path: string): Promise<boolean>;
+  getSubmoduleParent(path: string): Promise<string | null>;
+
+  // Status
+  getStatus(path: string): Promise<GitStatus>;
+  getStatusPorcelain(path: string): Promise<string>;
+  getCurrentBranch(path: string): Promise<string>;
+  getTrackingBranch(path: string): Promise<string | null>;
+  countUnpushedCommits(path: string): Promise<number>;
+  countUnpulledCommits(path: string): Promise<number>;
+  getRemoteUrl(path: string, remote?: string): Promise<string | null>;
+  getLastCommitDate(path: string): Promise<Date | null>;
+  getRemoteLastCommitDate(path: string, remoteBranch?: string): Promise<Date | null>;
+  listSubmodules(path: string): Promise<SubmoduleEntry[]>;
+
+  // Operations
+  init(path: string): Promise<OperationResult>;
+  pull(path: string): Promise<OperationResult>;
+  push(path: string, setUpstream?: boolean): Promise<OperationResult>;
+  fetch(path: string): Promise<OperationResult>;
+  fetchAll(path: string): Promise<OperationResult>;
+  addRemote(path: string, url: string, name?: string): Promise<OperationResult>;
+  clone(url: string, targetDir: string): Promise<OperationResult>;
+}
+
+// ============================================================================
+// Bun Implementation
+// ============================================================================
+
+export const bunGitService: GitService = {
+  // Repository info
+  async isGitRepo(path: string): Promise<boolean> {
+    try {
+      await $`git -C ${path} rev-parse --is-inside-work-tree`.quiet();
+      return true;
+    } catch {
+      return false;
+    }
+  },
+
+  async getGitRoot(path: string): Promise<string | null> {
+    try {
+      const result = await $`git -C ${path} rev-parse --show-toplevel`.quiet().text();
+      return result.trim() || null;
+    } catch {
+      return null;
+    }
+  },
+
+  async isSubmodule(path: string): Promise<boolean> {
+    try {
+      const result = await $`git -C ${path} rev-parse --show-superproject-working-tree`.quiet().text();
+      return result.trim().length > 0;
+    } catch {
+      return false;
+    }
+  },
+
+  async getSubmoduleParent(path: string): Promise<string | null> {
+    try {
+      const result = await $`git -C ${path} rev-parse --show-superproject-working-tree`.quiet().text();
+      return result.trim() || null;
+    } catch {
+      return null;
+    }
+  },
+
+  // Status
+  async getStatus(path: string): Promise<GitStatus> {
+    // Get porcelain status
+    const porcelain = await withTimeout(
+      $`git -C ${path} status --porcelain`.quiet().text(),
+      GIT_TIMEOUTS.STATUS,
+      "git status"
+    );
+
+    // Get current branch
+    const currentBranch = await withTimeout(
+      $`git -C ${path} rev-parse --abbrev-ref HEAD`.quiet().text(),
+      GIT_TIMEOUTS.STATUS,
+      "git rev-parse"
+    );
+
+    // Get tracking branch
+    const trackingBranch = await withTimeout(
+      $`git -C ${path} rev-parse --abbrev-ref @{u}`.quiet().text(),
+      GIT_TIMEOUTS.STATUS,
+      "git rev-parse"
+    );
+
+    // Get remote URL
+    const remoteUrl = await withTimeout(
+      $`git -C ${path} config --get remote.origin.url`.quiet().text(),
+      GIT_TIMEOUTS.STATUS,
+      "git config"
+    );
+
+    // Get last commit date
+    const lastLocalCommit = await withTimeout(
+      $`git -C ${path} log -1 --format=%ct`.quiet().text(),
+      GIT_TIMEOUTS.STATUS,
+      "git log"
+    );
+
+    // Get remote last commit date
+    const lastRemoteCommit = trackingBranch
+      ? await withTimeout(
+          $`git -C ${path} log -1 --format=%ct ${trackingBranch}`.quiet().text(),
+          GIT_TIMEOUTS.STATUS,
+          "git log"
+        )
+      : null;
+
+    // Count unpushed commits
+    const unpushedCommits = trackingBranch
+      ? await withTimeout(
+          $`git -C ${path} log --oneline --count ${trackingBranch}..HEAD`.quiet().text(),
+          GIT_TIMEOUTS.STATUS,
+          "git log"
+        )
+      : 0;
+
+    // Count unpulled commits
+    const unpulledCommits = trackingBranch
+      ? await withTimeout(
+          $`git -C ${path} log --oneline --count HEAD..${trackingBranch}`.quiet().text(),
+          GIT_TIMEOUTS.STATUS,
+          "git log"
+        )
+      : 0;
+
+    // Parse porcelain status
+    const lines = porcelain.trim().split("\n");
+    let modifiedCount = 0;
+    let stagedCount = 0;
+    let untrackedCount = 0;
+
+    for (const line of lines) {
+      if (!line) continue;
+      const statusCode = line[0];
+      const filename = line.slice(3);
+
+      switch (statusCode) {
+        case "M":
+          modifiedCount++;
+          break;
+        case "A":
+          stagedCount++;
+          break;
+        case "??":
+          untrackedCount++;
+          break;
+      }
+    }
+
+    return {
+      hasUnstagedChanges: modifiedCount > 0,
+      hasStagedChanges: stagedCount > 0,
+      hasUntrackedFiles: untrackedCount > 0,
+      modifiedCount,
+      stagedCount,
+      untrackedCount,
+      currentBranch: (currentBranch as string).trim() || "unknown",
+      trackingBranch: (trackingBranch as string | null)?.trim() || null,
+      unpushedCommits: parseInt(unpushedCommits as string) || 0,
+      unpulledCommits: parseInt(unpulledCommits as string) || 0,
+      hasRemote: !!remoteUrl,
+      remoteUrl: (remoteUrl as string | null)?.trim() || null,
+      lastLocalCommit: lastLocalCommit ? new Date(parseInt(lastLocalCommit as string) * 1000) : null,
+      lastRemoteActivity: lastRemoteCommit ? new Date(parseInt(lastRemoteCommit as string) * 1000) : null,
+      hasCommits: true, // If we can run git status, we have commits
+      isDirty: modifiedCount > 0 || stagedCount > 0 || untrackedCount > 0,
+      isAhead: (parseInt(unpushedCommits as string) || 0) > 0,
+      isBehind: (parseInt(unpulledCommits as string) || 0) > 0,
+      isOutOfSync: (parseInt(unpushedCommits as string) || 0) > 0 || (parseInt(unpulledCommits as string) || 0) > 0,
+    };
+  },
+
+  async getStatusPorcelain(path: string): Promise<string> {
+    try {
+      return await $`git -C ${path} status --porcelain`.quiet().text();
+    } catch {
+      return "";
+    }
+  },
+
+  async getCurrentBranch(path: string): Promise<string> {
+    try {
+      const result = await $`git -C ${path} rev-parse --abbrev-ref HEAD`.quiet().text();
+      return result.trim();
+    } catch {
+      return "unknown";
+    }
+  },
+
+  async getTrackingBranch(path: string): Promise<string | null> {
+    try {
+      const result = await $`git -C ${path} rev-parse --abbrev-ref @{u}`.quiet().text();
+      return result.trim() || null;
+    } catch {
+      return null;
+    }
+  },
+
+  async countUnpushedCommits(path: string): Promise<number> {
+    try {
+      const trackingBranch = await this.getTrackingBranch(path);
+      if (!trackingBranch) return 0;
+
+      const result = await $`git -C ${path} log --oneline --count ${trackingBranch}..HEAD`.quiet().text();
+      return parseInt(result) || 0;
+    } catch {
+      return 0;
+    }
+  },
+
+  async countUnpulledCommits(path: string): Promise<number> {
+    try {
+      const trackingBranch = await this.getTrackingBranch(path);
+      if (!trackingBranch) return 0;
+
+      const result = await $`git -C ${path} log --oneline --count HEAD..${trackingBranch}`.quiet().text();
+      return parseInt(result) || 0;
+    } catch {
+      return 0;
+    }
+  },
+
+  async getRemoteUrl(path: string, remoteName?: string): Promise<string | null> {
+    try {
+      const remote = remoteName || "origin";
+      const result = await $`git -C ${path} config --get remote.${remote}.url`.quiet().text();
+      return result.trim() || null;
+    } catch {
+      return null;
+    }
+  },
+
+  async getLastCommitDate(path: string): Promise<Date | null> {
+    try {
+      const result = await $`git -C ${path} log -1 --format=%ct`.quiet().text();
+      return new Date(parseInt(result) * 1000);
+    } catch {
+      return null;
+    }
+  },
+
+  async getRemoteLastCommitDate(path: string, remoteBranch?: string): Promise<Date | null> {
+    try {
+      if (!remoteBranch) return null;
+
+      const result = await $`git -C ${path} log -1 --format=%ct ${remoteBranch}`.quiet().text();
+      return new Date(parseInt(result) * 1000);
+    } catch {
+      return null;
+    }
+  },
+
+  async listSubmodules(path: string): Promise<SubmoduleEntry[]> {
+    try {
+      const result = await $`git -C ${path} submodule status`.quiet().text();
+      const lines = result.trim().split("\n");
+      
+      const submodules: SubmoduleEntry[] = [];
+      for (const line of lines) {
+        if (!line) continue;
+        
+        const parts = line.split(" ");
+        if (parts.length >= 4) {
+          const statusChar = parts[0];
+          const commit = parts[1] || "";
+          const submodulePath = parts.slice(3).join(" ");
+          
+          submodules.push({
+            path: submodulePath,
+            commit,
+            status: (statusChar?.[0] as "-" | "+" | " " | "U") || " ",
+          });
+        }
+      }
+      
+      return submodules;
+    } catch {
+      return [];
+    }
+  },
+
+  // Operations
+  async init(path: string): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      await $`git -C ${path} init`.quiet();
+      await $`git -C ${path} config user.email "test@test.com"`.quiet();
+      await $`git -C ${path} config user.name "Test User"`.quiet();
+      
+      return {
+        success: true,
+        projectPath: path,
+        operation: "init",
+        message: "Git repository initialized",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        projectPath: path,
+        operation: "init",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+
+  async pull(path: string): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      await withTimeout(
+        $`git -C ${path} pull --ff-only`.quiet(),
+        GIT_TIMEOUTS.PULL,
+        "git pull"
+      );
+      
+      return {
+        success: true,
+        projectPath: path,
+        operation: "pull",
+        message: "Pull successful",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        return {
+          success: false,
+          projectPath: path,
+          operation: "pull",
+          error: `pull timeout after ${GIT_TIMEOUTS.PULL}ms`,
+          duration: Date.now() - start,
+        };
+      }
+      
+      return {
+        success: false,
+        projectPath: path,
+        operation: "pull",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+
+  async push(path: string, setUpstream?: boolean): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      const upstreamFlag = setUpstream ? "-u" : "";
+      await withTimeout(
+        $`git -C ${path} push ${upstreamFlag} origin`.quiet(),
+        GIT_TIMEOUTS.PUSH,
+        "git push"
+      );
+      
+      return {
+        success: true,
+        projectPath: path,
+        operation: "push",
+        message: "Push successful",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        return {
+          success: false,
+          projectPath: path,
+          operation: "push",
+          error: `push timeout after ${GIT_TIMEOUTS.PUSH}ms`,
+          duration: Date.now() - start,
+        };
+      }
+      
+      return {
+        success: false,
+        projectPath: path,
+        operation: "push",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+
+  async fetch(path: string): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      await withTimeout(
+        $`git -C ${path} fetch origin`.quiet(),
+        GIT_TIMEOUTS.FETCH,
+        "git fetch"
+      );
+      
+      return {
+        success: true,
+        projectPath: path,
+        operation: "fetch",
+        message: "Fetch successful",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        return {
+          success: false,
+          projectPath: path,
+          operation: "fetch",
+          error: `fetch timeout after ${GIT_TIMEOUTS.FETCH}ms`,
+          duration: Date.now() - start,
+        };
+      }
+      
+      return {
+        success: false,
+        projectPath: path,
+        operation: "fetch",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+
+  async fetchAll(path: string): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      await withTimeout(
+        $`git -C ${path} fetch --all`.quiet(),
+        GIT_TIMEOUTS.FETCH,
+        "git fetch --all"
+      );
+      
+      return {
+        success: true,
+        projectPath: path,
+        operation: "fetch-all",
+        message: "Fetch all successful",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        return {
+          success: false,
+          projectPath: path,
+          operation: "fetch-all",
+          error: `fetch-all timeout after ${GIT_TIMEOUTS.FETCH}ms`,
+          duration: Date.now() - start,
+        };
+      }
+      
+      return {
+        success: false,
+        projectPath: path,
+        operation: "fetch-all",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+
+  async addRemote(path: string, url: string, name?: string): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      const remoteName = name || "origin";
+      await $`git -C ${path} remote add ${remoteName} ${url}`.quiet();
+      
+      return {
+        success: true,
+        projectPath: path,
+        operation: "add-remote",
+        message: `Remote '${remoteName}' added`,
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      return {
+        success: false,
+        projectPath: path,
+        operation: "add-remote",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+
+  async clone(url: string, targetDir: string): Promise<OperationResult> {
+    const start = Date.now();
+    try {
+      await $`git clone ${url} ${targetDir}`.quiet();
+      
+      return {
+        success: true,
+        projectPath: targetDir,
+        operation: "clone",
+        message: "Clone successful",
+        duration: Date.now() - start,
+      };
+    } catch (error) {
+      if (error instanceof TimeoutError) {
+        return {
+          success: false,
+          projectPath: targetDir,
+          operation: "clone",
+          error: `clone timeout after ${GIT_TIMEOUTS.CLONE}ms`,
+          duration: Date.now() - start,
+        };
+      }
+      
+      return {
+        success: false,
+        projectPath: targetDir,
+        operation: "clone",
+        error: errorToString(error),
+        duration: Date.now() - start,
+      };
+    }
+  },
+};

package/src/git/status.ts

@@ -0,0 +1,84 @@
+import type { GitStatus } from "../types/index.ts";
+import type { GitService } from "../services/git.ts";
+import { bunGitService } from "../services/git.ts";
+
+/**
+ * Parse git status porcelain output
+ */
+export function parseGitStatusPorcelain(output: string): {
+  modifiedCount: number;
+  stagedCount: number;
+  untrackedCount: number;
+  hasUnstagedChanges: boolean;
+  hasStagedChanges: boolean;
+  hasUntrackedFiles: boolean;
+} {
+  // Split on newlines, preserving leading whitespace (important for porcelain format)
+  // Only trim trailing whitespace and filter empty lines
+  const lines = output.split("\n").map(line => line.trimEnd()).filter(line => line.length >= 2);
+
+  let modifiedCount = 0;
+  let stagedCount = 0;
+  let untrackedCount = 0;
+
+  for (const line of lines) {
+    const indexStatus = line[0];
+    const worktreeStatus = line[1];
+
+    // Untracked files
+    if (indexStatus === "?" && worktreeStatus === "?") {
+      untrackedCount++;
+      continue;
+    }
+
+    // Staged changes (index status is not empty or ?)
+    if (indexStatus && indexStatus !== " " && indexStatus !== "?") {
+      stagedCount++;
+    }
+
+    // Unstaged changes (worktree status is not empty)
+    if (worktreeStatus && worktreeStatus !== " ") {
+      modifiedCount++;
+    }
+  }
+
+  return {
+    modifiedCount,
+    stagedCount,
+    untrackedCount,
+    hasUnstagedChanges: modifiedCount > 0,
+    hasStagedChanges: stagedCount > 0,
+    hasUntrackedFiles: untrackedCount > 0,
+  };
+}
+
+/**
+ * Get comprehensive git status for a repository
+ */
+export async function getGitStatus(
+  path: string,
+  gitService: GitService = bunGitService
+): Promise<GitStatus> {
+  return await gitService.getStatus(path);
+}
+
+/**
+ * Quick status check (faster, less comprehensive)
+ */
+export async function getQuickStatus(
+  path: string,
+  gitService: GitService = bunGitService
+): Promise<{
+  isDirty: boolean;
+  hasRemote: boolean;
+}> {
+  const [porcelainOutput, remoteUrl] = await Promise.all([
+    gitService.getStatusPorcelain(path),
+    gitService.getRemoteUrl(path),
+  ]);
+
+  return {
+    isDirty: porcelainOutput.trim().length > 0,
+    hasRemote: remoteUrl !== null,
+  };
+}

package/src/git/types.ts

@@ -0,0 +1,5 @@
+/**
+ * Types for git module
+ */
+
+export type { SubmoduleEntry } from "../services/types.ts";