@samaksh/git-worker 0.2.2 → 0.3.0

package/dist/stages/plan.js

@@ -8,50 +8,174 @@ import { computeDiff } from "../services/review/index.js";
 import { clack, sectionHeader, statusLine, sym } from "../utils/ui.js";
 import chalk from "chalk";
 export const planChangesStage = async (context, deps) => {
-    if ((!context.template && !context.activeTemplate) ||
-        !context.eligible ||
-        !context.target ||
-        !context.project) {
+    const templates = context.templates || (context.activeTemplate ? [context.activeTemplate] : []);
+    if (templates.length === 0 || !context.eligible || !context.project) {
         return err(workspaceError("Prerequisites missing for planning"));
     }
-    sectionHeader("Planning Changes");
+    sectionHeader(`Planning Changes across ${context.eligible.length} branch(es) & ${templates.length} template(s)`);
     const plans = [];
     const isCi = context.input.ci ?? false;
-    const targetPath = context.target.path;
-    const isEnv = targetPath === ".env" || targetPath.startsWith(".env.");
-    const engine = context.activeTemplate?.engine ?? (isEnv ? "env-reconcile" : "source-of-truth");
-    const templateRaw = context.activeTemplate?.raw ?? context.template?.raw ?? "";
     for (const branch of context.eligible) {
         const s = clack.spinner();
         s.start(`Planning ${branch.name}…`);
-        // ─────────────────────────────────────────────────────────────────
-        // 1. SOURCE-OF-TRUTH ENGINE (for Dockerfile, JSON, YAML, scripts)
-        // ─────────────────────────────────────────────────────────────────
-        if (engine === "source-of-truth") {
-            // A. Read the branch's .env to extract 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);
-                    }
+        // 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);
+                }
+            }
+        }
+        // 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;
+                }
+            }
+        }
+        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) {
+                    branchErrorCount++;
+                    const errorReason = `Missing '${varName}' in branch .env required for dynamic path ${targetPath}`;
+                    plans.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;
+            // ─────────────────────────────────────────────────────────────────
+            // 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 interpolated = interpolateTemplate(templateRaw, envMap, {
+                    branchName: branch.name,
+                    repoName: context.project.id,
+                    commitSha: branch.sha,
+                });
+                if (!interpolated.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: 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(", ")}`;
+                    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: [],
+                        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++;
+                }
+                plans.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;
             }
-            // B. Read existing target file from branch (if present)
-            const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
-            const isNewFile = !targetRead.ok;
-            const beforeContent = targetRead.ok ? targetRead.value : "";
+            // ─────────────────────────────────────────────────────────────────
+            // 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);
-            // C. Interpolate template with branch's .env vars and built-ins
-            const interpolated = interpolateTemplate(templateRaw, envMap, {
-                branchName: branch.name,
-                repoName: context.project.id,
-                commitSha: branch.sha,
-            });
-            if (!interpolated.ok) {
-                s.stop(chalk.red(`${branch.name} — interpolation error`));
+            const existingParse = parseEnvFile(beforeContent);
+            if (!existingParse.ok) {
+                branchErrorCount++;
                 plans.push({
                     branch,
                     baseCommitSha: branch.sha,
@@ -63,18 +187,55 @@ export const planChangesStage = async (context, deps) => {
                     diff: "",
                     planHash: computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, beforeContentHash),
                     status: "error",
-                    reason: interpolated.error.message,
+                    reason: existingParse.error.message,
                     addedKeys: [],
                     updatedKeys: [],
-                    isNewFile,
                 });
                 continue;
             }
-            const { content: afterContent, missingVars } = interpolated.value;
-            // D. Handle missing variables without fallback
-            if (missingVars.length > 0) {
-                const errorReason = `Missing required variable(s) from .env: ${missingVars.join(", ")}`;
-                s.stop(chalk.red(`${branch.name} — ${errorReason}`));
+            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}…`);
+                    }
+                }
+            }
+            if (hadError) {
+                branchErrorCount++;
                 plans.push({
                     branch,
                     baseCommitSha: branch.sha,
@@ -89,21 +250,35 @@ export const planChangesStage = async (context, deps) => {
                     reason: errorReason,
                     addedKeys: [],
                     updatedKeys: [],
-                    missingVars,
-                    isNewFile,
                 });
                 continue;
             }
-            // E. Diff & Plan Hash
+            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 changed = afterContent !== beforeContent;
             const diff = computeDiff(beforeContent, afterContent, targetPath);
             const hash = computePlanHash(branch.name, branch.sha, targetPath, beforeContentHash, afterContentHash);
             if (changed) {
-                s.stop(chalk.green(`${branch.name} — ${isNewFile ? "new file created" : "file updated"}`));
-            }
-            else {
-                s.stop(chalk.gray(`${branch.name} — no changes`));
+                branchChangedCount++;
             }
             plans.push({
                 branch,
@@ -116,155 +291,24 @@ 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 (for .env files)
-        // ─────────────────────────────────────────────────────────────────
-        const readResult = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, targetPath);
-        const beforeContent = readResult.ok ? readResult.value : "";
-        const beforeContentHash = sha256(beforeContent);
-        // Parse existing file to find which keys exist
-        const existingParse = parseEnvFile(beforeContent);
-        if (!existingParse.ok) {
-            s.stop(chalk.red(`${branch.name} — file parse error`));
-            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;
-        }
-        const existingMap = existingParse.value.map;
-        const branchValues = new Map();
-        let hadError = false;
-        let errorReason = "";
-        const envTemplate = context.activeTemplate?.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`);
-                    console.log("");
-                    console.log(chalk.bold(`  ${sym.branch} Branch: ${chalk.cyan(branch.name)}`));
-                    console.log(chalk.yellow(`  Missing key: ${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}…`);
-                }
-            }
-        }
-        if (hadError) {
-            s.stop(chalk.red(`${branch.name} — ${errorReason}`));
-            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;
-        }
-        // Transform
-        const transformResult = transformEnv(beforeContent, envTemplate, branchValues);
-        if (!transformResult.ok) {
-            s.stop(chalk.red(`${branch.name} — transform error`));
-            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;
+        if (branchErrorCount > 0) {
+            s.stop(chalk.red(`${branch.name} — ${branchErrorCount} error(s)`));
         }
-        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) {
-            const summary = [
-                updatedKeys.length > 0 ? `${updatedKeys.length} updated` : "",
-                addedKeys.length > 0 ? `${addedKeys.length} added` : "",
-            ]
-                .filter(Boolean)
-                .join(", ");
-            s.stop(chalk.green(`${branch.name} — ${summary || "changed"}`));
+        else if (branchChangedCount > 0) {
+            s.stop(chalk.green(`${branch.name} — ${branchChangedCount} file(s) changed`));
         }
         else {
             s.stop(chalk.gray(`${branch.name} — no changes`));
         }
-        plans.push({
-            branch,
-            baseCommitSha: branch.sha,
-            path: targetPath,
-            beforeContent,
-            beforeContentHash,
-            afterContent,
-            afterContentHash,
-            diff,
-            planHash: hash,
-            status: changed ? "changed" : "unchanged",
-            addedKeys,
-            updatedKeys,
-        });
     }
     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} changed, ${unchanged} unchanged, ${errors} error(s)`);
+    statusLine("ok", `Planning complete — ${changed} file change(s) across branches (${unchanged} unchanged, ${errors} error(s))`);
     return ok({ ...context, plans });
 };

