@samaksh/git-worker 0.0.0-stage → 0.1.0

package/dist/core/types.d.ts

@@ -0,0 +1,153 @@
+export type Result<T, E = AppError> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    error: E;
+};
+export type AppErrorCategory = "CONFIG" | "GIT" | "EDITOR" | "TEMPLATE" | "ELIGIBILITY" | "INPUT_CANCELLED" | "STALE_PLAN" | "APPLY" | "PUSH" | "WORKSPACE" | "VALIDATION";
+export declare class AppError extends Error {
+    category: AppErrorCategory;
+    details?: unknown;
+    constructor(category: AppErrorCategory, message: string, details?: unknown);
+}
+export declare function ok<T>(value: T): Result<T>;
+export declare function err<E extends AppError>(error: E): Result<never, E>;
+export type BranchRef = {
+    name: string;
+    remote?: string;
+    sha: string;
+    isRemote: boolean;
+};
+export type TargetFile = {
+    path: string;
+};
+export type TemplateEngineType = "env-reconcile" | "source-of-truth";
+export type TargetTemplate = {
+    path: string;
+    engine: TemplateEngineType;
+    raw: string;
+    parsedEnv?: TemplateDocument;
+    variables?: Array<{
+        name: string;
+        fallback?: string;
+        raw: string;
+    }>;
+    isNewFile?: boolean;
+};
+export type ManagedProject = {
+    id: string;
+    sourceRepoPath: string;
+    remoteUrl?: string;
+    managedRepoPath: string;
+    stagingDir: string;
+    stateDir: string;
+    reportsDir: string;
+    markerPath: string;
+    isCached?: boolean;
+};
+export type TemplateDocument = {
+    raw: string;
+    assignments: TemplateAssignment[];
+    placeholders: string[];
+};
+export type TemplateAssignment = {
+    key: string;
+    value: string;
+    isStatic: boolean;
+    isPlaceholder: boolean;
+    placeholderName?: string;
+    originalLine: string;
+};
+export type EnvEntry = {
+    key: string;
+    value: string;
+    lineIndex: number;
+    originalLine: string;
+    hasExport: boolean;
+};
+export type BranchContent = {
+    branch: BranchRef;
+    exists: boolean;
+    content?: string;
+    error?: string;
+};
+export type MissingValueRequest = {
+    branch: BranchRef;
+    key: string;
+};
+export type BranchPlan = {
+    branch: BranchRef;
+    baseCommitSha: string;
+    path: string;
+    beforeContent: string;
+    beforeContentHash: string;
+    afterContent: string;
+    afterContentHash: string;
+    diff: string;
+    planHash: string;
+    status: "changed" | "unchanged" | "error";
+    reason?: string;
+    addedKeys: string[];
+    updatedKeys: string[];
+    missingVars?: string[];
+    isNewFile?: boolean;
+};
+export type Approval = {
+    branchName: string;
+    approved: boolean;
+    planHash: string;
+};
+export type BranchResult = {
+    branch: BranchRef;
+    status: "skipped" | "rejected" | "unchanged" | "committed" | "failed";
+    commitSha?: string;
+    reason?: string;
+};
+export type PushResult = {
+    branch: BranchRef;
+    status: "pushed" | "skipped" | "failed";
+    reason?: string;
+};
+export type CliInput = {
+    repo?: string;
+    cached?: boolean;
+    branch?: string;
+    invertBranch?: boolean;
+    file?: string;
+    editor?: string;
+    commitMsg?: string;
+    push?: "prompt" | "always" | "never";
+    remote?: string;
+    autoApprove?: boolean;
+    ci?: boolean;
+};
+export type AppServices = {
+    git: import("../services/git/reader.js").GitReader;
+    gitOps: import("../services/git/ops.js").GitOps;
+    workspace: import("../services/workspace/manager.js").WorkspaceManager;
+    template: import("../services/template/transform.js").TemplateService;
+    state: import("../services/state/index.js").StateService;
+    editor: import("../services/editor/index.js").EditorService;
+    review: import("../services/review/index.js").ReviewService;
+};
+export type AppDeps = {
+    config: import("../config/schema.js").AppConfig;
+    services: AppServices;
+};
+export type RunContext = {
+    runId: string;
+    input: CliInput;
+    project?: ManagedProject;
+    selectedBranches?: BranchRef[];
+    target?: TargetFile;
+    targets?: TargetFile[];
+    eligible?: BranchRef[];
+    template?: TemplateDocument;
+    activeTemplate?: TargetTemplate;
+    templates?: TargetTemplate[];
+    plans?: BranchPlan[];
+    approvals?: Approval[];
+    results?: BranchResult[];
+    pushResults?: PushResult[];
+};

