agy-statusblocks 0.0.0-stage → 0.1.0

package/dist/segments/state.d.ts

@@ -0,0 +1,2 @@
+import type { Segment } from '../types.js';
+export declare const stateSegment: Segment;

package/dist/segments/state.js

@@ -0,0 +1,35 @@
+import { color, c, visibleLength } from '../colors.js';
+const STATE_CONFIG = {
+    idle: { label: '● IDLE', color: c.green },
+    working: { label: '● RUNNING', color: c.geminiCyan },
+    tool_use: { label: '● TOOL USE', color: c.yellow },
+    reviewing: { label: '● REVIEW', color: c.purple },
+    error: { label: '● ERROR', color: c.red },
+};
+export const stateSegment = {
+    id: 'state',
+    priority: 35,
+    enabled: (data) => Boolean(data.agent_state || data.task_count || data.artifact_count || data.subagents?.length),
+    render(data) {
+        const rawState = (data.agent_state || 'idle').toLowerCase();
+        const stateCfg = STATE_CONFIG[rawState] || { label: `● ${rawState.toUpperCase()}`, color: c.dim };
+        const line1 = color(stateCfg.label, stateCfg.color, c.bold);
+        // Line 2: orchestration telemetry
+        const counters = [];
+        if (data.task_count != null && data.task_count > 0) {
+            counters.push(`${data.task_count} task${data.task_count === 1 ? '' : 's'}`);
+        }
+        if (data.subagents && data.subagents.length > 0) {
+            counters.push(`${data.subagents.length} subagent${data.subagents.length === 1 ? '' : 's'}`);
+        }
+        if (data.artifact_count != null && data.artifact_count > 0) {
+            counters.push(`${data.artifact_count} artifact${data.artifact_count === 1 ? '' : 's'}`);
+        }
+        const line2 = counters.length > 0
+            ? color(counters.join(' · '), c.dim)
+            : color('orchestration idle', c.dim);
+        const lines = [line1, line2];
+        const width = Math.max(...lines.map(visibleLength));
+        return { id: 'state', priority: 35, width, lines };
+    },
+};

package/dist/segments/usage.d.ts

@@ -0,0 +1,2 @@
+import type { Segment } from '../types.js';
+export declare const usageSegment: Segment;

package/dist/segments/usage.js

