@iaforged/context-code 1.0.63 → 1.0.65

package/dist/src/utils/effort.js

@@ -1,278 +0,0 @@
-// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
-import { isUltrathinkEnabled } from './thinking.js';
-import { getInitialSettings } from './settings/settings.js';
-import { isProSubscriber, isMaxSubscriber, isTeamSubscriber } from './auth.js';
-import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
-import { getAPIProvider } from './model/providers.js';
-import { get3PModelCapabilityOverride } from './model/modelSupportOverrides.js';
-import { isEnvTruthy } from './envUtils.js';
-export const EFFORT_LEVELS = [
-    'low',
-    'medium',
-    'high',
-    'max',
-];
-// @[MODEL LAUNCH]: Add the new model to the allowlist if it supports the effort parameter.
-export function modelSupportsEffort(model) {
-    const m = model.toLowerCase();
-    if (isEnvTruthy(process.env.CLAUDE_CODE_ALWAYS_ENABLE_EFFORT)) {
-        return true;
-    }
-    const supported3P = get3PModelCapabilityOverride(model, 'effort');
-    if (supported3P !== undefined) {
-        return supported3P;
-    }
-    // Supported by a subset of Claude 4 models
-    if (m.includes('opus-4-7') || m.includes('opus-4-6') || m.includes('sonnet-4-6')) {
-        return true;
-    }
-    // Exclude any other known legacy models (haiku, older opus/sonnet variants)
-    if (m.includes('haiku') || m.includes('sonnet') || m.includes('opus')) {
-        return false;
-    }
-    // IMPORTANT: Do not change the default effort support without notifying
-    // the model launch DRI and research. This is a sensitive setting that can
-    // greatly affect model quality and bashing.
-    // Default to true for unknown model strings on 1P.
-    // Do not default to true for 3P as they have different formats for their
-    // model strings (ex. anthropics/claude-code#30795)
-    return getAPIProvider() === 'firstParty';
-}
-// @[MODEL LAUNCH]: Add the new model to the allowlist if it supports 'max' effort.
-// Per API docs, 'max' is Opus 4.6 only for public models — other models return an error.
-export function modelSupportsMaxEffort(model) {
-    const supported3P = get3PModelCapabilityOverride(model, 'max_effort');
-    if (supported3P !== undefined) {
-        return supported3P;
-    }
-    if (model.toLowerCase().includes('opus-4-7') || model.toLowerCase().includes('opus-4-6')) {
-        return true;
-    }
-    if (process.env.USER_TYPE === 'ant' && resolveAntModel(model)) {
-        return true;
-    }
-    return false;
-}
-export function isEffortLevel(value) {
-    return EFFORT_LEVELS.includes(value);
-}
-export function parseEffortValue(value) {
-    if (value === undefined || value === null || value === '') {
-        return undefined;
-    }
-    if (typeof value === 'number' && isValidNumericEffort(value)) {
-        return value;
-    }
-    const str = String(value).toLowerCase();
-    if (isEffortLevel(str)) {
-        return str;
-    }
-    const numericValue = parseInt(str, 10);
-    if (!isNaN(numericValue) && isValidNumericEffort(numericValue)) {
-        return numericValue;
-    }
-    return undefined;
-}
-/**
- * Numeric values are model-default only and not persisted.
- * 'max' is session-scoped for external users (ants can persist it).
- * Write sites call this before saving to settings so the Zod schema
- * (which only accepts string levels) never rejects a write.
- */
-export function toPersistableEffort(value) {
-    if (value === 'low' || value === 'medium' || value === 'high') {
-        return value;
-    }
-    if (value === 'max' && process.env.USER_TYPE === 'ant') {
-        return value;
-    }
-    return undefined;
-}
-export function getInitialEffortSetting() {
-    // toPersistableEffort filters 'max' for non-ants on read, so a manually
-    // edited settings.json doesn't leak session-scoped max into a fresh session.
-    return toPersistableEffort(getInitialSettings().effortLevel);
-}
-/**
- * Decide what effort level (if any) to persist when the user selects a model
- * in ModelPicker. Keeps an explicit prior /effort choice sticky even when it
- * matches the picked model's default, while letting purely-default and
- * session-ephemeral effort (CLI --effort, EffortCallout default) fall through
- * to undefined so it follows future model-default changes.
- *
- * priorPersisted must come from userSettings on disk
- * (getSettingsForSource('userSettings')?.effortLevel), NOT merged settings
- * (project/policy layers would leak into the user's global settings.json)
- * and NOT AppState.effortValue (includes session-scoped sources that
- * deliberately do not write to settings.json).
- */
-export function resolvePickerEffortPersistence(picked, modelDefault, priorPersisted, toggledInPicker) {
-    const hadExplicit = priorPersisted !== undefined || toggledInPicker;
-    return hadExplicit || picked !== modelDefault ? picked : undefined;
-}
-export function getEffortEnvOverride() {
-    const envOverride = process.env.CLAUDE_CODE_EFFORT_LEVEL;
-    return envOverride?.toLowerCase() === 'unset' ||
-        envOverride?.toLowerCase() === 'auto'
-        ? null
-        : parseEffortValue(envOverride);
-}
-/**
- * Resolve the effort value that will actually be sent to the API for a given
- * model, following the full precedence chain:
- *   env CLAUDE_CODE_EFFORT_LEVEL → appState.effortValue → model default
- *
- * Returns undefined when no effort parameter should be sent (env set to
- * 'unset', or no default exists for the model).
- */
-export function resolveAppliedEffort(model, appStateEffortValue) {
-    const envOverride = getEffortEnvOverride();
-    if (envOverride === null) {
-        return undefined;
-    }
-    const resolved = envOverride ?? appStateEffortValue ?? getDefaultEffortForModel(model);
-    // API rejects 'max' on non-Opus-4.6 models — downgrade to 'high'.
-    if (resolved === 'max' && !modelSupportsMaxEffort(model)) {
-        return 'high';
-    }
-    return resolved;
-}
-export const levelTranslations = {
-    low: 'bajo',
-    medium: 'medio',
-    high: 'alto',
-    max: 'máximo',
-};
-/**
- * Resolve the effort level to show the user. Wraps resolveAppliedEffort
- * with the 'high' fallback (what the API uses when no effort param is sent).
- * Single source of truth for the status bar and /effort output (CC-1088).
- */
-export function getDisplayedEffortLevel(model, appStateEffort) {
-    const resolved = resolveAppliedEffort(model, appStateEffort) ?? 'high';
-    return convertEffortValueToLevel(resolved);
-}
-/**
- * Build the ` with {level} effort` suffix shown in Logo/Spinner.
- * Returns empty string if the user hasn't explicitly set an effort value.
- * Delegates to resolveAppliedEffort() so the displayed level matches what
- * the API actually receives (including max→high clamp for non-Opus models).
- */
-export function getEffortSuffix(model, effortValue) {
-    if (effortValue === undefined)
-        return '';
-    const resolved = resolveAppliedEffort(model, effortValue);
-    if (resolved === undefined)
-        return '';
-    const level = convertEffortValueToLevel(resolved);
-    return ` con esfuerzo ${levelTranslations[level] ?? level}`;
-}
-export function isValidNumericEffort(value) {
-    return Number.isInteger(value);
-}
-export function convertEffortValueToLevel(value) {
-    if (typeof value === 'string') {
-        // Runtime guard: value may come from remote config (GrowthBook) where
-        // TypeScript types can't help us. Coerce unknown strings to 'high'
-        // rather than passing them through unchecked.
-        return isEffortLevel(value) ? value : 'high';
-    }
-    if (process.env.USER_TYPE === 'ant' && typeof value === 'number') {
-        if (value <= 50)
-            return 'low';
-        if (value <= 85)
-            return 'medium';
-        if (value <= 100)
-            return 'high';
-        return 'max';
-    }
-    return 'high';
-}
-/**
- * Get user-facing description for effort levels
- *
- * @param level The effort level to describe
- * @returns Human-readable description
- */
-export function getEffortLevelDescription(level) {
-    switch (level) {
-        case 'low':
-            return 'Implementación rápida y directa con mínima sobrecarga';
-        case 'medium':
-            return 'Equilibrio entre implementación estándar y pruebas';
-        case 'high':
-            return 'Implementación exhaustiva con pruebas y documentación extensas';
-        case 'max':
-            return 'Capacidad máxima con el razonamiento más profundo (solo Opus 4.6)';
-    }
-}
-/**
- * Get user-facing description for effort values (both string and numeric)
- *
- * @param value The effort value to describe
- * @returns Human-readable description
- */
-export function getEffortValueDescription(value) {
-    if (process.env.USER_TYPE === 'ant' && typeof value === 'number') {
-        return `[SOLO-ANT] Valor de esfuerzo numérico de ${value}`;
-    }
-    if (typeof value === 'string') {
-        return getEffortLevelDescription(value);
-    }
-    return 'Enfoque equilibrado con implementación y pruebas estándar';
-}
-const OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT = {
-    enabled: true,
-    dialogTitle: 'Recomendamos el esfuerzo medio para Opus',
-    dialogDescription: 'El esfuerzo determina cuánto tiempo piensa Context antes de completar tu tarea. Recomendamos el esfuerzo medio para la mayoría de las tareas para equilibrar velocidad e inteligencia y maximizar los límites de frecuencia. Usa ultrathink para activar el esfuerzo alto cuando sea necesario.',
-};
-export function getOpusDefaultEffortConfig() {
-    const config = getFeatureValue_CACHED_MAY_BE_STALE('tengu_grey_step2', OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT);
-    return {
-        ...OPUS_DEFAULT_EFFORT_CONFIG_DEFAULT,
-        ...config,
-    };
-}
-// @[MODEL LAUNCH]: Update the default effort levels for new models
-export function getDefaultEffortForModel(model) {
-    if (process.env.USER_TYPE === 'ant') {
-        const config = getAntModelOverrideConfig();
-        const isDefaultModel = config?.defaultModel !== undefined &&
-            model.toLowerCase() === config.defaultModel.toLowerCase();
-        if (isDefaultModel && config?.defaultModelEffortLevel) {
-            return config.defaultModelEffortLevel;
-        }
-        const antModel = resolveAntModel(model);
-        if (antModel) {
-            if (antModel.defaultEffortLevel) {
-                return antModel.defaultEffortLevel;
-            }
-            if (antModel.defaultEffortValue !== undefined) {
-                return antModel.defaultEffortValue;
-            }
-        }
-        // Always default ants to undefined/high
-        return undefined;
-    }
-    // IMPORTANT: Do not change the default effort level without notifying
-    // the model launch DRI and research. Default effort is a sensitive setting
-    // that can greatly affect model quality and bashing.
-    // Default effort on Opus 4.7/4.6 to medium for Pro.
-    // Max/Team also get medium when the tengu_grey_step2 config is enabled.
-    if (model.toLowerCase().includes('opus-4-7') || model.toLowerCase().includes('opus-4-6')) {
-        if (isProSubscriber()) {
-            return 'medium';
-        }
-        if (getOpusDefaultEffortConfig().enabled &&
-            (isMaxSubscriber() || isTeamSubscriber())) {
-            return 'medium';
-        }
-    }
-    // When ultrathink feature is on, default effort to medium (ultrathink bumps to high)
-    if (isUltrathinkEnabled() && modelSupportsEffort(model)) {
-        return 'medium';
-    }
-    // Fallback to undefined, which means we don't set an effort level. This
-    // should resolve to high effort level in the API.
-    return undefined;
-}

