@cjhyy/code-shell-core 0.5.0-rc.0

package/dist/utils/format.js

@@ -0,0 +1,236 @@
+// Pure display formatters — leaf-safe (no Ink). Width-aware truncation lives in ./truncate.ts.
+import { getRelativeTimeFormat, getTimeZone } from './intl.js';
+/**
+ * Formats a byte count to a human-readable string (KB, MB, GB).
+ * @example formatFileSize(1536) → "1.5KB"
+ */
+export function formatFileSize(sizeInBytes) {
+    const kb = sizeInBytes / 1024;
+    if (kb < 1) {
+        return `${sizeInBytes} bytes`;
+    }
+    if (kb < 1024) {
+        return `${kb.toFixed(1).replace(/\.0$/, '')}KB`;
+    }
+    const mb = kb / 1024;
+    if (mb < 1024) {
+        return `${mb.toFixed(1).replace(/\.0$/, '')}MB`;
+    }
+    const gb = mb / 1024;
+    return `${gb.toFixed(1).replace(/\.0$/, '')}GB`;
+}
+/**
+ * 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 function formatSecondsShort(ms) {
+    return `${(ms / 1000).toFixed(1)}s`;
+}
+export function formatDuration(ms, options) {
+    if (ms < 60000) {
+        // Special case for 0
+        if (ms === 0) {
+            return '0s';
+        }
+        // For durations < 1s, show 1 decimal place (e.g., 0.5s)
+        if (ms < 1) {
+            const s = (ms / 1000).toFixed(1);
+            return `${s}s`;
+        }
+        const s = Math.floor(ms / 1000).toString();
+        return `${s}s`;
+    }
+    let days = Math.floor(ms / 86400000);
+    let hours = Math.floor((ms % 86400000) / 3600000);
+    let minutes = Math.floor((ms % 3600000) / 60000);
+    let seconds = Math.round((ms % 60000) / 1000);
+    // Handle rounding carry-over (e.g., 59.5s rounds to 60s)
+    if (seconds === 60) {
+        seconds = 0;
+        minutes++;
+    }
+    if (minutes === 60) {
+        minutes = 0;
+        hours++;
+    }
+    if (hours === 24) {
+        hours = 0;
+        days++;
+    }
+    const hide = options?.hideTrailingZeros;
+    if (options?.mostSignificantOnly) {
+        if (days > 0)
+            return `${days}d`;
+        if (hours > 0)
+            return `${hours}h`;
+        if (minutes > 0)
+            return `${minutes}m`;
+        return `${seconds}s`;
+    }
+    if (days > 0) {
+        if (hide && hours === 0 && minutes === 0)
+            return `${days}d`;
+        if (hide && minutes === 0)
+            return `${days}d ${hours}h`;
+        return `${days}d ${hours}h ${minutes}m`;
+    }
+    if (hours > 0) {
+        if (hide && minutes === 0 && seconds === 0)
+            return `${hours}h`;
+        if (hide && seconds === 0)
+            return `${hours}h ${minutes}m`;
+        return `${hours}h ${minutes}m ${seconds}s`;
+    }
+    if (minutes > 0) {
+        if (hide && seconds === 0)
+            return `${minutes}m`;
+        return `${minutes}m ${seconds}s`;
+    }
+    return `${seconds}s`;
+}
+// `new Intl.NumberFormat` is expensive, so cache formatters for reuse
+let numberFormatterForConsistentDecimals = null;
+let numberFormatterForInconsistentDecimals = null;
+const getNumberFormatter = (useConsistentDecimals) => {
+    if (useConsistentDecimals) {
+        if (!numberFormatterForConsistentDecimals) {
+            numberFormatterForConsistentDecimals = new Intl.NumberFormat('en-US', {
+                notation: 'compact',
+                maximumFractionDigits: 1,
+                minimumFractionDigits: 1,
+            });
+        }
+        return numberFormatterForConsistentDecimals;
+    }
+    else {
+        if (!numberFormatterForInconsistentDecimals) {
+            numberFormatterForInconsistentDecimals = new Intl.NumberFormat('en-US', {
+                notation: 'compact',
+                maximumFractionDigits: 1,
+                minimumFractionDigits: 0,
+            });
+        }
+        return numberFormatterForInconsistentDecimals;
+    }
+};
+export function formatNumber(number) {
+    // Only use minimumFractionDigits for numbers that will be shown in compact notation
+    const shouldUseConsistentDecimals = number >= 1000;
+    return getNumberFormatter(shouldUseConsistentDecimals)
+        .format(number) // eg. "1321" => "1.3K", "900" => "900"
+        .toLowerCase(); // eg. "1.3K" => "1.3k", "1.0K" => "1.0k"
+}
+export function formatTokens(count) {
+    return formatNumber(count).replace('.0', '');
+}
+export function formatRelativeTime(date, options = {}) {
+    const { style = 'narrow', numeric = 'always', now = new Date() } = options;
+    const diffInMs = date.getTime() - now.getTime();
+    // Use Math.trunc to truncate towards zero for both positive and negative values
+    const diffInSeconds = Math.trunc(diffInMs / 1000);
+    // Define time intervals with custom short units
+    const intervals = [
+        { unit: 'year', seconds: 31536000, shortUnit: 'y' },
+        { unit: 'month', seconds: 2592000, shortUnit: 'mo' },
+        { unit: 'week', seconds: 604800, shortUnit: 'w' },
+        { unit: 'day', seconds: 86400, shortUnit: 'd' },
+        { unit: 'hour', seconds: 3600, shortUnit: 'h' },
+        { unit: 'minute', seconds: 60, shortUnit: 'm' },
+        { unit: 'second', seconds: 1, shortUnit: 's' },
+    ];
+    // Find the appropriate unit
+    for (const { unit, seconds: intervalSeconds, shortUnit } of intervals) {
+        if (Math.abs(diffInSeconds) >= intervalSeconds) {
+            const value = Math.trunc(diffInSeconds / intervalSeconds);
+            // For short style, use custom format
+            if (style === 'narrow') {
+                return diffInSeconds < 0
+                    ? `${Math.abs(value)}${shortUnit} ago`
+                    : `in ${value}${shortUnit}`;
+            }
+            // For days and longer, use long style regardless of the style parameter
+            return getRelativeTimeFormat('long', numeric).format(value, unit);
+        }
+    }
+    // For values less than 1 second
+    if (style === 'narrow') {
+        return diffInSeconds <= 0 ? '0s ago' : 'in 0s';
+    }
+    return getRelativeTimeFormat(style, numeric).format(0, 'second');
+}
+export function formatRelativeTimeAgo(date, options = {}) {
+    const { now = new Date(), ...restOptions } = options;
+    if (date > now) {
+        // For future dates, just return the relative time without "ago"
+        return formatRelativeTime(date, { ...restOptions, now });
+    }
+    // For past dates, force numeric: 'always' to ensure we get "X units ago"
+    return formatRelativeTime(date, { ...restOptions, numeric: 'always', now });
+}
+/**
+ * Formats log metadata for display (time, size or message count, branch, tag, PR)
+ */
+export function formatLogMetadata(log) {
+    const sizeOrCount = log.fileSize !== undefined
+        ? formatFileSize(log.fileSize)
+        : `${log.messageCount} messages`;
+    const parts = [
+        formatRelativeTimeAgo(log.modified, { style: 'short' }),
+        ...(log.gitBranch ? [log.gitBranch] : []),
+        sizeOrCount,
+    ];
+    if (log.tag) {
+        parts.push(`#${log.tag}`);
+    }
+    if (log.agentSetting) {
+        parts.push(`@${log.agentSetting}`);
+    }
+    if (log.prNumber) {
+        parts.push(log.prRepository
+            ? `${log.prRepository}#${log.prNumber}`
+            : `#${log.prNumber}`);
+    }
+    return parts.join(' · ');
+}
+export function formatResetTime(timestampInSeconds, showTimezone = false, showTime = true) {
+    if (!timestampInSeconds)
+        return undefined;
+    const date = new Date(timestampInSeconds * 1000);
+    const now = new Date();
+    const minutes = date.getMinutes();
+    // Calculate hours until reset
+    const hoursUntilReset = (date.getTime() - now.getTime()) / (1000 * 60 * 60);
+    // If reset is more than 24 hours away, show the date as well
+    if (hoursUntilReset > 24) {
+        // Show date and time for resets more than a day away
+        const dateOptions = {
+            month: 'short',
+            day: 'numeric',
+            hour: showTime ? 'numeric' : undefined,
+            minute: !showTime || minutes === 0 ? undefined : '2-digit',
+            hour12: showTime ? true : undefined,
+        };
+        // Add year if it's not the current year
+        if (date.getFullYear() !== now.getFullYear()) {
+            dateOptions.year = 'numeric';
+        }
+        const dateString = date.toLocaleString('en-US', dateOptions);
+        // Remove the space before AM/PM and make it lowercase
+        return (dateString.replace(/ ([AP]M)/i, (_match, ampm) => ampm.toLowerCase()) +
+            (showTimezone ? ` (${getTimeZone()})` : ''));
+    }
+    // For resets within 24 hours, show just the time (existing behavior)
+    const timeString = date.toLocaleTimeString('en-US', {
+        hour: 'numeric',
+        minute: minutes === 0 ? undefined : '2-digit',
+        hour12: true,
+    });
+    // Remove the space before AM/PM and make it lowercase, then add timezone
+    return (timeString.replace(/ ([AP]M)/i, (_match, ampm) => ampm.toLowerCase()) +
+        (showTimezone ? ` (${getTimeZone()})` : ''));
+}
+export function formatResetText(resetsAt, showTimezone = false, showTime = true) {
+    const dt = new Date(resetsAt);
+    return `${formatResetTime(Math.floor(dt.getTime() / 1000), showTimezone, showTime)}`;
+}

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/intl.js

