zapdev 0.7.1 → 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,6 +44,8 @@ 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`

package/dist/cli.js

@@ -1718,7 +1718,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "0.7.1",
+  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,6 +2222,16 @@ async function push() {
 async function pushSetUpstream(branch) {
   await git(["push", "-u", "origin", branch]);
 }
+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);
@@ -2372,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",
@@ -2457,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 });
@@ -2467,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;
       }
@@ -2484,6 +2494,75 @@ 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");

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapdev",
-  "version": "0.7.1",
+  "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": {