zapdev 1.4.0 → 1.6.0

package/README.md

@@ -37,13 +37,14 @@ flowchart LR
 
 ## Environment Variables
 
-| Variable    | Required     | Description                                                                                         |
-| ----------- | ------------ | --------------------------------------------------------------------------------------------------- |
-| `ZD_URL`    | For `commit` | Complete HTTP(S) Chat Completions endpoint, including its path                                      |
-| `ZD_MODEL`  | For `commit` | Model identifier supported by the endpoint                                                          |
-| `ZD_EFFORT` | For `commit` | Sent as `reasoning_effort`; use a value supported by your model, such as `low`, `medium`, or `high` |
+| Variable          | Required     | Description                                                                                         |
+| ----------------- | ------------ | --------------------------------------------------------------------------------------------------- |
+| `ZD_URL`          | For `commit` | Complete HTTP(S) Chat Completions endpoint, including its path                                      |
+| `ZD_MODEL`        | For `commit` | Model identifier supported by the endpoint                                                          |
+| `ZD_EFFORT`       | For `commit` | Sent as `reasoning_effort`; use a value supported by your model, such as `low`, `medium`, or `high` |
+| `ZD_HOOK_TIMEOUT` | No           | Deadline per Git hook in seconds (default: `60`); positive numbers from `0.001` to `2147483.647` |
 
-There are no defaults, automatic provider detection, or backup models. CLI flags override these variables. Legacy `OLLAMA_*` variables are no longer read.
+The LLM settings have no defaults, automatic provider detection, or backup models. CLI flags override these settings. Legacy `OLLAMA_*` variables are no longer read.
 
 Requests use the OpenAI Chat Completions format over plain `fetch`, without a provider SDK. No authentication headers are sent; use an endpoint that does not require them. The endpoint and model must support `reasoning_effort`.
 
@@ -139,6 +140,8 @@ Before contacting the LLM endpoint, zapdev runs `gitleaks git --staged --verbose
 
 Failures are reported per repository while the others continue. Any failure produces a nonzero exit code.
 
+In a terminal, Git and its hooks display live logs and support native prompts, even with `--yes` (which only skips zapdev 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`.
+
 Pushing is optimistic, with no preliminary fetch. If the branch is behind upstream, `--rebase` runs `git pull --rebase`, while `--merge` runs `git pull --no-rebase --no-edit`; zapdev then retries once. Without either flag, interactive runs ask whether to rebase, merge, or quit. Runs using `--yes` or without a TTY must provide one of the flags.
 
 Without a TTY, zapdev commits all prepared repositories automatically and only pushes when `--push` is set.

package/dist/cli.js

