pi-editor-footer 0.1.0 → 0.1.2

package/CHANGELOG.md

@@ -4,8 +4,20 @@ All notable changes to this project will be documented in this file.
 
 ## [Unreleased]
 
+## [0.1.2] - 2026-08-20
+
+### Fixed
+- `npm:pi-editor-footer` not being discovered when installed via `pi install npm:pi-editor-footer` — added `pi.extensions` (`dist/index.js`) and `keywords` so pi loads the theme from `~/.pi/agent/npm/node_modules`
+
+## [0.1.1] - 2026-08-20
+
+
+### Fixed
+- `npm:pi-editor-footer` now works when installed via `pi install npm:pi-editor-footer` — added `main` (`dist/index.js`), `files`, and `build` (`tsc --project tsconfig.build.json`) so pi can discover the extension from `~/.pi/agent/npm/node_modules`
+
 ## [0.1.0] - 2026-08-20
 
+
 ### Added
 
 - Full TUI theme `pi-editor-footer` rebuilt on `TrackingEditor`: project-aware footer (`cwd` · `git` • `runtime` left, `tokens` next to `context` right), model-info border glow top, live theme respect, detail window preserved

package/dist/config.js

@@ -0,0 +1,131 @@
+/** Typed config for pi-skill-desc theme (admission boundary: validate once). */
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+export const DEFAULT_CONFIG = {
+    enabled: true,
+    workspaceDisplay: "path",
+    cursorStyle: "block",
+    icons: {
+        mode: "auto",
+    },
+    footerSegments: {
+        cwd: true,
+        sessionName: false,
+        gitBranch: true,
+        gitStatus: true,
+        gitCommit: false,
+        runtime: true,
+        context: true,
+        tokens: true,
+        cost: true,
+        extensionStatuses: true,
+    },
+    telemetry: {
+        enabled: true,
+        tps: true,
+        ttft: true,
+        duration: true,
+        tokens: true,
+        stalls: true,
+        cost: true,
+    },
+};
+export function getConfigPath() {
+    const home = homedir();
+    return join(home, ".pi", "agent", "pi-skill-desc.json");
+}
+function deepMerge(base, override) {
+    if (typeof base !== "object" || base === null || Array.isArray(base)) {
+        return override ?? base;
+    }
+    if (typeof override !== "object" ||
+        override === null ||
+        Array.isArray(override)) {
+        return base;
+    }
+    const result = { ...base };
+    const rec = override;
+    for (const key of Object.keys(rec)) {
+        const bv = base[key];
+        const ov = rec[key];
+        if (typeof bv === "object" &&
+            bv !== null &&
+            !Array.isArray(bv) &&
+            typeof ov === "object" &&
+            ov !== null &&
+            !Array.isArray(ov)) {
+            result[key] = deepMerge(bv, ov);
+        }
+        else if (ov !== undefined) {
+            result[key] = ov;
+        }
+    }
+    return result;
+}
+function validate(config) {
+    // workspaceDisplay
+    if (config.workspaceDisplay !== "path" &&
+        config.workspaceDisplay !== "name") {
+        config.workspaceDisplay = DEFAULT_CONFIG.workspaceDisplay;
+    }
+    // cursorStyle
+    if (config.cursorStyle !== "block" &&
+        config.cursorStyle !== "bar" &&
+        config.cursorStyle !== "underline") {
+        config.cursorStyle = DEFAULT_CONFIG.cursorStyle;
+    }
+    // icons.mode
+    if (config.icons.mode !== "auto" &&
+        config.icons.mode !== "nerd" &&
+        config.icons.mode !== "ascii") {
+        config.icons.mode = DEFAULT_CONFIG.icons.mode;
+    }
+    return config;
+}
+export function ensureConfigExists() {
+    const path = getConfigPath();
+    if (existsSync(path))
+        return;
+    try {
+        const dir = join(path, "..");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(path, JSON.stringify(DEFAULT_CONFIG, null, 2) + "\n", "utf8");
+    }
+    catch {
+        // best-effort
+    }
+}
+export function loadConfig() {
+    const path = getConfigPath();
+    if (!existsSync(path)) {
+        ensureConfigExists();
+        return structuredClone(DEFAULT_CONFIG);
+    }
+    try {
+        const raw = readFileSync(path, "utf8");
+        const parsed = JSON.parse(raw);
+        const merged = deepMerge(structuredClone(DEFAULT_CONFIG), parsed);
+        return validate(merged);
+    }
+    catch (err) {
+        console.warn(`[pi-skill-desc] config parse error (${path}): ${err instanceof Error ? err.message : String(err)} — using defaults`);
+        return structuredClone(DEFAULT_CONFIG);
+    }
+}
+export function saveConfig(patch) {
+    const current = loadConfig();
+    const merged = validate(deepMerge(current, patch));
+    const path = getConfigPath();
+    try {
+        const dir = join(path, "..");
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        writeFileSync(path, JSON.stringify(merged, null, 2) + "\n", "utf8");
+    }
+    catch {
+        // best-effort
+    }
+    return merged;
+}

