zapdev 1.9.0 → 1.11.0

package/README.md

@@ -113,7 +113,7 @@ Stages all changes, scans them with Gitleaks when installed, generates Conventio
 - **Unified review:** generates messages in parallel, then presents every message with its repository name and branch. Repositories with pending changes are shown in bold and underlined when terminal styling is enabled.
 - **Actions:** commit all, commit only a named repository, edit a named repository's message, or cancel. Editing returns to the review menu.
 
-Repositories with no new changes can still send existing commits. Unselected or cancelled changes remain staged; failed or unselected commit drafts are not pushed. Push confirmation is asked once, followed by a destination input for each eligible repository or subtree.
+Repositories with no new changes can still send existing commits. Unselected or cancelled changes remain staged; failed or unselected commit drafts are not pushed. The branch is chosen before committing, never when pushing. Push confirmation is asked once.
 
 ```bash
 zapdev commit
@@ -124,8 +124,8 @@ 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.) |
-| `-p, --push`        | Skip push confirmation; still ask for each destination branch      |
+| `-t, --type <type>` | Force an exact lowercase Conventional Commit type (`feat`, `fix`, `chore`, etc.) |
+| `-p, --push`        | Skip push confirmation and push the current branch                |
 | `-s, --staged`      | Commit only changes that are already staged                       |
 | `-y, --yes`         | Skip commit review; still confirm push unless `--push` is set     |
 
@@ -133,7 +133,7 @@ zapdev commit
 zapdev commit -t feat      # force the type
 zapdev commit --staged     # leave unstaged changes untouched
 zapdev commit -y           # commit automatically, then ask before pushing
-zapdev commit -yp          # commit automatically, then enter each push destination
+zapdev commit -yp          # skip review and push confirmation; choose a branch if protected
 ```
 
 Before contacting the LLM endpoint, zapdev runs `gitleaks git --staged --verbose` in each changed repository when Gitleaks is installed. A failed scan skips that repository without sending its diff; when Gitleaks is absent, the scan is skipped. The staged diff is sent to the configured endpoint, which may be remote.
@@ -142,11 +142,11 @@ Preparation and commit failures are reported per repository while the others con
 
 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`.
 
-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.
+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.
 
-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.
+Pushes always target a remote branch with the current local branch's name, with no destination input. 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/<current-branch>`. Ambiguous remotes are skipped with a warning. Both modes 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, publication is attempted. Classic mode compares HEAD; subtree mode compares its extracted history. Already published history is skipped. No rebase, merge, retry, or force-push.
 
-Without a TTY, zapdev commits all prepared repositories automatically but cannot push; `--push` reports an error and leaves commits local.
+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.
 
 #### Subtree publication
 
@@ -167,15 +167,15 @@ Place an optional `zapdev.json` in the directory where you launch zapdev:
 
 - **Scope:** only the launch directory's file is read, not parents or child repositories. Its mapping applies to newly committed repositories and repositories without new changes.
 - **Configuration:** only `zapdev.json` selects subtree mode; no subtree CLI flag. Missing or empty `subtrees` uses classic push. Invalid configuration stops the command before staging. Replace the removed `isSubtree` option with an explicit mapping.
-- **Destinations:** only mapped folders are published, using their configured remotes; folder and remote names need not match. Each changed subtree asks for its own destination branch, initially empty, then prefilled with the previous input across repositories in this run. Press Enter to reuse it, or leave the input empty to use the current branch. `main` is allowed; detached HEAD is refused.
-- **Publication:** check the presumed destination branch using the shared unpublished-commit rule above, then run `git subtree push --prefix=<folder> <remote> <input>`. Already published history is skipped without prompting; uncommitted changes are excluded.
+- **Destinations:** only mapped folders are published, using their configured remotes; folder and remote names need not match. All subtrees use the parent repository's current branch name. The parent itself is not pushed. Detached HEAD is refused.
+- **Publication:** check each subtree using the shared unpublished-commit rule above, then run `git subtree push --prefix=<folder> <remote> <current-branch>`. Subtrees without unpublished commits are skipped without creating remote branches; uncommitted changes are excluded.
 - **Failures:** stop all remaining publications, leaving earlier publications intact. No automatic recovery.
 
-Interactive runs still ask for confirmation, including with `--yes`; `--push` skips only that confirmation, never the destination inputs. Publication requires a TTY.
+Interactive runs still ask for publication confirmation, including with `--yes`; `--push` skips that confirmation. The commit and branch-selection flow is identical to classic mode.
 
 ```bash
 zapdev commit       # with subtrees configured, ask to publish after committing
-zapdev commit -yp   # enter a destination for each changed subtree
+zapdev commit -yp   # publish changed subtrees on the parent's current branch
 ```
 
 ### `zapdev subtree-init`
