@samaksh/git-worker 0.0.0-stage → 0.2.0

package/dist/services/git/ops.js

@@ -0,0 +1,139 @@
+import { simpleGit } from "simple-git";
+import { ok, err } from "../../core/types.js";
+import { gitError } from "../../core/errors.js";
+import { writeFile, mkdir, rename } from "fs/promises";
+import { dirname, join } from "path";
+export async function ensureRepo(repoPath) {
+    try {
+        const git = simpleGit(repoPath);
+        const isRepo = await git.checkIsRepo();
+        if (!isRepo)
+            return err(gitError("Not a git repository"));
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(gitError("Failed to check repository", e));
+    }
+}
+export async function checkoutBranch(repoPath, branchName) {
+    try {
+        const git = 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) {
+        return err(gitError(`Failed to checkout '${branchName}'`, e));
+    }
+}
+export async function resetHard(repoPath) {
+    try {
+        const git = simpleGit(repoPath);
+        await git.reset(["--hard"]);
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(gitError("Failed to reset --hard", e));
+    }
+}
+export async function clean(repoPath, mode = "tracked-and-untracked") {
+    try {
+        const git = 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) {
+        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, filePath, content) {
+    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(repoPath);
+        await git.add([filePath]);
+        return ok(undefined);
+    }
+    catch (e) {
+        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) {
+    try {
+        const git = 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) {
+        return err(gitError("Failed to get staged files", e));
+    }
+}
+export async function commit(repoPath, message) {
+    try {
+        const git = simpleGit(repoPath);
+        const result = await git.commit(message);
+        return ok(result.commit);
+    }
+    catch (e) {
+        return err(gitError(`Failed to commit: ${e.message}`, e));
+    }
+}
+export async function push(repoPath, remote, branchName) {
+    try {
+        const git = simpleGit(repoPath);
+        // Non-force push only
+        await git.push([remote, `${branchName}:${branchName}`]);
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(gitError(`Failed to push '${branchName}' to '${remote}': ${e.message}`, e));
+    }
+}
+export async function getBranchSha(repoPath, branchName) {
+    try {
+        const git = simpleGit(repoPath);
+        const sha = await git.revparse([branchName]);
+        return ok(sha.trim());
+    }
+    catch (e) {
+        return err(gitError(`Failed to get SHA for '${branchName}'`, e));
+    }
+}
+export function createGitOps() {
+    return {
+        ensureRepo,
+        checkoutBranch,
+        resetHard,
+        clean,
+        writeAndStage,
+        getStagedFiles,
+        commit,
+        push,
+        getBranchSha,
+    };
+}

package/dist/services/git/reader.d.ts

@@ -0,0 +1,14 @@
+import { Result, BranchRef } from "../../core/types.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 declare function readFileFromBranch(repoPath: string, branch: BranchRef, filePath: string): Promise<Result<string>>;
+export declare function listBranches(repoPath: string, remote?: string): Promise<Result<BranchRef[]>>;
+export declare function getCurrentBranch(repoPath: string): Promise<Result<string>>;
+export declare function fetch(repoPath: string, remote?: string, prune?: boolean): Promise<Result<void>>;
+export declare function getRemoteUrl(repoPath: string, remote?: string): Promise<Result<string>>;
+export declare function createGitReader(): GitReader;

package/dist/services/git/reader.js

@@ -0,0 +1,195 @@
+import { simpleGit } from "simple-git";
+import { ok, err } from "../../core/types.js";
+import { gitError } from "../../core/errors.js";
+export async function readFileFromBranch(repoPath, branch, filePath) {
+    try {
+        const git = 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) {
+        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, remote) {
+    try {
+        const git = simpleGit(repoPath);
+        // Fast path: use git for-each-ref plumbing command.
+        // Retrieves all branch names, SHAs, and ref types in a single process execution (<25ms for 300+ branches)
+        // instead of running hundreds of sequential rev-parse child processes.
+        try {
+            const rawOutput = await git.raw([
+                "for-each-ref",
+                "--sort=-committerdate",
+                "--format=%(objectname)\t%(refname)",
+                "refs/remotes",
+                "refs/heads",
+            ]);
+            const remoteBranches = [];
+            const localBranches = [];
+            for (const rawLine of rawOutput.split("\n")) {
+                const line = rawLine.trim();
+                if (!line)
+                    continue;
+                const tabIdx = line.indexOf("\t");
+                if (tabIdx === -1)
+                    continue;
+                const sha = line.substring(0, tabIdx).trim();
+                const refname = line.substring(tabIdx + 1).trim();
+                if (!sha || !refname)
+                    continue;
+                if (refname.startsWith("refs/remotes/")) {
+                    const rest = refname.substring("refs/remotes/".length);
+                    const slashIdx = rest.indexOf("/");
+                    if (slashIdx === -1)
+                        continue;
+                    const remoteName = rest.substring(0, slashIdx);
+                    const branchName = rest.substring(slashIdx + 1);
+                    // Skip symbolic refs like origin/HEAD
+                    if (branchName === "HEAD" || branchName.endsWith("/HEAD"))
+                        continue;
+                    if (remote && remoteName !== remote)
+                        continue;
+                    remoteBranches.push({
+                        name: branchName,
+                        remote: remoteName,
+                        sha,
+                        isRemote: true,
+                    });
+                }
+                else if (refname.startsWith("refs/heads/")) {
+                    const branchName = refname.substring("refs/heads/".length);
+                    localBranches.push({
+                        name: branchName,
+                        sha,
+                        isRemote: false,
+                    });
+                }
+            }
+            const branches = [];
+            const seen = new Set();
+            // 1. Remote branches take priority (source of truth for managed clone)
+            for (const b of remoteBranches) {
+                if (!seen.has(b.name)) {
+                    seen.add(b.name);
+                    branches.push(b);
+                }
+            }
+            // 2. Local branches (only if not already discovered on remote)
+            for (const b of localBranches) {
+                if (!seen.has(b.name)) {
+                    seen.add(b.name);
+                    branches.push(b);
+                }
+            }
+            return ok(branches);
+        }
+        catch {
+            // Fallback path: use standard branch enumeration if for-each-ref fails
+            const branches = [];
+            const seen = new Set();
+            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 unresolvable
+                    }
+                }
+            }
+            catch {
+                // no remotes
+            }
+            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) {
+        return err(gitError("Failed to list branches", e));
+    }
+}
+export async function getCurrentBranch(repoPath) {
+    try {
+        const git = simpleGit(repoPath);
+        const branch = await git.revparse(["--abbrev-ref", "HEAD"]);
+        return ok(branch.trim());
+    }
+    catch (e) {
+        return err(gitError("Failed to get current branch", e));
+    }
+}
+export async function fetch(repoPath, remote = "origin", prune = true) {
+    try {
+        const git = simpleGit(repoPath);
+        const args = prune ? [remote, "--prune"] : [remote];
+        await git.fetch(args);
+        return ok(undefined);
+    }
+    catch (e) {
+        return err(gitError(`Failed to fetch from '${remote}'`, e));
+    }
+}
+export async function getRemoteUrl(repoPath, remote = "origin") {
+    try {
+        const git = 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) {
+        return err(gitError("Failed to get remote URL", e));
+    }
+}
+export function createGitReader() {
+    return {
+        readFileFromBranch,
+        listBranches,
+        getCurrentBranch,
+        fetch,
+        getRemoteUrl,
+    };
+}

