@samaksh/git-worker 0.2.2 → 0.3.0

package/dist/stages/review.js

@@ -10,19 +10,43 @@ export const reviewChangesStage = async (context, deps) => {
     const isCi = context.input.ci ?? false;
     const autoApprove = context.input.autoApprove || deps.config.review.autoApprove;
     sectionHeader("Review Changes");
-    // Show summary table first
-    renderBranchTable(context.plans.map((p) => ({
-        name: p.branch.name,
-        status: p.status,
-        detail: p.status === "changed"
-            ? `${p.updatedKeys.length} updated, ${p.addedKeys.length} added`
-            : p.status === "error"
-                ? p.reason ?? "error"
-                : "no changes",
-    })));
-    const changedPlans = context.plans.filter((p) => p.status === "changed");
+    // Group plans by branch
+    const branchMap = new Map();
+    for (const plan of context.plans) {
+        const list = branchMap.get(plan.branch.name) || [];
+        list.push(plan);
+        branchMap.set(plan.branch.name, list);
+    }
+    // Show summary table grouped by branch
+    const tableRows = Array.from(branchMap.entries()).map(([branchName, plans]) => {
+        const hasError = plans.some((p) => p.status === "error");
+        const changedPlans = plans.filter((p) => p.status === "changed");
+        if (hasError) {
+            const errPlan = plans.find((p) => p.status === "error");
+            return {
+                name: branchName,
+                status: "error",
+                detail: `${errPlan?.path}: ${errPlan?.reason ?? "error"}`,
+            };
+        }
+        if (changedPlans.length > 0) {
+            const fileSummary = changedPlans.map((p) => p.path).join(", ");
+            return {
+                name: branchName,
+                status: "changed",
+                detail: `${changedPlans.length} file(s) modified (${fileSummary})`,
+            };
+        }
+        return {
+            name: branchName,
+            status: "unchanged",
+            detail: "no changes across files",
+        };
+    });
+    renderBranchTable(tableRows);
+    const changedBranches = Array.from(branchMap.entries()).filter(([_, plans]) => plans.some((p) => p.status === "changed") && !plans.some((p) => p.status === "error"));
     const approvals = [];
-    // Auto-approve unchanged and errors
+    // Auto-record non-changed or errored plans as unapproved
     for (const plan of context.plans) {
         if (plan.status !== "changed") {
             approvals.push({
@@ -32,42 +56,48 @@ export const reviewChangesStage = async (context, deps) => {
             });
         }
     }
-    if (changedPlans.length === 0) {
+    if (changedBranches.length === 0) {
         statusLine("info", "No changed branches to review");
         return ok({ ...context, approvals });
     }
     // Auto-approve all
     if (autoApprove) {
-        for (const plan of changedPlans) {
-            approvals.push({
-                branchName: plan.branch.name,
-                approved: true,
-                planHash: plan.planHash,
-            });
+        for (const [_, plans] of changedBranches) {
+            for (const plan of plans) {
+                if (plan.status === "changed") {
+                    approvals.push({
+                        branchName: plan.branch.name,
+                        approved: true,
+                        planHash: plan.planHash,
+                    });
+                }
+            }
         }
-        statusLine("ok", `Auto-approved ${changedPlans.length} branch(es)`);
+        statusLine("ok", `Auto-approved ${changedBranches.length} branch(es)`);
         return ok({ ...context, approvals });
     }
     if (isCi) {
-        // CI without auto-approve: reject all
-        for (const plan of changedPlans) {
-            approvals.push({
-                branchName: plan.branch.name,
-                approved: false,
-                planHash: plan.planHash,
-            });
+        for (const [_, plans] of changedBranches) {
+            for (const plan of plans) {
+                if (plan.status === "changed") {
+                    approvals.push({
+                        branchName: plan.branch.name,
+                        approved: false,
+                        planHash: plan.planHash,
+                    });
+                }
+            }
         }
         statusLine("warn", "CI mode — all branches rejected (use --auto-approve to commit in CI)");
         return ok({ ...context, approvals });
     }
     // Interactive review
     console.log("");
-    // Ask if user wants batch action or per-branch review
     const batchChoice = await clack.select({
-        message: `Review ${changedPlans.length} changed branch(es):`,
+        message: `Review ${changedBranches.length} changed branch(es):`,
         options: [
             { value: "per-branch", label: "Review each branch individually", hint: "recommended" },
-            { value: "approve-all", label: `Approve all ${changedPlans.length} branches` },
+            { value: "approve-all", label: `Approve all ${changedBranches.length} branches` },
             { value: "reject-all", label: "Reject all" },
         ],
     });
@@ -75,118 +105,106 @@ export const reviewChangesStage = async (context, deps) => {
         return err(inputCancelledError("Review cancelled"));
     }
     if (batchChoice === "approve-all") {
-        for (const plan of changedPlans) {
-            approvals.push({ branchName: plan.branch.name, approved: true, planHash: plan.planHash });
+        for (const [_, plans] of changedBranches) {
+            for (const plan of plans) {
+                if (plan.status === "changed") {
+                    approvals.push({ branchName: plan.branch.name, approved: true, planHash: plan.planHash });
+                }
+            }
         }
-        statusLine("ok", `Approved all ${changedPlans.length} branch(es)`);
+        statusLine("ok", `Approved all ${changedBranches.length} branch(es)`);
         return ok({ ...context, approvals });
     }
     if (batchChoice === "reject-all") {
-        for (const plan of changedPlans) {
-            approvals.push({ branchName: plan.branch.name, approved: false, planHash: plan.planHash });
+        for (const [_, plans] of changedBranches) {
+            for (const plan of plans) {
+                if (plan.status === "changed") {
+                    approvals.push({ branchName: plan.branch.name, approved: false, planHash: plan.planHash });
+                }
+            }
         }
         statusLine("warn", "All branches rejected");
         return ok({ ...context, approvals });
     }
     // Per-branch review
-    for (const plan of changedPlans) {
+    for (const [branchName, plans] of changedBranches) {
+        const branchPlansToCommit = plans.filter((p) => p.status === "changed");
+        const firstPlan = branchPlansToCommit[0];
         console.log("");
         divider();
-        console.log(`  ${sym.branch} ${chalk.bold.cyan(plan.branch.name)}  ${chalk.gray(plan.baseCommitSha.slice(0, 8))}`);
-        console.log(`  ${chalk.gray(plan.path)}`);
-        console.log("");
-        // Show inline diff
-        if (deps.config.report.warnOnSecrets) {
-            console.log(chalk.yellow("  ⚠  Diff may contain secret values — treat with care"));
+        console.log(`  ${sym.branch} ${chalk.bold.cyan(branchName)}  ${chalk.gray(firstPlan.baseCommitSha.slice(0, 8))}  (${branchPlansToCommit.length} file(s) changed)`);
+        // Show diffs for each file on this branch
+        for (const plan of branchPlansToCommit) {
             console.log("");
-        }
-        renderDiff(plan.diff, false);
-        // Write snapshots for external diff tool
-        const snapResult = await writeSnapshots(context.project.stagingDir, context.runId, plan);
-        let openDiff = false;
-        if (snapResult.ok) {
-            const choice = await clack.select({
-                message: "Action:",
-                options: [
-                    { value: "approve", label: `${chalk.green("✓")} Approve`, hint: "commit this branch" },
-                    { value: "reject", label: `${chalk.red("✗")} Reject`, hint: "skip this branch" },
-                    { value: "diff", label: `${chalk.cyan("⊞")} Open in diff viewer`, hint: deps.config.editor.name },
-                ],
-            });
-            if (clack.isCancel(choice)) {
-                return err(inputCancelledError("Review cancelled"));
+            console.log(`  ${chalk.bold("File:")} ${chalk.yellow(plan.path)}`);
+            if (deps.config.report.warnOnSecrets) {
+                console.log(chalk.yellow("  ⚠  Diff may contain secret values — treat with care"));
             }
-            if (choice === "diff") {
-                const { beforePath, afterPath } = snapResult.value;
-                const diffResult = await deps.services.editor.openForDiff(beforePath, afterPath, deps.config);
-                if (!diffResult.ok) {
-                    clack.log.warn(diffResult.error.message);
-                }
-                // Ask again after opening diff
-                const afterDiff = await clack.select({
-                    message: "After reviewing the diff:",
-                    options: [
-                        { value: "approve", label: `${chalk.green("✓")} Approve` },
-                        { value: "reject", label: `${chalk.red("✗")} Reject` },
-                    ],
-                });
-                if (clack.isCancel(afterDiff)) {
-                    return err(inputCancelledError("Review cancelled"));
+            renderDiff(plan.diff, false);
+        }
+        const choice = await clack.select({
+            message: `Action for branch ${chalk.cyan(branchName)}:`,
+            options: [
+                { value: "approve", label: `${chalk.green("✓")} Approve branch bundle`, hint: `commit ${branchPlansToCommit.length} file(s)` },
+                { value: "reject", label: `${chalk.red("✗")} Reject`, hint: "skip this branch" },
+                { value: "diff", label: `${chalk.cyan("⊞")} Open in external diff viewer`, hint: deps.config.editor.name },
+            ],
+        });
+        if (clack.isCancel(choice)) {
+            return err(inputCancelledError("Review cancelled"));
+        }
+        if (choice === "diff") {
+            for (const plan of branchPlansToCommit) {
+                const snapResult = await writeSnapshots(context.project.stagingDir, context.runId, plan);
+                if (snapResult.ok) {
+                    await deps.services.editor.openForDiff(snapResult.value.beforePath, snapResult.value.afterPath, deps.config);
                 }
-                approvals.push({
-                    branchName: plan.branch.name,
-                    approved: afterDiff === "approve",
-                    planHash: plan.planHash,
-                });
-            }
-            else {
-                approvals.push({
-                    branchName: plan.branch.name,
-                    approved: choice === "approve",
-                    planHash: plan.planHash,
-                });
             }
-        }
-        else {
-            // No snapshots — just approve/reject
-            const choice = await clack.select({
-                message: "Action:",
+            const afterDiff = await clack.select({
+                message: `After reviewing diffs for ${branchName}:`,
                 options: [
                     { value: "approve", label: `${chalk.green("✓")} Approve` },
                     { value: "reject", label: `${chalk.red("✗")} Reject` },
                 ],
             });
-            if (clack.isCancel(choice)) {
+            if (clack.isCancel(afterDiff)) {
                 return err(inputCancelledError("Review cancelled"));
             }
-            approvals.push({
-                branchName: plan.branch.name,
-                approved: choice === "approve",
-                planHash: plan.planHash,
-            });
+            const isApproved = afterDiff === "approve";
+            for (const plan of branchPlansToCommit) {
+                approvals.push({ branchName, approved: isApproved, planHash: plan.planHash });
+            }
+        }
+        else {
+            const isApproved = choice === "approve";
+            for (const plan of branchPlansToCommit) {
+                approvals.push({ branchName, approved: isApproved, planHash: plan.planHash });
+            }
         }
     }
     divider();
-    const approved = approvals.filter((a) => a.approved).length;
-    const rejected = approvals.filter((a) => !a.approved && context.plans.find((p) => p.branch.name === a.branchName)?.status === "changed").length;
-    statusLine("ok", `Review complete — ${approved} approved, ${rejected} rejected`);
+    const approvedCount = new Set(approvals.filter((a) => a.approved).map((a) => a.branchName)).size;
+    const rejectedCount = new Set(approvals
+        .filter((a) => !a.approved && changedBranches.some(([b]) => b === a.branchName))
+        .map((a) => a.branchName)).size;
+    statusLine("ok", `Review complete — ${approvedCount} branch(es) approved, ${rejectedCount} rejected`);
     // Confirm before destructive apply
-    if (approved > 0) {
+    if (approvedCount > 0) {
         console.log("");
-        console.log(chalk.bold("  Summary of approved changes:"));
-        for (const plan of changedPlans) {
-            const a = approvals.find((ap) => ap.branchName === plan.branch.name);
-            if (a?.approved) {
-                const detail = [
-                    plan.updatedKeys.length > 0 ? `update: ${plan.updatedKeys.join(", ")}` : "",
-                    plan.addedKeys.length > 0 ? `add: ${plan.addedKeys.join(", ")}` : "",
-                ].filter(Boolean).join(" | ");
-                statusLine("ok", plan.branch.name, detail);
+        console.log(chalk.bold("  Summary of approved branch commits:"));
+        for (const [branchName, plans] of changedBranches) {
+            const isApp = approvals.some((a) => a.branchName === branchName && a.approved);
+            if (isApp) {
+                const fileNames = plans
+                    .filter((p) => p.status === "changed")
+                    .map((p) => p.path)
+                    .join(", ");
+                statusLine("ok", branchName, `files: ${fileNames}`);
             }
         }
         console.log("");
         const confirm = await clack.confirm({
-            message: `Proceed to commit ${approved} branch(es)?`,
+            message: `Proceed to commit ${approvedCount} branch(es)?`,
             initialValue: true,
         });
         if (clack.isCancel(confirm) || !confirm) {

package/dist/stages/select.js

@@ -3,6 +3,7 @@ import { workspaceError, inputCancelledError } from "../core/errors.js";
 import { clack, sectionHeader, statusLine } from "../utils/ui.js";
 import inquirer from "inquirer";
 import chalk from "chalk";
+import { detectPreset } from "../config/repo-presets.js";
 /**
  * Matches a branch name against a pattern.
  * Supports:
@@ -253,7 +254,7 @@ export const selectTargetsStage = async (context, deps) => {
                         {
                             type: "checkbox",
                             name: "picked",
-                            message: "Select branches to process:",
+                            message: "Select branches to process (Space: toggle • a: select all • i: invert • Enter: confirm):",
                             pageSize: 15,
                             choices,
                         },
@@ -325,26 +326,125 @@ export const selectTargetsStage = async (context, deps) => {
         clack.log.warn("No branches selected.");
         return err(inputCancelledError("No branches selected"));
     }
-    // Target file selection
-    let targetPath = context.input.file;
-    if (!targetPath && !context.input.ci) {
-        const fileInput = await clack.text({
-            message: "Target file path:",
-            placeholder: ".env",
-            defaultValue: ".env",
+    // ── Target file(s) selection ──────────────────────────────────────────
+    let targets = [];
+    if (context.input.file) {
+        const preset = detectPreset(context.project.remoteUrl, context.project.id);
+        const rawPaths = context.input.file
+            .split(",")
+            .map((p) => p.trim())
+            .filter(Boolean);
+        targets = rawPaths.map((p) => {
+            const presetFile = preset?.files.find((pf) => pf.path === p);
+            if (presetFile) {
+                return {
+                    path: presetFile.path,
+                    description: presetFile.description,
+                    isDynamic: presetFile.isDynamic,
+                    dynamicVar: presetFile.dynamicVar,
+                };
+            }
+            return { path: p };
         });
-        if (clack.isCancel(fileInput)) {
-            return err(inputCancelledError("File selection cancelled"));
+    }
+    else if (!context.input.ci) {
+        const preset = detectPreset(context.project.remoteUrl, context.project.id);
+        if (preset) {
+            statusLine("ok", `Detected repository preset: ${chalk.bold.cyan(preset.name)}`);
+            const CUSTOM_PATH_VAL = "__CUSTOM_PATH__";
+            try {
+                const { selectedPaths } = await inquirer.prompt([
+                    {
+                        type: "checkbox",
+                        name: "selectedPaths",
+                        message: "Select template file(s) to edit and sync across branches:",
+                        pageSize: 15,
+                        choices: [
+                            ...preset.files.map((f) => ({
+                                name: `${f.path.padEnd(32)} ${chalk.gray(f.description)}${f.isDynamic ? chalk.yellow(" [dynamic]") : ""}`,
+                                value: f.path,
+                                checked: f.path === ".env",
+                            })),
+                            new inquirer.Separator(),
+                            {
+                                name: chalk.cyan("➕ [Add custom file path...]"),
+                                value: CUSTOM_PATH_VAL,
+                                checked: false,
+                            },
+                        ],
+                        validate: (ans) => ans.length > 0 || "Please select at least one file",
+                    },
+                ]);
+                const chosenPaths = selectedPaths.filter((p) => p !== CUSTOM_PATH_VAL);
+                if (selectedPaths.includes(CUSTOM_PATH_VAL)) {
+                    const customInput = await clack.text({
+                        message: "Enter custom target file path:",
+                        placeholder: "config/settings.json",
+                        validate: (v) => {
+                            if (!v || v.trim().length === 0)
+                                return "Please enter a valid path";
+                        },
+                    });
+                    if (!clack.isCancel(customInput)) {
+                        chosenPaths.push(customInput.trim());
+                    }
+                }
+                targets = chosenPaths.map((p) => {
+                    const presetFile = preset.files.find((pf) => pf.path === p);
+                    if (presetFile) {
+                        return {
+                            path: presetFile.path,
+                            description: presetFile.description,
+                            isDynamic: presetFile.isDynamic,
+                            dynamicVar: presetFile.dynamicVar,
+                        };
+                    }
+                    return { path: p };
+                });
+            }
+            catch (e) {
+                if (e.isTtyError ||
+                    e.name === "ExitPromptError" ||
+                    e.message?.includes("force closed") ||
+                    e.message?.includes("User force closed")) {
+                    return err(inputCancelledError("Target file selection cancelled"));
+                }
+                targets = [{ path: ".env" }];
+            }
         }
-        targetPath = fileInput || ".env";
+        else {
+            // Generic repository target selection
+            const fileInput = await clack.text({
+                message: "Target file path:",
+                placeholder: ".env",
+                defaultValue: ".env",
+            });
+            if (clack.isCancel(fileInput)) {
+                return err(inputCancelledError("File selection cancelled"));
+            }
+            const rawPath = fileInput || ".env";
+            targets = rawPath
+                .split(",")
+                .map((p) => p.trim())
+                .filter(Boolean)
+                .map((p) => ({ path: p }));
+        }
+    }
+    else {
+        targets = [{ path: ".env" }];
     }
-    else if (!targetPath) {
-        targetPath = ".env";
+    if (targets.length === 0) {
+        targets = [{ path: ".env" }];
     }
-    statusLine("ok", `Selected ${branches.length} branch(es) → ${targetPath}`);
+    const primaryTarget = targets[0];
+    const targetSummary = targets.length === 1
+        ? targets[0].path
+        : `${targets.length} files (${targets.map((t) => t.path).join(", ")})`;
+    statusLine("ok", `Selected ${branches.length} branch(es) → ${targetSummary}`);
     return ok({
         ...context,
         selectedBranches: branches,
-        target: { path: targetPath },
+        target: primaryTarget,
+        targets,
     });
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@samaksh/git-worker",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Safe, composable TypeScript CLI/TUI for applying reviewed file changes across many Git branches",
   "type": "module",
   "main": "dist/index.js",
@@ -15,11 +15,9 @@
   "files": [
     "dist",
     "README.md",
+    "LICENSE",
     "docs"
   ],
-  "licenses": [
-    "MIT"
-  ],
   "scripts": {
     "build": "tsc",
     "prepublishOnly": "npm run build",
@@ -38,7 +36,7 @@
     "branches",
     "multi-branch"
   ],
-  "author": "",
+  "author": "Samaksh Grover <samaksh@bsure.live>",
   "license": "MIT",
   "dependencies": {
     "@clack/prompts": "^1.8.1",