zapdev 1.12.0 → 1.13.0

package/README.md

@@ -145,11 +145,11 @@ Preparation and commit failures are reported per repository while the others con
 
 With `--pull`, repositories are pulled one at a time before any staging, secret scan, or message generation. Git uses each current branch's configured upstream. Missing upstreams, divergent history, or conflicting local changes stop the entire flow before staging; no rebase, merge commit, or automatic stash is performed. Earlier successful pulls remain applied.
 
-In a terminal, Git and its hooks display live logs and support native prompts, even with `--yes` (which skips commit review, not native Git prompts). Git controls hook stdin; interactive hooks should read from the terminal, for example `/dev/tty`. Each hook has a 60-second deadline, including time spent answering prompts; override it with `ZD_HOOK_TIMEOUT=120 zapdev commit`.
+In a terminal, commit, pull, and push output is streamed into Clack task logs; silent commands create no output block. Git keeps terminal input, but stdout/stderr are pipes: hooks requiring a TTY on those streams are not supported. Git controls hook stdin; hooks can read from `/dev/tty`, although prompts written there appear outside the blocks. `--yes` skips commit review, not native prompts. Without a terminal, stdout/stderr are streamed directly. Each hook has a 60-second deadline, including time spent answering prompts; override it with `ZD_HOOK_TIMEOUT=120 zapdev commit`.
 
 Immediately before each selected commit, zapdev asks for a local branch only when the current name exactly matches `main`, `master`, `principal`, `dev`, or `development`, including with `--yes`. The first prompt starts empty; subsequent prompts reuse the previous input across repositories. Press Enter to accept the prefilled name; an empty or cleared input keeps the current branch and leaves the next prompt empty. A different name switches to the existing local branch or creates it from HEAD, without forcing or discarding pending changes. Other branches and repositories with nothing to commit never trigger this prompt. Cancelling stops the remaining commits and all pushes; earlier commits remain local.
 
-Pushes always target a remote branch with the current local branch's name, with no destination input. They use the current branch's upstream remote, or the only configured remote if there is no upstream, and run `git push <remote> HEAD:refs/heads/<current-branch>`. Missing or ambiguous remotes are skipped with a warning. Pushes check for unpublished commits against that remote branch, falling back to the remote's default branch (`HEAD`) if it is missing. If neither reference exists, pushing is attempted. Already published history is skipped. No rebase, merge, retry, or force-push.
+Pushes always target a remote branch with the current local branch's name, with no destination input. They use the current branch's upstream remote, or the only configured remote if there is no upstream, and run `git push <remote> HEAD:refs/heads/<current-branch>`. Missing or ambiguous remotes are skipped with a warning. Pushes run directly, without a preliminary fetch or history comparison; Git handles up-to-date branches and rejects non-fast-forward updates. A missing destination branch can be created even without new changes. No rebase, merge, retry, or force-push.
 
 Without a TTY, zapdev commits prepared repositories on nonprotected branches automatically; protected-branch commits are refused and changes remain staged. `--push` can publish without a TTY; without it, commits stay local. Repositories without new changes do not trigger an LLM call, branch prompt, or new commit.
 

package/dist/cli.js

@@ -830,6 +830,7 @@ function isUnicodeSupported() {
 }
 var unicode = isUnicodeSupported();
 var isCI = () => process.env.CI === "true";
+var isTTY = (o2) => o2.isTTY === true;
 var unicodeOr = (o2, e2) => unicode ? o2 : e2;
 var S_STEP_ACTIVE = unicodeOr("\u25C6", "*");
 var S_STEP_CANCEL = unicodeOr("\u25A0", "x");
