claude-nomad 0.32.4 → 0.34.0

package/src/commands.update.test-helpers.git.ts

@@ -1,107 +0,0 @@
-/**
- * Produce git `remote -v` formatted output from a map of remote names to URLs.
- *
- * Each entry produces two lines: one with `(fetch)` and one with `(push)`.
- * `parseRemotes` only consumes `(fetch)`, but emitting production-shaped
- * output keeps the test honest against the real git CLI format.
- *
- * @param remotes - Mapping of remote name to its URL
- * @returns A `git remote -v`-style string where each remote has `(fetch)` and `(push)` lines; includes a trailing newline when there is at least one line
- */
-export function formatRemoteV(remotes: Record<string, string>): string {
-  const lines: string[] = [];
-  for (const [name, url] of Object.entries(remotes)) {
-    lines.push(`${name}\t${url} (fetch)`, `${name}\t${url} (push)`);
-  }
-  return lines.join('\n') + (lines.length > 0 ? '\n' : '');
-}
-
-/** Shape passed to `mockGit` so each test declares only the bits it cares
- * about; defaults cover the "vanilla healthy" path. */
-export type GitBehavior = {
-  remotes?: Record<string, string>;
-  branch?: string;
-  status?: string;
-  diffNames?: string;
-  pullThrows?: Error;
-  fetchThrows?: Error;
-  mergeThrows?: Error;
-  /** When set, `git rev-parse --abbrev-ref HEAD` throws this error. Used to
-   * exercise `currentBranch`'s NomadFatal-wrapping catch arm. */
-  branchThrows?: Error;
-  /** When set, `git rev-parse HEAD` throws this error. Used to exercise
-   * `headSha`'s NomadFatal-wrapping catch arm. */
-  headShaThrows?: Error;
-  /** Successive `git rev-parse HEAD` return values, consumed in order (one
-   * per call) and sticky on the last entry once exhausted. Lets a test model
-   * HEAD advancing across a merge (distinct pre/post SHAs) or staying put (a
-   * single entry, or unset for the constant default). Mutated in place. */
-  headShas?: string[];
-  /** When set, `git remote -v` throws this error. Used to exercise
-   * `loadTopology`'s NomadFatal-wrapping catch arm. */
-  remoteThrows?: Error;
-  /** Output for `git diff --name-only --diff-filter=U`: newline-separated
-   * unmerged paths after a failed merge. Empty/unset = no unmerged paths. */
-  unmergedPaths?: string;
-  /** When set, `git diff --name-only --diff-filter=U` throws this error.
-   * Used to verify the auto-resolve probe degrades gracefully and the
-   * original merge failure surfaces instead of a probe exception. */
-  diffThrows?: Error;
-};
-
-/** Per-command handler: returns the canned output (or throws the configured
- * error). Each handler is keyed by `git ${args[0]}` or `npm ${args[0]}` for
- * dispatch via a table, which keeps `mockGit`'s `execFileSync` body flat. */
-type Handler = (behavior: GitBehavior, args: readonly string[]) => Buffer;
-
-/** Dispatch table consumed by `mockGit`: maps `${bin} ${args[0]}` to the
- * handler that returns the canned git/npm output (or throws). Extracted from
- * the helper module so `mockGit` stays under the line cap. */
-export const HANDLERS: Record<string, Handler> = {
-  'git remote': (b, args) => {
-    if (args[1] !== '-v') throw new Error(`unhandled: git remote ${args.join(' ')}`);
-    if (b.remoteThrows !== undefined) throw b.remoteThrows;
-    return Buffer.from(formatRemoteV(b.remotes ?? {}));
-  },
-  'git rev-parse': (b, args) => {
-    if (args[1] === '--abbrev-ref') {
-      if (b.branchThrows !== undefined) throw b.branchThrows;
-      return Buffer.from((b.branch ?? 'main') + '\n');
-    }
-    if (args[1] === 'HEAD') {
-      if (b.headShaThrows !== undefined) throw b.headShaThrows;
-      const seq = b.headShas;
-      if (seq !== undefined && seq.length > 0) {
-        const next = seq.length > 1 ? seq.shift()! : seq[0];
-        return Buffer.from(next + '\n');
-      }
-      return Buffer.from('0123456789abcdef0123456789abcdef01234567\n');
-    }
-    throw new Error(`unhandled: git rev-parse ${args.join(' ')}`);
-  },
-  'git status': (b) => Buffer.from(b.status ?? ''),
-  'git pull': (b) => {
-    if (b.pullThrows !== undefined) throw b.pullThrows;
-    return Buffer.from('');
-  },
-  'git fetch': (b) => {
-    if (b.fetchThrows !== undefined) throw b.fetchThrows;
-    return Buffer.from('');
-  },
-  'git merge': (b) => {
-    if (b.mergeThrows !== undefined) throw b.mergeThrows;
-    return Buffer.from('');
-  },
-  'git push': () => Buffer.from(''),
-  'git diff': (b, args) => {
-    if (args.includes('--diff-filter=U')) {
-      if (b.diffThrows !== undefined) throw b.diffThrows;
-      return Buffer.from(b.unmergedPaths ?? '');
-    }
-    return Buffer.from(b.diffNames ?? '');
-  },
-  'git checkout': () => Buffer.from(''),
-  'git add': () => Buffer.from(''),
-  'git commit': () => Buffer.from(''),
-  'npm install': () => Buffer.from(''),
-};

