zapdev 1.8.0 → 1.9.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 nothing to commit are skipped. Unselected or cancelled changes remain staged. Push confirmation is asked once for the successfully committed repositories.
+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.
 
 ```bash
 zapdev commit
@@ -125,60 +125,84 @@ zapdev commit
 | `--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 or publish subtrees after committing without asking           |
-| `--publish-subtree` | Publish subtrees instead of using the classic push                |
-| `--publish-subtree=false` | Force classic push, overriding `zapdev.json`                |
+| `-p, --push`        | Skip push confirmation; still ask for each destination branch      |
 | `-s, --staged`      | Commit only changes that are already staged                       |
-| `-r, --rebase`      | Rebase on upstream if the push is rejected                        |
-| `-m, --merge`       | Merge upstream if the push is rejected                            |
 | `-y, --yes`         | Skip commit review; still confirm push unless `--push` is set     |
 
 ```bash
 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 and push without confirmation
+zapdev commit -yp          # commit automatically, then enter each push destination
 ```
 
 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.
 
-Failures are reported per repository while the others continue. Any failure produces a nonzero exit code.
+Preparation and commit failures are reported per repository while the others continue. A push failure stops all remaining sends. 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 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`.
 
-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.
+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.
 
-Without a TTY, zapdev commits all prepared repositories automatically and only pushes when `--push` is set.
+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.
+
+Without a TTY, zapdev commits all prepared repositories automatically but cannot push; `--push` reports an error and leaves commits local.
 
 #### Subtree publication
 
 Place an optional `zapdev.json` in the directory where you launch zapdev:
 
 ```json
-{ "isSubtree": true }
+{
+  "subtrees": {
+    "projet-front": "front",
+    "projet-back": "back"
+  }
+}
 ```
 
 | `zapdev.json` option | Default | Effect |
 | ------------------- | ------- | ------ |
-| `isSubtree` | `false` | Replace classic push with subtree publication when `true`; must be a boolean. |
+| `subtrees` | `{}` | Map repository-relative folders to Git remote names. A nonempty mapping replaces classic push with subtree publication. |
 
-- **Scope:** only the launch directory's file is read, not parents or child repositories. Its setting applies to all successfully committed repositories.
-- **Priority:** explicit `--publish-subtree` / `--publish-subtree=false` overrides the file. Without a flag, invalid configuration stops the command before staging.
-- **Destinations:** `projet-front` → remote `front`, `projet-back` → remote `back`, both using the current branch name. `main` and detached HEAD are refused.
-- **Publication:** fetch each remote's `main`, split committed contents, skip contents identical to `main`, then push without force. Uncommitted changes are excluded.
-- **Failures:** stop that repository's publication, leaving earlier publications intact; other repositories continue. No automatic rebase/merge recovery.
+- **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.
+- **Failures:** stop all remaining publications, leaving earlier publications intact. No automatic recovery.
 
-Interactive runs still ask for confirmation, including with `--yes`; `--push` publishes without asking. Without a TTY, `--yes` alone does not publish.
+Interactive runs still ask for confirmation, including with `--yes`; `--push` skips only that confirmation, never the destination inputs. Publication requires a TTY.
 
 ```bash
