@samaksh/git-worker 0.0.0-stage → 0.1.0

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,115 @@
+#!/usr/bin/env node
+import { Command } from "commander";
+import { run } from "../app.js";
+import { handleCacheList, handleCacheClean } from "./commands.js";
+import chalk from "chalk";
+const program = new Command();
+program
+    .name("git-worker")
+    .description("Safe, composable CLI/TUI for applying reviewed file changes across many Git branches")
+    .version("0.1.0")
+    .option("-r, --repo <path>", "Repository path or remote URL (default: current directory)")
+    .option("-c, --cached", "Select from previously cloned and cached repositories")
+    .option("-b, --branch <pattern>", "Branch pattern — glob (uat/*) or regex (/uat.*/)")
+    .option("-i, --invert-branch", "Invert the branch selection pattern")
+    .option("-f, --file <path>", "Target file path inside the repository (e.g. .env)")
+    .option("-e, --editor <name>", "Editor to use: code (VS Code) or vim")
+    .option("-m, --commit-msg <message>", "Commit message")
+    .option("-p, --push <policy>", "Push policy: prompt (default) | always | never")
+    .option("--remote <name>", "Git remote name (default: origin)")
+    .option("--auto-approve", "Auto-approve all changes (skip interactive review)")
+    .option("--ci", "CI mode: non-interactive, fail on missing dynamic values")
+    .action(async (opts) => {
+    // Validate push policy
+    if (opts.push && !["prompt", "always", "never"].includes(opts.push)) {
+        console.error(chalk.red(`  ✗ Invalid push policy '${opts.push}'. Must be: prompt | always | never`));
+        process.exit(1);
+    }
+    // Validate incompatible combinations
+    if (opts.ci && opts.push === "prompt") {
+        console.error(chalk.yellow(`  ⚠ Warning: --ci with --push prompt will not push (no interactive prompt in CI). Use --push always or --push never.`));
+    }
+    try {
+        const result = await run({
+            repo: opts.repo,
+            cached: opts.cached ?? false,
+            branch: opts.branch,
+            invertBranch: opts.invertBranch ?? false,
+            file: opts.file,
+            editor: opts.editor,
+            commitMsg: opts.commitMsg,
+            push: opts.push,
+            remote: opts.remote,
+            autoApprove: opts.autoApprove ?? false,
+            ci: opts.ci ?? false,
+        });
+        if (!result.ok) {
+            const { error } = result;
+            if (error.category === "INPUT_CANCELLED") {
+                console.log(chalk.gray("\n  Cancelled."));
+                process.exit(0);
+            }
+            console.error(chalk.red(`\n  ✗ [${error.category}] ${error.message}`));
+            process.exit(1);
+        }
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(chalk.red(`\n  ✗ Fatal: ${e.message}`));
+        if (process.env.DEBUG) {
+            console.error(e.stack);
+        }
+        process.exit(1);
+    }
+});
+// ── Cache management subcommands ──────────────────────────────────────────
+const cacheCmd = program
+    .command("cache")
+    .description("Manage git-worker's cached workspaces and repositories (~/.git-worker)");
+cacheCmd
+    .command("list")
+    .alias("ls")
+    .description("List all cached projects")
+    .action(async () => {
+    try {
+        await handleCacheList();
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(chalk.red(`  ✗ Error: ${e.message}`));
+        process.exit(1);
+    }
+});
+cacheCmd
+    .command("clean [target]")
+    .alias("clear")
+    .description("Clean workspace cache (all or a specific project)")
+    .option("-a, --all", "Clean all cached projects")
+    .option("-y, --yes", "Skip confirmation prompt")
+    .action(async (target, opts) => {
+    try {
+        await handleCacheClean(target, opts);
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(chalk.red(`  ✗ Error: ${e.message}`));
+        process.exit(1);
+    }
+});
+// Convenient top-level alias: git-worker clean [target] [-a]
+program
+    .command("clean [target]")
+    .description("Shorthand to clean cached workspace(s)")
+    .option("-a, --all", "Clean all cached projects")
+    .option("-y, --yes", "Skip confirmation prompt")
+    .action(async (target, opts) => {
+    try {
+        await handleCacheClean(target, opts);
+        process.exit(0);
+    }
+    catch (e) {
+        console.error(chalk.red(`  ✗ Error: ${e.message}`));
+        process.exit(1);
+    }
+});
+program.parse();

