@fnclaude/cli 0.7.2 → 0.7.4

package/src/pty.ts

@@ -57,18 +57,24 @@ export class RingBuffer {
   write(p: Buffer | Uint8Array | string): void {
     const data = typeof p === 'string' ? Buffer.from(p) : Buffer.from(p);
     if (data.length === 0) return;
-    // Hot path for small writes: per-byte loop matches Go's reference impl.
-    // For large writes (> cap) skip ahead so we don't churn over discarded
-    // bytes that will immediately be overwritten.
-    let start = 0;
+    // For oversize writes (> cap) skip ahead — the prefix we'd write would
+    // be immediately overwritten by the suffix. Land on a clean state where
+    // pos = 0, full = true, and we copy the trailing `cap` bytes in one go.
+    let src = 0;
     if (data.length > this.cap) {
-      start = data.length - this.cap;
+      src = data.length - this.cap;
       this.full = true;
       this.pos = 0;
     }
-    for (let i = start; i < data.length; i++) {
-      this.buf[this.pos] = data[i] as number;
-      this.pos = (this.pos + 1) % this.cap;
+    // Copy in up to two chunks: from src to end-of-buf, then wrapped around
+    // from start-of-buf for the remainder. `Buffer.copy` is a memcpy under
+    // the hood — substantially cheaper than the per-byte assignment loop
+    // this replaces, for the same final buffer state.
+    while (src < data.length) {
+      const writable = Math.min(data.length - src, this.cap - this.pos);
+      data.copy(this.buf, this.pos, src, src + writable);
+      src += writable;
+      this.pos = (this.pos + writable) % this.cap;
       if (this.pos === 0) this.full = true;
     }
   }
@@ -117,16 +123,17 @@ export interface CrossCwdMatch {
  * the LAST match wins.
  */
 export function detectCrossCwd(tail: Buffer): CrossCwdMatch | null {
-  // Reset regex internal state — crossCwdRe is `g`-flagged.
-  crossCwdRe.lastIndex = 0;
   // Decode as Latin-1 so every byte maps to a code unit; the regex matches
   // ASCII anchors so the multi-byte representation of any non-ASCII bytes
   // never participates in a match. This is the JS equivalent of Go's
   // []byte-scanning behavior.
   const s = tail.toString('latin1');
-  let last: RegExpExecArray | null = null;
-  // biome-ignore lint/suspicious/noAssignInExpressions: standard regex loop
-  for (let m: RegExpExecArray | null; (m = crossCwdRe.exec(s)) !== null; ) {
+  // matchAll iterates from a fresh internal cursor each call — no
+  // module-level `lastIndex` to reset. The exported `crossCwdRe` stays
+  // `g`-flagged (matchAll requires it) but is only ever consumed as an
+  // anchor for tests / the source-of-truth comparison.
+  let last: RegExpMatchArray | null = null;
+  for (const m of s.matchAll(crossCwdRe)) {
     last = m;
   }
   if (last === null) return null;

package/src/repoSettings.ts

@@ -38,6 +38,17 @@ function home(): string {
   return process.env.HOME ?? homedir();
 }
 
+/**
+ * Result of a repo-settings load: the merged settings plus any non-fatal
+ * warnings (e.g. malformed JSON files that were skipped). Mirrors
+ * `LoadConfigResult` so the caller can thread warnings into the deferred
+ * flush.
+ */
+export interface LoadRepoSettingsResult {
+  settings: RepoSettings;
+  warnings: readonly string[];
+}
+
 /**
  * Resolve the four-tier merge for the user's environment.
  * `projectRoot` is the cwd Claude Code anchors project/local tiers
@@ -46,7 +57,7 @@ function home(): string {
 export function loadRepoSettings(
   homeDir: string,
   projectRoot: string,
-): RepoSettings {
+): LoadRepoSettingsResult {
   const paths: string[] = [
     join(homeDir, '.claude', 'settings.json'), // user
     join(projectRoot, '.claude', 'settings.json'), // project
@@ -59,13 +70,17 @@ export function loadRepoSettings(
 
 /**
  * Read each path (if it exists) and merge per-field with later entries
- * winning over earlier ones. Missing or malformed files are silently
- * skipped — same fail-soft posture as the plugin.
+ * winning over earlier ones. Missing files are silently skipped (the
+ * fail-soft posture the plugin matches); malformed files produce a
+ * warning so the user can fix them rather than wondering why their
+ * settings don't apply.
  */
-export function mergeRepoSettings(paths: string[]): RepoSettings {
+export function mergeRepoSettings(paths: string[]): LoadRepoSettingsResult {
   const merged: RepoSettings = {};
+  const warnings: string[] = [];
   for (const p of paths) {
-    const f = readRepoSettings(p);
+    const { settings: f, warning } = readRepoSettings(p);
+    if (warning !== null) warnings.push(warning);
     if (!f) continue;
     // Shallow-merge per field: only overwrite when the higher tier sets
     // a non-empty value.
@@ -74,23 +89,32 @@ export function mergeRepoSettings(paths: string[]): RepoSettings {
     if (f.branchTemplate) merged.branchTemplate = f.branchTemplate;
     if (f.gateEnvVar) merged.gateEnvVar = f.gateEnvVar;
   }
-  return merged;
+  return { settings: merged, warnings };
 }
 
-function readRepoSettings(path: string): RepoSettings | null {
+interface ReadRepoSettingsResult {
+  settings: RepoSettings | null;
+  warning: string | null;
+}
+
+function readRepoSettings(path: string): ReadRepoSettingsResult {
   let data: string;
   try {
     data = readFileSync(path, 'utf8');
   } catch {
-    return null;
+    // Missing file is the common path — stay silent.
+    return { settings: null, warning: null };
   }
   let f: SettingsFile;
   try {
     f = JSON.parse(data) as SettingsFile;
-  } catch {
-    return null;
+  } catch (err) {
+    return {
+      settings: null,
+      warning: `fnclaude: repo-settings file ${path} is malformed, skipping: ${(err as Error).message}`,
+    };
   }
-  return f.repoSettings ?? null;
+  return { settings: f.repoSettings ?? null, warning: null };
 }
 
 /**

package/src/sessionState.ts

@@ -3,7 +3,8 @@
 // CWD encoding for Claude Code's project dir naming scheme, and JSONL
 // permission-mode last-wins scan over a session log.
 
-import { readFileSync } from 'node:fs';
+import { appendFileSync, readFileSync } from 'node:fs';
+import { randomUUID } from 'node:crypto';
 import { homedir } from 'node:os';
 import { join } from 'node:path';
 
@@ -92,3 +93,126 @@ export function readLivePermissionMode(
   }
   return latest;
 }
+
+/**
+ * Overrides that may have landed alongside the restart. When any of these
+ * are set the appended reminder names them so the resumed model can briefly
+ * acknowledge the change before continuing the pre-restart work.
+ */
+export interface RestartReminderOverrides {
+  model?: string;
+  effort?: string;
+  permissionMode?: string;
+  agent?: string;
+  /** True iff `--ide` is being added on the relaunch. */
+  ide?: boolean;
+}
+
+/**
+ * Read the trailing entries of `data` and return the most recent `uuid`
+ * field, or `null` if none found. Used to link the appended reminder into
+ * the JSONL parent-chain.
+ */
+function lastEntryUUID(data: string): string | null {
+  const lines = data.split('\n');
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i];
+    if (!line || line.length === 0) continue;
+    let parsed: { uuid?: unknown };
+    try {
+      parsed = JSON.parse(line) as typeof parsed;
+    } catch {
+      continue;
+    }
+    if (typeof parsed.uuid === 'string' && parsed.uuid.length > 0) {
+      return parsed.uuid;
+    }
+  }
+  return null;
+}
+
+/** Render the system-reminder body text, optionally naming overrides. */
+export function renderRestartReminderContent(
+  overrides?: RestartReminderOverrides,
+): string {
+  const parts: string[] = [];
+  if (overrides?.model && overrides.model !== '') {
+    parts.push(`model swap to ${overrides.model}`);
+  }
+  if (overrides?.effort && overrides.effort !== '') {
+    parts.push(`effort=${overrides.effort}`);
+  }
+  if (overrides?.permissionMode && overrides.permissionMode !== '') {
+    parts.push(`permission-mode=${overrides.permissionMode}`);
+  }
+  if (overrides?.agent && overrides.agent !== '') {
+    parts.push(`agent=${overrides.agent}`);
+  }
+  if (overrides?.ide) {
+    parts.push('--ide connected');
+  }
+  const overrideClause =
+    parts.length > 0
+      ? ` Restart-specific overrides applied: ${parts.join(', ')} — acknowledge briefly, then continue.`
+      : '';
+  return (
+    '<system-reminder>\n' +
+    'This session was restarted via fnc_restart (all prior context and the ' +
+    'session JSONL are preserved). Resume the work that was in flight ' +
+    'before the restart — finish the task, monitor what you were ' +
+    'monitoring, surface results — rather than treating this as a fresh ' +
+    'session.' +
+    overrideClause +
+    '\n</system-reminder>'
+  );
+}
+
+/**
+ * Append an `isMeta:true` user-message bearing a `<system-reminder>` block
+ * to the session JSONL at `launchCWD` / `sessionID`. Best-effort: missing
+ * or unreadable JSONL is silently tolerated (the restart should still
+ * proceed; the reminder is a UX nicety, not a hard requirement).
+ *
+ * Shape matches the entries Claude Code itself emits for inline reminders
+ * — `type:"user"`, `message:{role:"user",content:"<system-reminder>…</system-reminder>"}`,
+ * `isMeta:true`. The `parentUuid` is linked to the most recent entry's
+ * `uuid` so the resumed session reads it as a fresh terminal user turn.
+ */
+export function appendRestartReminder(
+  launchCWD: string,
+  sessionID: string,
+  overrides?: RestartReminderOverrides,
+): void {
+  const path = sessionJSONLPath(launchCWD, sessionID);
+  let existing: string;
+  try {
+    existing = readFileSync(path, 'utf8');
+  } catch {
+    // No JSONL — nothing to append to. The relaunched claude will start
+    // fresh anyway, so the reminder would be off-target.
+    return;
+  }
+  const parentUuid = lastEntryUUID(existing);
+  const entry = {
+    parentUuid,
+    isSidechain: false,
+    type: 'user' as const,
+    message: {
+      role: 'user' as const,
+      content: renderRestartReminderContent(overrides),
+    },
+    isMeta: true,
+    uuid: randomUUID(),
+    timestamp: new Date().toISOString(),
+    userType: 'external' as const,
+    cwd: launchCWD,
+    sessionId: sessionID,
+  };
+  try {
+    appendFileSync(path, `${JSON.stringify(entry)}\n`);
+  } catch {
+    // Best-effort — disk full, permission denied, raced unlink, etc. The
+    // restart proceeds; user gets the historical "Restarted." idle behavior
+    // rather than a hard failure.
+  }
+}

package/src/silentRelaunch.ts

@@ -18,7 +18,7 @@
 import { spawn } from 'node:child_process';
 import process from 'node:process';
 import { clearScreen, reconstructArgv } from './pty.js';
-import { selfPath } from './spawn.js';
+import { resolveSelfPath } from './paths.js';
 
 // `process.execve` is a Bun-native POSIX-only API (1.3.14+). @types/bun
 // hasn't typed it yet — declare the shape inline so TS strict mode is happy.
@@ -53,7 +53,7 @@ export function silentRelaunch(
 ): void {
   let self: string;
   try {
-    self = selfPath();
+    self = resolveSelfPath();
   } catch (err) {
     process.stderr.write(
       `fnclaude: cannot determine executable, cannot relaunch: ${(err as Error).message}\n`,
@@ -84,7 +84,7 @@ export function silentRelaunchHandoff(
 ): void {
   let self: string;
   try {
-    self = selfPath();
+    self = resolveSelfPath();
   } catch (err) {
     process.stderr.write(
       `fnclaude: cannot determine executable, cannot relaunch: ${(err as Error).message}\n`,

package/src/spawn.ts

@@ -9,10 +9,9 @@
 // The indirection via spawnFn lets tests inject a mock without launching
 // real processes.
 
-import { realpathSync } from 'node:fs';
-import { dirname } from 'node:path';
 import process from 'node:process';
 import type { Config } from './config.js';
+import { resolveSelfPath } from './paths.js';
 import { substitute } from './template.js';
 
 // ── env cleaning ───────────────────────────────────────────────────────────
@@ -39,31 +38,6 @@ export function cleanEnvForSpawn(env: string[]): string[] {
   return out;
 }
 
-// ── selfPath ───────────────────────────────────────────────────────────────
-
-/**
- * Return the absolute, symlink-resolved path to this fnclaude script,
- * suitable for `{bin}` substitution in a spawn-launcher template.
- *
- * Preference order mirrors prompts.ts (Unit 6):
- *  1. process.argv[1] — the CLI script path (anchors to the script, not the
- *     Bun interpreter).
- *  2. process.execPath — the Bun binary; fallback when argv[1] is absent.
- *
- * Symlinks are resolved so the spawned launcher gets the real path, not a
- * shim that might not be on the PATH inside the new window.
- */
-export function selfPath(): string {
-  const argv1 = process.argv.length > 1 ? process.argv[1] : undefined;
-  let exe = argv1 !== undefined && argv1 !== '' ? argv1 : process.execPath;
-  try {
-    exe = realpathSync(exe);
-  } catch {
-    // symlink resolution failure is not fatal — use the unresolved path
-  }
-  return exe;
-}
-
 // ── autoDetectSpawnCommand ─────────────────────────────────────────────────
 
 /**
@@ -162,7 +136,7 @@ export async function spawnSibling(
   extraArgs: string[],
   spawnFn: SpawnFn = defaultSpawnFn,
 ): Promise<boolean> {
-  const bin = selfPath();
+  const bin = resolveSelfPath();
 
   let tmpl = cfg.auto.spawnCommand;
   if (!tmpl) {

package/src/warnings.ts

@@ -5,46 +5,30 @@
 // scroll off-screen too fast to read; flushing on exit shows them in the
 // user's shell where they have time to actually be seen.
 //
+// There is no module-global queue here — every loader (loadConfig,
+// loadRepoSettings, loadHostAliases, loadPrompts) returns its warnings
+// alongside its result, and `main.ts` threads them into a single local
+// list that `flushWarnings` drains at the deferred-flush point. The old
+// global queue made test fixtures share state across files and forced
+// callers to know about a sink module they otherwise didn't depend on;
+// the explicit-thread shape is the fix.
+//
 // Fatal errors that prevent launch entirely (e.g. claude binary not on PATH)
 // should still print directly to stderr and exit non-zero — those don't
 // need deferring because there's no claude session about to drown them out.
 
 import process from 'node:process';
 
-const warnings: string[] = [];
-
 /**
- * Queue a non-fatal warning. Accepts a pre-formatted message (callers do
- * their own templating); printed verbatim on flush.
+ * Print each warning to `stream` on its own line. Returns the number of
+ * warnings written (useful for tests). Empty input is a no-op.
  */
-export function warn(msg: string): void {
-  warnings.push(msg);
-}
-
-/**
- * Print all queued warnings to stderr in order, then clear the queue.
- * Called from `run()` after claude exits. Returns the number of warnings
- * that were flushed (useful for tests).
- */
-export function flushWarnings(stream: NodeJS.WriteStream = process.stderr): number {
-  const n = warnings.length;
+export function flushWarnings(
+  warnings: readonly string[],
+  stream: NodeJS.WriteStream = process.stderr,
+): number {
   for (const w of warnings) {
     stream.write(`${w}\n`);
   }
-  warnings.length = 0;
-  return n;
-}
-
-/**
- * Test helper: return a snapshot of the current queue without flushing.
- */
-export function pendingWarnings(): readonly string[] {
-  return [...warnings];
-}
-
-/**
- * Test helper: clear the queue without emitting anything.
- */
-export function clearWarnings(): void {
-  warnings.length = 0;
+  return warnings.length;
 }

package/src/worktree.ts

@@ -8,14 +8,18 @@
 //     pass a GitRunner in, with `defaultGitRunner` exported for production
 //     use. Both shapes give tests deterministic control without an env or
 //     module-state assumption.
-//   - applyWorktreeIntercept mutates Args in place to match the Go signature
-//     `*Args`. This keeps the call site in run() simple: `applyWorktreeIntercept(args, cwd)`
-//     reads naturally, and Args is a single-owner container at that point in
-//     the lifecycle — no aliasing concerns.
+//   - applyWorktreeIntercept is a pure stage transition: takes a
+//     `ResolvedArgs`, returns an `InterceptedArgs` that carries the new
+//     `worktreeMatched` invariant. The cwd / passthrough overrides flow
+//     through `withIntercepted`; nothing is mutated in place.
 
-import { execFileSync } from 'node:child_process';
 import { isAbsolute, join } from 'node:path';
-import type { Args } from './args.js';
+import {
+  withIntercepted,
+  type InterceptedArgs,
+  type ResolvedArgs,
+} from './args.js';
+import { nameInPassthrough } from './passthrough.js';
 
 /**
  * GitRunner is a thin wrapper around `git -C <dir> <args...>`. Returns the
@@ -26,14 +30,30 @@ import type { Args } from './args.js';
 export type GitRunner = (dir: string, ...args: string[]) => string;
 
 /**
- * Production GitRunner. Spawns git synchronously (same shape as Go's
- * `exec.Command(...).Output()` posture in the reference).
+ * Production GitRunner. Spawns git synchronously via Bun.spawnSync — same
+ * mechanism the rest of the codebase uses for its child-process work
+ * (autoname, resolver, clipboard, spawn). Node's `execFileSync` here was
+ * the lone holdout; switching unifies the spawn layer.
+ *
+ * Behaviour preserved from the prior `execFileSync` version:
+ *   - On a successful run (exit 0), returns the UTF-8-decoded stdout.
+ *   - On non-zero exit, throws an Error with the git stderr verbatim —
+ *     callers (listWorktrees) catch any thrown value and treat it as
+ *     "no match possible", so the exact shape of the error doesn't matter
+ *     beyond being throwable.
+ *   - If `git` isn't on PATH, Bun.spawnSync throws ENOENT itself (same
+ *     posture as execFileSync did).
  */
 export const defaultGitRunner: GitRunner = (dir, ...args) => {
-  return execFileSync('git', ['-C', dir, ...args], {
-    encoding: 'utf8',
-    stdio: ['ignore', 'pipe', 'pipe'],
+  const proc = Bun.spawnSync(['git', '-C', dir, ...args], {
+    stdout: 'pipe',
+    stderr: 'pipe',
   });
+  if (proc.exitCode !== 0) {
+    const stderr = proc.stderr?.toString('utf8') ?? '';
+    throw new Error(`git -C ${dir} ${args.join(' ')} exited ${proc.exitCode}: ${stderr.trim()}`);
+  }
+  return proc.stdout?.toString('utf8') ?? '';
 };
 
 /**
@@ -127,30 +147,37 @@ function basename(p: string): string {
 }
 
 /**
- * applyWorktreeIntercept applies the -w / --worktree intercept logic to a.
- * It may modify a.cwd, a.passthrough, and a.worktreeMatched in place.
+ * applyWorktreeIntercept applies the -w / --worktree intercept logic.
+ *
+ * Pure function: takes a `ResolvedArgs`, returns a new `InterceptedArgs`.
+ * No input is mutated. The four cases:
  *
- *   1. worktreeSet=false → no-op.
- *   2. Bare -w (worktreeArg="") → push --worktree through unchanged.
- *   3. Existing worktree matched → swap a.cwd to the worktree, set
+ *   1. worktreeSet=false → carry through with worktreeMatched=false.
+ *   2. Bare -w (worktreeArg="") → append --worktree to passthrough,
+ *      worktreeMatched=false.
+ *   3. Existing worktree matched → swap cwd to the worktree path, set
  *      worktreeMatched=true, suppress --worktree.
- *   4. Otherwise → push --worktree <name> through, plus --name <name>
- *      (when --name isn't already set).
+ *   4. Otherwise → append --worktree <name>, plus --name <name> when
+ *      --name isn't already set; worktreeMatched=false.
  *
  * `shellCWD` is the process working directory at fnclaude startup, used
- * to resolve a relative a.cwd to an absolute path before querying git.
+ * to resolve a relative `cwd` to an absolute path before querying git.
  */
 export function applyWorktreeIntercept(
-  a: Args,
+  a: ResolvedArgs,
   shellCWD: string,
   runner: GitRunner = defaultGitRunner,
-): void {
-  if (!a.worktreeSet) return;
+): InterceptedArgs {
+  if (!a.worktreeSet) {
+    return withIntercepted(a, { worktreeMatched: false });
+  }
 
   // Bare -w with no name: push --worktree back through unchanged.
   if (a.worktreeArg === '') {
-    a.passthrough.push('--worktree');
-    return;
+    return withIntercepted(a, {
+      passthrough: [...a.passthrough, '--worktree'],
+      worktreeMatched: false,
+    });
   }
 
   // Resolve absolute cwd for git queries.
@@ -161,26 +188,13 @@ export function applyWorktreeIntercept(
   const hit = findWorktree(listWorktrees(dir, runner), a.worktreeArg);
   if (hit) {
     // Existing worktree matched: swap cwd, suppress -w.
-    a.cwd = hit.path;
-    a.worktreeMatched = true;
-    return;
+    return withIntercepted(a, { cwd: hit.path, worktreeMatched: true });
   }
 
   // No match (or not a repo): pass --worktree through and attach --name.
-  a.passthrough.push('--worktree', a.worktreeArg);
-  if (!nameInPassthrough(a.passthrough)) {
-    a.passthrough.push('--name', a.worktreeArg);
-  }
-}
-
-/**
- * nameInPassthrough — local copy of the helper in argParser.ts. Replicated
- * to avoid an import cycle (argParser → buildArgv → worktree → argParser).
- * Both copies must agree; the shared contract is "--name or -n, bare or
- * =value, anywhere in the slice."
- */
-function nameInPassthrough(passthrough: readonly string[]): boolean {
-  return passthrough.some(
-    (t) => t === '--name' || t === '-n' || t.startsWith('--name=') || t.startsWith('-n='),
-  );
+  const withWt = [...a.passthrough, '--worktree', a.worktreeArg];
+  const passthrough = nameInPassthrough(withWt)
+    ? withWt
+    : [...withWt, '--name', a.worktreeArg];
+  return withIntercepted(a, { passthrough, worktreeMatched: false });
 }