agy-statusblocks 0.1.1 → 0.1.3

package/README.md

@@ -47,14 +47,30 @@ On narrow/split-pane terminals, the layout degrades gracefully to stacked single
 
 ```json
 {
-  "segments": ["context", "model", "usage", "state", "git"]
+  "segments": ["context", "model", "usage", "state", "git"],
+  "border": "rounded"
 }
 ```
 
-Or via environment:
+Border styles supported:
+- `rounded` (default) — `╭─╮` `╰─╯` `│` `─`
+- `square` — `┌─┐` `└─┘` `│` `─`
+- `double` — `╔═╗` `╚═╝` `║` `═`
+- `thick` — `┏━┓` `┗━┛` `┃` `━`
+- `ascii` — `+-+` `+-+` `|` `-` (clean standard 7-bit ASCII)
+- `none` — clean padded columns without frame borders
+
+Or configure via environment variables:
 
 ```sh
 AGY_STATUSBLOCKS_SEGMENTS=context,model,usage
+AGY_STATUSBLOCKS_BORDER=double
+```
+
+Or pass via CLI flag:
+
+```sh
+npx agy-statusblocks preview --border double
 ```
 
 ## Preview

package/dist/cache.js

@@ -3,9 +3,9 @@ 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 override = process.env['AGY_STATUSBLOCKS_CACHE_DIR'];
     const uid = typeof process.getuid === 'function' ? `-${process.getuid()}` : '';
-    const dir = override || join(tmpdir(), `claude-statusblocks${uid}`);
+    const dir = override || join(tmpdir(), `agy-statusblocks${uid}`);
     if (create)
         mkdirSync(dir, { recursive: true });
     return dir;

package/dist/cli.js