@@ -0,0 +1,83 @@
+/**
+ * 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.
+ */
+// Segmenters for Unicode text processing (lazily initialized)
+let graphemeSegmenter = null;
+let wordSegmenter = null;
+export function getGraphemeSegmenter() {
+    if (!graphemeSegmenter) {
+        graphemeSegmenter = new Intl.Segmenter(undefined, {
+            granularity: 'grapheme',
+        });
+    }
+    return graphemeSegmenter;
+}
+/**
+ * Extract the first grapheme cluster from a string.
+ * Returns '' for empty strings.
+ */
+export function firstGrapheme(text) {
+    if (!text)
+        return '';
+    const segments = getGraphemeSegmenter().segment(text);
+    const first = segments[Symbol.iterator]().next().value;
+    return first?.segment ?? '';
+}
+/**
+ * Extract the last grapheme cluster from a string.
+ * Returns '' for empty strings.
+ */
+export function lastGrapheme(text) {
+    if (!text)
+        return '';
+    let last = '';
+    for (const { segment } of getGraphemeSegmenter().segment(text)) {
+        last = segment;
+    }
+    return last;
+}
+export function getWordSegmenter() {
+    if (!wordSegmenter) {
+        wordSegmenter = new Intl.Segmenter(undefined, { granularity: 'word' });
+    }
+    return wordSegmenter;
+}
+// RelativeTimeFormat cache (keyed by style:numeric)
+const rtfCache = new Map();
+export function getRelativeTimeFormat(style, numeric) {
+    const key = `${style}:${numeric}`;
+    let rtf = rtfCache.get(key);
+    if (!rtf) {
+        rtf = new Intl.RelativeTimeFormat('en', { style, numeric });
+        rtfCache.set(key, rtf);
+    }
+    return rtf;
+}
+// Timezone is constant for the process lifetime
+let cachedTimeZone = null;
+export function getTimeZone() {
+    if (!cachedTimeZone) {
+        cachedTimeZone = Intl.DateTimeFormat().resolvedOptions().timeZone;
+    }
+    return cachedTimeZone;
+}
+// System locale language subtag (e.g. 'en', 'ja') is constant for the process
+// lifetime. null = not yet computed; undefined = computed but unavailable (so
+// a stripped-ICU environment fails once instead of retrying on every call).
+let cachedSystemLocaleLanguage = null;
+export function getSystemLocaleLanguage() {
+    if (cachedSystemLocaleLanguage === null) {
+        try {
+            const locale = Intl.DateTimeFormat().resolvedOptions().locale;
+            cachedSystemLocaleLanguage = new Intl.Locale(locale).language;
+        }
+        catch {
+            cachedSystemLocaleLanguage = undefined;
+        }
+    }
+    return cachedSystemLocaleLanguage;
+}

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/lockfile.js

