@cjhyy/code-shell 0.1.0-alpha.0

package/dist/updater-URVNPDPW.cjs

@@ -0,0 +1,183 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true}); function _nullishCoalesce(lhs, rhsFn) { if (lhs != null) { return lhs; } else { return rhsFn(); } }
+
+
+var _chunkIJSHQGMPcjs = require('./chunk-IJSHQGMP.cjs');
+
+// package.json
+var require_package = _chunkIJSHQGMPcjs.__commonJS.call(void 0, {
+  "package.json"(exports, module) {
+    module.exports = {
+      name: "@cjhyy/code-shell",
+      version: "0.1.0-alpha.0",
+      description: "Code Shell \u2014 general-purpose agent orchestration framework with a terminal coding preset",
+      type: "module",
+      main: "./dist/index.cjs",
+      module: "./dist/index.js",
+      types: "./dist/index.d.ts",
+      exports: {
+        ".": {
+          types: "./dist/index.d.ts",
+          import: "./dist/index.js",
+          require: "./dist/index.cjs"
+        },
+        "./run": {
+          types: "./dist/run/index.d.ts",
+          import: "./dist/run/index.js",
+          require: "./dist/run/index.cjs"
+        },
+        "./arena": {
+          types: "./dist/arena/index.d.ts",
+          import: "./dist/arena/index.js",
+          require: "./dist/arena/index.cjs"
+        },
+        "./product": {
+          types: "./dist/product/index.d.ts",
+          import: "./dist/product/index.js",
+          require: "./dist/product/index.cjs"
+        },
+        "./package.json": "./package.json"
+      },
+      bin: {
+        "code-shell": "dist/cli/main.js"
+      },
+      repository: {
+        type: "git",
+        url: "git+https://github.com/cjhyy/codeshell.git"
+      },
+      homepage: "https://github.com/cjhyy/codeshell#readme",
+      bugs: {
+        url: "https://github.com/cjhyy/codeshell/issues"
+      },
+      publishConfig: {
+        access: "public"
+      },
+      scripts: {
+        build: "bun run tsup && bun run build:dts",
+        "build:dts": "tsc --emitDeclarationOnly --declaration --outDir dist || true",
+        dev: "bun run src/cli/main.ts",
+        test: "bun test",
+        "test:watch": "bun test --watch",
+        lint: "eslint src/",
+        format: "prettier --write 'src/**/*.ts'",
+        typecheck: "bun run tsc --noEmit",
+        prepublishOnly: "bun run build"
+      },
+      engines: {
+        node: ">=20"
+      },
+      files: [
+        "dist",
+        "README.md",
+        "LICENSE",
+        "CHANGELOG.md"
+      ],
+      keywords: [
+        "ai",
+        "agent",
+        "orchestration",
+        "coding-assistant",
+        "cli",
+        "claude-code",
+        "mcp",
+        "llm"
+      ],
+      author: "maki maki",
+      license: "MIT",
+      dependencies: {
+        "@alcalzone/ansi-tokenize": "^0.3.0",
+        "@anthropic-ai/sdk": "^0.39.0",
+        "@modelcontextprotocol/sdk": "^1.12.1",
+        asciichart: "^1.5.25",
+        "auto-bind": "^5.0.1",
+        "bidi-js": "^1.0.3",
+        chalk: "^5.4.1",
+        "cli-boxes": "^4.0.1",
+        "cli-highlight": "^2.1.11",
+        "code-excerpt": "^4.0.0",
+        commander: "^13.1.0",
+        diff: "^8.0.4",
+        "emoji-regex": "^10.6.0",
+        "get-east-asian-width": "^1.5.0",
+        glob: "^11.0.0",
+        "indent-string": "^5.0.0",
+        ink: "^6.8.0",
+        "lodash-es": "^4.17.23",
+        marked: "^17.0.5",
+        "marked-terminal": "^7.3.0",
+        nanoid: "^5.1.2",
+        openai: "^4.82.0",
+        ora: "^9.3.0",
+        "proper-lockfile": "^4.1.2",
+        react: "^19.2.4",
+        "react-reconciler": "^0.33.0",
+        semver: "^7.7.4",
+        "signal-exit": "^4.1.0",
+        "stack-utils": "^2.0.6",
+        "strip-ansi": "^7.2.0",
+        "supports-hyperlinks": "^4.4.0",
+        "type-fest": "^5.5.0",
+        "usehooks-ts": "^3.1.1",
+        "wrap-ansi": "^10.0.0",
+        yaml: "^2.7.0",
+        "yoga-layout": "^3.2.1",
+        zod: "^3.24.2"
+      },
+      devDependencies: {
+        "@eslint/js": "^10.0.1",
+        "@types/lodash": "^4.17.24",
+        "@types/lodash-es": "^4.17.12",
+        "@types/node": "^22.12.0",
+        "@types/react": "^19.2.14",
+        "@types/semver": "^7.7.1",
+        eslint: "^9.19.0",
+        prettier: "^3.4.2",
+        tsup: "^8.3.6",
+        typescript: "^5.7.3",
+        "typescript-eslint": "^8.59.0"
+      }
+    };
+  }
+});
+
+// src/cli/updater.ts
+_chunkIJSHQGMPcjs.init_cjs_shims.call(void 0, );
+var _child_process = require('child_process');
+var _updateAvailable;
+function checkForUpdate(packageName = "code-shell") {
+  try {
+    const currentVersion = getCurrentVersion();
+    const latestVersion = _child_process.execSync.call(void 0, `npm view ${packageName} version 2>/dev/null`, {
+      encoding: "utf-8",
+      timeout: 5e3
+    }).trim();
+    if (latestVersion && latestVersion !== currentVersion && compareVersions(latestVersion, currentVersion) > 0) {
+      _updateAvailable = latestVersion;
+    }
+  } catch (e) {
+  }
+}
+function getUpdateAvailable() {
+  return _updateAvailable;
+}
+function getCurrentVersion() {
+  try {
+    const pkg = require_package();
+    return _nullishCoalesce(pkg.version, () => ( "0.1.0"));
+  } catch (e2) {
+    return "0.1.0";
+  }
+}
+function compareVersions(a, b) {
+  const pa = a.split(".").map(Number);
+  const pb = b.split(".").map(Number);
+  for (let i = 0; i < 3; i++) {
+    const diff = (_nullishCoalesce(pa[i], () => ( 0))) - (_nullishCoalesce(pb[i], () => ( 0)));
+    if (diff !== 0) return diff;
+  }
+  return 0;
+}
+
+
+
+
+exports.checkForUpdate = checkForUpdate; exports.getCurrentVersion = getCurrentVersion; exports.getUpdateAvailable = getUpdateAvailable;

