@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/ShellCommand.js

@@ -1,338 +0,0 @@
-var _a;
-import { stat } from 'fs/promises';
-import treeKill from 'tree-kill';
-import { generateTaskId } from '../Task.js';
-import { formatDuration } from './format.js';
-import { MAX_TASK_OUTPUT_BYTES, MAX_TASK_OUTPUT_BYTES_DISPLAY, } from './task/diskOutput.js';
-import { TaskOutput } from './task/TaskOutput.js';
-const SIGKILL = 137;
-const SIGTERM = 143;
-// Background tasks write stdout/stderr directly to a file fd (no JS involvement),
-// so a stuck append loop can fill the disk. Poll file size and kill when exceeded.
-const SIZE_WATCHDOG_INTERVAL_MS = 5_000;
-function prependStderr(prefix, stderr) {
-    return stderr ? `${prefix} ${stderr}` : prefix;
-}
-/**
- * Thin pipe from a child process stream into TaskOutput.
- * Used in pipe mode (hooks) for stdout and stderr.
- * In file mode (bash commands), both fds go to the output file —
- * the child process streams are null and no wrappers are created.
- */
-class StreamWrapper {
-    #stream;
-    #isCleanedUp = false;
-    #taskOutput;
-    #isStderr;
-    #onData = this.#dataHandler.bind(this);
-    constructor(stream, taskOutput, isStderr) {
-        this.#stream = stream;
-        this.#taskOutput = taskOutput;
-        this.#isStderr = isStderr;
-        // Emit strings instead of Buffers - avoids repeated .toString() calls
-        stream.setEncoding('utf-8');
-        stream.on('data', this.#onData);
-    }
-    #dataHandler(data) {
-        const str = typeof data === 'string' ? data : data.toString();
-        if (this.#isStderr) {
-            this.#taskOutput.writeStderr(str);
-        }
-        else {
-            this.#taskOutput.writeStdout(str);
-        }
-    }
-    cleanup() {
-        if (this.#isCleanedUp) {
-            return;
-        }
-        this.#isCleanedUp = true;
-        this.#stream.removeListener('data', this.#onData);
-        // Release references so the stream, its StringDecoder, and
-        // the TaskOutput can be GC'd independently of this wrapper.
-        this.#stream = null;
-        this.#taskOutput = null;
-        this.#onData = () => { };
-    }
-}
-/**
- * Implementation of ShellCommand that wraps a child process.
- *
- * For bash commands: both stdout and stderr go to a file fd via
- * stdio[1] and stdio[2] — no JS involvement. Progress is extracted
- * by polling the file tail.
- * For hooks: pipe mode with StreamWrappers for real-time detection.
- */
-class ShellCommandImpl {
-    #status = 'running';
-    #backgroundTaskId;
-    #stdoutWrapper;
-    #stderrWrapper;
-    #childProcess;
-    #timeoutId = null;
-    #sizeWatchdog = null;
-    #killedForSize = false;
-    #maxOutputBytes;
-    #abortSignal;
-    #onTimeoutCallback;
-    #timeout;
-    #shouldAutoBackground;
-    #resultResolver = null;
-    #exitCodeResolver = null;
-    #boundAbortHandler = null;
-    taskOutput;
-    static #handleTimeout(self) {
-        if (self.#shouldAutoBackground && self.#onTimeoutCallback) {
-            self.#onTimeoutCallback(self.background.bind(self));
-        }
-        else {
-            self.#doKill(SIGTERM);
-        }
-    }
-    result;
-    onTimeout;
-    constructor(childProcess, abortSignal, timeout, taskOutput, shouldAutoBackground = false, maxOutputBytes = MAX_TASK_OUTPUT_BYTES) {
-        this.#childProcess = childProcess;
-        this.#abortSignal = abortSignal;
-        this.#timeout = timeout;
-        this.#shouldAutoBackground = shouldAutoBackground;
-        this.#maxOutputBytes = maxOutputBytes;
-        this.taskOutput = taskOutput;
-        // In file mode (bash commands), both stdout and stderr go to the
-        // output file fd — childProcess.stdout/.stderr are both null.
-        // In pipe mode (hooks), wrap streams to funnel data into TaskOutput.
-        this.#stderrWrapper = childProcess.stderr
-            ? new StreamWrapper(childProcess.stderr, taskOutput, true)
-            : null;
-        this.#stdoutWrapper = childProcess.stdout
-            ? new StreamWrapper(childProcess.stdout, taskOutput, false)
-            : null;
-        if (shouldAutoBackground) {
-            this.onTimeout = (callback) => {
-                this.#onTimeoutCallback = callback;
-            };
-        }
-        this.result = this.#createResultPromise();
-    }
-    get status() {
-        return this.#status;
-    }
-    #abortHandler() {
-        // On 'interrupt' (user submitted a new message), don't kill — let the
-        // caller background the process so the model can see partial output.
-        if (this.#abortSignal.reason === 'interrupt') {
-            return;
-        }
-        this.kill();
-    }
-    #exitHandler(code, signal) {
-        const exitCode = code !== null && code !== undefined
-            ? code
-            : signal === 'SIGTERM'
-                ? 144
-                : 1;
-        this.#resolveExitCode(exitCode);
-    }
-    #errorHandler() {
-        this.#resolveExitCode(1);
-    }
-    #resolveExitCode(code) {
-        if (this.#exitCodeResolver) {
-            this.#exitCodeResolver(code);
-            this.#exitCodeResolver = null;
-        }
-    }
-    // Note: exit/error listeners are NOT removed here — they're needed for
-    // the result promise to resolve. They clean up when the child process exits.
-    #cleanupListeners() {
-        this.#clearSizeWatchdog();
-        const timeoutId = this.#timeoutId;
-        if (timeoutId) {
-            clearTimeout(timeoutId);
-            this.#timeoutId = null;
-        }
-        const boundAbortHandler = this.#boundAbortHandler;
-        if (boundAbortHandler) {
-            this.#abortSignal.removeEventListener('abort', boundAbortHandler);
-            this.#boundAbortHandler = null;
-        }
-    }
-    #clearSizeWatchdog() {
-        if (this.#sizeWatchdog) {
-            clearInterval(this.#sizeWatchdog);
-            this.#sizeWatchdog = null;
-        }
-    }
-    #startSizeWatchdog() {
-        this.#sizeWatchdog = setInterval(() => {
-            void stat(this.taskOutput.path).then(s => {
-                // Bail if the watchdog was cleared while this stat was in flight
-                // (process exited on its own) — otherwise we'd mislabel stderr.
-                if (s.size > this.#maxOutputBytes &&
-                    this.#status === 'backgrounded' &&
-                    this.#sizeWatchdog !== null) {
-                    this.#killedForSize = true;
-                    this.#clearSizeWatchdog();
-                    this.#doKill(SIGKILL);
-                }
-            }, () => {
-                // ENOENT before first write, or unlinked mid-run — skip this tick
-            });
-        }, SIZE_WATCHDOG_INTERVAL_MS);
-        this.#sizeWatchdog.unref();
-    }
-    #createResultPromise() {
-        this.#boundAbortHandler = this.#abortHandler.bind(this);
-        this.#abortSignal.addEventListener('abort', this.#boundAbortHandler, {
-            once: true,
-        });
-        // Use 'exit' not 'close': 'close' waits for stdio to close, which includes
-        // grandchild processes that inherit file descriptors (e.g. `sleep 30 &`).
-        // 'exit' fires when the shell itself exits, returning control immediately.
-        this.#childProcess.once('exit', this.#exitHandler.bind(this));
-        this.#childProcess.once('error', this.#errorHandler.bind(this));
-        this.#timeoutId = setTimeout(_a.#handleTimeout, this.#timeout, this);
-        const exitPromise = new Promise(resolve => {
-            this.#exitCodeResolver = resolve;
-        });
-        return new Promise(resolve => {
-            this.#resultResolver = resolve;
-            void exitPromise.then(this.#handleExit.bind(this));
-        });
-    }
-    async #handleExit(code) {
-        this.#cleanupListeners();
-        if (this.#status === 'running' || this.#status === 'backgrounded') {
-            this.#status = 'completed';
-        }
-        const stdout = await this.taskOutput.getStdout();
-        const result = {
-            code,
-            stdout,
-            stderr: this.taskOutput.getStderr(),
-            interrupted: code === SIGKILL,
-            backgroundTaskId: this.#backgroundTaskId,
-        };
-        if (this.taskOutput.stdoutToFile && !this.#backgroundTaskId) {
-            if (this.taskOutput.outputFileRedundant) {
-                // Small file — full content is in result.stdout, delete the file
-                void this.taskOutput.deleteOutputFile();
-            }
-            else {
-                // Large file — tell the caller where the full output lives
-                result.outputFilePath = this.taskOutput.path;
-                result.outputFileSize = this.taskOutput.outputFileSize;
-                result.outputTaskId = this.taskOutput.taskId;
-            }
-        }
-        if (this.#killedForSize) {
-            result.stderr = prependStderr(`Background command killed: output file exceeded ${MAX_TASK_OUTPUT_BYTES_DISPLAY}`, result.stderr);
-        }
-        else if (code === SIGTERM) {
-            result.stderr = prependStderr(`Command timed out after ${formatDuration(this.#timeout)}`, result.stderr);
-        }
-        const resultResolver = this.#resultResolver;
-        if (resultResolver) {
-            this.#resultResolver = null;
-            resultResolver(result);
-        }
-    }
-    #doKill(code) {
-        this.#status = 'killed';
-        if (this.#childProcess.pid) {
-            treeKill(this.#childProcess.pid, 'SIGKILL');
-        }
-        this.#resolveExitCode(code ?? SIGKILL);
-    }
-    kill() {
-        this.#doKill();
-    }
-    background(taskId) {
-        if (this.#status === 'running') {
-            this.#backgroundTaskId = taskId;
-            this.#status = 'backgrounded';
-            this.#cleanupListeners();
-            if (this.taskOutput.stdoutToFile) {
-                // File mode: child writes directly to the fd with no JS involvement.
-                // The foreground timeout is gone, so watch file size to prevent
-                // a stuck append loop from filling the disk (768GB incident).
-                this.#startSizeWatchdog();
-            }
-            else {
-                // Pipe mode: spill the in-memory buffer so readers can find it on disk.
-                this.taskOutput.spillToDisk();
-            }
-            return true;
-        }
-        return false;
-    }
-    cleanup() {
-        this.#stdoutWrapper?.cleanup();
-        this.#stderrWrapper?.cleanup();
-        this.taskOutput.clear();
-        // Must run before nulling #abortSignal — #cleanupListeners() calls
-        // removeEventListener on it. Without this, a kill()+cleanup() sequence
-        // crashes: kill() queues #handleExit as a microtask, cleanup() nulls
-        // #abortSignal, then #handleExit runs #cleanupListeners() on the null ref.
-        this.#cleanupListeners();
-        // Release references to allow GC of ChildProcess internals and AbortController chain
-        this.#childProcess = null;
-        this.#abortSignal = null;
-        this.#onTimeoutCallback = undefined;
-    }
-}
-_a = ShellCommandImpl;
-/**
- * Wraps a child process to enable flexible handling of shell command execution.
- */
-export function wrapSpawn(childProcess, abortSignal, timeout, taskOutput, shouldAutoBackground = false, maxOutputBytes = MAX_TASK_OUTPUT_BYTES) {
-    return new ShellCommandImpl(childProcess, abortSignal, timeout, taskOutput, shouldAutoBackground, maxOutputBytes);
-}
-/**
- * Static ShellCommand implementation for commands that were aborted before execution.
- */
-class AbortedShellCommand {
-    status = 'killed';
-    result;
-    taskOutput;
-    constructor(opts) {
-        this.taskOutput = new TaskOutput(generateTaskId('local_bash'), null);
-        this.result = Promise.resolve({
-            code: opts?.code ?? 145,
-            stdout: '',
-            stderr: opts?.stderr ?? 'Command aborted before execution',
-            interrupted: true,
-            backgroundTaskId: opts?.backgroundTaskId,
-        });
-    }
-    background() {
-        return false;
-    }
-    kill() { }
-    cleanup() { }
-}
-export function createAbortedCommand(backgroundTaskId, opts) {
-    return new AbortedShellCommand({
-        backgroundTaskId,
-        ...opts,
-    });
-}
-export function createFailedCommand(preSpawnError) {
-    const taskOutput = new TaskOutput(generateTaskId('local_bash'), null);
-    return {
-        status: 'completed',
-        result: Promise.resolve({
-            code: 1,
-            stdout: '',
-            stderr: preSpawnError,
-            interrupted: false,
-            preSpawnError,
-        }),
-        taskOutput,
-        background() {
-            return false;
-        },
-        kill() { },
-        cleanup() { },
-    };
-}

