agy-statusline 1.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 radioman
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,148 @@
+# Optimized Statusline for Antigravity CLI
+
+<p align="center">
+  <img src="assets/logo.png" alt="Optimized Statusline for Antigravity CLI Logo" width="250" />
+</p>
+
+An optimized custom statusline implementation for the Antigravity CLI, featuring token scaling, dynamic context warnings, and a 20-step progress bar.
+
+## Features
+
+- **High Performance**: Native startup under Bun (`~3ms`) or Node.js (`~15ms`), fitting safely below the CLI's `150ms` execution timeout.
+- **Token Scale & Rounding**: Displays cumulative input and output token counts in `k` scale, rounded to the nearest integer.
+- **Dynamic Context Warnings**: Colorizes context usage text automatically based on total input token counts:
+  - **Cyan**: Normal ($<160\text{k}$ tokens)
+  - **Orange**: Warning ($\ge 160\text{k}$ tokens)
+  - **Red**: Alert ($\ge 200\text{k}$ tokens)
+- **20-Step Progress Bar**: Visualizes context usage percentage in 5% increments (`[■■■■□□□□□□□□□□□□□□□□]`).
+- **Compact & Split Layout**: Calibrates spaces dynamically according to your `terminal_width` to push the folder and model information cleanly to the right side.
+
+## Layout Structure
+
+```
+? for shortcuts • {progress_bar} {used_pct}% of {limit} • in {input}k | out {output}k           {cwd} • {model_name}
+```
+
+---
+
+## How It Works
+
+1. **Input**: The Antigravity CLI pipes a JSON metadata payload containing session details (active model, workspace, context token consumption, terminal size) into the script via standard input (`stdin`).
+2. **Parsing**: The script parses the incoming JSON stream. If `stdin` is empty or times out (safety threshold: `150ms`), it falls back to defaults or reads from the environment variable (`process.env.ANTIGRAVITY_SOURCE_METADATA`).
+3. **Calculations**:
+   - Calculates cumulative token usage (`total_input_tokens + total_output_tokens`) and rounds the values to integer `k` scales.
+   - Selects the statusline alert color (Cyan, Orange, or Red) based on total token limits.
+   - Strips ANSI escape codes from formatting templates to measure the true printable character width.
+   - Subtracts the printed width from the target `terminal_width` to determine the required padding spaces.
+4. **Output**: Writes the aligned statusline directly to standard output (`stdout`) with no trailing newline, enabling the CLI shell wrapper to render it cleanly at the bottom of the prompt.
+
+---
+
+## Installation & Setup
+
+### Installation via NPM
+
+You can install this statusline directly from the npm registry and configure it automatically with a single command:
+
+1. **Install Globally**:
+   ```bash
+   npm install -g agy-statusline
+   ```
+   *(or `bun install -g agy-statusline` if using Bun)*
+
+2. **Run Automatic Configuration**:
+   ```bash
+   agy-statusline-setup
+   ```
+   *(This automatically locates your `settings.json` configuration file and updates your `statusLine` configuration block).*
+
+3. **Verify Installation** (Optional):
+   Run the diagnostics doctor to verify everything is working perfectly:
+   ```bash
+   agy-statusline-setup doctor
+   ```
+
+### Local Setup & Automatic Installation
+
+If you cloned this repository locally, you can set it up using the included `setup.js` script:
+
+Run the setup script using Bun (or Node.js):
+
+```bash
+bun setup.js
+```
+
+This will automatically:
+1. Run `bun link` to register the `agy-statusline` command globally.
+2. Locate your Antigravity CLI `settings.json` configuration file.
+3. Add or update the `statusLine` configuration block automatically (handling the UTF-8 BOM check correctly):
+   ```json
+   "statusLine": {
+     "type": "command",
+     "command": "agy-statusline",
+     "enabled": true
+   }
+   ```
+
+### Manual Local Installation (Alternative)
+
+If you prefer manual setup from the local directory:
+1. **Link Globally**: Run `bun link` in the repository folder.
+2. **Configure Settings**: Open your Antigravity CLI config file located at `~/.gemini/antigravity-cli/settings.json` (or `C:\Users\<username>\.gemini\antigravity-cli\settings.json` on Windows), making sure to write without a UTF-8 BOM, and set:
+   ```json
+   "statusLine": {
+     "type": "command",
+     "command": "agy-statusline",
+     "enabled": true
+   }
+   ```
+
+---
+
+## Local Testing
+
+You can simulate how the statusline renders using the provided mock payload (`agy_statusline_stdin.json`).
+
+### Windows (PowerShell)
+```powershell
+Get-Content .\agy_statusline_stdin.json -Raw | bun .\statusline.js
+```
+
+### macOS/Linux
+```bash
+cat ./agy_statusline_stdin.json | bun ./statusline.js
+```
+
+---
+
+## Diagnostic Doctor Check
+
+You can run the built-in diagnostic tool to verify that the script is linked, the CLI settings are properly configured without a BOM, and the simulation executes correctly:
+
+```bash
+bun setup.js doctor
+```
+
+---
+
+## Testing & Coverage
+
+This project features a comprehensive test suite written using Node's native test runner to maintain zero external runtime dependencies.
+
+### Run Tests
+
+You can run the full integration test suite (which validates rendering layout, token math, threshold coloring, path contraction, and error fallbacks):
+
+```bash
+npm test
+```
+
+*Note: This command runs both the Node.js test runner and the Doctor diagnostics script, which also runs automatically as a Husky pre-commit hook.*
+
+### Test Coverage Report
+
+To run the tests with a code coverage report (requires Node.js v20+):
+
+```bash
+node --test --experimental-test-coverage
+```

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "agy-statusline",
+  "version": "1.1.1",
+  "description": "Optimized custom statusline implementation for the Antigravity CLI",
+  "main": "statusline.js",
+  "logo": "assets/logo.png",
+  "icon": "assets/logo.png",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pkradioman/agy-statusline.git"
+  },
+  "bugs": {
+    "url": "https://github.com/pkradioman/agy-statusline/issues"
+  },
+  "homepage": "https://github.com/pkradioman/agy-statusline#readme",
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "scripts": {
+    "prepare": "husky",
+    "test": "node --test && node setup.js doctor",
+    "release": "commit-and-tag-version"
+  },
+  "bin": {
+    "agy-statusline": "statusline.js",
+    "agy-statusline-setup": "setup.js"
+  },
+  "files": [
+    "statusline.js",
+    "setup.js",
+    "README.md",
+    "LICENSE",
+    "assets/logo.png"
+  ],
+  "keywords": [
+    "antigravity",
+    "statusline",
+    "customizer"
+  ],
+  "author": "radioman",
+  "license": "MIT",
+  "devDependencies": {
+    "@commitlint/cli": "^21.0.2",
+    "@commitlint/config-conventional": "^21.0.2",
+    "commit-and-tag-version": "^12.7.3",
+    "husky": "^9.1.7"
+  }
+}