package/dist/utils/debug.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Debug logging — category-filtered, leveled output with file support.
+ *
+ * Activation:
+ *   CODE_SHELL_DEBUG=1          — all debug output to stderr
+ *   --debug                     — all debug output to file (~/.code-shell/debug/<session>.txt)
+ *   --debug=api,hooks           — filtered categories only
+ *   --debug-file=/path/to/file  — explicit output file
+ *   --debug-to-stderr / -d2e    — force stderr output
+ *
+ * Levels: verbose < debug < info < warn < error
+ *   Set CODE_SHELL_DEBUG_LOG_LEVEL=verbose to include high-volume diagnostics.
+ */
+export type DebugLogLevel = "verbose" | "debug" | "info" | "warn" | "error";
+type DebugFilter = {
+    categories: Set<string>;
+};
+export declare function setDebugSessionId(id: string): void;
+export declare function getMinDebugLogLevel(): DebugLogLevel;
+export declare function isDebugMode(): boolean;
+/**
+ * Enable debug logging mid-session (e.g. via /debug command).
+ * Returns true if logging was already active.
+ */
+export declare function enableDebugLogging(): boolean;
+export declare function isDebugToStdErr(): boolean;
+export declare function getDebugFilter(): DebugFilter | null;
+export declare function getDebugFilePath(): string | null;
+/**
+ * Log a debug message with optional level.
+ * Output goes to stderr (--debug-to-stderr / CODE_SHELL_DEBUG=1)
+ * or to a file (~/.code-shell/debug/<session>.txt).
+ */
+export declare function logForDebugging(message: string, opts?: {
+    level?: DebugLogLevel | string;
+}): void;
+/**
+ * Category-scoped debug logger.
+ * Usage: const log = debugCategory("mcp"); log("connecting...");
+ */
+export declare function debugCategory(category: string): (msg: string) => void;
+/**
+ * Time a function and log the duration.
+ */
+export declare function debugTiming<T>(label: string, fn: () => T | Promise<T>): Promise<T>;
+/**
+ * CC compatibility: log errors for Anthropic internal users.
+ * In Code Shell this is a debug-level error log.
+ */
+export declare function logAntError(msg: string, _err?: unknown): void;
+/**
+ * CC compatibility exports.
+ */
+export declare function setHasFormattedOutput(_value: boolean): void;
+export declare function getHasFormattedOutput(): boolean;
+export declare function flushDebugLogs(): Promise<void>;
+export {};

