@iaforged/context-code 1.0.72 → 1.0.74

package/dist/src/utils/slowOperations.js

@@ -0,0 +1,323 @@
+import { feature } from '../recovery/bunBundleShim.js';
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import { closeSync, writeFileSync as fsWriteFileSync, fsyncSync, openSync, } from 'fs';
+// biome-ignore lint: This file IS the cloneDeep wrapper - it must import the original
+import lodashCloneDeep from 'lodash-es/cloneDeep.js';
+import { addSlowOperation } from '../bootstrap/state.js';
+import { logForDebugging } from './debug.js';
+// --- Slow operation logging infrastructure ---
+/**
+ * Threshold in milliseconds for logging slow JSON/clone operations.
+ * Operations taking longer than this will be logged for debugging.
+ * - Override: set CLAUDE_CODE_SLOW_OPERATION_THRESHOLD_MS to a number
+ * - Dev builds: 20ms (lower threshold for development)
+ * - Ants: 300ms (enabled for all internal users)
+ */
+const SLOW_OPERATION_THRESHOLD_MS = (() => {
+    const envValue = process.env.CLAUDE_CODE_SLOW_OPERATION_THRESHOLD_MS;
+    if (envValue !== undefined) {
+        const parsed = Number(envValue);
+        if (!Number.isNaN(parsed) && parsed >= 0) {
+            return parsed;
+        }
+    }
+    if (process.env.NODE_ENV === 'development') {
+        return 20;
+    }
+    if (process.env.USER_TYPE === 'ant') {
+        return 300;
+    }
+    return Infinity;
+})();
+// Re-export for callers that still need the threshold value directly
+export { SLOW_OPERATION_THRESHOLD_MS };
+// Module-level re-entrancy guard. logForDebugging writes to a debug file via
+// appendFileSync, which goes through slowLogging again. Without this guard,
+// a slow appendFileSync → dispose → logForDebugging → appendFileSync → dispose → ...
+let isLogging = false;
+/**
+ * Extract the first stack frame outside this file, so the DevBar warning
+ * points at the actual caller instead of a useless `Object{N keys}`.
+ * Only called when an operation was actually slow — never on the fast path.
+ */
+export function callerFrame(stack) {
+    if (!stack)
+        return '';
+    for (const line of stack.split('\n')) {
+        if (line.includes('slowOperations'))
+            continue;
+        const m = line.match(/([^/\\]+?):(\d+):\d+\)?$/);
+        if (m)
+            return ` @ ${m[1]}:${m[2]}`;
+    }
+    return '';
+}
+/**
+ * Builds a human-readable description from tagged template arguments.
+ * Only called when an operation was actually slow — never on the fast path.
+ *
+ * args[0] = TemplateStringsArray, args[1..n] = interpolated values
+ */
+function buildDescription(args) {
+    const strings = args[0];
+    let result = '';
+    for (let i = 0; i < strings.length; i++) {
+        result += strings[i];
+        if (i + 1 < args.length) {
+            const v = args[i + 1];
+            if (Array.isArray(v)) {
+                result += `Array[${v.length}]`;
+            }
+            else if (v !== null && typeof v === 'object') {
+                result += `Object{${Object.keys(v).length} keys}`;
+            }
+            else if (typeof v === 'string') {
+                result += v.length > 80 ? `${v.slice(0, 80)}…` : v;
+            }
+            else {
+                result += String(v);
+            }
+        }
+    }
+    return result;
+}
+class AntSlowLogger {
+    startTime;
+    args;
+    err;
+    constructor(args) {
+        this.startTime = performance.now();
+        this.args = args;
+        // V8/JSC capture the stack at construction but defer the expensive string
+        // formatting until .stack is read — so this stays off the fast path.
+        this.err = new Error();
+    }
+    [Symbol.dispose]() {
+        const duration = performance.now() - this.startTime;
+        if (duration > SLOW_OPERATION_THRESHOLD_MS && !isLogging) {
+            isLogging = true;
+            try {
+                const description = buildDescription(this.args) + callerFrame(this.err.stack);
+                logForDebugging(`[SLOW OPERATION DETECTED] ${description} (${duration.toFixed(1)}ms)`);
+                addSlowOperation(description, duration);
+            }
+            finally {
+                isLogging = false;
+            }
+        }
+    }
+}
+const NOOP_LOGGER = { [Symbol.dispose]() { } };
+// Must be regular functions (not arrows) to access `arguments`
+function slowLoggingAnt(_strings, ..._values) {
+    // eslint-disable-next-line prefer-rest-params
+    return new AntSlowLogger(arguments);
+}
+function slowLoggingExternal() {
+    return NOOP_LOGGER;
+}
+/**
+ * Tagged template for slow operation logging.
+ *
+ * In ANT builds: creates an AntSlowLogger that times the operation and logs
+ * if it exceeds the threshold. Description is built lazily only when slow.
+ *
+ * In external builds: returns a singleton no-op disposable. Zero allocations,
+ * zero timing. AntSlowLogger and buildDescription are dead-code-eliminated.
+ *
+ * @example
+ * using _ = slowLogging`structuredClone(${value})`
+ * const result = structuredClone(value)
+ */
+export const slowLogging = feature('SLOW_OPERATION_LOGGING') ? slowLoggingAnt : slowLoggingExternal;
+export function jsonStringify(value, replacer, space) {
+    const env_1 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_1, slowLogging `JSON.stringify(${value})`, false);
+        return JSON.stringify(value, replacer, space);
+    }
+    catch (e_1) {
+        env_1.error = e_1;
+        env_1.hasError = true;
+    }
+    finally {
+        __disposeResources(env_1);
+    }
+}
+/**
+ * Wrapped JSON.parse with slow operation logging.
+ * Use this instead of JSON.parse directly to detect performance issues.
+ *
+ * @example
+ * import { jsonParse } from './slowOperations.js'
+ * const data = jsonParse(jsonString)
+ */
+export const jsonParse = (text, reviver) => {
+    const env_2 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_2, slowLogging `JSON.parse(${text})`
+        // V8 de-opts JSON.parse when a second argument is passed, even if undefined.
+        // Branch explicitly so the common (no-reviver) path stays on the fast path.
+        , false);
+        // V8 de-opts JSON.parse when a second argument is passed, even if undefined.
+        // Branch explicitly so the common (no-reviver) path stays on the fast path.
+        return typeof reviver === 'undefined'
+            ? JSON.parse(text)
+            : JSON.parse(text, reviver);
+    }
+    catch (e_2) {
+        env_2.error = e_2;
+        env_2.hasError = true;
+    }
+    finally {
+        __disposeResources(env_2);
+    }
+};
+/**
+ * Wrapped structuredClone with slow operation logging.
+ * Use this instead of structuredClone directly to detect performance issues.
+ *
+ * @example
+ * import { clone } from './slowOperations.js'
+ * const copy = clone(originalObject)
+ */
+export function clone(value, options) {
+    const env_3 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_3, slowLogging `structuredClone(${value})`, false);
+        return structuredClone(value, options);
+    }
+    catch (e_3) {
+        env_3.error = e_3;
+        env_3.hasError = true;
+    }
+    finally {
+        __disposeResources(env_3);
+    }
+}
+/**
+ * Wrapped cloneDeep with slow operation logging.
+ * Use this instead of lodash cloneDeep directly to detect performance issues.
+ *
+ * @example
+ * import { cloneDeep } from './slowOperations.js'
+ * const copy = cloneDeep(originalObject)
+ */
+export function cloneDeep(value) {
+    const env_4 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_4, slowLogging `cloneDeep(${value})`, false);
+        return lodashCloneDeep(value);
+    }
+    catch (e_4) {
+        env_4.error = e_4;
+        env_4.hasError = true;
+    }
+    finally {
+        __disposeResources(env_4);
+    }
+}
+/**
+ * Wrapper around fs.writeFileSync with slow operation logging.
+ * Supports flush option to ensure data is written to disk before returning.
+ * @param filePath The path to the file to write to
+ * @param data The data to write (string or Buffer)
+ * @param options Optional write options (encoding, mode, flag, flush)
+ * @deprecated Use `fs.promises.writeFile` instead for non-blocking writes.
+ * Sync file writes block the event loop and cause performance issues.
+ */
+export function writeFileSync_DEPRECATED(filePath, data, options) {
+    const env_5 = { stack: [], error: void 0, hasError: false };
+    try {
+        const _ = __addDisposableResource(env_5, slowLogging `fs.writeFileSync(${filePath}, ${data})`
+        // Check if flush is requested (for object-style options)
+        , false);
+        // Check if flush is requested (for object-style options)
+        const needsFlush = options !== null &&
+            typeof options === 'object' &&
+            'flush' in options &&
+            options.flush === true;
+        if (needsFlush) {
+            // Manual flush: open file, write, fsync, close
+            const encoding = typeof options === 'object' && 'encoding' in options
+                ? options.encoding
+                : undefined;
+            const mode = typeof options === 'object' && 'mode' in options
+                ? options.mode
+                : undefined;
+            let fd;
+            try {
+                fd = openSync(filePath, 'w', mode);
+                fsWriteFileSync(fd, data, { encoding: encoding ?? undefined });
+                fsyncSync(fd);
+            }
+            finally {
+                if (fd !== undefined) {
+                    closeSync(fd);
+                }
+            }
+        }
+        else {
+            // No flush needed, use standard writeFileSync
+            fsWriteFileSync(filePath, data, options);
+        }
+    }
+    catch (e_5) {
+        env_5.error = e_5;
+        env_5.hasError = true;
+    }
+    finally {
+        __disposeResources(env_5);
+    }
+}