package/dist/core/types.js

@@ -0,0 +1,16 @@
+export class AppError extends Error {
+    category;
+    details;
+    constructor(category, message, details) {
+        super(message);
+        this.name = "AppError";
+        this.category = category;
+        this.details = details;
+    }
+}
+export function ok(value) {
+    return { ok: true, value };
+}
+export function err(error) {
+    return { ok: false, error };
+}

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

@@ -0,0 +1,9 @@
+import { Result } from "../../core/types.js";
+import { AppConfig } from "../../config/schema.js";
+export type EditorService = {
+    openForEdit(templatePath: string, config: AppConfig): Promise<Result<void>>;
+    openForDiff(beforePath: string, afterPath: string, config: AppConfig): Promise<Result<void>>;
+};
+export declare function openForEdit(templatePath: string, config: AppConfig): Promise<Result<void>>;
+export declare function openForDiff(beforePath: string, afterPath: string, config: AppConfig): Promise<Result<void>>;
+export declare function createEditorService(): EditorService;

package/dist/services/editor/index.js

@@ -0,0 +1,59 @@
+import { ok, err } from "../../core/types.js";
+import { editorError } from "../../core/errors.js";
+import { spawn } from "child_process";
+/**
+ * Substitute {file}, {before}, {after} placeholders in a command template.
+ */
+function buildCommand(template, vars) {
+    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, description) {
+    return new Promise((resolve) => {
+        const [bin, ...args] = cmd;
+        const proc = spawn(bin, args, { stdio: "inherit" });
+        proc.on("error", (e) => {
+            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, config) {
+    const cmd = buildCommand(config.editor.editCommand, { file: templatePath });
+    return runCommand(cmd, "Editor");
+}
+export async function openForDiff(beforePath, afterPath, config) {
+    const cmd = buildCommand(config.editor.diffCommand, {
+        before: beforePath,
+        after: afterPath,
+    });
+    return runCommand(cmd, "Diff viewer");
+}
+export function createEditorService() {
+    return {
+        openForEdit,
+        openForDiff,
+    };
+}

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

@@ -0,0 +1,30 @@
+import { Result } from "../../core/types.js";
+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 declare function ensureRepo(repoPath: string): Promise<Result<void>>;
+export declare function checkoutBranch(repoPath: string, branchName: string): Promise<Result<void>>;
+export declare function resetHard(repoPath: string): Promise<Result<void>>;
+export declare function clean(repoPath: string, mode?: "tracked-and-untracked" | "tracked-only"): Promise<Result<void>>;
+/**
+ * Atomically write a file (via temp file + rename) and stage it.
+ * Only stages the specific path — no glob or wildcard.
+ */
+export declare function writeAndStage(repoPath: string, filePath: string, content: string): Promise<Result<void>>;
+/**
+ * Returns the list of staged file paths.
+ * Used to verify only the intended path is staged before committing.
+ */
+export declare function getStagedFiles(repoPath: string): Promise<Result<string[]>>;
+export declare function commit(repoPath: string, message: string): Promise<Result<string>>;
+export declare function push(repoPath: string, remote: string, branchName: string): Promise<Result<void>>;
+export declare function getBranchSha(repoPath: string, branchName: string): Promise<Result<string>>;
+export declare function createGitOps(): GitOps;

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,124 @@
+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);
+        const branches = [];
+        const seen = new Set();
+        // 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) {
+        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;