package/setup.js

@@ -0,0 +1,161 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const { execSync } = require('child_process');
+
+// 0. Handle doctor CLI parameter
+if (process.argv.includes('doctor') || process.argv.includes('--doctor')) {
+    runDoctor();
+    process.exit(0);
+}
+
+console.log('🚀 Setting up Antigravity statusline...');
+
+// 1. Run bun link to register agy-statusline globally (if in local repository dev environment)
+let isLocalDev = fs.existsSync(path.join(__dirname, '.git'));
+if (isLocalDev) {
+    try {
+        console.log('🔗 Running "bun link" to register the binary globally...');
+        execSync('bun link', { stdio: 'inherit' });
+        console.log('✅ Registered "agy-statusline" successfully.');
+    } catch (error) {
+        console.warn('⚠️  Failed to run "bun link". Proceeding with settings configuration anyway...');
+    }
+} else {
+    console.log('📦 Running from global package installation, skipping "bun link".');
+}
+
+// 2. Locate settings.json
+const homeDir = os.homedir();
+const settingsPath = path.join(homeDir, '.gemini', 'antigravity-cli', 'settings.json');
+
+if (!fs.existsSync(settingsPath)) {
+    console.error(`❌ Antigravity settings file not found at: ${settingsPath}`);
+    process.exit(1);
+}
+
+// 3. Read and update settings.json
+try {
+    const rawSettings = fs.readFileSync(settingsPath, 'utf8').trim();
+    // Strip UTF-8 BOM if present
+    const cleanSettings = rawSettings.replace(/^\uFEFF/, '');
+    const settings = JSON.parse(cleanSettings);
+
+    // Initialize statusLine block if it doesn't exist
+    if (!settings.statusLine) {
+        settings.statusLine = {};
+    }
+
+    settings.statusLine.type = 'command';
+    settings.statusLine.command = 'agy-statusline';
+    settings.statusLine.enabled = true;
+
+    // Convert back to string and write to file (default write has no BOM)
+    fs.writeFileSync(settingsPath, JSON.stringify(settings, null, 2), 'utf8');
+    console.log(`✅ Successfully updated settings at: ${settingsPath}`);
+    console.log('🎉 Setup complete! Restart your shell or CLI to see changes.');
+} catch (error) {
+    console.error(`❌ Failed to update settings.json: ${error.message}`);
+    process.exit(1);
+}
+
+function runDoctor() {
+    console.log('🩺 Running Antigravity Statusline Doctor...');
+    let health = true;
+
+    // 1. Check Runtime
+    console.log(`\n1. Checking JavaScript Runtime...`);
+    console.log(`   Running under: ${process.release ? process.release.name : 'Bun'} (${process.version})`);
+
+    // 2. Check settings.json location and contents
+    console.log(`\n2. Checking settings.json...`);
+    const sPath = path.join(os.homedir(), '.gemini', 'antigravity-cli', 'settings.json');
+    if (!fs.existsSync(sPath)) {
+        console.error(`   ❌ settings.json NOT found at: ${sPath}`);
+        health = false;
+    } else {
+        console.log(`   Found settings.json at: ${sPath}`);
+        try {
+            const rawBytes = fs.readFileSync(sPath);
+            // Check for UTF-8 BOM (0xEF, 0xBB, 0xBF)
+            if (rawBytes.length >= 3 && rawBytes[0] === 0xEF && rawBytes[1] === 0xBB && rawBytes[2] === 0xBF) {
+                console.error(`   ❌ WARNING: settings.json contains a UTF-8 BOM (Byte Order Mark). This will cause the CLI to crash or reset!`);
+                health = false;
+            } else {
+                console.log(`   ✅ UTF-8 BOM Check: Passed (No BOM found)`);
+            }
+
+            const settings = JSON.parse(rawBytes.toString('utf8').trim());
+            if (settings.statusLine) {
+                console.log(`   ✅ statusLine block exists`);
+                console.log(`      Enabled: ${settings.statusLine.enabled}`);
+                console.log(`      Type: ${settings.statusLine.type}`);
+                console.log(`      Command: ${settings.statusLine.command}`);
+
+                if (settings.statusLine.command !== 'agy-statusline') {
+                    console.error(`   ❌ WARNING: statusLine.command is set to "${settings.statusLine.command}" instead of "agy-statusline"`);
+                    health = false;
+                }
+            } else {
+                console.error(`   ❌ statusLine configuration is missing in settings.json`);
+                health = false;
+            }
+        } catch (e) {
+            console.error(`   ❌ Failed to parse settings.json: ${e.message}`);
+            health = false;
+        }
+    }
+
+    // 3. Check global executable in PATH
+    console.log(`\n3. Checking PATH for agy-statusline command...`);
+    const pathDirs = (process.env.PATH || '').split(path.delimiter);
+    let binaryFound = false;
+    const isWindows = process.platform === 'win32';
+    const binaryNames = isWindows ? ['agy-statusline.exe', 'agy-statusline.cmd', 'agy-statusline.ps1', 'agy-statusline'] : ['agy-statusline'];
+
+    for (const dir of pathDirs) {
+        for (const binName of binaryNames) {
+            const fullPath = path.join(dir, binName);
+            if (fs.existsSync(fullPath)) {
+                console.log(`   ✅ Found executable shim at: ${fullPath}`);
+                binaryFound = true;
+                break;
+            }
+        }
+        if (binaryFound) break;
+    }
+
+    if (!binaryFound) {
+        console.error(`   ❌ "agy-statusline" was NOT found in your system PATH.`);
+        console.error(`      Make sure your global Bun/NPM binary folder is in your PATH environment variable.`);
+        health = false;
+    }
+
+    // 4. Try running the statusline script with a mock input
+    console.log(`\n4. Simulating Statusline Run...`);
+    const mockPayloadPath = path.join(__dirname, 'agy_statusline_stdin.json');
+    if (!fs.existsSync(mockPayloadPath)) {
+        console.error(`   ❌ Mock input payload NOT found at: ${mockPayloadPath}`);
+        health = false;
+    } else {
+        try {
+            const mockInput = fs.readFileSync(mockPayloadPath, 'utf8');
+            const runtime = process.release ? 'node' : 'bun';
+            const scriptPath = path.join(__dirname, 'statusline.js');
+            const output = execSync(`${runtime} "${scriptPath}"`, { input: mockInput, encoding: 'utf8' });
+            console.log(`   ✅ Test Run Successful! Output:`);
+            console.log(`      ${output}`);
+        } catch (e) {
+            console.error(`   ❌ Test Run Failed: ${e.message}`);
+            health = false;
+        }
+    }
+
+    console.log('\n---');
+    if (health) {
+        console.log('🎉 Statusline Health: EXCELLENT (All checks passed)');
+    } else {
+        console.error('❌ Statusline Health: PROBLEMS DETECTED (See details above)');
+    }
+}