package/dist/detail-render.js

@@ -0,0 +1,93 @@
+/**
+ * Pure, TUI-free rendering of the Detail window (ADR-0001).
+ *
+ * Given a highlighted completion candidate and window state, produces the
+ * lines to render in the 5-line detail window above the input box.
+ * No pi imports — this is the single testable seam of the extension.
+ */
+/**
+ * Rendered lines for the detail window: `[header, ...contentLines]`.
+ *
+ * - Returns `[]` when `item` is null or its description is empty/whitespace.
+ * - Header is `<label> · <kind>`, suffixed with a ` offset/total` scroll
+ *   marker (e.g. ` 3/8`) when the description overflows the window.
+ * - The description is wrapped to `width` characters per line (simple
+ *   character-based wrap; embedded newlines become paragraph breaks).
+ * - Shrink-to-fit: exactly `min(maxLines, 1 + contentLines)` lines are
+ *   returned (1 header + up to `maxLines - 1` content lines).
+ * - `scrollOffset` is clamped into `[0, max(0, contentLines - (maxLines - 1))]`.
+ */
+export function renderDetail(item, width, maxLines, scrollOffset) {
+    if (!item || item.description.trim() === "") {
+        return [];
+    }
+    const wrapWidth = Math.max(1, Math.floor(width));
+    const safeMax = Math.max(1, Math.floor(maxLines));
+    const contentLines = wrapDescription(item.description, wrapWidth);
+    const capacity = Math.max(0, safeMax - 1);
+    const maxOffset = capacity === 0 ? 0 : Math.max(0, contentLines.length - capacity);
+    const offset = clamp(Math.floor(scrollOffset) || 0, 0, maxOffset);
+    const visibleLines = contentLines.slice(offset, offset + capacity);
+    // "More content" marker: `...` replaces the last visible content line when
+    // there is content remaining BELOW the window (not yet scrolled to the
+    // bottom). The header's ` offset/total` marker still carries the totals.
+    const hasMoreBelow = offset + visibleLines.length < contentLines.length;
+    if (hasMoreBelow && visibleLines.length > 0) {
+        visibleLines[visibleLines.length - 1] = "...";
+    }
+    const overflows = contentLines.length > capacity;
+    const namePart = `${item.label} · ${item.kind}`;
+    let header;
+    if (overflows) {
+        // Reserve room for the scroll marker so it always survives truncation.
+        const marker = ` ${offset + 1}/${contentLines.length}`;
+        const nameWidth = Math.max(0, wrapWidth - marker.length);
+        header = truncateToWidth(namePart, nameWidth) + marker;
+    }
+    else {
+        header = truncateToWidth(namePart, wrapWidth);
+    }
+    return [header, ...visibleLines];
+}
+/**
+ * Next scroll offset after moving by `delta` (-1 = back/up, +1 = forward/down).
+ *
+ * - Returns 0 when there is nothing to scroll (description fits the window).
+ * - Otherwise returns `offset + delta`, clamped to
+ *   `[0, contentLines - (maxLines - 1)]`.
+ */
+export function scroll(offset, delta, contentLines, maxLines) {
+    const capacity = Math.max(0, maxLines - 1);
+    if (capacity === 0) {
+        return 0;
+    }
+    const maxOffset = Math.max(0, contentLines - capacity);
+    if (maxOffset === 0) {
+        return 0;
+    }
+    return clamp(Math.floor(offset) + delta, 0, maxOffset);
+}
+function wrapDescription(description, width) {
+    const lines = [];
+    for (const rawLine of description.split("\n")) {
+        const trimmed = rawLine.replace(/\s+$/g, "");
+        if (trimmed === "") {
+            // Preserve explicit paragraph breaks (empty lines in the description).
+            lines.push("");
+            continue;
+        }
+        for (let i = 0; i < trimmed.length; i += width) {
+            const segment = trimmed.slice(i, i + width).replace(/\s+$/g, "");
+            if (segment !== "") {
+                lines.push(segment);
+            }
+        }
+    }
+    return lines;
+}
+function truncateToWidth(text, width) {
+    return text.length <= width ? text : text.slice(0, width);
+}
+function clamp(value, min, max) {
+    return Math.max(min, Math.min(max, value));
+}

