agy-statusblocks 0.0.0-stage → 0.1.1

package/dist/index.js

@@ -0,0 +1,158 @@
+#!/usr/bin/env node
+import { execSync } from 'child_process';
+import { readFileSync, writeFileSync, existsSync } from 'fs';
+import { join } from 'path';
+import { homedir } from 'os';
+import { loadConfig } from './config.js';
+import { render } from './layout.js';
+import { maybeRefreshRemoteUsage } from './remote-usage.js';
+import { spawnDetached } from './spawn.js';
+const AUTO_UPDATE_INTERVAL = 86400000; // 24 hours
+function maybeAutoUpdate() {
+    if (process.env['AGY_STATUSBLOCKS_NO_UPDATE'])
+        return;
+    try {
+        const dir = join(homedir(), '.gemini', 'antigravity-cli', 'statusblocks');
+        if (!existsSync(dir))
+            return;
+        const checkFile = join(dir, '.last-update-check');
+        let lastCheck = 0;
+        try {
+            lastCheck = parseInt(readFileSync(checkFile, 'utf8'), 10) || 0;
+        }
+        catch { /* missing file */ }
+        if (Date.now() - lastCheck < AUTO_UPDATE_INTERVAL)
+            return;
+        writeFileSync(checkFile, String(Date.now()));
+        spawnDetached(process.execPath, [join(dir, 'update-check.js')]);
+    }
+    catch { /* auto-update is best-effort */ }
+}
+function detectWidth(providedWidth) {
+    if (providedWidth && providedWidth > 0)
+        return providedWidth;
+    let w = process.stderr.columns || process.stdout.columns || 0;
+    if (!w)
+        w = parseInt(process.env.COLUMNS ?? '', 10) || 0;
+    if (w > 0)
+        return w;
+    if (process.platform !== 'win32') {
+        try {
+            w = parseInt(execSync('tput cols', { encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim(), 10) || 0;
+        }
+        catch {
+            // ignore
+        }
+    }
+    return w > 0 ? w : 120;
+}
+function coerceNumber(v) {
+    if (typeof v === 'number' && Number.isFinite(v))
+        return v;
+    if (typeof v === 'string') {
+        const parsed = parseFloat(v.replace(/%/g, '').trim());
+        if (Number.isFinite(parsed))
+            return parsed;
+    }
+    return undefined;
+}
+function normalizeInput(raw) {
+    if (!raw || typeof raw !== 'object' || Array.isArray(raw))
+        return null;
+    const obj = raw;
+    const modelObj = (obj.model && typeof obj.model === 'object') ? obj.model : {};
+    const modelName = typeof modelObj.display_name === 'string'
+        ? modelObj.display_name
+        : typeof modelObj.id === 'string'
+            ? modelObj.id
+            : 'Gemini';
+    const cwObj = (obj.context_window && typeof obj.context_window === 'object') ? obj.context_window : {};
+    const cwSize = coerceNumber(cwObj.context_window_size) ?? 1048576;
+    const usedPct = coerceNumber(cwObj.used_percentage) ?? 0;
+    const remPct = coerceNumber(cwObj.remaining_percentage) ?? (100 - usedPct);
+    const cwd = typeof obj.current_dir === 'string'
+        ? obj.current_dir
+        : (typeof obj.workspace === 'object' && obj.workspace && typeof obj.workspace.current_dir === 'string')
+            ? obj.workspace.current_dir
+            : process.cwd();
+    const vcs = (obj.vcs && typeof obj.vcs === 'object') ? obj.vcs : undefined;
+    let effortLevel = typeof modelObj.effort === 'string' ? modelObj.effort.toLowerCase() : undefined;
+    if (!effortLevel) {
+        if (modelName.includes('(High)'))
+            effortLevel = 'high';
+        else if (modelName.includes('(Medium)'))
+            effortLevel = 'medium';
+        else if (modelName.includes('(Low)'))
+            effortLevel = 'low';
+        else if (modelName.includes('(Max)'))
+            effortLevel = 'max';
+    }
+    const costObj = (obj.cost && typeof obj.cost === 'object') ? obj.cost : {};
+    const rlObj = (obj.rate_limits && typeof obj.rate_limits === 'object') ? obj.rate_limits : undefined;
+    const quotaObj = (obj.quota && typeof obj.quota === 'object') ? obj.quota : undefined;
+    return {
+        product: typeof obj.product === 'string' ? obj.product : 'antigravity',
+        conversation_id: typeof obj.conversation_id === 'string' ? obj.conversation_id : undefined,
+        agent_state: typeof obj.agent_state === 'string' ? obj.agent_state : 'idle',
+        model: {
+            id: typeof modelObj.id === 'string' ? modelObj.id : 'gemini',
+            display_name: modelName,
+            effort: effortLevel,
+        },
+        context_window: {
+            context_window_size: cwSize,
+            used_percentage: usedPct,
+            remaining_percentage: remPct,
+            total_input_tokens: coerceNumber(cwObj.total_input_tokens) ?? 0,
+            total_output_tokens: coerceNumber(cwObj.total_output_tokens) ?? 0,
+        },
+        rate_limits: rlObj,
+        quota: quotaObj,
+        current_dir: cwd,
+        workspace: { current_dir: cwd },
+        vcs: vcs ? {
+            type: typeof vcs.type === 'string' ? vcs.type : 'git',
+            branch: typeof vcs.branch === 'string' ? vcs.branch : undefined,
+            dirty: typeof vcs.dirty === 'boolean' ? vcs.dirty : undefined,
+        } : undefined,
+        artifact_count: coerceNumber(obj.artifact_count) ?? 0,
+        task_count: coerceNumber(obj.task_count) ?? 0,
+        subagents: Array.isArray(obj.subagents) ? obj.subagents : [],
+        plan_tier: typeof obj.plan_tier === 'string' ? obj.plan_tier : 'Consumer',
+        terminal_width: coerceNumber(obj.terminal_width),
+        cost: {
+            total_usd: coerceNumber(costObj.total_usd),
+            subagent_usd: coerceNumber(costObj.subagent_usd),
+            estimated: typeof costObj.estimated === 'boolean' ? costObj.estimated : coerceNumber(costObj.estimated),
+        },
+        effort: effortLevel ? { level: effortLevel } : undefined,
+    };
+}
+let input = '';
+process.stdin.setEncoding('utf8');
+process.stdin.on('data', (chunk) => { input += chunk; });
+process.stdin.on('end', () => {
+    try {
+        if (!input.trim()) {
+            process.stdout.write('\n');
+            return;
+        }
+        const raw = JSON.parse(input);
+        const data = normalizeInput(raw);
+        if (!data) {
+            process.stdout.write('\n');
+            return;
+        }
+        const config = loadConfig();
+        if (config.remoteUsage === true) {
+            maybeRefreshRemoteUsage();
+        }
+        const width = detectWidth(data.terminal_width);
+        const rendered = render(data, width, config);
+        process.stdout.write(rendered + '\n');
+        maybeAutoUpdate();
+    }
+    catch {
+        process.stdout.write('\n');
+    }
+});

package/dist/layout.d.ts

@@ -0,0 +1,3 @@
+import type { AgyStatusData, StatusBlocksConfig } from './types.js';
+export declare const DEFAULT_ORDER: string[];
+export declare function render(data: AgyStatusData, width: number, config?: StatusBlocksConfig): string;

package/dist/layout.js

@@ -0,0 +1,146 @@
+import { padRight, color, c } from './colors.js';
+import { contextSegment } from './segments/context.js';
+import { modelSegment } from './segments/model.js';
+import { usageSegment } from './segments/usage.js';
+import { stateSegment } from './segments/state.js';
+import { gitSegment } from './segments/git.js';
+const ALL_SEGMENTS = [contextSegment, modelSegment, usageSegment, stateSegment, gitSegment];
+export const DEFAULT_ORDER = ['context', 'model', 'usage', 'state', 'git'];
+const GAP = 1;
+const BOX_CHROME = 4; // ╭─ ... ─╮ has 2 border chars + 2 inner spaces
+function boxify(lines, innerW, title) {
+    let top;
+    if (title) {
+        const label = ` ${title} `;
+        const remaining = Math.max(0, innerW + 2 - label.length - 1);
+        top = color('╭─', c.gray) + color(label, c.dim) + color('─'.repeat(remaining) + '╮', c.gray);
+    }
+    else {
+        top = color('╭' + '─'.repeat(innerW + 2) + '╮', c.gray);
+    }
+    const bot = color('╰' + '─'.repeat(innerW + 2) + '╯', c.gray);
+    const boxed = [top];
+    for (const line of lines) {
+        boxed.push(color('│', c.gray) + ' ' + padRight(line, innerW) + ' ' + color('│', c.gray));
+    }
+    boxed.push(bot);
+    return boxed;
+}
+function renderRow(group) {
+    const { blocks, widths } = group;
+    const boxes = blocks.map((b, i) => boxify(b.lines, widths[i], b.id));
+    const boxWidths = widths.map(w => w + BOX_CHROME);
+    const maxHeight = Math.max(...boxes.map(b => b.length));
+    for (let i = 0; i < boxes.length; i++) {
+        const box = boxes[i];
+        while (box.length < maxHeight) {
+            const blankRow = color('│', c.gray) + ' '.repeat(widths[i] + 2) + color('│', c.gray);
+            box.splice(box.length - 1, 0, blankRow);
+        }
+    }
+    const rows = [];
+    for (let row = 0; row < maxHeight; row++) {
+        const parts = [];
+        for (let i = 0; i < boxes.length; i++) {
+            parts.push(padRight(boxes[i][row], boxWidths[i]));
+        }
+        rows.push(parts.join(' '.repeat(GAP)).replace(/\s+$/, ''));
+    }
+    return rows;
+}
+function decodeAssignment(combo, blockCount, targetRows, blockRow, rowUsed) {
+    let encoded = combo;
+    for (let b = 0; b < blockCount; b++) {
+        blockRow[b] = encoded % targetRows;
+        encoded = Math.floor(encoded / targetRows);
+    }
+    rowUsed.fill(false, 0, targetRows);
+    for (let b = 0; b < blockCount; b++)
+        rowUsed[blockRow[b]] = true;
+    for (let r = 0; r < targetRows; r++) {
+        if (!rowUsed[r])
+            return false;
+    }
+    return true;
+}
+function computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidths) {
+    rowWidths.fill(0, 0, targetRows);
+    const rowCounts = new Array(targetRows).fill(0);
+    for (let b = 0; b < blockCount; b++) {
+        const r = blockRow[b];
+        rowWidths[r] = (rowWidths[r] ?? 0) + (blockWidths[b] ?? 0) + BOX_CHROME;
+        rowCounts[r] = (rowCounts[r] ?? 0) + 1;
+    }
+    for (let r = 0; r < targetRows; r++) {
+        if ((rowCounts[r] ?? 0) > 1) {
+            rowWidths[r] = (rowWidths[r] ?? 0) + ((rowCounts[r] ?? 0) - 1) * GAP;
+        }
+    }
+}
+function solveLayout(blocks, maxWidth) {
+    if (blocks.length === 0)
+        return [];
+    const blockCount = blocks.length;
+    const blockWidths = blocks.map(b => b.width);
+    for (let targetRows = 1; targetRows <= blockCount; targetRows++) {
+        const totalCombos = Math.pow(targetRows, blockCount);
+        const blockRow = new Array(blockCount);
+        const rowUsed = new Array(targetRows);
+        const rowWidths = new Array(targetRows);
+        let bestCombo = -1;
+        let minMaxRowW = Infinity;
+        for (let combo = 0; combo < totalCombos; combo++) {
+            if (!decodeAssignment(combo, blockCount, targetRows, blockRow, rowUsed))
+                continue;
+            computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidths);
+            let fits = true;
+            let maxRowW = 0;
+            for (let r = 0; r < targetRows; r++) {
+                const rw = rowWidths[r];
+                if (rw > maxWidth) {
+                    fits = false;
+                    break;
+                }
+                if (rw > maxRowW)
+                    maxRowW = rw;
+            }
+            if (fits && maxRowW < minMaxRowW) {
+                minMaxRowW = maxRowW;
+                bestCombo = combo;
+            }
+        }
+        if (bestCombo !== -1) {
+            decodeAssignment(bestCombo, blockCount, targetRows, blockRow, rowUsed);
+            const rows = [];
+            for (let r = 0; r < targetRows; r++) {
+                const rBlocks = [];
+                const rWidths = [];
+                for (let b = 0; b < blockCount; b++) {
+                    if (blockRow[b] === r) {
+                        rBlocks.push(blocks[b]);
+                        rWidths.push(blocks[b].width);
+                    }
+                }
+                const totalW = rWidths.reduce((a, w) => a + w + BOX_CHROME, 0) + (rBlocks.length - 1) * GAP;
+                rows.push({ blocks: rBlocks, widths: rWidths, totalW });
+            }
+            rows.sort((a, b) => a.totalW - b.totalW);
+            return rows.map(r => ({ blocks: r.blocks, widths: r.widths }));
+        }
+    }
+    return blocks.map(b => ({ blocks: [b], widths: [b.width] }));
+}
+export function render(data, width, config = {}) {
+    const order = config.segments ?? DEFAULT_ORDER;
+    const segmentsMap = new Map(ALL_SEGMENTS.map(s => [s.id, s]));
+    const activeSegments = order
+        .map(id => segmentsMap.get(id))
+        .filter((s) => !!s && s.enabled(data));
+    const blocks = activeSegments.map(s => s.render(data, width));
+    const groups = solveLayout(blocks, width);
+    const lines = [];
+    for (const group of groups) {
+        lines.push(...renderRow(group));
+    }
+    return lines.join('\n');
+}