-zapdev commit --publish-subtree        # ask to publish after committing
-zapdev commit --publish-subtree -yp    # publish without zapdev prompts
-zapdev commit --publish-subtree=false -yp # force classic push
+zapdev commit       # with subtrees configured, ask to publish after committing
+zapdev commit -yp   # enter a destination for each changed subtree
 ```
 
+### `zapdev subtree-init`
+
+Create or extend a repository with squashed subtrees, named remotes, and the matching `zapdev.json`. No gum or LLM configuration required.
+
+```bash
+zapdev subtree-init my-project \
+  front=git@github.com:org/front.git \
+  back=git@github.com:org/back.git \
+  --origin git@github.com:org/project.git
+```
+
+| Parameter | Effect |
+| --------- | ------ |
+| `<directory>` | Repository to create or extend. New repositories start on `main`; existing branches are kept. |
+| `<name=url>...` | One or more sources. Each name is both the subtree folder and its Git remote name. |
+| `--origin <url>` | Optional parent repository remote; replaces the shell helper's `remote=url` argument. |
+
+- Requires a clean working tree, including untracked files. Existing folders, conflicting mappings or remote URLs, and a symlinked `zapdev.json` are refused before importing any subtree.
+- Detects each source's default branch, falling back to `main` with a warning when unavailable; imports with `git subtree add --squash`.
+- Commits the explicit folder-to-remote mapping before imports, preserving existing mappings and other JSON settings. Example: `{"subtrees":{"front":"front","back":"back"}}`.
+- Does not push. Git failures stop immediately without rollback; configuration, remotes, and earlier imports remain in place.
+
 ### 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 prompts, and pushes the commit.
+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.
 
 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.8.0",
+  version: "1.9.0",
   description: "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   type: "module",
   bin: {
@@ -1816,7 +1816,7 @@ function sanitizeCommitMessage(raw) {
 
 // src/lib/config.ts
 import { readFile } from "node:fs/promises";
-import { join } from "node:path";
+import { isAbsolute, join } from "node:path";
 
 // src/lib/errors.ts
 var GitOutputError = class extends Error {
@@ -1831,13 +1831,12 @@ function errorMessage(error) {
 }
 
 // src/lib/config.ts
-async function resolvePublishSubtree(directory, override) {
-  if (override !== void 0) return override;
+async function readProjectConfig(directory) {
   let content;
   try {
     content = await readFile(join(directory, "zapdev.json"), "utf8");
   } catch (error) {
-    if (error.code === "ENOENT") return false;
+    if (error.code === "ENOENT") return {};
     throw new Error(`Unable to read zapdev.json: ${errorMessage(error)}`, { cause: error });
   }
   let config;
@@ -1849,11 +1848,27 @@ async function resolvePublishSubtree(directory, override) {
   if (typeof config !== "object" || config === null || Array.isArray(config)) {
     throw new Error("zapdev.json must contain an object.");
   }
-  const isSubtree = config.isSubtree;
-  if (isSubtree !== void 0 && typeof isSubtree !== "boolean") {
-    throw new Error("zapdev.json isSubtree must be a boolean.");
+  const settings2 = config;
+  if (settings2.isSubtree !== void 0) {
+    throw new Error("zapdev.json isSubtree is no longer supported; use a subtrees folder-to-remote mapping.");
+  }
+  const subtrees = settings2.subtrees;
+  if (subtrees === void 0) return settings2;
+  if (typeof subtrees !== "object" || subtrees === null || Array.isArray(subtrees)) {
+    throw new Error("zapdev.json subtrees must be a folder-to-remote object.");
+  }
+  for (const [prefix, remote] of Object.entries(subtrees)) {
+    if (prefix !== prefix.trim() || isAbsolute(prefix) || prefix.includes("\\") || prefix.split("/").some((part) => ["", ".", "..", ".git"].includes(part))) {
+      throw new Error(`zapdev.json subtree folder "${prefix}" must be a repository-relative directory.`);
+    }
+    if (typeof remote !== "string" || !remote || /\s/.test(remote) || remote.startsWith("-")) {
+      throw new Error(`zapdev.json subtree "${prefix}" must map to a nonempty Git remote name.`);
+    }
   }
-  return isSubtree === true;
+  return settings2;
+}
+async function resolveSubtrees(directory) {
+  return (await readProjectConfig(directory)).subtrees ?? {};
 }
 function resolveHookTimeout(env = process.env) {
   const timeout = Number(env.ZD_HOOK_TIMEOUT ?? 60) * 1e3;
@@ -2252,10 +2267,9 @@ function createHookReporter(onHook, onTimeout, timeout) {
 }
 
 // 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 interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY && ["commit", "push", "subtree", "fetch"].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;
   const child = R2("git", args, {
     nodeOptions: {
@@ -2346,38 +2360,28 @@ async function getRepoStatus(repo) {
     hasChanges: lines.some((line) => !line.startsWith("#"))
   };
 }
-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, onHook) {
-  await git(["push", "--quiet"], repo, onHook);
+async function getPushRemote(repo, branch) {
+  const remotes = (await git(["remote"], repo)).trim().split("\n").filter(Boolean);
+  const upstream = (await git(["for-each-ref", "--format=%(upstream:remotename)", `refs/heads/${branch}`], repo)).trim();
+  if (upstream) return remotes.includes(upstream) ? upstream : null;
+  return remotes.length === 1 ? remotes[0] : null;
 }
-async function pushSetUpstream(repo, branch, onHook) {
-  await git(["push", "--quiet", "-u", "origin", branch], repo, onHook);
-}
-async function publishSubtree(repo, remote, branch, onHook) {
-  if (branch === "main") throw new Error("Refusing to publish directly to main.");
+async function push(repo, remote, branch, onHook) {
   await git(["check-ref-format", "--branch", branch], repo);
-  await git(["fetch", "--quiet", remote, "main"], repo, onHook);
-  const split = (await git(["subtree", "split", "--quiet", `--prefix=projet-${remote}`], repo)).trim();
-  const changes = await git(["diff", "--name-only", "FETCH_HEAD", split, "--"], repo);
-  if (!changes.trim()) return false;
-  await git(["push", "--quiet", remote, `${split}:refs/heads/${branch}`], repo, onHook);
-  return true;
-}
-async function pullRebase(repo, onHook) {
-  await git(["pull", "--quiet", "--rebase"], repo, onHook);
+  await git(["push", "--", remote, `HEAD:refs/heads/${branch}`], repo, onHook);
 }
-async function pullMerge(repo, onHook) {
-  await git(["pull", "--quiet", "--no-rebase", "--no-edit"], repo, onHook);
-}
-async function fetchRemote(repo, onHook) {
-  await git(["fetch", "--quiet"], repo, onHook);
+async function hasUnpushedCommits(repo, remote, branch, onHook, prefix) {
+  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);
+  return Boolean((await git(["rev-list", "--max-count=1", `FETCH_HEAD..${source}`], repo)).trim());
 }
-async function behindCount(repo) {
-  const out = await tryGit(["rev-list", "--count", `HEAD..${UPSTREAM_REF}`], repo);
-  return out === null ? 0 : Number(out.trim()) || 0;
+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);
@@ -2514,27 +2518,13 @@ var commitCommand = defineCommand({
     push: {
       type: "boolean",
       alias: "p",
-      description: "Push or publish subtrees after committing without asking."
-    },
-    "publish-subtree": {
-      type: "boolean",
-      description: "Publish projet-front and projet-back; use --publish-subtree=false to force classic push."
+      description: "Skip push confirmation; still ask for each destination branch."
     },
     staged: {
       type: "boolean",
       alias: "s",
       description: "Commit only changes that are already staged."
     },
-    rebase: {
-      type: "boolean",
-      alias: "r",
-      description: "Rebase on the upstream branch if the push is rejected."
-    },
-    merge: {
-      type: "boolean",
-      alias: "m",
-      description: "Merge the upstream branch if the push is rejected."
-    },
     yes: {
       type: "boolean",
       alias: "y",
@@ -2543,12 +2533,6 @@ var commitCommand = defineCommand({
   },
   async run({ args }) {
     const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
-    if (args.rebase && args.merge) {
-      log.error("Choose either --rebase or --merge, not both.");
-      process.exitCode = 1;
-      return;
-    }
-    const syncStrategy = args.rebase ? "rebase" : args.merge ? "merge" : void 0;
     const type = args.type ? normalizeCommitType(args.type) : void 0;
     if (type === null) {
       log.error(
@@ -2558,7 +2542,7 @@ var commitCommand = defineCommand({
       return;
     }
     let config;
-    let publishSubtreeMode;
+    let subtrees;
     try {
       resolveHookTimeout();
       config = resolveConfig(process.env, {
@@ -2566,12 +2550,13 @@ var commitCommand = defineCommand({
         model: args.model,
         effort: args.effort
       });
-      publishSubtreeMode = await resolvePublishSubtree(process.cwd(), args["publish-subtree"]);
+      subtrees = await resolveSubtrees(process.cwd());
     } catch (error) {
       log.error(errorMessage(error));
       process.exitCode = 1;
       return;
     }
+    const publishSubtreeMode = Object.keys(subtrees).length > 0;
     if (interactive) intro("zapdev commit");
     const repos = await findRepos(process.cwd());
     if (repos.length === 0) {
@@ -2606,6 +2591,7 @@ var commitCommand = defineCommand({
     }));
     loader?.stop("Repositories prepared");
     const drafts = [];
+    const unchanged = [];
     for (const [index, result] of results.entries()) {
       if (result.status === "rejected") {
         log.error(`${repositories[index].pendingLabel}: ${errorMessage(result.reason)}`);
@@ -2614,13 +2600,10 @@ var commitCommand = defineCommand({
         drafts.push(result.value);
       } else {
         log.info(`${repositories[index].pendingLabel}: nothing to commit.`);
+        unchanged.push(repositories[index]);
       }
     }
-    if (drafts.length === 0) {
-      if (interactive) outro("No commits prepared.");
-      return;
-    }
-    const selected = await reviewMessages(drafts, interactive && !args.yes);
+    const selected = drafts.length ? await reviewMessages(drafts, interactive && !args.yes) : [];
     if (!selected) {
       cancel("Cancelled (changes left staged).");
       return;
@@ -2637,11 +2620,12 @@ var commitCommand = defineCommand({
         process.exitCode = 1;
       }
     }
-    if (committed.length === 0) return;
+    const toSend = [...committed, ...unchanged];
+    if (toSend.length === 0) return;
     let shouldPush = Boolean(args.push);
     if (!shouldPush && interactive) {
       const answer = await confirm({
-        message: `${publishSubtreeMode ? "Publish subtrees in" : "Push"} ${committed.map(({ label }) => label).join(", ")}?`,
+        message: `${publishSubtreeMode ? "Publish subtrees in" : "Push"} ${toSend.map(({ label }) => label).join(", ")}?`,
         initialValue: false
       });
       if (isCancel(answer)) {
@@ -2651,26 +2635,55 @@ var commitCommand = defineCommand({
       shouldPush = answer;
     }
     if (shouldPush) {
-      for (const repository of committed) {
+      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;
         try {
-          const pushed = publishSubtreeMode ? await publishSubtrees(repository) : await pushOptimistic(
-            repository,
-            interactive && !args.yes,
-            syncStrategy
-          );
-          if (!pushed) process.exitCode = 1;
+          const current = await currentBranch(repo);
+          const destinations = publishSubtreeMode ? Object.entries(subtrees) : [["", await getPushRemote(repo, current)]];
+          for (const [prefix, remote] of destinations) {
+            if (!remote) {
+              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}: 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}`);
+          }
         } catch (error) {
-          reportGitFailure(`${repository.label}: ${publishSubtreeMode ? "publication" : "push"} failed`, error);
+          reportGitFailure(`${label}: ${publishSubtreeMode ? "publication" : "push"} failed`, error);
           process.exitCode = 1;
+          outro("Sending stopped after a Git failure.");
+          return;
         }
       }
     }
     if (interactive) outro(process.exitCode ? "Finished with errors." : "Done.");
   }
 });