package/dist/config/defaults.d.ts

@@ -0,0 +1,2 @@
+import { AppConfig } from "./schema.js";
+export declare const DEFAULT_CONFIG: AppConfig;

package/dist/config/defaults.js

@@ -0,0 +1,44 @@
+export const DEFAULT_CONFIG = {
+    git: {
+        remote: "origin",
+        fetchPrune: true,
+        cleanMode: "tracked-and-untracked",
+        pushPolicy: "prompt",
+        commitMessage: "chore: sync configuration",
+    },
+    workspace: {
+        root: ".git-worker",
+        lockTimeoutMs: 30000,
+    },
+    editor: {
+        name: "code",
+        editCommand: ["code", "--wait", "{file}"],
+        diffCommand: ["code", "--diff", "{before}", "{after}"],
+    },
+    template: {
+        placeholderOpen: "{",
+        placeholderClose: "}",
+        missingValuePolicy: "prompt-each-branch",
+        emptyValueIsPresent: true,
+        unmanagedKeyPolicy: "preserve",
+        removedTemplateKeyPolicy: "preserve",
+    },
+    review: {
+        autoApprove: false,
+        readOnlySnapshots: true,
+    },
+    execution: {
+        concurrency: 1,
+        stopOnBranchError: false,
+    },
+    report: {
+        writeJson: false,
+        writeMarkdown: false,
+        redactValues: true,
+        warnOnSecrets: true,
+    },
+    safety: {
+        rejectNoRemote: true,
+        saveOnPartialSuccess: true,
+    },
+};

package/dist/config/load.d.ts

@@ -0,0 +1,3 @@
+import { AppConfig } from "./schema.js";
+import { CliInput } from "../core/types.js";
+export declare function loadConfig(cliInput: CliInput): AppConfig;

package/dist/config/load.js

@@ -0,0 +1,65 @@
+import { AppConfigSchema } from "./schema.js";
+import { DEFAULT_CONFIG } from "./defaults.js";
+import { existsSync, readFileSync } from "fs";
+import { join, resolve } from "path";
+function loadProjectConfig(repoPath) {
+    const candidates = [
+        join(resolve(repoPath), "git-worker.config.json"),
+        join(resolve(repoPath), ".git-worker.config.json"),
+    ];
+    for (const candidate of candidates) {
+        if (existsSync(candidate)) {
+            try {
+                const raw = readFileSync(candidate, "utf-8");
+                return JSON.parse(raw);
+            }
+            catch {
+                // ignore malformed
+            }
+        }
+    }
+    return {};
+}
+function deepMerge(base, override) {
+    const result = { ...base };
+    for (const key of Object.keys(override)) {
+        const overrideVal = override[key];
+        if (overrideVal === undefined)
+            continue;
+        if (typeof overrideVal === "object" &&
+            overrideVal !== null &&
+            !Array.isArray(overrideVal) &&
+            typeof result[key] === "object" &&
+            result[key] !== null) {
+            result[key] = deepMerge(result[key], overrideVal);
+        }
+        else {
+            result[key] = overrideVal;
+        }
+    }
+    return result;
+}
+export function loadConfig(cliInput) {
+    // Load project config from repo directory
+    const repoPath = cliInput.repo || process.cwd();
+    const projectConfig = loadProjectConfig(repoPath);
+    // Merge: defaults < project config < CLI overrides
+    const cliOverrides = {
+        git: {
+            ...DEFAULT_CONFIG.git,
+            ...(cliInput.push ? { pushPolicy: cliInput.push } : {}),
+            ...(cliInput.commitMsg ? { commitMessage: cliInput.commitMsg } : {}),
+            ...(cliInput.remote ? { remote: cliInput.remote } : {}),
+        },
+        editor: {
+            ...DEFAULT_CONFIG.editor,
+            ...(cliInput.editor ? { name: cliInput.editor } : {}),
+        },
+        review: {
+            ...DEFAULT_CONFIG.review,
+            ...(cliInput.autoApprove !== undefined ? { autoApprove: cliInput.autoApprove } : {}),
+        },
+    };
+    const merged = deepMerge(deepMerge(DEFAULT_CONFIG, projectConfig), cliOverrides);
+    return Object.freeze(AppConfigSchema.parse(merged));
+}