@@ -554,7 +554,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "1.4.0",
+  version: "1.6.0",
   description: "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   type: "module",
   bin: {
@@ -1815,6 +1815,13 @@ function sanitizeCommitMessage(raw) {
 }
 
 // src/lib/config.ts
+function resolveHookTimeout(env = process.env) {
+  const timeout = Number(env.ZD_HOOK_TIMEOUT ?? 60) * 1e3;
+  if (!Number.isFinite(timeout) || timeout < 1 || timeout > 2147483647) {
+    throw new Error("ZD_HOOK_TIMEOUT must be a number of seconds between 0.001 and 2147483.647.");
+  }
+  return timeout;
+}
 function resolveConfig(env = process.env, overrides = {}) {
   const config = {
     url: (overrides.url ?? env.ZD_URL)?.trim() ?? "",
@@ -1837,6 +1844,7 @@ function resolveConfig(env = process.env, overrides = {}) {
 }
 
 // src/lib/git.ts
+import { execFileSync } from "node:child_process";
 import { readdir } from "node:fs/promises";
 import { join } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
@@ -2168,10 +2176,22 @@ var R2 = (e2, t3, n4) => {
 };
 var z = R2;
 
+// src/lib/errors.ts
+var GitOutputError = class extends Error {
+  constructor(message, hookFailureReported = false) {
+    super(message);
+    this.hookFailureReported = hookFailureReported;
+  }
+  hookFailureReported;
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
 // src/lib/git-hooks.ts
-function createHookReporter(onHook) {
+function createHookReporter(onHook, onTimeout, timeout) {
   const hooks = /* @__PURE__ */ new Map();
-  return (line) => {
+  const report = (line) => {
     let event;
     try {
       const value = JSON.parse(line);
@@ -2183,13 +2203,22 @@ function createHookReporter(onHook) {
     if (typeof event.sid !== "string" || typeof event.child_id !== "number") return;
     const key = `${event.sid}:${event.child_id}`;
     if (event.event === "child_start" && event.child_class === "hook" && typeof event.hook_name === "string") {
-      hooks.set(key, event.hook_name);
-      onHook({ name: event.hook_name, phase: "start" });
+      const name = event.hook_name;
+      hooks.set(key, { name, timer: setTimeout(() => onTimeout(name), timeout) });
+      onHook?.({ name, phase: "start" });
     } else if (event.event === "child_exit" && typeof event.code === "number") {
-      const name = hooks.get(key);
-      if (name === void 0) return;
+      const hook = hooks.get(key);
+      if (!hook) return;
+      clearTimeout(hook.timer);
       hooks.delete(key);
-      onHook({ name, phase: "exit", exitCode: event.code });
+      onHook?.({ name: hook.name, phase: "exit", exitCode: event.code });
+    }
+  };
+  return {
+    report,
+    close() {
+      for (const { timer } of hooks.values()) clearTimeout(timer);
+      hooks.clear();
     }
   };
 }
@@ -2197,18 +2226,73 @@ function createHookReporter(onHook) {
 // src/lib/git.ts
 var UPSTREAM_REF = "@{upstream}";
 async function git(args, cwd, onHook) {
+  const timeout = resolveHookTimeout();
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && ["commit", "push", "pull", "fetch"].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: onHook ? { cwd, env: { ...process.env, GIT_TRACE2_EVENT: "3" }, stdio: ["pipe", "pipe", "pipe", "pipe"] } : { cwd }
+    nodeOptions: {
+      cwd,
+      detached: !interactive && process.platform !== "win32",
+      env: { ...process.env, GIT_TRACE2_EVENT: "3" },
+      stdio: interactive ? ["inherit", "inherit", "inherit", "pipe"] : ["pipe", "pipe", "pipe", "pipe"]
+    }
   });
+  let timeoutError;
+  let hookFailureReported = false;
+  const { report, close } = createHookReporter((event) => {
+    if (onHook && event.phase === "exit" && event.exitCode !== 0) hookFailureReported = true;
+    onHook?.(event);
+  }, (name) => {
+    if (timeoutError || child.pid === void 0) return;
+    timeoutError = new Error(`${name} hook timed out after ${timeout / 1e3} seconds`);
+    try {
+      if (process.platform === "win32") {
+        execFileSync("taskkill", ["/pid", String(child.pid), "/T", "/F"], { stdio: "ignore" });
+      } else if (interactive) {
+        killProcessTree(child.pid);
+      } else {
+        process.kill(-child.pid, "SIGKILL");
+      }
+    } catch {
+      child.kill("SIGKILL");
+    }
+  }, timeout);
   const trace = child.process?.stdio[3];
-  if (onHook && trace instanceof Readable) {
-    createInterface2({ input: trace }).on("line", createHookReporter(onHook));
-  }
-  const result = await child;
-  if (result.exitCode !== 0) {
-    throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+  const reader = trace instanceof Readable ? createInterface2({ input: trace }).on("line", report) : void 0;
+  try {
+    const result = await child;
+    if (timeoutError) throw timeoutError;
+    if (result.exitCode !== 0) {
+      const message = result.stderr.trim() || `git ${args.join(" ")} failed`;
+      if (interactive) throw new GitOutputError(message, hookFailureReported);
+      throw new Error(message);
+    }
+    return result.stdout;
+  } finally {
+    reader?.close();
+    close();
+    if (terminalState) execFileSync("stty", [terminalState], { stdio: ["inherit", "ignore", "ignore"] });
+  }
+}
+function killProcessTree(pid) {
+  const children = /* @__PURE__ */ new Map();
+  const output = execFileSync("ps", ["-A", "-o", "pid=,ppid="], { encoding: "utf8" });
+  for (const line of output.trim().split("\n")) {
+    const [child, parent] = line.trim().split(/\s+/).map(Number);
+    if (child === void 0 || parent === void 0) continue;
+    const siblings = children.get(parent) ?? [];
+    siblings.push(child);
+    children.set(parent, siblings);
+  }
+  const pids = [pid];
+  for (const parent of pids) pids.push(...children.get(parent) ?? []);
+  for (const child of pids.reverse()) {
+    try {
+      process.kill(child, "SIGKILL");
+    } catch (error) {
+      if (error.code !== "ESRCH") throw error;
+    }
   }
-  return result.stdout;
 }
 async function tryGit(args, cwd) {
   const result = await R2("git", args, { nodeOptions: { cwd } });
@@ -2221,7 +2305,7 @@ async function getStagedDiff(repo) {
   return git(["diff", "--cached"], repo);
 }
 async function commit(repo, message, onHook) {
-  await git(["commit", "-m", message], repo, onHook);
+  await git(["commit", "--quiet", "-m", message], repo, onHook);
 }
 async function currentBranch(repo) {
   return (await git(["symbolic-ref", "--short", "HEAD"], repo)).trim();
@@ -2239,19 +2323,19 @@ async function hasUpstream(repo) {
   return result !== null;
 }
 async function push(repo, onHook) {
-  await git(["push"], repo, onHook);
+  await git(["push", "--quiet"], repo, onHook);
 }
 async function pushSetUpstream(repo, branch, onHook) {
-  await git(["push", "-u", "origin", branch], repo, onHook);
+  await git(["push", "--quiet", "-u", "origin", branch], repo, onHook);
 }
 async function pullRebase(repo, onHook) {
-  await git(["pull", "--rebase"], repo, onHook);
+  await git(["pull", "--quiet", "--rebase"], repo, onHook);
 }
 async function pullMerge(repo, onHook) {
-  await git(["pull", "--no-rebase", "--no-edit"], repo, onHook);
+  await git(["pull", "--quiet", "--no-rebase", "--no-edit"], repo, onHook);
 }
 async function fetchRemote(repo, onHook) {
-  await git(["fetch"], repo, onHook);
+  await git(["fetch", "--quiet"], repo, onHook);
 }
 async function behindCount(repo) {
   const out = await tryGit(["rev-list", "--count", `HEAD..${UPSTREAM_REF}`], repo);
@@ -2270,11 +2354,6 @@ async function repoRoot(dir) {
   return (await tryGit(["rev-parse", "--show-toplevel"], dir))?.trim() ?? null;
 }
 
-// src/lib/errors.ts
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
 // src/lib/gitleaks.ts
 async function hasGitleaks() {
   try {
@@ -2438,6 +2517,7 @@ var commitCommand = defineCommand({
     }
     let config;
     try {
+      resolveHookTimeout();
       config = resolveConfig(process.env, {
         url: args.url,
         model: args.model,
@@ -2503,17 +2583,13 @@ var commitCommand = defineCommand({
     }
     const committed = [];
     for (const draft of selected) {
-      const loader2 = interactive ? spinner() : void 0;
-      const message = `${draft.label}: committing`;
-      loader2?.start(message);
+      log.info(`${draft.label}: committing`);
       try {
-        await commit(draft.repo, draft.message, reportHooks(draft.label, loader2, message));
-        loader2?.clear();
+        await commit(draft.repo, draft.message, reportHooks(draft.label));
         committed.push(draft);
         log.success(`${draft.label}: committed ${draft.message}`);
       } catch (error) {
-        loader2?.clear();
-        log.error(`${draft.pendingLabel}: commit failed: ${errorMessage(error)}`);
+        reportGitFailure(`${draft.pendingLabel}: commit failed`, error);
         process.exitCode = 1;
       }
     }
@@ -2535,13 +2611,12 @@ var commitCommand = defineCommand({
         try {
           const pushed = await pushOptimistic(
             repository,
-            interactive,
             interactive && !args.yes,
             syncStrategy
           );
           if (!pushed) process.exitCode = 1;
         } catch (error) {
-          log.error(`${repository.label}: push failed: ${errorMessage(error)}`);
+          reportGitFailure(`${repository.label}: push failed`, error);
           process.exitCode = 1;
         }
       }
@@ -2549,17 +2624,19 @@ var commitCommand = defineCommand({
     if (interactive) outro(process.exitCode ? "Finished with errors." : "Done.");
   }
 });
-function reportHooks(label, loader, message) {
+function reportGitFailure(message, error, level = "error") {
+  if (error instanceof GitOutputError && error.hookFailureReported) return;
+  log[level](error instanceof GitOutputError ? message : `${message}: ${errorMessage(error)}`);
+}
+function reportHooks(label) {
+  const options = { secondarySymbol: "" };
   return (event) => {
     const hook = `${label}: ${event.name}`;
     if (event.phase === "start") {
-      if (loader) loader.message(`${hook} running\u2026`);
-      else log.info(`${hook} running\u2026`);
+      log.step(styleText3("bold", hook), options);
     } else {
-      loader?.clear();
-      if (event.exitCode === 0) log.success(`${hook} \u2713`);
-      else log.error(`${hook} \u2717 (exit ${event.exitCode})`);
-      loader?.start(message);
+      if (event.exitCode === 0) log.success(`${hook}: completed`, options);
+      else log.error(`${hook}: failed (exit ${event.exitCode})`, options);
     }
   };
 }
@@ -2595,36 +2672,33 @@ async function reviewMessages(drafts, canPrompt) {
     action.draft.message = edited.trim();
   }
 }
-async function syncWithUpstream({ repo, label }, strategy, interactive) {
-  const loader = interactive ? spinner() : void 0;
+async function syncWithUpstream({ repo, label }, strategy) {
   const actionLabel = strategy === "rebase" ? "Rebase" : "Merge";
-  const message = `${label}: pulling --${strategy === "rebase" ? "rebase" : "no-rebase"}`;
-  loader?.start(message);
+  log.info(`${label}: pulling --${strategy === "rebase" ? "rebase" : "no-rebase"}`);
   try {
-    await (strategy === "rebase" ? pullRebase : pullMerge)(repo, reportHooks(label, loader, message));
-    loader?.stop(strategy === "rebase" ? "\u2713 Rebased on upstream" : "\u2713 Merged upstream");
+    await (strategy === "rebase" ? pullRebase : pullMerge)(repo, reportHooks(label));
+    log.success(`${label}: ${strategy === "rebase" ? "rebased on upstream" : "merged upstream"}`);
     return true;
   } catch (error) {
-    loader?.error(`${actionLabel} failed`);
-    log.error(`${label}: ${actionLabel} failed (resolve conflicts, then push): ${errorMessage(error)}`);
+    reportGitFailure(`${label}: ${actionLabel} failed (resolve conflicts, then push)`, error);
     return false;
   }
 }
-async function pushOptimistic(repository, interactive, canPrompt, strategy) {
+async function pushOptimistic(repository, canPrompt, strategy) {
   const { repo, label } = repository;
   const [upstream, branch] = await Promise.all([hasUpstream(repo), currentBranch(repo)]);
   const doPush = (onHook) => upstream ? push(repo, onHook) : pushSetUpstream(repo, branch, onHook);
-  const first = await tryPush(repository, interactive, doPush);
+  const first = await tryPush(repository, doPush);
   if (first.ok) return true;
-  if (upstream && await isBehind(repository, interactive)) {
+  if (upstream && await isBehind(repository)) {
     const syncStrategy = strategy ?? await chooseSyncStrategy(repository, canPrompt);
-    if (!syncStrategy || !await syncWithUpstream(repository, syncStrategy, interactive)) return false;
-    const retry = await tryPush(repository, interactive, doPush);
+    if (!syncStrategy || !await syncWithUpstream(repository, syncStrategy)) return false;
+    const retry = await tryPush(repository, doPush);
     if (retry.ok) return true;
-    log.error(`${label}: push failed: ${errorMessage(retry.error)}`);
+    reportGitFailure(`${label}: push failed`, retry.error);
     return false;
   }
-  log.error(`${label}: push failed: ${errorMessage(first.error)}`);
+  reportGitFailure(`${label}: push failed`, first.error);
   return false;
 }
 async function chooseSyncStrategy({ label }, interactive) {
@@ -2646,33 +2720,25 @@ async function chooseSyncStrategy({ label }, interactive) {
   }
   return action;
 }
-async function tryPush({ label }, interactive, doPush) {
-  const loader = interactive ? spinner() : void 0;
-  const message = `${label}: pushing`;
-  loader?.start(message);
+async function tryPush({ label }, doPush) {
+  log.info(`${label}: pushing`);
   try {
-    await doPush(reportHooks(label, loader, message));
-    loader?.stop("\u2713 Pushed");
+    await doPush(reportHooks(label));
+    log.success(`${label}: pushed`);
     return { ok: true };
   } catch (error) {
-    loader?.error("Push failed");
     return { ok: false, error };
   }
 }
-async function isBehind({ repo, label }, interactive) {
-  const loader = interactive ? spinner() : void 0;
-  const message = `${label}: checking upstream`;
-  loader?.start(message);
+async function isBehind({ repo, label }) {
+  log.info(`${label}: checking upstream`);
   try {
-    await fetchRemote(repo, reportHooks(label, loader, message));
+    await fetchRemote(repo, reportHooks(label));
     const behind = await behindCount(repo);
-    loader?.stop(
-      behind > 0 ? `Behind upstream by ${behind} commit${behind > 1 ? "s" : ""}` : "Up to date with upstream"
-    );
+    log.info(`${label}: ${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(`${label}: could not check upstream: ${errorMessage(error)}`);
+    reportGitFailure(`${label}: could not check upstream`, error, "warn");
     return false;
   }
 }

package/package.json

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