@phnx-labs/agents-cli 1.22.120 → 1.22.121

package/dist/lib/fs-atomic.js

@@ -3,28 +3,13 @@ import * as path from 'path';
 import { randomBytes } from 'crypto';
 import lockfile from 'proper-lockfile';
 const LOCK_STALE_MS = 5_000;
-// Wall-clock budget to acquire the lock before giving up. A count-bounded retry
-// (the old 5 attempts / ~750ms ceiling) could expire while a peer legitimately
-// held the lock — under CI/parallel load two `agents` invocations mutating
-// agents.yaml would have one throw and silently drop its write. The budget must
-// comfortably exceed both a normal critical-section hold and the stale-break
-// window (LOCK_STALE_MS): a dead holder's lock turns stale at 5s and is then
-// broken on the next attempt, so this only ever waits out a live, in-progress
-// holder. Bounded (not unbounded) so a truly wedged holder still surfaces an
-// error instead of hanging the CLI forever.
 const LOCK_ACQUIRE_TIMEOUT_MS = 30_000;
 const LOCK_RETRY_MIN_MS = 50;
 const LOCK_RETRY_MAX_MS = 250;
-// Reused across all sleepSync calls — avoids allocating a new SAB each time.
 const _sleepBuf = new Int32Array(new SharedArrayBuffer(4));
 export function sleepSync(ms) {
     Atomics.wait(_sleepBuf, 0, 0, ms);
 }
-/**
- * Ensures the target file (and its parent directory) exist so proper-lockfile
- * can create a sibling .lock directory. Created with flag 'wx' so concurrent
- * creation races are safe (EEXIST is swallowed).
- */
 export function ensureLockTarget(filePath, initialContent = '', dirMode) {
     fs.mkdirSync(path.dirname(filePath), { recursive: true, ...(dirMode != null ? { mode: dirMode } : {}) });
     if (fs.existsSync(filePath))
@@ -37,10 +22,6 @@ export function ensureLockTarget(filePath, initialContent = '', dirMode) {
             throw err;
     }
 }
-/**
- * Writes content to filePath via a temp file + rename so readers never see a
- * partial write. On POSIX, rename(2) is atomic.
- */
 export function atomicWriteFileSync(filePath, content, options = 'utf-8') {
     const tmpPath = `${filePath}.tmp-${process.pid}-${randomBytes(8).toString('hex')}`;
     fs.writeFileSync(tmpPath, content, options);
@@ -51,25 +32,13 @@ export function atomicWriteFileSync(filePath, content, options = 'utf-8') {
         try {
             fs.unlinkSync(tmpPath);
         }
-        catch { /* best-effort cleanup */ }
+        catch { }
         throw err;
     }
 }
-/**
- * Convenience wrapper around {@link atomicWriteFileSync} for the common case of
- * writing pretty-printed JSON (RUSH-2840). Same tmp-then-rename mechanics, same
- * caller responsibility to ensure the parent directory exists first — this adds
- * only the `JSON.stringify`.
- */
 export function atomicWriteJsonSync(filePath, data) {
     atomicWriteFileSync(filePath, JSON.stringify(data, null, 2));
 }