@@ -0,0 +1,30 @@
+/**
+ * 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.
+ */
+let _lockfile;
+function getLockfile() {
+    if (!_lockfile) {
+        // eslint-disable-next-line @typescript-eslint/no-require-imports
+        _lockfile = require('proper-lockfile');
+    }
+    return _lockfile;
+}
+export function lock(file, options) {
+    return getLockfile().lock(file, options);
+}
+export function lockSync(file, options) {
+    return getLockfile().lockSync(file, options);
+}
+export function unlock(file, options) {
+    return getLockfile().unlock(file, options);
+}
+export function check(file, options) {
+    return getLockfile().check(file, options);
+}

package/dist/utils/memoize.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Minimal memoize with a custom cache-key resolver — same shape as
+ * lodash's `memoize(fn, resolver)` for the call sites that need to
+ * derive the cache key from arguments + side-channel state (e.g.
+ * "user home + installed-plugins mtime"). Kept in-tree to drop the
+ * lodash-es dependency from the core package.
+ *
+ * The returned function exposes `.cache` matching the subset of
+ * lodash's MapCache API the existing call sites use (`.clear()`).
+ * Cache lives for the lifetime of the returned function. Not LRU —
+ * call sites cache scan results keyed by a string that changes when
+ * external state changes, so unbounded growth is bounded by the
+ * cardinality of that key.
+ */
+export interface MemoizedFn<Args extends readonly unknown[], R> {
+    (...args: Args): R;
+    cache: Map<string, R>;
+}
+export declare function memoize<Args extends readonly unknown[], R>(fn: (...args: Args) => R, resolver: (...args: Args) => string): MemoizedFn<Args, R>;

