zapdev 1.5.0 → 1.7.0

package/README.md

@@ -125,7 +125,9 @@ 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 after committing without asking                              |
+| `-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`                |
 | `-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                            |
@@ -146,6 +148,32 @@ Pushing is optimistic, with no preliminary fetch. If the branch is behind upstre
 
 Without a TTY, zapdev commits all prepared repositories automatically and only pushes when `--push` is set.
 
+#### Subtree publication
+
+Place an optional `zapdev.json` in the directory where you launch zapdev:
+
+```json
+{ "isSubtree": true }
+```
+
+| `zapdev.json` option | Default | Effect |
+| ------------------- | ------- | ------ |
+| `isSubtree` | `false` | Replace classic push with subtree publication when `true`; must be a boolean. |
+
+- **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.
+
+Interactive runs still ask for confirmation; `--push` publishes without asking. `--yes` alone does not publish.
+
+```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
+```
+
 ### 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.

package/dist/cli.js

@@ -554,7 +554,7 @@ function _getBuiltinFlags(long, short, userNames, userAliases) {
 // package.json
 var package_default = {
   name: "zapdev",
-  version: "1.5.0",
+  version: "1.7.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,46 @@ function sanitizeCommitMessage(raw) {
 }
 
 // src/lib/config.ts
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+
+// src/lib/errors.ts
+var GitOutputError = class extends Error {
+  constructor(message, hookFailureReported = false) {
+    super(message);
+    this.hookFailureReported = hookFailureReported;
+  }
+  hookFailureReported;
+};
+function errorMessage(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+
+// src/lib/config.ts
+async function resolvePublishSubtree(directory, override) {
+  if (override !== void 0) return override;
+  let content;
+  try {
+    content = await readFile(join(directory, "zapdev.json"), "utf8");
+  } catch (error) {
+    if (error.code === "ENOENT") return false;
+    throw new Error(`Unable to read zapdev.json: ${errorMessage(error)}`, { cause: error });
+  }
+  let config;
+  try {
+    config = JSON.parse(content);
+  } catch (error) {
+    throw new Error("zapdev.json must contain valid JSON.", { cause: error });
+  }
+  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.");
+  }
+  return isSubtree === true;
+}
 function resolveHookTimeout(env = process.env) {
   const timeout = Number(env.ZD_HOOK_TIMEOUT ?? 60) * 1e3;
   if (!Number.isFinite(timeout) || timeout < 1 || timeout > 2147483647) {
@@ -1846,7 +1886,7 @@ function resolveConfig(env = process.env, overrides = {}) {
 // src/lib/git.ts
 import { execFileSync } from "node:child_process";
 import { readdir } from "node:fs/promises";
-import { join } from "node:path";
+import { join as join2 } from "node:path";
 import { createInterface as createInterface2 } from "node:readline";
 import { Readable } from "node:stream";
 
@@ -2226,7 +2266,11 @@ async function git(args, cwd, onHook) {
     }
   });
   let timeoutError;
-  const { report, close } = createHookReporter(onHook, (name) => {
+  let hookFailureReported = false;
+  const { report, close } = createHookReporter((event) => {
+    if (onHook && event.phase === "exit" && event.exitCode !== 0) hookFailureReported = true;
+    onHook?.(event);
+  }, (name) => {
     if (timeoutError || child.pid === void 0) return;
     timeoutError = new Error(`${name} hook timed out after ${timeout / 1e3} seconds`);
     try {
@@ -2247,7 +2291,9 @@ async function git(args, cwd, onHook) {
     const result = await child;
     if (timeoutError) throw timeoutError;
     if (result.exitCode !== 0) {
-      throw new Error(result.stderr.trim() || `git ${args.join(" ")} failed`);
+      const message = result.stderr.trim() || `git ${args.join(" ")} failed`;
+      if (interactive) throw new GitOutputError(message, hookFailureReported);
+      throw new Error(message);
     }
     return result.stdout;
   } finally {
@@ -2287,7 +2333,7 @@ async function getStagedDiff(repo) {
   return git(["diff", "--cached"], repo);
 }
 async function commit(repo, message, onHook) {
-  await git(["commit", "-m", message], repo, onHook);
+  await git(["commit", "--quiet", "-m", message], repo, onHook);
 }
 async function currentBranch(repo) {
   return (await git(["symbolic-ref", "--short", "HEAD"], repo)).trim();
@@ -2305,19 +2351,29 @@ async function hasUpstream(repo) {
   return result !== null;
 }
 async function push(repo, onHook) {
-  await git(["push"], repo, onHook);
+  await git(["push", "--quiet"], repo, onHook);
 }
 async function pushSetUpstream(repo, branch, onHook) {
-  await git(["push", "-u", "origin", branch], repo, onHook);
+  await git(["push", "--quiet", "-u", "origin", branch], repo, onHook);
+}
+async function publishSubtree(repo, remote, branch, onHook) {
+  if (branch === "main") throw new Error("Refusing to publish directly to main.");
+  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", "--rebase"], repo, onHook);
+  await git(["pull", "--quiet", "--rebase"], repo, onHook);
 }
 async function pullMerge(repo, onHook) {
-  await git(["pull", "--no-rebase", "--no-edit"], repo, onHook);
+  await git(["pull", "--quiet", "--no-rebase", "--no-edit"], repo, onHook);
 }
 async function fetchRemote(repo, onHook) {
-  await git(["fetch"], repo, onHook);
+  await git(["fetch", "--quiet"], repo, onHook);
 }
 async function behindCount(repo) {
   const out = await tryGit(["rev-list", "--count", `HEAD..${UPSTREAM_REF}`], repo);
@@ -2329,18 +2385,13 @@ async function findRepos(path) {
   const entries = await readdir(path, { withFileTypes: true }).catch(() => null);
   if (!entries) return [];
   const dirs = entries.filter((entry) => entry.isDirectory() && entry.name !== "node_modules");
-  const repos = await Promise.all(dirs.map((entry) => repoRoot(join(path, entry.name))));
+  const repos = await Promise.all(dirs.map((entry) => repoRoot(join2(path, entry.name))));
   return repos.filter((dir) => dir !== null).sort();
 }
 async function repoRoot(dir) {
   return (await tryGit(["rev-parse", "--show-toplevel"], dir))?.trim() ?? null;
 }
 
-// src/lib/errors.ts
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
-}
-
 // src/lib/gitleaks.ts
 async function hasGitleaks() {
   try {
@@ -2463,7 +2514,11 @@ var commitCommand = defineCommand({
     push: {
       type: "boolean",
       alias: "p",
-      description: "Push after committing without asking."
+      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."
     },
     staged: {
       type: "boolean",
@@ -2503,6 +2558,7 @@ var commitCommand = defineCommand({
       return;
     }
     let config;
+    let publishSubtreeMode;
     try {
       resolveHookTimeout();
       config = resolveConfig(process.env, {
@@ -2510,6 +2566,7 @@ var commitCommand = defineCommand({
         model: args.model,
         effort: args.effort
       });
+      publishSubtreeMode = await resolvePublishSubtree(process.cwd(), args["publish-subtree"]);
     } catch (error) {
       log.error(errorMessage(error));
       process.exitCode = 1;
@@ -2576,7 +2633,7 @@ var commitCommand = defineCommand({
         committed.push(draft);
         log.success(`${draft.label}: committed ${draft.message}`);
       } catch (error) {
-        log.error(`${draft.pendingLabel}: commit failed: ${errorMessage(error)}`);
+        reportGitFailure(`${draft.pendingLabel}: commit failed`, error);
         process.exitCode = 1;
       }
     }
@@ -2584,11 +2641,11 @@ var commitCommand = defineCommand({
     let shouldPush = Boolean(args.push);
     if (!shouldPush && interactive && !args.yes) {
       const answer = await confirm({
-        message: `Push ${committed.map(({ label }) => label).join(", ")}?`,
+        message: `${publishSubtreeMode ? "Publish subtrees in" : "Push"} ${committed.map(({ label }) => label).join(", ")}?`,
         initialValue: false
       });
       if (isCancel(answer)) {
-        outro("Committed. Not pushed.");
+        outro(publishSubtreeMode ? "Committed. Not published." : "Committed. Not pushed.");
         return;
       }
       shouldPush = answer;
@@ -2596,14 +2653,14 @@ var commitCommand = defineCommand({
     if (shouldPush) {
       for (const repository of committed) {
         try {
-          const pushed = await pushOptimistic(
+          const pushed = publishSubtreeMode ? await publishSubtrees(repository) : await pushOptimistic(
             repository,
             interactive && !args.yes,
             syncStrategy
           );
           if (!pushed) process.exitCode = 1;
         } catch (error) {
-          log.error(`${repository.label}: push failed: ${errorMessage(error)}`);
+          reportGitFailure(`${repository.label}: ${publishSubtreeMode ? "publication" : "push"} failed`, error);
           process.exitCode = 1;
         }
       }
@@ -2611,14 +2668,19 @@ var commitCommand = defineCommand({
     if (interactive) outro(process.exitCode ? "Finished with errors." : "Done.");
   }
 });
+function reportGitFailure(message, error, level = "error") {
+  if (error instanceof GitOutputError && error.hookFailureReported) return;
+  log[level](error instanceof GitOutputError ? message : `${message}: ${errorMessage(error)}`);
+}
 function reportHooks(label) {
+  const options = { secondarySymbol: "" };
   return (event) => {
     const hook = `${label}: ${event.name}`;
     if (event.phase === "start") {
-      log.info(`${hook} running`);
+      log.step(styleText3("bold", hook), options);
     } else {
-      if (event.exitCode === 0) log.success(`${hook} \u2713`);
-      else log.error(`${hook} \u2717 (exit ${event.exitCode})`);
+      if (event.exitCode === 0) log.success(`${hook}: completed`, options);
+      else log.error(`${hook}: failed (exit ${event.exitCode})`, options);
     }
   };
 }
@@ -2662,10 +2724,25 @@ async function syncWithUpstream({ repo, label }, strategy) {
     log.success(`${label}: ${strategy === "rebase" ? "rebased on upstream" : "merged upstream"}`);
     return true;
   } catch (error) {
-    log.error(`${label}: ${actionLabel} failed (resolve conflicts, then push): ${errorMessage(error)}`);
+    reportGitFailure(`${label}: ${actionLabel} failed (resolve conflicts, then push)`, error);
     return false;
   }
 }
+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;
+    }
+  }
+  return true;
+}
 async function pushOptimistic(repository, canPrompt, strategy) {
   const { repo, label } = repository;
   const [upstream, branch] = await Promise.all([hasUpstream(repo), currentBranch(repo)]);
@@ -2677,10 +2754,10 @@ async function pushOptimistic(repository, canPrompt, strategy) {
     if (!syncStrategy || !await syncWithUpstream(repository, syncStrategy)) return false;
     const retry = await tryPush(repository, doPush);
     if (retry.ok) return true;
-    log.error(`${label}: push failed: ${errorMessage(retry.error)}`);
+    reportGitFailure(`${label}: push failed`, retry.error);
     return false;
   }
-  log.error(`${label}: push failed: ${errorMessage(first.error)}`);
+  reportGitFailure(`${label}: push failed`, first.error);
   return false;
 }
 async function chooseSyncStrategy({ label }, interactive) {
@@ -2720,7 +2797,7 @@ async function isBehind({ repo, label }) {
     log.info(`${label}: ${behind > 0 ? `Behind upstream by ${behind} commit${behind > 1 ? "s" : ""}` : "Up to date with upstream"}`);
     return behind > 0;
   } catch (error) {
-    log.warn(`${label}: could not check upstream: ${errorMessage(error)}`);
+    reportGitFailure(`${label}: could not check upstream`, error, "warn");
     return false;
   }
 }

package/package.json

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