@@ -0,0 +1,193 @@
+import { color, c, visibleLength, padRight, pctColor, renderBar } from '../colors.js';
+import { readRemoteLimits } from '../remote-usage.js';
+const MS_PER_DAY = 86400000;
+const MS_PER_HOUR = 3600000;
+const MS_PER_MIN = 60000;
+function formatResetTime(epochSec) {
+    if (!epochSec)
+        return '';
+    const ms = epochSec * 1000 - Date.now();
+    if (ms <= 0)
+        return 'now';
+    const d = Math.floor(ms / MS_PER_DAY);
+    const h = Math.floor((ms % MS_PER_DAY) / MS_PER_HOUR);
+    const m = Math.floor((ms % MS_PER_HOUR) / MS_PER_MIN);
+    if (d > 0)
+        return `${d}d${h > 0 ? `${h}h` : ''}${m > 0 ? `${m}m` : ''}`;
+    if (h > 0)
+        return `${h}h${m > 0 ? `${m}m` : ''}`;
+    return `${m}m`;
+}
+function clampPercent(v) {
+    return Math.min(999, Math.max(0, Math.round(v ?? 0)));
+}
+function parseResetTime(v) {
+    if (typeof v === 'number' && Number.isFinite(v)) {
+        return v > 1e11 ? Math.floor(v / 1000) : v;
+    }
+    if (typeof v === 'string') {
+        const ms = Date.parse(v);
+        if (Number.isFinite(ms))
+            return Math.floor(ms / 1000);
+    }
+    return 0;
+}
+function inferWindowSuffix(resetSec) {
+    if (!resetSec || resetSec <= 0)
+        return '';
+    if (resetSec > 18 * 3600)
+        return '7d';
+    return '5h';
+}
+function shortenBucketLabel(rawKey, resetSec = 0) {
+    const k = rawKey.trim();
+    const lower = k.toLowerCase();
+    const explicitWin = lower.includes('weekly') || lower.includes('7d') || lower.includes('7-day')
+        ? '7d'
+        : lower.includes('5h') || lower.includes('5-hour')
+            ? '5h'
+            : inferWindowSuffix(resetSec);
+    if (lower.includes('claude') && (lower.includes('gpt') || lower.includes('pool') || (!lower.includes('sonnet') && !lower.includes('opus') && !lower.includes('haiku')))) {
+        return explicitWin ? `claude ${explicitWin}` : 'claude';
+    }
+    if (lower.includes('sonnet')) {
+        const ver = k.match(/\d+(?:\.\d+)?/)?.[0] ?? '';
+        return ver ? `sonnet ${ver}` : 'sonnet';
+    }
+    if (lower.includes('opus')) {
+        const ver = k.match(/\d+(?:\.\d+)?/)?.[0] ?? '';
+        return ver ? `opus ${ver}` : 'opus';
+    }
+    if (lower.includes('haiku')) {
+        const ver = k.match(/\d+(?:\.\d+)?/)?.[0] ?? '';
+        return ver ? `haiku ${ver}` : 'haiku';
+    }
+    if (lower.includes('flash'))
+        return explicitWin === '7d' ? 'flash 7d' : 'flash';
+    if (lower.includes('argon'))
+        return 'argon';
+    if (lower.includes('pro'))
+        return explicitWin === '7d' ? 'pro 7d' : 'pro';
+    if (lower.includes('gemini'))
+        return explicitWin ? `gemini ${explicitWin}` : 'gemini';
+    const cleaned = k.replace(/\s*\(.*?\)\s*/g, '').replace(/^gemini\s+/i, '').replace(/^claude\s+/i, '').trim();
+    return cleaned.length > 12 ? cleaned.slice(0, 12) : (cleaned || k);
+}
+function bucketPool(key) {
+    const k = key.toLowerCase();
+    if (k.includes('claude') || k.includes('sonnet') || k.includes('opus') || k.includes('haiku') || k.includes('gpt'))
+        return 'claude';
+    if (k.includes('argon'))
+        return 'argon';
+    if (k.includes('gemini') || k.includes('flash') || k.includes('pro'))
+        return 'gemini';
+    return 'other';
+}
+function isActiveModelBucket(key, data) {
+    const k = key.toLowerCase();
+    const mName = (data.model?.display_name ?? '').toLowerCase();
+    const mId = (data.model?.id ?? '').toLowerCase();
+    if (k && (mName.includes(k) || mId.includes(k)))
+        return true;
+    for (const token of ['sonnet', 'opus', 'haiku', 'flash', 'argon', 'pro']) {
+        if (k.includes(token) && (mName.includes(token) || mId.includes(token)))
+            return true;
+    }
+    // If active model is Sonnet/Opus and bucket is a shared Claude/GPT pool
+    if ((mName.includes('claude') || mName.includes('sonnet') || mName.includes('opus')) && bucketPool(key) === 'claude') {
+        return true;
+    }
+    return false;
+}
+function extractLimits(data) {
+    const out = [];
+    // 1. Quota map if provided natively by Antigravity (includes Gemini + Argon + Claude/GPT pools)
+    if (data.quota && typeof data.quota === 'object') {
+        const entries = Object.entries(data.quota)
+            .filter(([, bucket]) => bucket && typeof bucket === 'object' && !bucket.disabled);
+        // Sort active model's bucket first, then prefer showing distinct pools (Gemini/Argon + Claude), then by highest utilization
+        entries.sort(([keyA, a], [keyB, b]) => {
+            const actA = isActiveModelBucket(keyA, data) ? 1 : 0;
+            const actB = isActiveModelBucket(keyB, data) ? 1 : 0;
+            if (actA !== actB)
+                return actB - actA;
+            const pctA = typeof a.remaining_fraction === 'number' ? (1 - a.remaining_fraction) * 100 : (a.used_percentage ?? 0);
+            const pctB = typeof b.remaining_fraction === 'number' ? (1 - b.remaining_fraction) * 100 : (b.used_percentage ?? 0);
+            return pctB - pctA;
+        });
+        const seenLabels = new Set();
+        for (const [key, bucket] of entries) {
+            const rawPct = typeof bucket.remaining_fraction === 'number'
+                ? (1 - bucket.remaining_fraction) * 100
+                : bucket.used_percentage;
+            const pct = clampPercent(rawPct);
+            const nowSec = Math.floor(Date.now() / 1000);
+            const resetsAt = typeof bucket.reset_in_seconds === 'number' && bucket.reset_in_seconds > 0
+                ? nowSec + bucket.reset_in_seconds
+                : parseResetTime(bucket.reset_time ?? bucket.resets_at);
+            const resetSec = resetsAt > nowSec ? resetsAt - nowSec : (bucket.reset_in_seconds ?? 0);
+            const label = shortenBucketLabel(key, resetSec);
+            if (seenLabels.has(label))
+                continue;
+            seenLabels.add(label);
+            out.push({ label, percent: pct, resetsAt });
+        }
+    }
+    // 2. Rate limits if provided
+    const rl = data.rate_limits;
+    if (rl) {
+        if (rl.five_hour) {
+            out.push({
+                label: '5h',
+                percent: clampPercent(rl.five_hour.used_percentage),
+                resetsAt: parseResetTime(rl.five_hour.resets_at),
+            });
+        }
+        if (rl.seven_day) {
+            out.push({
+                label: '7d',
+                percent: clampPercent(rl.seven_day.used_percentage),
+                resetsAt: parseResetTime(rl.seven_day.resets_at),
+            });
+        }
+        if (rl.daily) {
+            out.push({
+                label: 'daily',
+                percent: clampPercent(rl.daily.used_percentage),
+                resetsAt: parseResetTime(rl.daily.resets_at),
+            });
+        }
+    }
+    // 3. Fallback to cached remote usage
+    if (out.length === 0) {
+        const remote = readRemoteLimits();
+        if (remote && remote.length > 0) {
+            const now = Date.now() / 1000;
+            return remote.map(l => (l.resetsAt > 0 && l.resetsAt <= now ? { ...l, percent: 0 } : l));
+        }
+    }
+    return out;
+}
+export const usageSegment = {
+    id: 'usage',
+    priority: 25,
+    enabled: (data) => extractLimits(data).length > 0,
+    render(data) {
+        const limits = extractLimits(data);
+        if (limits.length === 0) {
+            return { id: 'usage', priority: 25, width: 0, lines: [''] };
+        }
+        const BAR_WIDTH = 8;
+        const rows = limits.slice(0, 2).map(l => {
+            const bar = renderBar(l.percent, BAR_WIDTH);
+            const pctStr = color(`${l.percent}%`, pctColor(l.percent), c.bold);
+            const reset = l.resetsAt ? color(`↻ ${formatResetTime(l.resetsAt)}`, c.dim) : '';
+            const lbl = color(l.label, c.dim);
+            const parts = [bar, pctStr, reset, lbl].filter(Boolean);
+            return parts.join(color(' · ', c.dim));
+        });
+        const width = Math.max(...rows.map(visibleLength));
+        const paddedRows = rows.map(r => padRight(r, width));
+        return { id: 'usage', priority: 25, width, lines: paddedRows };
+    },
+};