package/dist/config/schema.d.ts

@@ -0,0 +1,200 @@
+import { z } from "zod";
+export declare const AppConfigSchema: z.ZodObject<{
+    git: z.ZodObject<{
+        remote: z.ZodDefault<z.ZodString>;
+        fetchPrune: z.ZodDefault<z.ZodBoolean>;
+        cleanMode: z.ZodDefault<z.ZodEnum<["tracked-and-untracked", "tracked-only"]>>;
+        pushPolicy: z.ZodDefault<z.ZodEnum<["prompt", "always", "never"]>>;
+        commitMessage: z.ZodDefault<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        remote: string;
+        fetchPrune: boolean;
+        cleanMode: "tracked-and-untracked" | "tracked-only";
+        pushPolicy: "never" | "prompt" | "always";
+        commitMessage: string;
+    }, {
+        remote?: string | undefined;
+        fetchPrune?: boolean | undefined;
+        cleanMode?: "tracked-and-untracked" | "tracked-only" | undefined;
+        pushPolicy?: "never" | "prompt" | "always" | undefined;
+        commitMessage?: string | undefined;
+    }>;
+    workspace: z.ZodObject<{
+        root: z.ZodDefault<z.ZodString>;
+        lockTimeoutMs: z.ZodDefault<z.ZodNumber>;
+    }, "strip", z.ZodTypeAny, {
+        root: string;
+        lockTimeoutMs: number;
+    }, {
+        root?: string | undefined;
+        lockTimeoutMs?: number | undefined;
+    }>;
+    editor: z.ZodObject<{
+        name: z.ZodDefault<z.ZodString>;
+        editCommand: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+        diffCommand: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        editCommand: string[];
+        diffCommand: string[];
+    }, {
+        name?: string | undefined;
+        editCommand?: string[] | undefined;
+        diffCommand?: string[] | undefined;
+    }>;
+    template: z.ZodObject<{
+        placeholderOpen: z.ZodDefault<z.ZodString>;
+        placeholderClose: z.ZodDefault<z.ZodString>;
+        missingValuePolicy: z.ZodDefault<z.ZodEnum<["prompt-each-branch"]>>;
+        emptyValueIsPresent: z.ZodDefault<z.ZodBoolean>;
+        unmanagedKeyPolicy: z.ZodDefault<z.ZodEnum<["preserve"]>>;
+        removedTemplateKeyPolicy: z.ZodDefault<z.ZodEnum<["preserve"]>>;
+    }, "strip", z.ZodTypeAny, {
+        placeholderOpen: string;
+        placeholderClose: string;
+        missingValuePolicy: "prompt-each-branch";
+        emptyValueIsPresent: boolean;
+        unmanagedKeyPolicy: "preserve";
+        removedTemplateKeyPolicy: "preserve";
+    }, {
+        placeholderOpen?: string | undefined;
+        placeholderClose?: string | undefined;
+        missingValuePolicy?: "prompt-each-branch" | undefined;
+        emptyValueIsPresent?: boolean | undefined;
+        unmanagedKeyPolicy?: "preserve" | undefined;
+        removedTemplateKeyPolicy?: "preserve" | undefined;
+    }>;
+    review: z.ZodObject<{
+        autoApprove: z.ZodDefault<z.ZodBoolean>;
+        readOnlySnapshots: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        autoApprove: boolean;
+        readOnlySnapshots: boolean;
+    }, {
+        autoApprove?: boolean | undefined;
+        readOnlySnapshots?: boolean | undefined;
+    }>;
+    execution: z.ZodObject<{
+        concurrency: z.ZodDefault<z.ZodNumber>;
+        stopOnBranchError: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        concurrency: number;
+        stopOnBranchError: boolean;
+    }, {
+        concurrency?: number | undefined;
+        stopOnBranchError?: boolean | undefined;
+    }>;
+    report: z.ZodObject<{
+        writeJson: z.ZodDefault<z.ZodBoolean>;
+        writeMarkdown: z.ZodDefault<z.ZodBoolean>;
+        redactValues: z.ZodDefault<z.ZodBoolean>;
+        warnOnSecrets: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        writeJson: boolean;
+        writeMarkdown: boolean;
+        redactValues: boolean;
+        warnOnSecrets: boolean;
+    }, {
+        writeJson?: boolean | undefined;
+        writeMarkdown?: boolean | undefined;
+        redactValues?: boolean | undefined;
+        warnOnSecrets?: boolean | undefined;
+    }>;
+    safety: z.ZodObject<{
+        rejectNoRemote: z.ZodDefault<z.ZodBoolean>;
+        saveOnPartialSuccess: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        rejectNoRemote: boolean;
+        saveOnPartialSuccess: boolean;
+    }, {
+        rejectNoRemote?: boolean | undefined;
+        saveOnPartialSuccess?: boolean | undefined;
+    }>;
+}, "strip", z.ZodTypeAny, {
+    git: {
+        remote: string;
+        fetchPrune: boolean;
+        cleanMode: "tracked-and-untracked" | "tracked-only";
+        pushPolicy: "never" | "prompt" | "always";
+        commitMessage: string;
+    };
+    workspace: {
+        root: string;
+        lockTimeoutMs: number;
+    };
+    editor: {
+        name: string;
+        editCommand: string[];
+        diffCommand: string[];
+    };
+    template: {
+        placeholderOpen: string;
+        placeholderClose: string;
+        missingValuePolicy: "prompt-each-branch";
+        emptyValueIsPresent: boolean;
+        unmanagedKeyPolicy: "preserve";
+        removedTemplateKeyPolicy: "preserve";
+    };
+    review: {
+        autoApprove: boolean;
+        readOnlySnapshots: boolean;
+    };
+    execution: {
+        concurrency: number;
+        stopOnBranchError: boolean;
+    };
+    report: {
+        writeJson: boolean;
+        writeMarkdown: boolean;
+        redactValues: boolean;
+        warnOnSecrets: boolean;
+    };
+    safety: {
+        rejectNoRemote: boolean;
+        saveOnPartialSuccess: boolean;
+    };
+}, {
+    git: {
+        remote?: string | undefined;
+        fetchPrune?: boolean | undefined;
+        cleanMode?: "tracked-and-untracked" | "tracked-only" | undefined;
+        pushPolicy?: "never" | "prompt" | "always" | undefined;
+        commitMessage?: string | undefined;
+    };
+    workspace: {
+        root?: string | undefined;
+        lockTimeoutMs?: number | undefined;
+    };
+    editor: {
+        name?: string | undefined;
+        editCommand?: string[] | undefined;
+        diffCommand?: string[] | undefined;
+    };
+    template: {
+        placeholderOpen?: string | undefined;
+        placeholderClose?: string | undefined;
+        missingValuePolicy?: "prompt-each-branch" | undefined;
+        emptyValueIsPresent?: boolean | undefined;
+        unmanagedKeyPolicy?: "preserve" | undefined;
+        removedTemplateKeyPolicy?: "preserve" | undefined;
+    };
+    review: {
+        autoApprove?: boolean | undefined;
+        readOnlySnapshots?: boolean | undefined;
+    };
+    execution: {
+        concurrency?: number | undefined;
+        stopOnBranchError?: boolean | undefined;
+    };
+    report: {
+        writeJson?: boolean | undefined;
+        writeMarkdown?: boolean | undefined;
+        redactValues?: boolean | undefined;
+        warnOnSecrets?: boolean | undefined;
+    };
+    safety: {
+        rejectNoRemote?: boolean | undefined;
+        saveOnPartialSuccess?: boolean | undefined;
+    };
+}>;
+export type AppConfig = z.infer<typeof AppConfigSchema>;

