@samaksh/git-worker 0.0.0-stage → 0.1.0

package/src/services/git/ops.ts

@@ -0,0 +1,170 @@
+import { simpleGit, SimpleGit } from "simple-git";
+import { Result, ok, err } from "../../core/types.js";
+import { gitError } from "../../core/errors.js";
+import { writeFile, mkdir, rename, mkdtemp } from "fs/promises";
+import { dirname, join } from "path";
+import { tmpdir } from "os";
+
+export type GitOps = {
+  ensureRepo(repoPath: string): Promise<Result<void>>;
+  checkoutBranch(repoPath: string, branchName: string): Promise<Result<void>>;
+  resetHard(repoPath: string): Promise<Result<void>>;
+  clean(repoPath: string, mode?: "tracked-and-untracked" | "tracked-only"): Promise<Result<void>>;
+  writeAndStage(repoPath: string, filePath: string, content: string): Promise<Result<void>>;
+  getStagedFiles(repoPath: string): Promise<Result<string[]>>;
+  commit(repoPath: string, message: string): Promise<Result<string>>;
+  push(repoPath: string, remote: string, branchName: string): Promise<Result<void>>;
+  getBranchSha(repoPath: string, branchName: string): Promise<Result<string>>;
+};
+
+export async function ensureRepo(repoPath: string): Promise<Result<void>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const isRepo = await git.checkIsRepo();
+    if (!isRepo) return err(gitError("Not a git repository"));
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError("Failed to check repository", e));
+  }
+}
+
+export async function checkoutBranch(
+  repoPath: string,
+  branchName: string
+): Promise<Result<void>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    // Align local branch to origin/branchName if remote branch exists
+    try {
+      await git.checkout(["-B", branchName, `origin/${branchName}`]);
+    } catch {
+      // Fallback for local-only branch
+      await git.checkout(branchName);
+    }
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError(`Failed to checkout '${branchName}'`, e));
+  }
+}
+
+export async function resetHard(repoPath: string): Promise<Result<void>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    await git.reset(["--hard"]);
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError("Failed to reset --hard", e));
+  }
+}
+
+export async function clean(
+  repoPath: string,
+  mode: "tracked-and-untracked" | "tracked-only" = "tracked-and-untracked"
+): Promise<Result<void>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    if (mode === "tracked-and-untracked") {
+      await git.clean("f", ["-d"]);
+    }
+    // tracked-only: git reset --hard already handles it
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError("Failed to clean working tree", e));
+  }
+}
+
+/**
+ * Atomically write a file (via temp file + rename) and stage it.
+ * Only stages the specific path — no glob or wildcard.
+ */
+export async function writeAndStage(
+  repoPath: string,
+  filePath: string,
+  content: string
+): Promise<Result<void>> {
+  try {
+    const fullPath = join(repoPath, filePath);
+    await mkdir(dirname(fullPath), { recursive: true });
+
+    // Atomic write: write to temp, then rename
+    const tmp = fullPath + ".git-worker-tmp";
+    await writeFile(tmp, content, "utf-8");
+    await rename(tmp, fullPath);
+
+    const git: SimpleGit = simpleGit(repoPath);
+    await git.add([filePath]);
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError(`Failed to write/stage '${filePath}'`, e));
+  }
+}
+
+/**
+ * Returns the list of staged file paths.
+ * Used to verify only the intended path is staged before committing.
+ */
+export async function getStagedFiles(repoPath: string): Promise<Result<string[]>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const diff = await git.diff(["--cached", "--name-only"]);
+    const files = diff
+      .split("\n")
+      .map((l) => l.trim())
+      .filter(Boolean);
+    return ok(files);
+  } catch (e: any) {
+    return err(gitError("Failed to get staged files", e));
+  }
+}
+
+export async function commit(repoPath: string, message: string): Promise<Result<string>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const result = await git.commit(message);
+    return ok(result.commit);
+  } catch (e: any) {
+    return err(gitError(`Failed to commit: ${e.message}`, e));
+  }
+}
+
+export async function push(
+  repoPath: string,
+  remote: string,
+  branchName: string
+): Promise<Result<void>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    // Non-force push only
+    await git.push([remote, `${branchName}:${branchName}`]);
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError(`Failed to push '${branchName}' to '${remote}': ${e.message}`, e));
+  }
+}
+
+export async function getBranchSha(
+  repoPath: string,
+  branchName: string
+): Promise<Result<string>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const sha = await git.revparse([branchName]);
+    return ok(sha.trim());
+  } catch (e: any) {
+    return err(gitError(`Failed to get SHA for '${branchName}'`, e));
+  }
+}
+
+export function createGitOps(): GitOps {
+  return {
+    ensureRepo,
+    checkoutBranch,
+    resetHard,
+    clean,
+    writeAndStage,
+    getStagedFiles,
+    commit,
+    push,
+    getBranchSha,
+  };
+}

