devflow-kit 1.7.0 → 1.8.0

package/dist/hud/colors.js

@@ -0,0 +1,62 @@
+/**
+ * ANSI color helpers — no dependencies, precompiled escape sequences.
+ * Used by HUD components for direct terminal output (not @clack/prompts).
+ */
+const ESC = '\x1b[';
+const RESET = `${ESC}0m`;
+export function bold(s) {
+    return `${ESC}1m${s}${RESET}`;
+}
+export function dim(s) {
+    return `${ESC}2m${s}${RESET}`;
+}
+export function red(s) {
+    return `${ESC}31m${s}${RESET}`;
+}
+export function green(s) {
+    return `${ESC}32m${s}${RESET}`;
+}
+export function yellow(s) {
+    return `${ESC}33m${s}${RESET}`;
+}
+export function blue(s) {
+    return `${ESC}34m${s}${RESET}`;
+}
+export function magenta(s) {
+    return `${ESC}35m${s}${RESET}`;
+}
+export function cyan(s) {
+    return `${ESC}36m${s}${RESET}`;
+}
+export function gray(s) {
+    return `${ESC}90m${s}${RESET}`;
+}
+export function white(s) {
+    return `${ESC}37m${s}${RESET}`;
+}
+export function orange(s) {
+    return `${ESC}38;5;208m${s}${RESET}`;
+}
+export function brightRed(s) {
+    return `${ESC}91m${s}${RESET}`;
+}
+export function boldRed(s) {
+    return `${ESC}1;31m${s}${RESET}`;
+}
+export function bgGreen(s) {
+    return `${ESC}42m${s}${RESET}`;
+}
+export function bgYellow(s) {
+    return `${ESC}43m${s}${RESET}`;
+}
+export function bgRed(s) {
+    return `${ESC}41m${s}${RESET}`;
+}
+export function truncate(s, max) {
+    return s.length > max ? s.slice(0, max - 1) + '\u2026' : s;
+}
+const ANSI_PATTERN = /\x1b\[[0-9;]*m/g;
+export function stripAnsi(s) {
+    return s.replace(ANSI_PATTERN, '');
+}
+//# sourceMappingURL=colors.js.map

package/dist/hud/components/config-counts.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentResult, GatherContext, ConfigCountsData } from '../types.js';
+/**
+ * Gather configuration counts for the configCounts component.
+ * Exported for use by the main HUD entry point.
+ */
+export declare function gatherConfigCounts(cwd: string): ConfigCountsData;
+export default function configCounts(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=config-counts.d.ts.map

package/dist/hud/components/config-counts.js

@@ -0,0 +1,91 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+import { dim } from '../colors.js';
+function countClaudeMdFiles(cwd) {
+    let count = 0;
+    // Check project CLAUDE.md
+    if (fs.existsSync(path.join(cwd, 'CLAUDE.md')))
+        count++;
+    // Check user CLAUDE.md
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR ||
+        path.join(process.env.HOME || homedir(), '.claude');
+    if (fs.existsSync(path.join(claudeDir, 'CLAUDE.md')))
+        count++;
+    return count;
+}
+function countFromSettings(settingsPath) {
+    try {
+        const settings = JSON.parse(fs.readFileSync(settingsPath, 'utf-8'));
+        const mcpServers = settings.mcpServers
+            ? Object.keys(settings.mcpServers).length
+            : 0;
+        let hooks = 0;
+        if (settings.hooks) {
+            const hooksObj = settings.hooks;
+            for (const event of Object.values(hooksObj)) {
+                if (Array.isArray(event))
+                    hooks += event.length;
+            }
+        }
+        return { mcpServers, hooks };
+    }
+    catch {
+        return { mcpServers: 0, hooks: 0 };
+    }
+}
+/**
+ * Gather configuration counts for the configCounts component.
+ * Exported for use by the main HUD entry point.
+ */
+export function gatherConfigCounts(cwd) {
+    const claudeDir = process.env.CLAUDE_CONFIG_DIR ||
+        path.join(process.env.HOME || homedir(), '.claude');
+    const claudeMdFiles = countClaudeMdFiles(cwd);
+    // Count rules (.md/.mdc files in .claude/rules)
+    let rules = 0;
+    for (const rulesDir of [
+        path.join(cwd, '.claude', 'rules'),
+        path.join(claudeDir, 'rules'),
+    ]) {
+        try {
+            const files = fs.readdirSync(rulesDir);
+            rules += files.filter((f) => f.endsWith('.md') || f.endsWith('.mdc')).length;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    // Aggregate settings from user and project
+    const userSettings = countFromSettings(path.join(claudeDir, 'settings.json'));
+    const projectSettings = countFromSettings(path.join(cwd, '.claude', 'settings.json'));
+    return {
+        claudeMdFiles,
+        rules,
+        mcpServers: userSettings.mcpServers + projectSettings.mcpServers,
+        hooks: userSettings.hooks + projectSettings.hooks,
+    };
+}
+export default async function configCounts(ctx) {
+    if (!ctx.configCounts)
+        return null;
+    const { claudeMdFiles, rules: ruleCount, mcpServers, hooks: hookCount } = ctx.configCounts;
+    const skillCount = ctx.transcript?.skills.length ?? 0;
+    const parts = [];
+    if (claudeMdFiles > 0)
+        parts.push(`${claudeMdFiles} CLAUDE.md`);
+    if (ruleCount > 0)
+        parts.push(`${ruleCount} rules`);
+    if (mcpServers > 0)
+        parts.push(`${mcpServers} MCPs`);
+    if (hookCount > 0)
+        parts.push(`${hookCount} hooks`);
+    if (skillCount > 0)
+        parts.push(`${skillCount} skills`);
+    if (parts.length === 0)
+        return null;
+    const raw = parts.join(' \u00B7 ');
+    const text = parts.map((p) => dim(p)).join(dim(' \u00B7 '));
+    return { text, raw };
+}
+//# sourceMappingURL=config-counts.js.map

package/dist/hud/components/context-usage.d.ts

@@ -0,0 +1,8 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+/**
+ * Context window usage component.
+ * Visual bar with 3-tier color gradient matching usage-quota: green / yellow / red.
+ * At >85% appends token breakdown: (in: Nk).
+ */
+export default function contextUsage(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=context-usage.d.ts.map

package/dist/hud/components/context-usage.js

@@ -0,0 +1,49 @@
+import { dim, green, yellow, red } from '../colors.js';
+const BAR_WIDTH = 8;
+/**
+ * Context window usage component.
+ * Visual bar with 3-tier color gradient matching usage-quota: green / yellow / red.
+ * At >85% appends token breakdown: (in: Nk).
+ */
+export default async function contextUsage(ctx) {
+    const cw = ctx.stdin.context_window;
+    if (!cw)
+        return null;
+    let pct = null;
+    if (cw.used_percentage !== undefined) {
+        pct = Math.round(cw.used_percentage);
+    }
+    else if (cw.context_window_size && cw.current_usage?.input_tokens !== undefined) {
+        pct = Math.round((cw.current_usage.input_tokens / cw.context_window_size) * 100);
+    }
+    if (pct === null)
+        return null;
+    const filled = Math.round((pct / 100) * BAR_WIDTH);
+    const empty = BAR_WIDTH - filled;
+    let colorFn;
+    if (pct < 50) {
+        colorFn = green;
+    }
+    else if (pct < 80) {
+        colorFn = yellow;
+    }
+    else {
+        colorFn = red;
+    }
+    const filledBar = '\u2588'.repeat(filled);
+    const emptyBar = '\u2591'.repeat(empty);
+    let suffix = '';
+    if (pct > 85 && cw.current_usage?.input_tokens !== undefined) {
+        const inK = Math.round(cw.current_usage.input_tokens / 1000);
+        suffix = ` (in: ${inK}k)`;
+    }
+    const raw = `Current Session ${filledBar}${emptyBar} ${pct}%${suffix}`;
+    const text = dim('Current Session ') +
+        colorFn(filledBar) +
+        dim(emptyBar) +
+        ' ' +
+        colorFn(`${pct}%`) +
+        (suffix ? dim(suffix) : '');
+    return { text, raw };
+}
+//# sourceMappingURL=context-usage.js.map

package/dist/hud/components/diff-stats.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function diffStats(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=diff-stats.d.ts.map

package/dist/hud/components/diff-stats.js

@@ -0,0 +1,36 @@
+import { dim, green, red } from '../colors.js';
+export default async function diffStats(ctx) {
+    if (!ctx.git)
+        return null;
+    const { filesChanged, additions, deletions } = ctx.git;
+    if (filesChanged === 0 && additions === 0 && deletions === 0)
+        return null;
+    const filePart = filesChanged > 0
+        ? `${filesChanged} file${filesChanged === 1 ? '' : 's'}`
+        : '';
+    const lineParts = [];
+    if (additions > 0)
+        lineParts.push(`+${additions}`);
+    if (deletions > 0)
+        lineParts.push(`-${deletions}`);
+    const sections = [];
+    const rawSections = [];
+    if (filePart) {
+        sections.push(dim(filePart));
+        rawSections.push(filePart);
+    }
+    if (lineParts.length > 0) {
+        const lineText = lineParts
+            .map((p) => (p.startsWith('+') ? green(p) : red(p)))
+            .join(' ');
+        sections.push(lineText);
+        rawSections.push(lineParts.join(' '));
+    }
+    if (sections.length === 0)
+        return null;
+    return {
+        text: sections.join(dim(' \u00B7 ')),
+        raw: rawSections.join(' \u00B7 '),
+    };
+}
+//# sourceMappingURL=diff-stats.js.map

package/dist/hud/components/directory.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function directory(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=directory.d.ts.map

package/dist/hud/components/directory.js

@@ -0,0 +1,10 @@
+import { bold, white } from '../colors.js';
+import * as path from 'node:path';
+export default async function directory(ctx) {
+    const cwd = ctx.stdin.cwd;
+    if (!cwd)
+        return null;
+    const name = path.basename(cwd);
+    return { text: bold(white(name)), raw: name };
+}
+//# sourceMappingURL=directory.js.map

package/dist/hud/components/git-ahead-behind.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function gitAheadBehind(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=git-ahead-behind.d.ts.map

package/dist/hud/components/git-ahead-behind.js

@@ -0,0 +1,16 @@
+import { dim } from '../colors.js';
+export default async function gitAheadBehind(ctx) {
+    if (!ctx.git)
+        return null;
+    const { ahead, behind } = ctx.git;
+    if (ahead === 0 && behind === 0)
+        return null;
+    const rawParts = [];
+    if (ahead > 0)
+        rawParts.push(`${ahead}\u2191`);
+    if (behind > 0)
+        rawParts.push(`${behind}\u2193`);
+    const raw = rawParts.join(' ');
+    return { text: dim(raw), raw };
+}
+//# sourceMappingURL=git-ahead-behind.js.map

package/dist/hud/components/git-branch.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function gitBranch(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=git-branch.d.ts.map

package/dist/hud/components/git-branch.js

@@ -0,0 +1,14 @@
+import { white, yellow, green } from '../colors.js';
+export default async function gitBranch(ctx) {
+    if (!ctx.git)
+        return null;
+    const dirtyMark = ctx.git.dirty ? '*' : '';
+    const stagedMark = ctx.git.staged ? '+' : '';
+    const indicator = dirtyMark + stagedMark;
+    const text = white(ctx.git.branch) +
+        (dirtyMark ? yellow(dirtyMark) : '') +
+        (stagedMark ? green(stagedMark) : '');
+    const raw = ctx.git.branch + indicator;
+    return { text, raw };
+}
+//# sourceMappingURL=git-branch.js.map

package/dist/hud/components/model.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function model(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=model.d.ts.map

package/dist/hud/components/model.js

@@ -0,0 +1,21 @@
+import { dim, white } from '../colors.js';
+export default async function model(ctx) {
+    const name = ctx.stdin.model?.display_name;
+    if (!name)
+        return null;
+    // Strip "Claude " prefix and trailing context info like "(1M context)" for brevity
+    const short = name
+        .replace(/^Claude\s+/i, '')
+        .replace(/\s*\(\d+[KkMm]\s*context\)\s*$/, '');
+    const cwSize = ctx.stdin.context_window?.context_window_size;
+    let sizeStr = '';
+    if (cwSize) {
+        sizeStr =
+            cwSize >= 1_000_000
+                ? ` [${Math.round(cwSize / 1_000_000)}m]`
+                : ` [${Math.round(cwSize / 1000)}k]`;
+    }
+    const raw = short + sizeStr;
+    return { text: white(short) + (sizeStr ? dim(sizeStr) : ''), raw };
+}
+//# sourceMappingURL=model.js.map

package/dist/hud/components/release-info.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function releaseInfo(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=release-info.d.ts.map

package/dist/hud/components/release-info.js

@@ -0,0 +1,9 @@
+import { dim } from '../colors.js';
+export default async function releaseInfo(ctx) {
+    if (!ctx.git?.lastTag)
+        return null;
+    const { lastTag, commitsSinceTag } = ctx.git;
+    const raw = commitsSinceTag > 0 ? `${lastTag} +${commitsSinceTag}` : lastTag;
+    return { text: dim(raw), raw };
+}
+//# sourceMappingURL=release-info.js.map

package/dist/hud/components/session-cost.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function sessionCost(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=session-cost.d.ts.map

package/dist/hud/components/session-cost.js

@@ -0,0 +1,9 @@
+import { dim } from '../colors.js';
+export default async function sessionCost(ctx) {
+    const cost = ctx.stdin.cost?.total_cost_usd;
+    if (cost == null)
+        return null;
+    const formatted = `$${cost.toFixed(2)}`;
+    return { text: dim(formatted), raw: formatted };
+}
+//# sourceMappingURL=session-cost.js.map

package/dist/hud/components/session-duration.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function sessionDuration(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=session-duration.d.ts.map

package/dist/hud/components/session-duration.js

@@ -0,0 +1,18 @@
+import { dim } from '../colors.js';
+export default async function sessionDuration(ctx) {
+    if (!ctx.sessionStartTime)
+        return null;
+    const elapsed = Math.floor((Date.now() - ctx.sessionStartTime) / 1000);
+    const minutes = Math.floor(elapsed / 60);
+    const hours = Math.floor(minutes / 60);
+    let label;
+    if (hours > 0) {
+        label = `${hours}h ${minutes % 60}m`;
+    }
+    else {
+        label = `${minutes}m`;
+    }
+    const text = `\u23F1 ${label}`;
+    return { text: dim(text), raw: text };
+}
+//# sourceMappingURL=session-duration.js.map

package/dist/hud/components/todo-progress.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function todoProgress(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=todo-progress.d.ts.map

package/dist/hud/components/todo-progress.js

@@ -0,0 +1,11 @@
+import { dim } from '../colors.js';
+export default async function todoProgress(ctx) {
+    if (!ctx.transcript)
+        return null;
+    const { todos } = ctx.transcript;
+    if (todos.total === 0)
+        return null;
+    const label = `${todos.completed}/${todos.total} todos`;
+    return { text: dim(label), raw: label };
+}
+//# sourceMappingURL=todo-progress.js.map

package/dist/hud/components/usage-quota.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function usageQuota(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=usage-quota.d.ts.map

package/dist/hud/components/usage-quota.js

@@ -0,0 +1,45 @@
+import { green, yellow, red, dim } from '../colors.js';
+const BAR_WIDTH = 8;
+function renderBar(percent) {
+    const filled = Math.round((percent / 100) * BAR_WIDTH);
+    const empty = BAR_WIDTH - filled;
+    let colorFn;
+    if (percent < 50) {
+        colorFn = green;
+    }
+    else if (percent < 80) {
+        colorFn = yellow;
+    }
+    else {
+        colorFn = red;
+    }
+    const filledBar = '\u2588'.repeat(filled);
+    const emptyBar = '\u2591'.repeat(empty);
+    const text = colorFn(filledBar) +
+        dim(emptyBar) +
+        ' ' +
+        colorFn(`${percent}%`);
+    const raw = `${filledBar}${emptyBar} ${percent}%`;
+    return { text, raw };
+}
+export default async function usageQuota(ctx) {
+    if (!ctx.usage)
+        return null;
+    const { fiveHourPercent, sevenDayPercent } = ctx.usage;
+    const parts = [];
+    if (fiveHourPercent !== null) {
+        const bar = renderBar(Math.round(fiveHourPercent));
+        parts.push({ text: dim('5h ') + bar.text, raw: `5h ${bar.raw}` });
+    }
+    if (sevenDayPercent !== null) {
+        const bar = renderBar(Math.round(sevenDayPercent));
+        parts.push({ text: dim('7d ') + bar.text, raw: `7d ${bar.raw}` });
+    }
+    if (parts.length === 0)
+        return null;
+    const sep = dim(' \u00B7 ');
+    const text = dim('Session ') + parts.map((p) => p.text).join(sep);
+    const raw = 'Session ' + parts.map((p) => p.raw).join(' \u00B7 ');
+    return { text, raw };
+}
+//# sourceMappingURL=usage-quota.js.map

package/dist/hud/components/version-badge.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function versionBadge(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=version-badge.d.ts.map

package/dist/hud/components/version-badge.js

@@ -0,0 +1,80 @@
+import { execFile } from 'node:child_process';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { yellow } from '../colors.js';
+import { readCache, writeCache } from '../cache.js';
+const VERSION_CACHE_KEY = 'version-check';
+const VERSION_CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+function getCurrentVersion(devflowDir) {
+    // Try manifest.json first (most reliable for installed version)
+    try {
+        const manifestPath = path.join(devflowDir, 'manifest.json');
+        const manifest = JSON.parse(fs.readFileSync(manifestPath, 'utf-8'));
+        if (typeof manifest.version === 'string')
+            return manifest.version;
+    }
+    catch {
+        // Fall through
+    }
+    // Try package.json as fallback
+    try {
+        const pkgPath = path.join(path.dirname(new URL(import.meta.url).pathname), '..', '..', '..', 'package.json');
+        const pkg = JSON.parse(fs.readFileSync(pkgPath, 'utf-8'));
+        if (typeof pkg.version === 'string')
+            return pkg.version;
+    }
+    catch {
+        // Fall through
+    }
+    return null;
+}
+function fetchLatestVersion() {
+    return new Promise((resolve) => {
+        execFile('npm', ['view', 'devflow-kit', 'version', '--json'], { timeout: 5000 }, (err, stdout) => {
+            if (err) {
+                resolve(null);
+                return;
+            }
+            try {
+                const parsed = JSON.parse(stdout.trim());
+                resolve(typeof parsed === 'string' ? parsed : null);
+            }
+            catch {
+                const trimmed = stdout.trim();
+                resolve(trimmed || null);
+            }
+        });
+    });
+}
+function compareVersions(current, latest) {
+    const a = current.split('.').map(Number);
+    const b = latest.split('.').map(Number);
+    for (let i = 0; i < 3; i++) {
+        if ((a[i] || 0) < (b[i] || 0))
+            return -1;
+        if ((a[i] || 0) > (b[i] || 0))
+            return 1;
+    }
+    return 0;
+}
+export default async function versionBadge(ctx) {
+    const current = getCurrentVersion(ctx.devflowDir);
+    if (!current)
+        return null;
+    // Check cache
+    let info = readCache(VERSION_CACHE_KEY);
+    if (!info) {
+        const latest = await fetchLatestVersion();
+        if (latest) {
+            info = { current, latest };
+            writeCache(VERSION_CACHE_KEY, info, VERSION_CACHE_TTL);
+        }
+    }
+    if (info && compareVersions(info.current, info.latest) < 0) {
+        const badge = `\u2726 Devflow v${info.latest} \u00B7 update: npx devflow-kit init`;
+        return { text: yellow(badge), raw: badge };
+    }
+    // Don't show version when up to date
+    return null;
+}
+//# sourceMappingURL=version-badge.js.map

package/dist/hud/components/worktree-count.d.ts

@@ -0,0 +1,3 @@
+import type { ComponentResult, GatherContext } from '../types.js';
+export default function worktreeCount(ctx: GatherContext): Promise<ComponentResult | null>;
+//# sourceMappingURL=worktree-count.d.ts.map

package/dist/hud/components/worktree-count.js

@@ -0,0 +1,8 @@
+import { dim } from '../colors.js';
+export default async function worktreeCount(ctx) {
+    if (!ctx.git || ctx.git.worktreeCount <= 1)
+        return null;
+    const raw = `${ctx.git.worktreeCount} worktrees`;
+    return { text: dim(raw), raw };
+}
+//# sourceMappingURL=worktree-count.js.map

package/dist/hud/config.d.ts

@@ -0,0 +1,10 @@
+import type { HudConfig, ComponentId } from './types.js';
+/**
+ * All 14 HUD components in display order.
+ */
+export declare const HUD_COMPONENTS: readonly ComponentId[];
+export declare function getConfigPath(): string;
+export declare function loadConfig(): HudConfig;
+export declare function saveConfig(config: HudConfig): void;
+export declare function resolveComponents(config: HudConfig): ComponentId[];
+//# sourceMappingURL=config.d.ts.map

package/dist/hud/config.js

@@ -0,0 +1,55 @@
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import { homedir } from 'node:os';
+/**
+ * All 14 HUD components in display order.
+ */
+export const HUD_COMPONENTS = [
+    'directory',
+    'gitBranch',
+    'gitAheadBehind',
+    'diffStats',
+    'releaseInfo',
+    'worktreeCount',
+    'model',
+    'contextUsage',
+    'versionBadge',
+    'sessionDuration',
+    'sessionCost',
+    'usageQuota',
+    'todoProgress',
+    'configCounts',
+];
+export function getConfigPath() {
+    const devflowDir = process.env.DEVFLOW_DIR || path.join(process.env.HOME || homedir(), '.devflow');
+    return path.join(devflowDir, 'hud.json');
+}
+export function loadConfig() {
+    const configPath = getConfigPath();
+    try {
+        const raw = fs.readFileSync(configPath, 'utf-8');
+        const parsed = JSON.parse(raw);
+        return {
+            enabled: parsed.enabled !== false,
+            detail: parsed.detail === true,
+        };
+    }
+    catch {
+        return { enabled: true, detail: false };
+    }
+}
+export function saveConfig(config) {
+    const configPath = getConfigPath();
+    const dir = path.dirname(configPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + '\n');
+}
+export function resolveComponents(config) {
+    if (config.enabled)
+        return [...HUD_COMPONENTS];
+    // Version badge always renders so users see upgrade notifications
+    return ['versionBadge'];
+}
+//# sourceMappingURL=config.js.map

package/dist/hud/credentials.d.ts

@@ -0,0 +1,17 @@
+export interface OAuthCredentials {
+    accessToken: string;
+    subscriptionType?: string;
+}
+/** Resolve the Claude config directory, respecting CLAUDE_CONFIG_DIR. */
+export declare function getClaudeDir(): string;
+/** Read OAuth credentials from ~/.claude/.credentials.json. Injectable claudeDir for tests. */
+export declare function readCredentialsFile(claudeDir?: string): OAuthCredentials | null;
+/** Read OAuth token from macOS Keychain. Returns null on non-darwin or failure. */
+export declare function readKeychainToken(): Promise<string | null>;
+/**
+ * Get OAuth credentials using platform-appropriate strategy.
+ * macOS: Keychain first, then file fallback. Other platforms: file only.
+ * Hybrid: if Keychain has token but no subscriptionType, merge from file.
+ */
+export declare function getCredentials(): Promise<OAuthCredentials | null>;
+//# sourceMappingURL=credentials.d.ts.map