zapdev 1.9.0 → 1.10.0

package/README.md

@@ -124,7 +124,7 @@ zapdev commit
 | `--url <url>`       | Override the complete Chat Completions endpoint                   |
 | `--model <model>`   | Override the model                                                |
 | `--effort <effort>` | Override the reasoning effort                                     |
-| `-t, --type <type>` | Force the Conventional Commit type (`feat`, `fix`, `chore`, etc.) |
+| `-t, --type <type>` | Force an exact lowercase Conventional Commit type (`feat`, `fix`, `chore`, etc.) |
 | `-p, --push`        | Skip push confirmation; still ask for each destination branch      |
 | `-s, --staged`      | Commit only changes that are already staged                       |
 | `-y, --yes`         | Skip commit review; still confirm push unless `--push` is set     |
@@ -144,7 +144,7 @@ In a terminal, Git and its hooks display live logs and support native prompts, e
 
 Every push asks for a destination branch, even with `--yes --push`. In both modes, prompts start empty and then reuse the previous input across repositories in this run. Press Enter to accept the prefilled name; an empty or cleared input uses the current branch and leaves the next prompt empty. Pushing to `main` is allowed in both modes. Classic pushes 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/<input>` without changing local branches or their upstreams. The destination need not exist locally. When no remote can be selected unambiguously, the repository's push is skipped with a warning, without a branch prompt. Git rejections stop the command: no rebase, merge, retry, or force-push.
 
-Before each destination input, both modes check the presumed remote branch: the previous input, or the current branch when empty. If the remote branch is missing or local commits remain unpublished, zapdev asks for a destination; otherwise it skips the send. Classic mode compares HEAD; subtree mode compares its extracted history. This check cannot anticipate a different destination you would type next. Repositories without new changes do not trigger an LLM call or a new commit.
+Before each destination input, both modes check the presumed remote branch: the previous input, or the current branch when empty. If that branch is missing, the check falls back to the remote's default branch (`HEAD`). Only unpublished local commits trigger a destination input; if neither reference exists, zapdev also asks. Classic mode compares HEAD; subtree mode compares its extracted history. This check cannot anticipate a different destination you would type next. Repositories without new changes do not trigger an LLM call or a new commit.
 
 Without a TTY, zapdev commits all prepared repositories automatically but cannot push; `--push` reports an error and leaves commits local.
 

package/dist/cli.js

@@ -554,7 +554,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "1.9.0",
+  version: "1.10.0",
   description: "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   type: "module",
   bin: {
@@ -614,7 +614,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";
 
 // node_modules/@clack/core/dist/index.mjs
 import { styleText } from "node:util";
@@ -1780,40 +1780,6 @@ ${r3}
   }
 }).prompt();
 
-// src/types/commit.ts
-var COMMIT_TYPES = [
-  "feat",
-  "fix",
-  "chore",
-  "docs",
-  "style",
-  "refactor",
-  "perf",
-  "test",
-  "build",
-  "ci",
-  "revert"
-];
-
-// src/lib/commit-message.ts
-function normalizeCommitType(input) {
-  const normalized = input.trim().toLowerCase();
-  return COMMIT_TYPES.includes(normalized) ? normalized : null;
-}
-function applyCommitType(systemPrompt, type) {
-  return `${systemPrompt}
-
-The type MUST be exactly "${type}".`;
-}
-var MAX_DIFF_CHARS = 12e3;
-function truncateDiff(diff, max = MAX_DIFF_CHARS) {
-  return diff.length > max ? diff.slice(0, max) : diff;
-}
-function sanitizeCommitMessage(raw) {
-  const firstLine = raw.split("\n", 1)[0] ?? "";
-  return firstLine.replace(/[`"]/g, "").trim();
-}
-
 // src/lib/config.ts
 import { readFile } from "node:fs/promises";
 import { isAbsolute, join } from "node:path";
@@ -2267,16 +2233,17 @@ function createHookReporter(onHook, onTimeout, timeout) {
 }
 
 // src/lib/git.ts
-async function git(args, cwd, onHook) {
+async function git(args, cwd, onHook, onNativeOutput) {
   const timeout = resolveHookTimeout();
-  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && ["commit", "push", "subtree", "fetch"].includes(args[0] ?? "") && !(args[0] === "subtree" && args[1] === "split"));
+  const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && ["commit", "push", "subtree", "fetch", "ls-remote"].includes(args[0] ?? "") && !(args[0] === "subtree" && args[1] === "split"));
   const terminalState = interactive && process.platform !== "win32" ? execFileSync("stty", ["-g"], { stdio: ["inherit", "pipe", "ignore"], encoding: "utf8" }).trim() : void 0;