package/dist/utils/earlyInput.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Early Input Capture
+ *
+ * This module captures terminal input that is typed before the REPL is fully
+ * initialized. Users often type `claude` and immediately start typing their
+ * prompt, but those early keystrokes would otherwise be lost during startup.
+ *
+ * Usage:
+ * 1. Call startCapturingEarlyInput() as early as possible in cli.tsx
+ * 2. When REPL is ready, call consumeEarlyInput() to get any buffered text
+ * 3. stopCapturingEarlyInput() is called automatically when input is consumed
+ */
+/**
+ * Start capturing stdin data early, before the REPL is initialized.
+ * Should be called as early as possible in the startup sequence.
+ *
+ * Only captures if stdin is a TTY (interactive terminal).
+ */
+export declare function startCapturingEarlyInput(): void;
+/**
+ * Stop capturing early input.
+ * Called automatically when input is consumed, or can be called manually.
+ */
+export declare function stopCapturingEarlyInput(): void;
+/**
+ * Consume any early input that was captured.
+ * Returns the captured input and clears the buffer.
+ * Automatically stops capturing when called.
+ */
+export declare function consumeEarlyInput(): string;
+/**
+ * Check if there is any early input available without consuming it.
+ */
+export declare function hasEarlyInput(): boolean;
+/**
+ * Seed the early input buffer with text that will appear pre-filled
+ * in the prompt input when the REPL renders. Does not auto-submit.
+ */
+export declare function seedEarlyInput(text: string): void;
+/**
+ * Check if early input capture is currently active.
+ */
+export declare function isCapturingEarlyInput(): boolean;

package/dist/utils/env.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Environment detection — platform, runtime, config paths, network.
+ */
+export declare const env: {
+    platform: "darwin" | "linux" | "win32";
+    terminal: string;
+    shell: string;
+    isCI: boolean;
+};
+export declare function getHostPlatform(): "macos" | "linux" | "windows";
+export declare function getHostPlatformForAnalytics(): string;
+export declare function isWSL(): boolean;
+/** ~/.claude/ directory (Claude Code compatible) */
+export declare function getGlobalClaudeDir(): string;
+/** ~/.code-shell/ directory */
+export declare function getGlobalCodeShellDir(): string;
+/** Resolve a file in ~/.claude/ or ~/.code-shell/ (claude takes precedence) */
+export declare function getGlobalClaudeFile(filename: string): string | undefined;
+export declare function getRuntime(): "bun" | "deno" | "node";
+export declare function getPackageManager(cwd?: string): "bun" | "pnpm" | "yarn" | "npm";
+export declare function hasInternetAccess(): Promise<boolean>;
+export declare const JETBRAINS_IDES: readonly ["idea", "pycharm", "webstorm", "phpstorm", "rubymine", "clion", "goland", "rider", "datagrip", "fleet"];
+export declare function isJetBrainsTerminal(): boolean;
+export declare function isVSCodeTerminal(): boolean;