-function reportGitFailure(message, error, level = "error") {
+function reportGitFailure(message, error) {
   if (error instanceof GitOutputError && error.hookFailureReported) return;
-  log[level](error instanceof GitOutputError ? message : `${message}: ${errorMessage(error)}`);
+  log.error(error instanceof GitOutputError ? message : `${message}: ${errorMessage(error)}`);
 }
 function reportHooks(label) {
   const options = { secondarySymbol: "" };
@@ -2716,91 +2729,113 @@ async function reviewMessages(drafts, canPrompt) {
     action.draft.message = edited.trim();
   }
 }
-async function syncWithUpstream({ repo, label }, strategy) {
-  const actionLabel = strategy === "rebase" ? "Rebase" : "Merge";
-  log.info(`${label}: pulling --${strategy === "rebase" ? "rebase" : "no-rebase"}`);
-  try {
-    await (strategy === "rebase" ? pullRebase : pullMerge)(repo, reportHooks(label));
-    log.success(`${label}: ${strategy === "rebase" ? "rebased on upstream" : "merged upstream"}`);
-    return true;
-  } catch (error) {
-    reportGitFailure(`${label}: ${actionLabel} failed (resolve conflicts, then push)`, error);
-    return false;
-  }
+
+// src/lib/subtree-init.ts
+import { lstat, mkdir, writeFile } from "node:fs/promises";
+import { join as join3, resolve } from "node:path";
+function parseSubtreeSources(entries) {
+  if (entries.length === 0) throw new Error("Provide at least one subtree as name=url.");
+  const names = /* @__PURE__ */ new Set();
+  return entries.map((entry) => {
+    const separator = entry.indexOf("=");
+    const name = entry.slice(0, separator);
+    const url = entry.slice(separator + 1);
+    if (separator < 1 || !/^[a-zA-Z0-9_][a-zA-Z0-9_.-]*$/.test(name) || name === "zapdev.json" || name.includes("..") || name.endsWith(".") || name.endsWith(".lock") || !url.trim() || url.startsWith("-") || url.includes("\0")) {
+      throw new Error(`Invalid source "${entry}": expected name=url with a simple folder and remote name.`);
+    }
+    if (names.has(name)) throw new Error(`Duplicate subtree name "${name}".`);
+    names.add(name);
+    return { name, url };
+  });
 }
-async function publishSubtrees({ repo, label }) {
-  const branch = await currentBranch(repo);
-  for (const remote of ["front", "back"]) {
-    log.info(`${label}: publishing projet-${remote} \u2192 ${remote}/${branch}`);
-    try {
-      const published = await publishSubtree(repo, remote, branch, reportHooks(label));
-      if (published) log.success(`${label}: published projet-${remote} \u2192 ${remote}/${branch}`);
-      else log.info(`${label}: no changes in projet-${remote}. Skipping.`);
-    } catch (error) {
-      reportGitFailure(`${label}: publication to ${remote}/${branch} failed`, error);
-      return false;
-    }
+async function initializeSubtrees(directory, sources, options = {}) {
+  if (!directory.trim()) throw new Error("Directory cannot be empty.");
+  if (options.origin !== void 0 && (!options.origin.trim() || options.origin.startsWith("-") || options.origin.includes("\0"))) {
+    throw new Error("--origin must be a nonempty repository URL.");
+  }
+  const repo = resolve(directory);
+  await mkdir(repo, { recursive: true });
+  if (!await exists(join3(repo, ".git"))) await git(["init", "--quiet", "-b", "main"], repo);
+  if ((await getRepoStatus(repo)).hasChanges) {
+    throw new Error("Working tree must be clean before adding subtrees (including untracked files).");
+  }
+  const configPath = join3(repo, "zapdev.json");
+  if (await exists(configPath) && (await lstat(configPath)).isSymbolicLink()) {
+    throw new Error("Refusing to overwrite zapdev.json through a symbolic link.");
+  }
+  const settings2 = await readProjectConfig(repo);
+  const mapping = new Map(Object.entries(settings2.subtrees ?? {}));
+  const remotes = /* @__PURE__ */ new Map();
+  if (options.origin !== void 0) remotes.set("origin", options.origin);
+  for (const { name, url } of sources) {
+    if (await exists(join3(repo, name))) throw new Error(`"${name}" already exists.`);
+    const mappedRemote = mapping.get(name);
+    if (mappedRemote && mappedRemote !== name) throw new Error(`"${name}" is already mapped to remote "${mappedRemote}".`);
+    const plannedURL = remotes.get(name);
+    if (plannedURL && plannedURL !== url) throw new Error(`Remote "${name}" was requested with another URL: ${plannedURL}`);
+    remotes.set(name, url);
+  }
+  const missingRemotes = [];
+  for (const [name, url] of remotes) {
+    const existingURL = await tryGit(["remote", "get-url", name], repo);
+    if (existingURL === null) missingRemotes.push([name, url]);
+    else if (existingURL.trim() !== url) throw new Error(`Remote "${name}" already exists with another URL: ${existingURL.trim()}`);
+  }
+  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 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" });
+  }
+  const initial = await tryGit(["rev-parse", "--verify", "HEAD"], repo) === null;
+  for (const { name } of sources) mapping.set(name, name);
+  await writeFile(configPath, `${JSON.stringify({ ...settings2, subtrees: Object.fromEntries(mapping) }, null, 2)}
+`);
+  await git(["add", "--", "zapdev.json"], repo);
+  if (initial || (await getStagedDiff(repo)).trim()) {
+    await commit(repo, initial ? "chore: init" : "chore: configure subtrees");
   }
-  return true;
-}
-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, doPush);
-  if (first.ok) return true;
-  if (upstream && await isBehind(repository)) {
-    const syncStrategy = strategy ?? await chooseSyncStrategy(repository, canPrompt);
-    if (!syncStrategy || !await syncWithUpstream(repository, syncStrategy)) return false;
-    const retry = await tryPush(repository, doPush);
-    if (retry.ok) return true;
-    reportGitFailure(`${label}: push failed`, retry.error);
-    return false;
+  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);
   }
-  reportGitFailure(`${label}: push failed`, first.error);
-  return false;
 }