package/dist/remote-usage-fetch.d.ts

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

package/dist/remote-usage-fetch.js

@@ -0,0 +1,22 @@
+#!/usr/bin/env node
+import { getOAuthToken } from './credentials.js';
+import { normalizeLimits, storeRemoteLimits } from './remote-usage.js';
+async function main() {
+    const token = getOAuthToken();
+    if (!token)
+        return;
+    const res = await fetch('https://api.anthropic.com/api/oauth/usage', {
+        headers: {
+            'Authorization': `Bearer ${token}`,
+            'anthropic-beta': 'oauth-2025-04-20',
+        },
+        signal: AbortSignal.timeout(10000),
+    });
+    if (!res.ok)
+        return;
+    const body = (await res.json());
+    storeRemoteLimits(normalizeLimits(body?.limits));
+}
+main().catch(() => {
+    // Silent fallback
+});

package/dist/remote-usage.d.ts

@@ -0,0 +1,14 @@
+export interface RemoteLimit {
+    label: string;
+    percent: number;
+    resetsAt: number;
+    scope?: 'model' | 'surface';
+    match?: string;
+    id?: string;
+}
+export declare const REMOTE_USAGE_CACHE = "remote-usage";
+export declare const KIND_LABELS: Record<string, string>;
+export declare function normalizeLimits(raw: unknown): RemoteLimit[];
+export declare function storeRemoteLimits(limits: RemoteLimit[]): void;
+export declare function readRemoteLimits(): RemoteLimit[] | null;
+export declare function maybeRefreshRemoteUsage(): void;