package/dist/utils/envUtils.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Environment variable helpers — ported from CC's utils/envUtils with full implementations.
+ */
+/**
+ * Returns the Claude/Code Shell config home directory.
+ * Defaults to ~/.claude, overridable via CLAUDE_CONFIG_DIR env var.
+ * Memoized — keyed off CLAUDE_CONFIG_DIR so tests that change the env var get a fresh value.
+ */
+export declare function getClaudeConfigHomeDir(): string;
+export declare function getTeamsDir(): string;
+export declare function isEnvTruthy(val: string | boolean | undefined): boolean;
+export declare function isEnvDefinedFalsy(envVar: string | boolean | undefined): boolean;
+/**
+ * Check if NODE_OPTIONS contains a specific flag.
+ */
+export declare function hasNodeOption(flag: string): boolean;
+/**
+ * --bare / CLAUDE_CODE_SIMPLE — skip hooks, LSP, plugin sync, skill dir-walk,
+ * attribution, background prefetches, and ALL keychain/credential reads.
+ */
+export declare function isBareMode(): boolean;
+/**
+ * Parses an array of environment variable strings into a key-value object.
+ * @param rawEnvArgs Array of strings in KEY=VALUE format
+ */
+export declare function parseEnvVars(rawEnvArgs: string[] | undefined): Record<string, string>;
+/**
+ * Get the AWS region with fallback to default.
+ */
+export declare function getAWSRegion(): string;
+/**
+ * Get the default Vertex AI region.
+ */
+export declare function getDefaultVertexRegion(): string;
+/**
+ * Check if bash commands should maintain project working directory.
+ */
+export declare function shouldMaintainProjectWorkingDir(): boolean;
+/**
+ * Check if running on Homespace (ant-internal cloud environment).
+ */
+export declare function isRunningOnHomespace(): boolean;
+/**
+ * Get the Vertex AI region for a specific model.
+ */
+export declare function getVertexRegionForModel(model: string | undefined): string | undefined;
+/**
+ * Stub: Check if running inside a protected namespace.
+ * Always returns false in Code Shell (Anthropic-internal feature).
+ */
+export declare function isInProtectedNamespace(): boolean;

package/dist/utils/execFileNoThrow.d.ts

@@ -0,0 +1,39 @@
+/**
+ * Execute a child process without throwing on non-zero exit.
+ *
+ * Distinguishes between:
+ * - Spawn failure (file not found, permission denied) → code = null
+ * - Non-zero exit (process ran but returned error) → code = exit code
+ * - Success → code = 0
+ */
+export interface ExecFileNoThrowResult {
+    /** Process exit code (0 = success, null = spawn failed). */
+    code: number | null;
+    stdout: string;
+    stderr: string;
+}
+export interface ExecFileNoThrowOptions {
+    /** stdin input to pipe to the process. */
+    input?: string;
+    /** Working directory. */
+    cwd?: string;
+    /** Timeout in ms (default 10_000). */
+    timeout?: number;
+    /** Environment variables to merge. */
+    env?: Record<string, string | undefined>;
+    /** Shell to run in (if true, uses platform default). */
+    shell?: boolean | string;
+}
+/**
+ * Run a command and return exit code + stdout/stderr.
+ * Never throws — spawn failures return code=null.
+ */
+export declare function execFileNoThrow(file: string, args: string[], options?: ExecFileNoThrowOptions): Promise<ExecFileNoThrowResult>;
+/**
+ * execFileNoThrow with explicit cwd (convenience wrapper).
+ */
+export declare function execFileNoThrowWithCwd(cwd: string, file: string, args: string[], options?: Omit<ExecFileNoThrowOptions, "cwd">): Promise<ExecFileNoThrowResult>;
+/**
+ * @deprecated Use execFileNoThrow directly.
+ */
+export declare function execSyncWithDefaults_DEPRECATED(..._args: any[]): any;