package/dist/spawn.d.ts

@@ -0,0 +1 @@
+export declare function spawnDetached(execPath: string, args: string[]): void;

package/dist/spawn.js

@@ -0,0 +1,13 @@
+import { spawn } from 'child_process';
+export function spawnDetached(execPath, args) {
+    try {
+        const child = spawn(execPath, args, {
+            detached: true,
+            stdio: 'ignore',
+        });
+        child.unref();
+    }
+    catch {
+        // Best-effort detached spawn
+    }
+}

package/dist/types.d.ts

@@ -0,0 +1,83 @@
+export interface AgyQuotaBucket {
+    remaining_fraction?: number;
+    remaining_amount?: number;
+    reset_time?: string;
+    reset_in_seconds?: number;
+    disabled?: boolean;
+    used_percentage?: number;
+    resets_at?: number | string;
+    cycle_mode?: string;
+}
+export interface AgyStatusData {
+    product?: string;
+    conversation_id?: string;
+    agent_state?: 'idle' | 'working' | 'tool_use' | 'reviewing' | 'error' | string;
+    model: {
+        id?: string;
+        display_name: string;
+        effort?: string;
+    };
+    context_window: {
+        context_window_size: number;
+        used_percentage?: number | null;
+        remaining_percentage?: number | null;
+        total_input_tokens?: number;
+        total_output_tokens?: number;
+        current_usage?: unknown;
+    };
+    rate_limits?: {
+        five_hour?: {
+            used_percentage?: number;
+            resets_at?: number | string;
+        };
+        seven_day?: {
+            used_percentage?: number;
+            resets_at?: number | string;
+        };
+        daily?: {
+            used_percentage?: number;
+            resets_at?: number | string;
+        };
+    };
+    quota?: Record<string, AgyQuotaBucket>;
+    current_dir?: string;
+    workspace?: {
+        current_dir: string;
+        project_dir?: string;
+    };
+    vcs?: {
+        type?: string;
+        branch?: string;
+        dirty?: boolean;
+    };
+    artifact_count?: number;
+    task_count?: number;
+    subagents?: unknown[];
+    plan_tier?: string;
+    terminal_width?: number;
+    cost?: {
+        total_usd?: number;
+        subagent_usd?: number;
+        estimated?: number | boolean;
+    };
+    effort?: {
+        level: string;
+    };
+}
+export interface Block {
+    id: string;
+    priority: number;
+    width: number;
+    lines: string[];
+}
+export interface Segment {
+    id: string;
+    priority: number;
+    render(data: AgyStatusData, allocWidth: number): Block;
+    enabled(data: AgyStatusData): boolean;
+}
+export interface StatusBlocksConfig {
+    segments?: string[];
+    stackWithDefault?: boolean;
+    remoteUsage?: boolean;
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/update-check.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/update-check.js

@@ -0,0 +1,33 @@
+import { readFileSync } from 'fs';
+import { execSync } from 'child_process';
+import { isValidVersion, isNewerVersion } from './version.js';
+const REGISTRY_URL = 'https://registry.npmjs.org/agy-statusblocks/latest';
+async function main() {
+    let installed = '';
+    try {
+        installed = readFileSync(new URL('./.version', import.meta.url), 'utf8').trim();
+    }
+    catch { /* unstamped install */ }
+    let latest = '';
+    try {
+        const res = await fetch(REGISTRY_URL, { signal: AbortSignal.timeout(10000) });
+        if (!res.ok)
+            return;
+        const body = (await res.json());
+        if (typeof body.version === 'string')
+            latest = body.version.trim();
+    }
+    catch {
+        return;
+    }
+    if (!isValidVersion(latest))
+        return;
+    if (isValidVersion(installed) && !isNewerVersion(latest, installed))
+        return;
+    execSync(`npx -y agy-statusblocks@${latest} update`, {
+        stdio: 'ignore',
+        windowsHide: true,
+        timeout: 300000,
+    });
+}
+main().catch(() => { });

package/dist/version.d.ts

@@ -0,0 +1,2 @@
+export declare function isValidVersion(v: string): boolean;
+export declare function isNewerVersion(a: string, b: string): boolean;

package/dist/version.js

@@ -0,0 +1,15 @@
+const VERSION_RE = /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/;
+export function isValidVersion(v) {
+    return VERSION_RE.test(v);
+}
+export function isNewerVersion(a, b) {
+    if (!isValidVersion(a) || !isValidVersion(b))
+        return false;
+    const pa = a.split(/[-+]/)[0].split('.').map(Number);
+    const pb = b.split(/[-+]/)[0].split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if (pa[i] !== pb[i])
+            return pa[i] > pb[i];
+    }
+    return false;
+}