package/dist/src/utils/embeddedTools.js

@@ -1,26 +0,0 @@
-import { isEnvTruthy } from './envUtils.js';
-/**
- * Whether this build has bfs/ugrep embedded in the bun binary (ant-native only).
- *
- * When true:
- * - `find` and `grep` in Claude's Bash shell are shadowed by shell functions
- *   that invoke the bun binary with argv0='bfs' / argv0='ugrep' (same trick
- *   as embedded ripgrep)
- * - The dedicated Glob/Grep tools are removed from the tool registry
- * - Prompt guidance steering Claude away from find/grep is omitted
- *
- * Set as a build-time define in scripts/build-with-plugins.ts for ant-native builds.
- */
-export function hasEmbeddedSearchTools() {
-    if (!isEnvTruthy(process.env.EMBEDDED_SEARCH_TOOLS))
-        return false;
-    const e = process.env.CLAUDE_CODE_ENTRYPOINT;
-    return (e !== 'sdk-ts' && e !== 'sdk-py' && e !== 'sdk-cli' && e !== 'local-agent');
-}
-/**
- * Path to the bun binary that contains the embedded search tools.
- * Only meaningful when hasEmbeddedSearchTools() is true.
- */
-export function embeddedSearchToolsBinaryPath() {
-    return process.execPath;
-}