package/dist/utils/memoize.js

@@ -0,0 +1,14 @@
+export function memoize(fn, resolver) {
+    const cache = new Map();
+    const memoized = ((...args) => {
+        const key = resolver(...args);
+        const hit = cache.get(key);
+        if (hit !== undefined || cache.has(key))
+            return hit;
+        const result = fn(...args);
+        cache.set(key, result);
+        return result;
+    });
+    memoized.cache = cache;
+    return memoized;
+}

package/dist/utils/semver.d.ts

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

package/dist/utils/semver.js

@@ -0,0 +1,13 @@
+/**
+ * Shim for CC's utils/semver — re-exports semver comparison helpers.
+ */
+import { gte as semverGte, gt as semverGt, lt as semverLt } from 'semver';
+export function gte(a, b) {
+    return semverGte(a, b);
+}
+export function gt(a, b) {
+    return semverGt(a, b);
+}
+export function lt(a, b) {
+    return semverLt(a, b);
+}

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/sliceAnsi.js

@@ -0,0 +1,62 @@
+/**
+ * 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`.
+ */
+import stripAnsi from 'strip-ansi';
+// Matches a single ANSI escape sequence
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+/**
+ * Slice a string that may contain ANSI escape codes by *visible* character
+ * positions (start inclusive, end exclusive).
+ */
+export default function sliceAnsi(text, start, end) {
+    // Fast path: no ANSI codes at all
+    if (!text.includes('\x1b')) {
+        return text.slice(start, end);
+    }
+    const chars = [];
+    let i = 0;
+    while (i < text.length) {
+        ANSI_RE.lastIndex = i;
+        const m = ANSI_RE.exec(text);
+        if (m && m.index === i) {
+            chars.push({ ch: m[0], visible: false });
+            i += m[0].length;
+        }
+        else {
+            chars.push({ ch: text[i], visible: true });
+            i++;
+        }
+    }
+    const finalEnd = end ?? stripAnsi(text).length;
+    let visIdx = 0;
+    let result = '';
+    let activeStyles = '';
+    for (const { ch, visible } of chars) {
+        if (!visible) {
+            // Always accumulate style sequences that precede visible chars in range
+            if (visIdx >= start && visIdx < finalEnd) {
+                result += ch;
+            }
+            else {
+                activeStyles += ch;
+            }
+            continue;
+        }
+        if (visIdx >= start && visIdx < finalEnd) {
+            // First visible char in range: prepend any accumulated styles
+            if (activeStyles) {
+                result += activeStyles;
+                activeStyles = '';
+            }
+            result += ch;
+        }
+        visIdx++;
+        if (visIdx >= finalEnd)
+            break;
+    }
+    return result;
+}

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;

