@samaksh/git-worker 0.1.0 → 0.2.1

package/src/services/editor/index.ts

@@ -1,85 +0,0 @@
-import { Result, ok, err } from "../../core/types.js";
-import { editorError, inputCancelledError } from "../../core/errors.js";
-import { spawn } from "child_process";
-import { AppConfig } from "../../config/schema.js";
-import { existsSync } from "fs";
-import { which } from "../../utils/which.js";
-
-export type EditorService = {
-  openForEdit(templatePath: string, config: AppConfig): Promise<Result<void>>;
-  openForDiff(beforePath: string, afterPath: string, config: AppConfig): Promise<Result<void>>;
-};
-
-/**
- * Substitute {file}, {before}, {after} placeholders in a command template.
- */
-function buildCommand(
-  template: string[],
-  vars: Record<string, string>
-): string[] {
-  return template.map((part) => {
-    let result = part;
-    for (const [k, v] of Object.entries(vars)) {
-      result = result.replace(`{${k}}`, v);
-    }
-    return result;
-  });
-}
-
-/**
- * Spawn a command and wait for it to exit.
- * Returns an error if the process exits with a non-zero code.
- */
-async function runCommand(
-  cmd: string[],
-  description: string
-): Promise<Result<void>> {
-  return new Promise((resolve) => {
-    const [bin, ...args] = cmd;
-    const proc = spawn(bin, args, { stdio: "inherit" });
-
-    proc.on("error", (e: any) => {
-      if (e.code === "ENOENT") {
-        resolve(err(editorError(`Editor '${bin}' not found. Install it or set a different editor via --editor or git-worker.config.json.`)));
-      } else {
-        resolve(err(editorError(`${description} failed: ${e.message}`)));
-      }
-    });
-
-    proc.on("close", (code) => {
-      if (code === 0) {
-        resolve(ok(undefined));
-      } else {
-        // Some editors (like VS Code) return non-zero on cancel
-        resolve(ok(undefined));
-      }
-    });
-  });
-}
-
-export async function openForEdit(
-  templatePath: string,
-  config: AppConfig
-): Promise<Result<void>> {
-  const cmd = buildCommand(config.editor.editCommand, { file: templatePath });
-  return runCommand(cmd, "Editor");
-}
-
-export async function openForDiff(
-  beforePath: string,
-  afterPath: string,
-  config: AppConfig
-): Promise<Result<void>> {
-  const cmd = buildCommand(config.editor.diffCommand, {
-    before: beforePath,
-    after: afterPath,
-  });
-  return runCommand(cmd, "Diff viewer");
-}
-
-export function createEditorService(): EditorService {
-  return {
-    openForEdit,
-    openForDiff,
-  };
-}

package/src/services/git/ops.ts

@@ -1,170 +0,0 @@
-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

@@ -1,148 +0,0 @@
-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

@@ -1,104 +0,0 @@
-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

@@ -1,80 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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,
-  };
-}