package/dist/src/utils/standaloneAgent.js

@@ -0,0 +1,20 @@
+/**
+ * Standalone agent utilities for sessions with custom names/colors
+ *
+ * These helpers provide access to standalone agent context (name and color)
+ * for sessions that are NOT part of a swarm team. When a session is part
+ * of a swarm, these functions return undefined to let swarm context take
+ * precedence.
+ */
+import { getTeamName } from './teammate.js';
+/**
+ * Returns the standalone agent name if set and not a swarm teammate.
+ * Uses getTeamName() for consistency with isTeammate() swarm detection.
+ */
+export function getStandaloneAgentName(appState) {
+    // If in a team (swarm), don't return standalone name
+    if (getTeamName()) {
+        return undefined;
+    }
+    return appState.standaloneAgentContext?.name;
+}

package/dist/src/utils/startupProfiler.js

@@ -0,0 +1,158 @@
+/**
+ * Startup profiling utility for measuring and reporting time spent in various
+ * initialization phases.
+ *
+ * Two modes:
+ * 1. Sampled logging: 100% of ant users, 0.1% of external users - logs phases to Statsig
+ * 2. Detailed profiling: CLAUDE_CODE_PROFILE_STARTUP=1 - full report with memory snapshots
+ *
+ * Uses Node.js built-in performance hooks API for standard timing measurement.
+ */
+import { dirname, join } from 'path';
+import { appendFileSync } from 'fs';
+import { getSessionId } from '../bootstrap/state.js';
+import { logEvent, } from '../services/analytics/index.js';
+import { logForDebugging } from './debug.js';
+import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js';
+import { getFsImplementation } from './fsOperations.js';
+import { formatMs, formatTimelineLine, getPerformance } from './profilerBase.js';
+import { writeFileSync_DEPRECATED } from './slowOperations.js';
+// Module-level state - decided once at module load
+// eslint-disable-next-line custom-rules/no-process-env-top-level
+const DETAILED_PROFILING = isEnvTruthy(process.env.CLAUDE_CODE_PROFILE_STARTUP);
+// Sampling for Statsig logging: 100% ant, 0.5% external
+// Decision made once at startup - non-sampled users pay no profiling cost
+const STATSIG_SAMPLE_RATE = 0.005;
+// eslint-disable-next-line custom-rules/no-process-env-top-level
+const STATSIG_LOGGING_SAMPLED = process.env.USER_TYPE === 'ant' || Math.random() < STATSIG_SAMPLE_RATE;
+// Enable profiling if either detailed mode OR sampled for Statsig
+const SHOULD_PROFILE = DETAILED_PROFILING || STATSIG_LOGGING_SAMPLED;
+// Track memory snapshots separately (perf_hooks doesn't track memory).
+// Only used when DETAILED_PROFILING is enabled.
+// Stored as an array that appends in the same order as perf.mark() calls, so
+// memorySnapshots[i] corresponds to getEntriesByType('mark')[i]. Using a Map
+// keyed by checkpoint name is wrong because some checkpoints fire more than
+// once (e.g. loadSettingsFromDisk_start fires during init and again after
+// plugins reset the settings cache), and the second call would overwrite the
+// first's memory snapshot.
+const memorySnapshots = [];
+// Phase definitions for Statsig logging: [startCheckpoint, endCheckpoint]
+const PHASE_DEFINITIONS = {
+    import_time: ['cli_entry', 'main_tsx_imports_loaded'],
+    init_time: ['init_function_start', 'init_function_end'],
+    settings_time: ['eagerLoadSettings_start', 'eagerLoadSettings_end'],
+    total_time: ['cli_entry', 'main_after_run'],
+};
+// Record initial checkpoint if profiling is enabled
+if (SHOULD_PROFILE) {
+    // eslint-disable-next-line custom-rules/no-top-level-side-effects
+    profileCheckpoint('profiler_initialized');
+}
+/**
+ * Record a checkpoint with the given name
+ */
+export function profileCheckpoint(name) {
+    if (!SHOULD_PROFILE)
+        return;
+    const perf = getPerformance();
+    perf.mark(name);
+    if (process.env.CONTEXT_CODE_CHECKPOINT_LOG) {
+        try {
+            appendFileSync(process.env.CONTEXT_CODE_CHECKPOINT_LOG, `${new Date().toISOString()} ${name}\n`, 'utf8');
+        }
+        catch {
+            // Best effort only.
+        }
+    }
+    // Only capture memory when detailed profiling enabled (env var)
+    if (DETAILED_PROFILING) {
+        memorySnapshots.push(process.memoryUsage());
+    }
+}
+/**
+ * Get a formatted report of all checkpoints
+ * Only available when DETAILED_PROFILING is enabled
+ */
+function getReport() {
+    if (!DETAILED_PROFILING) {
+        return 'Startup profiling not enabled';
+    }
+    const perf = getPerformance();
+    const marks = perf.getEntriesByType('mark');
+    if (marks.length === 0) {
+        return 'No profiling checkpoints recorded';
+    }
+    const lines = [];
+    lines.push('='.repeat(80));
+    lines.push('STARTUP PROFILING REPORT');
+    lines.push('='.repeat(80));
+    lines.push('');
+    let prevTime = 0;
+    for (const [i, mark] of marks.entries()) {
+        lines.push(formatTimelineLine(mark.startTime, mark.startTime - prevTime, mark.name, memorySnapshots[i], 8, 7));
+        prevTime = mark.startTime;
+    }
+    const lastMark = marks[marks.length - 1];
+    lines.push('');
+    lines.push(`Total startup time: ${formatMs(lastMark?.startTime ?? 0)}ms`);
+    lines.push('='.repeat(80));
+    return lines.join('\n');
+}
+let reported = false;
+export function profileReport() {
+    if (reported)
+        return;
+    reported = true;
+    // Log to Statsig (sampled: 100% ant, 0.1% external)
+    logStartupPerf();
+    // Output detailed report if CLAUDE_CODE_PROFILE_STARTUP=1
+    if (DETAILED_PROFILING) {
+        // Write to file
+        const path = getStartupPerfLogPath();
+        const dir = dirname(path);
+        const fs = getFsImplementation();
+        fs.mkdirSync(dir);
+        writeFileSync_DEPRECATED(path, getReport(), {
+            encoding: 'utf8',
+            flush: true,
+        });
+        logForDebugging('Startup profiling report:');
+        logForDebugging(getReport());
+    }
+}
+export function isDetailedProfilingEnabled() {
+    return DETAILED_PROFILING;
+}
+export function getStartupPerfLogPath() {
+    return join(getClaudeConfigHomeDir(), 'startup-perf', `${getSessionId()}.txt`);
+}
+/**
+ * Log startup performance phases to Statsig.
+ * Only logs if this session was sampled at startup.
+ */
+export function logStartupPerf() {
+    // Only log if we were sampled (decision made at module load)
+    if (!STATSIG_LOGGING_SAMPLED)
+        return;
+    const perf = getPerformance();
+    const marks = perf.getEntriesByType('mark');
+    if (marks.length === 0)
+        return;
+    // Build checkpoint lookup
+    const checkpointTimes = new Map();
+    for (const mark of marks) {
+        checkpointTimes.set(mark.name, mark.startTime);
+    }
+    // Compute phase durations
+    const metadata = {};
+    for (const [phaseName, [startCheckpoint, endCheckpoint]] of Object.entries(PHASE_DEFINITIONS)) {
+        const startTime = checkpointTimes.get(startCheckpoint);
+        const endTime = checkpointTimes.get(endCheckpoint);
+        if (startTime !== undefined && endTime !== undefined) {
+            metadata[`${phaseName}_ms`] = Math.round(endTime - startTime);
+        }
+    }
+    // Add checkpoint count for debugging
+    metadata.checkpoint_count = marks.length;
+    logEvent('tengu_startup_perf', metadata);
+}

