ccglance 1.0.0

package/dist/readers/transcript.js

@@ -0,0 +1,206 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readTailLines = readTailLines;
+exports.getLatestTranscriptUsage = getLatestTranscriptUsage;
+exports.getRecentStatus = getRecentStatus;
+// transcript(.jsonl)流式读取 —— 只从文件「尾部」读固定字节，绝不把整个文件读进内存
+// （优于把整份 readFile 后 split 的做法）。派生指标按 path+mtime+size 落盘缓存，未变化则复用，
+// 从而不阻塞状态栏：默认无 transcript 段时根本不调用；启用时也只做一次有上限的尾部读。
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../utils/paths");
+const TAIL_BYTES = 64 * 1024; // 尾部读取上限：足够覆盖最近若干条消息
+function cacheFileFor(p) {
+    const h = hashString(path_1.default.resolve(p));
+    return path_1.default.join((0, paths_1.cacheDir)('transcript'), `${h}.usage.json`);
+}
+function statusCacheFileFor(p) {
+    const h = hashString(path_1.default.resolve(p));
+    return path_1.default.join((0, paths_1.cacheDir)('transcript'), `${h}.status.json`);
+}
+function hashString(input) {
+    let h = 0x811c9dc5;
+    for (let i = 0; i < input.length; i++) {
+        h ^= input.charCodeAt(i);
+        h = Math.imul(h, 0x01000193);
+    }
+    return (h >>> 0).toString(16);
+}
+// 流式尾部读：只读最后 maxBytes 字节，丢弃被截断的首行，返回完整 JSONL 行。
+function readTailLines(filePath, maxBytes = TAIL_BYTES) {
+    let fd;
+    try {
+        const st = fs_1.default.statSync(filePath);
+        const size = st.size;
+        if (size <= 0)
+            return [];
+        const start = size > maxBytes ? size - maxBytes : 0;
+        const len = size - start;
+        fd = fs_1.default.openSync(filePath, 'r');
+        const buf = Buffer.allocUnsafe(len);
+        fs_1.default.readSync(fd, buf, 0, len, start);
+        let text = buf.toString('utf8');
+        if (start > 0) {
+            const nl = text.indexOf('\n'); // 丢弃因截断产生的不完整首行
+            if (nl >= 0)
+                text = text.slice(nl + 1);
+        }
+        return text.split('\n').filter((l) => l.trim().length > 0);
+    }
+    catch {
+        return [];
+    }
+    finally {
+        if (fd !== undefined) {
+            try {
+                fs_1.default.closeSync(fd);
+            }
+            catch { /* ignore */ }
+        }
+    }
+}
+// 从尾部行里取最近一条 assistant 消息的 usage（倒序找）。
+function extractLatestUsage(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let e;
+        try {
+            e = JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+        if (e.type === 'assistant' && e.message && e.message.usage) {
+            const u = e.message.usage;
+            return {
+                inputTokens: u.input_tokens || 0,
+                outputTokens: u.output_tokens || 0,
+                cacheReadTokens: u.cache_read_input_tokens || 0,
+                cacheCreationTokens: u.cache_creation_input_tokens || 0,
+            };
+        }
+    }
+    return null;
+}
+// 取最近 usage：优先命中「文件未变化」的落盘缓存，否则尾部流式读一次并回写缓存。
+function getLatestTranscriptUsage(transcriptPath) {
+    if (!transcriptPath)
+        return null;
+    let st;
+    try {
+        st = fs_1.default.statSync(transcriptPath);
+    }
+    catch {
+        return null;
+    }
+    const cf = cacheFileFor(transcriptPath);
+    try {
+        const c = JSON.parse(fs_1.default.readFileSync(cf, 'utf8'));
+        if (c.mtimeMs === st.mtimeMs && c.size === st.size)
+            return c.usage; // 未变化 → 复用
+    }
+    catch { /* 无缓存 / 坏缓存 */ }
+    const usage = extractLatestUsage(readTailLines(transcriptPath));
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(cf), { recursive: true });
+        const payload = { mtimeMs: st.mtimeMs, size: st.size, usage };
+        fs_1.default.writeFileSync(cf, JSON.stringify(payload));
+    }
+    catch { /* 缓存尽力而为 */ }
+    return usage;
+}
+const blocks = (c) => {
+    if (Array.isArray(c))
+        return c;
+    if (c && typeof c === 'object')
+        return [c];
+    return [];
+};
+const contentText = (c) => {
+    if (typeof c === 'string')
+        return c;
+    return blocks(c).map((b) => b.text || b.content || '').filter(Boolean).join('\n');
+};
+function isInterruptedEntry(e) {
+    if (e.type !== 'user')
+        return false;
+    const text = contentText(e.message && e.message.content).trim();
+    if (!text)
+        return false;
+    const loose = /\b(interrupted|interrupt|aborted|abort|cancelled|canceled|keyboardinterrupt)\b|中断|取消/i;
+    if (e.isMeta)
+        return loose.test(text);
+    return /^\[?\s*(request\s+)?(interrupted|cancelled|canceled|aborted)(\s+by\s+user)?\.?\s*\]?$/i.test(text)
+        || /^\[?\s*user\s+(interrupted|cancelled|canceled|aborted)(\s+the\s+request)?\.?\s*\]?$/i.test(text)
+        || /^keyboardinterrupt$/i.test(text);
+}
+// 会话状态推断：从尾部倒序找「最后一条对话消息」(跳过 mode/title 等元数据行)，细分为：
+//   tool     —— assistant 请求工具(tool_use)，带工具名        (正在调用/运行工具)
+//   idle     —— assistant end_turn/stop_sequence               (回合结束)
+//   paused   —— 用户中断 / Esc 取消
+//   working  —— user 消息含 tool_result                        (工具已返回，模型继续处理)
+//   thinking —— user 纯提示 / assistant 未结束且无工具         (等待模型响应/生成中)
+function extractRecentStatus(lines) {
+    for (let i = lines.length - 1; i >= 0; i--) {
+        let e;
+        try {
+            e = JSON.parse(lines[i]);
+        }
+        catch {
+            continue;
+        }
+        const msg = e.message;
+        if (isInterruptedEntry(e))
+            return { state: 'paused' };
+        if (e.type === 'assistant') {
+            const content = blocks(msg && msg.content);
+            const toolUse = content.find((b) => b && b.type === 'tool_use');
+            if (toolUse)
+                return { state: 'tool', tool: toolUse.name };
+            // 已产出文本/思考内容 = 回合结束 → idle。
+            // 注意：Claude Code transcript 常把完成的文本回复记为 stop_reason:null（而非 end_turn），
+            // 所以判 idle 看「有内容」而非 stop_reason，否则正常回复会被误判成 thinking。
+            const hasText = content.some((b) => b && (b.type === 'text' || b.type === 'thinking'))
+                || (typeof (msg && msg.content) === 'string' && String(msg && msg.content).length > 0);
+            return { state: hasText ? 'idle' : 'thinking' };
+        }
+        if (e.type === 'user') {
+            const hasToolResult = blocks(msg && msg.content).some((b) => b && b.type === 'tool_result');
+            return { state: hasToolResult ? 'working' : 'thinking' };
+        }
+    }
+    return null;
+}
+// 局限：statusLine 仅在重绘时被 spawn，故这是「重绘时刻的近似态」，非实时事件流。
+function getRecentStatus(transcriptPath) {
+    if (!transcriptPath)
+        return null;
+    let st;
+    try {
+        st = fs_1.default.statSync(transcriptPath);
+    }
+    catch {
+        return null;
+    }
+    const cf = statusCacheFileFor(transcriptPath);
+    try {
+        const c = JSON.parse(fs_1.default.readFileSync(cf, 'utf8'));
+        if (c.mtimeMs === st.mtimeMs && c.size === st.size)
+            return c.status;
+    }
+    catch {
+        // Cache miss.
+    }
+    const status = extractRecentStatus(readTailLines(transcriptPath));
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(cf), { recursive: true });
+        const payload = { mtimeMs: st.mtimeMs, size: st.size, status };
+        fs_1.default.writeFileSync(cf, JSON.stringify(payload));
+    }
+    catch {
+        // Cache is best effort.
+    }
+    return status;
+}