package/statusline.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env bun
+const fs = require('fs');
+const path = require('path');
+
+let timeout;
+
+if (require.main === module) {
+    let inputData = '';
+    process.stdin.setEncoding('utf8');
+
+    process.stdin.on('data', (chunk) => {
+        inputData += chunk;
+    });
+
+    process.stdin.on('end', () => {
+        renderStatusline(inputData, 'end_event');
+    });
+
+    // To prevent hanging if stdin is not closed or redirected, set a safety timeout.
+    timeout = setTimeout(() => {
+        renderStatusline(inputData, 'timeout');
+        process.exit(0);
+    }, 150);
+}
+
+function renderStatusline(jsonStr, triggerSource) {
+    clearTimeout(timeout);
+    
+    // Default values
+    let used_pct = 0;
+    let size = 0;
+    let model_name = 'Antigravity';
+    let current_dir = process.cwd();
+    let terminal_width = 80;
+    let input_tokens = 0;
+    let output_tokens = 0;
+    let errorLog = '';
+
+    // Read from environment fallback if stdin is empty
+    if (process.env.ANTIGRAVITY_SOURCE_METADATA) {
+        try {
+            let envMeta = process.env.ANTIGRAVITY_SOURCE_METADATA.replace(/^\uFEFF/, '');
+            const meta = JSON.parse(envMeta);
+            if (meta.model && (meta.model.display_name || meta.model.id)) {
+                model_name = meta.model.display_name || meta.model.id;
+            }
+            if (meta.workspace && meta.workspace.current_dir) {
+                current_dir = meta.workspace.current_dir;
+            }
+        } catch (e) {
+            errorLog += `[Env Parse Err: ${e.message}] `;
+        }
+    }
+
+    if (jsonStr) {
+        try {
+            jsonStr = jsonStr.replace(/^\uFEFF/, '').trim();
+            if (jsonStr) {
+                const data = JSON.parse(jsonStr);
+                
+                if (data.model) {
+                    model_name = data.model.display_name || data.model.id || model_name;
+                }
+                if (data.workspace && data.workspace.current_dir) {
+                    current_dir = data.workspace.current_dir;
+                } else if (data.cwd) {
+                    current_dir = data.cwd;
+                }
+                if (data.terminal_width !== undefined) {
+                    terminal_width = Number(data.terminal_width) || 80;
+                }
+                
+                if (data.context_window) {
+                    let cw = data.context_window;
+                    used_pct = cw.used_percentage !== undefined ? Math.round(cw.used_percentage) : 0;
+                    size = cw.context_window_size !== undefined ? cw.context_window_size : 0;
+                    input_tokens = cw.total_input_tokens !== undefined ? cw.total_input_tokens : 0;
+                    output_tokens = cw.total_output_tokens !== undefined ? cw.total_output_tokens : 0;
+                }
+                
+                // Save to file for debugging
+                const userProfile = process.env.USERPROFILE || process.env.HOME || '';
+                const targetDir = path.join(userProfile, 'temp');
+                if (fs.existsSync(targetDir)) {
+                    fs.writeFileSync(path.join(targetDir, 'agy_statusline_stdin.txt'), jsonStr, 'utf8');
+                }
+            }
+        } catch (e) {
+            errorLog += `[Stdin Parse Err: ${e.message}. Content: ${JSON.stringify(jsonStr)}] `;
+        }
+    }
+    
+    // Format size
+    let formatted_size = String(size);
+    if (size >= 1048576) {
+        formatted_size = `${Math.floor(size / 1048576)}M`;
+    } else if (size >= 1024) {
+        formatted_size = `${Math.floor(size / 1024)}k`;
+    }
+
+    // ANSI color codes
+    const RESET = '\x1b[0m';
+    const BOLD = '\x1b[1m';
+    const GREY = '\x1b[90m';
+    const CYAN = '\x1b[36m';
+    const BLUE = '\x1b[34m';
+    const GREEN = '\x1b[32m';
+    const RED = '\x1b[31m';
+    const ORANGE = '\x1b[38;5;208m';
+
+    // Determine color of context info
+    let CONTEXT_COLOR = CYAN;
+    if (input_tokens >= 200000) {
+        CONTEXT_COLOR = RED;
+    } else if (input_tokens >= 160000) {
+        CONTEXT_COLOR = ORANGE;
+    }
+
+    const formatK = (n) => {
+        return `${Math.round(n / 1000)}k`;
+    };
+
+    let filled = Math.min(20, Math.max(0, Math.ceil(used_pct / 5)));
+    let empty = 20 - filled;
+    let bar = `[${'■'.repeat(filled)}${'□'.repeat(empty)}]`;
+
+    // Strip ANSI codes to calculate actual printed length
+    const stripAnsi = (str) => str.replace(/\x1b\[[0-9;]*m/g, '');
+
+    // Form left part and calculate its clean length
+    let left_str = `${GREY}? for shortcuts${RESET}${GREY} • ${RESET}${CONTEXT_COLOR}${bar} ${used_pct}% of ${formatted_size}${RESET}${GREY} • ${RESET}${CONTEXT_COLOR}in ${formatK(input_tokens)}${RESET}${GREY} | ${RESET}${CONTEXT_COLOR}out ${formatK(output_tokens)}${RESET}`;
+    let plain_left_len = stripAnsi(left_str).length;
+
+    // Calculate clean length of the right part excluding the directory (bullet + model name)
+    let right_sans_dir = `${GREY} • ${RESET}${BOLD}${model_name}${RESET}`;
+    let plain_right_sans_dir_len = stripAnsi(right_sans_dir).length;
+
+    // Remaining width for the directory path (with a safety buffer of 2)
+    let max_dir_len = terminal_width - plain_left_len - plain_right_sans_dir_len - 2;
+
+    // Contract directory path dynamically to fit remaining space
+    let contracted_dir = contractPath(current_dir, max_dir_len);
+
+    // Form final right part using the contracted directory
+    let right_str = `${GREEN}${contracted_dir}${RESET}${right_sans_dir}`;
+    let plain_right_len = stripAnsi(right_str).length;
+
+    // Calculate padding size using clean lengths
+    let padding_size = terminal_width - plain_left_len - plain_right_len;
+    
+    let status = '';
+    if (padding_size > 0) {
+        let padding = ' '.repeat(padding_size);
+        status = `${left_str}${padding}${right_str}`;
+    } else {
+        status = `${left_str}${GREY} • ${RESET}${right_str}`;
+    }
+
+    process.stdout.write(status);
+
+    // Write debug log
+    const userProfile = process.env.USERPROFILE || process.env.HOME || '';
+    const logFile = path.join(userProfile, 'temp', 'statusline_debug.log');
+    const logEntry = `${new Date().toISOString()} - Executed via ${triggerSource}. Model: ${model_name}. Cwd: ${current_dir}. Errs: ${errorLog}\n`;
+    try {
+        fs.appendFileSync(logFile, logEntry, 'utf8');
+    } catch(e) {}
+}
+
+function contractPath(p, maxLen) {
+    if (p.length <= maxLen) return p;
+    
+    // 1. Try substituting home directory with ~
+    const home = process.env.USERPROFILE || process.env.HOME || '';
+    if (home && p.startsWith(home)) {
+        p = p.replace(home, '~');
+    }
+    if (p.length <= maxLen) return p;
+
+    // 2. If still too long, truncate it in the middle or keep the last N characters with ...
+    if (maxLen <= 10) return p; // Don't truncate if allowed length is too small to be readable
+    
+    // Split by path separator
+    const sep = p.includes('\\') ? '\\' : '/';
+    const segments = p.split(sep);
+    
+    if (segments.length <= 2) {
+        return '...' + p.slice(-(maxLen - 3));
+    }
+    
+    let first = segments[0];
+    let last = segments[segments.length - 1];
+    
+    // Keep adding segments from the end as long as we stay under maxLen
+    let middle = '...';
+    let result = first + sep + middle + sep + last;
+    
+    for (let i = segments.length - 2; i > 0; i--) {
+        let candidate = first + sep + middle + sep + segments[i] + sep + last;
+        if (candidate.length <= maxLen) {
+            last = segments[i] + sep + last;
+        } else {
+            break;
+        }
+    }
+    
+    result = first + sep + middle + sep + last;
+    if (result.length > maxLen) {
+        return '...' + p.slice(-(maxLen - 3));
+    }
+    return result;
+}
+
+if (typeof module !== 'undefined' && module.exports) {
+    module.exports = {
+        renderStatusline,
+    };
+}