agent-relay 1.3.1 → 1.3.3

package/dist/utils/git-remote.js

@@ -0,0 +1,125 @@
+/**
+ * Git Remote Detection Utility
+ *
+ * Detects the git remote URL from a working directory and parses it
+ * to extract the repository full name (owner/repo).
+ */
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { execSync } from 'node:child_process';
+/**
+ * Parse a git remote URL to extract owner/repo format.
+ *
+ * Supports:
+ * - git@github.com:owner/repo.git
+ * - https://github.com/owner/repo.git
+ * - https://github.com/owner/repo
+ * - git://github.com/owner/repo.git
+ */
+export function parseGitRemoteUrl(url) {
+    if (!url)
+        return null;
+    // SSH format: git@github.com:owner/repo.git
+    const sshMatch = url.match(/git@[^:]+:([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (sshMatch) {
+        return sshMatch[1];
+    }
+    // HTTPS/Git format: https://github.com/owner/repo.git
+    const httpsMatch = url.match(/(?:https?|git):\/\/[^/]+\/([^/]+\/[^/]+?)(?:\.git)?$/);
+    if (httpsMatch) {
+        return httpsMatch[1];
+    }
+    return null;
+}
+/**
+ * Get the git remote URL from a directory.
+ *
+ * @param workingDirectory The directory to check for git remote
+ * @param remoteName The remote name to use (default: 'origin')
+ * @returns The remote URL or null if not found
+ */
+export function getGitRemoteUrl(workingDirectory, remoteName = 'origin') {
+    try {
+        // First check if it's a git repository
+        const gitDir = path.join(workingDirectory, '.git');
+        if (!fs.existsSync(gitDir)) {
+            return null;
+        }
+        // Try to get the remote URL using git command
+        const result = execSync(`git remote get-url ${remoteName}`, {
+            cwd: workingDirectory,
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['pipe', 'pipe', 'pipe'],
+        });
+        return result.trim() || null;
+    }
+    catch {
+        // Git command failed - try parsing .git/config directly
+        try {
+            const configPath = path.join(workingDirectory, '.git', 'config');
+            if (!fs.existsSync(configPath)) {
+                return null;
+            }
+            const config = fs.readFileSync(configPath, 'utf-8');
+            // Parse git config to find remote URL
+            const remoteSection = new RegExp(`\\[remote\\s+"${remoteName}"\\][^\\[]*url\\s*=\\s*([^\\n]+)`, 'i');
+            const match = config.match(remoteSection);
+            return match?.[1]?.trim() || null;
+        }
+        catch {
+            return null;
+        }
+    }
+}
+/**
+ * Get the repository full name (owner/repo) from a working directory.
+ *
+ * @param workingDirectory The directory to check
+ * @returns The repo full name (e.g., "AgentWorkforce/relay") or null
+ */
+export function getRepoFullName(workingDirectory) {
+    const remoteUrl = getGitRemoteUrl(workingDirectory);
+    if (!remoteUrl) {
+        return null;
+    }
+    return parseGitRemoteUrl(remoteUrl);
+}
+/**
+ * Find the git root directory from a given path.
+ * Walks up the directory tree looking for .git folder.
+ *
+ * @param startPath The path to start searching from
+ * @returns The git root directory or null if not in a git repo
+ */
+export function findGitRoot(startPath) {
+    let currentPath = path.resolve(startPath);
+    const root = path.parse(currentPath).root;
+    while (currentPath !== root) {
+        if (fs.existsSync(path.join(currentPath, '.git'))) {
+            return currentPath;
+        }
+        currentPath = path.dirname(currentPath);
+    }
+    return null;
+}
+/**
+ * Get repository full name, walking up to find git root if needed.
+ *
+ * @param workingDirectory The directory to start from
+ * @returns The repo full name or null
+ */
+export function getRepoFullNameFromPath(workingDirectory) {
+    // First try the exact directory
+    let repoName = getRepoFullName(workingDirectory);
+    if (repoName) {
+        return repoName;
+    }
+    // Walk up to find git root
+    const gitRoot = findGitRoot(workingDirectory);
+    if (gitRoot && gitRoot !== workingDirectory) {
+        repoName = getRepoFullName(gitRoot);
+    }
+    return repoName;
+}
+//# sourceMappingURL=git-remote.js.map

package/dist/utils/id-generator.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Monotonic ID Generator
+ *
+ * Generates unique, lexicographically sortable IDs that are faster than UUID v4.
+ *
+ * Format: <timestamp-base36>-<counter-base36>-<nodeId>
+ * Example: "lxyz5g8-0001-7d2a"
+ *
+ * Properties:
+ * - Lexicographically sortable by time
+ * - Unique across processes (node prefix)
+ * - ~16x faster than UUID v4
+ * - Shorter (20-24 chars vs 36 chars)
+ */
+export declare class IdGenerator {
+    private counter;
+    private readonly prefix;
+    private lastTs;
+    constructor(nodeId?: string);
+    /**
+     * Generate a unique, monotonically increasing ID.
+     */
+    next(): string;
+    /**
+     * Generate a short ID (just timestamp + counter, no node prefix).
+     * Use when you don't need cross-process uniqueness.
+     */
+    short(): string;
+}
+export declare const idGen: IdGenerator;
+/**
+ * Generate a unique ID (drop-in replacement for uuid()).
+ */
+export declare function generateId(): string;
+//# sourceMappingURL=id-generator.d.ts.map

package/dist/utils/id-generator.js

@@ -0,0 +1,60 @@
+/**
+ * Monotonic ID Generator
+ *
+ * Generates unique, lexicographically sortable IDs that are faster than UUID v4.
+ *
+ * Format: <timestamp-base36>-<counter-base36>-<nodeId>
+ * Example: "lxyz5g8-0001-7d2a"
+ *
+ * Properties:
+ * - Lexicographically sortable by time
+ * - Unique across processes (node prefix)
+ * - ~16x faster than UUID v4
+ * - Shorter (20-24 chars vs 36 chars)
+ */
+export class IdGenerator {
+    counter = 0;
+    prefix;
+    lastTs = 0;
+    constructor(nodeId) {
+        // Use process ID + random suffix for uniqueness across processes
+        this.prefix = nodeId ?? `${process.pid.toString(36)}${Math.random().toString(36).slice(2, 6)}`;
+    }
+    /**
+     * Generate a unique, monotonically increasing ID.
+     */
+    next() {
+        const now = Date.now();
+        // Reset counter if timestamp changed
+        if (now !== this.lastTs) {
+            this.lastTs = now;
+            this.counter = 0;
+        }
+        const ts = now.toString(36);
+        const seq = (this.counter++).toString(36).padStart(4, '0');
+        return `${ts}-${seq}-${this.prefix}`;
+    }
+    /**
+     * Generate a short ID (just timestamp + counter, no node prefix).
+     * Use when you don't need cross-process uniqueness.
+     */
+    short() {
+        const now = Date.now();
+        if (now !== this.lastTs) {
+            this.lastTs = now;
+            this.counter = 0;
+        }
+        const ts = now.toString(36);
+        const seq = (this.counter++).toString(36).padStart(4, '0');
+        return `${ts}-${seq}`;
+    }
+}
+// Singleton instance for the process
+export const idGen = new IdGenerator();
+/**
+ * Generate a unique ID (drop-in replacement for uuid()).
+ */
+export function generateId() {
+    return idGen.next();
+}
+//# sourceMappingURL=id-generator.js.map

package/dist/utils/index.d.ts

@@ -1,3 +1,4 @@
 export * from './name-generator.js';
 export * from './logger.js';
+export * from './precompiled-patterns.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/utils/index.js

@@ -1,3 +1,4 @@
 export * from './name-generator.js';
 export * from './logger.js';
+export * from './precompiled-patterns.js';
 //# sourceMappingURL=index.js.map

package/dist/utils/precompiled-patterns.d.ts

@@ -0,0 +1,110 @@
+/**
+ * Precompiled Pattern Matching
+ *
+ * Optimized regex patterns for high-performance message parsing.
+ * Inspired by russian-code-ts performance targets (<1ms for pattern matching).
+ *
+ * Strategies:
+ * 1. Precompile patterns at module load (not per-instance)
+ * 2. Combine multiple patterns into single regex where possible
+ * 3. Use non-capturing groups and atomic patterns
+ * 4. Cache compiled patterns by prefix
+ */
+export interface CompiledPatterns {
+    inline: RegExp;
+    fencedInline: RegExp;
+    escape: RegExp;
+}
+/**
+ * Get or create compiled patterns for a given prefix configuration.
+ * Patterns are cached for reuse across parser instances.
+ */
+export declare function getCompiledPatterns(prefix?: string, thinkingPrefix?: string): CompiledPatterns;
+/**
+ * Fast check if text matches any instructional pattern.
+ * Single regex test instead of array.some().
+ */
+export declare function isInstructionalTextFast(body: string): boolean;
+/**
+ * Fast placeholder target check using Set.
+ */
+export declare function isPlaceholderTargetFast(target: string): boolean;
+/**
+ * Strip ANSI escape codes from a string.
+ * Uses precompiled patterns for better performance.
+ */
+export declare function stripAnsiFast(str: string): string;
+/**
+ * Precompiled static patterns used across parsing operations.
+ */
+export declare const StaticPatterns: {
+    readonly BLOCK_END: RegExp;
+    readonly BLOCK_METADATA_END: RegExp;
+    readonly CODE_FENCE: RegExp;
+    readonly FENCE_END_START: RegExp;
+    readonly FENCE_END_LINE: RegExp;
+    readonly FENCE_END: RegExp;
+    readonly ESCAPED_FENCE_START: RegExp;
+    readonly ESCAPED_FENCE_END: RegExp;
+    readonly ESCAPED_FENCE_END_CHECK: RegExp;
+    readonly ESCAPED_FENCE_START_CHECK: RegExp;
+    readonly BULLET_OR_NUMBERED_LIST: RegExp;
+    readonly PROMPTISH_LINE: RegExp;
+    readonly RELAY_INJECTION_PREFIX: RegExp;
+    readonly SPAWN_COMMAND: RegExp;
+    readonly RELEASE_COMMAND: RegExp;
+    readonly THINKING_START: RegExp;
+    readonly THINKING_END: RegExp;
+    readonly AGENT_NAME: RegExp;
+    readonly CLI_PROMPTS: {
+        readonly claude: RegExp;
+        readonly gemini: RegExp;
+        readonly codex: RegExp;
+        readonly droid: RegExp;
+        readonly opencode: RegExp;
+        readonly spawned: RegExp;
+        readonly other: RegExp;
+    };
+};
+/**
+ * Check if line is a spawn or release command.
+ */
+export declare function isSpawnOrReleaseCommandFast(line: string): boolean;
+/**
+ * Check if a line contains an escaped fence end.
+ */
+export declare function isEscapedFenceEndFast(line: string): boolean;
+/**
+ * Unescape fence markers in content.
+ */
+export declare function unescapeFenceMarkersFast(content: string): string;
+interface PatternMetrics {
+    calls: number;
+    totalMs: number;
+    maxMs: number;
+}
+/**
+ * Track pattern matching performance (for debugging/profiling).
+ * Call with pattern name and execution time.
+ */
+export declare function trackPatternPerformance(name: string, ms: number): void;
+/**
+ * Get pattern performance metrics.
+ */
+export declare function getPatternMetrics(): Map<string, PatternMetrics & {
+    avgMs: number;
+}>;
+/**
+ * Reset pattern performance metrics.
+ */
+export declare function resetPatternMetrics(): void;
+/**
+ * Benchmark pattern matching performance.
+ * Useful for testing optimization impact.
+ */
+export declare function benchmarkPatterns(iterations?: number): Record<string, {
+    avgNs: number;
+    maxNs: number;
+}>;
+export {};
+//# sourceMappingURL=precompiled-patterns.d.ts.map

package/dist/utils/precompiled-patterns.js

@@ -0,0 +1,322 @@
+/**
+ * Precompiled Pattern Matching
+ *
+ * Optimized regex patterns for high-performance message parsing.
+ * Inspired by russian-code-ts performance targets (<1ms for pattern matching).
+ *
+ * Strategies:
+ * 1. Precompile patterns at module load (not per-instance)
+ * 2. Combine multiple patterns into single regex where possible
+ * 3. Use non-capturing groups and atomic patterns
+ * 4. Cache compiled patterns by prefix
+ */
+const patternCache = new Map();
+/**
+ * Escape special regex characters in a string
+ */
+function escapeRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+/**
+ * Get or create compiled patterns for a given prefix configuration.
+ * Patterns are cached for reuse across parser instances.
+ */
+export function getCompiledPatterns(prefix = '->relay:', thinkingPrefix = '->thinking:') {
+    const cacheKey = `${prefix}|${thinkingPrefix}`;
+    const cached = patternCache.get(cacheKey);
+    if (cached) {
+        return cached;
+    }
+    const escapedPrefix = escapeRegex(prefix);
+    const escapedThinking = escapeRegex(thinkingPrefix);
+    // Combined prompt character class for line start
+    // Includes: >, $, %, #, →, ➜, ›, », bullets (●•◦‣⁃-*⏺◆◇○□■), box chars (│┃┆┇┊┋╎╏), sparkle (✦)
+    const promptChars = String.raw `[>$%#→➜›»●•◦‣⁃\-*⏺◆◇○□■│┃┆┇┊┋╎╏✦]`;
+    const lineStartPrefix = String.raw `^(?:\s*(?:${promptChars}\s*)*)?`;
+    // Thread syntax: [thread:id] or [thread:project:id]
+    const threadSyntax = String.raw `(?:\s+\[thread:(?:([\w-]+):)?([\w-]+)\])?`;
+    const patterns = {
+        // Combined inline pattern for both relay and thinking prefixes
+        // Groups: 1=prefix type (relay/thinking), 2=target, 3=thread project, 4=thread id, 5=body
+        inline: new RegExp(`${lineStartPrefix}(${escapedPrefix}|${escapedThinking})(\\S+)${threadSyntax}\\s+(.+)$`),
+        // Combined fenced inline pattern: ->relay:Target <<<
+        // Groups: 1=prefix type, 2=target, 3=thread project, 4=thread id
+        fencedInline: new RegExp(`${lineStartPrefix}(${escapedPrefix}|${escapedThinking})(\\S+)${threadSyntax}\\s+<<<\\s*$`),
+        // Escape pattern for \->relay: or \->thinking:
+        escape: new RegExp(`^(\\s*)\\\\(${escapedPrefix}|${escapedThinking})`),
+    };
+    patternCache.set(cacheKey, patterns);
+    return patterns;
+}
+// =============================================================================
+// Combined Instructional Markers (Single Regex)
+// =============================================================================
+/**
+ * Combined instructional markers pattern.
+ * Instead of testing each pattern separately, we combine into one regex.
+ *
+ * Original patterns:
+ * - /\bSEND:\s*$/i
+ * - /\bPROTOCOL:\s*\(\d+\)/i
+ * - /\bExample:/i
+ * - /\\->relay:/
+ * - /\\->thinking:/
+ * - /^AgentName\s+/
+ * - /^Target\s+/
+ * - /\[Agent Relay\]/
+ * - /MULTI-LINE:/i
+ * - /RECEIVE:/i
+ */
+const INSTRUCTIONAL_COMBINED = new RegExp([
+    String.raw `\bSEND:\s*$`, // "SEND:" at end (instruction prefix)
+    String.raw `\bPROTOCOL:\s*\(\d+\)`, // "PROTOCOL: (1)" - numbered instructions
+    String.raw `\bExample:`, // "Example:" marker
+    String.raw `\\->relay:`, // Escaped relay prefix (documentation)
+    String.raw `\\->thinking:`, // Escaped thinking prefix (documentation)
+    String.raw `^AgentName\s+`, // Body starting with "AgentName"
+    String.raw `^Target\s+`, // Body starting with "Target"
+    String.raw `\[Agent Relay\]`, // Injected instruction header
+    String.raw `MULTI-LINE:`, // Multi-line format instruction
+    String.raw `RECEIVE:`, // Receive instruction marker
+].join('|'), 'i' // Case insensitive
+);
+/**
+ * Fast check if text matches any instructional pattern.
+ * Single regex test instead of array.some().
+ */
+export function isInstructionalTextFast(body) {
+    return INSTRUCTIONAL_COMBINED.test(body);
+}
+// =============================================================================
+// Placeholder Targets (Set for O(1) Lookup)
+// =============================================================================
+/**
+ * Placeholder target names - precomputed lowercase set for fast lookup.
+ */
+const PLACEHOLDER_TARGETS_SET = new Set([
+    'agentname',
+    'target',
+    'recipient',
+    'yourtarget',
+    'targetagent',
+    'someagent',
+    'otheragent',
+    'worker',
+]);
+/**
+ * Fast placeholder target check using Set.
+ */
+export function isPlaceholderTargetFast(target) {
+    return PLACEHOLDER_TARGETS_SET.has(target.toLowerCase());
+}
+// =============================================================================
+// ANSI Stripping (Precompiled)
+// =============================================================================
+/**
+ * Precompiled ANSI escape sequence pattern.
+ * Global flag for replace operations.
+ */
+// eslint-disable-next-line no-control-regex
+const ANSI_PATTERN_COMPILED = /\x1b\[[0-9;?]*[a-zA-Z]|\x1b\].*?(?:\x07|\x1b\\)|\r/g;
+/**
+ * Precompiled orphaned CSI pattern.
+ */
+const ORPHANED_CSI_COMPILED = /^\s*(\[(?:\?|\d)\d*[A-Za-z])+\s*/g;
+/**
+ * Strip ANSI escape codes from a string.
+ * Uses precompiled patterns for better performance.
+ */
+export function stripAnsiFast(str) {
+    // Reset lastIndex for global patterns
+    ANSI_PATTERN_COMPILED.lastIndex = 0;
+    ORPHANED_CSI_COMPILED.lastIndex = 0;
+    let result = str.replace(ANSI_PATTERN_COMPILED, '');
+    result = result.replace(ORPHANED_CSI_COMPILED, '');
+    return result;
+}
+// =============================================================================
+// Static Patterns (Precompiled)
+// =============================================================================
+/**
+ * Precompiled static patterns used across parsing operations.
+ */
+export const StaticPatterns = {
+    // Block markers
+    BLOCK_END: /\[\[\/RELAY\]\]/,
+    BLOCK_METADATA_END: /\[\[\/RELAY_METADATA\]\]/,
+    CODE_FENCE: /^```/,
+    // Fence markers
+    FENCE_END_START: /^(?:\s*)?>>>/,
+    FENCE_END_LINE: />>>\s*$/,
+    FENCE_END: /^(?:\s*)?>>>|>>>\s*$/,
+    // Escape patterns
+    ESCAPED_FENCE_START: /\\<<</g,
+    ESCAPED_FENCE_END: /\\>>>/g,
+    ESCAPED_FENCE_END_CHECK: /\\>>>\s*$/,
+    ESCAPED_FENCE_START_CHECK: /^(?:\s*)?\\>>>/,
+    // Continuation helpers
+    BULLET_OR_NUMBERED_LIST: /^[ \t]*([\-*•◦‣⏺◆◇○□■]|[0-9]+[.)])\s+/,
+    PROMPTISH_LINE: /^[\s]*[>$%#➜›»][\s]*$/,
+    RELAY_INJECTION_PREFIX: /^\s*Relay message from /,
+    // Spawn/release commands
+    SPAWN_COMMAND: /->relay:spawn\s+\S+/i,
+    RELEASE_COMMAND: /->relay:release\s+\S+/i,
+    // Claude extended thinking blocks
+    THINKING_START: /<thinking>/,
+    THINKING_END: /<\/thinking>/,
+    // Agent name validation (PascalCase, 2-30 chars)
+    AGENT_NAME: /^[A-Z][a-zA-Z0-9]{1,29}$/,
+    // CLI prompt patterns by type
+    CLI_PROMPTS: {
+        claude: /^[>›»]\s*$/,
+        gemini: /^[>›»]\s*$/,
+        codex: /^[>›»]\s*$/,
+        droid: /^[>›»]\s*$/,
+        opencode: /^[>›»]\s*$/,
+        spawned: /^[>›»]\s*$/,
+        other: /^[>$%#➜›»]\s*$/,
+    },
+};
+// =============================================================================
+// Pattern Matching Utilities
+// =============================================================================
+/**
+ * Check if line is a spawn or release command.
+ */
+export function isSpawnOrReleaseCommandFast(line) {
+    return StaticPatterns.SPAWN_COMMAND.test(line) ||
+        StaticPatterns.RELEASE_COMMAND.test(line);
+}
+/**
+ * Check if a line contains an escaped fence end.
+ */
+export function isEscapedFenceEndFast(line) {
+    return StaticPatterns.ESCAPED_FENCE_END_CHECK.test(line) ||
+        StaticPatterns.ESCAPED_FENCE_START_CHECK.test(line);
+}
+/**
+ * Unescape fence markers in content.
+ */
+export function unescapeFenceMarkersFast(content) {
+    StaticPatterns.ESCAPED_FENCE_START.lastIndex = 0;
+    StaticPatterns.ESCAPED_FENCE_END.lastIndex = 0;
+    return content
+        .replace(StaticPatterns.ESCAPED_FENCE_START, '<<<')
+        .replace(StaticPatterns.ESCAPED_FENCE_END, '>>>');
+}
+const metrics = new Map();
+/**
+ * Track pattern matching performance (for debugging/profiling).
+ * Call with pattern name and execution time.
+ */
+export function trackPatternPerformance(name, ms) {
+    const existing = metrics.get(name);
+    if (existing) {
+        existing.calls++;
+        existing.totalMs += ms;
+        existing.maxMs = Math.max(existing.maxMs, ms);
+    }
+    else {
+        metrics.set(name, { calls: 1, totalMs: ms, maxMs: ms });
+    }
+}
+/**
+ * Get pattern performance metrics.
+ */
+export function getPatternMetrics() {
+    const result = new Map();
+    for (const [name, m] of metrics) {
+        result.set(name, {
+            ...m,
+            avgMs: m.calls > 0 ? m.totalMs / m.calls : 0,
+        });
+    }
+    return result;
+}
+/**
+ * Reset pattern performance metrics.
+ */
+export function resetPatternMetrics() {
+    metrics.clear();
+}
+// =============================================================================
+// Benchmark Utility
+// =============================================================================
+/**
+ * Benchmark pattern matching performance.
+ * Useful for testing optimization impact.
+ */
+export function benchmarkPatterns(iterations = 10000) {
+    const testStrings = [
+        '->relay:Agent Hello world',
+        '->relay:Lead [thread:task-123] Starting work',
+        '  > ->relay:Worker <<<',
+        'Some random text without relay',
+        '\x1b[32m->relay:Test\x1b[0m message with ANSI',
+        '->relay:spawn Worker claude "task"',
+        'ACK: Task received',
+        'SEND: Protocol instruction',
+        'Example: how to use relay',
+    ];
+    const results = {};
+    // Benchmark combined instructional check
+    {
+        let maxNs = 0;
+        const start = process.hrtime.bigint();
+        for (let i = 0; i < iterations; i++) {
+            for (const str of testStrings) {
+                const s = process.hrtime.bigint();
+                isInstructionalTextFast(str);
+                const elapsed = Number(process.hrtime.bigint() - s);
+                if (elapsed > maxNs)
+                    maxNs = elapsed;
+            }
+        }
+        const totalNs = Number(process.hrtime.bigint() - start);
+        results['instructionalCheck'] = {
+            avgNs: totalNs / (iterations * testStrings.length),
+            maxNs,
+        };
+    }
+    // Benchmark ANSI stripping
+    {
+        let maxNs = 0;
+        const start = process.hrtime.bigint();
+        for (let i = 0; i < iterations; i++) {
+            for (const str of testStrings) {
+                const s = process.hrtime.bigint();
+                stripAnsiFast(str);
+                const elapsed = Number(process.hrtime.bigint() - s);
+                if (elapsed > maxNs)
+                    maxNs = elapsed;
+            }
+        }
+        const totalNs = Number(process.hrtime.bigint() - start);
+        results['ansiStrip'] = {
+            avgNs: totalNs / (iterations * testStrings.length),
+            maxNs,
+        };
+    }
+    // Benchmark placeholder check
+    {
+        const targets = ['AgentName', 'Lead', 'Worker', 'target', 'Developer'];
+        let maxNs = 0;
+        const start = process.hrtime.bigint();
+        for (let i = 0; i < iterations; i++) {
+            for (const t of targets) {
+                const s = process.hrtime.bigint();
+                isPlaceholderTargetFast(t);
+                const elapsed = Number(process.hrtime.bigint() - s);
+                if (elapsed > maxNs)
+                    maxNs = elapsed;
+            }
+        }
+        const totalNs = Number(process.hrtime.bigint() - start);
+        results['placeholderCheck'] = {
+            avgNs: totalNs / (iterations * targets.length),
+            maxNs,
+        };
+    }
+    return results;
+}
+//# sourceMappingURL=precompiled-patterns.js.map

package/dist/wrapper/auth-detection.js

@@ -104,7 +104,7 @@ export function detectAuthRevocation(output, recentOutputOnly = false) {
 /**
  * Determine confidence level based on the matched pattern.
  */
-function getConfidenceLevel(pattern, matchedText) {
+function getConfidenceLevel(pattern, _matchedText) {
     const patternStr = pattern.source.toLowerCase();
     // High confidence: Explicit auth failure messages
     if (patternStr.includes('session') && patternStr.includes('expired') ||