zapdev 1.1.1 → 1.3.0

package/README.md

@@ -94,7 +94,7 @@ Stages all changes, scans them with Gitleaks when installed, generates Conventio
 
 - **Inside a Git repository:** uses that repository only, including when launched from a subdirectory. Does not inspect child repositories.
 - **Outside a Git repository:** processes only direct child repositories. No recursive search; `node_modules` is excluded.
-- **Unified review:** generates messages in parallel, then presents every message with its repository name.
+- **Unified review:** generates messages in parallel, then presents every message with its repository name and branch. Repositories with pending changes are shown in bold and underlined when terminal styling is enabled.
 - **Actions:** commit all, commit only a named repository, edit a named repository's message, or cancel. Editing returns to the review menu.
 
 Repositories with nothing to commit are skipped. Unselected or cancelled changes remain staged. Push confirmation is asked once for the successfully committed repositories.

package/dist/cli.js

@@ -554,7 +554,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "1.1.1",
+  version: "1.3.0",
   description: "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   type: "module",
   bin: {
@@ -614,6 +614,7 @@ var package_default = {
 
 // src/commands/commit.ts
 import { basename } from "node:path";
+import { styleText as styleText3 } from "node:util";
 
 // node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
@@ -2190,6 +2191,14 @@ async function commit(repo, message) {
 async function currentBranch(repo) {
   return (await git(["symbolic-ref", "--short", "HEAD"], repo)).trim();
 }
+async function getRepoStatus(repo) {
+  const lines = (await git(["status", "--porcelain=v2", "--branch", "--untracked-files=normal"], repo)).trim().split("\n");
+  const branch = lines.find((line) => line.startsWith("# branch.head "))?.slice(14) ?? "HEAD";
+  return {
+    branch: branch === "(detached)" ? "detached HEAD" : branch,
+    hasChanges: lines.some((line) => !line.startsWith("#"))
+  };
+}
 async function hasUpstream(repo) {
   const result = await tryGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", UPSTREAM_REF], repo);
   return result !== null;
@@ -2422,25 +2431,30 @@ var commitCommand = defineCommand({
     if (!scan) log.info("Gitleaks not found, skipping secret scan.");
     const loader = interactive ? spinner() : void 0;
     loader?.start("Preparing repositories and generating commit messages in parallel");
-    const results = await Promise.allSettled(repos.map(async (repo) => {
+    const repositories = repos.map((repo) => ({ repo, label: basename(repo), pendingLabel: basename(repo) }));
+    const results = await Promise.allSettled(repositories.map(async (repository) => {
+      const { repo } = repository;
+      const { branch, hasChanges } = await getRepoStatus(repo);
+      repository.label = `${basename(repo)} (${branch})`;
+      repository.pendingLabel = hasChanges ? styleText3(["bold", "underline"], repository.label) : repository.label;
       if (!args.staged) await stageAll(repo);
       const diff = await getStagedDiff(repo);
       if (!diff.trim()) return null;
       if (scan) await scanStagedChanges(repo);
       const message = await generateCommitMessage(diff, config, type);
       if (!message) throw new Error("The model returned an empty message.");
-      return { repo, message };
+      return { ...repository, message };
     }));
     loader?.stop("Repositories prepared");
     const drafts = [];
     for (const [index, result] of results.entries()) {
       if (result.status === "rejected") {
-        log.error(`${basename(repos[index])}: ${errorMessage(result.reason)}`);
+        log.error(`${repositories[index].pendingLabel}: ${errorMessage(result.reason)}`);
         process.exitCode = 1;
       } else if (result.value) {
         drafts.push(result.value);
       } else {
-        log.info(`${basename(repos[index])}: nothing to commit.`);
+        log.info(`${repositories[index].pendingLabel}: nothing to commit.`);
       }
     }
     if (drafts.length === 0) {
@@ -2457,9 +2471,9 @@ var commitCommand = defineCommand({
       try {
         await commit(draft.repo, draft.message);
         committed.push(draft);
-        log.success(`${basename(draft.repo)}: committed ${draft.message}`);
+        log.success(`${draft.label}: committed ${draft.message}`);
       } catch (error) {
-        log.error(`${basename(draft.repo)}: commit failed: ${errorMessage(error)}`);
+        log.error(`${draft.pendingLabel}: commit failed: ${errorMessage(error)}`);
         process.exitCode = 1;
       }
     }
@@ -2467,7 +2481,7 @@ var commitCommand = defineCommand({
     let shouldPush = Boolean(args.push);
     if (!shouldPush && interactive && !args.yes) {
       const answer = await confirm({
-        message: `Push ${committed.map(({ repo }) => basename(repo)).join(", ")}?`,
+        message: `Push ${committed.map(({ label }) => label).join(", ")}?`,
         initialValue: false
       });
       if (isCancel(answer)) {
@@ -2477,17 +2491,17 @@ var commitCommand = defineCommand({
       shouldPush = answer;
     }
     if (shouldPush) {
-      for (const { repo } of committed) {
+      for (const repository of committed) {
         try {
           const pushed = await pushOptimistic(
-            repo,
+            repository,
             interactive,
             interactive && !args.yes,
             syncStrategy
           );
           if (!pushed) process.exitCode = 1;
         } catch (error) {
-          log.error(`${basename(repo)}: push failed: ${errorMessage(error)}`);
+          log.error(`${repository.label}: push failed: ${errorMessage(error)}`);
           process.exitCode = 1;
         }
       }
@@ -2497,7 +2511,7 @@ var commitCommand = defineCommand({
 });
 async function reviewMessages(drafts, canPrompt) {
   while (true) {
-    for (const draft of drafts) log.message(`${basename(draft.repo)}: ${draft.message}`);
+    for (const draft of drafts) log.message(`${draft.pendingLabel}: ${draft.message}`);
     if (!canPrompt) return drafts;
     const action = await select({
       message: "Action",
@@ -2506,11 +2520,11 @@ async function reviewMessages(drafts, canPrompt) {
         { value: "all", label: drafts.length > 1 ? "Commit all" : "Commit" },
         ...drafts.length > 1 ? drafts.map((draft) => ({
           value: { action: "commit", draft },
-          label: `Commit only "${basename(draft.repo)}"`
+          label: `Commit only "${draft.pendingLabel}"`
         })) : [],
         ...drafts.map((draft) => ({
           value: { action: "edit", draft },
-          label: `Edit message for "${basename(draft.repo)}"`
+          label: `Edit message for "${draft.pendingLabel}"`
         })),
         { value: "cancel", label: "Cancel" }
       ]
@@ -2519,7 +2533,7 @@ async function reviewMessages(drafts, canPrompt) {
     if (action === "all") return drafts;
     if (action.action === "commit") return [action.draft];
     const edited = await text({
-      message: `Edit message for "${basename(action.draft.repo)}"`,
+      message: `Edit message for "${action.draft.pendingLabel}"`,
       initialValue: action.draft.message,
       validate: (value) => value?.trim() ? void 0 : "Message cannot be empty."
     });
@@ -2527,43 +2541,44 @@ async function reviewMessages(drafts, canPrompt) {
     action.draft.message = edited.trim();
   }
 }
-async function syncWithUpstream(repo, strategy, interactive) {
+async function syncWithUpstream({ repo, label }, strategy, interactive) {
   const loader = interactive ? spinner() : void 0;
-  const label = strategy === "rebase" ? "Rebase" : "Merge";
-  loader?.start(`${basename(repo)}: pulling --${strategy === "rebase" ? "rebase" : "no-rebase"}`);
+  const actionLabel = strategy === "rebase" ? "Rebase" : "Merge";
+  loader?.start(`${label}: pulling --${strategy === "rebase" ? "rebase" : "no-rebase"}`);
   try {
     await (strategy === "rebase" ? pullRebase(repo) : pullMerge(repo));
     loader?.stop(strategy === "rebase" ? "\u2713 Rebased on upstream" : "\u2713 Merged upstream");
     return true;
   } catch (error) {
-    loader?.error(`${label} failed`);
-    log.error(`${basename(repo)}: ${label} failed (resolve conflicts, then push): ${errorMessage(error)}`);
+    loader?.error(`${actionLabel} failed`);
+    log.error(`${label}: ${actionLabel} failed (resolve conflicts, then push): ${errorMessage(error)}`);
     return false;
   }
 }
-async function pushOptimistic(repo, interactive, canPrompt, strategy) {
+async function pushOptimistic(repository, interactive, canPrompt, strategy) {
+  const { repo, label } = repository;
   const [upstream, branch] = await Promise.all([hasUpstream(repo), currentBranch(repo)]);
   const doPush = () => upstream ? push(repo) : pushSetUpstream(repo, branch);
-  const first = await tryPush(repo, interactive, doPush);
+  const first = await tryPush(repository, interactive, doPush);
   if (first.ok) return true;
-  if (upstream && await isBehind(repo, interactive)) {
-    const syncStrategy = strategy ?? await chooseSyncStrategy(repo, canPrompt);
-    if (!syncStrategy || !await syncWithUpstream(repo, syncStrategy, interactive)) return false;
-    const retry = await tryPush(repo, interactive, doPush);
+  if (upstream && await isBehind(repository, interactive)) {
+    const syncStrategy = strategy ?? await chooseSyncStrategy(repository, canPrompt);
+    if (!syncStrategy || !await syncWithUpstream(repository, syncStrategy, interactive)) return false;
+    const retry = await tryPush(repository, interactive, doPush);
     if (retry.ok) return true;
-    log.error(`${basename(repo)}: push failed: ${errorMessage(retry.error)}`);
+    log.error(`${label}: push failed: ${errorMessage(retry.error)}`);
     return false;
   }
-  log.error(`${basename(repo)}: push failed: ${errorMessage(first.error)}`);
+  log.error(`${label}: push failed: ${errorMessage(first.error)}`);
   return false;
 }
-async function chooseSyncStrategy(repo, interactive) {
+async function chooseSyncStrategy({ label }, interactive) {
   if (!interactive) {
-    log.error(`${basename(repo)}: branch is behind upstream. Re-run with --rebase or --merge.`);
+    log.error(`${label}: branch is behind upstream. Re-run with --rebase or --merge.`);
     return null;
   }
   const action = await select({
-    message: `${basename(repo)}: branch is behind upstream. How should zapdev sync it?`,
+    message: `${label}: branch is behind upstream. How should zapdev sync it?`,
     options: [
       { value: "rebase", label: "Rebase" },
       { value: "merge", label: "Merge" },
@@ -2576,9 +2591,9 @@ async function chooseSyncStrategy(repo, interactive) {
   }
   return action;
 }
-async function tryPush(repo, interactive, doPush) {
+async function tryPush({ label }, interactive, doPush) {
   const loader = interactive ? spinner() : void 0;
-  loader?.start(`${basename(repo)}: pushing`);
+  loader?.start(`${label}: pushing`);
   try {
     await doPush();
     loader?.stop("\u2713 Pushed");
@@ -2588,9 +2603,9 @@ async function tryPush(repo, interactive, doPush) {
     return { ok: false, error };
   }
 }
-async function isBehind(repo, interactive) {
+async function isBehind({ repo, label }, interactive) {
   const loader = interactive ? spinner() : void 0;
-  loader?.start(`${basename(repo)}: checking upstream`);
+  loader?.start(`${label}: checking upstream`);
   try {
     await fetchRemote(repo);
     const behind = await behindCount(repo);
@@ -2600,7 +2615,7 @@ async function isBehind(repo, interactive) {
     return behind > 0;
   } catch (error) {
     loader?.error("Could not check upstream");
-    log.warn(`${basename(repo)}: could not check upstream: ${errorMessage(error)}`);
+    log.warn(`${label}: could not check upstream: ${errorMessage(error)}`);
     return false;
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapdev",
-  "version": "1.1.1",
+  "version": "1.3.0",
   "description": "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   "type": "module",
   "bin": {