@@ -202,7 +202,7 @@ zapdev subtree-init my-project \
 
 ### Zed IDE
 
-For a faster review and commit workflow, review and stage changes from Zed's Git panel, then run `zapdev commit -syp` from a task. The command commits only staged changes, skips commit review and push confirmation, then asks for the push destination.
+For a faster review and commit workflow, review and stage changes from Zed's Git panel, then run `zapdev commit -syp` from a task. The command commits only staged changes, skips commit review and push confirmation, and asks for a branch before committing only if the current branch is protected.
 
 Add the following tasks to `.zed/tasks.json`:
 

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.11.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,12 +2317,18 @@ 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();
 }
+async function switchBranch(repo, branch) {
+  await git(["check-ref-format", "--branch", branch], repo);
+  await git(["check-ref-format", `refs/heads/${branch}`], repo);
+  const exists2 = await tryGit(["show-ref", "--verify", "--quiet", `refs/heads/${branch}`], repo) !== null;
+  await git(exists2 ? ["switch", "--no-guess", "--", branch] : ["switch", "--no-track", "-c", branch], repo);
+}
 async function getRepoStatus(repo) {
   const lines = (await git(["status", "--porcelain=v2", "--branch", "--untracked-files=normal"], repo)).trim().split("\n");
   const branch = lines.find((line) => line.startsWith("# branch.head "))?.slice(14) ?? "HEAD";
@@ -2366,23 +2343,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 +2399,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 +2453,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 +2475,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,14 +2517,16 @@ 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(", ")}).`
     },
     push: {
       type: "boolean",
       alias: "p",
-      description: "Skip push confirmation; still ask for each destination branch."
+      description: "Skip push confirmation and push the current branch."
     },
     staged: {
       type: "boolean",
@@ -2533,14 +2541,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 +2580,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 +2608,39 @@ var commitCommand = defineCommand({
       cancel("Cancelled (changes left staged).");
       return;
     }
-    const committed = [];
+    const toSend = [];
+    let previousBranchInput = "";
     for (const draft of selected) {
-      log.info(`${draft.label}: committing`);
       try {
-        await commit(draft.repo, draft.message, reportHooks(draft.label));
-        committed.push(draft);
+        const current = await currentBranch(draft.repo);
+        if (/^(main|master|principal|dev|development)$/.test(current)) {
+          if (!interactive) throw new Error("Committing on a protected branch requires a terminal to choose a branch. Changes remain staged.");
+          const answer = await text({
+            message: `${basename(draft.repo)} (${current}): branch to commit to`,
+            initialValue: previousBranchInput
+          });
+          if (isCancel(answer)) {
+            cancel("Committing cancelled. Changes remain staged; earlier commits stay local.");
+            return;
+          }
+          previousBranchInput = answer.trim();
+          const branch = previousBranchInput || current;
+          if (branch !== current) {
+            await switchBranch(draft.repo, branch);
+            draft.label = `${basename(draft.repo)} (${branch})`;
+            draft.pendingLabel = styleText4(["bold", "underline"], draft.label);
+          }
+        }
+        log.info(`${draft.label}: committing`);
+        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) {
@@ -2635,14 +2655,7 @@ var commitCommand = defineCommand({
       shouldPush = answer;
     }
     if (shouldPush) {
-      if (!interactive) {
-        log.error("Pushing requires a terminal to choose each destination branch. Commits remain local.");
-        process.exitCode = 1;
-        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,24 +2664,14 @@ 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}/${current}).`);
+            if (!await hasUnpushedCommits(repo, remote, current, reportHooks(label), prefix || void 0, reportNativeOutput)) {
               log.info(`${label}: no unpushed commits${prefix ? ` in ${prefix}` : ""}. Skipping.`);
               continue;
             }
-            const answer = await text({
-              message: `${label}: branch to push ${publishSubtreeMode ? `${prefix} to ` : "to "}${remote}`,
-              initialValue: previousBranchInput
-            });
-            if (isCancel(answer)) {
-              outro("Sending cancelled. Remaining commits stay local.");
-              return;
-            }
-            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));
-            log.success(`${label}: pushed to ${remote}/${branch}`);
+            log.info(`${label}: pushing ${publishSubtreeMode ? `${prefix} \u2192 ` : ""}${remote}/${current}`);
+            await push(repo, remote, current, reportHooks(label), prefix || void 0, reportNativeOutput);
+            log.success(`${label}: pushed to ${remote}/${current}`);
           }
         } catch (error) {
           reportGitFailure(`${label}: ${publishSubtreeMode ? "publication" : "push"} failed`, error);
@@ -2686,11 +2689,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 +2787,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 +2798,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 +2829,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.11.0",
   "description": "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   "type": "module",
   "bin": {