package/dist/remote-usage.js

@@ -0,0 +1,93 @@
+import { fileURLToPath } from 'url';
+import { join, dirname } from 'path';
+import { readCacheEntry, writeCache, acquireMarker } from './cache.js';
+import { spawnDetached } from './spawn.js';
+export const REMOTE_USAGE_CACHE = 'remote-usage';
+const REFRESH_THROTTLE_MARKER = 'remote-usage-attempt';
+const DISPLAY_TTL = 3600000; // 1 hour
+const REFRESH_INTERVAL = 60000; // 1 minute
+export const KIND_LABELS = {
+    session: '5h',
+    weekly_all: '7d',
+};
+const KNOWN_GENERIC_KINDS = new Set(Object.keys(KIND_LABELS));
+function clampPercent(v) {
+    if (typeof v !== 'number' || !Number.isFinite(v))
+        return null;
+    return Math.min(999, Math.max(0, Math.round(v)));
+}
+export function normalizeLimits(raw) {
+    if (!Array.isArray(raw))
+        return [];
+    const out = [];
+    for (const entry of raw) {
+        if (!entry || typeof entry !== 'object')
+            continue;
+        const e = entry;
+        const percent = clampPercent(e.percent);
+        if (percent === null)
+            continue;
+        let resetsAt = 0;
+        if (typeof e.resets_at === 'string') {
+            const ms = Date.parse(e.resets_at);
+            if (Number.isFinite(ms))
+                resetsAt = Math.floor(ms / 1000);
+        }
+        const kind = typeof e.kind === 'string' ? e.kind : '';
+        if (KNOWN_GENERIC_KINDS.has(kind)) {
+            out.push({ label: KIND_LABELS[kind], percent, resetsAt });
+            continue;
+        }
+        const scope = e.scope;
+        const modelName = typeof scope?.model?.display_name === 'string' ? scope.model.display_name : '';
+        const modelId = typeof scope?.model?.id === 'string' ? scope.model.id : '';
+        const surface = typeof scope?.surface === 'string' ? scope.surface : '';
+        if (surface)
+            continue;
+        if (modelName || modelId) {
+            out.push({
+                label: modelName || modelId,
+                percent,
+                resetsAt,
+                scope: 'model',
+                match: (modelName || modelId).toLowerCase(),
+                id: modelId || undefined,
+            });
+        }
+    }
+    return out;
+}
+export function storeRemoteLimits(limits) {
+    writeCache(REMOTE_USAGE_CACHE, limits);
+}
+function remoteUsageDisabled() {
+    return !!(process.env['AGY_STATUSBLOCKS_NO_REMOTE'] || process.env['CLAUDE_STATUSBLOCKS_NO_REMOTE']);
+}
+export function readRemoteLimits() {
+    if (remoteUsageDisabled())
+        return null;
+    const entry = readCacheEntry(REMOTE_USAGE_CACHE);
+    if (!entry || Date.now() - entry.ts > DISPLAY_TTL)
+        return null;
+    if (!Array.isArray(entry.value))
+        return null;
+    return entry.value;
+}
+export function maybeRefreshRemoteUsage() {
+    if (remoteUsageDisabled())
+        return;
+    const entry = readCacheEntry(REMOTE_USAGE_CACHE);
+    const isFresh = entry && Date.now() - entry.ts < REFRESH_INTERVAL;
+    if (isFresh)
+        return;
+    if (!acquireMarker(REFRESH_THROTTLE_MARKER, REFRESH_INTERVAL))
+        return;
+    try {
+        const here = dirname(fileURLToPath(import.meta.url));
+        const script = join(here, 'remote-usage-fetch.js');
+        spawnDetached(process.execPath, [script]);
+    }
+    catch {
+        // Best-effort
+    }
+}