package/dist/readers/version.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scheduleRefresh = exports.readCachedLatest = void 0;
+var version_1 = require("../runtime/version");
+Object.defineProperty(exports, "readCachedLatest", { enumerable: true, get: function () { return version_1.readCachedLatest; } });
+Object.defineProperty(exports, "scheduleRefresh", { enumerable: true, get: function () { return version_1.scheduleRefresh; } });

package/dist/render/colors.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.seg = exports.DOT = exports.SEP = exports.C = exports.paint = void 0;
+// 上色与配色 —— ANSI 16-color，固定内置风格。
+const sanitize_1 = require("../utils/sanitize");
+const R = '\x1b[0m';
+const GREEN = 92;
+const RED = 91;
+const YELLOW = 33;
+const CYAN = 96;
+const BLUE = 94;
+const MAGENTA = 95;
+const WHITE = 37;
+const paint = (code, s, bold = false) => `\x1b[${bold ? '1;' : ''}${code}m${(0, sanitize_1.sanitizeText)(s)}${R}`;
+exports.paint = paint;
+exports.C = {
+    // 第一行（运行时）
+    model: CYAN, effort: YELLOW, fast: GREEN,
+    ctx: MAGENTA, cache: GREEN, style: CYAN,
+    rate: CYAN, // rate_limits 主图标/标签
+    rateReset: YELLOW, // 配额重置时间
+    safe: GREEN, // 正常/成功/新增
+    caution: YELLOW, // 阈值染色：警戒
+    danger: RED, // 阈值染色：危险/删除
+    idle: GREEN, // 状态：空闲
+    paused: YELLOW, // 状态：用户暂停/中断
+    working: CYAN, // 状态：工作中/工具返回后处理
+    stTool: BLUE, // 状态：调用工具
+    stThink: MAGENTA, // 状态：等待模型/生成中
+    // 第二行（项目 / 会话）
+    name: MAGENTA, dirIcon: YELLOW, dirText: GREEN, git: WHITE,
+    gitClean: GREEN, gitDirty: BLUE, gitConflict: RED,
+    gitAhead: GREEN, gitBehind: BLUE,
+    sess: CYAN, add: GREEN, del: RED,
+    cost: YELLOW, // 美元成本
+    wt: GREEN, // worktree
+    ver: CYAN, upd: RED, // 版本：默认同 style
+};
+exports.SEP = (0, exports.paint)(WHITE, ' | '); // 段间白色分隔符（两侧各一空格）
+exports.DOT = ' · '; // 项内值与值分隔（中点，两侧各一空格）
+// “图标 文字”同色段
+const seg = (color, icon, text, iconColor = color, textColor = color, bold = false) => (0, exports.paint)(iconColor, icon, bold) + ' ' + (0, exports.paint)(textColor, text, bold);
+exports.seg = seg;