package/src/services/git/reader.ts

@@ -0,0 +1,148 @@
+import { simpleGit, SimpleGit } from "simple-git";
+import { Result, ok, err, BranchRef } from "../../core/types.js";
+import { gitError } from "../../core/errors.js";
+
+export type GitReader = {
+  readFileFromBranch(repoPath: string, branch: BranchRef, filePath: string): Promise<Result<string>>;
+  listBranches(repoPath: string, remote?: string): Promise<Result<BranchRef[]>>;
+  getCurrentBranch(repoPath: string): Promise<Result<string>>;
+  fetch(repoPath: string, remote?: string, prune?: boolean): Promise<Result<void>>;
+  getRemoteUrl(repoPath: string, remote?: string): Promise<Result<string>>;
+};
+
+export async function readFileFromBranch(
+  repoPath: string,
+  branch: BranchRef,
+  filePath: string
+): Promise<Result<string>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    // For remote branches, use the full remote ref; for local use name
+    const ref =
+      branch.isRemote && branch.remote
+        ? `${branch.remote}/${branch.name}`
+        : branch.name;
+    const content = await git.show([`${ref}:${filePath}`]);
+    return ok(content);
+  } catch (e: any) {
+    if (
+      e.message?.includes("does not exist") ||
+      e.message?.includes("fatal") ||
+      e.message?.includes("not a valid object")
+    ) {
+      return err(gitError(`File '${filePath}' not found in branch '${branch.name}'`, e));
+    }
+    return err(gitError(`Failed to read '${filePath}' from '${branch.name}'`, e));
+  }
+}
+
+export async function listBranches(
+  repoPath: string,
+  remote?: string
+): Promise<Result<BranchRef[]>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const branches: BranchRef[] = [];
+    const seen = new Set<string>();
+
+    // Remote branches (source of truth for managed clone)
+    try {
+      const remoteBranches = await git.branch(["-r"]);
+      for (const fullName of remoteBranches.all) {
+        if (fullName.includes("HEAD")) continue;
+        const parts = fullName.trim().split("/");
+        if (parts.length < 2) continue;
+        const remoteName = parts[0];
+        const branchName = parts.slice(1).join("/");
+
+        if (remote && remoteName !== remote) continue;
+        if (seen.has(branchName)) continue;
+
+        try {
+          const sha = await git.revparse([fullName.trim()]);
+          seen.add(branchName);
+          branches.push({
+            name: branchName,
+            remote: remoteName,
+            sha: sha.trim(),
+            isRemote: true,
+          });
+        } catch {
+          // skip branches we can't resolve
+        }
+      }
+    } catch {
+      // No remotes is ok
+    }
+
+    // Local branches (only if not already discovered on remote)
+    try {
+      const local = await git.branchLocal();
+      for (const name of local.all) {
+        if (!seen.has(name)) {
+          const sha = await git.revparse([name]);
+          seen.add(name);
+          branches.push({ name, sha: sha.trim(), isRemote: false });
+        }
+      }
+    } catch {
+      // ignore
+    }
+
+    return ok(branches);
+  } catch (e: any) {
+    return err(gitError("Failed to list branches", e));
+  }
+}
+
+export async function getCurrentBranch(repoPath: string): Promise<Result<string>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+    return ok(branch.trim());
+  } catch (e: any) {
+    return err(gitError("Failed to get current branch", e));
+  }
+}
+
+export async function fetch(
+  repoPath: string,
+  remote: string = "origin",
+  prune: boolean = true
+): Promise<Result<void>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const args = prune ? [remote, "--prune"] : [remote];
+    await git.fetch(args);
+    return ok(undefined);
+  } catch (e: any) {
+    return err(gitError(`Failed to fetch from '${remote}'`, e));
+  }
+}
+
+export async function getRemoteUrl(
+  repoPath: string,
+  remote: string = "origin"
+): Promise<Result<string>> {
+  try {
+    const git: SimpleGit = simpleGit(repoPath);
+    const remotes = await git.getRemotes(true);
+    const target = remotes.find((r) => r.name === remote) || remotes[0];
+    if (!target?.refs?.fetch) {
+      return err(gitError(`No remote '${remote}' found`));
+    }
+    return ok(target.refs.fetch);
+  } catch (e: any) {
+    return err(gitError("Failed to get remote URL", e));
+  }
+}
+
+export function createGitReader(): GitReader {
+  return {
+    readFileFromBranch,
+    listBranches,
+    getCurrentBranch,
+    fetch,
+    getRemoteUrl,
+  };
+}