package/dist/services/report/index.d.ts

@@ -0,0 +1,18 @@
+import { BranchResult, PushResult, BranchPlan } from "../../core/types.js";
+import { AppConfig } from "../../config/schema.js";
+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>;
+};
+export declare function saveJson(reportsDir: string, report: RunReport, config: AppConfig): Promise<void>;
+export declare function saveMarkdown(reportsDir: string, report: RunReport, config: AppConfig): Promise<void>;
+export declare function createReportService(): ReportService;

package/dist/services/report/index.js

@@ -0,0 +1,68 @@
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+function redactContent(text) {
+    // 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, report, config) {
+    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, report, config) {
+    if (!config.report.writeMarkdown)
+        return;
+    await mkdir(reportsDir, { recursive: true });
+    const filePath = join(reportsDir, `${report.runId}.md`);
+    const statusEmoji = {
+        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() {
+    return {
+        saveJson,
+        saveMarkdown,
+    };
+}

package/dist/services/review/index.d.ts

@@ -0,0 +1,30 @@
+import { Result, BranchPlan } from "../../core/types.js";
+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 declare function writeSnapshots(stagingDir: string, runId: string, plan: BranchPlan): Promise<Result<{
+    beforePath: string;
+    afterPath: string;
+}>>;
+/**
+ * Compute a unified diff string between before and after content.
+ * Uses the `diff` package for accurate line-level diffing.
+ */
+export declare function computeDiff(before: string, after: string, filePath: string): string;
+/**
+ * Format a diff for terminal display with color markers.
+ * Returns an array of lines with +/- prefixes for coloring.
+ */
+export declare function parseDiffLines(diff: string): Array<{
+    line: string;
+    type: "added" | "removed" | "header" | "context";
+}>;
+export declare function createReviewService(): ReviewService;

package/dist/services/review/index.js

@@ -0,0 +1,59 @@
+import { ok, err } from "../../core/types.js";
+import { workspaceError } from "../../core/errors.js";
+import { writeFile, mkdir } from "fs/promises";
+import { join } from "path";
+import { createPatch } from "diff";
+/**
+ * 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, runId, plan) {
+    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) {
+        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, after, filePath) {
+    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) {
+    const lines = diff.split("\n");
+    return lines.map((line) => {
+        if (line.startsWith("+++") || line.startsWith("---") || line.startsWith("@@")) {
+            return { line, type: "header" };
+        }
+        else if (line.startsWith("+")) {
+            return { line, type: "added" };
+        }
+        else if (line.startsWith("-")) {
+            return { line, type: "removed" };
+        }
+        else {
+            return { line, type: "context" };
+        }
+    });
+}
+export function createReviewService() {
+    return {
+        writeSnapshots,
+        computeDiff,
+    };
+}

package/dist/services/state/index.d.ts

@@ -0,0 +1,20 @@
+import { Result } from "../../core/types.js";
+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>>;
+};
+export declare function loadTemplate(stateDir: string, targetPath: string): Promise<Result<TemplateState | null>>;
+export declare function saveTemplate(stateDir: string, targetPath: string, templateRaw: string, summary?: TemplateState["lastRunSummary"]): Promise<Result<void>>;
+export declare function createStateService(): StateService;

package/dist/services/state/index.js

@@ -0,0 +1,49 @@
+import { 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";
+function stateFileName(targetPath) {
+    return targetPath.replace(/[/\\]/g, "__") + ".state.json";
+}
+export async function loadTemplate(stateDir, targetPath) {
+    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);
+        if (data.schemaVersion !== 1) {
+            return ok(null); // Unknown schema — start fresh
+        }
+        return ok(data);
+    }
+    catch (e) {
+        return err(workspaceError(`Failed to load template state: ${e.message}`));
+    }
+}
+export async function saveTemplate(stateDir, targetPath, templateRaw, summary) {
+    try {
+        await mkdir(stateDir, { recursive: true });
+        const filePath = join(stateDir, stateFileName(targetPath));
+        const state = {
+            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) {
+        return err(workspaceError(`Failed to save template state: ${e.message}`));
+    }
+}
+export function createStateService() {
+    return {
+        loadTemplate,
+        saveTemplate,
+    };
+}

package/dist/services/template/env.d.ts

@@ -0,0 +1,23 @@
+import { TemplateDocument, Result, EnvEntry } from "../../core/types.js";
+/**
+ * Parse a .env template file into structured assignments.
+ * Template uses {KEY} for dynamic placeholders, KEY=value for static.
+ */
+export declare function parseEnvTemplate(raw: string): Result<TemplateDocument>;
+/**
+ * Parse a .env file into a map of key → EnvEntry (preserving export, quoting, lineIndex).
+ * Returns an error if duplicate keys are found.
+ * Lines that cannot be parsed as assignments are tracked but not included in the map.
+ */
+export declare function parseEnvFile(content: string): Result<{
+    map: Map<string, EnvEntry>;
+    lines: string[];
+}>;
+/**
+ * Synthesize a first-run template draft from common keys across branches.
+ * Uniform values → static assignment. Varying values → dynamic placeholder.
+ */
+export declare function synthesizeTemplate(branchContents: Array<{
+    branchName: string;
+    content: string;
+}>): string;