package/dist/render/icons.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.icon = icon;
+const ICONS = {
+    model: '🤖',
+    dir: '📁',
+    git: '🌿',
+    context: '⚡️',
+    cache: '💾',
+    rate_limits: '📊',
+    fast: '🚀',
+    style: '🎯',
+    session: '⏱️',
+    cost: '💰',
+    version: '💩',
+};
+function icon(id) {
+    return ICONS[id];
+}

package/dist/render/index.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hasEnabledSegment = hasEnabledSegment;
+exports.render = render;
+const colors_1 = require("./colors");
+const segments_1 = require("../segments");
+const layout_1 = require("./layout");
+const termwidth_1 = require("../readers/termwidth");
+function hasEnabledSegment(spec, id) {
+    return spec.segments[id]?.enabled !== false && spec.layout.rows.some((row) => row.includes(id));
+}
+function render(data, spec, options = {}) {
+    const latest = options.latest !== undefined
+        ? options.latest
+        : data.version && hasEnabledSegment(spec, 'version')
+            ? require('../runtime/version').readCachedLatest()
+            : '';
+    const ctx = {
+        data,
+        spec,
+        nowMs: options.nowMs ?? Date.now(),
+        latest,
+        previewStatus: options.previewStatus,
+    };
+    // 按逻辑行收集：跳过 enabled:false，调用段函数，过滤 null。
+    const rendered = spec.layout.rows.map((row) => row
+        .filter((id) => spec.segments[id] == null || spec.segments[id].enabled !== false)
+        .map((id) => {
+        const fn = segments_1.SEGMENTS[id];
+        return fn ? fn(ctx) : null;
+    })
+        .filter((s) => s != null && s.length > 0));
+    // 固定白色段分隔符。
+    const coloredSep = (0, colors_1.paint)(37, spec.layout.separator);
+    // 多级健壮宽度探测（CCGLANCE_WIDTH → COLUMNS → stdout.columns → unix 兜底 → minWidth）
+    const columns = (0, termwidth_1.detectWidth)(spec.layout.minWidth);
+    const lines = (0, layout_1.layout)(rendered, coloredSep, columns, spec.layout.mode);
+    if (!lines.length)
+        return '';
+    // 每行前缀 \x1b[0m：覆盖 Claude Code 施加给状态栏的 dim(发灰)，让配色正常显示。
+    const RESET = '\x1b[0m';
+    return lines.map((l) => RESET + l).join('\n') + '\n';
+}

