zapdev 1.6.0 → 1.8.0

package/README.md

@@ -125,27 +125,57 @@ 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                            |
-| `-y, --yes`         | Skip prompts and commit all prepared repositories                 |
+| `-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
 ```
 
 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.
 
-In a terminal, Git and its hooks display live logs and support native prompts, even with `--yes` (which only skips zapdev 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`.
+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.
 
 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, including with `--yes`; `--push` publishes without asking. Without a TTY, `--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.8.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",
@@ -2496,7 +2538,7 @@ var commitCommand = defineCommand({
     yes: {
       type: "boolean",
       alias: "y",
-      description: "Skip prompts and commit directly."
+      description: "Skip commit review; still confirm push unless --push is set."
     }
   },
   async run({ args }) {
@@ -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;
@@ -2595,13 +2639,13 @@ var commitCommand = defineCommand({
     }
     if (committed.length === 0) return;
     let shouldPush = Boolean(args.push);
-    if (!shouldPush && interactive && !args.yes) {
+    if (!shouldPush && interactive) {
       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.8.0",
   "description": "Fast, performant and lightweight git chores and dev tools using your terminal and an OpenAI-compatible LLM endpoint.",
   "type": "module",
   "bin": {