package/dist/src/utils/abortController.js

@@ -1,74 +0,0 @@
-import { setMaxListeners } from 'events';
-/**
- * Default max listeners for standard operations
- */
-const DEFAULT_MAX_LISTENERS = 50;
-/**
- * Creates an AbortController with proper event listener limits set.
- * This prevents MaxListenersExceededWarning when multiple listeners
- * are attached to the abort signal.
- *
- * @param maxListeners - Maximum number of listeners (default: 50)
- * @returns AbortController with configured listener limit
- */
-export function createAbortController(maxListeners = DEFAULT_MAX_LISTENERS) {
-    const controller = new AbortController();
-    setMaxListeners(maxListeners, controller.signal);
-    return controller;
-}
-/**
- * Propagates abort from a parent to a weakly-referenced child controller.
- * Both parent and child are weakly held — neither direction creates a
- * strong reference that could prevent GC.
- * Module-scope function avoids per-call closure allocation.
- */
-function propagateAbort(weakChild) {
-    const parent = this.deref();
-    weakChild.deref()?.abort(parent?.signal.reason);
-}
-/**
- * Removes an abort handler from a weakly-referenced parent signal.
- * Both parent and handler are weakly held — if either has been GC'd
- * or the parent already aborted ({once: true}), this is a no-op.
- * Module-scope function avoids per-call closure allocation.
- */
-function removeAbortHandler(weakHandler) {
-    const parent = this.deref();
-    const handler = weakHandler.deref();
-    if (parent && handler) {
-        parent.signal.removeEventListener('abort', handler);
-    }
-}
-/**
- * Creates a child AbortController that aborts when its parent aborts.
- * Aborting the child does NOT affect the parent.
- *
- * Memory-safe: Uses WeakRef so the parent doesn't retain abandoned children.
- * If the child is dropped without being aborted, it can still be GC'd.
- * When the child IS aborted, the parent listener is removed to prevent
- * accumulation of dead handlers.
- *
- * @param parent - The parent AbortController
- * @param maxListeners - Maximum number of listeners (default: 50)
- * @returns Child AbortController
- */
-export function createChildAbortController(parent, maxListeners) {
-    const child = createAbortController(maxListeners);
-    // Fast path: parent already aborted, no listener setup needed
-    if (parent.signal.aborted) {
-        child.abort(parent.signal.reason);
-        return child;
-    }
-    // WeakRef prevents the parent from keeping an abandoned child alive.
-    // If all strong references to child are dropped without aborting it,
-    // the child can still be GC'd — the parent only holds a dead WeakRef.
-    const weakChild = new WeakRef(child);
-    const weakParent = new WeakRef(parent);
-    const handler = propagateAbort.bind(weakParent, weakChild);
-    parent.signal.addEventListener('abort', handler, { once: true });
-    // Auto-cleanup: remove parent listener when child is aborted (from any source).
-    // Both parent and handler are weakly held — if either has been GC'd or the
-    // parent already aborted ({once: true}), the cleanup is a harmless no-op.
-    child.signal.addEventListener('abort', removeAbortHandler.bind(weakParent, new WeakRef(handler)), { once: true });
-    return child;
-}