package/dist/utils/format.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Formats a byte count to a human-readable string (KB, MB, GB).
+ * @example formatFileSize(1536) → "1.5KB"
+ */
+export declare function formatFileSize(sizeInBytes: number): string;
+/**
+ * Formats milliseconds as seconds with 1 decimal place (e.g. `1234` → `"1.2s"`).
+ * Unlike formatDuration, always keeps the decimal — use for sub-minute timings
+ * where the fractional second is meaningful (TTFT, hook durations, etc.).
+ */
+export declare function formatSecondsShort(ms: number): string;
+export declare function formatDuration(ms: number, options?: {
+    hideTrailingZeros?: boolean;
+    mostSignificantOnly?: boolean;
+}): string;
+export declare function formatNumber(number: number): string;
+export declare function formatTokens(count: number): string;
+type RelativeTimeStyle = 'long' | 'short' | 'narrow';
+type RelativeTimeOptions = {
+    style?: RelativeTimeStyle;
+    numeric?: 'always' | 'auto';
+};
+export declare function formatRelativeTime(date: Date, options?: RelativeTimeOptions & {
+    now?: Date;
+}): string;
+export declare function formatRelativeTimeAgo(date: Date, options?: RelativeTimeOptions & {
+    now?: Date;
+}): string;
+/**
+ * Formats log metadata for display (time, size or message count, branch, tag, PR)
+ */
+export declare function formatLogMetadata(log: {
+    modified: Date;
+    messageCount: number;
+    fileSize?: number;
+    gitBranch?: string;
+    tag?: string;
+    agentSetting?: string;
+    prNumber?: number;
+    prRepository?: string;
+}): string;
+export declare function formatResetTime(timestampInSeconds: number | undefined, showTimezone?: boolean, showTime?: boolean): string | undefined;
+export declare function formatResetText(resetsAt: string, showTimezone?: boolean, showTime?: boolean): string;
+export { truncate, truncatePathMiddle, truncateStartToWidth, truncateToWidth, truncateToWidthNoEllipsis, wrapText, } from './truncate.js';

package/dist/utils/fullscreen.d.ts

@@ -0,0 +1,47 @@
+/**
+ * True when running under `tmux -CC` (iTerm2 integration mode).
+ *
+ * The alt-screen / mouse-tracking path in fullscreen mode is unrecoverable
+ * in -CC mode (double-click corrupts terminal state; mouse wheel is dead),
+ * so callers auto-disable fullscreen.
+ */
+export declare function isTmuxControlMode(): boolean;
+export declare function _resetTmuxControlModeProbeForTesting(): void;
+/**
+ * Runtime env-var check only. Ants default to on (CLAUDE_CODE_NO_FLICKER=0
+ * to opt out); external users default to off (CLAUDE_CODE_NO_FLICKER=1 to
+ * opt in).
+ */
+export declare function isFullscreenEnvEnabled(): boolean;
+/**
+ * Whether fullscreen mode should enable SGR mouse tracking (DEC 1000/1002/1006).
+ * Set CLAUDE_CODE_DISABLE_MOUSE=1 to keep alt-screen + virtualized scroll
+ * but skip mouse capture, so tmux/kitty/terminal-native copy-on-select keeps working.
+ */
+export declare function isMouseTrackingEnabled(): boolean;
+/**
+ * Whether mouse click handling is disabled (clicks/drags ignored, wheel still
+ * works). Set CLAUDE_CODE_DISABLE_MOUSE_CLICKS=1 to prevent accidental clicks
+ * from triggering cursor positioning, text selection, or message expansion.
+ */
+export declare function isMouseClicksDisabled(): boolean;
+/**
+ * True when the fullscreen alt-screen layout is actually rendering —
+ * requires an interactive REPL session AND the env var not explicitly
+ * set falsy.
+ */
+export declare function isFullscreenActive(): boolean;
+/**
+ * One-time hint for tmux users in fullscreen with `mouse off`.
+ *
+ * Fire-and-forget from REPL startup. Returns the hint text once per
+ * session if TMUX is set, fullscreen is active, and tmux's current
+ * `mouse` option is off; null otherwise.
+ */
+export declare function maybeGetTmuxMouseHint(): Promise<string | null>;
+/** Test-only: reset module-level once-per-session flags. */
+export declare function _resetForTesting(): void;
+/**
+ * Whether fullscreen mode is available (alias for isFullscreenActive).
+ */
+export declare function isFullscreen(): boolean;