package/dist/render/layout.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.layout = layout;
+// 响应式多行布局引擎。
+//   输入：已渲染的逻辑行（每行是若干段的字符串，已过滤 null/空），join 用的分隔符，终端宽度，模式。
+//   responsive：每个逻辑行按显示宽度贪心折成多物理行（行末不留分隔符）；组间强制换行。
+//   fixed：每个逻辑行原样一行，不折。
+const width_1 = require("../utils/width");
+// 终端宽度探测已统一到 reader/termwidth.ts 的 detectWidth()。
+function layout(rows, sep, columns, mode) {
+    const sepW = (0, width_1.stringWidth)(sep);
+    const lines = [];
+    for (const row of rows) {
+        const segs = row.filter((s) => s && s.length > 0);
+        if (segs.length === 0)
+            continue;
+        if (mode === 'fixed') {
+            lines.push(segs.join(sep));
+            continue;
+        }
+        // responsive：贪心装箱。
+        // 最小保证「一行一个功能」：当前行为空时（cur.length===0）无条件放入该段，
+        // 即使单段比整行还宽也让它独占一行 —— 宁可它自己占一行，也不与他段挤在一起被挡住。
+        let cur = [];
+        let curW = 0;
+        for (const s of segs) {
+            const w = (0, width_1.stringWidth)(s);
+            const add = cur.length ? sepW + w : w;
+            if (cur.length > 0 && curW + add > columns) {
+                lines.push(cur.join(sep));
+                cur = [s];
+                curW = w;
+            }
+            else {
+                cur.push(s);
+                curW += add;
+            }
+        }
+        if (cur.length > 0)
+            lines.push(cur.join(sep));
+    }
+    return lines;
+}

package/dist/runtime/git.js