package/dist/stages/report.js

@@ -47,34 +47,39 @@ export const reportResultsStage = async (context, deps) => {
             skipped > 0 ? chalk.gray(`${skipped} skipped`) : "",
         ].filter(Boolean).join("  "));
     console.log("");
-    // Save template state if any commits succeeded
-    const rawTemplate = context.activeTemplate?.raw ?? context.template?.raw;
-    if (committed > 0 && context.project && context.target && rawTemplate) {
+    // Save template state for all edited templates
+    const templates = context.templates || (context.activeTemplate ? [context.activeTemplate] : []);
+    if (context.project && templates.length > 0) {
         const summary = {
             committed,
             failed,
             skipped: skipped + rejected,
             total: results.length,
         };
-        const saveResult = await deps.services.state.saveTemplate(context.project.stateDir, context.target.path, rawTemplate, summary);
-        if (saveResult.ok) {
-            statusLine("ok", `Template saved for '${context.target.path}' (ready for next run)`);
-        }
-        else {
-            statusLine("warn", "Could not save template state", saveResult.error.message);
+        if (committed > 0) {
+            for (const t of templates) {
+                if (t.raw) {
+                    const saveResult = await deps.services.state.saveTemplate(context.project.stateDir, t.path, t.raw, summary);
+                    if (saveResult.ok) {
+                        statusLine("ok", `Template state saved for '${t.path}' (ready for future runs)`);
+                    }
+                }
+            }
         }
-    }
-    else if (committed === 0 && context.project && context.target && rawTemplate) {
-        // No commits but everything matches — offer to save reviewed template
-        const { clack } = await import("../utils/ui.js");
-        if (!context.input.ci) {
+        else if (!context.input.ci) {
+            // No commits — offer to save reviewed templates
+            const { clack } = await import("../utils/ui.js");
             const save = await clack.confirm({
-                message: "No changes committed. Save current template for next run?",
+                message: `No changes committed. Save ${templates.length} reviewed template(s) for next run?`,
                 initialValue: true,
             });
             if (!clack.isCancel(save) && save) {
-                await deps.services.state.saveTemplate(context.project.stateDir, context.target.path, rawTemplate);
-                statusLine("ok", `Template saved for '${context.target.path}'`);
+                for (const t of templates) {
+                    if (t.raw) {
+                        await deps.services.state.saveTemplate(context.project.stateDir, t.path, t.raw);
+                        statusLine("ok", `Template saved for '${t.path}'`);
+                    }
+                }
             }
         }
     }
@@ -82,7 +87,7 @@ export const reportResultsStage = async (context, deps) => {
     if (context.project && (deps.config.report.writeJson || deps.config.report.writeMarkdown)) {
         const report = {
             runId: context.runId,
-            targetPath: context.target?.path ?? "",
+            targetPath: context.target?.path ?? templates.map((t) => t.path).join(", "),
             startedAt: new Date().toISOString(),
             completedAt: new Date().toISOString(),
             plans: context.plans ?? [],