package/dist/footer.js

@@ -0,0 +1,282 @@
+import { truncateToWidth, visibleWidth, wrapTextWithAnsi, } from "@earendil-works/pi-tui";
+import { getUsageTotals } from "./state.js";
+import { resolveGlyphs, resolveIconMode, runtimeSymbol } from "./icons.js";
+import { alignRight, basenamePath, cacheHitColor, fitSegmentsByPriority, fmtTokens, formatCwd, formatDuration, formatProviderLabel, sanitizeStatus, stressColor, truncateBranch, truncatePath, } from "./utils.js";
+function renderBar(theme, pct, barWidth, ascii) {
+    const filled = Math.max(0, Math.min(barWidth, Math.round((pct / 100) * barWidth)));
+    const empty = barWidth - filled;
+    const color = stressColor(pct);
+    const filledCell = ascii ? "#" : "█";
+    const emptyCell = ascii ? "-" : "░";
+    return (theme.fg("dim", "[") +
+        theme.fg(color, filledCell.repeat(filled)) +
+        theme.fg("dim", emptyCell.repeat(empty)) +
+        theme.fg("dim", "]"));
+}
+function renderGitSegment(theme, git, glyphs, segments, maxBranchLen = 20) {
+    const parts = [];
+    if (segments.gitBranch) {
+        if (git.branch) {
+            parts.push(theme.fg("mdLink", truncateBranch(git.branch, maxBranchLen)));
+        }
+        else if (git.commit?.detached) {
+            parts.push(theme.fg("warning", "HEAD"));
+            if (git.commit.oid) {
+                const shortHash = git.commit.oid.slice(0, 7);
+                const tag = git.commit.tag ? ` ${git.commit.tag}` : "";
+                parts.push(theme.fg("dim", `${shortHash}${tag}`));
+            }
+        }
+    }
+    if (segments.gitStatus) {
+        const statusIcons = [];
+        const addStatus = (count, glyph, color) => {
+            if (count > 0)
+                statusIcons.push(theme.fg(color, `${glyph}${count}`));
+        };
+        addStatus(git.conflicted, glyphs.conflicted, "error");
+        addStatus(git.deleted, glyphs.deleted, "error");
+        addStatus(git.modified, glyphs.modified, "warning");
+        addStatus(git.renamed, glyphs.renamed, "warning");
+        addStatus(git.staged, glyphs.staged, "success");
+        addStatus(git.untracked, glyphs.untracked, "muted");
+        addStatus(git.stashed, glyphs.stashed, "muted");
+        if (git.ahead > 0 && git.behind > 0) {
+            statusIcons.push(theme.fg("warning", `${glyphs.diverged}${git.ahead}/${git.behind}`));
+        }
+        else if (git.ahead > 0) {
+            statusIcons.push(theme.fg("success", `${glyphs.ahead}${git.ahead}`));
+        }
+        else if (git.behind > 0) {
+            statusIcons.push(theme.fg("warning", `${glyphs.behind}${git.behind}`));
+        }
+        const statusBlock = statusIcons.join(" ");
+        if (statusBlock) {
+            parts.push(`${theme.fg("dim", "[")}${statusBlock}${theme.fg("dim", "]")}`);
+        }
+    }
+    return parts.join(" ");
+}
+function renderRuntimeSegment(theme, runtime, iconMode) {
+    if (!runtime)
+        return "";
+    const symbol = theme.fg("success", runtimeSymbol(runtime.name, iconMode));
+    const version = runtime.version ? theme.fg("muted", runtime.version) : "";
+    const label = [symbol, version].filter(Boolean).join(" ");
+    return label;
+}
+function renderTimerSegment(theme, state, glyphs) {
+    if (state.workingSince !== undefined) {
+        return `${theme.fg("accent", glyphs.working)} ${theme.fg("dim", "working")} ${theme.fg("accent", formatDuration(Date.now() - state.workingSince))}`;
+    }
+    if (state.lastDoneIn !== undefined) {
+        return `${theme.fg("success", glyphs.done)} ${theme.fg("success", "done")} ${theme.fg("text", formatDuration(state.lastDoneIn))}`;
+    }
+    return "";
+}
+export function renderFooter(width, state, config, theme, ctx) {
+    if (width <= 0)
+        return [""];
+    const glyphs = resolveGlyphs(config.icons.mode);
+    const segments = config.footerSegments;
+    const totals = ctx.totals ?? {
+        input: 0,
+        output: 0,
+        cacheRead: 0,
+        cacheWrite: 0,
+        cost: 0,
+        latestCacheHitRate: undefined,
+    };
+    const meta = ctx.getModelMeta
+        ? ctx.getModelMeta()
+        : {
+            provider: formatProviderLabel(ctx.model?.provider),
+            model: ctx.model?.name ?? ctx.model?.id ?? "no-model",
+            effort: undefined,
+        };
+    const leftParts = [];
+    if (segments.cwd) {
+        const maxCwd = Math.min(30, Math.max(10, Math.floor(width * 0.4)));
+        const rawCwd = formatCwd(ctx.cwd);
+        const displayCwd = config.workspaceDisplay === "name" ? basenamePath(rawCwd) : rawCwd;
+        const cwdPrefix = `${theme.fg("mdLink", glyphs.cwd)} `;
+        const accent = (text) => theme.fg("accent", text);
+        leftParts.push({
+            text: `${cwdPrefix}${accent(truncatePath(displayCwd, maxCwd))}`,
+            compactText: `${cwdPrefix}${accent(truncatePath(basenamePath(displayCwd), maxCwd))}`,
+            priority: 5,
+            truncate: (_text, maxWidth, ellipsis) => {
+                const pathWidth = maxWidth - visibleWidth(cwdPrefix);
+                if (pathWidth <= visibleWidth(ellipsis)) {
+                    return truncateToWidth(`${cwdPrefix}${accent(basenamePath(displayCwd))}`, maxWidth, ellipsis);
+                }
+                return `${cwdPrefix}${accent(truncatePath(basenamePath(displayCwd), pathWidth))}`;
+            },
+        });
+    }
+    if (segments.sessionName) {
+        const sessionName = ctx.sessionName;
+        if (sessionName) {
+            const sep = leftParts.length > 0 ? `${theme.fg("dim", " • ")}` : "";
+            leftParts.push({
+                text: `${sep}${theme.fg("dim", glyphs.session)} ${theme.fg("text", truncateToWidth(sessionName, 24, theme.fg("dim", "...")))}`,
+                priority: 2,
+            });
+        }
+    }
+    const gitSeg = renderGitSegment(theme, state.git, glyphs, segments);
+    if (gitSeg) {
+        const sep = leftParts.length > 0 ? `${theme.fg("dim", " · ")}` : "";
+        leftParts.push({ text: `${sep}${gitSeg}`, priority: 4 });
+    }
+    if (segments.runtime) {
+        const runtimeSeg = renderRuntimeSegment(theme, state.runtime, config.icons.mode);
+        if (runtimeSeg) {
+            const sep = leftParts.length > 0 ? `${theme.fg("dim", " • ")}` : "";
+            leftParts.push({ text: `${sep}${runtimeSeg}`, priority: 4 });
+        }
+    }
+    const timerSeg = renderTimerSegment(theme, state, glyphs);
+    if (timerSeg) {
+        const sep = leftParts.length > 0 ? `${theme.fg("dim", " • ")}` : "";
+        leftParts.push({ text: `${sep}${timerSeg}`, priority: 1 });
+    }
+    const stats = [];
+    if (segments.tokens) {
+        stats.push(theme.fg("accent", `${glyphs.input} ${fmtTokens(totals.input)}`));
+        stats.push(theme.fg("success", `${glyphs.output} ${fmtTokens(totals.output)}`));
+        const hasCacheTokens = totals.cacheRead > 0 || totals.cacheWrite > 0;
+        if (hasCacheTokens && totals.latestCacheHitRate !== undefined) {
+            stats.push(theme.fg(cacheHitColor(totals.latestCacheHitRate), `${glyphs.cacheHit} ${totals.latestCacheHitRate.toFixed(1)}%`));
+        }
+    }
+    if (segments.cost) {
+        stats.push(theme.fg("warning", `${glyphs.cost} $${totals.cost.toFixed(3)}`));
+    }
+    const statsBlock = stats.join(` ${theme.fg("dim", "|")} `);
+    // Context
+    let contextText = "";
+    let contextCompact;
+    if (segments.context) {
+        const contextUsage = ctx.contextUsage;
+        const contextWindow = contextUsage?.contextWindow ?? 0;
+        if (contextWindow > 0) {
+            const contextPct = contextUsage?.percent ?? 0;
+            const pctText = theme.fg(stressColor(contextPct), `${contextPct.toFixed(1)}%`);
+            const contextTokens = contextUsage?.tokens ?? 0;
+            const ctxText = `${theme.fg("text", fmtTokens(contextTokens))}${theme.fg("dim", "/")}${theme.fg("text", fmtTokens(contextWindow))}`;
+            const contextIcon = theme.fg(stressColor(contextPct), glyphs.context);
+            const reserved = visibleWidth(contextIcon) +
+                visibleWidth(pctText) +
+                visibleWidth(ctxText) +
+                7;
+            const barWidth = Math.max(4, Math.min(12, width - reserved));
+            contextText = `${contextIcon} ${renderBar(theme, contextPct, barWidth, resolveIconMode(config.icons.mode) === "ascii")} ${pctText} ${theme.fg("dim", "·")} ${ctxText}`;
+            const compact = `${theme.fg(stressColor(contextPct), glyphs.context)} ${theme.fg(stressColor(contextPct), `${contextPct.toFixed(1)}%`)}`;
+            if (visibleWidth(compact) < visibleWidth(contextText))
+                contextCompact = compact;
+        }
+    }
+    // Tokens right next to context bar (user request): combine them as single right block
+    const rightBlock = [statsBlock, contextText].filter(Boolean).join("  ");
+    const rightCompact = statsBlock && contextCompact ? `${statsBlock}  ${contextCompact}` : statsBlock || contextCompact;
+    const allParts = [...leftParts];
+    if (rightBlock) {
+        allParts.push({
+            text: rightBlock,
+            compactText: rightCompact,
+            priority: 4,
+        });
+    }
+    const fitted = fitSegmentsByPriority(allParts, width, theme.fg("dim", "..."));
+    const fittedContext = rightBlock ? (fitted.pop() ?? "") : "";
+    const line1 = alignRight(fitted.join(" "), fittedContext, width, theme);
+    const mainLines = [line1].map((line) => truncateToWidth(line, width, theme.fg("dim", "...")));
+    if (segments.extensionStatuses && ctx.extensionStatuses) {
+        const statuses = Array.from(ctx.extensionStatuses.entries())
+            .sort(([a], [b]) => a.localeCompare(b))
+            .map(([, text]) => sanitizeStatus(text))
+            .filter((text) => text.length > 0);
+        if (statuses.length > 0) {
+            const separator = ` ${theme.fg("dim", "|")} `;
+            const statusText = statuses
+                .map((status) => theme.fg("muted", status))
+                .join(separator);
+            const line = `${theme.fg("mdLink", glyphs.extensions)} ${statusText}`;
+            return [...mainLines, ...wrapTextWithAnsi(line, width)];
+        }
+    }
+    return mainLines;
+}
+// Simplified installFooter for typecheck — real pi integration will wire via ExtensionContext
+export function installFooter(ctx, getState, getConfig, getModelMeta, hooks) {
+    // Try setFooter if available (pi-coding-agent), else fallback to setWidget belowEditor
+    const themeStub = { fg: (_s, t) => t };
+    const render = (width) => {
+        const state = getState();
+        const config = getConfig();
+        const cwd = ctx.sessionManager?.getCwd() ?? process.cwd();
+        const totals = getUsageTotals(ctx);
+        return renderFooter(width, state, config, themeStub, {
+            cwd,
+            sessionName: ctx.sessionManager?.getSessionName?.(),
+            contextUsage: ctx.getContextUsage?.(),
+            model: ctx.model,
+            totals,
+            getModelMeta,
+        });
+    };
+    // Prefer native footer if available
+    if (typeof ctx.ui.setFooter ===
+        "function") {
+        const ui = ctx.ui;
+        ui.setFooter((tui, _theme, footerData) => {
+            hooks.setRequestRender(() => tui.requestRender());
+            const unsub = footerData.onBranchChange(() => {
+                hooks.scheduleGitRefresh();
+                tui.requestRender();
+            });
+            return {
+                dispose() {
+                    unsub();
+                    hooks.setRequestRender(undefined);
+                },
+                invalidate() { },
+                render(width) {
+                    // Use real theme when rendering
+                    const theme = _theme;
+                    const state = getState();
+                    const config = getConfig();
+                    const cwd = ctx.sessionManager?.getCwd() ?? process.cwd();
+                    const totals = getUsageTotals(ctx);
+                    return renderFooter(width, state, config, theme, {
+                        cwd,
+                        sessionName: ctx.sessionManager?.getSessionName?.(),
+                        contextUsage: ctx.getContextUsage?.(),
+                        model: ctx.model,
+                        totals,
+                        extensionStatuses: footerData.getExtensionStatuses(),
+                        getModelMeta,
+                    });
+                },
+            };
+        });
+        return () => {
+            ctx.ui.setFooter(undefined);
+        };
+    }
+    // Fallback: widget belowEditor
+    if (ctx.ui.setWidget) {
+        ctx.ui.setWidget("theme-footer", () => ({
+            invalidate() { },
+            render,
+        }), { placement: "belowEditor" });
+        hooks.setRequestRender(() => { });
+        return () => {
+            ctx.ui.setWidget?.("theme-footer", undefined);
+            hooks.setRequestRender(undefined);
+        };
+    }
+    hooks.setRequestRender(undefined);
+    return () => { };
+}