package/dist/config/schema.js

@@ -0,0 +1,45 @@
+import { z } from "zod";
+export const AppConfigSchema = z.object({
+    git: z.object({
+        remote: z.string().default("origin"),
+        fetchPrune: z.boolean().default(true),
+        cleanMode: z.enum(["tracked-and-untracked", "tracked-only"]).default("tracked-and-untracked"),
+        pushPolicy: z.enum(["prompt", "always", "never"]).default("prompt"),
+        commitMessage: z.string().default("chore: sync configuration"),
+    }),
+    workspace: z.object({
+        root: z.string().default(".git-worker"),
+        lockTimeoutMs: z.number().default(30000),
+    }),
+    editor: z.object({
+        name: z.string().default("code"),
+        editCommand: z.array(z.string()).default(["code", "--wait", "{file}"]),
+        diffCommand: z.array(z.string()).default(["code", "--diff", "{before}", "{after}"]),
+    }),
+    template: z.object({
+        placeholderOpen: z.string().default("{"),
+        placeholderClose: z.string().default("}"),
+        missingValuePolicy: z.enum(["prompt-each-branch"]).default("prompt-each-branch"),
+        emptyValueIsPresent: z.boolean().default(true),
+        unmanagedKeyPolicy: z.enum(["preserve"]).default("preserve"),
+        removedTemplateKeyPolicy: z.enum(["preserve"]).default("preserve"),
+    }),
+    review: z.object({
+        autoApprove: z.boolean().default(false),
+        readOnlySnapshots: z.boolean().default(true),
+    }),
+    execution: z.object({
+        concurrency: z.number().default(1),
+        stopOnBranchError: z.boolean().default(false),
+    }),
+    report: z.object({
+        writeJson: z.boolean().default(false),
+        writeMarkdown: z.boolean().default(false),
+        redactValues: z.boolean().default(true),
+        warnOnSecrets: z.boolean().default(true),
+    }),
+    safety: z.object({
+        rejectNoRemote: z.boolean().default(true),
+        saveOnPartialSuccess: z.boolean().default(true),
+    }),
+});