package/dist/utils/intl.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared Intl object instances with lazy initialization.
+ *
+ * Intl constructors are expensive (~0.05-0.1ms each), so we cache instances
+ * for reuse across the codebase instead of creating new ones each time.
+ * Lazy initialization ensures we only pay the cost when actually needed.
+ */
+export declare function getGraphemeSegmenter(): Intl.Segmenter;
+/**
+ * Extract the first grapheme cluster from a string.
+ * Returns '' for empty strings.
+ */
+export declare function firstGrapheme(text: string): string;
+/**
+ * Extract the last grapheme cluster from a string.
+ * Returns '' for empty strings.
+ */
+export declare function lastGrapheme(text: string): string;
+export declare function getWordSegmenter(): Intl.Segmenter;
+export declare function getRelativeTimeFormat(style: 'long' | 'short' | 'narrow', numeric: 'always' | 'auto'): Intl.RelativeTimeFormat;
+export declare function getTimeZone(): string;
+export declare function getSystemLocaleLanguage(): string | undefined;

package/dist/utils/lockfile.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Lazy accessor for proper-lockfile.
+ *
+ * proper-lockfile depends on graceful-fs, which monkey-patches every fs
+ * method on first require (~8ms). Static imports of proper-lockfile pull this
+ * cost into the startup path even when no locking happens (e.g. `--help`).
+ *
+ * Import this module instead of `proper-lockfile` directly. The underlying
+ * package is only loaded the first time a lock function is actually called.
+ */
+import type { CheckOptions, LockOptions, UnlockOptions } from 'proper-lockfile';
+export declare function lock(file: string, options?: LockOptions): Promise<() => Promise<void>>;
+export declare function lockSync(file: string, options?: LockOptions): () => void;
+export declare function unlock(file: string, options?: UnlockOptions): Promise<void>;
+export declare function check(file: string, options?: CheckOptions): Promise<boolean>;

