zapdev 0.7.0 → 0.8.0

package/README.md

@@ -36,6 +36,7 @@ zapdev commit
 | --- | --- |
 | `-m, --model <model>` | Override the Ollama model |
 | `-t, --type <type>` | Force the Conventional Commits type (`feat`, `fix`, `chore`, …) |
+| `--pull` | Rebase onto upstream (`git pull --rebase`) after committing, before pushing |
 | `-p, --push` | Push after committing without asking |
 | `-y, --yes` | Skip prompts and commit directly |
 
@@ -43,15 +44,17 @@ zapdev commit
 zapdev commit -t feat      # force the type; the model still writes scope + description
 ```
 
+Pushing is optimistic — no preliminary fetch, so the common case stays a single round-trip. If the push is rejected because the branch is behind its upstream, in a TTY it offers to `git pull --rebase` and retry; non-interactively (`--yes` / piped) it stops and asks you to re-run with `--pull`. Pass `--pull` to rebase onto upstream right after the commit (a rebase conflict stops before pushing). `--yes` only silences prompts; it never rebases on its own.
+
 Without a TTY (piped / CI), it commits automatically and only pushes when `--push` is set.
 
 ### `zapdev reset`
 
-Scans a directory for its **direct child** git repos (level 1, non-recursive). For each one: `git fetch --prune`, switch to a branch (chosen interactively, or forced with `--principal` / `--target`), then permanently delete every other local branch and every linked worktree. The principal branch (from `origin/HEAD`) and the branch you switched to are always kept. Ends with an optional `pull`.
+Operates on a git repo, or — when the path is a plain directory — on its **direct child** repos (level 1, non-recursive). For each one: `git fetch --prune`, switch to a branch (chosen interactively, or forced with `--principal` / `--target`), then permanently delete every other local branch and every linked worktree. The principal branch (from `origin/HEAD`) and the branch you switched to are always kept. Ends with an optional `pull`.
 
 ```bash
