@atercates/claude-deck 0.2.1

package/lib/git-history.ts

@@ -0,0 +1,294 @@
+import { execSync } from "child_process";
+import { expandPath } from "./git-status";
+
+export interface CommitSummary {
+  hash: string;
+  shortHash: string;
+  subject: string;
+  body: string;
+  author: string;
+  authorEmail: string;
+  timestamp: number;
+  relativeTime: string;
+  filesChanged: number;
+  additions: number;
+  deletions: number;
+}
+
+export interface CommitFile {
+  path: string;
+  oldPath?: string;
+  status: "added" | "modified" | "deleted" | "renamed";
+  additions: number;
+  deletions: number;
+}
+
+export interface CommitDetail extends CommitSummary {
+  files: CommitFile[];
+}
+
+/**
+ * Get relative time string from timestamp
+ */
+function getRelativeTime(timestamp: number): string {
+  const now = Date.now();
+  const diff = now - timestamp * 1000;
+  const seconds = Math.floor(diff / 1000);
+  const minutes = Math.floor(seconds / 60);
+  const hours = Math.floor(minutes / 60);
+  const days = Math.floor(hours / 24);
+  const weeks = Math.floor(days / 7);
+  const months = Math.floor(days / 30);
+
+  if (months > 0) return `${months}mo ago`;
+  if (weeks > 0) return `${weeks}w ago`;
+  if (days > 0) return `${days}d ago`;
+  if (hours > 0) return `${hours}h ago`;
+  if (minutes > 0) return `${minutes}m ago`;
+  return "just now";
+}
+
+/**
+ * Get commit history
+ */
+export function getCommitHistory(
+  workingDir: string,
+  limit: number = 30
+): CommitSummary[] {
+  const cwd = expandPath(workingDir);
+
+  try {
+    // Format: hash|shortHash|subject|body|author|email|timestamp
+    // Using %x00 as separator to handle commit messages with |
+    const format = "%H%x00%h%x00%s%x00%b%x00%an%x00%ae%x00%at";
+    const output = execSync(
+      `git log --format="${format}" -n ${limit} --shortstat`,
+      { cwd, encoding: "utf-8", maxBuffer: 10 * 1024 * 1024 }
+    );
+
+    const commits: CommitSummary[] = [];
+    const lines = output.split("\n");
+
+    let i = 0;
+    while (i < lines.length) {
+      const line = lines[i];
+      if (!line || !line.includes("\x00")) {
+        i++;
+        continue;
+      }
+
+      const parts = line.split("\x00");
+      if (parts.length < 7) {
+        i++;
+        continue;
+      }
+
+      const [
+        hash,
+        shortHash,
+        subject,
+        body,
+        author,
+        authorEmail,
+        timestampStr,
+      ] = parts;
+      const timestamp = parseInt(timestampStr, 10);
+
+      // Look for shortstat line (next non-empty line)
+      let filesChanged = 0;
+      let additions = 0;
+      let deletions = 0;
+
+      i++;
+      while (i < lines.length) {
+        const statLine = lines[i].trim();
+        if (!statLine) {
+          i++;
+          continue;
+        }
+        // Parse shortstat: "3 files changed, 10 insertions(+), 5 deletions(-)"
+        const filesMatch = statLine.match(/(\d+) files? changed/);
+        const addMatch = statLine.match(/(\d+) insertions?\(\+\)/);
+        const delMatch = statLine.match(/(\d+) deletions?\(-\)/);
+
+        if (filesMatch || addMatch || delMatch) {
+          filesChanged = filesMatch ? parseInt(filesMatch[1], 10) : 0;
+          additions = addMatch ? parseInt(addMatch[1], 10) : 0;
+          deletions = delMatch ? parseInt(delMatch[1], 10) : 0;
+          i++;
+          break;
+        }
+        // If line contains separator, it's a new commit
+        if (statLine.includes("\x00")) {
+          break;
+        }
+        i++;
+      }
+
+      commits.push({
+        hash,
+        shortHash,
+        subject,
+        body: body.trim(),
+        author,
+        authorEmail,
+        timestamp,
+        relativeTime: getRelativeTime(timestamp),
+        filesChanged,
+        additions,
+        deletions,
+      });
+    }
+
+    return commits;
+  } catch (error) {
+    console.error("Failed to get commit history:", error);
+    return [];
+  }
+}
+
+/**
+ * Get detailed commit info including files changed
+ */
+export function getCommitDetail(
+  workingDir: string,
+  commitHash: string
+): CommitDetail | null {
+  const cwd = expandPath(workingDir);
+
+  try {
+    // Get commit info
+    const format = "%H%x00%h%x00%s%x00%b%x00%an%x00%ae%x00%at";
+    const infoOutput = execSync(
+      `git show --format="${format}" -s ${commitHash}`,
+      {
+        cwd,
+        encoding: "utf-8",
+      }
+    ).trim();
+
+    const parts = infoOutput.split("\x00");
+    if (parts.length < 7) return null;
+
+    const [hash, shortHash, subject, body, author, authorEmail, timestampStr] =
+      parts;
+    const timestamp = parseInt(timestampStr, 10);
+
+    // Get file stats using numstat
+    const statOutput = execSync(
+      `git show --numstat --format="" ${commitHash}`,
+      { cwd, encoding: "utf-8" }
+    );
+
+    // Get name-status for detecting renames
+    const nameStatusOutput = execSync(
+      `git show --name-status --format="" ${commitHash}`,
+      { cwd, encoding: "utf-8" }
+    );
+
+    const files: CommitFile[] = [];
+    const statLines = statOutput.trim().split("\n").filter(Boolean);
+    const nameStatusLines = nameStatusOutput.trim().split("\n").filter(Boolean);
+
+    // Build a map of path -> status from name-status
+    const statusMap = new Map<string, { status: string; oldPath?: string }>();
+    for (const line of nameStatusLines) {
+      const match = line.match(/^([AMDRC])\d*\t(.+?)(?:\t(.+))?$/);
+      if (match) {
+        const [, status, path1, path2] = match;
+        const finalPath = path2 || path1;
+        statusMap.set(finalPath, {
+          status,
+          oldPath: path2 ? path1 : undefined,
+        });
+      }
+    }
+
+    // Parse numstat for additions/deletions
+    for (const line of statLines) {
+      const match = line.match(/^(\d+|-)\t(\d+|-)\t(.+)$/);
+      if (match) {
+        const [, addStr, delStr, path] = match;
+        const additions = addStr === "-" ? 0 : parseInt(addStr, 10);
+        const deletions = delStr === "-" ? 0 : parseInt(delStr, 10);
+
+        const statusInfo = statusMap.get(path);
+        let status: CommitFile["status"] = "modified";
+        if (statusInfo) {
+          switch (statusInfo.status) {
+            case "A":
+              status = "added";
+              break;
+            case "D":
+              status = "deleted";
+              break;
+            case "R":
+              status = "renamed";
+              break;
+            default:
+              status = "modified";
+          }
+        }
+
+        files.push({
+          path,
+          oldPath: statusInfo?.oldPath,
+          status,
+          additions,
+          deletions,
+        });
+      }
+    }
+
+    // Get total stats
+    let totalFilesChanged = files.length;
+    let totalAdditions = 0;
+    let totalDeletions = 0;
+    for (const file of files) {
+      totalAdditions += file.additions;
+      totalDeletions += file.deletions;
+    }
+
+    return {
+      hash,
+      shortHash,
+      subject,
+      body: body.trim(),
+      author,
+      authorEmail,
+      timestamp,
+      relativeTime: getRelativeTime(timestamp),
+      filesChanged: totalFilesChanged,
+      additions: totalAdditions,
+      deletions: totalDeletions,
+      files,
+    };
+  } catch (error) {
+    console.error("Failed to get commit detail:", error);
+    return null;
+  }
+}
+
+/**
+ * Get diff for a specific file in a commit
+ */
+export function getCommitFileDiff(
+  workingDir: string,
+  commitHash: string,
+  filePath: string
+): string {
+  const cwd = expandPath(workingDir);
+
+  try {
+    // Get diff for the specific file in this commit
+    // Use -m to handle merge commits (shows diff against first parent)
+    const diff = execSync(
+      `git show -m --first-parent ${commitHash} -- "${filePath}"`,
+      { cwd, encoding: "utf-8", maxBuffer: 5 * 1024 * 1024 }
+    );
+    return diff;
+  } catch (error) {
+    console.error("Failed to get commit file diff:", error);
+    return "";
+  }
+}