package/src/services/report/index.ts

@@ -0,0 +1,104 @@
+import { BranchResult, PushResult, BranchPlan } from "../../core/types.js";
+import { AppConfig } from "../../config/schema.js";
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+
+export type RunReport = {
+  runId: string;
+  targetPath: string;
+  startedAt: string;
+  completedAt: string;
+  plans: BranchPlan[];
+  results: BranchResult[];
+  pushResults: PushResult[];
+};
+
+export type ReportService = {
+  saveJson(reportsDir: string, report: RunReport, config: AppConfig): Promise<void>;
+  saveMarkdown(reportsDir: string, report: RunReport, config: AppConfig): Promise<void>;
+};
+
+function redactContent(text: string): string {
+  // Replace value portions of assignments with [REDACTED]
+  return text.replace(/^([A-Za-z_][A-Za-z0-9_]*)=.+$/gm, "$1=[REDACTED]");
+}
+
+export async function saveJson(
+  reportsDir: string,
+  report: RunReport,
+  config: AppConfig
+): Promise<void> {
+  if (!config.report.writeJson) return;
+  await mkdir(reportsDir, { recursive: true });
+  const filePath = join(reportsDir, `${report.runId}.json`);
+
+  let data = report;
+  if (config.report.redactValues) {
+    data = {
+      ...report,
+      plans: report.plans.map((p) => ({
+        ...p,
+        beforeContent: redactContent(p.beforeContent),
+        afterContent: redactContent(p.afterContent),
+        diff: redactContent(p.diff),
+      })),
+    };
+  }
+
+  await writeFile(filePath, JSON.stringify(data, null, 2), "utf-8");
+}
+
+export async function saveMarkdown(
+  reportsDir: string,
+  report: RunReport,
+  config: AppConfig
+): Promise<void> {
+  if (!config.report.writeMarkdown) return;
+  await mkdir(reportsDir, { recursive: true });
+  const filePath = join(reportsDir, `${report.runId}.md`);
+
+  const statusEmoji: Record<string, string> = {
+    committed: "✅",
+    failed: "❌",
+    rejected: "⊘",
+    unchanged: "○",
+    skipped: "–",
+  };
+
+  const lines = [
+    `# Git Worker Run Report`,
+    ``,
+    `**Run ID:** ${report.runId}  `,
+    `**Target:** ${report.targetPath}  `,
+    `**Started:** ${report.startedAt}  `,
+    `**Completed:** ${report.completedAt}  `,
+    ``,
+    `## Results`,
+    ``,
+    `| Branch | Status | Commit |`,
+    `|--------|--------|--------|`,
+    ...report.results.map(
+      (r) =>
+        `| ${r.branch.name} | ${statusEmoji[r.status] ?? r.status} ${r.status} | ${r.commitSha ? `\`${r.commitSha.slice(0, 8)}\`` : "—"} |`
+    ),
+    ``,
+  ];
+
+  if (report.pushResults.length > 0) {
+    lines.push(`## Push Results`, ``);
+    lines.push(`| Branch | Status |`, `|--------|--------|`);
+    for (const pr of report.pushResults) {
+      lines.push(`| ${pr.branch.name} | ${pr.status} |`);
+    }
+    lines.push(``);
+  }
+
+  await writeFile(filePath, lines.join("\n"), "utf-8");
+}
+
+export function createReportService(): ReportService {
+  return {
+    saveJson,
+    saveMarkdown,
+  };
+}

package/src/services/review/index.ts