-zapdev reset                 # child repos of the current directory
-zapdev reset ~/dev           # child repos of a specific directory
+zapdev reset                 # the current repo, or the child repos of the current directory
+zapdev reset ~/dev           # a repo, or the child repos of a directory
 zapdev reset -p              # switch each repo to its principal branch, no prompt
 zapdev reset -t dev          # switch each repo to `dev` (or principal if absent)
 ```

package/dist/cli.js

@@ -1718,7 +1718,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "0.7.0",
+  version: "0.8.0",
   description: "Fast, performant and lightweight git chores and dev tools using your terminal and your own local LLM.",
   type: "module",
   bin: {
@@ -2222,13 +2222,24 @@ async function push() {
 async function pushSetUpstream(branch) {
   await git(["push", "-u", "origin", branch]);
 }
-async function findChildRepos(parent) {
-  const entries = await readdir(parent, { withFileTypes: true }).catch(() => null);
+async function pullRebase() {
+  await git(["pull", "--rebase"]);
+}
+async function fetchRemote() {
+  await git(["fetch"]);
+}
+async function behindCount() {
+  const out = await tryGit(["rev-list", "--count", `HEAD..${UPSTREAM_REF}`]);
+  return out === null ? 0 : Number(out.trim()) || 0;
+}
+async function findRepos(path) {
+  if (await isGitRepo(path)) return [path];
+  const entries = await readdir(path, { withFileTypes: true }).catch(() => null);
   if (!entries) return [];
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules");
   const repos = await Promise.all(
     dirs.map(async (entry) => {
-      const dir = join(parent, entry.name);
+      const dir = join(path, entry.name);
       return await isGitRepo(dir) ? dir : null;
     })
   );
@@ -2371,6 +2382,10 @@ var commitCommand = defineCommand({
       alias: "t",
       description: `Force the Conventional Commits type (${COMMIT_TYPES.join(", ")}).`
     },
+    pull: {
+      type: "boolean",
+      description: "Rebase onto upstream (git pull --rebase) after committing, before pushing."
+    },
     push: {
       type: "boolean",
       alias: "p",
@@ -2456,6 +2471,10 @@ var commitCommand = defineCommand({
     }
     await commit(finalMessage);
     if (interactive) log.success(`Committed: ${finalMessage}`);
+    if (args.pull && !await rebaseOnUpstream(interactive)) {
+      process.exitCode = 1;
+      return;
+    }
     let shouldPush = Boolean(args.push);
     if (!shouldPush && interactive && !args.yes) {
       const answer = await confirm({ message: "Push?", initialValue: false });
@@ -2466,16 +2485,8 @@ var commitCommand = defineCommand({
       shouldPush = answer;
     }
     if (shouldPush) {
-      const pushLoader = interactive ? spinner() : void 0;
-      pushLoader?.start("Pushing");
-      try {
-        const [upstream, branch] = await Promise.all([hasUpstream(), currentBranch()]);
-        if (upstream) await push();
-        else await pushSetUpstream(branch);
-        pushLoader?.stop("\u2713 Pushed");
-      } catch (error) {
-        pushLoader?.error("Push failed");
-        log.error(`Push failed: ${errorMessage(error)}`);
+      const pushed = await pushOptimistic(interactive, Boolean(args.yes));
+      if (!pushed) {
         process.exitCode = 1;
         return;
       }
@@ -2483,20 +2494,89 @@ var commitCommand = defineCommand({
     if (interactive) outro("Done.");
   }
 });
+async function rebaseOnUpstream(interactive) {
+  if (!await hasUpstream()) {
+    log.info("No upstream to pull from; skipping --pull.");
+    return true;
+  }
+  const loader = interactive ? spinner() : void 0;
+  loader?.start("Pulling --rebase");
+  try {
+    await pullRebase();
+    loader?.stop("\u2713 Rebased on upstream");
+    return true;
+  } catch (error) {
+    loader?.error("Rebase failed");
+    log.error(`Rebase failed (resolve conflicts, then push): ${errorMessage(error)}`);
+    return false;
+  }
+}
+async function pushOptimistic(interactive, assumeYes) {
+  const [upstream, branch] = await Promise.all([hasUpstream(), currentBranch()]);
+  const doPush = () => upstream ? push() : pushSetUpstream(branch);
+  const first = await tryPush(interactive, doPush);
+  if (first.ok) return true;
+  if (upstream && await isBehind(interactive)) {
+    if (assumeYes || !interactive) {
+      log.error("Behind upstream \u2014 re-run with --pull to rebase and push.");
+      return false;
+    }
+    const answer = await confirm({ message: "Pull --rebase and retry push?", initialValue: true });
+    if (isCancel(answer) || !answer) {
+      log.info("Not pushed (still behind).");
+      return true;
+    }
+    if (!await rebaseOnUpstream(interactive)) return false;
+    const retry = await tryPush(interactive, doPush);
+    if (retry.ok) return true;
+    log.error(`Push failed: ${errorMessage(retry.error)}`);
+    return false;
+  }
+  log.error(`Push failed: ${errorMessage(first.error)}`);
+  return false;
+}
+async function tryPush(interactive, doPush) {
+  const loader = interactive ? spinner() : void 0;
+  loader?.start("Pushing");
+  try {
+    await doPush();
+    loader?.stop("\u2713 Pushed");
+    return { ok: true };
+  } catch (error) {
+    loader?.error("Push failed");
+    return { ok: false, error };
+  }
+}
+async function isBehind(interactive) {
+  const loader = interactive ? spinner() : void 0;
+  loader?.start("Checking upstream");
+  try {
+    await fetchRemote();
+    const behind = await behindCount();
+    loader?.stop(
+      behind > 0 ? `Behind upstream by ${behind} commit${behind > 1 ? "s" : ""}` : "Up to date with upstream"
+    );
+    return behind > 0;
+  } catch (error) {
+    loader?.error("Could not check upstream");
+    log.warn(`Could not check upstream: ${errorMessage(error)}`);
+    return false;
+  }
+}
 
 // src/commands/reset.ts
 var CANCEL = /* @__PURE__ */ Symbol("cancel");
 var resetCommand = defineCommand({
   meta: {
     name: "reset",
-    description: "Switch every child repo to a branch, then delete all other local branches and worktrees."
+    description: "Switch each repo to a branch, then delete all other local branches and worktrees."
   },
   args: {
     path: {
       type: "positional",
       required: false,
       default: ".",
-      description: "Parent directory whose direct child repos are reset."
+      description: "A git repo to reset, or a directory whose direct child repos are reset."
     },
     principal: {
       type: "boolean",
@@ -2528,9 +2608,9 @@ var resetCommand = defineCommand({
     };
     const path = args.path || ".";
     if (interactive) intro("zapdev reset");
-    const repos = await findChildRepos(path);
+    const repos = await findRepos(path);
     if (repos.length === 0) {
-      log.warn(`No child git repository found under ${path}.`);
+      log.warn(`No git repository found at or under ${path}.`);
       if (interactive) outro("Nothing to do.");
       return;
     }
@@ -2685,7 +2765,7 @@ var commands = {
 };
 var MENU = {
   commit: "Stage all changes and commit with an AI-generated message",
-  reset: "Switch child repos to a branch and delete the other branches and worktrees"
+  reset: "Switch repos to a branch and delete the other branches and worktrees"
 };
 var menuOptions = Object.keys(MENU).map((value) => ({
   value,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapdev",
-  "version": "0.7.0",
+  "version": "0.8.0",
   "description": "Fast, performant and lightweight git chores and dev tools using your terminal and your own local LLM.",
   "type": "module",
   "bin": {