@samaksh/git-worker 0.3.1 → 0.3.3

package/dist/cli/index.js

@@ -4,7 +4,7 @@ import { createRequire } from "module";
 import { run } from "../app.js";
 import { handleCacheList, handleCacheClean } from "./commands.js";
 import chalk from "chalk";
-let version = "0.3.1";
+let version = "0.3.3";
 try {
     const require = createRequire(import.meta.url);
     const pkg = require("../../package.json");
@@ -24,7 +24,7 @@ program
     .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("-e, --editor <editor>", "Editor command or executable path (e.g. 'code', '/path/to/code', 'cursor', '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)")

package/dist/config/editor-resolver.d.ts

@@ -0,0 +1,15 @@
+export type ResolvedEditor = {
+    name: string;
+    executable: string;
+    editCommand: string[];
+    diffCommand: string[];
+};
+/**
+ * Resolves the editor command and flags based on CLI input or defaults.
+ *
+ * Supports:
+ * - Direct command names: "code", "cursor", "vim", "nano"
+ * - Full executable paths: "/Applications/Visual Studio Code.app/.../code", "/usr/bin/vim"
+ * - Auto-discovery for "code" if not found in PATH
+ */
+export declare function resolveEditorConfig(editorInput?: string): ResolvedEditor;

package/dist/config/editor-resolver.js

@@ -0,0 +1,160 @@
+import { existsSync } from "fs";
+import { join, basename, delimiter } from "path";
+import { homedir, platform } from "os";
+/**
+ * Searches system PATH for an executable name.
+ */
+function findInPath(binName) {
+    const pathEnv = process.env.PATH || "";
+    const dirs = pathEnv.split(delimiter);
+    // Extensions on Windows
+    const exts = platform() === "win32" ? [".cmd", ".exe", ".bat", ""] : [""];
+    for (const dir of dirs) {
+        if (!dir)
+            continue;
+        for (const ext of exts) {
+            const fullPath = join(dir, `${binName}${ext}`);
+            try {
+                if (existsSync(fullPath)) {
+                    return fullPath;
+                }
+            }
+            catch {
+                // ignore permission or path errors
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Common locations for VS Code when not linked into PATH.
+ */
+function findVsCodeFallback() {
+    const osPlatform = platform();
+    if (osPlatform === "darwin") {
+        const macCandidates = [
+            "/Applications/Visual Studio Code.app/Contents/Resources/app/bin/code",
+            join(homedir(), "Applications/Visual Studio Code.app/Contents/Resources/app/bin/code"),
+            "/opt/homebrew/bin/code",
+            "/usr/local/bin/code",
+            "/Applications/Visual Studio Code - Insiders.app/Contents/Resources/app/bin/code-insiders",
+            "/Applications/VSCodium.app/Contents/Resources/app/bin/codium",
+            "/Applications/Cursor.app/Contents/Resources/app/bin/cursor",
+            join(homedir(), "Applications/Cursor.app/Contents/Resources/app/bin/cursor"),
+        ];
+        for (const candidate of macCandidates) {
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    else if (osPlatform === "win32") {
+        const localAppData = process.env.LOCALAPPDATA || "";
+        const programFiles = process.env.PROGRAMFILES || "";
+        const programFilesX86 = process.env["PROGRAMFILES(X86)"] || "";
+        const winCandidates = [
+            join(localAppData, "Programs", "Microsoft VS Code", "bin", "code.cmd"),
+            join(programFiles, "Microsoft VS Code", "bin", "code.cmd"),
+            join(programFilesX86, "Microsoft VS Code", "bin", "code.cmd"),
+        ];
+        for (const candidate of winCandidates) {
+            if (candidate && existsSync(candidate))
+                return candidate;
+        }
+    }
+    else {
+        // Linux / BSD
+        const linuxCandidates = [
+            "/usr/bin/code",
+            "/usr/local/bin/code",
+            "/snap/bin/code",
+            "/var/lib/flatpak/exports/bin/com.visualstudio.code",
+        ];
+        for (const candidate of linuxCandidates) {
+            if (existsSync(candidate))
+                return candidate;
+        }
+    }
+    return null;
+}
+/**
+ * Resolves the editor command and flags based on CLI input or defaults.
+ *
+ * Supports:
+ * - Direct command names: "code", "cursor", "vim", "nano"
+ * - Full executable paths: "/Applications/Visual Studio Code.app/.../code", "/usr/bin/vim"
+ * - Auto-discovery for "code" if not found in PATH
+ */
+export function resolveEditorConfig(editorInput) {
+    const trimmed = (editorInput || "code").trim();
+    // 1. Direct path check (contains slash/backslash or exists)
+    const isExplicitPath = trimmed.includes("/") || trimmed.includes("\\") || existsSync(trimmed);
+    let resolvedExecutable = trimmed;
+    if (isExplicitPath) {
+        if (existsSync(trimmed)) {
+            resolvedExecutable = trimmed;
+        }
+        else {
+            // Check if tilde expansion needed
+            if (trimmed.startsWith("~/")) {
+                const expanded = join(homedir(), trimmed.slice(2));
+                if (existsSync(expanded)) {
+                    resolvedExecutable = expanded;
+                }
+            }
+        }
+    }
+    else {
+        // Check if binary is in PATH
+        const inPath = findInPath(trimmed);
+        if (inPath) {
+            resolvedExecutable = inPath;
+        }
+        else if (trimmed === "code" || trimmed.toLowerCase() === "vscode") {
+            // Auto-discover VS Code in well-known locations
+            const fallback = findVsCodeFallback();
+            if (fallback) {
+                resolvedExecutable = fallback;
+            }
+        }
+    }
+    const base = basename(resolvedExecutable).toLowerCase();
+    const isVsCodeFamily = base === "code" ||
+        base === "code.cmd" ||
+        base === "code-insiders" ||
+        base === "code-insiders.cmd" ||
+        base === "codium" ||
+        base === "cursor";
+    const isVim = base === "vim" || base === "vi" || base === "nvim";
+    const isNano = base === "nano";
+    if (isVsCodeFamily) {
+        return {
+            name: isExplicitPath ? basename(trimmed) : trimmed,
+            executable: resolvedExecutable,
+            editCommand: [resolvedExecutable, "--wait", "{file}"],
+            diffCommand: [resolvedExecutable, "--diff", "{before}", "{after}"],
+        };
+    }
+    if (isVim) {
+        return {
+            name: isExplicitPath ? basename(trimmed) : trimmed,
+            executable: resolvedExecutable,
+            editCommand: [resolvedExecutable, "{file}"],
+            diffCommand: [base === "nvim" ? "nvim" : "vim", "-d", "{before}", "{after}"],
+        };
+    }
+    if (isNano) {
+        return {
+            name: "nano",
+            executable: resolvedExecutable,
+            editCommand: [resolvedExecutable, "{file}"],
+            diffCommand: ["diff", "-u", "{before}", "{after}"],
+        };
+    }
+    // Generic custom editor
+    return {
+        name: isExplicitPath ? basename(trimmed) : trimmed,
+        executable: resolvedExecutable,
+        editCommand: [resolvedExecutable, "{file}"],
+        diffCommand: [resolvedExecutable, "{before}", "{after}"],
+    };
+}

package/dist/config/load.js

@@ -1,5 +1,6 @@
 import { AppConfigSchema } from "./schema.js";
 import { DEFAULT_CONFIG } from "./defaults.js";
+import { resolveEditorConfig } from "./editor-resolver.js";
 import { existsSync, readFileSync } from "fs";
 import { join, resolve } from "path";
 function loadProjectConfig(repoPath) {
@@ -43,6 +44,9 @@ export function loadConfig(cliInput) {
     // Load project config from repo directory
     const repoPath = cliInput.repo || process.cwd();
     const projectConfig = loadProjectConfig(repoPath);
+    // Resolve editor configuration (CLI flag, project config, or auto-discovery)
+    const editorInput = cliInput.editor || projectConfig.editor?.name;
+    const resolvedEditor = resolveEditorConfig(editorInput);
     // Merge: defaults < project config < CLI overrides
     const cliOverrides = {
         git: {
@@ -52,8 +56,9 @@ export function loadConfig(cliInput) {
             ...(cliInput.remote ? { remote: cliInput.remote } : {}),
         },
         editor: {
-            ...DEFAULT_CONFIG.editor,
-            ...(cliInput.editor ? { name: cliInput.editor } : {}),
+            name: resolvedEditor.name,
+            editCommand: resolvedEditor.editCommand,
+            diffCommand: resolvedEditor.diffCommand,
         },
         review: {
             ...DEFAULT_CONFIG.review,

package/dist/stages/eligibility.d.ts

@@ -1,3 +1,11 @@
 import { Stage } from "../core/pipeline.js";
 import { RunContext, AppDeps } from "../core/types.js";
+/**
+ * Lightweight eligibility pass-through.
+ *
+ * In-depth eligibility checks (branch readability, dynamic variable existence,
+ * and file readiness) are executed directly and concurrently during the planning stage.
+ * This eliminates thousands of redundant git subprocess calls and provides instant
+ * transition from selection to template editing.
+ */
 export declare const checkEligibilityStage: Stage<RunContext, AppDeps>;

package/dist/stages/eligibility.js

@@ -1,97 +1,18 @@
 import { ok, err } from "../core/types.js";
 import { workspaceError } from "../core/errors.js";
-import { parseEnvFile } from "../services/template/env.js";
-import { clack, sectionHeader, statusLine } from "../utils/ui.js";
-export const checkEligibilityStage = async (context, deps) => {
+/**
+ * Lightweight eligibility pass-through.
+ *
+ * In-depth eligibility checks (branch readability, dynamic variable existence,
+ * and file readiness) are executed directly and concurrently during the planning stage.
+ * This eliminates thousands of redundant git subprocess calls and provides instant
+ * transition from selection to template editing.
+ */
+export const checkEligibilityStage = async (context) => {
     const targets = context.targets || (context.target ? [context.target] : []);
     if (!context.selectedBranches || targets.length === 0 || !context.project) {
         return err(workspaceError("Prerequisites missing for eligibility check"));
     }
-    sectionHeader("Eligibility Check");
-    const eligible = [];
-    const ineligible = [];
-    const hasEnvTarget = targets.some((t) => t.path === ".env" || t.path.startsWith(".env."));
-    const total = context.selectedBranches.length;
-    const isBatchMode = total > 8;
-    const s = clack.spinner();
-    if (isBatchMode) {
-        s.start(`Checking eligibility for ${total} branches across ${targets.length} target file(s)…`);
-    }
-    // Concurrent execution pool (up to 16 workers in parallel)
-    const concurrency = Math.min(16, total);
-    let completed = 0;
-    let currentIndex = 0;
-    const workers = Array.from({ length: concurrency }, async () => {
-        while (currentIndex < total) {
-            const idx = currentIndex++;
-            const branch = context.selectedBranches[idx];
-            // Read branch .env if available to resolve dynamic paths or check variable availability
-            let envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
-            const envMap = new Map();
-            if (envRead.ok) {
-                const parsed = parseEnvFile(envRead.value);
-                if (parsed.ok) {
-                    for (const [k, v] of parsed.value.map) {
-                        envMap.set(k.toLowerCase(), v.value);
-                        envMap.set(k, v.value);
-                    }
-                }
-            }
-            let existingFileCount = 0;
-            let missingDynamicVar;
-            for (const target of targets) {
-                let checkPath = target.path;
-                if (target.isDynamic && (target.dynamicVar || target.path.includes("{servicename}"))) {
-                    const varName = target.dynamicVar || "servicename";
-                    const resolvedVal = envMap.get(varName) ||
-                        envMap.get(varName.toLowerCase()) ||
-                        envMap.get(varName.toUpperCase()) ||
-                        envMap.get("SERVICE_NAME");
-                    if (resolvedVal) {
-                        checkPath = target.path.replace(`{${varName}}`, resolvedVal);
-                    }
-                    else {
-                        missingDynamicVar = varName;
-                    }
-                }
-                const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, checkPath);
-                if (targetRead.ok) {
-                    existingFileCount++;
-                }
-            }
-            let envNote = "";
-            if (!hasEnvTarget) {
-                envNote = envRead.ok ? " • .env present" : " • .env missing";
-            }
-            if (missingDynamicVar) {
-                envNote += ` • note: '${missingDynamicVar}' missing in .env`;
-            }
-            const fileStatus = `${existingFileCount}/${targets.length} target file(s) found`;
-            eligible.push(branch);
-            completed++;
-            if (isBatchMode) {
-                s.message(`Checking eligibility (${completed}/${total})…`);
-            }
-            else {
-                statusLine("ok", branch.name, `${branch.sha.slice(0, 8)} — ${fileStatus}${envNote}`);
-            }
-        }
-    });
-    await Promise.all(workers);
-    if (isBatchMode) {
-        s.stop(`Checked ${total} branches (${eligible.length} eligible)`);
-    }
-    if (ineligible.length > 0) {
-        console.log("");
-        clack.log.warn(`${ineligible.length} branch(es) ineligible:`);
-        for (const { branch, reason } of ineligible) {
-            statusLine("warn", branch.name, reason);
-        }
-    }
-    if (eligible.length === 0) {
-        clack.log.error("No eligible branches found.");
-        return err(workspaceError("No eligible branches"));
-    }
-    statusLine("ok", `${eligible.length} eligible branch(es) ready`);
+    const eligible = [...context.selectedBranches];
     return ok({ ...context, eligible });
 };

package/dist/stages/plan.js

@@ -7,102 +7,276 @@ import { sha256, planHash as computePlanHash } from "../utils/hash.js";
 import { computeDiff } from "../services/review/index.js";
 import { clack, sectionHeader, statusLine, sym } from "../utils/ui.js";
 import chalk from "chalk";
+class AsyncMutex {
+    queue = Promise.resolve();
+    async runExclusive(fn) {
+        let release;
+        const wait = new Promise((r) => (release = r));
+        const previous = this.queue;
+        this.queue = wait;
+        await previous;
+        try {
+            return await fn();
+        }
+        finally {
+            release();
+        }
+    }
+}
 export const planChangesStage = async (context, deps) => {
     const templates = context.templates || (context.activeTemplate ? [context.activeTemplate] : []);
-    if (templates.length === 0 || !context.eligible || !context.project) {
+    const branches = context.eligible || context.selectedBranches || [];
+    if (templates.length === 0 || branches.length === 0 || !context.project) {
         return err(workspaceError("Prerequisites missing for planning"));
     }
-    sectionHeader(`Planning Changes across ${context.eligible.length} branch(es) & ${templates.length} template(s)`);
-    const plans = [];
+    const total = branches.length;
+    const isBatchMode = total > 6;
     const isCi = context.input.ci ?? false;
-    for (const branch of context.eligible) {
-        const s = clack.spinner();
-        s.start(`Planning ${branch.name}…`);
-        // Read branch's existing .env once to populate envMap and extract dynamic variables
-        const envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
-        const envMap = new Map();
-        if (envRead.ok) {
-            const parsedEnv = parseEnvFile(envRead.value);
-            if (parsedEnv.ok) {
-                for (const [key, entry] of parsedEnv.value.map) {
-                    envMap.set(key, entry.value);
+    const promptMutex = new AsyncMutex();
+    sectionHeader(`Planning & Verifying across ${total} branch(es) & ${templates.length} file(s)`);
+    const s = clack.spinner();
+    if (isBatchMode) {
+        s.start(`Planning changes for ${total} branches…`);
+    }
+    const branchPlansMap = new Map();
+    let completed = 0;
+    let currentIndex = 0;
+    const concurrency = Math.min(16, total);
+    const workers = Array.from({ length: concurrency }, async () => {
+        while (currentIndex < total) {
+            const idx = currentIndex++;
+            const branch = branches[idx];
+            const branchPlans = [];
+            if (!isBatchMode) {
+                s.start(`Planning ${branch.name}…`);
+            }
+            // 1. Read branch's .env to extract variables and dynamic path values
+            const envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
+            const envMap = new Map();
+            if (envRead.ok) {
+                const parsedEnv = parseEnvFile(envRead.value);
+                if (parsedEnv.ok) {
+                    for (const [key, entry] of parsedEnv.value.map) {
+                        envMap.set(key, entry.value);
+                        envMap.set(key.toLowerCase(), entry.value);
+                    }
                 }
             }
-        }
-        // Resolve branch-level servicename (support lowercase, uppercase, snake_case)
-        let branchServiceName = envMap.get("servicename") ||
-            envMap.get("SERVICE_NAME") ||
-            envMap.get("service_name") ||
-            envMap.get("SERVICENAME");
-        // Fallback: check if an env template in context statically defines servicename
-        if (!branchServiceName) {
-            const envTmpl = templates.find((t) => t.engine === "env-reconcile");
-            if (envTmpl?.parsedEnv) {
-                const assign = envTmpl.parsedEnv.assignments.find((a) => a.key === "servicename" ||
-                    a.key === "SERVICE_NAME" ||
-                    a.key.toLowerCase() === "servicename");
-                if (assign && assign.isStatic && assign.value) {
-                    branchServiceName = assign.value;
+            // Resolve branch-level servicename
+            let branchServiceName = envMap.get("servicename") ||
+                envMap.get("service_name") ||
+                envMap.get("SERVICE_NAME") ||
+                envMap.get("SERVICENAME");
+            // Fallback: check if an env template in context statically defines servicename
+            if (!branchServiceName) {
+                const envTmpl = templates.find((t) => t.engine === "env-reconcile");
+                if (envTmpl?.parsedEnv) {
+                    const assign = envTmpl.parsedEnv.assignments.find((a) => a.key === "servicename" ||
+                        a.key === "SERVICE_NAME" ||
+                        a.key.toLowerCase() === "servicename");
+                    if (assign && assign.isStatic && assign.value) {
+                        branchServiceName = assign.value;
+                    }
                 }
             }
-        }
-        let branchChangedCount = 0;
-        let branchErrorCount = 0;
-        for (const template of templates) {
-            let targetPath = template.path;
-            // Handle dynamic path substitution (e.g. {servicename}/requirements.txt)
-            if (template.isDynamic || targetPath.includes("{servicename}")) {
-                const varName = template.dynamicVar || "servicename";
-                const val = branchServiceName ||
-                    envMap.get(varName) ||
-                    envMap.get(varName.toLowerCase()) ||
-                    envMap.get(varName.toUpperCase());
-                if (!val) {
+            let branchChangedCount = 0;
+            let branchErrorCount = 0;
+            for (const template of templates) {
+                let targetPath = template.path;
+                // Dynamic path substitution (e.g. {servicename}/requirements.txt)
+                if (template.isDynamic || targetPath.includes("{servicename}")) {
+                    const varName = template.dynamicVar || "servicename";
+                    const val = branchServiceName ||
+                        envMap.get(varName) ||
+                        envMap.get(varName.toLowerCase()) ||
+                        envMap.get(varName.toUpperCase());
+                    if (!val) {
+                        branchErrorCount++;
+                        const errorReason = `Missing '${varName}' in branch .env required for dynamic path ${targetPath}`;
+                        branchPlans.push({
+                            branch,
+                            baseCommitSha: branch.sha,
+                            path: targetPath,
+                            beforeContent: "",
+                            beforeContentHash: sha256(""),
+                            afterContent: "",
+                            afterContentHash: sha256(""),
+                            diff: "",
+                            planHash: computePlanHash(branch.name, branch.sha, targetPath, sha256(""), sha256("")),
+                            status: "error",
+                            reason: errorReason,
+                            addedKeys: [],
+                            updatedKeys: [],
+                        });
+                        continue;
+                    }
+                    targetPath = targetPath.replace(`{${varName}}`, val);
+                }
+                const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
+                const engine = template.engine ?? (isEnv ? "env-reconcile" : "source-of-truth");
+                const templateRaw = template.raw;
+                // ─────────────────────────────────────────────────────────────────
+                // Source-of-Truth Engine
+                // ─────────────────────────────────────────────────────────────────
+                if (engine === "source-of-truth") {
+                    const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
+                    const isNewFile = !targetRead.ok;
+                    const beforeContent = targetRead.ok ? targetRead.value : "";
+                    const beforeContentHash = sha256(beforeContent);
+                    if (branchServiceName && !envMap.has("servicename")) {
+                        envMap.set("servicename", branchServiceName);
+                        envMap.set("SERVICE_NAME", branchServiceName);
+                    }
+                    const interpolated = interpolateTemplate(templateRaw, envMap, {
+                        branchName: branch.name,
+                        repoName: context.project.id,
+                        commitSha: branch.sha,
+                    });
+                    if (!interpolated.ok) {
+                        branchErrorCount++;
+                        branchPlans.push({
+                            branch,
+                            baseCommitSha: branch.sha,
+                            path: targetPath,
+                            beforeContent,
+                            beforeContentHash,
+                            afterContent: beforeContent,
+                            afterContentHash: beforeContentHash,
+                            diff: "",
+                            planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                            status: "error",
+                            reason: interpolated.error.message,
+                            addedKeys: [],
+                            updatedKeys: [],
+                            isNewFile,
+                        });
+                        continue;
+                    }
+                    const { content: afterContent, missingVars } = interpolated.value;
+                    if (missingVars.length > 0) {
+                        branchErrorCount++;
+                        const errorReason = `Missing required variable(s) from .env: ${missingVars.join(", ")}`;
+                        branchPlans.push({
+                            branch,
+                            baseCommitSha: branch.sha,
+                            path: targetPath,
+                            beforeContent,
+                            beforeContentHash,
+                            afterContent: beforeContent,
+                            afterContentHash: beforeContentHash,
+                            diff: "",
+                            planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
+                            status: "error",
+                            reason: errorReason,
+                            addedKeys: [],
+                            updatedKeys: [],
+                            missingVars,
+                            isNewFile,
+                        });
+                        continue;
+                    }
+                    const afterContentHash = sha256(afterContent);
+                    const changed = afterContent !== beforeContent;
+                    const diff = computeDiff(beforeContent, afterContent, targetPath);
+                    const hash = computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, afterContentHash);
+                    if (changed) {
+                        branchChangedCount++;
+                    }
+                    branchPlans.push({
+                        branch,
+                        baseCommitSha: branch.sha,
+                        path: targetPath,
+                        beforeContent,
+                        beforeContentHash,
+                        afterContent,
+                        afterContentHash,
+                        diff,
+                        planHash: hash,
+                        status: changed ? "changed" : "unchanged",
+                        addedKeys: isNewFile ? [targetPath] : [],
+                        updatedKeys: !isNewFile && changed ? [targetPath] : [],
+                        isNewFile,
+                    });
+                    continue;
+                }
+                // ─────────────────────────────────────────────────────────────────
+                // Env-Reconcile Engine
+                // ─────────────────────────────────────────────────────────────────
+                const readResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
+                const beforeContent = readResult.ok ? readResult.value : "";
+                const beforeContentHash = sha256(beforeContent);
+                const existingParse = parseEnvFile(beforeContent);
+                if (!existingParse.ok) {
                     branchErrorCount++;
-                    const errorReason = `Missing '${varName}' in branch .env required for dynamic path ${targetPath}`;
-                    plans.push({
+                    branchPlans.push({
                         branch,
                         baseCommitSha: branch.sha,
                         path: targetPath,
-                        beforeContent: "",
-                        beforeContentHash: sha256(""),
-                        afterContent: "",
-                        afterContentHash: sha256(""),
+                        beforeContent,
+                        beforeContentHash,
+                        afterContent: beforeContent,
+                        afterContentHash: beforeContentHash,
                         diff: "",
-                        planHash: computePlanHash(branch.name, branch.sha, targetPath, sha256(""), sha256("")),
+                        planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
                         status: "error",
-                        reason: errorReason,
+                        reason: existingParse.error.message,
                         addedKeys: [],
                         updatedKeys: [],
                     });
                     continue;
                 }
-                targetPath = targetPath.replace(`{${varName}}`, val);
-            }
-            const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
-            const engine = template.engine ?? (isEnv ? "env-reconcile" : "source-of-truth");
-            const templateRaw = template.raw;
-            // ─────────────────────────────────────────────────────────────────
-            // 1. SOURCE-OF-TRUTH ENGINE (Dockerfile, scripts, JSON, requirements)
-            // ─────────────────────────────────────────────────────────────────
-            if (engine === "source-of-truth") {
-                const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
-                const isNewFile = !targetRead.ok;
-                const beforeContent = targetRead.ok ? targetRead.value : "";
-                const beforeContentHash = sha256(beforeContent);
-                // Add dynamic servicename to envMap if available
-                if (branchServiceName && !envMap.has("servicename")) {
-                    envMap.set("servicename", branchServiceName);
-                    envMap.set("SERVICE_NAME", branchServiceName);
+                const existingMap = existingParse.value.map;
+                const branchValues = new Map();
+                let hadError = false;
+                let errorReason = "";
+                const envTemplate = template.parsedEnv ?? context.template;
+                if (envTemplate) {
+                    for (const assignment of envTemplate.assignments) {
+                        if (!assignment.isPlaceholder || !assignment.placeholderName)
+                            continue;
+                        if (existingMap.has(assignment.key)) {
+                            branchValues.set(assignment.key, existingMap.get(assignment.key).value);
+                        }
+                        else {
+                            if (isCi) {
+                                hadError = true;
+                                errorReason = `Missing value for '${assignment.key}' in CI mode`;
+                                break;
+                            }
+                            // Interactive prompt under mutex
+                            await promptMutex.runExclusive(async () => {
+                                s.stop(`${branch.name} — needs input`);
+                                console.log("");
+                                console.log(chalk.bold(`  ${sym.branch} Branch: ${chalk.cyan(branch.name)}`));
+                                console.log(chalk.yellow(`  Missing key in ${targetPath}: ${chalk.bold(assignment.key)}`));
+                                const value = await clack.text({
+                                    message: `Value for ${chalk.bold(assignment.key)} in ${chalk.cyan(branch.name)}:`,
+                                    placeholder: `enter value for ${assignment.key}`,
+                                    validate: (v) => {
+                                        if (!v || v.trim() === "")
+                                            return `Value cannot be empty`;
+                                    },
+                                });
+                                if (clack.isCancel(value)) {
+                                    hadError = true;
+                                    errorReason = "User cancelled value input";
+                                    s.stop(chalk.yellow(`${branch.name} — skipped`));
+                                }
+                                else {
+                                    branchValues.set(assignment.key, value);
+                                }
+                                if (isBatchMode) {
+                                    s.start(`Planning changes (${completed}/${total})…`);
+                                }
+                            });
+                            if (hadError)
+                                break;
+                        }
+                    }
                 }
-                const interpolated = interpolateTemplate(templateRaw, envMap, {
-                    branchName: branch.name,
-                    repoName: context.project.id,
-                    commitSha: branch.sha,
-                });
-                if (!interpolated.ok) {
+                if (hadError) {
                     branchErrorCount++;
-                    plans.push({
+                    branchPlans.push({
                         branch,
                         baseCommitSha: branch.sha,
                         path: targetPath,
@@ -113,18 +287,16 @@ export const planChangesStage = async (context, deps) => {
                         diff: "",
                         planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
                         status: "error",
-                        reason: interpolated.error.message,
+                        reason: errorReason,
                         addedKeys: [],
                         updatedKeys: [],
-                        isNewFile,
                     });
                     continue;
                 }
-                const { content: afterContent, missingVars } = interpolated.value;
-                if (missingVars.length > 0) {
+                const transformResult = transformEnv(beforeContent, envTemplate, branchValues);
+                if (!transformResult.ok) {
                     branchErrorCount++;
-                    const errorReason = `Missing required variable(s) from .env: ${missingVars.join(", ")}`;
-                    plans.push({
+                    branchPlans.push({
                         branch,
                         baseCommitSha: branch.sha,
                         path: targetPath,
@@ -135,22 +307,20 @@ export const planChangesStage = async (context, deps) => {
                         diff: "",
                         planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
                         status: "error",
-                        reason: errorReason,
+                        reason: transformResult.error.message,
                         addedKeys: [],
                         updatedKeys: [],
-                        missingVars,
-                        isNewFile,
                     });
                     continue;
                 }
+                const { content: afterContent, changed, addedKeys, updatedKeys } = transformResult.value;
                 const afterContentHash = sha256(afterContent);
-                const changed = afterContent !== beforeContent;
                 const diff = computeDiff(beforeContent, afterContent, targetPath);
                 const hash = computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, afterContentHash);
                 if (changed) {
                     branchChangedCount++;
                 }
-                plans.push({
+                branchPlans.push({
                     branch,
                     baseCommitSha: branch.sha,
                     path: targetPath,
@@ -161,154 +331,44 @@ export const planChangesStage = async (context, deps) => {
                     diff,
                     planHash: hash,
                     status: changed ? "changed" : "unchanged",
-                    addedKeys: isNewFile ? [targetPath] : [],
-                    updatedKeys: !isNewFile && changed ? [targetPath] : [],
-                    isNewFile,
+                    addedKeys,
+                    updatedKeys,
                 });
-                continue;
             }
-            // ─────────────────────────────────────────────────────────────────
-            // 2. ENV RECONCILE ENGINE (.env)
-            // ─────────────────────────────────────────────────────────────────
-            const readResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
-            const beforeContent = readResult.ok ? readResult.value : "";
-            const beforeContentHash = sha256(beforeContent);
-            const existingParse = parseEnvFile(beforeContent);
-            if (!existingParse.ok) {
-                branchErrorCount++;
-                plans.push({
-                    branch,
-                    baseCommitSha: branch.sha,
-                    path: targetPath,
-                    beforeContent,
-                    beforeContentHash,
-                    afterContent: beforeContent,
-                    afterContentHash: beforeContentHash,
-                    diff: "",
-                    planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
-                    status: "error",
-                    reason: existingParse.error.message,
-                    addedKeys: [],
-                    updatedKeys: [],
-                });
-                continue;
+            branchPlansMap.set(idx, branchPlans);
+            completed++;
+            if (isBatchMode) {
+                s.message(`Planning & verifying (${completed}/${total})…`);
             }
-            const existingMap = existingParse.value.map;
-            const branchValues = new Map();
-            let hadError = false;
-            let errorReason = "";
-            const envTemplate = template.parsedEnv ?? context.template;
-            if (envTemplate) {
-                for (const assignment of envTemplate.assignments) {
-                    if (!assignment.isPlaceholder || !assignment.placeholderName)
-                        continue;
-                    if (existingMap.has(assignment.key)) {
-                        branchValues.set(assignment.key, existingMap.get(assignment.key).value);
-                    }
-                    else {
-                        if (isCi) {
-                            hadError = true;
-                            errorReason = `Missing value for '${assignment.key}' in CI mode`;
-                            break;
-                        }
-                        s.stop(`${branch.name} — needs input for ${targetPath}`);
-                        console.log("");
-                        console.log(chalk.bold(`  ${sym.branch} Branch: ${chalk.cyan(branch.name)}`));
-                        console.log(chalk.yellow(`  Missing key in ${targetPath}: ${chalk.bold(assignment.key)}`));
-                        const value = await clack.text({
-                            message: `Value for ${chalk.bold(assignment.key)} in ${chalk.cyan(branch.name)}:`,
-                            placeholder: `enter value for ${assignment.key}`,
-                            validate: (v) => {
-                                if (!v || v.trim() === "")
-                                    return `Value cannot be empty`;
-                            },
-                        });
-                        if (clack.isCancel(value)) {
-                            hadError = true;
-                            errorReason = "User cancelled value input";
-                            s.stop(chalk.yellow(`${branch.name} — skipped`));
-                            break;
-                        }
-                        branchValues.set(assignment.key, value);
-                        s.start(`Planning ${branch.name}…`);
-                    }
+            else {
+                if (branchErrorCount > 0) {
+                    s.stop(chalk.red(`${branch.name} — ${branchErrorCount} error(s)`));
+                }
+                else if (branchChangedCount > 0) {
+                    s.stop(chalk.green(`${branch.name} — ${branchChangedCount} file(s) changed`));
+                }
+                else {
+                    s.stop(chalk.gray(`${branch.name} — no changes`));
                 }
             }
-            if (hadError) {
-                branchErrorCount++;
-                plans.push({
-                    branch,
-                    baseCommitSha: branch.sha,
-                    path: targetPath,
-                    beforeContent,
-                    beforeContentHash,
-                    afterContent: beforeContent,
-                    afterContentHash: beforeContentHash,
-                    diff: "",
-                    planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
-                    status: "error",
-                    reason: errorReason,
-                    addedKeys: [],
-                    updatedKeys: [],
-                });
-                continue;
-            }
-            const transformResult = transformEnv(beforeContent, envTemplate, branchValues);
-            if (!transformResult.ok) {
-                branchErrorCount++;
-                plans.push({
-                    branch,
-                    baseCommitSha: branch.sha,
-                    path: targetPath,
-                    beforeContent,
-                    beforeContentHash,
-                    afterContent: beforeContent,
-                    afterContentHash: beforeContentHash,
-                    diff: "",
-                    planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
-                    status: "error",
-                    reason: transformResult.error.message,
-                    addedKeys: [],
-                    updatedKeys: [],
-                });
-                continue;
-            }
-            const { content: afterContent, changed, addedKeys, updatedKeys } = transformResult.value;
-            const afterContentHash = sha256(afterContent);
-            const diff = computeDiff(beforeContent, afterContent, targetPath);
-            const hash = computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, afterContentHash);
-            if (changed) {
-                branchChangedCount++;
-            }
-            plans.push({
-                branch,
-                baseCommitSha: branch.sha,
-                path: targetPath,
-                beforeContent,
-                beforeContentHash,
-                afterContent,
-                afterContentHash,
-                diff,
-                planHash: hash,
-                status: changed ? "changed" : "unchanged",
-                addedKeys,
-                updatedKeys,
-            });
-        }
-        if (branchErrorCount > 0) {
-            s.stop(chalk.red(`${branch.name} — ${branchErrorCount} error(s)`));
-        }
-        else if (branchChangedCount > 0) {
-            s.stop(chalk.green(`${branch.name} — ${branchChangedCount} file(s) changed`));
-        }
-        else {
-            s.stop(chalk.gray(`${branch.name} — no changes`));
         }
+    });
+    await Promise.all(workers);
+    // Flatten plans in deterministic branch order
+    const allPlans = [];
+    for (let i = 0; i < total; i++) {
+        const list = branchPlansMap.get(i) || [];
+        allPlans.push(...list);
+    }
+    const changed = allPlans.filter((p) => p.status === "changed").length;
+    const unchanged = allPlans.filter((p) => p.status === "unchanged").length;
+    const errors = allPlans.filter((p) => p.status === "error").length;
+    if (isBatchMode) {
+        s.stop(`Planned ${total} branch(es) — ${changed} changed, ${unchanged} unchanged, ${errors} error(s)`);
+    }
+    else {
+        console.log("");
+        statusLine("ok", `Planning complete — ${changed} file change(s) across branches (${unchanged} unchanged, ${errors} error(s))`);
     }
-    const changed = plans.filter((p) => p.status === "changed").length;
-    const unchanged = plans.filter((p) => p.status === "unchanged").length;
-    const errors = plans.filter((p) => p.status === "error").length;
-    console.log("");
-    statusLine("ok", `Planning complete — ${changed} file change(s) across branches (${unchanged} unchanged, ${errors} error(s))`);
-    return ok({ ...context, plans });
+    return ok({ ...context, plans: allPlans });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samaksh/git-worker",
-  "version": "0.3.1",
+  "version": "0.3.3",
   "description": "Safe, composable TypeScript CLI/TUI for applying reviewed file changes across many Git branches",
   "type": "module",
   "main": "dist/index.js",