-/**
- * Async counterpart of {@link atomicWriteFileSync} for callers on the daemon's
- * shared event loop (PHNX-3695): a `writeFileSync`/`renameSync` on a tick freezes
- * every service and the browser IPC server until the disk write returns. Same
- * tmp-then-rename atomicity, but every syscall is awaited via `fs/promises`.
- */
 export async function atomicWriteFile(filePath, content, options = 'utf-8') {
     const tmpPath = `${filePath}.tmp-${process.pid}-${randomBytes(8).toString('hex')}`;
     await fs.promises.writeFile(tmpPath, content, options);
@@ -80,17 +49,13 @@ export async function atomicWriteFile(filePath, content, options = 'utf-8') {
         try {
             await fs.promises.unlink(tmpPath);
         }
-        catch { /* best-effort cleanup */ }
+        catch { }
         throw err;
     }
 }
 export function withFileLock(filePath, fn, opts = {}) {
     let release = null;
     let lastError;
-    // Set if a peer breaks this lock while we hold it. proper-lockfile reports that
-    // from its own refresh TIMER, so the default handler rethrows asynchronously —
-    // an uncatchable crash of the whole CLI process, from a callback no caller is
-    // on the stack for. Capture it instead and surface it synchronously below.
     let compromised = null;
     const staleMs = opts.staleMs ?? LOCK_STALE_MS;
     const acquireTimeoutMs = opts.acquireTimeoutMs ?? LOCK_ACQUIRE_TIMEOUT_MS;
@@ -106,11 +71,6 @@ export function withFileLock(filePath, fn, opts = {}) {
         }
         catch (err) {
             lastError = err;
-            // proper-lockfile breaks stale locks with rmdir, which fails with ENOTDIR
-            // when a prior crash left a regular file instead of the expected directory.
-            // Remove the stale file so the next attempt can succeed. Match
-            // proper-lockfile's own path resolution: realpath when the option is on
-            // (the default), raw path when it is off.
             if (err instanceof Error && err.code === 'ENOTDIR') {
                 try {
                     const base = (opts.realpath ?? true) ? fs.realpathSync(filePath) : filePath;
@@ -119,7 +79,7 @@ export function withFileLock(filePath, fn, opts = {}) {
                     if (st.isFile())
                         fs.unlinkSync(lockPath);
                 }
-                catch { /* best effort */ }
+                catch { }
             }
             if (Date.now() >= deadline)
                 break;
@@ -131,22 +91,16 @@ export function withFileLock(filePath, fn, opts = {}) {
         const message = lastError instanceof Error ? lastError.message : String(lastError);
         throw new Error(`Could not acquire lock for ${filePath} after ${acquireTimeoutMs}ms: ${message}`);
     }
-    // proper-lockfile's lock dir is `<filePath>.lock`; touching its mtime is exactly
-    // what proper-lockfile's own async updater does, so the staleness check keys off
-    // a fresh mtime. Best-effort: a failed touch just leaves the async updater's
-    // behaviour unchanged (no worse than before this heartbeat existed).
     const lockDir = `${filePath}.lock`;
     const heartbeat = () => {
         try {
             const now = new Date();
             fs.utimesSync(lockDir, now, now);
         }
-        catch { /* best effort */ }
+        catch { }
     };
     try {
         const result = fn(heartbeat);
-        // A compromised lock means a peer may have written under us — the caller must
-        // not treat the result as if it held exclusivity throughout.
         if (compromised) {
             throw new Error(`Lock for ${filePath} was broken by another process while held: ` +
                 `${compromised.message}`);
@@ -154,24 +108,12 @@ export function withFileLock(filePath, fn, opts = {}) {
         return result;
     }
     finally {
-        // Releasing a lock a peer already stole throws ENOTACQUIRED; that is the
-        // stolen case, already reported above, so don't mask it with a teardown error.
         try {
             release();
         }
-        catch { /* already gone */ }
+        catch { }
     }
 }
-/**
- * Async counterpart of {@link withFileLock} for callers on the daemon's shared
- * event loop (PHNX-3695). The sync version retries acquisition with
- * {@link sleepSync} (`Atomics.wait`), which HALTS the thread for up to
- * {@link LOCK_ACQUIRE_TIMEOUT_MS} on contention — on a daemon tick that freezes
- * every service and the browser IPC server. This variant awaits proper-lockfile's
- * async `lock()` and yields with a real timer between retries, so the loop keeps
- * turning while a peer holds the lock. Same stale-break, same acquire budget,
- * same compromised-lock surfacing.
- */
 export async function withFileLockAsync(filePath, fn, opts = {}) {
     let release = null;
     let lastError;
@@ -198,7 +140,7 @@ export async function withFileLockAsync(filePath, fn, opts = {}) {
                     if (st.isFile())
                         fs.unlinkSync(lockPath);
                 }
-                catch { /* best effort */ }
+                catch { }
             }
             if (Date.now() >= deadline)
                 break;
@@ -216,7 +158,7 @@ export async function withFileLockAsync(filePath, fn, opts = {}) {
             const now = new Date();
             fs.utimesSync(lockDir, now, now);
         }
-        catch { /* best effort */ }
+        catch { }
     };
     try {
         const result = await fn(heartbeat);
@@ -230,6 +172,6 @@ export async function withFileLockAsync(filePath, fn, opts = {}) {
         try {
             await release();
         }
-        catch { /* already gone */ }
+        catch { }
     }
 }

package/dist/lib/fs-walk.d.ts

@@ -1,22 +1,9 @@
-/** A file surfaced by the walk, carrying the mtime+size from the walk's own stat. */
 interface WalkedFile {
     path: string;
     mtimeMs: number;
     size: number;
 }
-/**
- * Walk a directory recursively for files with a given extension, newest first,
- * keeping each match's mtime and size from the walk's own stat. Callers that
- * then compare against the scan ledger reuse these instead of re-stat'ing every
- * path — eliminating a second stat per file on the Codex/Droid/routine scans.
- */
 export declare function walkForFilesWithStat(dir: string, ext: string, limit: number): WalkedFile[];
-/** Walk a directory recursively for files with a given extension, newest first. */
 export declare function walkForFiles(dir: string, ext: string, limit: number): string[];
-/**
- * Return the newest mtime (ms) among files with the given extension, or null
- * when none match. Single pass tracking the max — no collection or sort.
- * Hot-path helper for the `agents run` account-recency probe.
- */
 export declare function latestFileMtimeMs(dir: string, ext: string): number | null;
 export {};

package/dist/lib/fs-walk.js

@@ -1,12 +1,5 @@
 import * as fs from 'fs';
 import * as path from 'path';
-/**
- * Recursively visit files with a given extension, calling onFile with each
- * match's path and mtime. Uses dirent types from readdir so only matching
- * files (and symlinks, to preserve follow semantics) pay a stat call —
- * directories are classified for free. On large session trees this roughly
- * halves the syscall count versus stat-per-entry.
- */
 function walkEntries(dir, ext, onFile) {
     function walk(d, depth) {
         if (depth > 5)
@@ -21,9 +14,6 @@ function walkEntries(dir, ext, onFile) {
         for (const entry of entries) {
             const full = path.join(d, entry.name);
             let isDirectory = entry.isDirectory();
-            // Symlinks: dirent reports the link itself, but the previous stat-based
-            // walk followed links into directories and matched linked files. Stat
-            // (which follows) only for symlinks to keep that behavior.
             if (entry.isSymbolicLink()) {
                 const stat = safeStatSync(full);
                 if (!stat)
@@ -42,12 +32,6 @@ function walkEntries(dir, ext, onFile) {
     }
     walk(dir, 0);
 }
-/**
- * Walk a directory recursively for files with a given extension, newest first,
- * keeping each match's mtime and size from the walk's own stat. Callers that
- * then compare against the scan ledger reuse these instead of re-stat'ing every
- * path — eliminating a second stat per file on the Codex/Droid/routine scans.
- */
 export function walkForFilesWithStat(dir, ext, limit) {
     const results = [];
     walkEntries(dir, ext, (filePath, mtimeMs, size) => {
@@ -56,15 +40,9 @@ export function walkForFilesWithStat(dir, ext, limit) {
     results.sort((a, b) => b.mtimeMs - a.mtimeMs);
     return results.slice(0, limit);
 }
-/** Walk a directory recursively for files with a given extension, newest first. */
 export function walkForFiles(dir, ext, limit) {
     return walkForFilesWithStat(dir, ext, limit).map(r => r.path);
 }
-/**
- * Return the newest mtime (ms) among files with the given extension, or null
- * when none match. Single pass tracking the max — no collection or sort.
- * Hot-path helper for the `agents run` account-recency probe.
- */
 export function latestFileMtimeMs(dir, ext) {
     let latest = null;
     walkEntries(dir, ext, (_filePath, mtimeMs) => {

package/dist/lib/fuzzy.d.ts

@@ -1,61 +1,32 @@
-/**
- * Fuzzy string matching for user-provided identifiers.
- * Auto-corrects typos like "cladue" -> "claude" based on Levenshtein distance.
- */
-/** Levenshtein edit distance between two strings. */
 export declare function levenshtein(a: string, b: string): number;
-/**
- * Damerau-Levenshtein (optimal string alignment) distance.
- * Counts a transposition of two adjacent characters as a single edit,
- * so `cladue` -> `claude` is distance 1, matching the user's notion of
- * "one misspelling."
- */
 export declare function damerauLevenshtein(a: string, b: string): number;
 interface FuzzyOptions {
-    /** Absolute max edit distance allowed. */
     maxDistance?: number;
-    /** Max ratio of distance to input length. If set, effective threshold = min(maxDistance, floor(len * maxRatio)). */
     maxRatio?: number;
-    /** Use Damerau-Levenshtein (transposition = 1 edit) instead of plain Levenshtein. */
     damerau?: boolean;
 }
-/**
- * Fuzzy match an input string against a list of candidates.
- * Returns the single best match within tolerance, or null if no match or ambiguous.
- */
 export declare function fuzzyMatch<T extends string>(input: string, candidates: readonly T[], options?: FuzzyOptions): T | null;
-/**
- * Preset configurations for different identifier types.
- * Based on pairwise distance analysis of candidate pools.
- */
 export declare const FUZZY_PRESETS: {
-    /** Agents: 1 mistype (insertion/deletion/substitution/transposition). Damerau so `cladue`->`claude` is 1. */
     readonly agents: {
         readonly maxDistance: 1;
         readonly damerau: true;
     };
-    /** Modes: plan/edit/full all at dist=4, lenient */
     readonly modes: {
         readonly maxDistance: 2;
     };
-    /** Efforts: high/xhigh at dist=1, must be strict */
     readonly efforts: {
         readonly maxDistance: 1;
     };
-    /** Strategies: pinned/available/rotate all far apart */
     readonly strategies: {
         readonly maxDistance: 2;
     };
-    /** Beta features: drive/factory at dist=7, lenient */
     readonly beta: {
         readonly maxDistance: 2;
     };
-    /** Dynamic/user-defined: profiles, commands, hooks, etc. */
     readonly dynamic: {
         readonly maxDistance: 2;
         readonly maxRatio: 0.3;
     };
-    /** Skills: often longer names, slightly more lenient */
     readonly skills: {
         readonly maxDistance: 3;
         readonly maxRatio: 0.3;

package/dist/lib/fuzzy.js

@@ -1,8 +1,3 @@
-/**
- * Fuzzy string matching for user-provided identifiers.
- * Auto-corrects typos like "cladue" -> "claude" based on Levenshtein distance.
- */
-/** Levenshtein edit distance between two strings. */
 export function levenshtein(a, b) {
     const m = a.length, n = b.length;
     if (m === 0)
@@ -19,12 +14,6 @@ export function levenshtein(a, b) {
     }
     return dp[m][n];
 }
-/**
- * Damerau-Levenshtein (optimal string alignment) distance.
- * Counts a transposition of two adjacent characters as a single edit,
- * so `cladue` -> `claude` is distance 1, matching the user's notion of
- * "one misspelling."
- */
 export function damerauLevenshtein(a, b) {
     const m = a.length, n = b.length;
     if (m === 0)
@@ -43,22 +32,15 @@ export function damerauLevenshtein(a, b) {
     }
     return dp[m][n];
 }
-/**
- * Fuzzy match an input string against a list of candidates.
- * Returns the single best match within tolerance, or null if no match or ambiguous.
- */
 export function fuzzyMatch(input, candidates, options = {}) {
     const { maxDistance = 2, maxRatio, damerau = false } = options;
     const lower = input.toLowerCase();
-    // Reject inputs that are too short - they're too ambiguous
     if (lower.length < 3)
         return null;
-    // Compute effective threshold
     const threshold = maxRatio
         ? Math.min(maxDistance, Math.floor(lower.length * maxRatio))
         : maxDistance;
     const distance = damerau ? damerauLevenshtein : levenshtein;
-    // Find all candidates within threshold (excluding exact matches)
     const matches = [];
     for (const candidate of candidates) {
         const dist = distance(lower, candidate.toLowerCase());
@@ -68,30 +50,17 @@ export function fuzzyMatch(input, candidates, options = {}) {
     }
     if (matches.length === 0)
         return null;
-    // Sort by distance
     matches.sort((a, b) => a.dist - b.dist);
-    // Only return if exactly one candidate at the minimum distance (no ambiguity)
     const minDist = matches[0].dist;
     const atMinDist = matches.filter(m => m.dist === minDist);
     return atMinDist.length === 1 ? atMinDist[0].candidate : null;
 }
-/**
- * Preset configurations for different identifier types.
- * Based on pairwise distance analysis of candidate pools.
- */
 export const FUZZY_PRESETS = {
-    /** Agents: 1 mistype (insertion/deletion/substitution/transposition). Damerau so `cladue`->`claude` is 1. */
     agents: { maxDistance: 1, damerau: true },
-    /** Modes: plan/edit/full all at dist=4, lenient */
     modes: { maxDistance: 2 },
-    /** Efforts: high/xhigh at dist=1, must be strict */
     efforts: { maxDistance: 1 },
-    /** Strategies: pinned/available/rotate all far apart */
     strategies: { maxDistance: 2 },
-    /** Beta features: drive/factory at dist=7, lenient */
     beta: { maxDistance: 2 },
-    /** Dynamic/user-defined: profiles, commands, hooks, etc. */
     dynamic: { maxDistance: 2, maxRatio: 0.3 },
-    /** Skills: often longer names, slightly more lenient */
     skills: { maxDistance: 3, maxRatio: 0.3 },
 };

package/dist/lib/gemini-settings.js

@@ -1,15 +1,3 @@
-/**
- * Generic reader/writer for a `.gemini/…/settings.json`-shaped JSON config.
- *
- * Despite the name, this module is no longer gemini-specific: gemini itself
- * is hard-deprecated and has no live caller left (its own settings writer,
- * `generateGeminiConfig`, was removed with the RUSH-2202 runner.ts fix — a
- * gemini routine is rejected before it ever reaches sandbox prep). Antigravity
- * nests its own `settings.json` under the same `.gemini/antigravity-cli/` tree
- * and shares this exact shape, so `permissions.ts` reuses `updateGeminiSettings`
- * for antigravity's live permission writes. Keep the generic helpers; do not
- * reintroduce gemini-only logic here.
- */
 import * as fs from 'fs';
 import * as path from 'path';
 function isRecord(value) {