claude-nomad 0.26.2 → 0.27.0

package/src/remap.ts

@@ -49,22 +49,31 @@ export function copyDirJsonlOnly(src: string, dst: string): void {
 /**
  * Pull: copy from repo's logical project names into local path-encoded dirs.
  *
- * Returns `{ unmapped: N }` where `N` counts path-map entries skipped for
- * this host (either `'TBD'` placeholder or no entry for `HOST`). The count
- * is consumed by `computePreview` and the future summary line.
+ * Returns `{ unmapped, pulled, wouldPull }`. `unmapped` counts path-map entries
+ * skipped for this host (`'TBD'` placeholder or no entry for `HOST`); `pulled`
+ * holds logical names copied (wet), `wouldPull` those that would copy under
+ * `dryRun`. The arrays let cmdPull render a grouped tree; the wet path no longer
+ * logs per-project `pulled X -> Y` / `skip ...` inline. The dry-run path KEEPS
+ * its `would overwrite:` line because `computePreview` renders those as the
+ * Projects section of `nomad diff` and the dry-run pull preview. The degenerate
+ * early-return `log(...)` (not a per-project skip) is preserved.
  *
- * `opts.dryRun` (default `false`): when `true`, log `would overwrite:` lines
- * instead of calling `backupBeforeWrite` + `copyDir`. The unmapped count is
- * computed identically in both modes.
+ * @param ts - backup timestamp namespace.
+ * @param opts.dryRun - when `true`, collect `wouldPull` and log would-overwrite.
  */
-export function remapPull(ts: string, opts: { dryRun?: boolean } = {}): { unmapped: number } {
+export function remapPull(
+  ts: string,
+  opts: { dryRun?: boolean } = {},
+): { unmapped: number; pulled: string[]; wouldPull: string[] } {
   const dryRun = opts.dryRun === true;
   let unmapped = 0;
+  const pulled: string[] = [];
+  const wouldPull: string[] = [];
   const mapPath = join(REPO_HOME, 'path-map.json');
   const repoProjects = join(REPO_HOME, 'shared', 'projects');
   if (!existsSync(mapPath) || !existsSync(repoProjects)) {
     log('no path-map or repo projects dir; skipping session remap');
-    return { unmapped: 0 };
+    return { unmapped: 0, pulled, wouldPull };
   }
 
   const map = readJson<PathMap>(mapPath);
@@ -73,29 +82,28 @@ export function remapPull(ts: string, opts: { dryRun?: boolean } = {}): { unmapp
 
   for (const [logical, hosts] of Object.entries(map.projects)) {
     const localPath = hosts[HOST];
-    if (localPath === 'TBD') {
+    if (!localPath || localPath === 'TBD') {
       unmapped++;
-      log(`skip ${logical}: placeholder path for ${HOST}`);
-      continue;
-    }
-    if (!localPath) {
-      unmapped++;
-      log(`skip ${logical}: no path for ${HOST}`);
       continue;
     }
     const src = join(repoProjects, logical);
     if (!existsSync(src)) continue;
     const dst = join(localProjects, encodePath(localPath));
     if (dryRun) {
+      // KEEP this would-overwrite log: computePreview (backing both `nomad
+      // diff` and the dry-run pull preview) renders these lines as its
+      // Projects section, so removing them regresses that output. The grouped
+      // tree is built only on the WET path, which consumes `pulled` instead.
+      wouldPull.push(logical);
       log(`would overwrite: ${dst} (from ${src})`);
       continue;
     }
     // Snapshot prior encoded-path-dir state BEFORE copyDir overwrites it.
     backupBeforeWrite(dst, ts);
     copyDir(src, dst);
-    log(`pulled ${logical} -> ${encodePath(localPath)}`);
+    pulled.push(logical);
   }
-  return { unmapped };
+  return { unmapped, pulled, wouldPull };
 }
 
 /**
@@ -156,20 +164,32 @@ function buildReverseMap(map: PathMap): Map<string, string> {
  * refuse the push before any `shared/projects/` content is written. Detection
  * runs during the reverse-map build, so it fires under `dryRun` too.
  *
- * `opts.dryRun` (default `false`): when `true`, log `would push:` lines
- * instead of calling `backupRepoWrite` + `copyDir`. Collision detection
- * runs identically in both modes.
+ * `opts.dryRun` (default `false`): when `true`, collect `wouldPush` without
+ * calling `backupRepoWrite` + `copyDir`. Collision detection runs identically
+ * in both modes.
+ *
+ * Returns `pushed` (logical names actually copied, wet mode) and `wouldPush`
+ * (logical names under `dryRun`) alongside the counts so cmdPush can render a
+ * grouped tree. This function no longer logs per-project `pushed X -> Y` /
+ * `skip ... not in path-map` / `would push:` lines inline; the
+ * `copyDirJsonlOnly` extension-skip log is a separate file-filter concern and
+ * is preserved, as are the degenerate early-return `log(...)` lines.
+ *
+ * @param ts - backup timestamp namespace.
+ * @param opts.dryRun - when `true`, collect `wouldPush` without mutating.
  */
 export function remapPush(
   ts: string,
   opts: { dryRun?: boolean } = {},
-): { unmapped: number; collisions: number } {
+): { unmapped: number; collisions: number; pushed: string[]; wouldPush: string[] } {
   const dryRun = opts.dryRun === true;
   let unmapped = 0;
+  const pushed: string[] = [];
+  const wouldPush: string[] = [];
   const mapPath = join(REPO_HOME, 'path-map.json');
   if (!existsSync(mapPath)) {
     log('no path-map.json; skipping session export');
-    return { unmapped: 0, collisions: 0 };
+    return { unmapped: 0, collisions: 0, pushed, wouldPush };
   }
 
   const map = readJson<PathMap>(mapPath);
@@ -177,7 +197,7 @@ export function remapPush(
   const repoProjects = join(REPO_HOME, 'shared', 'projects');
 
   const reverse = buildReverseMap(map);
-  if (!existsSync(localProjects)) return { unmapped, collisions: 0 };
+  if (!existsSync(localProjects)) return { unmapped, collisions: 0, pushed, wouldPush };
   // Create the repo destination only after collision detection passes and we
   // know there is something to push, so a failing or no-op push is fully
   // side-effect-free (no empty shared/projects/ left behind).
@@ -187,12 +207,11 @@ export function remapPush(
     const logical = reverse.get(dir);
     if (!logical) {
       unmapped++;
-      log(`skip ${dir}: not in path-map for ${HOST}`);
       continue;
     }
     const repoDst = join(repoProjects, logical);
     if (dryRun) {
-      log(`would push: ${dir} -> ${logical}`);
+      wouldPush.push(logical);
       continue;
     }
     // Snapshot repo-side destination before copyDir clobbers it. Git
@@ -201,7 +220,7 @@ export function remapPush(
     // path. Symmetric with remapPull's backupBeforeWrite on the local dst.
     backupRepoWrite(repoDst, ts, REPO_HOME);
     copyDirJsonlOnly(join(localProjects, dir), repoDst);
-    log(`pushed ${dir} -> ${logical}`);
+    pushed.push(logical);
   }
-  return { unmapped, collisions: 0 };
+  return { unmapped, collisions: 0, pushed, wouldPush };
 }

package/src/summary.ts

@@ -1,51 +1,99 @@
+import { green, okGlyph, warnGlyph, yellow } from './color.ts';
 import { ok, warn } from './utils.ts';
 
 /**
- * Emit the single end-of-run summary line shared by cmdPull, cmdPush, and
- * cmdDiff. Canonical phrasing:
+ * Pure phrasing core for the end-of-run summary line shared by cmdPull,
+ * cmdPush, and cmdDiff. Returns the message `text` (without any status glyph)
+ * plus a `clean` flag so callers can pick the right glyph/stream. Canonical
+ * phrasing:
  *   - `summary: clean` when nothing was unmapped (and, for push, no
- *     collisions or extras skipped). Always printed so users see a consistent
- *     terminator and can spot when behavior changes.
+ *     collisions or extras skipped).
  *   - `summary: <N> unmapped on pull (run nomad doctor to list)`
  *   - `summary: <N> unmapped on pull, <X> extras skipped (run nomad doctor to list)`
  *   - `summary: <N> unmapped on diff (run nomad doctor to list)`
  *   - `summary: <N> unmapped on push, <M> collisions (run nomad doctor to list)`
  *   - `summary: <N> unmapped on push, <M> collisions, <X> extras skipped (run nomad doctor to list)`
  *
- * Clean outcomes go through `ok()` (green `✓` glyph, stdout) and unmapped /
- * collision / extras-skipped outcomes go through `warn()` (yellow `⚠︎` glyph,
- * stderr). The status glyph carries the success/warn semantics; users see e.g.
- * `✓ summary: clean` or `⚠︎ summary: 3 unmapped on pull (...)`. Note: clean
- * still goes to stdout so it survives backgrounded shell-rc invocations
- * like `nomad pull 2>/dev/null &`. `collisions` is meaningful only for
- * `'push'`; for `'pull'` / `'diff'` it is ignored and defaults to 0.
- * `extrasSkipped` counts dirnames that the per-project whitelist
- * (`SUPPORTED_EXTRAS`) declined to sync; surfaces from `remapExtrasPush`
- * and `remapExtrasPull`. The fourth positional parameter defaults to 0 so
- * legacy three-arg call sites continue to work unchanged (D-03 additive
- * contract). This module is the SINGLE source of truth for the phrasing,
- * eliminating drift risk across the three callers by construction.
+ * `collisions` is meaningful only for `'push'`; for `'pull'` / `'diff'` it is
+ * ignored and defaults to 0. `extrasSkipped` counts dirnames that the
+ * per-project whitelist (`SUPPORTED_EXTRAS`) declined to sync. This function is
+ * the SINGLE source of truth for the phrasing, so `emitSummary` (standalone
+ * line) and `summaryRow` (tree row) cannot drift apart.
+ *
+ * @param verb - the originating command.
+ * @param unmapped - count of path-map entries skipped for this host.
+ * @param collisions - push-only collision count (ignored for pull/diff).
+ * @param extrasSkipped - count of extras dirnames the whitelist declined.
+ * @returns `{ text, clean }` where `clean` is true on the no-warning outcome.
  */
-export function emitSummary(
+export function summaryText(
   verb: 'pull' | 'push' | 'diff',
   unmapped: number,
   collisions = 0,
   extrasSkipped = 0,
-): void {
+): { text: string; clean: boolean } {
+  const extras = extrasSkipped > 0 ? `, ${extrasSkipped} extras skipped` : '';
   if (verb === 'push') {
     if (unmapped === 0 && collisions === 0 && extrasSkipped === 0) {
-      ok('summary: clean');
-      return;
+      return { text: 'summary: clean', clean: true };
     }
     const base = `summary: ${unmapped} unmapped on push, ${collisions} collisions`;
-    const extras = extrasSkipped > 0 ? `, ${extrasSkipped} extras skipped` : '';
-    warn(`${base}${extras} (run nomad doctor to list)`);
-    return;
+    return { text: `${base}${extras} (run nomad doctor to list)`, clean: false };
   }
   if (unmapped === 0 && extrasSkipped === 0) {
-    ok('summary: clean');
+    return { text: 'summary: clean', clean: true };
+  }
+  return {
+    text: `summary: ${unmapped} unmapped on ${verb}${extras} (run nomad doctor to list)`,
+    clean: false,
+  };
+}
+
+/**
+ * Build the fully-rendered Summary-section row (status glyph embedded) for the
+ * grouped push/pull tree. Delegates phrasing to `summaryText` so the row text
+ * matches `emitSummary` byte-for-byte. A clean outcome renders
+ * `${green(okGlyph)} <text>`; any warning outcome renders
+ * `${yellow(warnGlyph)} <text>`.
+ *
+ * @param verb - the originating command.
+ * @param unmapped - count of path-map entries skipped for this host.
+ * @param collisions - push-only collision count (ignored for pull/diff).
+ * @param extrasSkipped - count of extras dirnames the whitelist declined.
+ * @returns the rendered row string for the Summary section.
+ */
+export function summaryRow(
+  verb: 'pull' | 'push' | 'diff',
+  unmapped: number,
+  collisions = 0,
+  extrasSkipped = 0,
+): string {
+  const { text, clean } = summaryText(verb, unmapped, collisions, extrasSkipped);
+  return clean ? `${green(okGlyph)} ${text}` : `${yellow(warnGlyph)} ${text}`;
+}
+
+/**
+ * Emit the single end-of-run summary line shared by cmdPull, cmdPush, and
+ * cmdDiff. Delegates phrasing to `summaryText` so the wording cannot drift from
+ * `summaryRow`. Clean outcomes go through `ok()` (green `✓` glyph, stdout) and
+ * unmapped / collision / extras-skipped outcomes go through `warn()` (yellow
+ * `⚠︎` glyph, stderr). The status glyph carries the success/warn semantics;
+ * users see e.g. `✓ summary: clean` or `⚠︎ summary: 3 unmapped on pull (...)`.
+ * Clean still goes to stdout so it survives backgrounded shell-rc invocations
+ * like `nomad pull 2>/dev/null &`. The fourth positional parameter defaults to
+ * 0 so legacy three-arg call sites continue to work unchanged (D-03 additive
+ * contract). `cmdDiff` still calls this for its standalone summary line.
+ */
+export function emitSummary(
+  verb: 'pull' | 'push' | 'diff',
+  unmapped: number,
+  collisions = 0,
+  extrasSkipped = 0,
+): void {
+  const { text, clean } = summaryText(verb, unmapped, collisions, extrasSkipped);
+  if (clean) {
+    ok(text);
     return;
   }
-  const extras = extrasSkipped > 0 ? `, ${extrasSkipped} extras skipped` : '';
-  warn(`summary: ${unmapped} unmapped on ${verb}${extras} (run nomad doctor to list)`);
+  warn(text);
 }