package/src/update.fork-extras.ts

@@ -1,102 +0,0 @@
-import { execFileSync } from 'node:child_process';
-import { existsSync } from 'node:fs';
-import { join } from 'node:path';
-
-import { REPO_HOME } from './config.ts';
-import { whitelistedExtrasPaths } from './extras-sync.ts';
-import { gitOrFatal, log } from './utils.ts';
-import { readPathMap } from './utils.json.ts';
-
-/**
- * Pre-commit whitelisted extras before a fork merge so an untracked-overwrite
- * abort becomes a tracked-file merge (issue #112).
- *
- * When a fork host has untracked `shared/extras/<logical>/<dirname>/` content
- * that `upstream/main` also introduces, `git merge upstream/main` aborts
- * before creating any merge state ("untracked working tree files would be
- * overwritten by merge"). No `UU` is recorded, so the lone-lockfile
- * auto-resolve never fires and the merge surfaces as an opaque failure.
- * Staging alone is insufficient (git still refuses to overwrite staged-but-
- * uncommitted local changes); the overlap must be a committed tracked path so
- * the merge engine treats it as a content merge. After this commit, identical
- * extras merge cleanly (the normal sync case, leaving the lone `UU
- * package-lock.json` the existing auto-resolve handles) and divergent extras
- * surface a real, resolvable conflict instead of the abort.
- *
- * Scoped strictly to the whitelisted `shared/extras/` paths declared in
- * `path-map.json`; never a blanket `git add -A`. No-op when there is no
- * `path-map.json`, no declared extras, or none of the declared extras paths
- * exist on disk, and when staging produces no index change (nothing dirty).
- */
-export function precommitForkExtras(): void {
-  const mapPath = join(REPO_HOME, 'path-map.json');
-  if (!existsSync(mapPath)) return;
-  const map = readPathMap(mapPath);
-  const candidates = whitelistedExtrasPaths(map).filter((p) => existsSync(join(REPO_HOME, p)));
-  if (candidates.length === 0) return;
-
-  gitOrFatal(['add', '--', ...candidates], 'git add extras', REPO_HOME);
-  // Only commit when staging actually changed the index. The probe and commit
-  // are BOTH path-scoped to the extras candidates so an unrelated staged change
-  // present before update neither flips the dirty probe nor rides along in the
-  // commit. `git diff --cached --quiet -- <candidates>` exits 0 when those paths
-  // match HEAD (nothing to commit), 1 when they differ; avoids an empty-commit
-  // failure when the extras were already tracked and unmodified.
-  let dirty = false;
-  try {
-    execFileSync('git', ['diff', '--cached', '--quiet', '--', ...candidates], {
-      cwd: REPO_HOME,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-  } catch {
-    dirty = true;
-  }
-  if (!dirty) return;
-  gitOrFatal(
-    ['commit', '-m', 'chore: stage local extras before upstream merge', '--', ...candidates],
-    'git commit extras',
-    REPO_HOME,
-  );
-  log(`staged local extras before merge: ${candidates.join(', ')}`);
-}
-
-/**
- * After a successful fork merge, commit a `package-lock.json` that `npm
- * install` regenerated and left uncommitted (secondary item of issue #112).
- *
- * The post-merge reinstall (`reinstallIfNeeded`) can rewrite the lockfile
- * when the merge changed dependencies, leaving working-tree drift that the
- * trailing `nomad doctor` reports as "uncommitted changes". This stages and
- * commits ONLY `package-lock.json` so the repo is clean after update. No-op
- * when the lockfile is absent or unchanged (the `git diff --quiet` probe
- * exits 0). Tightly scoped: never touches any other path.
- */
-export function commitRegeneratedLockfile(): void {
-  const lockfile = join(REPO_HOME, 'package-lock.json');
-  if (!existsSync(lockfile)) return;
-  // `git diff --quiet -- package-lock.json` exits 0 when the working tree
-  // matches HEAD (no drift to commit), 1 when it differs.
-  let drifted = false;
-  try {
-    execFileSync('git', ['diff', '--quiet', '--', 'package-lock.json'], {
-      cwd: REPO_HOME,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    });
-  } catch {
-    drifted = true;
-  }
-  if (!drifted) return;
-  gitOrFatal(['add', '--', 'package-lock.json'], 'git add package-lock.json', REPO_HOME);
-  gitOrFatal(
-    [
-      'commit',
-      '-m',
-      'chore: commit regenerated package-lock.json after update',
-      '--',
-      'package-lock.json',
-    ],
-    'git commit package-lock.json',
-    REPO_HOME,
-  );
-  log('committed regenerated package-lock.json after update');
-}

package/src/update.topology.ts

@@ -1,118 +0,0 @@
-import { execFileSync } from 'node:child_process';
-
-import { REPO_HOME, UPSTREAM_REPO_SLUG } from './config.ts';
-import { NomadFatal } from './utils.ts';
-
-/**
- * Topology label resolved by `detectTopology`. `vanilla` is a single `origin`
- * remote pointing at the public repo (read-only consumer). `fork` is the
- * private-config layout: `upstream` is the public repo and `origin` is the
- * user's private mirror. `unknown` is anything else: no `upstream`, an
- * `origin` that does not match the public repo, etc. Unknown topologies
- * surface a fatal so the user can run the two-command manual fallback
- * without nomad guessing at intent.
- */
-export type Topology = 'vanilla' | 'fork' | 'unknown';
-
-/** Escape regex metacharacters so a config value with `.` or `+` interpolated
- * into a `new RegExp(...)` does not silently broaden the match. The current
- * slug has no metachars, but this keeps the call defensible if it changes. */
-function escapeRe(s: string): string {
-  return s.replace(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
-}
-
-/**
- * Strict patterns matching the public repo's SSH and HTTPS remote URL forms,
- * with and without a `.git` suffix. Both `git remote add upstream ...` styles
- * (set-url ssh, gh-clone https) must round-trip through `detectTopology`.
- */
-const SLUG_RE = escapeRe(UPSTREAM_REPO_SLUG);
-const SSH_REGEX = new RegExp(String.raw`^git@github\.com:${SLUG_RE}(\.git)?$`);
-const HTTPS_REGEX = new RegExp(String.raw`^https://github\.com/${SLUG_RE}(\.git)?$`);
-
-/**
- * Determines whether a remote URL matches the canonical upstream repository forms (SSH or HTTPS).
- *
- * @param url - The remote URL to test
- * @returns `true` if `url` matches the canonical upstream SSH or HTTPS form, `false` otherwise.
- */
-function matchesUpstream(url: string): boolean {
-  return SSH_REGEX.test(url) || HTTPS_REGEX.test(url);
-}
-
-/**
- * Parse the output of `git remote -v` into a mapping of remote names to their fetch URLs.
- *
- * Ignores `(push)` entries because topology detection drives the
- * `git pull`/`fetch`/`merge` invocations, which all use the fetch URL.
- * Lines that do not match the expected `<name> <url> (fetch)` format are
- * skipped.
- *
- * @param out - Raw stdout from `git remote -v`
- * @returns A record mapping each remote name to its fetch URL
- */
-export function parseRemotes(out: string): Record<string, string> {
-  const remotes: Record<string, string> = {};
-  for (const line of out.split('\n')) {
-    const trimmed = line.trim();
-    if (trimmed === '') continue;
-    const match = /^(\S+)\s+(\S+)\s+\(fetch\)$/.exec(trimmed);
-    if (match === null) continue;
-    remotes[match[1]] = match[2];
-  }
-  return remotes;
-}
-
-/**
- * Classify a parsed `{ name: fetchUrl }` remote map into a topology label.
- *
- * Classification rules:
- * - `vanilla` — exactly one remote named `origin` matching the public repo.
- * - `fork` — an `upstream` matching the public repo and a separate `origin`
- *   (any URL).
- * - `unknown` — anything else (no `upstream`, an `origin` that does not
- *   match the public repo, etc.).
- *
- * Pure and side-effect-free; tests drive it directly with hand-built maps.
- *
- * @param remotes - Map of remote name -> fetch URL produced by `parseRemotes`.
- * @returns The resolved `Topology` label.
- */
-export function detectTopology(remotes: Record<string, string>): Topology {
-  const origin = remotes.origin;
-  const upstream = remotes.upstream;
-  if (typeof upstream === 'string' && matchesUpstream(upstream) && typeof origin === 'string') {
-    return 'fork';
-  }
-  const names = Object.keys(remotes);
-  if (names.length === 1 && names[0] === 'origin' && matchesUpstream(origin ?? '')) {
-    return 'vanilla';
-  }
-  return 'unknown';
-}
-
-/**
- * Detect the repository remote topology by running `git remote -v` in REPO_HOME
- * and routing the output through `parseRemotes` + `detectTopology`.
- *
- * `git remote -v` is read-only so failures here are unexpected; we still
- * route through `NomadFatal` so the dispatcher prints ``✗ ...``
- * rather than dumping a stack trace.
- *
- * @returns The detected topology label: `'vanilla'`, `'fork'`, or `'unknown'`.
- * @throws NomadFatal when `git remote -v` fails; any captured git stderr is written to `process.stderr` before the error is thrown.
- */
-export function loadTopology(): Topology {
-  let out: string;
-  try {
-    out = execFileSync('git', ['remote', '-v'], {
-      cwd: REPO_HOME,
-      stdio: ['ignore', 'pipe', 'pipe'],
-    }).toString();
-  } catch (err) {
-    const e = err as Error & { stderr?: Buffer };
-    if (e.stderr) process.stderr.write(e.stderr);
-    throw new NomadFatal('git remote -v failed');
-  }
-  return detectTopology(parseRemotes(out));
-}