package/dist/core/errors.d.ts

@@ -0,0 +1,12 @@
+import { AppError } from "./types.js";
+export declare function configError(msg: string, details?: unknown): AppError;
+export declare function gitError(msg: string, details?: unknown): AppError;
+export declare function editorError(msg: string, details?: unknown): AppError;
+export declare function templateError(msg: string, details?: unknown): AppError;
+export declare function eligibilityError(msg: string, details?: unknown): AppError;
+export declare function inputCancelledError(msg: string, details?: unknown): AppError;
+export declare function stalePlanError(msg: string, details?: unknown): AppError;
+export declare function applyError(msg: string, details?: unknown): AppError;
+export declare function pushError(msg: string, details?: unknown): AppError;
+export declare function workspaceError(msg: string, details?: unknown): AppError;
+export declare function validationError(msg: string, details?: unknown): AppError;

package/dist/core/errors.js

@@ -0,0 +1,34 @@
+import { AppError } from "./types.js";
+export function configError(msg, details) {
+    return new AppError("CONFIG", msg, details);
+}
+export function gitError(msg, details) {
+    return new AppError("GIT", msg, details);
+}
+export function editorError(msg, details) {
+    return new AppError("EDITOR", msg, details);
+}
+export function templateError(msg, details) {
+    return new AppError("TEMPLATE", msg, details);
+}
+export function eligibilityError(msg, details) {
+    return new AppError("ELIGIBILITY", msg, details);
+}
+export function inputCancelledError(msg, details) {
+    return new AppError("INPUT_CANCELLED", msg, details);
+}
+export function stalePlanError(msg, details) {
+    return new AppError("STALE_PLAN", msg, details);
+}
+export function applyError(msg, details) {
+    return new AppError("APPLY", msg, details);
+}
+export function pushError(msg, details) {
+    return new AppError("PUSH", msg, details);
+}
+export function workspaceError(msg, details) {
+    return new AppError("WORKSPACE", msg, details);
+}
+export function validationError(msg, details) {
+    return new AppError("VALIDATION", msg, details);
+}

package/dist/core/pipeline.d.ts

@@ -0,0 +1,3 @@
+import { Result, AppError } from "./types.js";
+export type Stage<C, D> = (context: C, deps: D) => Promise<Result<C, AppError>>;
+export declare function pipeline<C, D>(...stages: Stage<C, D>[]): Stage<C, D>;

package/dist/core/pipeline.js

@@ -0,0 +1,14 @@
+import { ok } from "./types.js";
+export function pipeline(...stages) {
+    return async (initial, deps) => {
+        let current = initial;
+        for (const stage of stages) {
+            const result = await stage(current, deps);
+            if (!result.ok) {
+                return result;
+            }
+            current = result.value;
+        }
+        return ok(current);
+    };
+}