cvc-tui 0.4.0 → 0.4.2

package/dist/lib/memory.js

@@ -1,123 +0,0 @@
-// @ts-nocheck
-// SPDX-License-Identifier: MIT
-// Ported from CVC Agent (https://github.com/NousResearch/cvc)
-// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
-import { createWriteStream } from 'node:fs';
-import { mkdir, readdir, readFile, writeFile } from 'node:fs/promises';
-import { homedir, tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { pipeline } from 'node:stream/promises';
-import { getHeapSnapshot, getHeapSpaceStatistics, getHeapStatistics } from 'node:v8';
-export async function captureMemoryDiagnostics(trigger) {
-    const usage = process.memoryUsage();
-    const heapStats = getHeapStatistics();
-    const resourceUsage = process.resourceUsage();
-    const uptimeSeconds = process.uptime();
-    // Not available on Bun / older Node.
-    let heapSpaces;
-    try {
-        heapSpaces = getHeapSpaceStatistics();
-    }
-    catch {
-        /* noop */
-    }
-    const internals = process;
-    const activeHandles = internals._getActiveHandles().length;
-    const activeRequests = internals._getActiveRequests().length;
-    const openFileDescriptors = await swallow(async () => (await readdir('/proc/self/fd')).length);
-    const smapsRollup = await swallow(() => readFile('/proc/self/smaps_rollup', 'utf8'));
-    const nativeMemory = usage.rss - usage.heapUsed;
-    // Real growth rate since STARTED_AT (captured at module load) — NOT a lifetime
-    // average of rss/uptime, which would report phantom "growth" for a stable process.
-    const elapsed = Math.max(0, uptimeSeconds - STARTED_AT.uptime);
-    const bytesPerSecond = elapsed > 0 ? (usage.rss - STARTED_AT.rss) / elapsed : 0;
-    const mbPerHour = (bytesPerSecond * 3600) / (1024 * 1024);
-    const potentialLeaks = [
-        heapStats.number_of_detached_contexts > 0 &&
-            `${heapStats.number_of_detached_contexts} detached context(s) — possible component/closure leak`,
-        activeHandles > 100 && `${activeHandles} active handles — possible timer/socket leak`,
-        nativeMemory > usage.heapUsed && 'Native memory > heap — leak may be in native addons',
-        mbPerHour > 100 && `High memory growth rate: ${mbPerHour.toFixed(1)} MB/hour`,
-        openFileDescriptors && openFileDescriptors > 500 && `${openFileDescriptors} open FDs — possible file/socket leak`
-    ].filter((s) => typeof s === 'string');
-    return {
-        activeHandles,
-        activeRequests,
-        analysis: {
-            potentialLeaks,
-            recommendation: potentialLeaks.length
-                ? `WARNING: ${potentialLeaks.length} potential leak indicator(s). See potentialLeaks.`
-                : 'No obvious leak indicators. Inspect heap snapshot for retained objects.'
-        },
-        memoryGrowthRate: { bytesPerSecond, mbPerHour },
-        memoryUsage: {
-            arrayBuffers: usage.arrayBuffers,
-            external: usage.external,
-            heapTotal: usage.heapTotal,
-            heapUsed: usage.heapUsed,
-            rss: usage.rss
-        },
-        nodeVersion: process.version,
-        openFileDescriptors,
-        platform: process.platform,
-        resourceUsage: {
-            maxRSS: resourceUsage.maxRSS * 1024,
-            systemCPUTime: resourceUsage.systemCPUTime,
-            userCPUTime: resourceUsage.userCPUTime
-        },
-        smapsRollup,
-        timestamp: new Date().toISOString(),
-        trigger,
-        uptimeSeconds,
-        v8HeapSpaces: heapSpaces?.map(s => ({
-            available: s.space_available_size,
-            name: s.space_name,
-            size: s.space_size,
-            used: s.space_used_size
-        })),
-        v8HeapStats: {
-            detachedContexts: heapStats.number_of_detached_contexts,
-            heapSizeLimit: heapStats.heap_size_limit,
-            mallocedMemory: heapStats.malloced_memory,
-            nativeContexts: heapStats.number_of_native_contexts,
-            peakMallocedMemory: heapStats.peak_malloced_memory
-        }
-    };
-}
-export async function performHeapDump(trigger = 'manual') {
-    try {
-        // Diagnostics first — heap-snapshot serialization can crash on very large
-        // heaps, and the JSON sidecar is the most actionable artifact if so.
-        const diagnostics = await captureMemoryDiagnostics(trigger);
-        const dir = process.env.HERMES_HEAPDUMP_DIR?.trim() || join(homedir() || tmpdir(), '.hermes', 'heapdumps');
-        await mkdir(dir, { recursive: true });
-        const base = `hermes-${new Date().toISOString().replace(/[:.]/g, '-')}-${process.pid}-${trigger}`;
-        const heapPath = join(dir, `${base}.heapsnapshot`);
-        const diagPath = join(dir, `${base}.diagnostics.json`);
-        await writeFile(diagPath, JSON.stringify(diagnostics, null, 2), { mode: 0o600 });
-        await pipeline(getHeapSnapshot(), createWriteStream(heapPath, { mode: 0o600 }));
-        return { diagPath, heapPath, success: true };
-    }
-    catch (e) {
-        return { error: e instanceof Error ? e.message : String(e), success: false };
-    }
-}
-export function formatBytes(bytes) {
-    if (!Number.isFinite(bytes) || bytes <= 0) {
-        return '0B';
-    }
-    const exp = Math.min(UNITS.length - 1, Math.floor(Math.log10(bytes) / 3));
-    const value = bytes / 1024 ** exp;
-    return `${value >= 100 ? value.toFixed(0) : value.toFixed(1)}${UNITS[exp]}`;
-}
-const UNITS = ['B', 'KB', 'MB', 'GB', 'TB'];
-const STARTED_AT = { rss: process.memoryUsage().rss, uptime: process.uptime() };
-// Returns undefined when the probe isn't available (non-Linux paths, sandboxed FS).
-const swallow = async (fn) => {
-    try {
-        return await fn();
-    }
-    catch {
-        return undefined;
-    }
-};

package/dist/lib/memoryMonitor.js

@@ -1,76 +0,0 @@
-// @ts-nocheck
-// SPDX-License-Identifier: MIT
-// Ported from CVC Agent (https://github.com/NousResearch/cvc)
-// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
-import { performHeapDump } from './memory.js';
-const GB = 1024 ** 3;
-// Deferred @cvc/ink import: loading `@cvc/ink` at module top-level
-// pulls the full ~414KB Ink bundle (React, renderer, components, hooks) onto
-// the critical path before the Python gateway can even be spawned. That
-// serialised roughly 150ms of Node work in front of gw.start() on every
-// cold `hermes --tui` launch.
-//
-// evictInkCaches only runs inside `tick()`, which fires on a 10s timer and
-// only when heap pressure crosses the high-water mark — by then Ink has
-// long since been loaded by the app entry. This dynamic import is a no-op
-// on the hot path (module is already in the ESM cache); when a startup
-// spike somehow trips the threshold before the app registers its own Ink
-// import, we pay the load cost exactly once, inside the tick that needs it.
-let _evictInkCaches = null;
-let _evictInkCachesPromise = null;
-async function _ensureEvictInkCaches() {
-    if (_evictInkCaches) {
-        return _evictInkCaches;
-    }
-    _evictInkCachesPromise ??= import('@cvc/ink')
-        .then(mod => {
-        _evictInkCaches = mod.evictInkCaches;
-        return _evictInkCaches;
-    })
-        .catch(err => {
-        _evictInkCachesPromise = null;
-        throw err;
-    });
-    return _evictInkCachesPromise;
-}
-export function startMemoryMonitor({ criticalBytes = 2.5 * GB, highBytes = 1.5 * GB, intervalMs = 10_000, onCritical, onHigh } = {}) {
-    const dumped = new Set();
-    const inFlight = new Set();
-    const tick = async () => {
-        const { heapUsed, rss } = process.memoryUsage();
-        const level = heapUsed >= criticalBytes ? 'critical' : heapUsed >= highBytes ? 'high' : 'normal';
-        if (level === 'normal') {
-            dumped.clear();
-            return;
-        }
-        if (dumped.has(level) || inFlight.has(level)) {
-            return;
-        }
-        inFlight.add(level);
-        // Prune Ink content caches before dump/exit — half on 'high' (recoverable),
-        // full on 'critical' (post-dump RSS reduction, keeps user running).
-        // Deferred import keeps `@cvc/ink` off the cold-start critical path;
-        // by the time a tick fires 10s after launch the app has already loaded
-        // the same module, so this resolves instantly from the ESM cache.
-        try {
-            try {
-                const evictInkCaches = await _ensureEvictInkCaches();
-                evictInkCaches(level === 'critical' ? 'all' : 'half');
-            }
-            catch {
-                // Best-effort: if the dynamic import fails for any reason we still
-                // continue to the heap dump below so the user gets diagnostics.
-            }
-            dumped.add(level);
-            const dump = await performHeapDump(level === 'critical' ? 'auto-critical' : 'auto-high').catch(() => null);
-            const snap = { heapUsed, level, rss };
-            (level === 'critical' ? onCritical : onHigh)?.(snap, dump);
-        }
-        finally {
-            inFlight.delete(level);
-        }
-    };
-    const handle = setInterval(() => void tick(), intervalMs);
-    handle.unref?.();
-    return () => clearInterval(handle);
-}

package/dist/lib/messages.js

@@ -1,3 +0,0 @@
-import { appendToolShelfMessage } from './liveProgress.js';
-export const appendTranscriptMessage = (prev, msg) => appendToolShelfMessage(prev, msg);
-export const upsert = (prev, role, text) => prev.at(-1)?.role === role ? [...prev.slice(0, -1), { role, text }] : [...prev, { role, text }];

package/dist/lib/messages.test.js

@@ -1,25 +0,0 @@
-// @ts-nocheck
-// SPDX-License-Identifier: MIT
-// Ported from CVC Agent (https://github.com/NousResearch/cvc)
-// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
-import { describe, expect, it } from 'vitest';
-import { appendTranscriptMessage } from './messages.js';
-describe('appendTranscriptMessage', () => {
-    it('merges adjacent tool-only shelves into one transcript row', () => {
-        const out = appendTranscriptMessage([{ kind: 'trail', role: 'system', text: '', tools: ['Terminal("one") ✓'] }], {
-            kind: 'trail',
-            role: 'system',
-            text: '',
-            tools: ['Terminal("two") ✓']
-        });
-        expect(out).toEqual([
-            { kind: 'trail', role: 'system', text: '', tools: ['Terminal("one") ✓', 'Terminal("two") ✓'] }
-        ]);
-    });
-    it('merges tool shelves into the nearest thinking shelf', () => {
-        const out = appendTranscriptMessage([{ kind: 'trail', role: 'system', text: '', thinking: 'plan', tools: ['Terminal("one") ✓'] }], { kind: 'trail', role: 'system', text: '', tools: ['Terminal("two") ✓'] });
-        expect(out).toEqual([
-            { kind: 'trail', role: 'system', text: '', thinking: 'plan', tools: ['Terminal("one") ✓', 'Terminal("two") ✓'] }
-        ]);
-    });
-});

package/dist/lib/osc52.js

@@ -1,53 +0,0 @@
-// @ts-nocheck
-// SPDX-License-Identifier: MIT
-// Ported from CVC Agent (https://github.com/NousResearch/cvc)
-// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
-const ESC = '\x1b';
-const BEL = '\x07';
-const ST = `${ESC}\\`;
-export const OSC52_CLIPBOARD_QUERY = `${ESC}]52;c;?${BEL}`;
-function wrapForMultiplexer(sequence) {
-    if (process.env['TMUX']) {
-        return `${ESC}Ptmux;${sequence.split(ESC).join(ESC + ESC)}${ST}`;
-    }
-    if (process.env['STY']) {
-        return `${ESC}P${sequence}${ST}`;
-    }
-    return sequence;
-}
-export function buildOsc52ClipboardQuery() {
-    return wrapForMultiplexer(OSC52_CLIPBOARD_QUERY);
-}
-export function parseOsc52ClipboardData(data) {
-    const firstSep = data.indexOf(';');
-    if (firstSep === -1) {
-        return null;
-    }
-    const selection = data.slice(0, firstSep);
-    const payload = data.slice(firstSep + 1);
-    if ((selection !== 'c' && selection !== 'p') || !payload || payload === '?') {
-        return null;
-    }
-    try {
-        return Buffer.from(payload, 'base64').toString('utf8');
-    }
-    catch {
-        return null;
-    }
-}
-export async function readOsc52Clipboard(querier, timeoutMs = 500) {
-    if (!querier) {
-        return null;
-    }
-    const timeout = new Promise(resolve => setTimeout(resolve, timeoutMs));
-    const query = querier.send({
-        request: buildOsc52ClipboardQuery(),
-        match: (r) => {
-            return !!r && typeof r === 'object' && r.type === 'osc' && r.code === 52;
-        }
-    });
-    const response = await Promise.race([query, timeout]);
-    await querier.flush();
-    return response ? parseOsc52ClipboardData(response.data) : null;
-}
-export const writeOsc52Clipboard = (s) => process.stdout.write(`\x1b]52;c;${Buffer.from(s, 'utf8').toString('base64')}\x07`);

package/dist/lib/perfPane.js

@@ -1,94 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-// @ts-nocheck
-// SPDX-License-Identifier: MIT
-// Ported from CVC Agent (https://github.com/NousResearch/cvc)
-// Original Copyright (c) 2025 Nous Research. CVC adaptations (c) 2026 Jai Kumar Meena.
-// Perf instrumentation for the full render pipeline.
-//
-//   PerfPane (React.Profiler)  → per-pane commit times
-//   logFrameEvent (ink.onFrame) → yoga / renderer / diff / optimize / write
-//                                 phases + yoga counters + scroll fast-path
-//
-// Both gate on HERMES_DEV_PERF=1 and dump JSON-lines (default ~/.hermes/perf.log,
-// override HERMES_DEV_PERF_LOG). Tagged { src: 'react' | 'frame' } for jq.
-// HERMES_DEV_PERF_MS (default 2) skips sub-ms idle frames; set 0 to capture all.
-//
-// Zero cost when unset: PerfPane returns children directly, logFrameEvent is
-// undefined so ink doesn't pay the timing cost.
-import { appendFileSync, mkdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { dirname, join } from 'node:path';
-import { scrollFastPathStats } from '@cvc/ink';
-import { Profiler } from 'react';
-const ENABLED = /^(?:1|true|yes|on)$/i.test((process.env.HERMES_DEV_PERF ?? '').trim());
-const THRESHOLD_MS = Number(process.env.HERMES_DEV_PERF_MS ?? '2') || 0;
-const LOG_PATH = process.env.HERMES_DEV_PERF_LOG?.trim() || join(homedir(), '.hermes', 'perf.log');
-let logReady = false;
-const writeRow = (row) => {
-    if (!logReady) {
-        logReady = true;
-        try {
-            mkdirSync(dirname(LOG_PATH), { recursive: true });
-        }
-        catch {
-            // Best-effort — never crash the TUI to log a sample.
-        }
-    }
-    try {
-        appendFileSync(LOG_PATH, `${JSON.stringify(row)}\n`);
-    }
-    catch {
-        /* best-effort */
-    }
-};
-const round2 = (n) => Math.round(n * 100) / 100;
-const onRender = (id, phase, actualMs, baseMs, startTime, commitTime) => {
-    if (actualMs < THRESHOLD_MS) {
-        return;
-    }
-    writeRow({
-        actualMs: round2(actualMs),
-        baseMs: round2(baseMs),
-        commitTimeMs: round2(commitTime),
-        id,
-        phase,
-        src: 'react',
-        startTimeMs: round2(startTime),
-        ts: Date.now()
-    });
-};
-export function PerfPane({ children, id }) {
-    if (!ENABLED) {
-        return children;
-    }
-    return (_jsx(Profiler, { id: id, onRender: onRender, children: children }));
-}
-export const logFrameEvent = ENABLED
-    ? (event) => {
-        if (event.durationMs < THRESHOLD_MS) {
-            return;
-        }
-        writeRow({
-            durationMs: round2(event.durationMs),
-            // Cumulative counters — consumers diff pairs to get per-frame deltas.
-            fastPath: { ...scrollFastPathStats, declined: { ...scrollFastPathStats.declined } },
-            flickers: event.flickers.length ? event.flickers : undefined,
-            phases: event.phases
-                ? {
-                    ...event.phases,
-                    commit: round2(event.phases.commit),
-                    diff: round2(event.phases.diff),
-                    optimize: round2(event.phases.optimize),
-                    prevFrameDrainMs: round2(event.phases.prevFrameDrainMs),
-                    renderer: round2(event.phases.renderer),
-                    write: round2(event.phases.write),
-                    yoga: round2(event.phases.yoga)
-                }
-                : undefined,
-            src: 'frame',
-            ts: Date.now()
-        });
-    }
-    : undefined;
-export const PERF_ENABLED = ENABLED;
-export const PERF_LOG_PATH = LOG_PATH;