zapdev 1.3.0 → 1.5.0

package/README.md

@@ -1,3 +1,12 @@
+<p align="center">
+  <img src="https://raw.githubusercontent.com/mvagnon/zapdev/main/.github/assets/preview.gif" alt="zapdev CLI demonstration">
+</p>
+
+---
+
+[![portfolio](https://img.shields.io/website?url=https%3A%2F%2Fmvagnon.dev&up_message=Visit&label=Portfolio&color=%23007fff)](https://mvagnon.dev)
+[![bymeacoffee](https://img.shields.io/badge/Buy%20me%20a%20coffee-Support-yellow?logo=buymeacoffee)](https://buymeacoffee.com/mvagnon)
+
 # zapdev
 
 ## Project Introduction
@@ -28,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`.
 
@@ -55,6 +65,12 @@ Install zapdev globally for daily use:
 npm install -g zapdev
 ```
 
+or
+
+```bash
+bun install -g zapdev
+```
+
 Configure your endpoint and model before running `commit` (replace these example values):
 
 ```bash
@@ -106,8 +122,8 @@ zapdev commit
 | Flag                | Description                                                       |
 | ------------------- | ----------------------------------------------------------------- |
 | `--url <url>`       | Override the complete Chat Completions endpoint                   |
-| `--model <model>`   | Override the model                                               |
-| `--effort <effort>` | Override the reasoning effort                                    |
+| `--model <model>`   | Override the model                                                |
+| `--effort <effort>` | Override the reasoning effort                                     |
 | `-t, --type <type>` | Force the Conventional Commit type (`feat`, `fix`, `chore`, etc.) |
 | `-p, --push`        | Push after committing without asking                              |
 | `-s, --staged`      | Commit only changes that are already staged                       |
@@ -124,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.3.0",
+  version: "1.5.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,8 +1844,11 @@ 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";
+import { Readable } from "node:stream";
 
 // node_modules/tinyexec/dist/main.mjs
 import { spawn as e, spawnSync as t2 } from "node:child_process";
@@ -2166,14 +2176,105 @@ var R2 = (e2, t3, n4) => {
 };
 var z = R2;
 
+// src/lib/git-hooks.ts
+function createHookReporter(onHook, onTimeout, timeout) {
+  const hooks = /* @__PURE__ */ new Map();
+  const report = (line) => {
+    let event;
+    try {
+      const value = JSON.parse(line);
+      if (!value || typeof value !== "object" || Array.isArray(value)) return;
+      event = value;
+    } catch {
+      return;
+    }
+    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") {
+      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 hook = hooks.get(key);
+      if (!hook) return;
+      clearTimeout(hook.timer);
+      hooks.delete(key);
+      onHook?.({ name: hook.name, phase: "exit", exitCode: event.code });
+    }
+  };
+  return {
+    report,
+    close() {
+      for (const { timer } of hooks.values()) clearTimeout(timer);
+      hooks.clear();
+    }
+  };
+}
+
 // src/lib/git.ts
 var UPSTREAM_REF = "@{upstream}";
-async function git(args, cwd) {
-  const result = await R2("git", args, { nodeOptions: { cwd } });
-  if (result.exitCode !== 0) {
-    throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+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: {
+      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;
+  const { report, close } = createHookReporter(onHook, (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];
+  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) {
+      throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+    }
+    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 } });
@@ -2185,8 +2286,8 @@ async function stageAll(repo) {
 async function getStagedDiff(repo) {
   return git(["diff", "--cached"], repo);
 }
-async function commit(repo, message) {
-  await git(["commit", "-m", message], repo);
+async function commit(repo, message, onHook) {
+  await git(["commit", "-m", message], repo, onHook);
 }
 async function currentBranch(repo) {
   return (await git(["symbolic-ref", "--short", "HEAD"], repo)).trim();
@@ -2203,20 +2304,20 @@ async function hasUpstream(repo) {
   const result = await tryGit(["rev-parse", "--abbrev-ref", "--symbolic-full-name", UPSTREAM_REF], repo);
   return result !== null;
 }
-async function push(repo) {
-  await git(["push"], repo);
+async function push(repo, onHook) {
+  await git(["push"], repo, onHook);
 }
-async function pushSetUpstream(repo, branch) {
-  await git(["push", "-u", "origin", branch], repo);
+async function pushSetUpstream(repo, branch, onHook) {
+  await git(["push", "-u", "origin", branch], repo, onHook);
 }
-async function pullRebase(repo) {
-  await git(["pull", "--rebase"], repo);
+async function pullRebase(repo, onHook) {
+  await git(["pull", "--rebase"], repo, onHook);
 }
-async function pullMerge(repo) {
-  await git(["pull", "--no-rebase", "--no-edit"], repo);
+async function pullMerge(repo, onHook) {
+  await git(["pull", "--no-rebase", "--no-edit"], repo, onHook);
 }
-async function fetchRemote(repo) {
-  await git(["fetch"], repo);
+async function fetchRemote(repo, onHook) {
+  await git(["fetch"], repo, onHook);
 }
 async function behindCount(repo) {
   const out = await tryGit(["rev-list", "--count", `HEAD..${UPSTREAM_REF}`], repo);
@@ -2403,6 +2504,7 @@ var commitCommand = defineCommand({
     }
     let config;
     try {
+      resolveHookTimeout();
       config = resolveConfig(process.env, {
         url: args.url,
         model: args.model,
@@ -2468,8 +2570,9 @@ var commitCommand = defineCommand({
     }
     const committed = [];
     for (const draft of selected) {
+      log.info(`${draft.label}: committing`);
       try {
-        await commit(draft.repo, draft.message);
+        await commit(draft.repo, draft.message, reportHooks(draft.label));
         committed.push(draft);
         log.success(`${draft.label}: committed ${draft.message}`);
       } catch (error) {
@@ -2495,7 +2598,6 @@ var commitCommand = defineCommand({
         try {
           const pushed = await pushOptimistic(
             repository,
-            interactive,
             interactive && !args.yes,
             syncStrategy
           );
@@ -2509,6 +2611,17 @@ var commitCommand = defineCommand({
     if (interactive) outro(process.exitCode ? "Finished with errors." : "Done.");
   }
 });
+function reportHooks(label) {
+  return (event) => {
+    const hook = `${label}: ${event.name}`;
+    if (event.phase === "start") {
+      log.info(`${hook} running`);
+    } else {
+      if (event.exitCode === 0) log.success(`${hook} \u2713`);
+      else log.error(`${hook} \u2717 (exit ${event.exitCode})`);
+    }
+  };
+}
 async function reviewMessages(drafts, canPrompt) {
   while (true) {
     for (const draft of drafts) log.message(`${draft.pendingLabel}: ${draft.message}`);
@@ -2541,30 +2654,28 @@ 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";
-  loader?.start(`${label}: pulling --${strategy === "rebase" ? "rebase" : "no-rebase"}`);
+  log.info(`${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");
+    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)}`);
     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 = () => upstream ? push(repo) : pushSetUpstream(repo, branch);
-  const first = await tryPush(repository, interactive, doPush);
+  const doPush = (onHook) => upstream ? push(repo, onHook) : pushSetUpstream(repo, branch, onHook);
+  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)}`);
     return false;
@@ -2591,30 +2702,24 @@ async function chooseSyncStrategy({ label }, interactive) {
   }
   return action;
 }
-async function tryPush({ label }, interactive, doPush) {
-  const loader = interactive ? spinner() : void 0;
-  loader?.start(`${label}: pushing`);
+async function tryPush({ label }, doPush) {
+  log.info(`${label}: pushing`);
   try {
-    await doPush();
-    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;
-  loader?.start(`${label}: checking upstream`);
+async function isBehind({ repo, label }) {
+  log.info(`${label}: checking upstream`);
   try {
-    await fetchRemote(repo);
+    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)}`);
     return false;
   }

package/package.json

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