cc-context-stats 1.6.2 → 1.8.0

package/scripts/statusline.js

@@ -36,6 +36,61 @@ const os = require('os');
 const ROTATION_THRESHOLD = 10000;
 const ROTATION_KEEP = 5000;
 
+// Model Intelligence constants (hardcoded, not configurable)
+const MI_WEIGHT_CPS = 0.60;
+const MI_WEIGHT_ES = 0.25;
+const MI_WEIGHT_PS = 0.15;
+const MI_GREEN_THRESHOLD = 0.65;
+const MI_YELLOW_THRESHOLD = 0.35;
+const MI_PRODUCTIVITY_TARGET = 0.2;
+
+/**
+ * Compute Model Intelligence score.
+ * Returns { mi, cps, es, ps }.
+ */
+function computeMI(usedTokens, contextWindowSize, cacheRead, totalContext,
+                   deltaLines, deltaOutput, beta = 1.5) {
+    // Guard clause
+    if (contextWindowSize === 0) {
+        return { mi: 1.0, cps: 1.0, es: 1.0, ps: 0.5 };
+    }
+
+    // CPS
+    const u = usedTokens / contextWindowSize;
+    const cps = u > 0 ? Math.max(0, 1 - Math.pow(u, beta)) : 1.0;
+
+    // ES
+    let es;
+    if (totalContext === 0) {
+        es = 1.0;
+    } else {
+        const cacheHitRatio = cacheRead / totalContext;
+        es = 0.3 + 0.7 * cacheHitRatio;
+    }
+
+    // PS
+    let ps;
+    if (deltaOutput === null || deltaOutput === undefined || deltaOutput <= 0) {
+        ps = 0.5;
+    } else {
+        const ratio = deltaLines / deltaOutput;
+        const normalized = Math.min(1.0, ratio / MI_PRODUCTIVITY_TARGET);
+        ps = 0.2 + 0.8 * normalized;
+    }
+
+    const mi = MI_WEIGHT_CPS * cps + MI_WEIGHT_ES * es + MI_WEIGHT_PS * ps;
+    return { mi, cps, es, ps };
+}
+
+/**
+ * Return ANSI color code for MI score.
+ */
+function getMIColor(mi, greenColor, yellowColor, redColor) {
+    if (mi > MI_GREEN_THRESHOLD) return greenColor || GREEN;
+    if (mi > MI_YELLOW_THRESHOLD) return yellowColor || YELLOW;
+    return redColor || RED;
+}
+
 /**
  * Rotate a state file if it exceeds ROTATION_THRESHOLD lines.
  * Keeps the most recent ROTATION_KEEP lines via atomic temp-file + rename.
@@ -72,7 +127,7 @@ function maybeRotateStateFile(stateFile) {
     }
 }
 
-// ANSI Colors
+// ANSI Colors (defaults, overridable via config)
 const BLUE = '\x1b[0;34m';
 const MAGENTA = '\x1b[0;35m';
 const CYAN = '\x1b[0;36m';
@@ -82,6 +137,54 @@ const RED = '\x1b[0;31m';
 const DIM = '\x1b[2m';
 const RESET = '\x1b[0m';
 
+// Named colors for config parsing
+const COLOR_NAMES = {
+    black: '\x1b[0;30m',
+    red: '\x1b[0;31m',
+    green: '\x1b[0;32m',
+    yellow: '\x1b[0;33m',
+    blue: '\x1b[0;34m',
+    magenta: '\x1b[0;35m',
+    cyan: '\x1b[0;36m',
+    white: '\x1b[0;37m',
+    bright_black: '\x1b[0;90m',
+    bright_red: '\x1b[0;91m',
+    bright_green: '\x1b[0;92m',
+    bright_yellow: '\x1b[0;93m',
+    bright_blue: '\x1b[0;94m',
+    bright_magenta: '\x1b[0;95m',
+    bright_cyan: '\x1b[0;96m',
+    bright_white: '\x1b[0;97m',
+};
+
+/**
+ * Parse a color name or #rrggbb hex into an ANSI escape code.
+ * Returns null if unrecognized.
+ */
+function parseColor(value) {
+    value = value.trim().toLowerCase();
+    if (COLOR_NAMES[value]) {
+        return COLOR_NAMES[value];
+    }
+    const m = value.match(/^#([0-9a-f]{6})$/);
+    if (m) {
+        const r = parseInt(m[1].slice(0, 2), 16);
+        const g = parseInt(m[1].slice(2, 4), 16);
+        const b = parseInt(m[1].slice(4, 6), 16);
+        return `\x1b[38;2;${r};${g};${b}m`;
+    }
+    return null;
+}
+
+const COLOR_CONFIG_KEYS = {
+    color_green: 'green',
+    color_yellow: 'yellow',
+    color_red: 'red',
+    color_blue: 'blue',
+    color_magenta: 'magenta',
+    color_cyan: 'cyan',
+};
+
 /**
  * Return the visible width of a string after stripping ANSI escape sequences.
  */
@@ -93,8 +196,24 @@ function visibleWidth(s) {
 /**
  * Return the terminal width in columns, defaulting to 80.
  */
+/**
+ * Return the terminal width in columns.
+ *
+ * When running inside Claude Code's statusline subprocess, neither $COLUMNS
+ * nor process.stdout.columns can detect the real terminal width (they return
+ * undefined or 80). If COLUMNS is not explicitly set and we'd fall back to 80,
+ * use a generous default of 200 so that no parts are unnecessarily dropped;
+ * Claude Code's own UI handles any overflow/truncation.
+ */
 function getTerminalWidth() {
-    return process.stdout.columns || parseInt(process.env.COLUMNS, 10) || 80;
+    if (process.env.COLUMNS) {
+        return parseInt(process.env.COLUMNS, 10) || 200;
+    }
+    const cols = process.stdout.columns;
+    if (cols && cols !== 80) {
+        return cols;
+    }
+    return 200;
 }
 
 /**
@@ -125,7 +244,9 @@ function fitToWidth(parts, maxWidth) {
     return result;
 }
 
-function getGitInfo(projectDir) {
+function getGitInfo(projectDir, magentaColor, cyanColor) {
+    const mg = magentaColor || MAGENTA;
+    const cy = cyanColor || CYAN;
     const gitDir = path.join(projectDir, '.git');
     if (!fs.existsSync(gitDir) || !fs.statSync(gitDir).isDirectory()) {
         return '';
@@ -154,9 +275,9 @@ function getGitInfo(projectDir) {
         const changes = status.split('\n').filter(l => l.trim()).length;
 
         if (changes > 0) {
-            return ` | ${MAGENTA}${branch}${RESET} ${CYAN}[${changes}]${RESET}`;
+            return ` | ${mg}${branch}${RESET} ${cy}[${changes}]${RESET}`;
         }
-        return ` | ${MAGENTA}${branch}${RESET}`;
+        return ` | ${mg}${branch}${RESET}`;
     } catch {
         return '';
     }
@@ -170,6 +291,9 @@ function readConfig() {
         showSession: true,
         showIoTokens: true,
         reducedMotion: false,
+        showMI: true,
+        miCurveBeta: 1.5,
+        colors: {},
     };
     const configPath = path.join(os.homedir(), '.claude', 'statusline.conf');
 
@@ -192,6 +316,12 @@ show_delta=true
 
 # Show session_id in status line
 show_session=true
+
+# Custom colors - use named colors or hex (#rrggbb)
+# Available: color_green, color_yellow, color_red, color_blue, color_magenta, color_cyan
+# Examples:
+#   color_green=#7dcfff
+#   color_red=#f7768e
 `;
             fs.writeFileSync(configPath, defaultConfig);
         } catch (e) {
@@ -207,9 +337,10 @@ show_session=true
             if (trimmed.startsWith('#') || !trimmed.includes('=')) {
                 continue;
             }
-            const [key, value] = trimmed.split('=', 2);
-            const keyTrimmed = key.trim();
-            const valueTrimmed = value.trim().toLowerCase();
+            const eqIdx = trimmed.indexOf('=');
+            const keyTrimmed = trimmed.slice(0, eqIdx).trim();
+            const rawValue = trimmed.slice(eqIdx + 1).trim();
+            const valueTrimmed = rawValue.toLowerCase();
             if (keyTrimmed === 'autocompact') {
                 config.autocompact = valueTrimmed !== 'false';
             } else if (keyTrimmed === 'token_detail') {
@@ -222,6 +353,18 @@ show_session=true
                 config.showIoTokens = valueTrimmed !== 'false';
             } else if (keyTrimmed === 'reduced_motion') {
                 config.reducedMotion = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'show_mi') {
+                config.showMI = valueTrimmed !== 'false';
+            } else if (keyTrimmed === 'mi_curve_beta') {
+                const parsed = parseFloat(rawValue);
+                if (!isNaN(parsed)) {
+                    config.miCurveBeta = parsed;
+                }
+            } else if (COLOR_CONFIG_KEYS[keyTrimmed]) {
+                const ansi = parseColor(rawValue);
+                if (ansi) {
+                    config.colors[COLOR_CONFIG_KEYS[keyTrimmed]] = ansi;
+                }
             }
         }
     } catch (e) {
@@ -250,9 +393,6 @@ process.stdin.on('end', () => {
     const model = data.model?.display_name || 'Claude';
     const dirName = path.basename(cwd) || '~';
 
-    // Git info
-    const gitInfo = getGitInfo(projectDir);
-
     // Read settings from config file
     const config = readConfig();
     const autocompactEnabled = config.autocompact;
@@ -261,6 +401,18 @@ process.stdin.on('end', () => {
     const showSession = config.showSession;
     // Note: showIoTokens setting is read but not yet implemented
 
+    // Apply color overrides from config
+    const c = config.colors || {};
+    const cGreen = c.green || GREEN;
+    const cYellow = c.yellow || YELLOW;
+    const cRed = c.red || RED;
+    const cBlue = c.blue || BLUE;
+    const cMagenta = c.magenta || MAGENTA;
+    const cCyan = c.cyan || CYAN;
+
+    // Git info (pass configurable colors)
+    const gitInfo = getGitInfo(projectDir, cMagenta, cCyan);
+
     // Extract session_id once for reuse
     const sessionId = data.session_id;
 
@@ -268,7 +420,10 @@ process.stdin.on('end', () => {
     let contextInfo = '';
     let acInfo = '';
     let deltaInfo = '';
+    let miInfo = '';
     let sessionInfo = '';
+    const showMI = config.showMI;
+    const miCurveBeta = config.miCurveBeta;
     const totalSize = data.context_window?.context_window_size || 0;
     const currentUsage = data.context_window?.current_usage;
     const totalInputTokens = data.context_window?.total_input_tokens || 0;
@@ -320,17 +475,17 @@ process.stdin.on('end', () => {
         // Color based on free percentage
         let ctxColor;
         if (freePctInt > 50) {
-            ctxColor = GREEN;
+            ctxColor = cGreen;
         } else if (freePctInt > 25) {
-            ctxColor = YELLOW;
+            ctxColor = cYellow;
         } else {
-            ctxColor = RED;
+            ctxColor = cRed;
         }
 
-        contextInfo = ` | ${ctxColor}${freeDisplay} free (${freePct.toFixed(1)}%)${RESET}`;
+        contextInfo = ` | ${ctxColor}${freeDisplay} (${freePct.toFixed(1)}%)${RESET}`;
 
-        // Calculate and display token delta if enabled
-        if (showDelta) {
+        // Read previous entry if needed for delta OR MI
+        if (showDelta || showMI) {
             const stateDir = path.join(os.homedir(), '.claude', 'statusline');
             if (!fs.existsSync(stateDir)) {
                 fs.mkdirSync(stateDir, { recursive: true });
@@ -360,10 +515,13 @@ process.stdin.on('end', () => {
             const stateFile = path.join(stateDir, stateFileName);
             let hasPrev = false;
             let prevTokens = 0;
+            let prevOutputTokens = 0;
+            let prevLinesAdded = 0;
+            let prevLinesRemoved = 0;
             try {
                 if (fs.existsSync(stateFile)) {
                     hasPrev = true;
-                    // Read last line to get previous context usage
+                    // Read last line to get previous state
                     const content = fs.readFileSync(stateFile, 'utf8').trim();
                     const lines = content.split('\n');
                     const lastLine = lines[lines.length - 1];
@@ -376,6 +534,10 @@ process.stdin.on('end', () => {
                         const prevCacheCreation = parseInt(parts[5], 10) || 0;
                         const prevCacheRead = parseInt(parts[6], 10) || 0;
                         prevTokens = prevCurInput + prevCacheCreation + prevCacheRead;
+                        // For MI productivity score
+                        prevOutputTokens = parseInt(parts[2], 10) || 0;
+                        prevLinesAdded = parseInt(parts[8], 10) || 0;
+                        prevLinesRemoved = parseInt(parts[9], 10) || 0;
                     } else {
                         // Old format - single value
                         prevTokens = parseInt(lastLine, 10) || 0;
@@ -387,20 +549,40 @@ process.stdin.on('end', () => {
                 );
                 prevTokens = 0;
             }
-            // Calculate delta (difference in context window usage)
-            const delta = usedTokens - prevTokens;
-            // Only show positive delta (and skip first run when no previous state)
-            if (hasPrev && delta > 0) {
-                const deltaDisplay = tokenDetail
-                    ? delta.toLocaleString('en-US')
-                    : `${(delta / 1000).toFixed(1)}k`;
-                deltaInfo = ` ${DIM}[+${deltaDisplay}]${RESET}`;
+
+            // Calculate and display token delta if enabled
+            if (showDelta) {
+                const delta = usedTokens - prevTokens;
+                if (hasPrev && delta > 0) {
+                    const deltaDisplay = tokenDetail
+                        ? delta.toLocaleString('en-US')
+                        : `${(delta / 1000).toFixed(1)}k`;
+                    deltaInfo = ` ${DIM}[+${deltaDisplay}]${RESET}`;
+                }
+            }
+
+            // Calculate and display MI score if enabled
+            if (showMI) {
+                let deltaLines, deltaOutput;
+                if (hasPrev) {
+                    const deltaLA = linesAdded - prevLinesAdded;
+                    const deltaLR = linesRemoved - prevLinesRemoved;
+                    deltaLines = deltaLA + deltaLR;
+                    deltaOutput = totalOutputTokens - prevOutputTokens;
+                } else {
+                    deltaLines = 0;
+                    deltaOutput = null;
+                }
+                const miResult = computeMI(
+                    usedTokens, totalSize, cacheRead, usedTokens,
+                    deltaLines, deltaOutput, miCurveBeta
+                );
+                const miColor = getMIColor(miResult.mi, cGreen, cYellow, cRed);
+                miInfo = ` ${miColor}MI:${miResult.mi.toFixed(2)}${RESET}`;
             }
+
             // Only append if context usage changed (avoid duplicates from multiple refreshes)
             if (!hasPrev || usedTokens !== prevTokens) {
-                // Append current usage with comprehensive format
-                // Format: ts,total_in,total_out,cur_in,cur_out,cache_create,cache_read,
-                //         cost_usd,lines_added,lines_removed,session_id,model_id,project_dir
                 try {
                     const timestamp = Math.floor(Date.now() / 1000);
                     const curInputTokens = currentUsage.input_tokens || 0;
@@ -438,13 +620,13 @@ process.stdin.on('end', () => {
     }
 
     // Output: [Model] dir | branch [n] | free (%) [+delta] [AC] session
-    const base = `${DIM}[${model}]${RESET} ${BLUE}${dirName}${RESET}`;
+    const base = `${DIM}[${model}]${RESET} ${cBlue}${dirName}${RESET}`;
     const maxWidth = getTerminalWidth();
-    const parts = [base, gitInfo, contextInfo, deltaInfo, acInfo, sessionInfo];
+    const parts = [base, gitInfo, contextInfo, deltaInfo, miInfo, acInfo, sessionInfo];
     console.log(fitToWidth(parts, maxWidth));
 });
 
 // Export for testing
 if (typeof module !== 'undefined' && module.exports) {
-    module.exports = { maybeRotateStateFile, ROTATION_THRESHOLD, ROTATION_KEEP };
+    module.exports = { maybeRotateStateFile, ROTATION_THRESHOLD, ROTATION_KEEP, computeMI };
 }