+  if (interactive) onNativeOutput?.("start");
   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"]
+      stdio: interactive ? ["inherit", args[0] === "ls-remote" ? "pipe" : "inherit", "inherit", "pipe"] : ["pipe", "pipe", "pipe", "pipe"]
     }
   });
   let timeoutError;
@@ -2313,7 +2280,11 @@ async function git(args, cwd, onHook) {
   } finally {
     reader?.close();
     close();
-    if (terminalState) execFileSync("stty", [terminalState], { stdio: ["inherit", "ignore", "ignore"] });
+    try {
+      if (terminalState) execFileSync("stty", [terminalState], { stdio: ["inherit", "ignore", "ignore"] });
+    } finally {
+      if (interactive) onNativeOutput?.("exit");
+    }
   }
 }
 function killProcessTree(pid) {
@@ -2346,8 +2317,8 @@ async function stageAll(repo) {
 async function getStagedDiff(repo) {
   return git(["diff", "--cached"], repo);
 }
-async function commit(repo, message, onHook) {
-  await git(["commit", "--quiet", "-m", message], repo, onHook);
+async function commit(repo, message, onHook, onNativeOutput) {
+  await git(["commit", "--quiet", "-m", message], repo, onHook, onNativeOutput);
 }
 async function currentBranch(repo) {
   return (await git(["symbolic-ref", "--short", "HEAD"], repo)).trim();
@@ -2366,23 +2337,21 @@ 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) {
+async function push(repo, remote, branch, onHook, prefix, onNativeOutput) {
   await git(["check-ref-format", "--branch", branch], repo);
-  await git(["push", "--", remote, `HEAD:refs/heads/${branch}`], repo, onHook);
+  await git(prefix ? ["subtree", "push", `--prefix=${prefix}`, remote, branch] : ["push", "--", remote, `HEAD:refs/heads/${branch}`], repo, onHook, onNativeOutput);
 }
-async function hasUnpushedCommits(repo, remote, branch, onHook, prefix) {
+async function hasUnpushedCommits(repo, remote, branch, onHook, prefix, onNativeOutput) {
   if (await tryGit(["rev-parse", "--verify", "HEAD"], repo) === null) return false;
   await git(["check-ref-format", "--branch", branch], repo);
   const source = prefix ? (await git(["subtree", "split", `--prefix=${prefix}`, "--quiet", "HEAD"], repo)).trim() : "HEAD";
   const ref = `refs/heads/${branch}`;
-  if (!(await git(["ls-remote", "--heads", "--", remote, ref], repo)).trim()) return true;
-  await git(["fetch", "--quiet", "--", remote, ref], repo, onHook);
+  const refs = new Set((await git(["ls-remote", "--", remote, ref, "HEAD"], repo, onHook, onNativeOutput)).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, onNativeOutput);
   return Boolean((await git(["rev-list", "--max-count=1", `FETCH_HEAD..${source}`], repo)).trim());
 }
-async function publishSubtree(repo, prefix, remote, branch, onHook) {
-  await git(["check-ref-format", "--branch", branch], repo);
-  await git(["subtree", "push", `--prefix=${prefix}`, remote, branch], repo, onHook);
-}
 async function findRepos(path) {
   const root = await repoRoot(path);
   if (root) return [root];
@@ -2424,6 +2393,21 @@ var commit_message_default = "You are zapdev, a CLI tool that creates commits qu
 // src/prompts/index.ts
 var COMMIT_SYSTEM_PROMPT = commit_message_default.trim();
 
+// src/lib/commit-message.ts
+function applyCommitType(systemPrompt, type) {
+  return `${systemPrompt}
+
+The type MUST be exactly "${type}".`;
+}
+var MAX_DIFF_CHARS = 12e3;
+function truncateDiff(diff, max = MAX_DIFF_CHARS) {
+  return diff.length > max ? diff.slice(0, max) : diff;
+}
+function sanitizeCommitMessage(raw) {
+  const firstLine = raw.split("\n", 1)[0] ?? "";
+  return firstLine.replace(/[`"]/g, "").trim();
+}
+
 // src/lib/llm.ts
 var REQUEST_TIMEOUT_MS = 25e3;
 async function generateCommitMessage(diff, config, type) {
@@ -2463,17 +2447,11 @@ async function generateCommitMessage(diff, config, type) {
   return sanitizeCommitMessage(content);
 }
 function describeRequestError(error) {
-  if (errorName(error) === "TimeoutError") {
+  if (error instanceof Error && error.name === "TimeoutError") {
     return `LLM did not answer within ${REQUEST_TIMEOUT_MS / 1e3}s.`;
   }
   return "Could not complete the LLM request. Check URL and endpoint availability.";
 }
-function errorName(error) {
-  if (error && typeof error === "object" && "name" in error && typeof error.name === "string") {
-    return error.name;
-  }
-  return null;
-}
 function serverError(body) {
   if (!body || typeof body !== "object" || !("error" in body)) return null;
   const error = body.error;
@@ -2491,6 +2469,28 @@ function messageContent(body) {
   return typeof message.content === "string" ? message.content : null;
 }
 
+// src/types/commit.ts
+var COMMIT_TYPES = [
+  "feat",
+  "fix",
+  "chore",
+  "docs",
+  "style",
+  "refactor",
+  "perf",
+  "test",
+  "build",
+  "ci",
+  "revert"
+];
+
+// src/commands/native-output.ts
+import { styleText as styleText3 } from "node:util";
+var reportNativeOutput = (phase) => {
+  const symbol2 = styleText3("gray", phase === "start" ? S_BAR_END : S_BAR_START);
+  log.message(phase === "start" ? symbol2 : ["", symbol2], { withGuide: false, spacing: 0 });
+};
+
 // src/commands/commit.ts
 var commitCommand = defineCommand({
   meta: {
@@ -2511,7 +2511,9 @@ var commitCommand = defineCommand({
       description: "Override $ZD_EFFORT, sent as reasoning_effort."
     },
     type: {
-      type: "string",
+      type: "enum",
+      options: [...COMMIT_TYPES],
+      required: false,
       alias: "t",
       description: `Force the Conventional Commits type (${COMMIT_TYPES.join(", ")}).`
     },
@@ -2533,14 +2535,6 @@ var commitCommand = defineCommand({
   },
   async run({ args }) {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-    const type = args.type ? normalizeCommitType(args.type) : void 0;
-    if (type === null) {
-      log.error(
-        `Invalid type "${args.type}". Valid types: ${COMMIT_TYPES.join(", ")}.`
-      );
-      process.exitCode = 1;
-      return;
-    }
     let config;
     let subtrees;
     try {
@@ -2580,12 +2574,12 @@ var commitCommand = defineCommand({
       const { repo } = repository;
       const { branch, hasChanges } = await getRepoStatus(repo);
       repository.label = `${basename(repo)} (${branch})`;
-      repository.pendingLabel = hasChanges ? styleText3(["bold", "underline"], repository.label) : repository.label;
+      repository.pendingLabel = hasChanges ? styleText4(["bold", "underline"], repository.label) : repository.label;
       if (!args.staged) await stageAll(repo);
       const diff = await getStagedDiff(repo);
       if (!diff.trim()) return null;
       if (scan) await scanStagedChanges(repo);
-      const message = await generateCommitMessage(diff, config, type);
+      const message = await generateCommitMessage(diff, config, args.type);
       if (!message) throw new Error("The model returned an empty message.");
       return { ...repository, message };
     }));
@@ -2608,19 +2602,19 @@ var commitCommand = defineCommand({
       cancel("Cancelled (changes left staged).");
       return;
     }
-    const committed = [];
+    const toSend = [];
     for (const draft of selected) {
       log.info(`${draft.label}: committing`);
       try {
-        await commit(draft.repo, draft.message, reportHooks(draft.label));
-        committed.push(draft);
+        await commit(draft.repo, draft.message, reportHooks(draft.label), reportNativeOutput);
+        toSend.push(draft);
         log.success(`${draft.label}: committed ${draft.message}`);
       } catch (error) {
         reportGitFailure(`${draft.pendingLabel}: commit failed`, error);
         process.exitCode = 1;
       }
     }
-    const toSend = [...committed, ...unchanged];
+    toSend.push(...unchanged);
     if (toSend.length === 0) return;
     let shouldPush = Boolean(args.push);
     if (!shouldPush && interactive) {
@@ -2641,8 +2635,7 @@ var commitCommand = defineCommand({
         return;
       }
       let previousBranchInput = "";
-      for (const repository of toSend) {
-        const { repo, label } = repository;
+      for (const { repo, label } of toSend) {
         try {
           const current = await currentBranch(repo);
           const destinations = publishSubtreeMode ? Object.entries(subtrees) : [["", await getPushRemote(repo, current)]];
@@ -2651,7 +2644,8 @@ var commitCommand = defineCommand({
               log.warn(`${label}: no remote or ambiguous remote choice. Skipping push; commit remains local.`);
               continue;
             }
-            if (!await hasUnpushedCommits(repo, remote, previousBranchInput || current, reportHooks(label), prefix || void 0)) {
+            log.info(`${label}: checking unpublished commits${prefix ? ` in ${prefix}` : ""} (${remote}/${previousBranchInput || current}).`);
+            if (!await hasUnpushedCommits(repo, remote, previousBranchInput || current, reportHooks(label), prefix || void 0, reportNativeOutput)) {
               log.info(`${label}: no unpushed commits${prefix ? ` in ${prefix}` : ""}. Skipping.`);
               continue;
             }
@@ -2666,8 +2660,7 @@ var commitCommand = defineCommand({
             previousBranchInput = answer.trim();
             const branch = previousBranchInput || current;
             log.info(`${label}: pushing ${publishSubtreeMode ? `${prefix} \u2192 ` : ""}${remote}/${branch}`);
-            if (publishSubtreeMode) await publishSubtree(repo, prefix, remote, branch, reportHooks(label));
-            else await push(repo, remote, branch, reportHooks(label));
+            await push(repo, remote, branch, reportHooks(label), prefix || void 0, reportNativeOutput);
             log.success(`${label}: pushed to ${remote}/${branch}`);
           }
         } catch (error) {
@@ -2686,11 +2679,11 @@ function reportGitFailure(message, error) {
   log.error(error instanceof GitOutputError ? message : `${message}: ${errorMessage(error)}`);
 }
 function reportHooks(label) {
-  const options = { secondarySymbol: "" };
+  const options = { secondarySymbol: "", withGuide: false };
   return (event) => {
     const hook = `${label}: ${event.name}`;
     if (event.phase === "start") {
-      log.step(styleText3("bold", hook), options);
+      log.step(styleText4("bold", hook), options);
     } else {
       if (event.exitCode === 0) log.success(`${hook}: completed`, options);
       else log.error(`${hook}: failed (exit ${event.exitCode})`, options);
@@ -2784,7 +2777,7 @@ async function initializeSubtrees(directory, sources, options = {}) {
   const imports = [];
   for (const source of sources) {
     options.onProgress?.(`Detecting default branch for ${source.name}`);
-    const refs = await git(["ls-remote", "--symref", "--", source.url, "HEAD"], repo);
+    const refs = await git(["ls-remote", "--symref", "--", source.url, "HEAD"], repo, void 0, options.onNativeOutput);
     const branch = /^ref: refs\/heads\/(.+)\tHEAD$/m.exec(refs)?.[1];
     if (!branch) options.onWarning?.(`Could not detect default branch for ${source.name}; using main.`);
     imports.push({ ...source, branch: branch ?? "main" });
@@ -2795,12 +2788,12 @@ async function initializeSubtrees(directory, sources, options = {}) {
 `);
   await git(["add", "--", "zapdev.json"], repo);
   if (initial || (await getStagedDiff(repo)).trim()) {
-    await commit(repo, initial ? "chore: init" : "chore: configure subtrees");
+    await commit(repo, initial ? "chore: init" : "chore: configure subtrees", void 0, options.onNativeOutput);
   }
   for (const [name, url] of missingRemotes) await git(["remote", "add", name, url], repo);
   for (const { name, branch } of imports) {
     options.onProgress?.(`Adding ${name} (${branch})`);
-    await git(["subtree", "add", `--prefix=${name}`, name, branch, "--squash"], repo);
+    await git(["subtree", "add", `--prefix=${name}`, name, branch, "--squash"], repo, void 0, options.onNativeOutput);
   }
 }
 async function exists(path) {
@@ -2826,7 +2819,8 @@ var subtreeInitCommand = defineCommand({
       await initializeSubtrees(args.directory, sources, {
         origin: args.origin,
         onProgress: log.info,
-        onWarning: log.warn
+        onWarning: log.warn,
+        onNativeOutput: reportNativeOutput
       });
       if (interactive) outro("Subtrees ready.");
       else log.info("Subtrees ready.");

package/package.json

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