package/dist/src/utils/staticRender.js

@@ -0,0 +1,103 @@
+import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
+import { c as _c } from "react/compiler-runtime";
+import { useLayoutEffect } from 'react';
+import { PassThrough } from 'stream';
+import stripAnsi from 'strip-ansi';
+import { render, useApp } from '../ink.js';
+// This is a workaround for the fact that Ink doesn't support multiple <Static>
+// components in the same render tree. Instead of using a <Static> we just render
+// the component to a string and then print it to stdout
+/**
+ * Wrapper component that exits after rendering.
+ * Uses useLayoutEffect to ensure we wait for React's commit phase to complete
+ * before exiting. This is more robust than process.nextTick() for React 19's
+ * async render cycle.
+ */
+function RenderOnceAndExit(t0) {
+    const $ = _c(5);
+    const { children } = t0;
+    const { exit } = useApp();
+    let t1;
+    let t2;
+    if ($[0] !== exit) {
+        t1 = () => {
+            const timer = setTimeout(exit, 0);
+            return () => clearTimeout(timer);
+        };
+        t2 = [exit];
+        $[0] = exit;
+        $[1] = t1;
+        $[2] = t2;
+    }
+    else {
+        t1 = $[1];
+        t2 = $[2];
+    }
+    useLayoutEffect(t1, t2);
+    let t3;
+    if ($[3] !== children) {
+        t3 = _jsx(_Fragment, { children: children });
+        $[3] = children;
+        $[4] = t3;
+    }
+    else {
+        t3 = $[4];
+    }
+    return t3;
+}
+// DEC synchronized update markers used by terminals
+const SYNC_START = '\x1B[?2026h';
+const SYNC_END = '\x1B[?2026l';
+/**
+ * Extracts content from the first complete frame in Ink's output.
+ * Ink with non-TTY stdout outputs multiple frames, each wrapped in DEC synchronized
+ * update sequences ([?2026h ... [?2026l). We only want the first frame's content.
+ */
+function extractFirstFrame(output) {
+    const startIndex = output.indexOf(SYNC_START);
+    if (startIndex === -1)
+        return output;
+    const contentStart = startIndex + SYNC_START.length;
+    const endIndex = output.indexOf(SYNC_END, contentStart);
+    if (endIndex === -1)
+        return output;
+    return output.slice(contentStart, endIndex);
+}
+/**
+ * Renders a React node to a string with ANSI escape codes (for terminal output).
+ */
+export function renderToAnsiString(node, columns) {
+    return new Promise(async (resolve) => {
+        let output = '';
+        // Capture all writes. Set .columns so Ink (ink.tsx:~165) picks up a
+        // chosen width instead of PassThrough's undefined → 80 fallback —
+        // useful for rendering at terminal width for file dumps that should
+        // match what the user sees on screen.
+        const stream = new PassThrough();
+        if (columns !== undefined) {
+            ;
+            stream.columns = columns;
+        }
+        stream.on('data', chunk => {
+            output += chunk.toString();
+        });
+        // Render the component wrapped in RenderOnceAndExit
+        // Non-TTY stdout (PassThrough) gives full-frame output instead of diffs
+        const instance = await render(_jsx(RenderOnceAndExit, { children: node }), {
+            stdout: stream,
+            patchConsole: false
+        });
+        // Wait for the component to exit naturally
+        await instance.waitUntilExit();
+        // Extract only the first frame's content to avoid duplication
+        // (Ink outputs multiple frames in non-TTY mode)
+        await resolve(extractFirstFrame(output));
+    });
+}
+/**
+ * Renders a React node to a plain text string (ANSI codes stripped).
+ */
+export async function renderToString(node, columns) {
+    const output = await renderToAnsiString(node, columns);
+    return stripAnsi(output);
+}