zapdev 1.6.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.6.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";
 
@@ -2176,18 +2216,6 @@ var R2 = (e2, t3, n4) => {
 };
 var z = R2;
 
-// 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/git-hooks.ts
 function createHookReporter(onHook, onTimeout, timeout) {
   const hooks = /* @__PURE__ */ new Map();
@@ -2328,6 +2356,16 @@ async function push(repo, onHook) {
 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.");
+  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);
 }
@@ -2347,7 +2385,7 @@ 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) {
@@ -2476,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",
@@ -2516,6 +2558,7 @@ var commitCommand = defineCommand({
       return;
     }
     let config;
+    let publishSubtreeMode;
     try {
       resolveHookTimeout();
       config = resolveConfig(process.env, {
@@ -2523,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;
@@ -2597,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;
@@ -2609,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) {
-          reportGitFailure(`${repository.label}: push failed`, error);
+          reportGitFailure(`${repository.label}: ${publishSubtreeMode ? "publication" : "push"} failed`, error);
           process.exitCode = 1;
         }
       }
@@ -2684,6 +2728,21 @@ async function syncWithUpstream({ repo, label }, strategy) {
     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)]);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zapdev",
-  "version": "1.6.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": {