package/dist/segments/context.d.ts

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

package/dist/segments/context.js

@@ -0,0 +1,30 @@
+import { color, c, visibleLength, pctColor, renderBar } from '../colors.js';
+function formatTokens(n) {
+    if (n >= 1000000)
+        return `${(n / 1000000).toFixed(1)}M`;
+    if (n >= 1000)
+        return `${Math.round(n / 1000)}K`;
+    return String(n);
+}
+export const contextSegment = {
+    id: 'context',
+    priority: 10,
+    enabled: () => true,
+    render(data) {
+        const total = data.context_window.context_window_size || 1048576;
+        let pct = data.context_window.used_percentage != null
+            ? Math.floor(data.context_window.used_percentage)
+            : 0;
+        const inTokens = data.context_window.total_input_tokens ?? 0;
+        const outTokens = data.context_window.total_output_tokens ?? 0;
+        const used = inTokens + outTokens;
+        if (pct === 0 && used > 0 && total > 0) {
+            pct = Math.floor((used / total) * 100);
+        }
+        const barColor = pctColor(pct);
+        const info = `${color(`${pct}%`, barColor, c.bold)}${color(' · ', c.dim)}${color(`${formatTokens(used)}/${formatTokens(total)}`, c.dim)}`;
+        const cardWidth = Math.max(16, visibleLength(info));
+        const lines = [renderBar(pct, cardWidth), info];
+        return { id: 'context', priority: 10, width: cardWidth, lines };
+    },
+};