package/dist/src/utils/activityManager.js

@@ -1,127 +0,0 @@
-import { getActiveTimeCounter as getActiveTimeCounterImpl } from '../bootstrap/state.js';
-/**
- * ActivityManager handles generic activity tracking for both user and CLI operations.
- * It automatically deduplicates overlapping activities and provides separate metrics
- * for user vs CLI active time.
- */
-export class ActivityManager {
-    activeOperations = new Set();
-    lastUserActivityTime = 0; // Start with 0 to indicate no activity yet
-    lastCLIRecordedTime;
-    isCLIActive = false;
-    USER_ACTIVITY_TIMEOUT_MS = 5000; // 5 seconds
-    getNow;
-    getActiveTimeCounter;
-    static instance = null;
-    constructor(options) {
-        this.getNow = options?.getNow ?? (() => Date.now());
-        this.getActiveTimeCounter =
-            options?.getActiveTimeCounter ?? getActiveTimeCounterImpl;
-        this.lastCLIRecordedTime = this.getNow();
-    }
-    static getInstance() {
-        if (!ActivityManager.instance) {
-            ActivityManager.instance = new ActivityManager();
-        }
-        return ActivityManager.instance;
-    }
-    /**
-     * Reset the singleton instance (for testing purposes)
-     */
-    static resetInstance() {
-        ActivityManager.instance = null;
-    }
-    /**
-     * Create a new instance with custom options (for testing purposes)
-     */
-    static createInstance(options) {
-        ActivityManager.instance = new ActivityManager(options);
-        return ActivityManager.instance;
-    }
-    /**
-     * Called when user interacts with the CLI (typing, commands, etc.)
-     */
-    recordUserActivity() {
-        // Don't record user time if CLI is active (CLI takes precedence)
-        if (!this.isCLIActive && this.lastUserActivityTime !== 0) {
-            const now = this.getNow();
-            const timeSinceLastActivity = (now - this.lastUserActivityTime) / 1000;
-            if (timeSinceLastActivity > 0) {
-                const activeTimeCounter = this.getActiveTimeCounter();
-                if (activeTimeCounter) {
-                    const timeoutSeconds = this.USER_ACTIVITY_TIMEOUT_MS / 1000;
-                    // Only record time if within the timeout window
-                    if (timeSinceLastActivity < timeoutSeconds) {
-                        activeTimeCounter.add(timeSinceLastActivity, { type: 'user' });
-                    }
-                }
-            }
-        }
-        // Update the last user activity timestamp
-        this.lastUserActivityTime = this.getNow();
-    }
-    /**
-     * Starts tracking CLI activity (tool execution, AI response, etc.)
-     */
-    startCLIActivity(operationId) {
-        // If operation already exists, it likely means the previous one didn't clean up
-        // properly (e.g., component crashed/unmounted without calling end). Force cleanup
-        // to avoid overestimating time - better to underestimate than overestimate.
-        if (this.activeOperations.has(operationId)) {
-            this.endCLIActivity(operationId);
-        }
-        const wasEmpty = this.activeOperations.size === 0;
-        this.activeOperations.add(operationId);
-        if (wasEmpty) {
-            this.isCLIActive = true;
-            this.lastCLIRecordedTime = this.getNow();
-        }
-    }
-    /**
-     * Stops tracking CLI activity
-     */
-    endCLIActivity(operationId) {
-        this.activeOperations.delete(operationId);
-        if (this.activeOperations.size === 0) {
-            // Last operation ended - CLI becoming inactive
-            // Record the CLI time before switching to inactive
-            const now = this.getNow();
-            const timeSinceLastRecord = (now - this.lastCLIRecordedTime) / 1000;
-            if (timeSinceLastRecord > 0) {
-                const activeTimeCounter = this.getActiveTimeCounter();
-                if (activeTimeCounter) {
-                    activeTimeCounter.add(timeSinceLastRecord, { type: 'cli' });
-                }
-            }
-            this.lastCLIRecordedTime = now;
-            this.isCLIActive = false;
-        }
-    }
-    /**
-     * Convenience method to track an async operation automatically (mainly for testing/debugging)
-     */
-    async trackOperation(operationId, fn) {
-        this.startCLIActivity(operationId);
-        try {
-            return await fn();
-        }
-        finally {
-            this.endCLIActivity(operationId);
-        }
-    }
-    /**
-     * Gets current activity states (mainly for testing/debugging)
-     */
-    getActivityStates() {
-        const now = this.getNow();
-        const timeSinceUserActivity = (now - this.lastUserActivityTime) / 1000;
-        const isUserActive = timeSinceUserActivity < this.USER_ACTIVITY_TIMEOUT_MS / 1000;
-        return {
-            isUserActive,
-            isCLIActive: this.isCLIActive,
-            activeOperationCount: this.activeOperations.size,
-        };
-    }
-}
-// Export singleton instance
-export const activityManager = ActivityManager.getInstance();