package/dist/src/utils/env.js

@@ -1,358 +0,0 @@
-import memoize from 'lodash-es/memoize.js';
-import { homedir } from 'os';
-import { join } from 'path';
-import { fileSuffixForOauthConfig } from '../constants/oauth.js';
-import { isRunningWithBun } from './bundledMode.js';
-import { getClaudeConfigHomeDir, isEnvTruthy } from './envUtils.js';
-import { findExecutable } from './findExecutable.js';
-import { getFsImplementation } from './fsOperations.js';
-import { which } from './which.js';
-// Config and data paths
-export const getGlobalClaudeFile = memoize(() => {
-    // Legacy fallback for backwards compatibility
-    if (getFsImplementation().existsSync(join(getClaudeConfigHomeDir(), '.config.json'))) {
-        return join(getClaudeConfigHomeDir(), '.config.json');
-    }
-    const filename = `.claude${fileSuffixForOauthConfig()}.json`;
-    return join(process.env.CLAUDE_CONFIG_DIR || homedir(), filename);
-});
-const hasInternetAccess = memoize(async () => {
-    try {
-        const { default: axiosClient } = await import('axios');
-        await axiosClient.head('http://1.1.1.1', {
-            signal: AbortSignal.timeout(1000),
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-});
-async function isCommandAvailable(command) {
-    try {
-        // which does not execute the file.
-        return !!(await which(command));
-    }
-    catch {
-        return false;
-    }
-}
-const detectPackageManagers = memoize(async () => {
-    const packageManagers = [];
-    if (await isCommandAvailable('npm'))
-        packageManagers.push('npm');
-    if (await isCommandAvailable('yarn'))
-        packageManagers.push('yarn');
-    if (await isCommandAvailable('pnpm'))
-        packageManagers.push('pnpm');
-    return packageManagers;
-});
-const detectRuntimes = memoize(async () => {
-    const runtimes = [];
-    if (await isCommandAvailable('bun'))
-        runtimes.push('bun');
-    if (await isCommandAvailable('deno'))
-        runtimes.push('deno');
-    if (await isCommandAvailable('node'))
-        runtimes.push('node');
-    return runtimes;
-});
-/**
- * Checks if we're running in a WSL environment
- * @returns true if running in WSL, false otherwise
- */
-const isWslEnvironment = memoize(() => {
-    try {
-        // Check for WSLInterop file which is a reliable indicator of WSL
-        return getFsImplementation().existsSync('/proc/sys/fs/binfmt_misc/WSLInterop');
-    }
-    catch (_error) {
-        // If there's an error checking, assume not WSL
-        return false;
-    }
-});
-/**
- * Checks if the npm executable is located in the Windows filesystem within WSL
- * @returns true if npm is from Windows (starts with /mnt/c/), false otherwise
- */
-const isNpmFromWindowsPath = memoize(() => {
-    try {
-        // Only relevant in WSL environment
-        if (!isWslEnvironment()) {
-            return false;
-        }
-        // Find the actual npm executable path
-        const { cmd } = findExecutable('npm', []);
-        // If npm is in Windows path, it will start with /mnt/c/
-        return cmd.startsWith('/mnt/c/');
-    }
-    catch (_error) {
-        // If there's an error, assume it's not from Windows
-        return false;
-    }
-});
-/**
- * Checks if we're running via Conductor
- * @returns true if running via Conductor, false otherwise
- */
-function isConductor() {
-    return process.env.__CFBundleIdentifier === 'com.conductor.app';
-}
-export const JETBRAINS_IDES = [
-    'pycharm',
-    'intellij',
-    'webstorm',
-    'phpstorm',
-    'rubymine',
-    'clion',
-    'goland',
-    'rider',
-    'datagrip',
-    'appcode',
-    'dataspell',
-    'aqua',
-    'gateway',
-    'fleet',
-    'jetbrains',
-    'androidstudio',
-];
-// Detect terminal type with fallbacks for all platforms
-function detectTerminal() {
-    if (process.env.CURSOR_TRACE_ID)
-        return 'cursor';
-    // Cursor and Windsurf under WSL have TERM_PROGRAM=vscode
-    if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('cursor')) {
-        return 'cursor';
-    }
-    if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('windsurf')) {
-        return 'windsurf';
-    }
-    if (process.env.VSCODE_GIT_ASKPASS_MAIN?.includes('antigravity')) {
-        return 'antigravity';
-    }
-    const bundleId = process.env.__CFBundleIdentifier?.toLowerCase();
-    if (bundleId?.includes('vscodium'))
-        return 'codium';
-    if (bundleId?.includes('windsurf'))
-        return 'windsurf';
-    if (bundleId?.includes('com.google.android.studio'))
-        return 'androidstudio';
-    // Check for JetBrains IDEs in bundle ID
-    if (bundleId) {
-        for (const ide of JETBRAINS_IDES) {
-            if (bundleId.includes(ide))
-                return ide;
-        }
-    }
-    if (process.env.VisualStudioVersion) {
-        // This is desktop Visual Studio, not VS Code
-        return 'visualstudio';
-    }
-    // Check for JetBrains terminal on Linux/Windows
-    if (process.env.TERMINAL_EMULATOR === 'JetBrains-JediTerm') {
-        // For macOS, bundle ID detection above already handles JetBrains IDEs
-        if (process.platform === 'darwin')
-            return 'pycharm';
-        // For finegrained detection on Linux/Windows use envDynamic.getTerminalWithJetBrainsDetection()
-        return 'pycharm';
-    }
-    // Check for specific terminals by TERM before TERM_PROGRAM
-    // This handles cases where TERM and TERM_PROGRAM might be inconsistent
-    if (process.env.TERM === 'xterm-ghostty') {
-        return 'ghostty';
-    }
-    if (process.env.TERM?.includes('kitty')) {
-        return 'kitty';
-    }
-    if (process.env.TERM_PROGRAM) {
-        return process.env.TERM_PROGRAM;
-    }
-    if (process.env.TMUX)
-        return 'tmux';
-    if (process.env.STY)
-        return 'screen';
-    // Check for terminal-specific environment variables (common on Linux)
-    if (process.env.KONSOLE_VERSION)
-        return 'konsole';
-    if (process.env.GNOME_TERMINAL_SERVICE)
-        return 'gnome-terminal';
-    if (process.env.XTERM_VERSION)
-        return 'xterm';
-    if (process.env.VTE_VERSION)
-        return 'vte-based';
-    if (process.env.TERMINATOR_UUID)
-        return 'terminator';
-    if (process.env.KITTY_WINDOW_ID) {
-        return 'kitty';
-    }
-    if (process.env.ALACRITTY_LOG)
-        return 'alacritty';
-    if (process.env.TILIX_ID)
-        return 'tilix';
-    // Windows-specific detection
-    if (process.env.WT_SESSION)
-        return 'windows-terminal';
-    if (process.env.SESSIONNAME && process.env.TERM === 'cygwin')
-        return 'cygwin';
-    if (process.env.MSYSTEM)
-        return process.env.MSYSTEM.toLowerCase(); // MINGW64, MSYS2, etc.
-    if (process.env.ConEmuANSI ||
-        process.env.ConEmuPID ||
-        process.env.ConEmuTask) {
-        return 'conemu';
-    }
-    // WSL detection
-    if (process.env.WSL_DISTRO_NAME)
-        return `wsl-${process.env.WSL_DISTRO_NAME}`;
-    // SSH session detection
-    if (isSSHSession()) {
-        return 'ssh-session';
-    }
-    // Fall back to TERM which is more universally available
-    // Special case for common terminal identifiers in TERM
-    if (process.env.TERM) {
-        const term = process.env.TERM;
-        if (term.includes('alacritty'))
-            return 'alacritty';
-        if (term.includes('rxvt'))
-            return 'rxvt';
-        if (term.includes('termite'))
-            return 'termite';
-        return process.env.TERM;
-    }
-    // Detect non-interactive environment
-    if (!process.stdout.isTTY)
-        return 'non-interactive';
-    return null;
-}
-/**
- * Detects the deployment environment/platform based on environment variables
- * @returns The deployment platform name, or 'unknown' if not detected
- */
-export const detectDeploymentEnvironment = memoize(() => {
-    // Cloud development environments
-    if (isEnvTruthy(process.env.CODESPACES))
-        return 'codespaces';
-    if (process.env.GITPOD_WORKSPACE_ID)
-        return 'gitpod';
-    if (process.env.REPL_ID || process.env.REPL_SLUG)
-        return 'replit';
-    if (process.env.PROJECT_DOMAIN)
-        return 'glitch';
-    // Cloud platforms
-    if (isEnvTruthy(process.env.VERCEL))
-        return 'vercel';
-    if (process.env.RAILWAY_ENVIRONMENT_NAME ||
-        process.env.RAILWAY_SERVICE_NAME) {
-        return 'railway';
-    }
-    if (isEnvTruthy(process.env.RENDER))
-        return 'render';
-    if (isEnvTruthy(process.env.NETLIFY))
-        return 'netlify';
-    if (process.env.DYNO)
-        return 'heroku';
-    if (process.env.FLY_APP_NAME || process.env.FLY_MACHINE_ID)
-        return 'fly.io';
-    if (isEnvTruthy(process.env.CF_PAGES))
-        return 'cloudflare-pages';
-    if (process.env.DENO_DEPLOYMENT_ID)
-        return 'deno-deploy';
-    if (process.env.AWS_LAMBDA_FUNCTION_NAME)
-        return 'aws-lambda';
-    if (process.env.AWS_EXECUTION_ENV === 'AWS_ECS_FARGATE')
-        return 'aws-fargate';
-    if (process.env.AWS_EXECUTION_ENV === 'AWS_ECS_EC2')
-        return 'aws-ecs';
-    // Check for EC2 via hypervisor UUID
-    try {
-        const uuid = getFsImplementation()
-            .readFileSync('/sys/hypervisor/uuid', { encoding: 'utf8' })
-            .trim()
-            .toLowerCase();
-        if (uuid.startsWith('ec2'))
-            return 'aws-ec2';
-    }
-    catch {
-        // Ignore errors reading hypervisor UUID (ENOENT on non-EC2, etc.)
-    }
-    if (process.env.K_SERVICE)
-        return 'gcp-cloud-run';
-    if (process.env.GOOGLE_CLOUD_PROJECT)
-        return 'gcp';
-    if (process.env.WEBSITE_SITE_NAME || process.env.WEBSITE_SKU)
-        return 'azure-app-service';
-    if (process.env.AZURE_FUNCTIONS_ENVIRONMENT)
-        return 'azure-functions';
-    if (process.env.APP_URL?.includes('ondigitalocean.app')) {
-        return 'digitalocean-app-platform';
-    }
-    if (process.env.SPACE_CREATOR_USER_ID)
-        return 'huggingface-spaces';
-    // CI/CD platforms
-    if (isEnvTruthy(process.env.GITHUB_ACTIONS))
-        return 'github-actions';
-    if (isEnvTruthy(process.env.GITLAB_CI))
-        return 'gitlab-ci';
-    if (process.env.CIRCLECI)
-        return 'circleci';
-    if (process.env.BUILDKITE)
-        return 'buildkite';
-    if (isEnvTruthy(process.env.CI))
-        return 'ci';
-    // Container orchestration
-    if (process.env.KUBERNETES_SERVICE_HOST)
-        return 'kubernetes';
-    try {
-        if (getFsImplementation().existsSync('/.dockerenv'))
-            return 'docker';
-    }
-    catch {
-        // Ignore errors checking for Docker
-    }
-    // Platform-specific fallback for undetected environments
-    if (env.platform === 'darwin')
-        return 'unknown-darwin';
-    if (env.platform === 'linux')
-        return 'unknown-linux';
-    if (env.platform === 'win32')
-        return 'unknown-win32';
-    return 'unknown';
-});
-// all of these should be immutable
-function isSSHSession() {
-    return !!(process.env.SSH_CONNECTION ||
-        process.env.SSH_CLIENT ||
-        process.env.SSH_TTY);
-}
-export const env = {
-    hasInternetAccess,
-    isCI: isEnvTruthy(process.env.CI),
-    platform: (['win32', 'darwin'].includes(process.platform)
-        ? process.platform
-        : 'linux'),
-    arch: process.arch,
-    nodeVersion: process.version,
-    terminal: detectTerminal(),
-    isSSH: isSSHSession,
-    getPackageManagers: detectPackageManagers,
-    getRuntimes: detectRuntimes,
-    isRunningWithBun: memoize(isRunningWithBun),
-    isWslEnvironment,
-    isNpmFromWindowsPath,
-    isConductor,
-    detectDeploymentEnvironment,
-};
-/**
- * Returns the host platform for analytics reporting.
- * If CLAUDE_CODE_HOST_PLATFORM is set to a valid platform value, that overrides
- * the detected platform. This is useful for container/remote environments where
- * process.platform reports the container OS but the actual host platform differs.
- */
-export function getHostPlatformForAnalytics() {
-    const override = process.env.CLAUDE_CODE_HOST_PLATFORM;
-    if (override === 'win32' || override === 'darwin' || override === 'linux') {
-        return override;
-    }
-    return env.platform;
-}