package/dist/segments/git.d.ts

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

package/dist/segments/git.js

@@ -0,0 +1,95 @@
+import { execSync } from 'child_process';
+import { color, c, visibleLength } from '../colors.js';
+import { readCache, writeCache, hashKey } from '../cache.js';
+const GIT_CACHE_TTL = 4000;
+let memo = null;
+function defang(s) {
+    return s.replace(/[^\x20-\x7e\u00a0-\uffff]/g, '');
+}
+function normalize(v) {
+    if (!v || typeof v !== 'object')
+        return null;
+    const o = v;
+    if (typeof o.branch !== 'string')
+        return null;
+    return {
+        branch: defang(o.branch),
+        staged: Number(o.staged) || 0,
+        modified: Number(o.modified) || 0,
+        added: Number(o.added) || 0,
+        removed: Number(o.removed) || 0,
+    };
+}
+function getGitInfo(cwd) {
+    if (memo && memo.cwd === cwd)
+        return memo.info;
+    const cacheName = `git-${hashKey(cwd)}`;
+    const cached = readCache(cacheName, GIT_CACHE_TTL);
+    if (cached !== undefined) {
+        memo = { cwd, info: normalize(cached) };
+        return memo.info;
+    }
+    let info = null;
+    try {
+        let branch = execSync('git branch --show-current', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        if (!branch) {
+            branch = '@' + execSync('git rev-parse --short HEAD', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        }
+        const stagedOut = execSync('git diff --cached --numstat', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        const modifiedOut = execSync('git diff --numstat', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        const staged = stagedOut ? stagedOut.split('\n').length : 0;
+        const modified = modifiedOut ? modifiedOut.split('\n').length : 0;
+        let added = 0, removed = 0;
+        for (const line of [...(stagedOut ? stagedOut.split('\n') : []), ...(modifiedOut ? modifiedOut.split('\n') : [])]) {
+            const [a, r] = line.split('\t');
+            if (a && a !== '-')
+                added += parseInt(a, 10) || 0;
+            if (r && r !== '-')
+                removed += parseInt(r, 10) || 0;
+        }
+        info = normalize({ branch, staged, modified, added, removed });
+    }
+    catch {
+        info = null;
+    }
+    memo = { cwd, info };
+    writeCache(cacheName, info);
+    return info;
+}
+export const gitSegment = {
+    id: 'git',
+    priority: 40,
+    enabled: (data) => {
+        if (data.vcs?.branch)
+            return true;
+        const cwd = data.workspace?.current_dir || data.current_dir || process.cwd();
+        const info = getGitInfo(cwd);
+        return info !== null && info.branch !== '';
+    },
+    render(data) {
+        const cwd = data.workspace?.current_dir || data.current_dir || process.cwd();
+        const info = getGitInfo(cwd);
+        const branch = data.vcs?.branch || info?.branch || 'git';
+        const line1 = color(branch, c.cyan);
+        let line2 = color('clean', c.dim);
+        if (info) {
+            const parts = [];
+            if (info.staged > 0)
+                parts.push(color(`${info.staged} staged`, c.green));
+            if (info.modified > 0)
+                parts.push(color(`${info.modified} modified`, c.yellow));
+            if (parts.length === 0)
+                parts.push(color('clean', c.dim));
+            if (info.added > 0 || info.removed > 0) {
+                parts.push(`${color(`+${info.added}`, c.green)} ${color(`-${info.removed}`, c.red)}`);
+            }
+            line2 = parts.join(color(' · ', c.dim));
+        }
+        else if (data.vcs?.dirty) {
+            line2 = color('modified', c.yellow);
+        }
+        const lines = [line1, line2];
+        const width = Math.max(...lines.map(visibleLength));
+        return { id: 'git', priority: 40, width, lines };
+    },
+};

package/dist/segments/model.d.ts

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

package/dist/segments/model.js

@@ -0,0 +1,96 @@
+import { basename } from 'path';
+import { homedir } from 'os';
+import { color, c, visibleLength } from '../colors.js';
+function tildeDir(dir) {
+    const home = homedir();
+    if (dir === home)
+        return '~';
+    if (dir.startsWith(home + '/') || dir.startsWith(home + '\\')) {
+        return '~' + dir.slice(home.length);
+    }
+    return dir;
+}
+const EFFORT_COLORS = {
+    low: c.dim,
+    medium: c.dim,
+    high: c.yellow,
+    xhigh: c.orange,
+    max: c.orange + c.bold,
+};
+function spreadLine(parts, targetWidth) {
+    if (parts.length === 0)
+        return '';
+    if (parts.length === 1)
+        return parts[0];
+    const dot = color(' · ', c.dim);
+    const dotWidth = 3;
+    const widths = parts.map(visibleLength);
+    const contentWidth = widths.reduce((a, b) => a + b, 0);
+    const totalGap = Math.max(0, targetWidth - contentWidth);
+    const spareAfterDots = totalGap - dotWidth * (parts.length - 1);
+    if (spareAfterDots <= 10) {
+        const gaps = parts.length * 2 - 2;
+        const base = Math.floor(Math.max(0, spareAfterDots) / gaps);
+        const remainder = Math.max(0, spareAfterDots) % gaps;
+        const result = [parts[0]];
+        for (let i = 1; i < parts.length; i++) {
+            const leftPad = base + (((i - 1) * 2) < remainder ? 1 : 0);
+            const rightPad = base + (((i - 1) * 2 + 1) < remainder ? 1 : 0);
+            result.push(' '.repeat(leftPad), dot, ' '.repeat(rightPad), parts[i]);
+        }
+        return result.join('');
+    }
+    const gapCount = parts.length - 1;
+    const baseGap = Math.floor(totalGap / gapCount);
+    const extraGap = totalGap % gapCount;
+    const result = [parts[0]];
+    for (let i = 1; i < parts.length; i++) {
+        result.push(' '.repeat(baseGap + (i <= extraGap ? 1 : 0)), parts[i]);
+    }
+    return result.join('');
+}
+export const modelSegment = {
+    id: 'model',
+    priority: 30,
+    enabled: () => true,
+    render(data, allocWidth) {
+        const fullName = data.model.display_name || data.model.id || 'Gemini';
+        const shortName = fullName.replace(/\s*\(.*?\)\s*/g, '').trim();
+        // Determine reasoning effort from display name or explicit effort
+        let effort = data.model.effort || data.effort?.level;
+        if (!effort) {
+            if (fullName.includes('(High)'))
+                effort = 'high';
+            else if (fullName.includes('(Medium)'))
+                effort = 'medium';
+            else if (fullName.includes('(Low)'))
+                effort = 'low';
+            else if (fullName.includes('(Max)'))
+                effort = 'max';
+        }
+        const currentDir = data.workspace?.current_dir || data.current_dir || process.cwd();
+        const tilde = tildeDir(currentDir);
+        const isClaude = /claude|sonnet|opus|haiku/i.test(shortName);
+        const nameStyled = color(shortName, isClaude ? c.orange : c.gemini, c.bold);
+        const sep = color(' · ', c.dim);
+        const nameLen = visibleLength(nameStyled) + visibleLength(sep);
+        const dirBudget = Math.max(allocWidth - nameLen, 0);
+        const dir = tilde.length <= dirBudget ? tilde : basename(currentDir);
+        const line1 = `${nameStyled}${sep}${color(dir, c.dim)}`;
+        const effortStr = effort ? color(effort.toLowerCase(), EFFORT_COLORS[effort.toLowerCase()] ?? c.dim) : '';
+        const tierStr = data.plan_tier ? color(data.plan_tier, c.dim) : '';
+        const usd = typeof data.cost?.total_usd === 'number'
+            ? data.cost.total_usd
+            : typeof data.cost?.estimated === 'number'
+                ? data.cost.estimated
+                : 0;
+        const costStr = usd > 0
+            ? color(`${data.cost?.estimated === true ? '~' : ''}$${usd.toFixed(3)}`, c.dim)
+            : '';
+        const parts = [effortStr, tierStr, costStr].filter(Boolean);
+        const line2 = spreadLine(parts, visibleLength(line1));
+        const lines = [line1, line2 || color(shortName, c.dim)];
+        const width = Math.max(...lines.map(visibleLength));
+        return { id: 'model', priority: 30, width, lines };
+    },
+};