package/lib/git-status.ts

@@ -0,0 +1,391 @@
+import { execSync } from "child_process";
+import { unlinkSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+
+/**
+ * Expand ~ to home directory in paths
+ */
+export function expandPath(path: string): string {
+  if (path.startsWith("~")) {
+    return path.replace(/^~/, homedir());
+  }
+  return path;
+}
+
+export type FileStatus =
+  | "modified"
+  | "added"
+  | "deleted"
+  | "renamed"
+  | "copied"
+  | "untracked"
+  | "unmerged";
+
+export interface GitFile {
+  path: string;
+  status: FileStatus;
+  staged: boolean;
+  oldPath?: string; // For renamed files
+}
+
+export interface GitStatus {
+  branch: string;
+  ahead: number;
+  behind: number;
+  staged: GitFile[];
+  unstaged: GitFile[];
+  untracked: GitFile[];
+}
+
+/**
+ * Parse git status --porcelain=v2 output
+ */
+export function getGitStatus(workingDir: string): GitStatus {
+  try {
+    // Get branch info
+    const branchOutput = execSync("git branch --show-current", {
+      cwd: workingDir,
+      encoding: "utf-8",
+    }).trim();
+
+    // Get ahead/behind counts
+    let ahead = 0;
+    let behind = 0;
+    try {
+      const trackingOutput = execSync(
+        "git rev-list --left-right --count @{upstream}...HEAD 2>/dev/null || echo '0 0'",
+        { cwd: workingDir, encoding: "utf-8" }
+      ).trim();
+      const [b, a] = trackingOutput.split(/\s+/).map(Number);
+      ahead = a || 0;
+      behind = b || 0;
+    } catch {
+      // No upstream configured
+    }
+
+    // Get status
+    const statusOutput = execSync("git status --porcelain=v1", {
+      cwd: workingDir,
+      encoding: "utf-8",
+    });
+
+    const staged: GitFile[] = [];
+    const unstaged: GitFile[] = [];
+    const untracked: GitFile[] = [];
+
+    for (const line of statusOutput.split("\n")) {
+      if (!line) continue;
+
+      const indexStatus = line[0];
+      const workTreeStatus = line[1];
+      const filePath = line.slice(3);
+
+      // Handle renames (format: "R  old -> new")
+      let path = filePath;
+      let oldPath: string | undefined;
+      if (filePath.includes(" -> ")) {
+        const parts = filePath.split(" -> ");
+        oldPath = parts[0];
+        path = parts[1];
+      }
+
+      // Untracked files
+      if (indexStatus === "?" && workTreeStatus === "?") {
+        untracked.push({ path, status: "untracked", staged: false });
+        continue;
+      }
+
+      // Staged changes (index status)
+      if (indexStatus !== " " && indexStatus !== "?") {
+        staged.push({
+          path,
+          oldPath,
+          status: parseStatus(indexStatus),
+          staged: true,
+        });
+      }
+
+      // Unstaged changes (work tree status)
+      if (workTreeStatus !== " " && workTreeStatus !== "?") {
+        unstaged.push({
+          path,
+          oldPath,
+          status: parseStatus(workTreeStatus),
+          staged: false,
+        });
+      }
+    }
+
+    return {
+      branch: branchOutput || "HEAD",
+      ahead,
+      behind,
+      staged,
+      unstaged,
+      untracked,
+    };
+  } catch (error) {
+    throw new Error(
+      `Failed to get git status: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+
+function parseStatus(char: string): FileStatus {
+  switch (char) {
+    case "M":
+      return "modified";
+    case "A":
+      return "added";
+    case "D":
+      return "deleted";
+    case "R":
+      return "renamed";
+    case "C":
+      return "copied";
+    case "U":
+      return "unmerged";
+    default:
+      return "modified";
+  }
+}
+
+/**
+ * Get diff for a specific file
+ */
+export function getFileDiff(
+  workingDir: string,
+  filePath: string,
+  staged: boolean
+): string {
+  try {
+    const stagedFlag = staged ? "--staged" : "";
+    const output = execSync(
+      `git diff ${stagedFlag} -- "${filePath}" 2>/dev/null || true`,
+      {
+        cwd: workingDir,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024, // 10MB
+      }
+    );
+    return output;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Get diff for untracked file (show full content)
+ */
+export function getUntrackedFileDiff(
+  workingDir: string,
+  filePath: string
+): string {
+  try {
+    const output = execSync(
+      `git diff --no-index /dev/null "${filePath}" 2>/dev/null || true`,
+      {
+        cwd: workingDir,
+        encoding: "utf-8",
+        maxBuffer: 10 * 1024 * 1024,
+      }
+    );
+    return output;
+  } catch {
+    return "";
+  }
+}
+
+/**
+ * Stage a file
+ */
+export function stageFile(workingDir: string, filePath: string): void {
+  execSync(`git add -- "${filePath}"`, {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+}
+
+/**
+ * Stage all files
+ */
+export function stageAll(workingDir: string): void {
+  execSync("git add -A", {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+}
+
+/**
+ * Unstage a file
+ */
+export function unstageFile(workingDir: string, filePath: string): void {
+  execSync(`git reset HEAD -- "${filePath}"`, {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+}
+
+/**
+ * Unstage all files
+ */
+export function unstageAll(workingDir: string): void {
+  execSync("git reset HEAD", {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+}
+
+/**
+ * Discard changes to a file (checkout for tracked, delete for untracked)
+ */
+export function discardChanges(workingDir: string, filePath: string): void {
+  // Check if file is tracked by git
+  try {
+    execSync(`git ls-files --error-unmatch "${filePath}"`, {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: "pipe",
+    });
+    // File is tracked - use checkout
+    execSync(`git checkout -- "${filePath}"`, {
+      cwd: workingDir,
+      encoding: "utf-8",
+    });
+  } catch {
+    // File is untracked - delete it
+    unlinkSync(join(workingDir, filePath));
+  }
+}
+
+/**
+ * Check if directory is a git repository
+ */
+export function isGitRepo(workingDir: string): boolean {
+  try {
+    execSync("git rev-parse --git-dir", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get the root of the git repository
+ */
+export function getGitRoot(workingDir: string): string {
+  try {
+    return execSync("git rev-parse --show-toplevel", {
+      cwd: workingDir,
+      encoding: "utf-8",
+    }).trim();
+  } catch {
+    return workingDir;
+  }
+}
+
+/**
+ * Check if on main/master branch
+ */
+export function isMainBranch(workingDir: string): boolean {
+  try {
+    const branch = execSync("git branch --show-current", {
+      cwd: workingDir,
+      encoding: "utf-8",
+    }).trim();
+    return branch === "main" || branch === "master";
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Create a new branch and switch to it
+ */
+export function createBranch(workingDir: string, branchName: string): void {
+  execSync(`git checkout -b "${branchName}"`, {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+}
+
+/**
+ * Commit staged changes
+ */
+export function commit(workingDir: string, message: string): string {
+  const output = execSync(`git commit -m "${message.replace(/"/g, '\\"')}"`, {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+  return output;
+}
+
+/**
+ * Push to remote
+ */
+export function push(workingDir: string, setUpstream = false): string {
+  const branch = execSync("git branch --show-current", {
+    cwd: workingDir,
+    encoding: "utf-8",
+  }).trim();
+
+  const upstreamFlag = setUpstream ? `-u origin "${branch}"` : "";
+  const output = execSync(`git push ${upstreamFlag}`, {
+    cwd: workingDir,
+    encoding: "utf-8",
+  });
+  return output;
+}
+
+/**
+ * Check if branch has upstream
+ */
+export function hasUpstream(workingDir: string): boolean {
+  try {
+    execSync("git rev-parse --abbrev-ref @{upstream}", {
+      cwd: workingDir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"],
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Get remote URL
+ */
+export function getRemoteUrl(workingDir: string): string | null {
+  try {
+    return execSync("git remote get-url origin", {
+      cwd: workingDir,
+      encoding: "utf-8",
+    }).trim();
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Get the default branch name (main or master)
+ */
+export function getDefaultBranch(workingDir: string): string {
+  try {
+    // Try to get from remote
+    const output = execSync(
+      "git symbolic-ref refs/remotes/origin/HEAD 2>/dev/null || echo 'refs/heads/main'",
+      { cwd: workingDir, encoding: "utf-8" }
+    ).trim();
+    return output
+      .replace("refs/remotes/origin/", "")
+      .replace("refs/heads/", "");
+  } catch {
+    return "main";
+  }
+}