package/package.json

@@ -1,6 +1,56 @@
 {
   "name": "agy-statusblocks",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+  "version": "0.1.0",
+  "description": "Opinionated, adaptive block-based status line for Antigravity CLI (agy) with bin-packing layout, rate limit tracking, and live agent telemetry",
+  "type": "module",
+  "bin": {
+    "agy-statusblocks": "dist/cli.js"
+  },
+  "main": "./dist/index.js",
+  "files": [
+    "dist",
+    "!dist/**/*.test.*",
+    "postinstall.cjs"
+  ],
+  "scripts": {
+    "prepare": "npm run build",
+    "postinstall": "node postinstall.cjs",
+    "prebuild": "node -e \"require('fs').rmSync('dist',{recursive:true,force:true})\"",
+    "build": "tsc",
+    "dev": "tsc --watch",
+    "test": "vitest run",
+    "preview": "node dist/cli.js preview"
+  },
+  "keywords": [
+    "antigravity",
+    "agy",
+    "gemini",
+    "statusline",
+    "status-bar",
+    "terminal",
+    "cli",
+    "ansi",
+    "box-drawing",
+    "rate-limit",
+    "bin-packing",
+    "layout"
+  ],
+  "homepage": "https://github.com/okanerturan/agy-statusblocks#readme",
+  "bugs": {
+    "url": "https://github.com/okanerturan/agy-statusblocks/issues"
+  },
+  "author": "Okan Turan",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/okanerturan/agy-statusblocks"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "license": "MIT",
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.1.0"
+  }
+}

package/postinstall.cjs

@@ -0,0 +1,17 @@
+// Auto-update ~/.gemini/antigravity-cli/statusblocks/ on npm install/update (if already installed via init)
+const { existsSync } = require('fs');
+const { execFileSync } = require('child_process');
+const { join } = require('path');
+const { homedir } = require('os');
+
+try {
+  const dest = join(homedir(), '.gemini', 'antigravity-cli', 'statusblocks');
+  if (existsSync(dest)) {
+    execFileSync(process.execPath, [join(__dirname, 'dist', 'cli.js'), 'update'], {
+      stdio: 'ignore',
+      windowsHide: true,
+    });
+  }
+} catch {
+  // Best-effort — don't fail the install
+}