@@ -1075,7 +1076,7 @@ var spinner = ({
   const x2 = getColumns(n4), k2 = I3?.styleFrame ?? W, g2 = (e2) => {
     const r3 = e2 > 1 ? O2 ?? settings.messages.error : G ?? settings.messages.cancel;
     S2 = e2 === 1, d2 && (a3(r3, e2), S2 && typeof h3 == "function" && h3());
-  }, f2 = () => g2(2), i3 = () => g2(1), A = () => {
+  }, f2 = () => g2(2), i3 = () => g2(1), A2 = () => {
     process.on("uncaughtExceptionMonitor", f2), process.on("unhandledRejection", f2), process.on("SIGINT", i3), process.on("SIGTERM", i3), process.on("exit", g2), m2 && m2.addEventListener("abort", i3);
   }, H = () => {
     process.removeListener("uncaughtExceptionMonitor", f2), process.removeListener("unhandledRejection", f2), process.removeListener("SIGINT", i3), process.removeListener("SIGTERM", i3), process.removeListener("exit", g2), m2 && m2.removeEventListener("abort", i3);
@@ -1096,7 +1097,7 @@ var spinner = ({
     d2 = true, M = block({ output: n4 }), s2 = C2(e2), w2 = performance.now(), N2 && n4.write(`${styleText2("gray", S_BAR)}
 `);
     let r3 = 0, t3 = 0;
-    A(), T2 = setInterval(() => {
+    A2(), T2 = setInterval(() => {
       if (u4 && s2 === p2)
         return;
       y2(), p2 = s2;
@@ -1224,6 +1225,123 @@ ${b2}
   }).prompt();
 };
 var i = `${styleText2("gray", S_BAR)}  `;
+var A = (l3) => l3.replace(/\x1b\[(?:\d+;)*\d*[ABCDEFGHfJKSTsu]|\x1b\[(s|u)/g, "");
+var taskLog = (l3) => {
+  const r3 = l3.output ?? process.stdout, O2 = getColumns(r3), i3 = styleText2("gray", S_BAR), p2 = l3.spacing ?? 1, k2 = 3, m2 = l3.retainLog === true, d2 = !isCI() && isTTY(r3);
+  r3.write(`${i3}
+`), r3.write(`${styleText2("green", S_STEP_SUBMIT)}  ${l3.title}
+`);
+  for (let e2 = 0; e2 < p2; e2++)
+    r3.write(`${i3}
+`);
+  const n4 = [
+    {
+      value: "",
+      full: ""
+    }
+  ];
+  let v2 = false;
+  const f2 = (e2) => {
+    if (n4.length === 0)
+      return;
+    let s2 = 0;
+    e2 && (s2 += p2 + 2);
+    for (const t3 of n4) {
+      const { value: o2, result: a3 } = t3;
+      let g2 = a3?.message ?? o2;
+      if (g2.length === 0)
+        continue;
+      a3 === void 0 && t3.header !== void 0 && t3.header !== "" && (g2 += `
+${t3.header}`);
+      const E2 = g2.split(`
+`).reduce((b2, w2) => w2 === "" ? b2 + 1 : b2 + Math.ceil((w2.length + k2) / O2), 0);
+      s2 += E2;
+    }
+    s2 > 0 && (s2 += 1, r3.write(import_sisteransi2.erase.lines(s2)));
+  }, h3 = (e2, s2, t3) => {
+    const o2 = t3 ? `${e2.full}
+${e2.value}` : e2.value;
+    e2.header !== void 0 && e2.header !== "" && log.message(
+      e2.header.split(`
+`).map((a3) => styleText2("bold", a3)),
+      {
+        output: r3,
+        secondarySymbol: i3,
+        symbol: i3,
+        spacing: 0
+      }
+    ), log.message(
+      o2.split(`
+`).map((a3) => styleText2("dim", a3)),
+      {
+        output: r3,
+        secondarySymbol: i3,
+        symbol: i3,
+        spacing: s2 ?? p2
+      }
+    );
+  }, T2 = () => {
+    for (const e2 of n4) {
+      const { header: s2, value: t3, full: o2 } = e2;
+      (s2 === void 0 || s2.length === 0) && t3.length === 0 || h3(e2, void 0, m2 === true && o2.length > 0);
+    }
+  }, L = (e2, s2, t3) => {
+    if (f2(false), (t3?.raw !== true || !v2) && e2.value !== "" && (e2.value += `
+`), e2.value += A(s2), v2 = t3?.raw === true, l3.limit !== void 0) {
+      const o2 = e2.value.split(`
+`), a3 = o2.length - l3.limit;
+      if (a3 > 0) {
+        const g2 = o2.splice(0, a3);
+        m2 && (e2.full += (e2.full === "" ? "" : `
+`) + g2.join(`
+`));
+      }
+      e2.value = o2.join(`
+`);
+    }
+    d2 && y2();
+  }, y2 = () => {
+    for (const e2 of n4)
+      e2.result ? e2.result.status === "error" ? log.error(e2.result.message, { output: r3, secondarySymbol: i3, spacing: 0 }) : log.success(e2.result.message, { output: r3, secondarySymbol: i3, spacing: 0 }) : e2.value !== "" && h3(e2, 0);
+  }, B = (e2, s2) => {
+    f2(false), e2.result = s2, d2 && y2();
+  };
+  return {
+    message(e2, s2) {
+      L(n4[0], e2, s2);
+    },
+    group(e2) {
+      const s2 = {
+        header: e2,
+        value: "",
+        full: ""
+      };
+      return n4.push(s2), {
+        message(t3, o2) {
+          L(s2, t3, o2);
+        },
+        error(t3) {
+          B(s2, {
+            status: "error",
+            message: t3
+          });
+        },
+        success(t3) {
+          B(s2, {
+            status: "success",
+            message: t3
+          });
+        }
+      };
+    },
+    error(e2, s2) {
+      f2(true), log.error(e2, { output: r3, secondarySymbol: i3, spacing: 1 }), s2?.showLog !== false && T2(), n4.splice(1, n4.length - 1), n4[0].value = "", n4[0].full = "";
+    },
+    success(e2, s2) {
+      f2(true), log.success(e2, { output: r3, secondarySymbol: i3, spacing: 1 }), s2?.showLog === true && T2(), n4.splice(1, n4.length - 1), n4[0].value = "", n4[0].full = "";
+    }
+  };
+};
 var text = (e2) => new n2({
   validate: e2.validate,
   placeholder: e2.placeholder,
@@ -1736,7 +1854,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "1.12.0",
+  version: "1.13.0",
   description: "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   type: "module",
   bin: {
@@ -1796,7 +1914,7 @@ var package_default = {
 
 // src/commands/commit.ts
 import { basename } from "node:path";
-import { styleText as styleText3 } from "node:util";
+import { styleText as styleText4 } from "node:util";
 
 // src/lib/config.ts
 function resolveHookTimeout(env = process.env) {
@@ -2208,18 +2326,23 @@ function createHookReporter(onHook, onTimeout, timeout) {
 }
 
 // src/lib/git.ts
-async function git(args, cwd, onHook) {
+async function git(args, cwd, onHook, onOutput) {
   const timeout = resolveHookTimeout();
-  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && ["commit", "pull", "push", "fetch", "ls-remote"].includes(args[0] ?? ""));
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && ["commit", "pull", "push"].includes(args[0] ?? ""));
   const terminalState = interactive && process.platform !== "win32" ? execFileSync("stty", ["-g"], { stdio: ["inherit", "pipe", "ignore"], encoding: "utf8" }).trim() : void 0;
   const child = R2("git", args, {
     nodeOptions: {
       cwd,
       detached: !interactive && process.platform !== "win32",
       env: { ...process.env, GIT_TRACE2_EVENT: "3" },
-      stdio: interactive ? ["inherit", args[0] === "ls-remote" ? "pipe" : "inherit", "inherit", "pipe"] : ["pipe", "pipe", "pipe", "pipe"]
+      stdio: interactive ? ["inherit", onOutput ? "pipe" : "inherit", onOutput ? "pipe" : "inherit", "pipe"] : ["pipe", "pipe", "pipe", "pipe"]
     }
   });
+  if (onOutput) {
+    for (const stream of ["stdout", "stderr"]) {
+      child.process?.[stream]?.setEncoding("utf8").on("data", (chunk) => onOutput(chunk, stream));
+    }
+  }
   let timeoutError;
   let hookFailureReported = false;
   const { report, close } = createHookReporter((event) => {
@@ -2247,7 +2370,7 @@ async function git(args, cwd, onHook) {
     if (timeoutError) throw timeoutError;
     if (result.exitCode !== 0) {
       const message = result.stderr.trim() || `git ${args.join(" ")} failed`;
-      if (interactive) throw new GitOutputError(message, hookFailureReported);
+      if (interactive || onOutput) throw new GitOutputError(message, hookFailureReported);
       throw new Error(message);
     }
     return result.stdout;
@@ -2297,8 +2420,8 @@ async function getStagedDiffStats(repo) {
   }
   return stats;
 }
-async function commit(repo, message, onHook) {
-  await git(["commit", "--quiet", "-m", message], repo, onHook);
+async function commit(repo, message, onHook, onOutput) {
+  await git(["commit", "--quiet", "-m", message], repo, onHook, onOutput);
 }
 async function currentBranch(repo) {
   return (await git(["symbolic-ref", "--short", "HEAD"], repo)).trim();
@@ -2323,19 +2446,9 @@ async function getPushRemote(repo, branch) {
   if (upstream) return remotes.includes(upstream) ? upstream : null;
   return remotes.length === 1 ? remotes[0] : null;
 }
-async function push(repo, remote, branch, onHook) {
-  await git(["check-ref-format", "--branch", branch], repo);
-  await git(["push", "--", remote, `HEAD:refs/heads/${branch}`], repo, onHook);
-}
-async function hasUnpushedCommits(repo, remote, branch, onHook) {
-  if (await tryGit(["rev-parse", "--verify", "HEAD"], repo) === null) return false;
+async function push(repo, remote, branch, onHook, onOutput) {
   await git(["check-ref-format", "--branch", branch], repo);
-  const ref = `refs/heads/${branch}`;
-  const refs = new Set((await git(["ls-remote", "--", remote, ref, "HEAD"], repo, onHook)).trim().split("\n").map((line) => line.split("	")[1]));
-  const target = refs.has(ref) ? ref : refs.has("HEAD") ? "HEAD" : null;
-  if (!target) return true;
-  await git(["fetch", "--quiet", "--", remote, target], repo, onHook);
-  return Boolean((await git(["rev-list", "--max-count=1", "FETCH_HEAD..HEAD"], repo)).trim());
+  await git(["push", "--", remote, `HEAD:refs/heads/${branch}`], repo, onHook, onOutput);
 }
 async function findRepos(path) {
   const root = await repoRoot(path);
@@ -2469,6 +2582,42 @@ var COMMIT_TYPES = [
   "revert"
 ];
 
+// src/commands/git-task.ts
+import { styleText as styleText3 } from "node:util";
+async function runGitTask(label, operation, successMessage, run) {
+  const title = `${label}: ${operation}`;
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+  let task;
+  const onOutput = (chunk, stream) => {
+    if (!interactive) {
+      process[stream].write(chunk);
+      return;
+    }
+    task ??= taskLog({ title, limit: 10, retainLog: true });
+    task.message(chunk, { raw: true });
+  };
+  const onHook = (event) => {
+    const hook = `${label}: ${event.name}`;
+    const message = event.phase === "start" ? hook : `${hook}: ${event.exitCode === 0 ? "completed" : `failed (exit ${event.exitCode})`}`;
+    if (task) task.message(message);
+    else if (event.phase === "start") log.step(styleText3("bold", message));
+    else if (event.exitCode === 0) log.success(message);
+    else log.error(message);
+  };
+  log.info(title);
+  try {
+    await run(onHook, onOutput);
+    if (task) task.success(successMessage, { showLog: true });
+    else log.success(successMessage);
+    return true;
+  } catch (error) {
+    const message = `${label}: ${operation} failed${error instanceof GitOutputError ? "" : `: ${errorMessage(error)}`}`;
+    if (task) task.error(message);
+    else if (!(error instanceof GitOutputError && error.hookFailureReported)) log.error(message);
+    return false;
+  }
+}
+
 // src/commands/commit.ts
 var commitCommand = defineCommand({
   meta: {
@@ -2540,11 +2689,7 @@ var commitCommand = defineCommand({
     if (args.pull) {
       for (const repo of repos) {
         const label = basename(repo);
-        try {
-          log.info(`${label}: pulling`);
-          await git(["pull", "--ff-only", "--no-rebase", "--no-autostash"], repo, reportHooks(label));
-        } catch (error) {
-          reportGitFailure(`${label}: pull failed`, error);
+        if (!await runGitTask(label, "pull", `${label}: pulled`, (onHook, onOutput) => git(["pull", "--ff-only", "--no-rebase", "--no-autostash"], repo, onHook, onOutput))) {
           process.exitCode = 1;
           return;
         }
@@ -2566,7 +2711,7 @@ var commitCommand = defineCommand({
       const { repo } = repository;
       const { branch, hasChanges } = await getRepoStatus(repo);
       repository.label = `${basename(repo)} (${branch})`;
-      repository.pendingLabel = hasChanges ? styleText3("bold", repository.label) : repository.label;
+      repository.pendingLabel = hasChanges ? styleText4("bold", repository.label) : repository.label;
       if (!args.staged) await stageAll(repo);
       const diff = await getStagedDiff(repo);
       if (!diff.trim()) return null;
@@ -2615,13 +2760,14 @@ var commitCommand = defineCommand({
           if (branch !== current) {
             await switchBranch(draft.repo, branch);
             draft.label = `${basename(draft.repo)} (${branch})`;
-            draft.pendingLabel = styleText3("bold", draft.label);
+            draft.pendingLabel = styleText4("bold", draft.label);
           }
         }
-        log.info(`${draft.label}: committing`);
-        await commit(draft.repo, draft.message, reportHooks(draft.label));
+        if (!await runGitTask(draft.label, "commit", `${draft.label}: committed ${draft.message}`, (onHook, onOutput) => commit(draft.repo, draft.message, onHook, onOutput))) {
+          process.exitCode = 1;
+          continue;
+        }
         toSend.push(draft);
-        log.success(`${draft.label}: committed ${draft.message}`);
       } catch (error) {
         reportGitFailure(`${draft.pendingLabel}: commit failed`, error);
         process.exitCode = 1;
@@ -2657,17 +2803,7 @@ var commitCommand = defineCommand({
     }
     if (shouldPush) {
       for (const { repo, label, branch, remote } of destinations) {
-        try {
-          log.info(`${label}: checking unpublished commits (${remote}/${branch}).`);
-          if (!await hasUnpushedCommits(repo, remote, branch, reportHooks(label))) {
-            log.info(`${label}: no unpushed commits. Skipping.`);
-            continue;
-          }
-          log.info(`${label}: pushing ${remote}/${branch}`);
-          await push(repo, remote, branch, reportHooks(label));
-          log.success(`${label}: pushed to ${remote}/${branch}`);
-        } catch (error) {
-          reportGitFailure(`${label}: push failed`, error);
+        if (!await runGitTask(label, "push", `${label}: pushed to ${remote}/${branch}`, (onHook, onOutput) => push(repo, remote, branch, onHook, onOutput))) {
           process.exitCode = 1;
           outro("Sending stopped after a Git failure.");
           return;
@@ -2681,21 +2817,10 @@ function reportGitFailure(message, error) {
   if (error instanceof GitOutputError && error.hookFailureReported) return;
   log.error(error instanceof GitOutputError ? message : `${message}: ${errorMessage(error)}`);
 }
-function reportHooks(label) {
-  return (event) => {
-    const hook = `${label}: ${event.name}`;
-    if (event.phase === "start") {
-      log.step(styleText3("bold", hook));
-    } else {
-      if (event.exitCode === 0) log.success(`${hook}: completed`);
-      else log.error(`${hook}: failed (exit ${event.exitCode})`);
-    }
-  };
-}
 async function reviewMessages(drafts, canPrompt) {
   while (true) {
     for (const { stats, pendingLabel, message } of drafts) {
-      log.message(`(${styleText3("green", `+${stats.additions}`)} ${styleText3("red", `-${stats.deletions}`)}) ${pendingLabel}: ${message}`);
+      log.message(`(${styleText4("green", `+${stats.additions}`)} ${styleText4("red", `-${stats.deletions}`)}) ${pendingLabel}: ${message}`);
     }
     if (!canPrompt) return drafts;
     const action = await select({
@@ -2728,7 +2853,7 @@ async function reviewMessages(drafts, canPrompt) {
 }
 
 // src/cli.ts
-updateSettings({ withGuide: false });
+updateSettings({ withGuide: true });
 var main = defineCommand({
   meta: {
     name: "zapdev",

package/package.json

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