@@ -0,0 +1,80 @@
+import { Result, ok, err, BranchPlan } from "../../core/types.js";
+import { workspaceError } from "../../core/errors.js";
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { createPatch } from "diff";
+
+export type ReviewService = {
+  writeSnapshots(
+    stagingDir: string,
+    runId: string,
+    plan: BranchPlan
+  ): Promise<Result<{ beforePath: string; afterPath: string }>>;
+  computeDiff(before: string, after: string, filePath: string): string;
+};
+
+/**
+ * Write before/after snapshots to the staging directory for a plan.
+ * Returns the file paths for opening in a diff viewer.
+ */
+export async function writeSnapshots(
+  stagingDir: string,
+  runId: string,
+  plan: BranchPlan
+): Promise<Result<{ beforePath: string; afterPath: string }>> {
+  try {
+    const planDir = join(stagingDir, runId, plan.branch.name.replace(/\//g, "__"));
+    await mkdir(planDir, { recursive: true });
+
+    const beforePath = join(planDir, `before.${plan.path.split("/").pop()}`);
+    const afterPath = join(planDir, `after.${plan.path.split("/").pop()}`);
+
+    await writeFile(beforePath, plan.beforeContent, "utf-8");
+    await writeFile(afterPath, plan.afterContent, "utf-8");
+
+    return ok({ beforePath, afterPath });
+  } catch (e: any) {
+    return err(workspaceError(`Failed to write snapshots: ${e.message}`));
+  }
+}
+
+/**
+ * Compute a unified diff string between before and after content.
+ * Uses the `diff` package for accurate line-level diffing.
+ */
+export function computeDiff(
+  before: string,
+  after: string,
+  filePath: string
+): string {
+  if (before === after) return "";
+  return createPatch(filePath, before, after, "before", "after");
+}
+
+/**
+ * Format a diff for terminal display with color markers.
+ * Returns an array of lines with +/- prefixes for coloring.
+ */
+export function parseDiffLines(
+  diff: string
+): Array<{ line: string; type: "added" | "removed" | "header" | "context" }> {
+  const lines = diff.split("\n");
+  return lines.map((line) => {
+    if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("@@")) {
+      return { line, type: "header" as const };
+    } else if (line.startsWith("+")) {
+      return { line, type: "added" as const };
+    } else if (line.startsWith("-")) {
+      return { line, type: "removed" as const };
+    } else {
+      return { line, type: "context" as const };
+    }
+  });
+}
+
+export function createReviewService(): ReviewService {
+  return {
+    writeSnapshots,
+    computeDiff,
+  };
+}

package/src/services/state/index.ts

@@ -0,0 +1,77 @@
+import { Result, ok, err } from "../../core/types.js";
+import { workspaceError } from "../../core/errors.js";
+import { readFile, writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { existsSync } from "fs";
+
+export type TemplateState = {
+  schemaVersion: 1;
+  targetPath: string;
+  template: string;
+  updatedAt: string;
+  lastRunSummary?: {
+    committed: number;
+    failed: number;
+    skipped: number;
+    total: number;
+  };
+};
+
+export type StateService = {
+  loadTemplate(stateDir: string, targetPath: string): Promise<Result<TemplateState | null>>;
+  saveTemplate(stateDir: string, targetPath: string, templateRaw: string, summary?: TemplateState["lastRunSummary"]): Promise<Result<void>>;
+};
+
+function stateFileName(targetPath: string): string {
+  return targetPath.replace(/[/\\]/g, "__") + ".state.json";
+}
+
+export async function loadTemplate(
+  stateDir: string,
+  targetPath: string
+): Promise<Result<TemplateState | null>> {
+  const filePath = join(stateDir, stateFileName(targetPath));
+  if (!existsSync(filePath)) {
+    return ok(null);
+  }
+  try {
+    const raw = await readFile(filePath, "utf-8");
+    const data = JSON.parse(raw) as TemplateState;
+    if (data.schemaVersion !== 1) {
+      return ok(null); // Unknown schema — start fresh
+    }
+    return ok(data);
+  } catch (e: any) {
+    return err(workspaceError(`Failed to load template state: ${e.message}`));
+  }
+}
+
+export async function saveTemplate(
+  stateDir: string,
+  targetPath: string,
+  templateRaw: string,
+  summary?: TemplateState["lastRunSummary"]
+): Promise<Result<void>> {
+  try {
+    await mkdir(stateDir, { recursive: true });
+    const filePath = join(stateDir, stateFileName(targetPath));
+    const state: TemplateState = {
+      schemaVersion: 1,
+      targetPath,
+      template: templateRaw,
+      updatedAt: new Date().toISOString(),
+      ...(summary ? { lastRunSummary: summary } : {}),
+    };
+    await writeFile(filePath, JSON.stringify(state, null, 2), "utf-8");
+    return ok(undefined);
+  } catch (e: any) {
+    return err(workspaceError(`Failed to save template state: ${e.message}`));
+  }
+}
+
+export function createStateService(): StateService {
+  return {
+    loadTemplate,
+    saveTemplate,
+  };
+}