@ekkos/cli 0.3.3 → 1.0.1

package/dist/lib/tmux-scrollbar.js

@@ -0,0 +1,296 @@
+#!/usr/bin/env node
+"use strict";
+/**
+ * tmux-scrollbar.ts
+ *
+ * A thin visual scrollbar (2 columns wide) that runs in its own narrow tmux pane.
+ * It tracks the scroll position of a target pane (Claude Code) and renders a
+ * proportional scrollbar thumb. Supports click-to-jump and drag-to-scroll.
+ *
+ * Usage: node tmux-scrollbar.js <target-pane>
+ * Example: node tmux-scrollbar.js :.0
+ *
+ * Layout: [Claude Code (68%)] [Scrollbar (2col)] [Dashboard (30%)]
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+const child_process_1 = require("child_process");
+const TARGET_PANE = process.argv[2] || ':.0';
+const POLL_MS = 200;
+// ── ANSI escape sequences ──
+const ESC = '\x1b';
+const CSI = `${ESC}[`;
+const ansi = {
+    clear: `${CSI}2J`,
+    home: `${CSI}H`,
+    hideCursor: `${CSI}?25l`,
+    showCursor: `${CSI}?25h`,
+    // SGR extended mouse protocol: supports coordinates > 223
+    enableMouse: `${CSI}?1000h${CSI}?1002h${CSI}?1006h`,
+    disableMouse: `${CSI}?1000l${CSI}?1002l${CSI}?1006l`,
+    reset: `${CSI}0m`,
+    moveTo: (row, col) => `${CSI}${row};${col}H`,
+    // 256-color mode
+    fg256: (n) => `${CSI}38;5;${n}m`,
+    bg256: (n) => `${CSI}48;5;${n}m`,
+};
+// ── Color scheme (matches dashboard cyan theme) ──
+const COLORS = {
+    thumbFg: ansi.fg256(44), // Cyan thumb
+    thumbBg: ansi.bg256(23), // Dark cyan background
+    thumbActiveFg: ansi.fg256(51), // Bright cyan when dragging
+    thumbActiveBg: ansi.bg256(30), // Brighter dark cyan when dragging
+    trackFg: ansi.fg256(236), // Very dark gray track dots
+    trackBg: ansi.bg256(233), // Near-black background
+    labelFg: ansi.fg256(240), // Dim label text
+};
+// ── State ──
+let lastRenderedFrame = '';
+let isDragging = false;
+let pollTimer;
+function getHeight() {
+    return process.stdout.rows || 40;
+}
+/**
+ * Query tmux for the target pane's scroll position.
+ * Returns { inMode, scrollPos, historySize, paneHeight }
+ */
+function getPaneInfo() {
+    try {
+        const raw = (0, child_process_1.execSync)(`tmux display-message -p -t "${TARGET_PANE}" ` +
+            `'#{pane_in_mode}|#{scroll_position}|#{history_size}|#{pane_height}'`, { encoding: 'utf-8', timeout: 800, stdio: ['pipe', 'pipe', 'pipe'] }).trim();
+        const [mode, pos, hist, ph] = raw.split('|');
+        return {
+            inMode: mode === '1',
+            scrollPos: parseInt(pos) || 0,
+            historySize: parseInt(hist) || 0,
+            paneHeight: parseInt(ph) || 40,
+        };
+    }
+    catch {
+        return { inMode: false, scrollPos: 0, historySize: 0, paneHeight: 40 };
+    }
+}
+/**
+ * Render the scrollbar to stdout using ANSI escape codes.
+ * Only redraws if the frame has changed (diffing).
+ */
+function render() {
+    const height = getHeight();
+    const info = getPaneInfo();
+    // Total scrollable content
+    const totalLines = info.historySize + info.paneHeight;
+    if (totalLines <= 0)
+        return;
+    // Thumb size proportional to viewport/total
+    const viewportRatio = Math.min(1, info.paneHeight / totalLines);
+    const thumbSize = Math.max(2, Math.round(viewportRatio * height));
+    // Thumb position
+    let thumbTop;
+    if (!info.inMode || info.historySize === 0) {
+        // Live output — thumb at bottom
+        thumbTop = height - thumbSize;
+    }
+    else {
+        // Copy mode — scroll_position = lines from bottom
+        const scrollFraction = Math.min(1, info.scrollPos / Math.max(1, info.historySize));
+        thumbTop = Math.round((1 - scrollFraction) * (height - thumbSize));
+    }
+    // Clamp
+    thumbTop = Math.max(0, Math.min(height - thumbSize, thumbTop));
+    // Build frame string
+    const fgColor = isDragging ? COLORS.thumbActiveFg : COLORS.thumbFg;
+    const bgColor = isDragging ? COLORS.thumbActiveBg : COLORS.thumbBg;
+    let frame = ansi.home;
+    for (let y = 0; y < height; y++) {
+        const isThumb = y >= thumbTop && y < thumbTop + thumbSize;
+        frame += ansi.moveTo(y + 1, 1);
+        if (isThumb) {
+            frame += `${fgColor}${bgColor}██${ansi.reset}`;
+        }
+        else {
+            frame += `${COLORS.trackFg}${COLORS.trackBg}░░${ansi.reset}`;
+        }
+    }
+    // Only write if changed
+    if (frame !== lastRenderedFrame) {
+        process.stdout.write(frame);
+        lastRenderedFrame = frame;
+    }
+}
+/**
+ * Scroll the target pane to a position based on scrollbar click location.
+ */
+function scrollToPosition(y) {
+    const height = getHeight();
+    const info = getPaneInfo();
+    if (info.historySize <= 0)
+        return;
+    const ratio = Math.max(0, Math.min(1, y / Math.max(1, height - 1)));
+    // If clicking at the very bottom, exit copy-mode for live output
+    if (ratio >= 0.95) {
+        try {
+            if (info.inMode) {
+                (0, child_process_1.execSync)(`tmux send-keys -t "${TARGET_PANE}" -X cancel`, {
+                    timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+        }
+        catch { /* ignore */ }
+        lastRenderedFrame = '';
+        render();
+        return;
+    }
+    // Target line from top of scrollback
+    const targetLine = Math.round(ratio * info.historySize);
+    try {
+        // Enter copy-mode if not already
+        if (!info.inMode) {
+            (0, child_process_1.execSync)(`tmux copy-mode -t "${TARGET_PANE}"`, {
+                timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        // Jump to target line using goto-line (tmux 3.1+)
+        // Fallback: history-top + cursor-down for older tmux
+        try {
+            (0, child_process_1.execSync)(`tmux send-keys -t "${TARGET_PANE}" -X goto-line ${targetLine}`, {
+                timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+        }
+        catch {
+            // Fallback for older tmux: go to top, then move down
+            (0, child_process_1.execSync)(`tmux send-keys -t "${TARGET_PANE}" -X history-top`, {
+                timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+            });
+            if (targetLine > 0) {
+                // Move in chunks to avoid command-line length limits
+                let remaining = targetLine;
+                while (remaining > 0) {
+                    const chunk = Math.min(remaining, 5000);
+                    (0, child_process_1.execSync)(`tmux send-keys -t "${TARGET_PANE}" -X -N ${chunk} cursor-down`, {
+                        timeout: 1000, stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                    remaining -= chunk;
+                }
+            }
+        }
+    }
+    catch { /* ignore scroll errors */ }
+    lastRenderedFrame = '';
+    render();
+}
+/**
+ * Refocus the target pane (Claude Code) after scrollbar interaction.
+ */
+function refocusTarget() {
+    try {
+        (0, child_process_1.execSync)(`tmux select-pane -t "${TARGET_PANE}"`, {
+            timeout: 300, stdio: ['pipe', 'pipe', 'pipe'],
+        });
+    }
+    catch { /* ignore */ }
+}
+// ── Mouse event handling ──
+function handleInput(data) {
+    const str = data.toString();
+    // Parse SGR mouse events: ESC [ < button ; x ; y M (press) / m (release)
+    const events = str.matchAll(/\x1b\[<(\d+);(\d+);(\d+)([Mm])/g);
+    for (const match of events) {
+        const button = parseInt(match[1]);
+        const y = parseInt(match[3]) - 1; // Convert to 0-indexed
+        const isPress = match[4] === 'M';
+        if (button === 0) {
+            // Left mouse button
+            if (isPress) {
+                isDragging = true;
+                scrollToPosition(y);
+            }
+            else {
+                // Release
+                if (isDragging) {
+                    isDragging = false;
+                    lastRenderedFrame = '';
+                    render();
+                    // Return focus to Claude Code pane after click
+                    refocusTarget();
+                }
+            }
+        }
+        else if (button === 32 && isDragging) {
+            // Left button drag (SGR reports button 32 for motion with button 0 held)
+            scrollToPosition(y);
+        }
+        else if (button === 64) {
+            // Scroll wheel up — forward to target pane
+            try {
+                const info = getPaneInfo();
+                if (!info.inMode) {
+                    (0, child_process_1.execSync)(`tmux copy-mode -t "${TARGET_PANE}" -e`, {
+                        timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+                    });
+                }
+                (0, child_process_1.execSync)(`tmux send-keys -t "${TARGET_PANE}" -X -N 5 scroll-up`, {
+                    timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch { /* ignore */ }
+            lastRenderedFrame = '';
+            render();
+        }
+        else if (button === 65) {
+            // Scroll wheel down — forward to target pane
+            try {
+                (0, child_process_1.execSync)(`tmux send-keys -t "${TARGET_PANE}" -X -N 5 scroll-down`, {
+                    timeout: 500, stdio: ['pipe', 'pipe', 'pipe'],
+                });
+            }
+            catch { /* ignore */ }
+            lastRenderedFrame = '';
+            render();
+        }
+        return; // Processed mouse event
+    }
+    // Keyboard input
+    if (str === 'q' || str === '\x03') {
+        // Quit on 'q' or Ctrl-C
+        shutdown();
+    }
+}
+// ── Lifecycle ──
+function setup() {
+    // Hide cursor, enable mouse tracking, clear screen
+    process.stdout.write(ansi.hideCursor + ansi.enableMouse + ansi.clear);
+    // Raw mode for stdin (capture mouse events)
+    if (process.stdin.setRawMode) {
+        process.stdin.setRawMode(true);
+    }
+    process.stdin.resume();
+    process.stdin.on('data', handleInput);
+    // Handle terminal resize
+    process.stdout.on('resize', () => {
+        lastRenderedFrame = '';
+        render();
+    });
+}
+function cleanup() {
+    process.stdout.write(ansi.showCursor + ansi.disableMouse + ansi.reset + ansi.clear);
+    if (process.stdin.setRawMode) {
+        try {
+            process.stdin.setRawMode(false);
+        }
+        catch { /* ignore */ }
+    }
+}
+function shutdown() {
+    clearInterval(pollTimer);
+    cleanup();
+    process.exit(0);
+}
+// Graceful exit
+process.on('exit', cleanup);
+process.on('SIGINT', shutdown);
+process.on('SIGTERM', shutdown);
+process.on('SIGHUP', shutdown);
+// ── Main ──
+setup();
+render();
+pollTimer = setInterval(render, POLL_MS);

package/dist/lib/usage-parser.d.ts

@@ -1,3 +1,36 @@
+export interface ActiveSession {
+    sessionId: string;
+    sessionName: string;
+    pid: number;
+    startedAt: string;
+    projectPath: string;
+    lastHeartbeat: string;
+}
+interface SessionNameResolution {
+    uuid: string;
+    sessionName: string;
+    projectPath: string;
+    encodedProjectPath: string;
+    startedAt?: string;
+}
+/** Detect ekkOS 3-word session names like "lit-lex-zip" */
+export declare function isEkkosSessionName(name: string): boolean;
+/** Resolve an ekkOS session name to a JSONL UUID */
+export declare function resolveSessionName(name: string): SessionNameResolution | null;
+/** Parse a single JSONL file and return SessionUsage for an ekkOS-named session */
+export declare function getSessionUsageByName(name: string): Promise<SessionUsage | null>;
+/** List ekkOS sessions with lightweight cost data (for session list view) */
+export declare function listEkkosSessions(limit?: number): Promise<{
+    name: string;
+    uuid: string;
+    projectPath: string;
+    startedAt: string;
+    lastHeartbeat: string;
+    cost: number;
+    tokens: number;
+    models: string[];
+    turnCount: number;
+}[]>;
 export interface TurnMetrics {
     turn_number: number;
     timestamp: string;
@@ -37,9 +70,10 @@ export interface CcusageSession {
     outputTokens: number;
     cacheCreationTokens: number;
     cacheReadTokens: number;
-    totalTokens: number;
+    cost: number;
     totalCost: number;
     lastActivity: string;
+    versions?: string[];
     modelsUsed: string[];
     modelBreakdowns: {
         modelName: string;
@@ -51,15 +85,54 @@ export interface CcusageSession {
     }[];
     projectPath: string;
 }
-export interface CcusageOutput {
-    sessions: CcusageSession[];
+/** Daily usage entry from ccusage */
+export interface CcusageDailyUsage {
+    date: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+    totalCost: number;
+    modelsUsed: string[];
+    modelBreakdowns: {
+        modelName: string;
+        inputTokens: number;
+        outputTokens: number;
+        cacheCreationTokens: number;
+        cacheReadTokens: number;
+        cost: number;
+    }[];
+}
+/** Weekly usage entry from ccusage */
+export interface CcusageWeeklyUsage {
+    week: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    totalCost: number;
+    modelsUsed: string[];
+    modelBreakdowns: CcusageDailyUsage['modelBreakdowns'];
+}
+/** Monthly usage entry from ccusage */
+export interface CcusageMonthlyUsage {
+    month: string;
+    inputTokens: number;
+    outputTokens: number;
+    cacheCreationTokens: number;
+    cacheReadTokens: number;
+    cost: number;
+    totalCost: number;
+    modelsUsed: string[];
+    modelBreakdowns: CcusageDailyUsage['modelBreakdowns'];
 }
 /**
- * Get all sessions using ccusage
+ * Get all sessions using ccusage library
  */
 export declare function getAllSessions(instanceId?: string): Promise<SessionUsage[]>;
 /**
- * Get specific session usage using ccusage
+ * Get specific session usage using ccusage library
  */
 export declare function getSessionUsage(sessionId: string, instanceId?: string): Promise<SessionUsage | null>;
 /**
@@ -70,3 +143,20 @@ export declare function getSessionName(sessionId: string): string;
  * Get current session ID from active Claude Code process
  */
 export declare function getCurrentSessionId(): string | null;
+/**
+ * Load daily usage data via ccusage library
+ */
+export declare function getDailyUsage(): Promise<CcusageDailyUsage[]>;
+/**
+ * Load weekly usage data via ccusage library
+ */
+export declare function getWeeklyUsage(): Promise<CcusageWeeklyUsage[]>;
+/**
+ * Load monthly usage data via ccusage library
+ */
+export declare function getMonthlyUsage(): Promise<CcusageMonthlyUsage[]>;
+/**
+ * Load bucket (5-hour block) usage data via ccusage library
+ */
+export declare function getBucketUsage(): Promise<any[]>;
+export {};