@samaksh/git-worker 0.0.0-stage → 0.2.0

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);
+    };
+}

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/index.d.ts

@@ -0,0 +1,3 @@
+export * from "./app.js";
+export * from "./core/types.js";
+export * from "./core/errors.js";

package/dist/index.js

@@ -0,0 +1,3 @@
+export * from "./app.js";
+export * from "./core/types.js";
+export * from "./core/errors.js";

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;