-async function chooseSyncStrategy({ label }, interactive) {
-  if (!interactive) {
-    log.error(`${label}: branch is behind upstream. Re-run with --rebase or --merge.`);
-    return null;
-  }
-  const action = await select({
-    message: `${label}: branch is behind upstream. How should zapdev sync it?`,
-    options: [
-      { value: "rebase", label: "Rebase" },
-      { value: "merge", label: "Merge" },
-      { value: "quit", label: "Quit" }
-    ]
+async function exists(path) {
+  return lstat(path).then(() => true, (error) => {
+    if (error.code === "ENOENT") return false;
+    throw error;
   });
-  if (isCancel(action) || action === "quit") {
-    log.warn("Push cancelled. Commit remains local.");
-    return null;
-  }
-  return action;
 }
-async function tryPush({ label }, doPush) {
-  log.info(`${label}: pushing`);
-  try {
-    await doPush(reportHooks(label));
-    log.success(`${label}: pushed`);
-    return { ok: true };
-  } catch (error) {
-    return { ok: false, error };
-  }
-}
-async function isBehind({ repo, label }) {
-  log.info(`${label}: checking upstream`);
-  try {
-    await fetchRemote(repo, reportHooks(label));
-    const behind = await behindCount(repo);
-    log.info(`${label}: ${behind > 0 ? `Behind upstream by ${behind} commit${behind > 1 ? "s" : ""}` : "Up to date with upstream"}`);
-    return behind > 0;
-  } catch (error) {
-    reportGitFailure(`${label}: could not check upstream`, error, "warn");
-    return false;
+
+// src/commands/subtree-init.ts
+var subtreeInitCommand = defineCommand({
+  meta: { name: "subtree-init", description: "Initialize a repository with squashed subtrees and their named remotes." },
+  args: {
+    directory: { type: "positional", required: true, description: "Repository directory to create or extend." },
+    subtree: { type: "positional", required: true, description: "name=url; add more positional sources for additional subtrees." },
+    origin: { type: "string", description: "Optional URL for the parent repository's origin remote." }
+  },
+  async run({ args }) {
+    const interactive = Boolean(process.stdin.isTTY && process.stdout.isTTY);
+    try {
+      const sources = parseSubtreeSources(args._.slice(1));
+      if (interactive) intro("zapdev subtree-init");
+      await initializeSubtrees(args.directory, sources, {
+        origin: args.origin,
+        onProgress: log.info,
+        onWarning: log.warn
+      });
+      if (interactive) outro("Subtrees ready.");
+      else log.info("Subtrees ready.");
+    } catch (error) {
+      log.error(error instanceof GitOutputError ? "Subtree initialization failed." : errorMessage(error));
+      process.exitCode = 1;
+    }
   }
-}
+});
 
 // src/cli.ts
 var main = defineCommand({
@@ -2810,7 +2845,7 @@ var main = defineCommand({
     description: "Fast, precise git chores from your terminal."
   },
   args: commitCommand.args,
-  subCommands: { commit: commitCommand },
+  subCommands: { commit: commitCommand, "subtree-init": subtreeInitCommand },
   default: "commit"
 });
 await runMain(main);

package/package.json

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