package/dist/src/utils/advisor.js

@@ -1,77 +0,0 @@
-import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
-import { shouldIncludeFirstPartyOnlyBetas } from './betas.js';
-import { isEnvTruthy } from './envUtils.js';
-import { getInitialSettings } from './settings/settings.js';
-export function isAdvisorBlock(param) {
-    return (param.type === 'advisor_tool_result' ||
-        (param.type === 'server_tool_use' && param.name === 'advisor'));
-}
-function getAdvisorConfig() {
-    return getFeatureValue_CACHED_MAY_BE_STALE('tengu_sage_compass', {});
-}
-export function isAdvisorEnabled() {
-    if (isEnvTruthy(process.env.CLAUDE_CODE_DISABLE_ADVISOR_TOOL)) {
-        return false;
-    }
-    // The advisor beta header is first-party only (Bedrock/Vertex 400 on it).
-    if (!shouldIncludeFirstPartyOnlyBetas()) {
-        return false;
-    }
-    return getAdvisorConfig().enabled ?? false;
-}
-export function canUserConfigureAdvisor() {
-    return isAdvisorEnabled() && (getAdvisorConfig().canUserConfigure ?? false);
-}
-export function getExperimentAdvisorModels() {
-    const config = getAdvisorConfig();
-    return isAdvisorEnabled() &&
-        !canUserConfigureAdvisor() &&
-        config.baseModel &&
-        config.advisorModel
-        ? { baseModel: config.baseModel, advisorModel: config.advisorModel }
-        : undefined;
-}
-// @[MODEL LAUNCH]: Add the new model if it supports the advisor tool.
-// Checks whether the main loop model supports calling the advisor tool.
-export function modelSupportsAdvisor(model) {
-    const m = model.toLowerCase();
-    return (m.includes('opus-4-6') ||
-        m.includes('sonnet-4-6') ||
-        process.env.USER_TYPE === 'ant');
-}
-// @[MODEL LAUNCH]: Add the new model if it can serve as an advisor model.
-export function isValidAdvisorModel(model) {
-    const m = model.toLowerCase();
-    return (m.includes('opus-4-6') ||
-        m.includes('sonnet-4-6') ||
-        process.env.USER_TYPE === 'ant');
-}
-export function getInitialAdvisorSetting() {
-    if (!isAdvisorEnabled()) {
-        return undefined;
-    }
-    return getInitialSettings().advisorModel;
-}
-export function getAdvisorUsage(usage) {
-    const iterations = usage.iterations;
-    if (!iterations) {
-        return [];
-    }
-    return iterations.filter(it => it.type === 'advisor_message');
-}
-export const ADVISOR_TOOL_INSTRUCTIONS = `# Advisor Tool
-
-You have access to an \`advisor\` tool backed by a stronger reviewer model. It takes NO parameters -- when you call it, your entire conversation history is automatically forwarded. The advisor sees the task, every tool call you've made, every result you've seen.
-
-Call advisor BEFORE substantive work -- before writing code, before committing to an interpretation, before building on an assumption. If the task requires orientation first (finding files, reading code, seeing what's there), do that, then call advisor. Orientation is not substantive work. Writing, editing, and declaring an answer are.
-
-Also call advisor:
-- When you believe the task is complete. BEFORE this call, make your deliverable durable: write the file, stage the change, save the result. The advisor call takes time; if the session ends during it, a durable result persists and an unwritten one doesn't.
-- When stuck -- errors recurring, approach not converging, results that don't fit.
-- When considering a change of approach.
-
-On tasks longer than a few steps, call advisor at least once before committing to an approach and once before declaring done. On short reactive tasks where the next action is dictated by tool output you just read, you don't need to keep calling -- the advisor adds most of its value on the first call, before the approach crystallizes.
-
-Give the advice serious weight. If you follow a step and it fails empirically, or you have primary-source evidence that contradicts a specific claim (the file says X, the code does Y), adapt. A passing self-test is not evidence the advice is wrong -- it's evidence your test doesn't check what the advice is checking.
-
-If you've already retrieved data pointing one way and the advisor points another: don't silently switch. Surface the conflict in one more advisor call -- "I found X, you suggest Y, which constraint breaks the tie?" The advisor saw your evidence but may have underweighted it; a reconcile call is cheaper than committing to the wrong branch.`;