package/dist/utils/log.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Persistent logging — writes to ~/.code-shell/logs/ with daily rotation.
+ *
+ * Also provides an in-memory error log (last 100 errors) for bug reports,
+ * and a pluggable ErrorLogSink architecture for decoupled error routing.
+ */
+/**
+ * Get recent in-memory errors for inclusion in bug reports.
+ */
+export declare function getInMemoryErrors(): Array<{
+    error: string;
+    timestamp: string;
+}>;
+/**
+ * Sink interface for pluggable error logging backends.
+ */
+export type ErrorLogSink = {
+    logError: (error: Error) => void;
+    logMCPError: (serverName: string, error: unknown) => void;
+    logMCPDebug: (serverName: string, message: string) => void;
+    getErrorsPath: () => string;
+    getMCPLogsPath: (serverName: string) => string;
+};
+/**
+ * Attach a sink to receive all error events.
+ * Queued events are drained immediately. Idempotent.
+ */
+export declare function attachErrorLogSink(newSink: ErrorLogSink): void;
+/**
+ * Log an error to multiple destinations:
+ * - In-memory error log (for bug reports)
+ * - Persistent log file
+ * - ErrorLogSink (if attached)
+ */
+export declare function logError(msgOrError: string | Error | unknown, err?: unknown): void;
+export declare function logInfo(msg: string): void;
+export declare function logWarn(msg: string): void;
+export declare function logMCPDebug(serverNameOrMsg: string, message?: string): void;
+export declare function logMCPError(serverNameOrMsg: string, err?: unknown): void;
+/**
+ * Read the most recent N lines from today's log.
+ */
+export declare function getRecentLogs(n?: number): string[];
+/**
+ * Clean up old log files (keep last MAX_LOG_FILES days).
+ */
+export declare function rotateLogs(): void;
+/**
+ * Get the logs directory path.
+ */
+export declare function getLogsDir(): string;
+/**
+ * Reset error log state for testing purposes only.
+ * @internal
+ */
+export declare function _resetErrorLogForTesting(): void;

package/dist/utils/semver.d.ts

@@ -0,0 +1,5 @@
+/**
+ * Shim for CC's utils/semver — re-exports semver comparison helpers.
+ */
+export declare function gte(a: string, b: string): boolean;
+export declare function lt(a: string, b: string): boolean;

package/dist/utils/sliceAnsi.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Shim for CC's utils/sliceAnsi — slices an ANSI-styled string by display
+ * column position while preserving escape sequences.
+ *
+ * This is a lightweight implementation. For full fidelity with wide characters
+ * and complex ANSI sequences, consider installing `slice-ansi`.
+ */
+/**
+ * Slice a string that may contain ANSI escape codes by *visible* character
+ * positions (start inclusive, end exclusive).
+ */
+export default function sliceAnsi(text: string, start: number, end?: number): string;

package/dist/utils/systemTheme.d.ts

@@ -0,0 +1,40 @@
+/**
+ * Terminal dark/light mode detection for the 'auto' theme setting.
+ *
+ * Detection is based on the terminal's actual background color (queried via
+ * OSC 11 by systemThemeWatcher.ts) rather than the OS appearance setting —
+ * a dark terminal on a light-mode OS should still resolve to 'dark'.
+ *
+ * The detected theme is cached module-level so callers can resolve 'auto'
+ * without awaiting the async OSC round-trip. The cache is seeded from
+ * $COLORFGBG (synchronous, set by some terminals at launch) and then
+ * updated by the watcher once the OSC 11 response arrives.
+ */
+import type { ThemeName, ThemeSetting } from './theme.js';
+export type SystemTheme = 'dark' | 'light';
+/**
+ * Get the current terminal theme. Cached after first detection; the watcher
+ * updates the cache on live changes.
+ */
+export declare function getSystemThemeName(): SystemTheme;
+/**
+ * Update the cached terminal theme. Called by the watcher when the OSC 11
+ * query returns so non-React call sites stay in sync.
+ */
+export declare function setCachedSystemTheme(theme: SystemTheme): void;
+/**
+ * Resolve a ThemeSetting (which may be 'auto') to a concrete ThemeName.
+ */
+export declare function resolveThemeSetting(setting: ThemeSetting): ThemeName;
+/**
+ * Parse an OSC color response data string into a theme.
+ *
+ * Accepts XParseColor formats returned by OSC 10/11 queries:
+ * - `rgb:R/G/B` where each component is 1–4 hex digits (each scaled to
+ *   [0, 16^n - 1] for n digits). This is what xterm, iTerm2, Terminal.app,
+ *   Ghostty, kitty, Alacritty, etc. return.
+ * - `#RRGGBB` / `#RRRRGGGGBBBB` (rare, but cheap to accept).
+ *
+ * Returns undefined for unrecognized formats so callers can fall back.
+ */
+export declare function themeFromOscColor(data: string): SystemTheme | undefined;