From 47bb624f76c84204b742800ea6732123e39d6bb7 Mon Sep 17 00:00:00 2001 From: Yongzhao Chen Date: Mon, 2 Nov 2026 00:37:41 +0100 Subject: [PATCH 1/2] feat(context-bar): add a thin line display mode MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Block glyphs (█░, ▓░) read heavy in light themes and plain-text layouts. The new 'line' mode draws used context as ━ and the rest as ─, at the same 16-cell width as the medium bar. It joins the end of the p cycle, so existing configurations are unchanged. --- docs/USAGE.md | 2 +- src/widgets/ContextBar.ts | 24 ++++++++++++++++++----- src/widgets/__tests__/ContextBar.test.ts | 25 +++++++++++++++++++++++- 3 files changed, 44 insertions(+), 7 deletions(-) diff --git a/docs/USAGE.md b/docs/USAGE.md index 04b69201d..b295a6e65 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -335,7 +335,7 @@ Widget-specific shortcuts: - **Block Timer**: `p` cycle time/full bar/short bar, `s` toggle compact time, `v` invert fill in progress mode - **Block Reset Timer**: `p` cycle time/full bar/short bar, `s` toggle compact time/date, `t` toggle exact reset date/time, `f` toggle 12/24-hour display in date mode, `z` edit timezone in date mode, `l` edit locale in date mode, `v` invert fill in progress mode - **Weekly Reset Timer**: `p` cycle time/full bar/short bar, `s` toggle compact time/date, `t` toggle exact reset date/time, `o` toggle hours-only in time mode, `f` toggle 12/24-hour display in date mode, `z` edit timezone in date mode, `l` edit locale in date mode, `v` invert fill in progress mode -- **Context Bar**: `p` cycle medium/full/short/short-only progress bar +- **Context Bar**: `p` cycle medium/full/short/short-only/line progress bar - **Compaction Counter**: `v` cycle value (count/auto/manual/unknown/reclaimed), `f` cycle format, `n` toggle Nerd Font icon in icon mode, `s` toggle trigger split (auto/manual/unknown), `t` toggle tokens reclaimed - **Cache widgets** (Cache Hit Rate, Cache Read, Cache Write): `t` toggle turn/session scope - **Cache Timer**: `t` cycle the fallback 5-minute/1-hour TTL (reported `5m`/`1h` takes precedence), `s` toggle compact time, `g` customize the working/fresh/draining/urgent/cold glyphs; Working is used only in the transcript fallback; Backspace in the glyph editor renders that state without one diff --git a/src/widgets/ContextBar.ts b/src/widgets/ContextBar.ts index 97f168425..2d6242ce1 100644 --- a/src/widgets/ContextBar.ts +++ b/src/widgets/ContextBar.ts @@ -23,11 +23,19 @@ import { makeSliderBar } from './shared/usage-display'; const LABEL = 'Context: '; -type DisplayMode = 'progress' | 'progress-short' | 'slider' | 'slider-only'; +type DisplayMode = 'progress' | 'progress-short' | 'slider' | 'slider-only' | 'line'; + +const LINE_BAR_WIDTH = 16; + +// Thin bar for fonts and themes where block glyphs look heavy: heavy rule for used, light rule for free. +function makeLineBar(percent: number, width = LINE_BAR_WIDTH): string { + const filled = Math.round((percent / 100) * width); + return '━'.repeat(filled) + '─'.repeat(width - filled); +} function getDisplayMode(item: WidgetItem): DisplayMode { const mode = item.metadata?.display; - if (mode === 'progress' || mode === 'slider' || mode === 'slider-only') { + if (mode === 'progress' || mode === 'slider' || mode === 'slider-only' || mode === 'line') { return mode; } return 'progress-short'; @@ -54,6 +62,8 @@ export class ContextBarWidget implements Widget { modifiers.push('short bar'); } else if (mode === 'slider-only') { modifiers.push('short bar only'); + } else if (mode === 'line') { + modifiers.push('line bar'); } return { @@ -74,7 +84,9 @@ export class ContextBarWidget implements Widget { ? 'slider' : currentMode === 'slider' ? 'slider-only' - : 'progress-short'; + : currentMode === 'slider-only' + ? 'line' + : 'progress-short'; return { ...item, @@ -100,7 +112,8 @@ export class ContextBarWidget implements Widget { return formatRawOrLabeledValue(item, this.getLabelPrefix(), sliderDisplay); } const barWidth = displayMode === 'progress' ? 32 : 16; - const previewDisplay = `${makeUsageProgressBar(25, barWidth)} ${usedDisplay}/${totalDisplay} (${percentDisplay})`; + const previewBar = displayMode === 'line' ? makeLineBar(25) : makeUsageProgressBar(25, barWidth); + const previewDisplay = `${previewBar} ${usedDisplay}/${totalDisplay} (${percentDisplay})`; return formatRawOrLabeledValue(item, this.getLabelPrefix(), previewDisplay); } @@ -131,7 +144,8 @@ export class ContextBarWidget implements Widget { } const barWidth = displayMode === 'progress' ? 32 : 16; - const display = `${makeUsageProgressBar(clampedPercent, barWidth)} ${usedDisplay}/${totalDisplay} (${percentDisplay})`; + const bar = displayMode === 'line' ? makeLineBar(clampedPercent) : makeUsageProgressBar(clampedPercent, barWidth); + const display = `${bar} ${usedDisplay}/${totalDisplay} (${percentDisplay})`; return formatRawOrLabeledValue(item, this.getLabelPrefix(), display); } diff --git a/src/widgets/__tests__/ContextBar.test.ts b/src/widgets/__tests__/ContextBar.test.ts index f8d09ad4a..3beb71247 100644 --- a/src/widgets/__tests__/ContextBar.test.ts +++ b/src/widgets/__tests__/ContextBar.test.ts @@ -161,11 +161,34 @@ describe('ContextBarWidget', () => { const second = widget.handleEditorAction('toggle-progress', first ?? base); const third = widget.handleEditorAction('toggle-progress', second ?? base); const fourth = widget.handleEditorAction('toggle-progress', third ?? base); + const fifth = widget.handleEditorAction('toggle-progress', fourth ?? base); expect(first?.metadata?.display).toBe('progress'); expect(second?.metadata?.display).toBe('slider'); expect(third?.metadata?.display).toBe('slider-only'); - expect(fourth?.metadata?.display).toBe('progress-short'); + expect(fourth?.metadata?.display).toBe('line'); + expect(fifth?.metadata?.display).toBe('progress-short'); + }); + + it('renders a thin line bar in line mode', () => { + const context: RenderContext = { + data: { + context_window: { + context_window_size: 200000, + current_usage: { + input_tokens: 20000, + output_tokens: 10000, + cache_creation_input_tokens: 5000, + cache_read_input_tokens: 5000 + } + } + } + }; + const item: WidgetItem = { id: 'ctx', type: 'context-bar', metadata: { display: 'line' } }; + const widget = new ContextBarWidget(); + + expect(widget.render(item, context, DEFAULT_SETTINGS)).toBe(`Context: ${'━'.repeat(2)}${'─'.repeat(14)} 30k/200k (15%)`); + expect(widget.getEditorDisplay(item).modifierText).toBe('(line bar)'); }); it('formats context preview samples with the selected styles', () => { From b7e1cecc0c124c3933c22e1038be9f0bd417f04d Mon Sep 17 00:00:00 2001 From: Matthew Breedlove Date: Thu, 5 Nov 2026 10:55:04 -0500 Subject: [PATCH 2/2] feat(widgets): extend line mode to all progress bars --- docs/USAGE.md | 12 +- src/widgets/BlockResetTimer.ts | 13 +- src/widgets/BlockTimer.ts | 18 +-- src/widgets/ContextBar.ts | 13 +- src/widgets/ExtraUsageUtilization.ts | 13 +- src/widgets/WeeklyResetTimer.ts | 15 +- .../__tests__/ContextPercentage.test.ts | 4 +- .../__tests__/helpers/usage-widget-suites.ts | 16 +- src/widgets/__tests__/line-bar.test.ts | 153 ++++++++++++++++++ .../__tests__/shared/progress-bar.test.ts | 30 +++- .../shared/__tests__/usage-display.test.ts | 12 +- src/widgets/shared/context-slider.ts | 15 +- src/widgets/shared/progress-bar.ts | 18 ++- src/widgets/shared/usage-display.ts | 29 +++- src/widgets/shared/usage-percent-widget.ts | 8 +- 15 files changed, 294 insertions(+), 75 deletions(-) create mode 100644 src/widgets/__tests__/line-bar.test.ts diff --git a/docs/USAGE.md b/docs/USAGE.md index b295a6e65..dc44178d2 100644 --- a/docs/USAGE.md +++ b/docs/USAGE.md @@ -316,6 +316,8 @@ Text editors use a blinking bar cursor so trailing spaces remain visible. Label The keybind footer in the TUI only shows shortcuts that apply to the currently selected widget. Plain-letter shortcuts ignore Ctrl and Alt/Option modifiers, so combinations such as `Ctrl+S` do not also trigger the letter action. +All bar widgets offer a 16-cell **line bar** mode using `━` for filled cells and `─` for empty cells, with no brackets and the widget's numeric values alongside it. It is the last mode before the `p` cycle returns to its starting mode. Fill inversion and time cursors remain available on widgets that support them. Existing modes retain their appearance. + Widget-specific shortcuts: - **Remote Control Status**: `e` edits the label in `label-check` and `label-mark` formats when raw value is off. The override is shared by these two formats; Tab in the label editor restores `remote `. - **Glyph widgets** (Git Branch, Git Worktree, Git Worktree Mode, Git Staged, Git Unstaged, Git Untracked, Git Conflicts, Git Ahead/Behind, Git Status, Git Changes, Git Insertions, Git Deletions, Git Clean Status, Git Is Fork, JJ Revision, JJ Bookmarks, JJ Workspace, JJ Changes, JJ Insertions, JJ Deletions, Remote Control Status with Nerd Font icons): `g` set custom glyphs for the widget's symbols; Backspace in the editor renders without one, Shift+Tab toggles every symbol between none and default, and multi-symbol widgets (Ahead/Behind, Status, Conflicts, Changes, Clean Status, Remote Control Status on/off) edit each part in one list @@ -326,15 +328,15 @@ Widget-specific shortcuts: - **Git remote widgets** (`Git Origin*` / `Git Upstream*`): `l` toggle clickable repo links - **Git Origin Owner/Repo**: `o` show only the owner when the repo is a fork - **Git Conflicts**: `z` toggles how a visible conflict-free tree renders (`⚠0` or the clean glyph); `g` edits the conflict and clean glyphs -- **Context % widgets**: `u` toggle used vs remaining display, `p` cycle percentage/short bar/short bar only +- **Context % widgets**: `u` toggle used vs remaining display, `p` cycle percentage/short bar/short bar only/line bar - **Session Cost Rate**: `t` switch between active time (how long Claude spent working, the default) and clock time (the whole session) -- **Block Usage / Weekly Usage / Weekly Sonnet Usage / Weekly Opus Usage / Weekly Fable Usage / Spend Limit Usage / Extra Usage Utilization**: `p` cycle percentage/full bar/medium bar/short bar/short bar only and `u` switch between used and remaining percentage in every display mode. The editor row labels the current direction as `used` or `remaining`, while the `u` helper names the direction it will switch to. Block and weekly usage widgets use `t` to toggle the time cursor in bar modes. +- **Block Usage / Weekly Usage / Weekly Sonnet Usage / Weekly Opus Usage / Weekly Fable Usage / Spend Limit Usage / Extra Usage Utilization**: `p` cycle percentage/full bar/medium bar/short bar/short bar only/line bar and `u` switch between used and remaining percentage in every display mode. The editor row labels the current direction as `used` or `remaining`, while the `u` helper names the direction it will switch to. Block and weekly usage widgets use `t` to toggle the time cursor in bar modes. - **Extra Usage Daily Budget**: `w` toggle counting weekdays only (Saturday and Sunday, UTC, are skipped; today always counts) - **Block Forecast**: `u` switch between projected used and remaining percentage - **Block Limit Timer / Weekly Limit Timer / Weekly Fable Limit Timer**: `s` toggle compact time -- **Block Timer**: `p` cycle time/full bar/short bar, `s` toggle compact time, `v` invert fill in progress mode -- **Block Reset Timer**: `p` cycle time/full bar/short bar, `s` toggle compact time/date, `t` toggle exact reset date/time, `f` toggle 12/24-hour display in date mode, `z` edit timezone in date mode, `l` edit locale in date mode, `v` invert fill in progress mode -- **Weekly Reset Timer**: `p` cycle time/full bar/short bar, `s` toggle compact time/date, `t` toggle exact reset date/time, `o` toggle hours-only in time mode, `f` toggle 12/24-hour display in date mode, `z` edit timezone in date mode, `l` edit locale in date mode, `v` invert fill in progress mode +- **Block Timer**: `p` cycle time/full bar/medium bar/short bar/short bar only/line bar, `s` toggle compact time, `v` invert fill in progress mode +- **Block Reset Timer**: `p` cycle time/full bar/medium bar/short bar/short bar only/line bar, `s` toggle compact time/date, `t` toggle exact reset date/time, `f` toggle 12/24-hour display in date mode, `z` edit timezone in date mode, `l` edit locale in date mode, `v` invert fill in progress mode +- **Weekly Reset Timer**: `p` cycle time/full bar/medium bar/short bar/short bar only/line bar, `s` toggle compact time/date, `t` toggle exact reset date/time, `o` toggle hours-only in time mode, `f` toggle 12/24-hour display in date mode, `z` edit timezone in date mode, `l` edit locale in date mode, `v` invert fill in progress mode - **Context Bar**: `p` cycle medium/full/short/short-only/line progress bar - **Compaction Counter**: `v` cycle value (count/auto/manual/unknown/reclaimed), `f` cycle format, `n` toggle Nerd Font icon in icon mode, `s` toggle trigger split (auto/manual/unknown), `t` toggle tokens reclaimed - **Cache widgets** (Cache Hit Rate, Cache Read, Cache Write): `t` toggle turn/session scope diff --git a/src/widgets/BlockResetTimer.ts b/src/widgets/BlockResetTimer.ts index 44cbaddcc..79830b8af 100644 --- a/src/widgets/BlockResetTimer.ts +++ b/src/widgets/BlockResetTimer.ts @@ -26,7 +26,6 @@ import { LOCALE_EDITOR_ACTION, renderUsageLocaleEditor } from './shared/locale-editor'; -import { makeTimerProgressBar } from './shared/progress-bar'; import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { TIMEZONE_EDITOR_ACTION, @@ -39,7 +38,6 @@ import { getUsageDisplayMode, getUsageDisplayModifierText, getUsageLocale, - getUsageProgressBarWidth, getUsageTimerCustomKeybinds, getUsageTimezone, isAtSessionLimit, @@ -50,6 +48,7 @@ import { isUsageProgressMode, isUsageSliderMode, makeSliderBar, + renderUsageProgressBar, toggleUsageCompact, toggleUsageDateMode, toggleUsageHourFormat, @@ -118,9 +117,8 @@ export class BlockResetTimerWidget implements Widget { const previewPercent = inverted ? 90.0 : 10.0; if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); - const progressBar = makeTimerProgressBar(previewPercent, barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${progressBar}] ${formatPercent(previewPercent, format)}`); + const progressBar = renderUsageProgressBar(previewPercent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(previewPercent, format)}`); } if (isUsageSliderMode(displayMode)) { @@ -164,10 +162,9 @@ export class BlockResetTimerWidget implements Widget { } if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const progressBar = makeTimerProgressBar(percent, barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${progressBar}] ${formatPercent(percent, format)}`); + const progressBar = renderUsageProgressBar(percent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(percent, format)}`); } if (isUsageSliderMode(displayMode)) { diff --git a/src/widgets/BlockTimer.ts b/src/widgets/BlockTimer.ts index af07aa185..ee99726d7 100644 --- a/src/widgets/BlockTimer.ts +++ b/src/widgets/BlockTimer.ts @@ -17,19 +17,18 @@ import { } from '../utils/usage'; import { isHidden } from './shared/hideable'; -import { makeTimerProgressBar } from './shared/progress-bar'; import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { cycleUsageDisplayMode, getUsageDisplayMode, getUsageDisplayModifierText, - getUsageProgressBarWidth, getUsageTimerCustomKeybinds, isUsageCompact, isUsageInverted, isUsageProgressMode, isUsageSliderMode, makeSliderBar, + renderUsageProgressBar, toggleUsageCompact, toggleUsageInverted } from './shared/usage-display'; @@ -82,9 +81,8 @@ export class BlockTimerWidget implements Widget { const previewPercent = inverted ? 26.1 : 73.9; if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); - const progressBar = makeTimerProgressBar(previewPercent, barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${progressBar}] ${formatPercent(previewPercent, format)}`); + const progressBar = renderUsageProgressBar(previewPercent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(previewPercent, format)}`); } if (isUsageSliderMode(displayMode)) { @@ -108,9 +106,8 @@ export class BlockTimerWidget implements Widget { const emptyPercent = formatPercent(0, format); if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); - const emptyBar = '░'.repeat(barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${emptyBar}] ${emptyPercent}`); + const emptyBar = renderUsageProgressBar(0, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${emptyBar} ${emptyPercent}`); } if (isUsageSliderMode(displayMode)) { @@ -125,10 +122,9 @@ export class BlockTimerWidget implements Widget { } if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const progressBar = makeTimerProgressBar(percent, barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${progressBar}] ${formatPercent(percent, format)}`); + const progressBar = renderUsageProgressBar(percent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(percent, format)}`); } if (isUsageSliderMode(displayMode)) { diff --git a/src/widgets/ContextBar.ts b/src/widgets/ContextBar.ts index 2d6242ce1..8d30462be 100644 --- a/src/widgets/ContextBar.ts +++ b/src/widgets/ContextBar.ts @@ -18,6 +18,7 @@ import { import { formatTokens } from '../utils/renderer'; import { makeUsageProgressBar } from '../utils/usage'; +import { makeLineProgressBar } from './shared/progress-bar'; import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { makeSliderBar } from './shared/usage-display'; @@ -25,14 +26,6 @@ const LABEL = 'Context: '; type DisplayMode = 'progress' | 'progress-short' | 'slider' | 'slider-only' | 'line'; -const LINE_BAR_WIDTH = 16; - -// Thin bar for fonts and themes where block glyphs look heavy: heavy rule for used, light rule for free. -function makeLineBar(percent: number, width = LINE_BAR_WIDTH): string { - const filled = Math.round((percent / 100) * width); - return '━'.repeat(filled) + '─'.repeat(width - filled); -} - function getDisplayMode(item: WidgetItem): DisplayMode { const mode = item.metadata?.display; if (mode === 'progress' || mode === 'slider' || mode === 'slider-only' || mode === 'line') { @@ -112,7 +105,7 @@ export class ContextBarWidget implements Widget { return formatRawOrLabeledValue(item, this.getLabelPrefix(), sliderDisplay); } const barWidth = displayMode === 'progress' ? 32 : 16; - const previewBar = displayMode === 'line' ? makeLineBar(25) : makeUsageProgressBar(25, barWidth); + const previewBar = displayMode === 'line' ? makeLineProgressBar(25) : makeUsageProgressBar(25, barWidth); const previewDisplay = `${previewBar} ${usedDisplay}/${totalDisplay} (${percentDisplay})`; return formatRawOrLabeledValue(item, this.getLabelPrefix(), previewDisplay); } @@ -144,7 +137,7 @@ export class ContextBarWidget implements Widget { } const barWidth = displayMode === 'progress' ? 32 : 16; - const bar = displayMode === 'line' ? makeLineBar(clampedPercent) : makeUsageProgressBar(clampedPercent, barWidth); + const bar = displayMode === 'line' ? makeLineProgressBar(clampedPercent) : makeUsageProgressBar(clampedPercent, barWidth); const display = `${bar} ${usedDisplay}/${totalDisplay} (${percentDisplay})`; return formatRawOrLabeledValue(item, this.getLabelPrefix(), display); diff --git a/src/widgets/ExtraUsageUtilization.ts b/src/widgets/ExtraUsageUtilization.ts index da4916fd6..4327ccfdc 100644 --- a/src/widgets/ExtraUsageUtilization.ts +++ b/src/widgets/ExtraUsageUtilization.ts @@ -18,7 +18,6 @@ import { getUsageErrorMessage } from '../utils/usage'; import { EXTRA_USAGE_DISABLED_HIDEABLE_STATE } from './shared/extra-usage-disabled'; import { isHidden } from './shared/hideable'; -import { makeTimerProgressBar } from './shared/progress-bar'; import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { USAGE_NO_DATA_HIDEABLE_STATE, @@ -26,11 +25,11 @@ import { getUsageDisplayMode, getUsageDisplayModifierText, getUsagePercentCustomKeybinds, - getUsageProgressBarWidth, isUsageInverted, isUsageProgressMode, isUsageSliderMode, makeSliderBar, + renderUsageProgressBar, toggleUsageInverted } from './shared/usage-display'; @@ -87,9 +86,8 @@ export class ExtraUsageUtilizationWidget implements Widget { const renderedPercent = inverted ? 100 - previewPercent : previewPercent; if (isUsageProgressMode(displayMode)) { - const width = getUsageProgressBarWidth(displayMode); - const progressBar = makeTimerProgressBar(renderedPercent, width); - return formatRawOrLabeledValue(item, this.getLabelPrefix(), `[${progressBar}] ${formatPercent(renderedPercent, format)}`); + const progressBar = renderUsageProgressBar(renderedPercent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(), `${progressBar} ${formatPercent(renderedPercent, format)}`); } if (isUsageSliderMode(displayMode)) { @@ -122,9 +120,8 @@ export class ExtraUsageUtilizationWidget implements Widget { const renderedPercent = inverted ? 100 - percent : percent; if (isUsageProgressMode(displayMode)) { - const width = getUsageProgressBarWidth(displayMode); - const progressBar = makeTimerProgressBar(renderedPercent, width); - return formatRawOrLabeledValue(item, this.getLabelPrefix(), `[${progressBar}] ${formatPercent(renderedPercent, format)}`); + const progressBar = renderUsageProgressBar(renderedPercent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(), `${progressBar} ${formatPercent(renderedPercent, format)}`); } if (isUsageSliderMode(displayMode)) { diff --git a/src/widgets/WeeklyResetTimer.ts b/src/widgets/WeeklyResetTimer.ts index 8803c20a1..78611066a 100644 --- a/src/widgets/WeeklyResetTimer.ts +++ b/src/widgets/WeeklyResetTimer.ts @@ -31,7 +31,6 @@ import { isMetadataFlagEnabled, toggleMetadataFlag } from './shared/metadata'; -import { makeTimerProgressBar } from './shared/progress-bar'; import { formatRawOrLabeledValue } from './shared/raw-or-labeled'; import { TIMEZONE_EDITOR_ACTION, @@ -43,7 +42,6 @@ import { getUsageDisplayMode, getUsageLocale, getUsageLocaleModifier, - getUsageProgressBarWidth, getUsageTimerCustomKeybinds, getUsageTimezone, getUsageTimezoneModifier, @@ -55,6 +53,7 @@ import { isUsageSliderMode, isUsageWeekdayEnabled, makeSliderBar, + renderUsageProgressBar, toggleUsageCompact, toggleUsageDateMode, toggleUsageHourFormat, @@ -91,6 +90,8 @@ function getWeeklyResetModifierText(item: WidgetItem): string | undefined { modifiers.push('short bar'); } else if (displayMode === 'slider-only') { modifiers.push('short bar only'); + } else if (displayMode === 'line') { + modifiers.push('line bar'); } if (isUsageInverted(item)) { @@ -195,9 +196,8 @@ export class WeeklyResetTimerWidget implements Widget { const previewPercent = inverted ? 90.0 : 10.0; if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); - const progressBar = makeTimerProgressBar(previewPercent, barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${progressBar}] ${formatPercent(previewPercent, format)}`); + const progressBar = renderUsageProgressBar(previewPercent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(previewPercent, format)}`); } if (isUsageSliderMode(displayMode)) { @@ -243,10 +243,9 @@ export class WeeklyResetTimerWidget implements Widget { } if (isUsageProgressMode(displayMode)) { - const barWidth = getUsageProgressBarWidth(displayMode); const percent = inverted ? window.remainingPercent : window.elapsedPercent; - const progressBar = makeTimerProgressBar(percent, barWidth); - return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `[${progressBar}] ${formatPercent(percent, format)}`); + const progressBar = renderUsageProgressBar(percent, displayMode); + return formatRawOrLabeledValue(item, this.getLabelPrefix(item), `${progressBar} ${formatPercent(percent, format)}`); } if (isUsageSliderMode(displayMode)) { diff --git a/src/widgets/__tests__/ContextPercentage.test.ts b/src/widgets/__tests__/ContextPercentage.test.ts index 0f2620ae5..1628c2d7e 100644 --- a/src/widgets/__tests__/ContextPercentage.test.ts +++ b/src/widgets/__tests__/ContextPercentage.test.ts @@ -139,10 +139,12 @@ describe('ContextPercentageWidget', () => { const slider = widget.handleEditorAction('toggle-slider', base); const sliderOnly = widget.handleEditorAction('toggle-slider', slider ?? base); - const none = widget.handleEditorAction('toggle-slider', sliderOnly ?? base); + const line = widget.handleEditorAction('toggle-slider', sliderOnly ?? base); + const none = widget.handleEditorAction('toggle-slider', line ?? base); expect(slider?.metadata?.display).toBe('slider'); expect(sliderOnly?.metadata?.display).toBe('slider-only'); + expect(line?.metadata?.display).toBe('line'); expect(none?.metadata?.display).toBeUndefined(); }); diff --git a/src/widgets/__tests__/helpers/usage-widget-suites.ts b/src/widgets/__tests__/helpers/usage-widget-suites.ts index 9ec6790a2..4106e58b3 100644 --- a/src/widgets/__tests__/helpers/usage-widget-suites.ts +++ b/src/widgets/__tests__/helpers/usage-widget-suites.ts @@ -198,7 +198,7 @@ export function runUsagePercentWidgetSuite(conf const updated = widget.handleEditorAction('toggle-progress', { ...config.baseItem, metadata: { - display: 'slider-only', + display: 'line', invert: 'true', cursor: 'true' } @@ -217,12 +217,14 @@ export function runUsagePercentWidgetSuite(conf const third = widget.handleEditorAction('toggle-progress', second ?? config.baseItem); const fourth = widget.handleEditorAction('toggle-progress', third ?? config.baseItem); const fifth = widget.handleEditorAction('toggle-progress', fourth ?? config.baseItem); + const sixth = widget.handleEditorAction('toggle-progress', fifth ?? config.baseItem); expect(first?.metadata?.display).toBe('progress'); expect(second?.metadata?.display).toBe('progress-short'); expect(third?.metadata?.display).toBe('slider'); expect(fourth?.metadata?.display).toBe('slider-only'); - expect(fifth?.metadata?.display).toBe('time'); + expect(fifth?.metadata?.display).toBe('line'); + expect(sixth?.metadata?.display).toBe('time'); }); it('toggles invert metadata and shows used/remaining editor modifiers', () => { @@ -290,7 +292,7 @@ export function runUsageTimerEditorSuite { const widget = config.createWidget(); - const lastBarMode = config.supportsSliderMode ? 'slider-only' : 'progress-short'; + const lastBarMode = 'line'; const updated = widget.handleEditorAction('toggle-progress', { ...config.baseItem, metadata: { @@ -316,12 +318,16 @@ export function runUsageTimerEditorSuite { + beforeEach(() => { + vi.spyOn(Date, 'now').mockReturnValue(NOW); + }); + afterEach(() => vi.restoreAllMocks()); + + for (const { widget, type, label, preview, cursor } of cases) { + describe(type, () => { + const item: WidgetItem = { id: type, type, metadata: { display: 'line' } }; + + it('renders live usage and its preview as an unbracketed 16-cell line', () => { + expect(widget.render(item, context, DEFAULT_SETTINGS)).toBe(`${label}━━━━──────────── 25.0%`); + expect(widget.render(item, { isPreview: true }, DEFAULT_SETTINGS)).toBe(label + preview); + expect(widget.getEditorDisplay(item).modifierText).toContain('line bar'); + }); + + it('preserves fill inversion, label overrides, raw values, and number formatting', () => { + const inverted: WidgetItem = { ...item, metadata: { display: 'line', invert: 'true', label: 'Custom ' }, numberFormat: { decimals: 2 } }; + expect(widget.render(inverted, context, DEFAULT_SETTINGS)).toBe('Custom ━━━━━━━━━━━━──── 75.00%'); + expect(widget.render({ ...inverted, rawValue: true }, context, DEFAULT_SETTINGS)).toBe('━━━━━━━━━━━━──── 75.00%'); + }); + + it('offers the same controls as medium bars and retains cursor behavior', () => { + const medium: WidgetItem = { ...item, metadata: { display: 'progress-short' } }; + expect(widget.getCustomKeybinds(item)).toEqual(widget.getCustomKeybinds(medium)); + const withCursor: WidgetItem = { ...item, metadata: { display: 'line', cursor: 'true' } }; + expect(widget.render(withCursor, context, DEFAULT_SETTINGS)).toBe( + label + (cursor ? '━━━━│─────────── 25.0%' : '━━━━──────────── 25.0%') + ); + const inverted: WidgetItem = { ...item, metadata: { display: 'line', cursor: 'true', invert: 'true' } }; + expect(widget.render(inverted, context, DEFAULT_SETTINGS)).toBe( + label + (cursor ? '━━━━━━━━━━━━│─── 75.0%' : '━━━━━━━━━━━━──── 75.0%') + ); + }); + + it('appends line mode to the cycle and returns to text with the existing metadata cleanup', () => { + const last: WidgetItem = { ...item, metadata: { display: 'slider-only', invert: 'true', cursor: 'true', label: 'Custom ' } }; + const line = widget.handleEditorAction('toggle-progress', last); + expect(line).not.toBeNull(); + expect(line?.metadata).toEqual({ display: 'line', invert: 'true', cursor: 'true', label: 'Custom ' }); + const text = widget.handleEditorAction('toggle-progress', line ?? item); + expect(text).not.toBeNull(); + expect(text?.metadata?.display).toBe('time'); + expect(text?.metadata?.cursor).toBeUndefined(); + expect(text?.metadata?.label).toBe('Custom '); + expect(text?.metadata?.invert).toBe(type.includes('timer') ? undefined : 'true'); + }); + }); + } + + it('renders an empty line for an inactive block and retains no-data hiding', () => { + const widget = new BlockTimerWidget(); + const item: WidgetItem = { id: 'block', type: 'block-timer', metadata: { display: 'line' } }; + expect(widget.render(item, {}, DEFAULT_SETTINGS)).toBe('Block ──────────────── 0.0%'); + expect(widget.render({ ...item, metadata: { display: 'line', hide: 'no-data' } }, {}, DEFAULT_SETTINGS)).toBeNull(); + }); +}); + +describe('context line bars', () => { + beforeEach(() => { + vi.spyOn(claudeSettings, 'getAutoCompactConfig').mockReturnValue({}); + }); + afterEach(() => vi.restoreAllMocks()); + + it.each([ + { widget: new ContextPercentageWidget(), type: 'context-percentage', live: 'Ctx Used: ━━━───────────── 20.0%', remaining: '━━━━━━━━━━━━━─── 80.0%', preview: 'Ctx Used: ━─────────────── 9.3%' }, + { widget: new ContextPercentageUsableWidget(), type: 'context-percentage-usable', live: 'Ctx(u) Used: ━━━━──────────── 25.0%', remaining: '━━━━━━━━━━━━──── 75.0%', preview: 'Ctx(u) Used: ━━────────────── 11.6%' } + ])('renders $type live and preview values, with remaining mode and cycle support', ({ widget, type, live, remaining, preview }) => { + const item: WidgetItem = { id: type, type, metadata: { display: 'line' } }; + expect(widget.render(item, context, DEFAULT_SETTINGS)).toBe(live); + expect(widget.render(item, { isPreview: true }, DEFAULT_SETTINGS)).toBe(preview); + expect(widget.render({ ...item, rawValue: true, metadata: { display: 'line', inverse: 'true' } }, context, DEFAULT_SETTINGS)).toBe(remaining); + expect(widget.getEditorDisplay(item).modifierText).toBe('(line bar)'); + const line = widget.handleEditorAction('toggle-slider', { ...item, metadata: { display: 'slider-only', inverse: 'true' } }); + expect(line).not.toBeNull(); + expect(line?.metadata).toEqual({ display: 'line', inverse: 'true' }); + expect(widget.handleEditorAction('toggle-slider', line ?? item)?.metadata).toEqual({ inverse: 'true' }); + }); + + it('retains the original Context Bar line appearance in live and preview output', () => { + const widget = new ContextBarWidget(); + const item: WidgetItem = { id: 'context-bar', type: 'context-bar', metadata: { display: 'line' } }; + expect(widget.render(item, context, DEFAULT_SETTINGS)).toBe('Context: ━━━───────────── 40k/200k (20%)'); + expect(widget.render(item, { isPreview: true }, DEFAULT_SETTINGS)).toBe('Context: ━━━━──────────── 50k/200k (25%)'); + }); +}); diff --git a/src/widgets/__tests__/shared/progress-bar.test.ts b/src/widgets/__tests__/shared/progress-bar.test.ts index fe0590074..e9fb39876 100644 --- a/src/widgets/__tests__/shared/progress-bar.test.ts +++ b/src/widgets/__tests__/shared/progress-bar.test.ts @@ -4,7 +4,10 @@ import { it } from 'vitest'; -import { makeTimerProgressBar } from '../../shared/progress-bar'; +import { + makeLineProgressBar, + makeTimerProgressBar +} from '../../shared/progress-bar'; describe('makeTimerProgressBar', () => { it('renders a fully empty bar at 0%', () => { @@ -75,3 +78,28 @@ describe('makeTimerProgressBar', () => { }); }); }); + +describe('makeLineProgressBar', () => { + it.each([ + [-10, '────────────────'], + [0, '────────────────'], + [25, '━━━━────────────'], + [50, '━━━━━━━━────────'], + [73.9, '━━━━━━━━━━━━────'], + [100, '━━━━━━━━━━━━━━━━'], + [150, '━━━━━━━━━━━━━━━━'] + ])('renders and clamps %s percent', (percent, expected) => { + expect(makeLineProgressBar(percent)).toBe(expected); + }); + + it.each([ + [-10, '│━━━━━━━────────'], + [0, '│━━━━━━━────────'], + [25, '━━━━│━━━────────'], + [75, '━━━━━━━━────│───'], + [100, '━━━━━━━━───────│'], + [150, '━━━━━━━━───────│'] + ])('positions and clamps the time cursor at %s percent', (cursorPercent, expected) => { + expect(makeLineProgressBar(50, 16, { cursorPercent })).toBe(expected); + }); +}); diff --git a/src/widgets/shared/__tests__/usage-display.test.ts b/src/widgets/shared/__tests__/usage-display.test.ts index 235ddb48f..aa3d48a67 100644 --- a/src/widgets/shared/__tests__/usage-display.test.ts +++ b/src/widgets/shared/__tests__/usage-display.test.ts @@ -55,22 +55,26 @@ describe('cycleUsageDisplayMode with slider', () => { const third = cycleUsageDisplayMode(second, [], true); const fourth = cycleUsageDisplayMode(third, [], true); const fifth = cycleUsageDisplayMode(fourth, [], true); + const sixth = cycleUsageDisplayMode(fifth, [], true); expect(first.metadata?.display).toBe('progress'); expect(second.metadata?.display).toBe('progress-short'); expect(third.metadata?.display).toBe('slider'); expect(fourth.metadata?.display).toBe('slider-only'); - expect(fifth.metadata?.display).toBe('time'); + expect(fifth.metadata?.display).toBe('line'); + expect(sixth.metadata?.display).toBe('time'); }); it('skips slider modes when includeSlider is false', () => { const first = cycleUsageDisplayMode(base); const second = cycleUsageDisplayMode(first); const third = cycleUsageDisplayMode(second); + const fourth = cycleUsageDisplayMode(third); expect(first.metadata?.display).toBe('progress'); expect(second.metadata?.display).toBe('progress-short'); - expect(third.metadata?.display).toBe('time'); + expect(third.metadata?.display).toBe('line'); + expect(fourth.metadata?.display).toBe('time'); }); it('keeps cursor metadata through slider modes and clears it when returning to time mode', () => { @@ -83,12 +87,14 @@ describe('cycleUsageDisplayMode with slider', () => { const third = cycleUsageDisplayMode(second, [], true); const fourth = cycleUsageDisplayMode(third, [], true); const fifth = cycleUsageDisplayMode(fourth, [], true); + const sixth = cycleUsageDisplayMode(fifth, [], true); expect(first.metadata?.cursor).toBe('true'); expect(second.metadata?.cursor).toBe('true'); expect(third.metadata?.cursor).toBe('true'); expect(fourth.metadata?.cursor).toBe('true'); - expect(fifth.metadata?.cursor).toBeUndefined(); + expect(fifth.metadata?.cursor).toBe('true'); + expect(sixth.metadata?.cursor).toBeUndefined(); }); }); diff --git a/src/widgets/shared/context-slider.ts b/src/widgets/shared/context-slider.ts index 253bf8c94..f86281916 100644 --- a/src/widgets/shared/context-slider.ts +++ b/src/widgets/shared/context-slider.ts @@ -5,15 +5,16 @@ import type { } from '../../types/Widget'; import { formatPercent } from '../../utils/number-format'; +import { makeLineProgressBar } from './progress-bar'; import { makeSliderBar } from './usage-display'; -export type ContextSliderMode = 'none' | 'slider' | 'slider-only'; +export type ContextSliderMode = 'none' | 'slider' | 'slider-only' | 'line'; const SLIDER_TOGGLE_KEYBIND: CustomKeybind = { key: 'p', label: '(p)rogress toggle', action: 'toggle-slider' }; export function getContextSliderMode(item: WidgetItem): ContextSliderMode { const mode = item.metadata?.display; - if (mode === 'slider' || mode === 'slider-only') { + if (mode === 'slider' || mode === 'slider-only' || mode === 'line') { return mode; } return 'none'; @@ -25,7 +26,9 @@ export function cycleContextSliderMode(item: WidgetItem): WidgetItem { ? 'slider' : currentMode === 'slider' ? 'slider-only' - : 'none'; + : currentMode === 'slider-only' + ? 'line' + : 'none'; if (nextMode === 'none') { const nextMetadata = { ...(item.metadata ?? {}) }; @@ -49,6 +52,9 @@ export function renderContextSlider(mode: ContextSliderMode, percent: number, fo if (mode === 'none') { return null; } + if (mode === 'line') { + return `${makeLineProgressBar(percent)} ${formatPercent(percent, format)}`; + } const slider = makeSliderBar(percent); if (mode === 'slider') { return `${slider} ${formatPercent(percent, format)}`; @@ -64,6 +70,9 @@ export function getContextSliderModifierText(item: WidgetItem): string | undefin if (mode === 'slider-only') { return '(short bar only)'; } + if (mode === 'line') { + return '(line bar)'; + } return undefined; } diff --git a/src/widgets/shared/progress-bar.ts b/src/widgets/shared/progress-bar.ts index 6148447d8..b2ea5ef5a 100644 --- a/src/widgets/shared/progress-bar.ts +++ b/src/widgets/shared/progress-bar.ts @@ -4,6 +4,20 @@ export function makeTimerProgressBar( percent: number, width: number, options?: TimerProgressBarOptions +): string { + return makeProgressBar(percent, width, '█', '░', options); +} + +export function makeLineProgressBar(percent: number, width = 16, options?: TimerProgressBarOptions): string { + return makeProgressBar(percent, width, '━', '─', options); +} + +function makeProgressBar( + percent: number, + width: number, + filledGlyph: string, + emptyGlyph: string, + options?: TimerProgressBarOptions ): string { const clampedPercent = Math.max(0, Math.min(100, percent)); const filledWidth = Math.round((clampedPercent / 100) * width); @@ -17,9 +31,9 @@ export function makeTimerProgressBar( if (i === cursorPos) { bar += '│'; } else if (i < filledWidth) { - bar += '█'; + bar += filledGlyph; } else { - bar += '░'; + bar += emptyGlyph; } } diff --git a/src/widgets/shared/usage-display.ts b/src/widgets/shared/usage-display.ts index 78f8c64e2..1f7c4ebe0 100644 --- a/src/widgets/shared/usage-display.ts +++ b/src/widgets/shared/usage-display.ts @@ -15,8 +15,13 @@ import { removeMetadataKeys, toggleMetadataFlag } from './metadata'; +import type { TimerProgressBarOptions } from './progress-bar'; +import { + makeLineProgressBar, + makeTimerProgressBar +} from './progress-bar'; -export type UsageDisplayMode = 'time' | 'progress' | 'progress-short' | 'slider' | 'slider-only'; +export type UsageDisplayMode = 'time' | 'progress' | 'progress-short' | 'slider' | 'slider-only' | 'line'; // Shared by the usage percentage widgets and the reset timers, which render the // same error placeholders @@ -56,14 +61,14 @@ const LOCALE_KEYBIND: CustomKeybind = { key: 'l', label: '(l)ocale', action: 'ed export function getUsageDisplayMode(item: WidgetItem): UsageDisplayMode { const mode = item.metadata?.display; - if (mode === 'progress' || mode === 'progress-short' || mode === 'slider' || mode === 'slider-only') { + if (mode === 'progress' || mode === 'progress-short' || mode === 'slider' || mode === 'slider-only' || mode === 'line') { return mode; } return 'time'; } export function isUsageProgressMode(mode: UsageDisplayMode): boolean { - return mode === 'progress' || mode === 'progress-short'; + return mode === 'progress' || mode === 'progress-short' || mode === 'line'; } export function isUsageSliderMode(mode: UsageDisplayMode): boolean { @@ -97,6 +102,14 @@ export function getUsageProgressBarWidth(mode: UsageDisplayMode): number { return mode === 'progress' ? 32 : 16; } +// Block modes keep their brackets; the thin line uses the same medium width. +export function renderUsageProgressBar(percent: number, mode: UsageDisplayMode, options?: TimerProgressBarOptions): string { + const width = getUsageProgressBarWidth(mode); + return mode === 'line' + ? makeLineProgressBar(percent, width, options) + : `[${makeTimerProgressBar(percent, width, options)}]`; +} + export function isUsageInverted(item: WidgetItem): boolean { return isMetadataFlagEnabled(item, 'invert'); } @@ -225,6 +238,8 @@ export function getUsageDisplayModifierText( modifiers.push('short bar'); } else if (mode === 'slider-only') { modifiers.push('short bar only'); + } else if (mode === 'line') { + modifiers.push('line bar'); } if (options.showUsageDirection) { @@ -274,13 +289,17 @@ export function cycleUsageDisplayMode(item: WidgetItem, disabledInProgressKeys: ? 'slider' : currentMode === 'slider' ? 'slider-only' - : 'time'; + : currentMode === 'slider-only' + ? 'line' + : 'time'; } else { nextMode = currentMode === 'time' ? 'progress' : currentMode === 'progress' ? 'progress-short' - : 'time'; + : currentMode === 'progress-short' + ? 'line' + : 'time'; } const keysToRemove = nextMode === 'time' ? (preserveInvertInTime ? ['cursor'] : ['invert', 'cursor']) : disabledInProgressKeys; diff --git a/src/widgets/shared/usage-percent-widget.ts b/src/widgets/shared/usage-percent-widget.ts index 3119f7b45..c05555bfd 100644 --- a/src/widgets/shared/usage-percent-widget.ts +++ b/src/widgets/shared/usage-percent-widget.ts @@ -23,19 +23,18 @@ import { import type { UsageWindowMetrics } from '../../utils/usage-types'; import { isHidden } from './hideable'; -import { makeTimerProgressBar } from './progress-bar'; import { formatRawOrLabeledValue } from './raw-or-labeled'; import { USAGE_NO_DATA_HIDEABLE_STATE, cycleUsageDisplayMode, getUsageDisplayMode, getUsageDisplayModifierText, - getUsageProgressBarWidth, isUsageCursorEnabled, isUsageInverted, isUsageProgressMode, isUsageSliderMode, makeSliderBar, + renderUsageProgressBar, toggleUsageCursor, toggleUsageInverted } from './usage-display'; @@ -134,9 +133,8 @@ function renderUsageDisplay( const displayMode = getUsageDisplayMode(item); if (isUsageProgressMode(displayMode)) { - const width = getUsageProgressBarWidth(displayMode); - const progressBar = makeTimerProgressBar(percent, width, getCursorOptions()); - const progressDisplay = `[${progressBar}] ${formatPercent(percent, format)}`; + const progressBar = renderUsageProgressBar(percent, displayMode, getCursorOptions()); + const progressDisplay = `${progressBar} ${formatPercent(percent, format)}`; return formatRawOrLabeledValue(item, label, progressDisplay); }