package/dist/utils/systemTheme.js

@@ -0,0 +1,108 @@
+/**
+ * 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.
+ */
+let cachedSystemTheme;
+/**
+ * Get the current terminal theme. Cached after first detection; the watcher
+ * updates the cache on live changes.
+ */
+export function getSystemThemeName() {
+    if (cachedSystemTheme === undefined) {
+        cachedSystemTheme = detectFromColorFgBg() ?? 'dark';
+    }
+    return cachedSystemTheme;
+}
+/**
+ * Update the cached terminal theme. Called by the watcher when the OSC 11
+ * query returns so non-React call sites stay in sync.
+ */
+export function setCachedSystemTheme(theme) {
+    cachedSystemTheme = theme;
+}
+/**
+ * Resolve a ThemeSetting (which may be 'auto') to a concrete ThemeName.
+ */
+export function resolveThemeSetting(setting) {
+    if (setting === 'auto') {
+        return getSystemThemeName();
+    }
+    return setting;
+}
+/**
+ * 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 function themeFromOscColor(data) {
+    const rgb = parseOscRgb(data);
+    if (!rgb)
+        return undefined;
+    // ITU-R BT.709 relative luminance. Midpoint split: > 0.5 is light.
+    const luminance = 0.2126 * rgb.r + 0.7152 * rgb.g + 0.0722 * rgb.b;
+    return luminance > 0.5 ? 'light' : 'dark';
+}
+function parseOscRgb(data) {
+    // rgb:RRRR/GGGG/BBBB — each component is 1–4 hex digits.
+    // Some terminals append an alpha component (rgba:…/…/…/…); ignore it.
+    const rgbMatch = /^rgba?:([0-9a-f]{1,4})\/([0-9a-f]{1,4})\/([0-9a-f]{1,4})/i.exec(data);
+    if (rgbMatch) {
+        return {
+            r: hexComponent(rgbMatch[1]),
+            g: hexComponent(rgbMatch[2]),
+            b: hexComponent(rgbMatch[3]),
+        };
+    }
+    // #RRGGBB or #RRRRGGGGBBBB — split into three equal hex runs.
+    const hashMatch = /^#([0-9a-f]+)$/i.exec(data);
+    if (hashMatch && hashMatch[1].length % 3 === 0) {
+        const hex = hashMatch[1];
+        const n = hex.length / 3;
+        return {
+            r: hexComponent(hex.slice(0, n)),
+            g: hexComponent(hex.slice(n, 2 * n)),
+            b: hexComponent(hex.slice(2 * n)),
+        };
+    }
+    return undefined;
+}
+/** Normalize a 1–4 digit hex component to [0, 1]. */
+function hexComponent(hex) {
+    const max = 16 ** hex.length - 1;
+    return parseInt(hex, 16) / max;
+}
+/**
+ * Read $COLORFGBG for a synchronous initial guess before the OSC 11
+ * round-trip completes. Format is `fg;bg` (or `fg;other;bg`) where values
+ * are ANSI color indices. rxvt convention: bg 0–6 or 8 are dark; bg 7
+ * and 9–15 are light. Only set by some terminals (rxvt-family, Konsole,
+ * iTerm2 with the option enabled), so this is a best-effort hint.
+ */
+function detectFromColorFgBg() {
+    const colorfgbg = process.env['COLORFGBG'];
+    if (!colorfgbg)
+        return undefined;
+    const parts = colorfgbg.split(';');
+    const bg = parts[parts.length - 1];
+    if (bg === undefined || bg === '')
+        return undefined;
+    const bgNum = Number(bg);
+    if (!Number.isInteger(bgNum) || bgNum < 0 || bgNum > 15)
+        return undefined;
+    // 0–6 and 8 are dark ANSI colors; 7 (white) and 9–15 (bright) are light.
+    return bgNum <= 6 || bgNum === 8 ? 'dark' : 'light';
+}

package/dist/utils/task-sanitizer.d.ts

@@ -0,0 +1,6 @@
+export interface NoiseResult {
+    isNoise: boolean;
+    reason: string;
+    cleaned: string;
+}
+export declare function detectPastedNoise(task: string): NoiseResult;