package/dist/git.js

@@ -0,0 +1,128 @@
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+const GIT_TIMEOUT_MS = 2000;
+export function emptyGitStatus() {
+    return {
+        branch: undefined,
+        ahead: 0,
+        behind: 0,
+        modified: 0,
+        untracked: 0,
+        staged: 0,
+        stashed: 0,
+        conflicted: 0,
+        renamed: 0,
+        deleted: 0,
+        commit: null,
+    };
+}
+async function gitExec(args, cwd) {
+    try {
+        const { stdout } = await execFileAsync("git", args, {
+            cwd,
+            timeout: GIT_TIMEOUT_MS,
+            maxBuffer: 1024 * 1024,
+        });
+        return stdout;
+    }
+    catch {
+        return null;
+    }
+}
+export async function readGitStatus(cwd, options = {}) {
+    if (!existsSync(join(cwd, ".git"))) {
+        return emptyGitStatus();
+    }
+    const stdout = await gitExec(["status", "--porcelain=v1", "--branch", "--show-stash"], cwd);
+    if (stdout === null) {
+        return emptyGitStatus();
+    }
+    const status = emptyGitStatus();
+    const lines = stdout.split("\n");
+    for (const line of lines) {
+        if (line.startsWith("## ")) {
+            const branchPart = line.slice(3);
+            const detached = branchPart.startsWith("HEAD (no branch)");
+            if (detached) {
+                status.branch = undefined;
+                status.commit = { oid: null, detached: true, tag: null };
+            }
+            else {
+                const branchMatch = branchPart.match(/^(\S+?)(?:\.\.\.(\S+))?(?:\s+\[(ahead|behind) (\d+)\])?$/);
+                if (branchMatch) {
+                    status.branch = branchMatch[1];
+                    if (branchMatch[3] === "ahead")
+                        status.ahead = parseInt(branchMatch[4], 10);
+                    if (branchMatch[3] === "behind")
+                        status.behind = parseInt(branchMatch[4], 10);
+                }
+            }
+            continue;
+        }
+        if (line.startsWith("# stash ")) {
+            const stashCount = parseInt(line.slice(8).trim(), 10);
+            if (!Number.isNaN(stashCount)) {
+                status.stashed = stashCount;
+            }
+            continue;
+        }
+        if (options.readCounts === false)
+            continue;
+        if (line.length < 3)
+            continue;
+        const x = line[0];
+        const y = line[1];
+        if (x === "U" || y === "U" || (x === "C" && y === "C"))
+            status.conflicted++;
+        else if (x === "?" && y === "?")
+            status.untracked++;
+        else if (x === "R")
+            status.renamed++;
+        else if (x === "D" || y === "D")
+            status.deleted++;
+        else {
+            if (x !== " " && x !== "?")
+                status.staged++;
+            if (y === "M" || y === "D")
+                status.modified++;
+        }
+    }
+    if (options.readCounts !== false &&
+        status.stashed === 0 &&
+        !stdout.includes("# stash")) {
+        const stashOut = await gitExec(["stash", "list"], cwd);
+        if (stashOut !== null) {
+            const count = stashOut
+                .split("\n")
+                .filter((l) => l.trim().length > 0).length;
+            if (!Number.isNaN(count))
+                status.stashed = count;
+        }
+    }
+    if (options.readCommit && status.commit?.detached) {
+        const oid = await gitExec(["rev-parse", "HEAD"], cwd);
+        if (oid) {
+            status.commit.oid = oid.trim();
+        }
+        if (options.readTag) {
+            const tag = await gitExec(["describe", "--tags", "--exact-match", "HEAD"], cwd);
+            if (tag) {
+                status.commit.tag = tag.trim();
+            }
+        }
+    }
+    return status;
+}
+export function hasGitChanges(s) {
+    return (s.modified > 0 ||
+        s.untracked > 0 ||
+        s.staged > 0 ||
+        s.conflicted > 0 ||
+        s.renamed > 0 ||
+        s.deleted > 0 ||
+        s.ahead > 0 ||
+        s.behind > 0);
+}