@@ -0,0 +1,204 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gitSegment = gitSegment;
+// Git segment: one bounded git status call, cached on disk.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const colors_1 = require("../render/colors");
+const paths_1 = require("../utils/paths");
+const CACHE_DIR = (0, paths_1.cacheDir)('git');
+const DEFAULT_TTL_MS = 20 * 60 * 1000;
+const GIT_TIMEOUT_MS = 700;
+const REFRESH_THROTTLE_MS = 5000;
+function resolveGitPaths(cwd) {
+    const abs = path_1.default.resolve(cwd);
+    const root = repoRootFor(abs);
+    const key = hashString(root || abs);
+    return {
+        cwd: abs,
+        root,
+        cacheFile: path_1.default.join(CACHE_DIR, `git-${key}.json`),
+        refreshFile: path_1.default.join(CACHE_DIR, `git-${key}.refresh`),
+    };
+}
+function repoRootFor(cwd) {
+    try {
+        let cur = path_1.default.resolve(cwd);
+        while (true) {
+            if (fs_1.default.existsSync(path_1.default.join(cur, '.git')))
+                return cur;
+            const parent = path_1.default.dirname(cur);
+            if (parent === cur)
+                return null;
+            cur = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+}
+function hashString(input) {
+    let h1 = 0x811c9dc5;
+    let h2 = 0x9e3779b9;
+    for (let i = 0; i < input.length; i++) {
+        const c = input.charCodeAt(i);
+        h1 ^= c;
+        h1 = Math.imul(h1, 0x01000193);
+        h2 ^= c;
+        h2 = Math.imul(h2, 0x85ebca6b);
+    }
+    return (h1 >>> 0).toString(16).padStart(8, '0') + (h2 >>> 0).toString(16).padStart(8, '0');
+}
+function readCache(paths) {
+    try {
+        const c = JSON.parse(fs_1.default.readFileSync(paths.cacheFile, 'utf8'));
+        return c && c.branch && typeof c.checkedAt === 'number' ? c : null;
+    }
+    catch {
+        return null;
+    }
+}
+function shouldRefresh(paths) {
+    const marker = paths.refreshFile;
+    try {
+        fs_1.default.mkdirSync(CACHE_DIR, { recursive: true });
+        fs_1.default.writeFileSync(marker, String(Date.now()), { flag: 'wx' });
+        return true;
+    }
+    catch {
+        // Existing marker means another statusline process is already refreshing.
+    }
+    try {
+        const st = fs_1.default.statSync(marker);
+        if (Date.now() - st.mtimeMs < REFRESH_THROTTLE_MS)
+            return false;
+        fs_1.default.rmSync(marker, { force: true });
+        fs_1.default.writeFileSync(marker, String(Date.now()), { flag: 'wx' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function parseStatus(out) {
+    let head = '';
+    let oid = '';
+    let ahead = 0;
+    let behind = 0;
+    let dirty = false;
+    let conflict = false;
+    for (const raw of out.split(/\r?\n/)) {
+        const line = raw.trimEnd();
+        if (!line)
+            continue;
+        if (line.startsWith('# branch.head ')) {
+            head = line.slice('# branch.head '.length).trim();
+            continue;
+        }
+        if (line.startsWith('# branch.oid ')) {
+            oid = line.slice('# branch.oid '.length).trim();
+            continue;
+        }
+        if (line.startsWith('# branch.ab ')) {
+            const m = /# branch\.ab \+(\d+) -(\d+)/.exec(line);
+            if (m) {
+                ahead = parseInt(m[1], 10) || 0;
+                behind = parseInt(m[2], 10) || 0;
+            }
+            continue;
+        }
+        if (line[0] === '#')
+            continue;
+        if (line.startsWith('u '))
+            conflict = true;
+        if (!line.startsWith('! '))
+            dirty = true;
+    }
+    const branch = head && head !== '(detached)' ? head : oid.slice(0, 8);
+    if (!branch)
+        return null;
+    return { branch, glyph: conflict ? '⚠' : dirty ? '●' : '✓', ahead, behind };
+}
+function readHeadFallback(root) {
+    if (!root)
+        return null;
+    try {
+        const dotgit = path_1.default.join(root, '.git');
+        let gitDir = dotgit;
+        const st = fs_1.default.statSync(dotgit);
+        if (st.isFile()) {
+            const raw = fs_1.default.readFileSync(dotgit, 'utf8').trim();
+            const m = /^gitdir:\s*(.+)$/i.exec(raw);
+            if (!m)
+                return null;
+            gitDir = path_1.default.resolve(root, m[1]);
+        }
+        const headRaw = fs_1.default.readFileSync(path_1.default.join(gitDir, 'HEAD'), 'utf8').trim();
+        const ref = /^ref:\s*refs\/heads\/(.+)$/.exec(headRaw);
+        const branch = ref ? ref[1] : headRaw.slice(0, 8);
+        return branch ? { branch, ahead: 0, behind: 0 } : null;
+    }
+    catch {
+        return null;
+    }
+}
+function branchHintFallback(branchHint) {
+    const branch = branchHint && branchHint.trim();
+    return branch ? { branch, ahead: 0, behind: 0 } : null;
+}
+function scheduleGitRefresh(paths) {
+    if (!paths.root || !shouldRefresh(paths))
+        return;
+    try {
+        const bg = "const fs=require('fs'),path=require('path'),{execFileSync}=require('child_process');" +
+            "const cwd=" + JSON.stringify(paths.root) + ";" +
+            "const cf=" + JSON.stringify(paths.cacheFile) + ";" +
+            "const marker=" + JSON.stringify(paths.refreshFile) + ";" +
+            "const parseStatus=" + parseStatus.toString() + ";" +
+            "const save=obj=>{const tmp=cf+'.'+process.pid+'.tmp';fs.mkdirSync(path.dirname(cf),{recursive:true});fs.writeFileSync(tmp,JSON.stringify(obj));fs.renameSync(tmp,cf)};" +
+            "try{" +
+            "const out=execFileSync('git',['--no-optional-locks','-C',cwd,'status','--porcelain=v2','--branch'],{encoding:'utf8',stdio:['ignore','pipe','ignore'],timeout:" + GIT_TIMEOUT_MS + ",windowsHide:true});" +
+            "const info=parseStatus(out);if(info)save({...info,checkedAt:Date.now()});" +
+            "}catch{}finally{try{fs.rmSync(marker,{force:true})}catch{}}";
+        const { spawn } = require('child_process');
+        spawn(process.execPath, ['-e', bg], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+    }
+    catch {
+        try {
+            fs_1.default.rmSync(paths.refreshFile, { force: true });
+        }
+        catch { /* ignore */ }
+    }
+}
+function formatGit(info, icon, worktreeName) {
+    const status = [];
+    if (info.glyph) {
+        const color = info.glyph === '⚠' ? colors_1.C.gitConflict : info.glyph === '●' ? colors_1.C.gitDirty : colors_1.C.gitClean;
+        status.push((0, colors_1.paint)(color, info.glyph));
+    }
+    if (info.ahead > 0)
+        status.push((0, colors_1.paint)(colors_1.C.gitAhead, '↑' + info.ahead));
+    if (info.behind > 0)
+        status.push((0, colors_1.paint)(colors_1.C.gitBehind, '↓' + info.behind));
+    const branch = (0, colors_1.seg)(colors_1.C.git, icon, info.branch);
+    const details = status.length ? status.join(' ') : '';
+    const worktree = worktreeName && worktreeName.trim() ? (0, colors_1.seg)(colors_1.C.wt, '🌲', worktreeName.trim()) : '';
+    return [branch, details, worktree].filter(Boolean).join(' ');
+}
+// 分支 + 状态标记(✓/●/⚠)+ ↑ahead ↓behind；无分支或非仓库返回 null。
+function gitSegment(cwd, icon = '🌿', options = {}, branchHint, worktreeName) {
+    const ttlMs = typeof options.ttlMs === 'number' && options.ttlMs >= 0 ? options.ttlMs : DEFAULT_TTL_MS;
+    const paths = resolveGitPaths(cwd);
+    const fallback = branchHintFallback(branchHint) || readHeadFallback(paths.root);
+    if (!fallback)
+        return null;
+    const cached = readCache(paths);
+    const cacheFresh = cached && Date.now() - cached.checkedAt <= ttlMs;
+    if (cacheFresh && cached.branch === fallback.branch)
+        return formatGit(cached, icon, worktreeName);
+    scheduleGitRefresh(paths);
+    return formatGit(cacheFresh && cached.branch === fallback.branch ? cached : fallback, icon, worktreeName);
+}

package/dist/runtime/version.js

@@ -0,0 +1,81 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readCachedLatest = readCachedLatest;
+exports.scheduleRefresh = scheduleRefresh;
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const paths_1 = require("../utils/paths");
+const CACHE_TTL_MS = 4 * 3600 * 1000;
+const REFRESH_THROTTLE_MS = 60 * 1000;
+const cacheFile = path_1.default.join((0, paths_1.cacheDir)('version'), 'claude-code.json');
+const refreshFile = path_1.default.join((0, paths_1.cacheDir)('version'), 'claude-code.refresh');
+let memo = null;
+function readCache() {
+    if (memo)
+        return memo;
+    try {
+        memo = JSON.parse(fs_1.default.readFileSync(cacheFile, 'utf8'));
+    }
+    catch {
+        memo = {};
+    }
+    return memo;
+}
+function readCachedLatest() {
+    return readCache().latest || '';
+}
+function shouldRefresh() {
+    try {
+        fs_1.default.mkdirSync(path_1.default.dirname(refreshFile), { recursive: true });
+        fs_1.default.writeFileSync(refreshFile, String(Date.now()), { flag: 'wx' });
+        return true;
+    }
+    catch {
+        // Existing marker means another statusline process is already refreshing.
+    }
+    try {
+        const st = fs_1.default.statSync(refreshFile);
+        if (Date.now() - st.mtimeMs < REFRESH_THROTTLE_MS)
+            return false;
+        fs_1.default.rmSync(refreshFile, { force: true });
+        fs_1.default.writeFileSync(refreshFile, String(Date.now()), { flag: 'wx' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function scheduleRefresh() {
+    try {
+        const age = Date.now() - (readCache().checkedAt || 0);
+        if (age <= CACHE_TTL_MS)
+            return;
+        if (!shouldRefresh())
+            return;
+        const bg = "const https=require('https'),fs=require('fs'),path=require('path');" +
+            "const f=" + JSON.stringify(cacheFile) + ";" +
+            "const marker=" + JSON.stringify(refreshFile) + ";" +
+            "let prev='';try{prev=(JSON.parse(fs.readFileSync(f,'utf8')).latest)||''}catch{}" +
+            "let done=false;const finish=v=>{if(done)return;done=true;" +
+            "try{const tmp=f+'.'+process.pid+'.tmp';fs.mkdirSync(path.dirname(f),{recursive:true});fs.writeFileSync(tmp,JSON.stringify({latest:v||prev,checkedAt:Date.now()}));fs.renameSync(tmp,f)}catch{}" +
+            "try{fs.rmSync(marker,{force:true})}catch{}};" +
+            "try{" +
+            "const req=https.get('https://registry.npmjs.org/@anthropic-ai/claude-code/latest',r=>{" +
+            "if(r.statusCode!==200){r.resume();return finish('')}" +
+            "let d='';r.on('data',c=>d+=c);r.on('end',()=>{try{finish(JSON.parse(d).version)}catch{finish('')}})" +
+            "});req.on('error',()=>finish(''));req.setTimeout(5000,()=>{req.destroy();finish('')});" +
+            "}catch{finish('')}";
+        const { spawn } = require('child_process');
+        spawn(process.execPath, ['-e', bg], { detached: true, stdio: 'ignore', windowsHide: true }).unref();
+    }
+    catch {
+        try {
+            fs_1.default.rmSync(refreshFile, { force: true });
+        }
+        catch { /* ignore */ }
+        // Version refresh never affects statusline rendering.
+    }
+}