@@ -4,7 +4,7 @@ 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 { loadConfig, normalizeBorderStyle } from './config.js';
 import { color, c } from './colors.js';
 import { isValidVersion, isNewerVersion } from './version.js';
 const PACKAGE_VERSION = (() => {
@@ -134,9 +134,26 @@ function runUninstall() {
     }
     console.log(color('✓ agy-statusblocks uninstalled and reverted to built-in status line', c.green));
 }
-function runPreview() {
+function parseBorderFlag(argv) {
+    for (let i = 0; i < argv.length; i++) {
+        const arg = argv[i];
+        if (arg === '--border' || arg === '-b') {
+            const next = argv[i + 1];
+            if (next)
+                return normalizeBorderStyle(next);
+        }
+        else if (arg && arg.startsWith('--border=')) {
+            return normalizeBorderStyle(arg.slice('--border='.length));
+        }
+    }
+    return undefined;
+}
+function runPreview(borderOverride) {
     process.env['AGY_STATUSBLOCKS_NO_REMOTE'] = '1';
     const config = loadConfig();
+    if (borderOverride) {
+        config.border = borderOverride;
+    }
     const now = Date.now() / 1000;
     const mockData = {
         product: 'antigravity',
@@ -186,7 +203,8 @@ function runPreview() {
             level: 'medium',
         },
     };
-    console.log(`\n${color('agy-statusblocks', c.bold, c.gemini)} preview\n`);
+    const styleLabel = config.border ?? 'rounded';
+    console.log(`\n${color('agy-statusblocks', c.bold, c.gemini)} preview ${color(`[border: ${styleLabel}]`, c.dim)}\n`);
     for (const width of [120, 80, 50]) {
         console.log(color('─'.repeat(width), c.gray));
         console.log(`${width} cols:`);
@@ -199,12 +217,12 @@ function showHelp() {
 ${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
+  agy-statusblocks init                        Install into Antigravity CLI settings
+  agy-statusblocks update                      Update installed files (--force to downgrade)
+  agy-statusblocks preview [--border <style>]  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
@@ -213,13 +231,22 @@ ${color('Blocks:', c.bold)}
   state      Agent state pill and task/subagent/artifact counters
   git        Branch, staged/modified counts, lines added/removed
 
+${color('Borders:', c.bold)}
+  rounded (default), square, double, thick, ascii, none
+
 ${color('Customize:', c.bold)}
-  ~/.agy-statusblocks.json:   { "segments": ["context", "model", "usage", "state", "git"] }
+  ~/.agy-statusblocks.json:   { "segments": ["context", "model", "usage", "state", "git"], "border": "rounded" }
   Env vars:                   AGY_STATUSBLOCKS_SEGMENTS=context,model,usage
+                              AGY_STATUSBLOCKS_BORDER=rounded|square|double|thick|ascii|none
+  CLI flags:                  --border, -b <style>
 `);
 }
-const cmd = process.argv[2];
-switch (cmd) {
+const borderFlag = parseBorderFlag(process.argv.slice(2));
+if (borderFlag) {
+    process.env['AGY_STATUSBLOCKS_BORDER'] = borderFlag;
+}
+const firstPositional = process.argv.slice(2).find(arg => !arg.startsWith('-'));
+switch (firstPositional) {
     case 'init':
         runInit();
         break;
@@ -227,18 +254,26 @@ switch (cmd) {
         runUpdate(process.argv.includes('--force'));
         break;
     case 'preview':
-        runPreview();
+        runPreview(borderFlag);
         break;
     case 'uninstall':
         runUninstall();
         break;
-    case '--version':
-    case '-v':
-        console.log(PACKAGE_VERSION);
+    case undefined:
+        if (process.argv.includes('--version') || process.argv.includes('-v')) {
+            console.log(PACKAGE_VERSION);
+        }
+        else if (process.argv.includes('--help') || process.argv.includes('-h')) {
+            showHelp();
+        }
+        else if (process.stdin.isTTY) {
+            showHelp();
+        }
+        else {
+            import('./index.js');
+        }
         break;
     case 'help':
-    case '--help':
-    case '-h':
         showHelp();
         break;
     default:

package/dist/config.d.ts

@@ -1,2 +1,4 @@
-import type { StatusBlocksConfig } from './types.js';
+import type { StatusBlocksConfig, BorderStyle } from './types.js';
+export declare const VALID_BORDER_STYLES: readonly BorderStyle[];
+export declare function normalizeBorderStyle(val: unknown): BorderStyle | undefined;
 export declare function loadConfig(): StatusBlocksConfig;

package/dist/config.js

@@ -1,8 +1,26 @@
 import { readFileSync } from 'fs';
 import { join } from 'path';
 import { homedir } from 'os';
+export const VALID_BORDER_STYLES = [
+    'rounded',
+    'square',
+    'double',
+    'thick',
+    'ascii',
+    'none',
+];
+export function normalizeBorderStyle(val) {
+    if (typeof val === 'string') {
+        const lower = val.trim().toLowerCase();
+        if (VALID_BORDER_STYLES.includes(lower)) {
+            return lower;
+        }
+    }
+    return undefined;
+}
 export function loadConfig() {
     const envSegments = process.env['AGY_STATUSBLOCKS_SEGMENTS'];
+    const envBorder = process.env['AGY_STATUSBLOCKS_BORDER'];
     const config = {};
     try {
         const raw = readFileSync(join(homedir(), '.agy-statusblocks.json'), 'utf8');
@@ -14,10 +32,20 @@ export function loadConfig() {
                 config.remoteUsage = parsed.remoteUsage;
             if (typeof parsed.stackWithDefault === 'boolean')
                 config.stackWithDefault = parsed.stackWithDefault;
+            if (parsed.border) {
+                const border = normalizeBorderStyle(parsed.border);
+                if (border)
+                    config.border = border;
+            }
         }
     }
     catch { /* no config file — use defaults */ }
     if (envSegments)
         config.segments = envSegments.split(',');
+    if (envBorder) {
+        const border = normalizeBorderStyle(envBorder);
+        if (border)
+            config.border = border;
+    }
     return config;
 }

package/dist/index.js

@@ -129,6 +129,10 @@ function normalizeInput(raw) {
     };
 }
 let input = '';
+if (process.stdin.isTTY) {
+    process.stdout.write('\n');
+    process.exit(0);
+}
 process.stdin.setEncoding('utf8');
 process.stdin.on('data', (chunk) => { input += chunk; });
 process.stdin.on('end', () => {

package/dist/layout.d.ts

@@ -1,3 +1,19 @@
-import type { AgyStatusData, StatusBlocksConfig } from './types.js';
+import type { Block, AgyStatusData, StatusBlocksConfig, BorderStyle } from './types.js';
 export declare const DEFAULT_ORDER: string[];
+export interface BorderGlyphs {
+    tl: string;
+    tr: string;
+    bl: string;
+    br: string;
+    h: string;
+    v: string;
+}
+export declare const BORDER_STYLES: Record<BorderStyle, BorderGlyphs>;
+type RowGroup = {
+    blocks: Block[];
+    widths: number[];
+};
+export declare function boxify(lines: string[], innerW: number, style?: BorderStyle, title?: string): string[];
+export declare function renderRow(group: RowGroup, style?: BorderStyle): string[];
 export declare function render(data: AgyStatusData, width: number, config?: StatusBlocksConfig): string;
+export {};

package/dist/layout.js

@@ -7,35 +7,62 @@ 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) {
+export const BORDER_STYLES = {
+    rounded: { tl: '╭', tr: '╮', bl: '╰', br: '╯', h: '─', v: '│' },
+    square: { tl: '┌', tr: '┐', bl: '└', br: '┘', h: '─', v: '│' },
+    double: { tl: '╔', tr: '╗', bl: '╚', br: '╝', h: '═', v: '║' },
+    thick: { tl: '┏', tr: '┓', bl: '┗', br: '┛', h: '━', v: '┃' },
+    ascii: { tl: '+', tr: '+', bl: '+', br: '+', h: '-', v: '|' },
+    none: { tl: '', tr: '', bl: '', br: '', h: '', v: '' },
+};
+export function boxify(lines, innerW, style = 'rounded', title) {
+    if (style === 'none') {
+        const boxed = [];
+        if (title) {
+            boxed.push(' ' + color(title, c.dim) + ' '.repeat(Math.max(0, innerW + 1 - title.length)));
+        }
+        for (const line of lines) {
+            boxed.push(' ' + padRight(line, innerW) + ' ');
+        }
+        return boxed;
+    }
+    const g = BORDER_STYLES[style] || BORDER_STYLES.rounded;
     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);
+        top = color(g.tl + g.h, c.gray) + color(label, c.dim) + color(g.h.repeat(remaining) + g.tr, c.gray);
     }
     else {
-        top = color('╭' + '─'.repeat(innerW + 2) + '╮', c.gray);
+        top = color(g.tl + g.h.repeat(innerW + 2) + g.tr, c.gray);
     }
-    const bot = color('╰' + '─'.repeat(innerW + 2) + '╯', c.gray);
+    const bot = color(g.bl + g.h.repeat(innerW + 2) + g.br, c.gray);
     const boxed = [top];
     for (const line of lines) {
-        boxed.push(color('│', c.gray) + ' ' + padRight(line, innerW) + ' ' + color('│', c.gray));
+        boxed.push(color(g.v, c.gray) + ' ' + padRight(line, innerW) + ' ' + color(g.v, c.gray));
     }
     boxed.push(bot);
     return boxed;
 }
-function renderRow(group) {
+export function renderRow(group, style = 'rounded') {
     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 chrome = style === 'none' ? 2 : 4;
+    const boxes = blocks.map((b, i) => boxify(b.lines, widths[i], style, b.id));
+    const boxWidths = widths.map(w => w + chrome);
+    const g = BORDER_STYLES[style] || BORDER_STYLES.rounded;
     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 blankRow = style === 'none'
+                ? ' '.repeat(widths[i] + 2)
+                : color(g.v, c.gray) + ' '.repeat(widths[i] + 2) + color(g.v, c.gray);
+            if (style === 'none') {
+                box.push(blankRow);
+            }
+            else {
+                box.splice(box.length - 1, 0, blankRow);
+            }
         }
     }
     const rows = [];
@@ -63,12 +90,12 @@ function decodeAssignment(combo, blockCount, targetRows, blockRow, rowUsed) {
     }
     return true;
 }
-function computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidths) {
+function computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidths, chrome) {
     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;
+        rowWidths[r] = (rowWidths[r] ?? 0) + (blockWidths[b] ?? 0) + chrome;
         rowCounts[r] = (rowCounts[r] ?? 0) + 1;
     }
     for (let r = 0; r < targetRows; r++) {
@@ -77,10 +104,34 @@ function computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidt
         }
     }
 }
-function solveLayout(blocks, maxWidth) {
+function solveGreedy(blocks, maxWidth, chrome) {
+    const rows = [];
+    for (const b of blocks) {
+        const boxW = b.width + chrome;
+        let placed = false;
+        for (const r of rows) {
+            const addedW = r.blocks.length > 0 ? boxW + GAP : boxW;
+            if (r.currentW + addedW <= maxWidth) {
+                r.blocks.push(b);
+                r.widths.push(b.width);
+                r.currentW += addedW;
+                placed = true;
+                break;
+            }
+        }
+        if (!placed) {
+            rows.push({ blocks: [b], widths: [b.width], currentW: boxW });
+        }
+    }
+    rows.sort((a, b) => a.currentW - b.currentW);
+    return rows.map(r => ({ blocks: r.blocks, widths: r.widths }));
+}
+function solveLayout(blocks, maxWidth, chrome) {
     if (blocks.length === 0)
         return [];
     const blockCount = blocks.length;
+    if (blockCount > 6)
+        return solveGreedy(blocks, maxWidth, chrome);
     const blockWidths = blocks.map(b => b.width);
     for (let targetRows = 1; targetRows <= blockCount; targetRows++) {
         const totalCombos = Math.pow(targetRows, blockCount);
@@ -92,7 +143,7 @@ function solveLayout(blocks, maxWidth) {
         for (let combo = 0; combo < totalCombos; combo++) {
             if (!decodeAssignment(combo, blockCount, targetRows, blockRow, rowUsed))
                 continue;
-            computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidths);
+            computeRowWidths(blockRow, blockCount, targetRows, blockWidths, rowWidths, chrome);
             let fits = true;
             let maxRowW = 0;
             for (let r = 0; r < targetRows; r++) {
@@ -121,7 +172,7 @@ function solveLayout(blocks, maxWidth) {
                         rWidths.push(blocks[b].width);
                     }
                 }
-                const totalW = rWidths.reduce((a, w) => a + w + BOX_CHROME, 0) + (rBlocks.length - 1) * GAP;
+                const totalW = rWidths.reduce((a, w) => a + w + chrome, 0) + (rBlocks.length - 1) * GAP;
                 rows.push({ blocks: rBlocks, widths: rWidths, totalW });
             }
             rows.sort((a, b) => a.totalW - b.totalW);
@@ -132,15 +183,17 @@ function solveLayout(blocks, maxWidth) {
 }
 export function render(data, width, config = {}) {
     const order = config.segments ?? DEFAULT_ORDER;
+    const borderStyle = config.border ?? 'rounded';
+    const chrome = borderStyle === 'none' ? 2 : 4;
     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 groups = solveLayout(blocks, width, chrome);
     const lines = [];
     for (const group of groups) {
-        lines.push(...renderRow(group));
+        lines.push(...renderRow(group, borderStyle));
     }
     return lines.join('\n');
 }

package/dist/segments/context.js

@@ -1,10 +1,11 @@
 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);
+    const safe = Math.max(0, Math.round(n || 0));
+    if (safe >= 1000000)
+        return `${(safe / 1000000).toFixed(1)}M`;
+    if (safe >= 1000)
+        return `${Math.round(safe / 1000)}K`;
+    return String(safe);
 }
 export const contextSegment = {
     id: 'context',

package/dist/segments/git.js

@@ -31,12 +31,13 @@ function getGitInfo(cwd) {
     }
     let info = null;
     try {
-        let branch = execSync('git branch --show-current', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+        const execOpts = { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'], timeout: 1500 };
+        let branch = execSync('git branch --show-current', execOpts).trim();
         if (!branch) {
-            branch = '@' + execSync('git rev-parse --short HEAD', { cwd, encoding: 'utf8', stdio: ['pipe', 'pipe', 'ignore'] }).trim();
+            branch = '@' + execSync('git rev-parse --short HEAD', execOpts).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 stagedOut = execSync('git diff --cached --numstat', execOpts).trim();
+        const modifiedOut = execSync('git diff --numstat', execOpts).trim();
         const staged = stagedOut ? stagedOut.split('\n').length : 0;
         const modified = modifiedOut ? modifiedOut.split('\n').length : 0;
         let added = 0, removed = 0;

package/dist/segments/usage.js

@@ -16,7 +16,7 @@ function formatResetTime(epochSec) {
         return `${d}d${h > 0 ? `${h}h` : ''}${m > 0 ? `${m}m` : ''}`;
     if (h > 0)
         return `${h}h${m > 0 ? `${m}m` : ''}`;
-    return `${m}m`;
+    return m > 0 ? `${m}m` : '<1m';
 }
 function clampPercent(v) {
     return Math.min(999, Math.max(0, Math.round(v ?? 0)));
@@ -178,12 +178,34 @@ export const usageSegment = {
             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);
+        const active = limits.slice(0, 2);
+        const formatted = active.map(l => {
+            const pctStr = `${l.percent}%`;
+            const resetTime = l.resetsAt ? formatResetTime(l.resetsAt) : '';
+            const resetRaw = resetTime ? `↻ ${resetTime}` : '';
+            return {
+                limit: l,
+                pctStr,
+                resetRaw,
+                label: l.label,
+            };
+        });
+        const maxPctLen = Math.max(...formatted.map(r => r.pctStr.length));
+        const hasAnyReset = formatted.some(r => r.resetRaw.length > 0);
+        const maxResetLen = hasAnyReset ? Math.max(...formatted.map(r => r.resetRaw.length)) : 0;
+        const maxLabelLen = Math.max(...formatted.map(r => r.label.length));
+        const rows = formatted.map(r => {
+            const bar = renderBar(r.limit.percent, BAR_WIDTH);
+            const paddedPct = ' '.repeat(maxPctLen - r.pctStr.length) + r.pctStr;
+            const pctColorStr = color(paddedPct, pctColor(r.limit.percent), c.bold);
+            let resetColorStr = '';
+            if (hasAnyReset && r.resetRaw) {
+                const paddedReset = r.resetRaw + ' '.repeat(maxResetLen - r.resetRaw.length);
+                resetColorStr = color(paddedReset, c.dim);
+            }
+            const paddedLabel = ' '.repeat(maxLabelLen - r.label.length) + r.label;
+            const lbl = color(paddedLabel, c.dim);
+            const parts = [bar, pctColorStr, resetColorStr, lbl].filter(Boolean);
             return parts.join(color(' · ', c.dim));
         });
         const width = Math.max(...rows.map(visibleLength));

package/dist/types.d.ts

@@ -76,8 +76,10 @@ export interface Segment {
     render(data: AgyStatusData, allocWidth: number): Block;
     enabled(data: AgyStatusData): boolean;
 }
+export type BorderStyle = 'rounded' | 'square' | 'double' | 'thick' | 'ascii' | 'none';
 export interface StatusBlocksConfig {
     segments?: string[];
     stackWithDefault?: boolean;
     remoteUsage?: boolean;
+    border?: BorderStyle;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "agy-statusblocks",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "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": {