agy-statusblocks 0.0.0-stage → 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Okan Turan
+
+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

@@ -1,3 +1,79 @@
-# Temporary Holding Version
+# agy-statusblocks
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+[![npm version](https://img.shields.io/npm/v/agy-statusblocks)](https://www.npmjs.com/package/agy-statusblocks)
+[![license](https://img.shields.io/npm/l/agy-statusblocks)](package.json)
+
+Adaptive, block-based status line for [Antigravity CLI](https://antigravity.google) (`agy`). Cards reflow into a pyramid layout based on available terminal width using an exhaustive bin-packing algorithm.
+
+**Zero runtime dependencies.** Pure Node.js built-ins only.
+
+## Install
+
+Requires Node.js ≥ 20. Works on macOS, Linux, and Windows.
+
+```sh
+npx agy-statusblocks init
+```
+
+This copies the renderer to `~/.gemini/antigravity-cli/statusblocks/` and writes `statusLine.command` into `~/.gemini/antigravity-cli/settings.json` (creating it if needed). Restart Antigravity CLI (`agy`) to activate.
+
+### Update
+
+```sh
+npx agy-statusblocks@latest update
+```
+
+Updates happen automatically — the statusline checks for new versions daily in the background. The `postinstall` hook also auto-updates when you run `npm update -g agy-statusblocks`. Set `AGY_STATUSBLOCKS_NO_UPDATE=1` to disable the background check.
+
+## Cards
+
+| Card | Shows |
+|------|-------|
+| **context** | Context window fill bar, percentage, used/total token count (supports 1M/2M context) |
+| **model** | Active model name, tilde-shortened directory, reasoning effort level, plan tier, estimated cost |
+| **usage** | Rate limit utilization (5-hour, daily, and 7-day windows) with reset countdowns |
+| **state** | Agent state pill (`● IDLE`, `● RUNNING`, `● TOOL USE`, `● REVIEW`) and live task/subagent/artifact counters |
+| **git** | Branch, staged/modified file counts, lines added/removed |
+
+## Layout
+
+Cards are bin-packed into rows for optimal fit — blocks can be freely reordered across rows. Rows are sorted narrowest-on-top (pyramid shape). The algorithm tries every possible row assignment and picks the layout with fewest rows and most balanced widths.
+
+On narrow/split-pane terminals, the layout degrades gracefully to stacked single-block rows.
+
+## Configure
+
+`~/.agy-statusblocks.json`:
+
+```json
+{
+  "segments": ["context", "model", "usage", "state", "git"]
+}
+```
+
+Or via environment:
+
+```sh
+AGY_STATUSBLOCKS_SEGMENTS=context,model,usage
+```
+
+## Preview
+
+```sh
+npx agy-statusblocks preview
+```
+
+Check the installed package version with `agy-statusblocks --version` (or `-v`).
+
+## Development
+
+```sh
+npm run build       # compile TypeScript
+npm run dev         # watch mode
+npm test            # run vitest suite
+npm run preview     # render with mock data
+```
+
+## License
+
+[MIT](./LICENSE)

package/dist/cache.d.ts

@@ -0,0 +1,9 @@
+export declare function hashKey(str: string): string;
+export declare function safeKey(str: string): string;
+export declare function readCacheEntry(name: string): {
+    ts: number;
+    value: unknown;
+} | undefined;
+export declare function readCache<T>(name: string, ttlMs: number): T | undefined;
+export declare function writeCache(name: string, value: unknown): void;
+export declare function acquireMarker(name: string, ttlMs: number): boolean;

package/dist/cache.js

@@ -0,0 +1,65 @@
+import { mkdirSync, readFileSync, writeFileSync, renameSync, statSync, unlinkSync } from 'fs';
+import { join } from 'path';
+import { tmpdir } from 'os';
+import { createHash } from 'crypto';
+function cacheDir(create) {
+    const override = process.env['AGY_STATUSBLOCKS_CACHE_DIR'] || process.env['CLAUDE_STATUSBLOCKS_CACHE_DIR'];
+    const uid = typeof process.getuid === 'function' ? `-${process.getuid()}` : '';
+    const dir = override || join(tmpdir(), `claude-statusblocks${uid}`);
+    if (create)
+        mkdirSync(dir, { recursive: true });
+    return dir;
+}
+export function hashKey(str) {
+    return createHash('sha256').update(str).digest('hex').slice(0, 12);
+}
+export function safeKey(str) {
+    return str.replace(/[^a-zA-Z0-9_-]/g, '_').slice(0, 64);
+}
+export function readCacheEntry(name) {
+    try {
+        const raw = JSON.parse(readFileSync(join(cacheDir(false), name), 'utf8'));
+        if (typeof raw?.ts !== 'number')
+            return undefined;
+        return { ts: raw.ts, value: raw.value };
+    }
+    catch {
+        return undefined;
+    }
+}
+export function readCache(name, ttlMs) {
+    const entry = readCacheEntry(name);
+    if (entry === undefined || Date.now() - entry.ts > ttlMs)
+        return undefined;
+    return entry.value;
+}
+export function writeCache(name, value) {
+    try {
+        const dir = cacheDir(true);
+        const tmp = join(dir, `${name}.tmp-${process.pid}`);
+        writeFileSync(tmp, JSON.stringify({ ts: Date.now(), value }));
+        renameSync(tmp, join(dir, name));
+    }
+    catch {
+        // Best-effort
+    }
+}
+export function acquireMarker(name, ttlMs) {
+    try {
+        const path = join(cacheDir(true), name);
+        try {
+            writeFileSync(path, String(Date.now()), { flag: 'wx' });
+            return true;
+        }
+        catch {
+            if (Date.now() - statSync(path).mtimeMs <= ttlMs)
+                return false;
+            unlinkSync(path);
+            writeFileSync(path, String(Date.now()), { flag: 'wx' });
+            return true;
+        }
+    }
+    catch {
+        return false;
+    }
+}

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,251 @@
+#!/usr/bin/env node
+import { readFileSync, writeFileSync, mkdirSync, cpSync, readdirSync, rmSync, existsSync } from 'fs';
+import { join, dirname, basename, sep } from 'path';
+import { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { render } from './layout.js';
+import { loadConfig } from './config.js';
+import { color, c } from './colors.js';
+import { isValidVersion, isNewerVersion } from './version.js';
+const PACKAGE_VERSION = (() => {
+    const manifest = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf8'));
+    if (typeof manifest.version !== 'string' || !isValidVersion(manifest.version)) {
+        throw new Error('package.json contains an invalid version');
+    }
+    return manifest.version;
+})();
+function settingsPath() {
+    return join(homedir(), '.gemini', 'antigravity-cli', 'settings.json');
+}
+function installDir() {
+    return join(homedir(), '.gemini', 'antigravity-cli', 'statusblocks');
+}
+function statusLineCommand(dest) {
+    return `node "${join(dest, 'index.js').split(sep).join('/')}"`;
+}
+function isOurCommand(cmd) {
+    return cmd.includes('agy-statusblocks') || /[\\/]statusblocks[\\/]index\.js/.test(cmd);
+}
+function readSettings() {
+    try {
+        return JSON.parse(readFileSync(settingsPath(), 'utf8'));
+    }
+    catch (err) {
+        if (err.code === 'ENOENT')
+            return {};
+        throw new Error(`could not parse ${settingsPath()}: ${err instanceof Error ? err.message : err}`);
+    }
+}
+function writeSettings(s) {
+    const file = settingsPath();
+    mkdirSync(dirname(file), { recursive: true });
+    writeFileSync(file, JSON.stringify(s, null, 2) + '\n');
+}
+const VERSION_STAMP = '.version';
+const KEEP_FILES = new Set(['.last-update-check', VERSION_STAMP]);
+function isInstallable(path) {
+    return !/\.test\./.test(basename(path));
+}
+function installedVersion(dest) {
+    try {
+        return readFileSync(join(dest, VERSION_STAMP), 'utf8').trim();
+    }
+    catch {
+        return '';
+    }
+}
+function installFiles() {
+    const dest = installDir();
+    const distDir = dirname(fileURLToPath(import.meta.url));
+    mkdirSync(dest, { recursive: true });
+    cpSync(distDir, dest, { recursive: true, force: true, filter: isInstallable });
+    for (const rel of readdirSync(dest, { recursive: true })) {
+        if (KEEP_FILES.has(rel))
+            continue;
+        if (existsSync(join(distDir, rel)) && isInstallable(rel))
+            continue;
+        rmSync(join(dest, rel), { recursive: true, force: true });
+    }
+    writeFileSync(join(dest, VERSION_STAMP), PACKAGE_VERSION);
+    return dest;
+}
+function runInit() {
+    console.log(`\n${color('agy-statusblocks', c.gemini, c.bold)} setup\n`);
+    try {
+        const dest = installFiles();
+        const command = statusLineCommand(dest);
+        const settings = readSettings();
+        const oldCommand = settings.statusLine?.command;
+        settings.statusLine = {
+            ...(settings.statusLine ?? {}),
+            type: 'command',
+            command,
+            enabled: true,
+        };
+        writeSettings(settings);
+        if (oldCommand && oldCommand !== command)
+            console.log(`  Replaced:  ${color(oldCommand, c.dim)}`);
+        console.log(`  Installed: ${color(command, c.green)}`);
+        console.log(`  Files:     ${color(dest, c.dim)}`);
+        console.log(`  Settings:  ${color('~/.gemini/antigravity-cli/settings.json', c.dim)}`);
+        console.log(`\n  Run ${color('npx agy-statusblocks update', c.cyan)} to update later.\n`);
+    }
+    catch (err) {
+        console.error(`  Error: Could not update ${settingsPath()}`);
+        console.error(`  ${err instanceof Error ? err.message : err}\n`);
+        process.exit(1);
+    }
+}
+function runUpdate(force) {
+    console.log(`\n${color('agy-statusblocks', c.gemini, c.bold)} update\n`);
+    try {
+        const installed = installedVersion(installDir());
+        if (!force && isNewerVersion(installed, PACKAGE_VERSION)) {
+            console.log(`  Kept:     installed ${color(installed, c.green)} is newer than this package (${PACKAGE_VERSION})`);
+            console.log(`  ${color('Run with --force to downgrade.', c.dim)}\n`);
+            return;
+        }
+        const dest = installFiles();
+        console.log(`  Updated:  ${color(dest, c.green)}`);
+        try {
+            const settings = readSettings();
+            const cmd = String(settings.statusLine?.command ?? '');
+            const command = statusLineCommand(dest);
+            if (cmd && isOurCommand(cmd) && cmd !== command) {
+                settings.statusLine = { type: 'command', ...settings.statusLine, command };
+                console.log(`  Migrated: ${color(command, c.cyan)}`);
+                writeSettings(settings);
+            }
+        }
+        catch { /* settings update is best-effort */ }
+        console.log();
+    }
+    catch (err) {
+        console.error(`  Error: ${err instanceof Error ? err.message : err}\n`);
+        process.exit(1);
+    }
+}
+function runUninstall() {
+    const settings = readSettings();
+    if (settings.statusLine) {
+        settings.statusLine.command = '';
+        settings.statusLine.type = '';
+        writeSettings(settings);
+    }
+    console.log(color('✓ agy-statusblocks uninstalled and reverted to built-in status line', c.green));
+}
+function runPreview() {
+    process.env['AGY_STATUSBLOCKS_NO_REMOTE'] = '1';
+    const config = loadConfig();
+    const now = Date.now() / 1000;
+    const mockData = {
+        product: 'antigravity',
+        conversation_id: 'preview-session-1234',
+        agent_state: 'idle',
+        model: {
+            id: 'gemini-3.8-flash',
+            display_name: 'Gemini 3.8 Flash (Medium)',
+        },
+        context_window: {
+            context_window_size: 1048576,
+            used_percentage: 12.4,
+            total_input_tokens: 124000,
+            total_output_tokens: 6000,
+        },
+        quota: {
+            'Gemini 3.8 Flash': {
+                remaining_fraction: 0.82,
+                reset_in_seconds: Math.floor(3600 * 2.5),
+            },
+            'Claude Sonnet 5.5': {
+                remaining_fraction: 0.64,
+                reset_in_seconds: Math.floor(3600 * 4.2),
+            },
+            'Claude Opus 5.5': {
+                remaining_fraction: 0.90,
+                reset_in_seconds: Math.floor(3600 * 4.2),
+            },
+        },
+        current_dir: join(homedir(), 'code', 'my-project'),
+        workspace: {
+            current_dir: join(homedir(), 'code', 'my-project'),
+        },
+        vcs: {
+            type: 'git',
+            branch: 'main',
+            dirty: false,
+        },
+        plan_tier: 'Consumer',
+        task_count: 0,
+        subagents: [],
+        artifact_count: 1,
+        cost: {
+            estimated: 0.005,
+        },
+        effort: {
+            level: 'medium',
+        },
+    };
+    console.log(`\n${color('agy-statusblocks', c.bold, c.gemini)} preview\n`);
+    for (const width of [120, 80, 50]) {
+        console.log(color('─'.repeat(width), c.gray));
+        console.log(`${width} cols:`);
+        console.log(render(mockData, width, config));
+        console.log();
+    }
+}
+function showHelp() {
+    console.log(`
+${color('agy-statusblocks', c.bold, c.gemini)} — block-based status line for Antigravity CLI (agy)
+
+${color('Usage:', c.bold)}
+  agy-statusblocks init       Install into Antigravity CLI settings
+  agy-statusblocks update     Update installed files (--force to downgrade)
+  agy-statusblocks preview    Preview with mock data at various widths
+  agy-statusblocks uninstall  Revert to built-in statusline
+  agy-statusblocks --version  Print the installed package version
+  agy-statusblocks help       Show this help
+
+${color('Blocks:', c.bold)}
+  context    Context window fill bar, percentage, token counts
+  model      Model name, directory, reasoning effort, tier, cost
+  usage      5-hour, daily, and 7-day rate limit utilization
+  state      Agent state pill and task/subagent/artifact counters
+  git        Branch, staged/modified counts, lines added/removed
+
+${color('Customize:', c.bold)}
+  ~/.agy-statusblocks.json:   { "segments": ["context", "model", "usage", "state", "git"] }
+  Env vars:                   AGY_STATUSBLOCKS_SEGMENTS=context,model,usage
+`);
+}
+const cmd = process.argv[2];
+switch (cmd) {
+    case 'init':
+        runInit();
+        break;
+    case 'update':
+        runUpdate(process.argv.includes('--force'));
+        break;
+    case 'preview':
+        runPreview();
+        break;
+    case 'uninstall':
+        runUninstall();
+        break;
+    case '--version':
+    case '-v':
+        console.log(PACKAGE_VERSION);
+        break;
+    case 'help':
+    case '--help':
+    case '-h':
+        showHelp();
+        break;
+    default:
+        if (process.stdin.isTTY) {
+            showHelp();
+        }
+        else {
+            import('./index.js');
+        }
+}

package/dist/colors.d.ts

@@ -0,0 +1,24 @@
+export declare const c: {
+    reset: string;
+    bold: string;
+    dim: string;
+    italic: string;
+    red: string;
+    green: string;
+    yellow: string;
+    blue: string;
+    magenta: string;
+    cyan: string;
+    white: string;
+    gray: string;
+    gemini: string;
+    geminiCyan: string;
+    orange: string;
+    purple: string;
+};
+export declare function color(text: string, ...codes: string[]): string;
+export declare function pctColor(pct: number): string;
+export declare function stripAnsi(str: string): string;
+export declare function visibleLength(str: string): number;
+export declare function padRight(str: string, targetLen: number): string;
+export declare function renderBar(pct: number, width: number): string;

package/dist/colors.js

@@ -0,0 +1,42 @@
+const ESC = '\x1b[';
+export const c = {
+    reset: `${ESC}0m`,
+    bold: `${ESC}1m`,
+    dim: `${ESC}2m`,
+    italic: `${ESC}3m`,
+    red: `${ESC}31m`,
+    green: `${ESC}32m`,
+    yellow: `${ESC}33m`,
+    blue: `${ESC}34m`,
+    magenta: `${ESC}35m`,
+    cyan: `${ESC}36m`,
+    white: `${ESC}37m`,
+    gray: `${ESC}90m`,
+    gemini: `${ESC}38;2;66;133;244m`, // Google blue #4285F4
+    geminiCyan: `${ESC}38;2;77;208;225m`, // Cyan #4DD0E1
+    orange: `${ESC}38;2;217;119;87m`,
+    purple: `${ESC}38;2;168;85;247m`,
+};
+export function color(text, ...codes) {
+    return codes.join('') + text + c.reset;
+}
+export function pctColor(pct) {
+    return pct >= 90 ? c.red : pct >= 70 ? c.yellow : c.green;
+}
+export function stripAnsi(str) {
+    // eslint-disable-next-line no-control-regex
+    return str.replace(/\x1b\[[0-9;]*m/g, '');
+}
+export function visibleLength(str) {
+    return stripAnsi(str).length;
+}
+export function padRight(str, targetLen) {
+    const vLen = visibleLength(str);
+    if (vLen >= targetLen)
+        return str;
+    return str + ' '.repeat(targetLen - vLen);
+}
+export function renderBar(pct, width) {
+    const filled = Math.min(width, Math.max(0, Math.round(pct * width / 100)));
+    return color('█'.repeat(filled), pctColor(pct)) + color('▒'.repeat(width - filled), c.gray);
+}

package/dist/config.d.ts

@@ -0,0 +1,2 @@
+import type { StatusBlocksConfig } from './types.js';
+export declare function loadConfig(): StatusBlocksConfig;

package/dist/config.js

@@ -0,0 +1,23 @@
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+export function loadConfig() {
+    const envSegments = process.env['AGY_STATUSBLOCKS_SEGMENTS'];
+    const config = {};
+    try {
+        const raw = readFileSync(join(homedir(), '.agy-statusblocks.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === 'object' && !Array.isArray(parsed)) {
+            if (Array.isArray(parsed.segments))
+                config.segments = parsed.segments.filter((s) => typeof s === 'string');
+            if (typeof parsed.remoteUsage === 'boolean')
+                config.remoteUsage = parsed.remoteUsage;
+            if (typeof parsed.stackWithDefault === 'boolean')
+                config.stackWithDefault = parsed.stackWithDefault;
+        }
+    }
+    catch { /* no config file — use defaults */ }
+    if (envSegments)
+        config.segments = envSegments.split(',');
+    return config;
+}

package/dist/credentials.d.ts

@@ -0,0 +1 @@
+export declare function getOAuthToken(): string | null;

package/dist/credentials.js

@@ -0,0 +1,44 @@
+import { execSync } from 'child_process';
+import { readFileSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+function parseToken(raw) {
+    try {
+        const creds = JSON.parse(raw);
+        const oauth = creds?.claudeAiOauth;
+        if (!oauth || typeof oauth.accessToken !== 'string' || !oauth.accessToken)
+            return null;
+        if (typeof oauth.expiresAt === 'number' && oauth.expiresAt < Date.now())
+            return null;
+        return oauth.accessToken;
+    }
+    catch {
+        return null;
+    }
+}
+export function getOAuthToken() {
+    try {
+        const configDir = process.env['CLAUDE_CONFIG_DIR'] || join(homedir(), '.claude');
+        const raw = readFileSync(join(configDir, '.credentials.json'), 'utf8');
+        const token = parseToken(raw);
+        if (token)
+            return token;
+    }
+    catch {
+        // No credentials file
+    }
+    if (process.platform === 'darwin') {
+        try {
+            const raw = execSync('security find-generic-password -s "Claude Code-credentials" -w', {
+                encoding: 'utf8',
+                stdio: ['pipe', 'pipe', 'ignore'],
+                timeout: 5000,
+            });
+            return parseToken(raw.trim());
+        }
+        catch {
+            // Keychain read failed or locked
+        }
+    }
+    return null;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};