@samaksh/git-worker 0.1.0 → 0.2.1

package/dist/cli/index.js

@@ -7,7 +7,7 @@ const program = new Command();
 program
     .name("git-worker")
     .description("Safe, composable CLI/TUI for applying reviewed file changes across many Git branches")
-    .version("0.1.0")
+    .version("0.2.1")
     .option("-r, --repo <path>", "Repository path or remote URL (default: current directory)")
     .option("-c, --cached", "Select from previously cloned and cached repositories")
     .option("-b, --branch <pattern>", "Branch pattern — glob (uat/*) or regex (/uat.*/)")

package/dist/index.d.ts

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

package/dist/index.js

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

package/dist/services/git/reader.js

@@ -23,56 +23,127 @@ export async function readFileFromBranch(repoPath, branch, filePath) {
 export async function listBranches(repoPath, remote) {
     try {
         const git = simpleGit(repoPath);
-        const branches = [];
-        const seen = new Set();
-        // Remote branches (source of truth for managed clone)
+        // Fast path: use git for-each-ref plumbing command.
+        // Retrieves all branch names, SHAs, and ref types in a single process execution (<25ms for 300+ branches)
+        // instead of running hundreds of sequential rev-parse child processes.
         try {
-            const remoteBranches = await git.branch(["-r"]);
-            for (const fullName of remoteBranches.all) {
-                if (fullName.includes("HEAD"))
+            const rawOutput = await git.raw([
+                "for-each-ref",
+                "--sort=-committerdate",
+                "--format=%(objectname)\t%(refname)",
+                "refs/remotes",
+                "refs/heads",
+            ]);
+            const remoteBranches = [];
+            const localBranches = [];
+            for (const rawLine of rawOutput.split("\n")) {
+                const line = rawLine.trim();
+                if (!line)
                     continue;
-                const parts = fullName.trim().split("/");
-                if (parts.length < 2)
+                const tabIdx = line.indexOf("\t");
+                if (tabIdx === -1)
                     continue;
-                const remoteName = parts[0];
-                const branchName = parts.slice(1).join("/");
-                if (remote && remoteName !== remote)
+                const sha = line.substring(0, tabIdx).trim();
+                const refname = line.substring(tabIdx + 1).trim();
+                if (!sha || !refname)
                     continue;
-                if (seen.has(branchName))
-                    continue;
-                try {
-                    const sha = await git.revparse([fullName.trim()]);
-                    seen.add(branchName);
-                    branches.push({
+                if (refname.startsWith("refs/remotes/")) {
+                    const rest = refname.substring("refs/remotes/".length);
+                    const slashIdx = rest.indexOf("/");
+                    if (slashIdx === -1)
+                        continue;
+                    const remoteName = rest.substring(0, slashIdx);
+                    const branchName = rest.substring(slashIdx + 1);
+                    // Skip symbolic refs like origin/HEAD
+                    if (branchName === "HEAD" || branchName.endsWith("/HEAD"))
+                        continue;
+                    if (remote && remoteName !== remote)
+                        continue;
+                    remoteBranches.push({
                         name: branchName,
                         remote: remoteName,
-                        sha: sha.trim(),
+                        sha,
                         isRemote: true,
                     });
                 }
-                catch {
-                    // skip branches we can't resolve
+                else if (refname.startsWith("refs/heads/")) {
+                    const branchName = refname.substring("refs/heads/".length);
+                    localBranches.push({
+                        name: branchName,
+                        sha,
+                        isRemote: false,
+                    });
                 }
             }
-        }
-        catch {
-            // No remotes is ok
-        }
-        // Local branches (only if not already discovered on remote)
-        try {
-            const local = await git.branchLocal();
-            for (const name of local.all) {
-                if (!seen.has(name)) {
-                    const sha = await git.revparse([name]);
-                    seen.add(name);
-                    branches.push({ name, sha: sha.trim(), isRemote: false });
+            const branches = [];
+            const seen = new Set();
+            // 1. Remote branches take priority (source of truth for managed clone)
+            for (const b of remoteBranches) {
+                if (!seen.has(b.name)) {
+                    seen.add(b.name);
+                    branches.push(b);
                 }
             }
+            // 2. Local branches (only if not already discovered on remote)
+            for (const b of localBranches) {
+                if (!seen.has(b.name)) {
+                    seen.add(b.name);
+                    branches.push(b);
+                }
+            }
+            return ok(branches);
         }
         catch {
-            // ignore
+            // Fallback path: use standard branch enumeration if for-each-ref fails
+            const branches = [];
+            const seen = new Set();
+            try {
+                const remoteBranches = await git.branch(["-r"]);
+                for (const fullName of remoteBranches.all) {
+                    if (fullName.includes("HEAD"))
+                        continue;
+                    const parts = fullName.trim().split("/");
+                    if (parts.length < 2)
+                        continue;
+                    const remoteName = parts[0];
+                    const branchName = parts.slice(1).join("/");
+                    if (remote && remoteName !== remote)
+                        continue;
+                    if (seen.has(branchName))
+                        continue;
+                    try {
+                        const sha = await git.revparse([fullName.trim()]);
+                        seen.add(branchName);
+                        branches.push({
+                            name: branchName,
+                            remote: remoteName,
+                            sha: sha.trim(),
+                            isRemote: true,
+                        });
+                    }
+                    catch {
+                        // skip unresolvable
+                    }
+                }
+            }
+            catch {
+                // no remotes
+            }
+            try {
+                const local = await git.branchLocal();
+                for (const name of local.all) {
+                    if (!seen.has(name)) {
+                        const sha = await git.revparse([name]);
+                        seen.add(name);
+                        branches.push({ name, sha: sha.trim(), isRemote: false });
+                    }
+                }
+            }
+            catch {
+                // ignore
+            }
+            return ok(branches);
         }
-        return ok(branches);
     }
     catch (e) {
         return err(gitError("Failed to list branches", e));

package/dist/services/workspace/manager.js

@@ -6,7 +6,7 @@ import { join, resolve, normalize } from "path";
 import { simpleGit, CheckRepoActions } from "simple-git";
 import { homedir } from "os";
 import { createHash } from "crypto";
-const GIT_WORKER_VERSION = "0.1.0";
+const GIT_WORKER_VERSION = "0.2.1";
 const LOCK_FILE = ".git-worker-lock";
 /**
  * Extract a human-readable repository name from a remote URL or file path.

package/dist/stages/eligibility.js

@@ -9,24 +9,48 @@ export const checkEligibilityStage = async (context, deps) => {
     const eligible = [];
     const ineligible = [];
     const isEnvTarget = context.target.path === ".env" || context.target.path.startsWith(".env.");
-    for (const branch of context.selectedBranches) {
-        // 1. Check if the target file exists in the branch
-        const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, context.target.path);
-        const targetFound = targetRead.ok;
-        // 2. If target is a non-.env file, check if .env is available as variable source
-        let envNote = "";
-        if (!isEnvTarget) {
-            const envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
-            if (envRead.ok) {
-                envNote = " • .env present";
+    const total = context.selectedBranches.length;
+    const isBatchMode = total > 8;
+    const s = clack.spinner();
+    if (isBatchMode) {
+        s.start(`Checking eligibility for ${total} branches…`);
+    }
+    // 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];
+            // 1. Check if the target file exists in the branch
+            const targetRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, context.target.path);
+            const targetFound = targetRead.ok;
+            // 2. If target is a non-.env file, check if .env is available as variable source
+            let envNote = "";
+            if (!isEnvTarget) {
+                const envRead = await deps.services.git.readFileFromBranch(context.project.managedRepoPath, branch, ".env");
+                if (envRead.ok) {
+                    envNote = " • .env present";
+                }
+                else {
+                    envNote = " • .env missing (variables will require fallbacks)";
+                }
+            }
+            const fileStatus = targetFound ? "target file found" : "target file will be created";
+            eligible.push(branch);
+            completed++;
+            if (isBatchMode) {
+                s.message(`Checking eligibility (${completed}/${total})…`);
             }
             else {
-                envNote = " • .env missing (variables will require fallbacks)";
+                statusLine(targetFound ? "ok" : "info", branch.name, `${branch.sha.slice(0, 8)} — ${fileStatus}${envNote}`);
             }
         }
-        const fileStatus = targetFound ? "target file found" : "target file will be created";
-        eligible.push(branch);
-        statusLine(targetFound ? "ok" : "info", 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("");

package/dist/stages/select.js

@@ -1,6 +1,7 @@
 import { ok, err } from "../core/types.js";
 import { workspaceError, inputCancelledError } from "../core/errors.js";
-import { clack, sectionHeader, statusLine, sym } from "../utils/ui.js";
+import { clack, sectionHeader, statusLine } from "../utils/ui.js";
+import inquirer from "inquirer";
 import chalk from "chalk";
 /**
  * Matches a branch name against a pattern.
@@ -100,44 +101,43 @@ export const selectTargetsStage = async (context, deps) => {
                     hint: "proceed to target file selection",
                 });
                 options.push({
-                    value: "invert",
-                    label: `🔄 Invert selection (select the other ${totalCount - selectedCount} branches)`,
-                    hint: "flip current selection",
+                    value: "list",
+                    label: "📋 Select from branch list",
+                    hint: "Space: toggle • a: select all • i: invert",
                 });
                 options.push({
-                    value: "pattern",
-                    label: "🔍 Filter by pattern or regex",
-                    hint: "glob (uat/*) or regex (/uat.*/)",
+                    value: "all",
+                    label: `🌟 Select all (a) — all ${totalCount} branches`,
                 });
                 options.push({
-                    value: "list",
-                    label: "📋 Customize selection from list",
-                    hint: "toggle individual checkboxes",
+                    value: "invert",
+                    label: `🔄 Invert selection (i) — select other ${totalCount - selectedCount} branch(es)`,
                 });
                 options.push({
-                    value: "all",
-                    label: `🌟 Select ALL branches (${totalCount} branches)`,
+                    value: "pattern",
+                    label: "🔍 Filter by pattern or regex",
+                    hint: "glob (uat/*) or regex (/uat.*/)",
                 });
             }
             else {
                 options.push({
-                    value: "pattern",
-                    label: "🔍 Filter by pattern or regex",
-                    hint: "glob (uat/*) or regex (/uat.*/)",
+                    value: "list",
+                    label: "📋 Select from branch list",
+                    hint: "Space: toggle • a: select all • i: invert",
                 });
                 options.push({
                     value: "all",
-                    label: `🌟 Select ALL branches (${totalCount} branches)`,
+                    label: `🌟 Select all (a) — all ${totalCount} branches`,
                     hint: "select every branch in repository",
                 });
                 options.push({
-                    value: "list",
-                    label: "📋 Choose individually from list",
-                    hint: "select branches with checkboxes",
+                    value: "invert",
+                    label: `🔄 Invert selection (i) — select all ${totalCount} branches`,
                 });
                 options.push({
-                    value: "invert",
-                    label: `🔄 Invert selection (select all ${totalCount} branches)`,
+                    value: "pattern",
+                    label: "🔍 Filter by pattern or regex",
+                    hint: "glob (uat/*) or regex (/uat.*/)",
                 });
             }
             const previewText = selectedCount > 0
@@ -199,24 +199,33 @@ export const selectTargetsStage = async (context, deps) => {
                 continue;
             }
             if (choice === "list") {
-                const picked = await clack.multiselect({
-                    message: "Select branches to process (Space to toggle, Enter to confirm):",
-                    options: allBranches.map((b) => ({
-                        value: b.name,
-                        label: `${sym.branch} ${b.name}`,
-                        hint: b.isRemote
-                            ? `remote/${b.remote}  ${b.sha.slice(0, 8)}`
-                            : `local  ${b.sha.slice(0, 8)}`,
-                    })),
-                    initialValues: Array.from(selectedNames),
-                    required: false,
-                });
-                if (clack.isCancel(picked)) {
+                try {
+                    const { picked } = await inquirer.prompt([
+                        {
+                            type: "checkbox",
+                            name: "picked",
+                            message: "Select branches to process:",
+                            pageSize: 15,
+                            choices: allBranches.map((b) => ({
+                                name: `${b.name} (${b.isRemote ? `remote/${b.remote}` : "local"} ${b.sha.slice(0, 8)})`,
+                                value: b.name,
+                                checked: selectedNames.has(b.name),
+                            })),
+                        },
+                    ]);
+                    selectedNames = new Set(picked);
+                    statusLine("ok", `Selection updated: ${selectedNames.size} branch(es) selected`);
+                    continue;
+                }
+                catch (e) {
+                    if (e.isTtyError ||
+                        e.name === "ExitPromptError" ||
+                        e.message?.includes("force closed") ||
+                        e.message?.includes("User force closed")) {
+                        return err(inputCancelledError("Branch selection cancelled"));
+                    }
                     continue;
                 }
-                selectedNames = new Set(picked);
-                statusLine("ok", `Selection updated: ${selectedNames.size} branch(es) selected`);
-                continue;
             }
         }
         branches = allBranches.filter((b) => selectedNames.has(b.name));

package/package.json

@@ -1,15 +1,25 @@
 {
   "name": "@samaksh/git-worker",
-  "version": "0.1.0",
+  "version": "0.2.1",
   "description": "Safe, composable TypeScript CLI/TUI for applying reviewed file changes across many Git branches",
   "type": "module",
   "main": "dist/index.js",
+  "types": "dist/index.d.ts",
   "bin": {
     "git-worker": "dist/cli/index.js",
     "gitworker": "dist/cli/index.js"
   },
+  "publishConfig": {
+    "access": "public"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "docs"
+  ],
   "scripts": {
     "build": "tsc",
+    "prepublishOnly": "npm run build",
     "dev": "tsx src/cli/index.ts",
     "demo": "tsx demo/index.ts",
     "demo:ci": "tsx demo/index.ts --ci",