@narumitw/pi-statusline 0.49.9 → 0.49.11

package/dist/index.ts

@@ -0,0 +1,1069 @@
+// @generated by scripts/build-runtime.mjs; do not edit.
+// @ts-nocheck -- generated JavaScript uses a .ts extension for Pi's Jiti loader.
+import {
+  DEFAULT_EXTENSION_STATUS_ICONS,
+  LINE_BREAK_SEGMENT_NAME,
+  completeStatuslineArguments,
+  consumeStatuslineSettingsNotice,
+  loadStatuslineSettings,
+  loadStatuslineSettingsForAgent,
+  resolvePreset,
+  settingsFilePath
+} from "./chunks/chunk-4PIP7RGK.js";
+
+// src/statusline.ts
+import { homedir } from "node:os";
+import {
+  getAgentDir as getAgentDir2
+} from "@earendil-works/pi-coding-agent";
+
+// src/extension-status.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { wrapTextWithAnsi } from "@earendil-works/pi-tui";
+
+// src/powerline.ts
+import { visibleWidth } from "@earendil-works/pi-tui";
+
+// src/ansi.ts
+function ansiStyle(text, colors) {
+  const codes = [
+    colors.fg ? truecolorCode("38", colors.fg) : void 0,
+    colors.bg ? truecolorCode("48", colors.bg) : void 0
+  ].filter((code) => code !== void 0);
+  if (codes.length === 0) return text;
+  return `\x1B[${codes.join(";")}m${text}\x1B[0m`;
+}
+function truecolorCode(prefix, hex) {
+  const { red, green, blue } = hexToRgb(hex);
+  return `${prefix};2;${red};${green};${blue}`;
+}
+function hexToRgb(hex) {
+  const normalized = hex.replace(/^#/, "");
+  return {
+    red: Number.parseInt(normalized.slice(0, 2), 16),
+    green: Number.parseInt(normalized.slice(2, 4), 16),
+    blue: Number.parseInt(normalized.slice(4, 6), 16)
+  };
+}
+
+// src/powerline.ts
+function renderPowerlineStatusline(width, items, config) {
+  if (items.length === 0 || width <= 0) return "";
+  return splitLines(items).map((segments) => fitPowerlineSegments(segments, width, config)).join("\n");
+}
+function splitLines(items) {
+  const lines = [[]];
+  for (const item of items) {
+    if (item.name === LINE_BREAK_SEGMENT_NAME) lines.push([]);
+    else lines.at(-1)?.push(item);
+  }
+  return lines;
+}
+var SEGMENT_RETENTION_PRIORITY = {
+  context: 120,
+  model: 110,
+  branch: 100,
+  tools: 90,
+  cwd: 80,
+  thinking: 70,
+  cost: 60,
+  provider: 50,
+  cache: 45,
+  tokens: 40,
+  time: 30,
+  turn: 20,
+  brand: 10
+};
+function fitPowerlineSegments(segments, width, config) {
+  if (segments.length === 0) return "";
+  const fitted = [...segments];
+  while (fitted.length > 1) {
+    const rendered2 = joinPowerlineSegments(fitted, config);
+    if (visibleWidth(rendered2) <= width) return rendered2;
+    let removalIndex = 0;
+    for (let index = 1; index < fitted.length; index += 1) {
+      const candidate = fitted[index];
+      const current = fitted[removalIndex];
+      if (candidate && current && SEGMENT_RETENTION_PRIORITY[candidate.name] < SEGMENT_RETENTION_PRIORITY[current.name]) {
+        removalIndex = index;
+      }
+    }
+    fitted.splice(removalIndex, 1);
+  }
+  const rendered = joinPowerlineSegments(fitted, config);
+  return visibleWidth(rendered) <= width ? rendered : "";
+}
+function powerlineExtensionSeparator(_theme, palettePreset = "tokyo-night") {
+  return ansiStyle(" \u2022 ", { fg: resolvePreset(palettePreset).extensionSeparator });
+}
+function joinPowerlineSegments(segments, config) {
+  const preset = resolvePreset(config.palettePreset);
+  const blocks = contiguousBlocks(segments, preset, config.palettePreset, config.palette);
+  let line = ansiStyle("\u2591\u2592\u2593", { fg: preset.lead });
+  for (const [index, block] of blocks.entries()) {
+    const previous = index === 0 ? void 0 : blocks[index - 1]?.colors;
+    if (previous) line += ansiStyle("\uE0B4", { fg: previous.bg, bg: block.colors.bg });
+    line += ansiStyle(formatBlockText(block, config), block.colors);
+  }
+  const lastBlock = blocks.at(-1);
+  if (lastBlock) line += ansiStyle("\uE0B4", { fg: lastBlock.colors.bg });
+  return line;
+}
+function contiguousBlocks(segments, preset, palettePreset, configuredPalette) {
+  const blocks = [];
+  const usesConfiguredColors = palettePreset === "custom";
+  for (const segment2 of segments) {
+    const colors = usesConfiguredColors ? configuredPalette[segment2.name] ?? {} : preset.blocks[segment2.block];
+    const previous = blocks.at(-1);
+    const matchesPrevious = previous !== void 0 && (usesConfiguredColors ? colorsEqual(previous.colors, colors) : previous.baseBlock === segment2.block);
+    if (matchesPrevious) previous.segments.push(segment2);
+    else blocks.push({ baseBlock: segment2.block, colors, segments: [segment2] });
+  }
+  return blocks;
+}
+function colorsEqual(left, right) {
+  return left.fg === right.fg && left.bg === right.bg;
+}
+function formatBlockText(block, config) {
+  const texts = block.segments.map(formatSegmentText);
+  const separator = separatorText(config.separator, config.density === "cozy");
+  const leading = config.density === "cozy" ? "  " : " ";
+  const trailing = config.density === "cozy" ? " " : "";
+  return `${leading}${texts.join(separator)}${trailing}`;
+}
+function formatSegmentText(segment2) {
+  return segment2.emphasis ? `\x1B[1m${segment2.text}\x1B[22m` : segment2.text;
+}
+function separatorText(separator, cozy) {
+  const padding = cozy ? "  " : " ";
+  switch (separator) {
+    case "dot":
+      return `${padding}\u2022${padding}`;
+    case "bar":
+      return `${padding}\u2502${padding}`;
+    case "powerline":
+      return `${padding}\uE0B1${padding}`;
+    case "round":
+      return `${padding}\u276F${padding}`;
+    case "none":
+      return padding;
+  }
+}
+
+// src/extension-status.ts
+var STATUSLINE_KEY = "statusline";
+var COMPATIBLE_STATUS_ICON_KEYS = {
+  retry: "unknown-error-retry",
+  sync: "pisync",
+  "unknown-error-retry": "retry",
+  pisync: "sync"
+};
+var EMPTY_EXTENSION_STATUS_ICON_ALIASES = /* @__PURE__ */ new Map();
+function extensionStatusSeparator(config, theme) {
+  return powerlineExtensionSeparator(theme, config.palettePreset);
+}
+function formatExtensionStatuses(statuses, theme, config, runtime, hiddenKeys = /* @__PURE__ */ new Set()) {
+  const separator = extensionStatusSeparator(config, theme);
+  const visibleStatuses = [
+    ...formatDuplicateExtensionStatus(runtime, theme),
+    ...[...statuses.entries()].filter(
+      ([key, value]) => key !== STATUSLINE_KEY && !hiddenKeys.has(key) && value.trim().length > 0
+    ).map(
+      ([key, value]) => formatExtensionStatus(key, value, theme, config, runtime.extensionStatusIconAliases)
+    )
+  ].slice(0, 5);
+  return visibleStatuses.join(separator);
+}
+function formatExtensionStatus(key, value, theme, config, extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES) {
+  const status = splitExtensionStatusIcon(stripExtensionStatusPrefix(key, value));
+  const text = simplifyExtensionStatusText(status.text);
+  const color = extensionColor(key, value);
+  const textColor = color === "warning" ? "warning" : "muted";
+  const icon = extensionStatusIcon(
+    key,
+    status.icon,
+    config.extensionStatusIcons,
+    extensionStatusIconAliases
+  );
+  const renderedText = theme.fg(textColor, text);
+  return icon ? `${theme.fg(color, icon)} ${renderedText}` : renderedText;
+}
+function extensionStatusIcon(key, leadingIcon, configuredIcons, extensionStatusIconAliases) {
+  if (Object.hasOwn(configuredIcons, key)) return configuredIcons[key];
+  const namespaceIcon = configuredNamespaceIcon(key, configuredIcons);
+  if (namespaceIcon !== void 0) return namespaceIcon;
+  const compatibleKey = COMPATIBLE_STATUS_ICON_KEYS[key];
+  if (compatibleKey && Object.hasOwn(configuredIcons, compatibleKey)) {
+    return configuredIcons[compatibleKey];
+  }
+  for (const alias of extensionStatusAliasesForKey(key, extensionStatusIconAliases)) {
+    if (Object.hasOwn(configuredIcons, alias)) return configuredIcons[alias];
+  }
+  return leadingIcon ?? DEFAULT_EXTENSION_STATUS_ICONS[key] ?? "\u{1F50C}";
+}
+function configuredNamespaceIcon(key, configuredIcons) {
+  let match;
+  for (const [selector, icon] of Object.entries(configuredIcons)) {
+    if (!selector.endsWith(":*")) continue;
+    const base = selector.slice(0, -2);
+    if (!base || !key.startsWith(`${base}:`)) continue;
+    if (!match || base.length > match.baseLength) match = { baseLength: base.length, icon };
+  }
+  return match?.icon;
+}
+function extensionStatusAliasesForKey(key, extensionStatusIconAliases) {
+  for (const [statusBase, aliases] of extensionStatusIconAliases) {
+    if (statusKeyMatchesStatusBase(key, statusBase)) return aliases;
+  }
+  return [];
+}
+function statusKeyMatchesStatusBase(key, statusBase) {
+  return key === statusBase || key.startsWith(`${statusBase}:`) || key.startsWith(`${statusBase}/`);
+}
+function wrapExtensionStatusline(status, width) {
+  if (!status || width <= 0) return [];
+  return wrapTextWithAnsi(status, width);
+}
+function formatDuplicateExtensionStatus(runtime, theme) {
+  if (runtime.duplicateExtensions.length === 0) return [];
+  const names = runtime.duplicateExtensions.slice(0, 2).join(", ");
+  const suffix = runtime.duplicateExtensions.length > 2 ? ` +${runtime.duplicateExtensions.length - 2}` : "";
+  return [`${theme.fg("warning", "\u26A0\uFE0F")} ${theme.fg("warning", `dup ${names}${suffix}`)}`];
+}
+function splitExtensionStatusIcon(value) {
+  const trimmed = value.trim();
+  const [firstToken, ...restTokens] = trimmed.split(/\s+/);
+  if (firstToken && isEmojiOnlyToken(firstToken)) {
+    return { icon: firstToken, text: restTokens.join(" ") };
+  }
+  return { text: trimmed };
+}
+function isEmojiOnlyToken(value) {
+  return /^(?=.*(?:\p{Extended_Pictographic}|\p{Regional_Indicator}|[0-9#*]\ufe0f?\u20e3))(?:\p{Extended_Pictographic}|\p{Emoji_Modifier}|\p{Regional_Indicator}|\u200d|\ufe0f|[0-9#*]\ufe0f?\u20e3)+$/u.test(
+    value
+  );
+}
+function extensionColor(key, value) {
+  const normalized = `${key} ${value}`.toLowerCase();
+  if (/missing|error|fail|conflict|duplicate|unavailable/.test(normalized)) return "warning";
+  if (normalized.includes("codex")) return "accent";
+  if (/ready|active|running|enabled|awake|ok/.test(normalized)) return "success";
+  return "muted";
+}
+function stripExtensionStatusPrefix(key, value) {
+  return value.trim().replace(new RegExp(`^${escapeRegExp(key)}\\s*:\\s*`, "iu"), "");
+}
+function simplifyExtensionStatusText(value) {
+  return value.trim().replace(/\bready\b/giu, "\u2713").replace(/\bmissing\b/giu, "\u2717").replace(/,\s*/g, " ").replace(/\s+\([^)]*\)\s*$/, "").replace(/\s+/g, " ");
+}
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function readInstalledExtensionPackages(cwd) {
+  const packages = [];
+  const settingsFiles = extensionSettingsFiles(cwd);
+  for (const settingsFile of settingsFiles) {
+    const baseDirectory = dirname(settingsFile);
+    for (const rawSource of readPackageSources(settingsFile)) {
+      const source = rawSource.trim();
+      if (!source) continue;
+      const packageName = packageNameForSource(source, baseDirectory);
+      if (!packageName) continue;
+      packages.push({ packageName, source, identity: sourceIdentity(source, baseDirectory) });
+    }
+  }
+  return packages;
+}
+function extensionSettingsFiles(cwd) {
+  return [join(getAgentDir(), "settings.json"), join(cwd, ".pi", "settings.json")].filter(
+    (file) => existsSync(file)
+  );
+}
+function findDuplicateExtensions(installedPackages) {
+  const sourcesByPackage = /* @__PURE__ */ new Map();
+  for (const extensionPackage of installedPackages) {
+    const sources = sourcesByPackage.get(extensionPackage.packageName) ?? /* @__PURE__ */ new Set();
+    sources.add(extensionPackage.identity);
+    sourcesByPackage.set(extensionPackage.packageName, sources);
+  }
+  return [...sourcesByPackage.entries()].filter(([, sources]) => sources.size > 1).map(([packageName]) => packageName.replace(/^@[^/]+\//, "").replace(/^pi-/, ""));
+}
+function buildExtensionStatusIconAliases(installedPackages) {
+  const packageAliasesByStatusBase = /* @__PURE__ */ new Map();
+  for (const extensionPackage of installedPackages) {
+    const candidate = extensionStatusIconAliasCandidate(
+      extensionPackage.packageName,
+      extensionPackage.source
+    );
+    if (!candidate) continue;
+    const aliasesByPackage = packageAliasesByStatusBase.get(candidate.statusBase) ?? /* @__PURE__ */ new Map();
+    const existingAliases = aliasesByPackage.get(extensionPackage.packageName) ?? [];
+    aliasesByPackage.set(
+      extensionPackage.packageName,
+      uniqueStrings([...existingAliases, ...candidate.aliases])
+    );
+    packageAliasesByStatusBase.set(candidate.statusBase, aliasesByPackage);
+  }
+  const aliases = /* @__PURE__ */ new Map();
+  for (const [statusBase, aliasesByPackage] of packageAliasesByStatusBase) {
+    if (aliasesByPackage.size === 1)
+      aliases.set(statusBase, [...aliasesByPackage.values()][0] ?? []);
+  }
+  return aliases;
+}
+function extensionStatusIconAliasCandidate(packageName, source) {
+  const packageBase = packageBaseName(packageName);
+  const statusBase = statusBaseFromPackageBase(packageBase);
+  if (!statusBase) return void 0;
+  const sourceAliases = source?.startsWith("npm:") ? [source, `npm:${npmPackageName(source)}`] : [];
+  return {
+    statusBase,
+    aliases: uniqueStrings([...sourceAliases, packageName, packageBase, statusBase])
+  };
+}
+function packageBaseName(packageName) {
+  const slashIndex = packageName.lastIndexOf("/");
+  return slashIndex === -1 ? packageName : packageName.slice(slashIndex + 1);
+}
+function statusBaseFromPackageBase(packageBase) {
+  return packageBase.startsWith("pi-") && packageBase.length > "pi-".length ? packageBase.slice("pi-".length) : packageBase;
+}
+function uniqueStrings(values) {
+  return [...new Set(values.filter((value) => value.length > 0))];
+}
+function readPackageSources(settingsFile) {
+  try {
+    const settings = JSON.parse(readFileSync(settingsFile, "utf8"));
+    return (settings.packages ?? []).map((entry) => {
+      if (typeof entry === "string") return entry;
+      if (entry && typeof entry === "object" && typeof entry.source === "string") {
+        return entry.source;
+      }
+      return void 0;
+    }).filter((source) => source !== void 0);
+  } catch {
+    return [];
+  }
+}
+function packageNameForSource(source, baseDirectory) {
+  if (source.startsWith("npm:")) return npmPackageName(source);
+  const packageJson = join(resolveSourcePath(source, baseDirectory), "package.json");
+  try {
+    const packageData = JSON.parse(readFileSync(packageJson, "utf8"));
+    return typeof packageData.name === "string" ? packageData.name : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function npmPackageName(source) {
+  const spec = source.slice("npm:".length);
+  if (spec.startsWith("@")) return spec.split("@").slice(0, 2).join("@");
+  return spec.split("@")[0] ?? spec;
+}
+function sourceIdentity(source, baseDirectory) {
+  if (source.startsWith("npm:")) return `npm:${npmPackageName(source)}`;
+  return resolveSourcePath(source, baseDirectory);
+}
+function resolveSourcePath(source, baseDirectory) {
+  return isAbsolute(source) ? source : resolve(baseDirectory, source);
+}
+
+// src/git-status.ts
+import { isAbsolute as isAbsolute2 } from "node:path";
+var GIT_STATUS_TIMEOUT_MS = 3e3;
+async function readGitStatus(pi, cwd, signal) {
+  const [statusResult, rootResult] = await Promise.all([
+    pi.exec(
+      "git",
+      ["--no-optional-locks", "status", "--porcelain=v1", "--branch", "--untracked-files=normal"],
+      { cwd, timeout: GIT_STATUS_TIMEOUT_MS, signal }
+    ),
+    pi.exec("git", ["rev-parse", "--path-format=absolute", "--show-toplevel"], {
+      cwd,
+      timeout: GIT_STATUS_TIMEOUT_MS,
+      signal
+    }).catch(() => void 0)
+  ]);
+  if (statusResult.code !== 0 || statusResult.killed) return void 0;
+  const summary = parseGitStatusPorcelain(statusResult.stdout);
+  if (rootResult && rootResult.code === 0 && !rootResult.killed) {
+    const root = parseGitRoot(rootResult.stdout);
+    if (root) summary.root = root;
+  }
+  return summary;
+}
+function parseGitStatusPorcelain(output) {
+  const summary = {
+    ahead: 0,
+    behind: 0,
+    staged: 0,
+    modified: 0,
+    untracked: 0,
+    conflicts: 0
+  };
+  for (const line of output.split(/\r?\n/)) {
+    if (!line) continue;
+    if (line.startsWith("## ")) {
+      const ahead = line.match(/\bahead (\d+)/u);
+      const behind = line.match(/\bbehind (\d+)/u);
+      summary.ahead = ahead ? Number(ahead[1]) : 0;
+      summary.behind = behind ? Number(behind[1]) : 0;
+      continue;
+    }
+    const indexStatus = line[0] ?? " ";
+    const worktreeStatus = line[1] ?? " ";
+    if (indexStatus === "?" && worktreeStatus === "?") {
+      summary.untracked += 1;
+      continue;
+    }
+    if (isConflictStatus(indexStatus, worktreeStatus)) {
+      summary.conflicts += 1;
+      continue;
+    }
+    if (isChangedStatus(indexStatus)) summary.staged += 1;
+    if (isChangedStatus(worktreeStatus)) summary.modified += 1;
+  }
+  return summary;
+}
+function isConflictStatus(indexStatus, worktreeStatus) {
+  return indexStatus === "D" && worktreeStatus === "D" || indexStatus === "A" && worktreeStatus === "A" || indexStatus === "U" || worktreeStatus === "U";
+}
+function isChangedStatus(status) {
+  return status !== " " && status !== "?" && status !== "!";
+}
+function parseGitRoot(output) {
+  const root = output.split(/\r?\n/u)[0]?.trim();
+  return root && isAbsolute2(root) ? root : void 0;
+}
+function formatGitStatusSummary(summary) {
+  if (!summary) return "";
+  const tokens = [
+    ["\u21E1", summary.ahead],
+    ["\u21E3", summary.behind],
+    ["+", summary.staged],
+    ["~", summary.modified],
+    ["?", summary.untracked],
+    ["!", summary.conflicts]
+  ];
+  return tokens.filter(([, count]) => count > 0).map(([prefix, count]) => `${prefix}${formatCount(count)}`).join(" ");
+}
+function formatGitBranchValue(branch, status, pr) {
+  if (!branch) return "no-git";
+  const suffixes = [formatGitStatusSummary(status), pr ? `(${pr})` : ""].filter(Boolean);
+  return suffixes.length > 0 ? `${branch} ${suffixes.join(" ")}` : branch;
+}
+function gitStatusSummaryEqual(left, right) {
+  if (!left || !right) return left === right;
+  return left.root === right.root && left.ahead === right.ahead && left.behind === right.behind && left.staged === right.staged && left.modified === right.modified && left.untracked === right.untracked && left.conflicts === right.conflicts;
+}
+function formatCount(value) {
+  return Intl.NumberFormat("en", { notation: "compact", maximumFractionDigits: 1 }).format(value);
+}
+
+// src/render.ts
+import { sanitizeTerminalText as sanitizeTerminalText2 } from "@narumitw/pi-tui-kit/terminal-text";
+
+// src/directory.ts
+import { basename, isAbsolute as isAbsolute3, relative, sep } from "node:path";
+import { sanitizeTerminalText } from "@narumitw/pi-tui-kit/terminal-text";
+var DEFAULT_TRUNCATION_LENGTH = 3;
+var DEFAULT_HOME_SYMBOL = "~";
+function formatDirectoryPath(cwd, homeDir, gitRoot) {
+  const contracted = gitRoot && (!homeDir || !samePath(gitRoot, homeDir)) ? contractRepositoryPath(cwd, gitRoot) ?? contractPath(cwd, homeDir, DEFAULT_HOME_SYMBOL) : contractPath(cwd, homeDir, DEFAULT_HOME_SYMBOL);
+  const safeContracted = sanitizeTerminalText(contracted);
+  const components = safeContracted.split("/").filter((component) => component.length > 0);
+  const displayed = components.length > DEFAULT_TRUNCATION_LENGTH ? components.slice(-DEFAULT_TRUNCATION_LENGTH).join("/") : safeContracted;
+  const native = sep === "/" ? displayed : displayed.replaceAll("/", sep);
+  return sanitizeTerminalText(native || basename(cwd) || cwd);
+}
+function toSlashPath(value) {
+  return sep === "\\" ? value.replaceAll("\\", "/") : value;
+}
+function contractPath(path, root, replacement) {
+  if (!root) return toSlashPath(path);
+  const child = relativeWithin(path, root);
+  if (child === void 0) return toSlashPath(path);
+  return child ? `${replacement}/${child}` : replacement;
+}
+function contractRepositoryPath(path, root) {
+  const child = relativeWithin(path, root);
+  if (child === void 0) return void 0;
+  const name = basename(root) || toSlashPath(root);
+  return child ? `${name}/${child}` : name;
+}
+function relativeWithin(path, root) {
+  const child = relative(root, path);
+  if (child === "") return "";
+  if (child === ".." || child.startsWith(`..${sep}`) || isAbsolute3(child)) return void 0;
+  return toSlashPath(child);
+}
+function samePath(left, right) {
+  return relative(left, right) === "";
+}
+
+// src/usage.ts
+function summarizeFooterUsage(entries) {
+  const totals = {
+    input: 0,
+    output: 0,
+    cacheRead: 0,
+    cacheWrite: 0,
+    cost: 0
+  };
+  for (const entry of entries) {
+    let usage;
+    if (entry.type === "message" && entry.message.role === "assistant") {
+      usage = entry.message.usage;
+      const input = usage.input ?? 0;
+      const cacheRead = usage.cacheRead ?? 0;
+      const cacheWrite = usage.cacheWrite ?? 0;
+      const promptTokens = input + cacheRead + cacheWrite;
+      totals.latestCacheHitRate = promptTokens > 0 ? cacheRead / promptTokens * 100 : void 0;
+    } else if (entry.type === "message" && entry.message.role === "toolResult") {
+      usage = entry.message.usage;
+    } else if (entry.type === "compaction" || entry.type === "branch_summary") {
+      usage = entry.usage;
+    }
+    if (!usage) continue;
+    totals.input += usage.input ?? 0;
+    totals.output += usage.output ?? 0;
+    totals.cacheRead += usage.cacheRead ?? 0;
+    totals.cacheWrite += usage.cacheWrite ?? 0;
+    totals.cost += usage.cost?.total ?? 0;
+  }
+  return totals;
+}
+
+// src/render.ts
+var GITHUB_PR_KEY = "github-pr";
+var GITHUB_PR_STATUS_KEYS = /* @__PURE__ */ new Set([GITHUB_PR_KEY]);
+function renderStatusline(width, ctx, footerData, _theme, config, runtime) {
+  if (width <= 0) return "";
+  const usageSummary = summarizeFooterUsage(ctx.sessionManager.getEntries());
+  const rows = [
+    { configuredSegments: 0, segments: [] }
+  ];
+  for (const name of config.segments) {
+    if (name === LINE_BREAK_SEGMENT_NAME) {
+      rows.push({ configuredSegments: 0, segments: [] });
+      continue;
+    }
+    const row = rows.at(-1);
+    if (!row) continue;
+    row.configuredSegments += 1;
+    const rendered = buildSegment(name, ctx, footerData, config, runtime, usageSummary);
+    if (rendered && rendered.text.length > 0) row.segments.push(rendered);
+  }
+  const segments = [];
+  const renderedRows = rows.filter(
+    (row) => row.configuredSegments === 0 || row.segments.length > 0
+  );
+  for (const [index, row] of renderedRows.entries()) {
+    if (index > 0) segments.push({ name: LINE_BREAK_SEGMENT_NAME });
+    segments.push(...row.segments);
+  }
+  return renderPowerlineStatusline(width, segments, config);
+}
+function renderExtensionStatusline(width, footerData, theme, config, runtime, mainLine) {
+  const statuses = footerData.getExtensionStatuses();
+  const prContext = prContextFromStatuses(statuses);
+  const rendersPrInline = prContext !== void 0 && mainLine.includes(prContext);
+  const status = formatExtensionStatuses(
+    statuses,
+    theme,
+    config,
+    runtime,
+    rendersPrInline ? GITHUB_PR_STATUS_KEYS : void 0
+  );
+  return wrapExtensionStatusline(status, width);
+}
+function buildSegment(name, ctx, footerData, config, runtime, usageSummary) {
+  switch (name) {
+    case "brand":
+      return segment(name, "\u03C0", config, "accent", "header", true);
+    case "provider":
+      return segment(name, ctx.model?.provider ?? "no-provider", config, "accent", "header");
+    case "model": {
+      const presentation = config.segmentText.model;
+      const model = truncateModel(
+        shortenModel(ctx.model?.id ?? "no-model"),
+        presentation.truncationLength,
+        presentation.truncationSymbol,
+        presentation.truncationDirection
+      );
+      return segment(name, model, config, "accent", "header");
+    }
+    case "thinking":
+      return segment(
+        name,
+        runtime.thinkingLevel,
+        config,
+        thinkingColor(runtime.thinkingLevel),
+        "header"
+      );
+    case "branch": {
+      const branch = footerData.getGitBranch();
+      const pr = branch ? prContextFromStatuses(footerData.getExtensionStatuses()) : void 0;
+      return segment(
+        name,
+        formatGitBranchValue(branch, runtime.gitStatus, pr),
+        config,
+        "accent",
+        "git"
+      );
+    }
+    case "cwd":
+      return segment(
+        name,
+        formatDirectoryPath(ctx.cwd, runtime.homeDir, runtime.gitStatus?.root),
+        config,
+        "accent",
+        "directory"
+      );
+    case "tools": {
+      const activity = formatToolActivity(runtime);
+      return activity ? segment(name, activity, config, "accent", "runtime") : void 0;
+    }
+    case "context": {
+      const usage = ctx.getContextUsage();
+      const percentage = usage?.percent === null || usage?.percent === void 0 ? "?" : `${usage.percent.toFixed(1)}%`;
+      const contextWindow = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
+      return segment(
+        name,
+        `${percentage}/${formatCount2(contextWindow)}`,
+        config,
+        contextColor(usage?.percent),
+        "runtime"
+      );
+    }
+    case "tokens": {
+      const value = usageSummary.input === 0 && usageSummary.output === 0 ? "tok 0" : `\u2191${formatCount2(usageSummary.input)} \u2193${formatCount2(usageSummary.output)}`;
+      return segment(name, value, config, "accent", "runtime");
+    }
+    case "cache": {
+      if (usageSummary.cacheRead === 0 && usageSummary.cacheWrite === 0) return void 0;
+      const values = [];
+      if (usageSummary.cacheRead > 0) values.push(`R${formatCount2(usageSummary.cacheRead)}`);
+      if (usageSummary.cacheWrite > 0) values.push(`W${formatCount2(usageSummary.cacheWrite)}`);
+      if (usageSummary.latestCacheHitRate !== void 0) {
+        values.push(`CH${usageSummary.latestCacheHitRate.toFixed(1)}%`);
+      }
+      return segment(name, values.join(" "), config, "accent", "runtime");
+    }
+    case "cost": {
+      const subscription = isSubscriptionBacked(ctx) ? " (sub)" : "";
+      return segment(
+        name,
+        `${usageSummary.cost.toFixed(usageSummary.cost >= 1 ? 2 : 3)}${subscription}`,
+        config,
+        "accent",
+        "meter"
+      );
+    }
+    case "time":
+      return segment(name, formatTime(), config, "accent", "meter");
+    case "turn":
+      return segment(name, `${runtime.turnCount}`, config, "accent", "meter");
+  }
+}
+function segment(name, value, config, color, block, emphasis = false) {
+  return { name, text: formatConfiguredSegment(name, value, config), color, block, emphasis };
+}
+function formatConfiguredSegment(name, value, config) {
+  const presentation = config.segmentText[name];
+  return `${presentation.prefix}${value}${presentation.suffix}`;
+}
+function thinkingColor(level) {
+  switch (level) {
+    case "off":
+      return "dim";
+    case "minimal":
+      return "thinkingMinimal";
+    case "low":
+      return "thinkingLow";
+    case "medium":
+      return "thinkingMedium";
+    case "high":
+      return "thinkingHigh";
+    case "xhigh":
+      return "thinkingXhigh";
+    case "max":
+      return "thinkingMax";
+    default:
+      return "dim";
+  }
+}
+function contextColor(percent) {
+  if (percent === null || percent === void 0) return "dim";
+  if (percent >= 90) return "error";
+  if (percent >= 70) return "warning";
+  return "success";
+}
+function formatToolActivity(runtime) {
+  const active = [...runtime.activeTools.entries()];
+  if (active.length > 0) {
+    const [name, count] = active[0] ?? ["tool", 1];
+    const suffix = count > 1 ? `\xD7${count}` : active.length > 1 ? `+${active.length - 1}` : "";
+    return `\u2699 ${name}${suffix}`;
+  }
+  return runtime.isStreaming ? "\u{1F4AD} thinking" : void 0;
+}
+function prLinkFromStatuses(statuses) {
+  const value = statuses.get(GITHUB_PR_KEY);
+  if (!value) return void 0;
+  const open = value.indexOf("\x1B]8;;");
+  if (open === -1) return void 0;
+  const closeMarker = "\x1B]8;;\x07";
+  const close = value.indexOf(closeMarker, open + 1);
+  return close === -1 ? void 0 : value.slice(open, close + closeMarker.length);
+}
+function prContextFromStatuses(statuses) {
+  const value = statuses.get(GITHUB_PR_KEY);
+  const link = prLinkFromStatuses(statuses);
+  if (!value || !link) return void 0;
+  const state = compactPrState(value.replace(link, ""));
+  return state ? `${link} \xB7 ${state}` : void 0;
+}
+function compactPrState(value) {
+  if (/:\s*merged\s*$/.test(value)) return "merged";
+  if (/:\s*closed\s*$/.test(value)) return "closed";
+  if (/\bdraft\b/.test(value)) return "draft";
+  const failing = /\bchecks failing \((\d+)\)/.exec(value);
+  if (failing) return `${failing[1]} failing`;
+  if (/\bchanges requested\b/.test(value)) return "changes requested";
+  const pending = /\bchecks pending \((\d+)\)/.exec(value);
+  if (pending) return `${pending[1]} pending`;
+  if (/\bapproved\b/.test(value)) return "approved";
+  if (/\breview required\b/.test(value)) return "review required";
+  if (/\bchecks passing\b/.test(value)) return "checks passing";
+  if (/\bno checks\b/.test(value)) return "no checks";
+  return void 0;
+}
+function isSubscriptionBacked(ctx) {
+  const model = ctx.model;
+  return model !== void 0 && (model.provider === "kimi-coding" || ctx.modelRegistry.isUsingOAuth(model));
+}
+function formatCount2(value) {
+  if (value < 1e3) return `${value}`;
+  if (value < 1e6) return `${(value / 1e3).toFixed(value < 1e4 ? 1 : 0)}k`;
+  return `${(value / 1e6).toFixed(1)}m`;
+}
+function formatTime() {
+  const now = /* @__PURE__ */ new Date();
+  const hours = now.getHours().toString().padStart(2, "0");
+  const minutes = now.getMinutes().toString().padStart(2, "0");
+  return `${hours}:${minutes}`;
+}
+var graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
+function truncateModel(model, length, symbol, direction) {
+  const safeModel = sanitizeTerminalText2(model);
+  if (length === 0) return safeModel;
+  const graphemes = [...graphemeSegmenter.segment(safeModel)].map(({ segment: segment2 }) => segment2);
+  if (graphemes.length <= length) return safeModel;
+  const safeSymbol = sanitizeTerminalText2(symbol);
+  switch (direction) {
+    case "start":
+      return `${safeSymbol}${graphemes.slice(-length).join("")}`;
+    case "middle": {
+      const headLength = Math.ceil(length / 2);
+      const tailLength = Math.floor(length / 2);
+      const tail = tailLength > 0 ? graphemes.slice(-tailLength).join("") : "";
+      return `${graphemes.slice(0, headLength).join("")}${safeSymbol}${tail}`;
+    }
+    case "end":
+      return `${graphemes.slice(0, length).join("")}${safeSymbol}`;
+  }
+}
+function shortenModel(model) {
+  return model.replace(/^claude-/, "").replace(/^gpt-/, "gpt ").replace(/-20\d{6}$/, "").replace(/-latest$/, "");
+}
+
+// src/statusline.ts
+var STATUSLINE_KEY2 = "statusline";
+var GIT_STATUS_REFRESH_INTERVAL_MS = 3e4;
+var GIT_STATUS_EVENT_DEBOUNCE_MS = 250;
+var EMPTY_EXTENSION_STATUS_ICON_ALIASES2 = /* @__PURE__ */ new Map();
+var statuslineCommandsPromise;
+function loadStatuslineCommands() {
+  if (!statuslineCommandsPromise) {
+    statuslineCommandsPromise = import("./chunks/commands-5CMKUNTM.js").catch((error) => {
+      statuslineCommandsPromise = void 0;
+      throw error;
+    });
+  }
+  return statuslineCommandsPromise;
+}
+function statusline(pi) {
+  let loaded;
+  let previewPalettePreset;
+  let activeSessionManager;
+  const runtime = {
+    turnCount: 0,
+    activeTools: /* @__PURE__ */ new Map(),
+    isStreaming: false,
+    thinkingLevel: "off",
+    duplicateExtensions: [],
+    extensionStatusIconAliases: EMPTY_EXTENSION_STATUS_ICON_ALIASES2
+  };
+  let sessionGeneration = 0;
+  let menuController = new AbortController();
+  let gitStatusRequestId = 0;
+  let activeGitStatusTarget;
+  let gitStatusRefreshInFlight = false;
+  let gitStatusAbortController;
+  let gitStatusDebounceTimer;
+  let pendingGitStatusRefresh;
+  const refresh = () => runtime.requestRender?.();
+  const ownsRuntime = (ctx) => ctx.sessionManager === activeSessionManager;
+  const setGitStatus = (summary) => {
+    if (gitStatusSummaryEqual(runtime.gitStatus, summary)) return;
+    runtime.gitStatus = summary;
+    refresh();
+  };
+  const clearGitStatusDebounce = () => {
+    if (!gitStatusDebounceTimer) return;
+    clearTimeout(gitStatusDebounceTimer);
+    gitStatusDebounceTimer = void 0;
+  };
+  const abortGitStatusRefresh = (reason) => {
+    gitStatusAbortController?.abort(new DOMException(reason, "AbortError"));
+  };
+  const isActiveGitStatusTarget = (cwd, generation) => activeGitStatusTarget?.cwd === cwd && activeGitStatusTarget.generation === generation && generation === sessionGeneration;
+  const isCurrentGitStatusRequest = (cwd, generation, requestId) => isActiveGitStatusTarget(cwd, generation) && requestId === gitStatusRequestId;
+  const runGitStatusRefresh = (cwd, generation, requestId) => {
+    if (!isCurrentGitStatusRequest(cwd, generation, requestId)) return;
+    if (gitStatusRefreshInFlight) {
+      pendingGitStatusRefresh = { cwd, generation, requestId };
+      return;
+    }
+    gitStatusRefreshInFlight = true;
+    const abortController = new AbortController();
+    gitStatusAbortController = abortController;
+    void (async () => {
+      try {
+        const summary = await readGitStatus(pi, cwd, abortController.signal);
+        if (isCurrentGitStatusRequest(cwd, generation, requestId)) setGitStatus(summary);
+      } catch {
+        if (isCurrentGitStatusRequest(cwd, generation, requestId)) setGitStatus(void 0);
+      } finally {
+        gitStatusRefreshInFlight = false;
+        if (gitStatusAbortController === abortController) gitStatusAbortController = void 0;
+        const pending = pendingGitStatusRefresh;
+        pendingGitStatusRefresh = void 0;
+        if (pending) runGitStatusRefresh(pending.cwd, pending.generation, pending.requestId);
+      }
+    })();
+  };
+  const refreshGitStatus = (cwd, generation = sessionGeneration) => {
+    if (!isActiveGitStatusTarget(cwd, generation)) return;
+    runGitStatusRefresh(cwd, generation, ++gitStatusRequestId);
+  };
+  const scheduleGitStatusRefresh = (cwd, generation = sessionGeneration) => {
+    if (!isActiveGitStatusTarget(cwd, generation)) return;
+    const requestId = ++gitStatusRequestId;
+    clearGitStatusDebounce();
+    gitStatusDebounceTimer = setTimeout(() => {
+      gitStatusDebounceTimer = void 0;
+      runGitStatusRefresh(cwd, generation, requestId);
+    }, GIT_STATUS_EVENT_DEBOUNCE_MS);
+  };
+  const scheduleGitStatusRefreshForContext = (ctx) => {
+    if (!activeGitStatusTarget || activeGitStatusTarget.cwd !== ctx.cwd) return;
+    scheduleGitStatusRefresh(activeGitStatusTarget.cwd, activeGitStatusTarget.generation);
+  };
+  const installFooter = (ctx) => {
+    const generation = ++sessionGeneration;
+    menuController.abort(new DOMException("Statusline session context replaced", "AbortError"));
+    menuController = new AbortController();
+    const cwd = ctx.cwd;
+    activeSessionManager = ctx.sessionManager;
+    runtime.homeDir = homedir();
+    previewPalettePreset = void 0;
+    abortGitStatusRefresh("Statusline session context replaced");
+    clearGitStatusDebounce();
+    activeGitStatusTarget = ctx.mode === "tui" ? { cwd, generation } : void 0;
+    runtime.gitStatus = void 0;
+    runtime.duplicateExtensions = [];
+    runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES2;
+    ctx.ui.setStatus(STATUSLINE_KEY2, void 0);
+    if (!activeGitStatusTarget || !loaded) return;
+    const installedPackages = readInstalledExtensionPackages(cwd);
+    runtime.duplicateExtensions = findDuplicateExtensions(installedPackages);
+    runtime.extensionStatusIconAliases = buildExtensionStatusIconAliases(installedPackages);
+    ctx.ui.setFooter((tui, theme, footerData) => {
+      runtime.requestRender = () => tui.requestRender();
+      const refreshFooterGitStatus = () => refreshGitStatus(cwd, generation);
+      const branchUnsubscribe = footerData.onBranchChange(() => {
+        runtime.gitStatus = void 0;
+        abortGitStatusRefresh("Statusline Git branch changed");
+        clearGitStatusDebounce();
+        refreshFooterGitStatus();
+        tui.requestRender();
+      });
+      const clock = setInterval(() => {
+        clearGitStatusDebounce();
+        refreshFooterGitStatus();
+        tui.requestRender();
+      }, GIT_STATUS_REFRESH_INTERVAL_MS);
+      return {
+        dispose() {
+          branchUnsubscribe();
+          clearInterval(clock);
+          if (isActiveGitStatusTarget(cwd, generation)) {
+            activeGitStatusTarget = void 0;
+            abortGitStatusRefresh("Statusline footer disposed");
+            clearGitStatusDebounce();
+            pendingGitStatusRefresh = void 0;
+            runtime.gitStatus = void 0;
+            runtime.duplicateExtensions = [];
+            runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES2;
+            runtime.requestRender = void 0;
+          }
+        },
+        invalidate() {
+        },
+        render(width) {
+          if (!loaded) return [];
+          const config = previewPalettePreset ? { ...loaded.config, palettePreset: previewPalettePreset } : loaded.config;
+          const mainLine = renderStatusline(width, ctx, footerData, theme, config, runtime);
+          const lines = mainLine ? mainLine.split("\n") : [];
+          lines.push(
+            ...renderExtensionStatusline(width, footerData, theme, config, runtime, mainLine)
+          );
+          return lines;
+        }
+      };
+    });
+    refreshGitStatus(cwd, generation);
+  };
+  const agentDir = getAgentDir2();
+  const configPath = settingsFilePath(agentDir);
+  const commandOptions = {
+    settingsPath: configPath,
+    getLoaded: () => loaded ?? loadStatuslineSettings(configPath),
+    getMenuOwner: () => {
+      const generation = sessionGeneration;
+      return {
+        signal: menuController.signal,
+        isCurrent: () => generation === sessionGeneration && !menuController.signal.aborted
+      };
+    },
+    apply(next, ctx) {
+      if (ctx.sessionManager !== activeSessionManager) return;
+      previewPalettePreset = void 0;
+      loaded = next;
+      refresh();
+    },
+    preview(palettePreset, ctx) {
+      if (ctx.sessionManager !== activeSessionManager) return;
+      previewPalettePreset = palettePreset;
+      refresh();
+    }
+  };
+  pi.registerCommand("statusline", {
+    description: "Open or inspect the statusline settings",
+    getArgumentCompletions: completeStatuslineArguments,
+    handler: async (args, ctx) => {
+      const commands = await loadStatuslineCommands();
+      if (ctx.sessionManager !== activeSessionManager) return;
+      await commands.handleStatuslineCommand(args, ctx, commandOptions);
+    }
+  });
+  pi.on("session_start", (_event, ctx) => {
+    runtime.turnCount = 0;
+    runtime.activeTools.clear();
+    runtime.isStreaming = false;
+    loaded = loadStatuslineSettingsForAgent(agentDir);
+    const settingsNotice = consumeStatuslineSettingsNotice();
+    if (settingsNotice) ctx.ui.notify(settingsNotice, "warning");
+    if (loaded.diagnostics.length > 0) {
+      ctx.ui.notify(formatSettingsDiagnostics(loaded), "warning");
+    }
+    runtime.thinkingLevel = pi.getThinkingLevel();
+    installFooter(ctx);
+  });
+  pi.on("session_tree", (_event, ctx) => {
+    installFooter(ctx);
+    refresh();
+  });
+  pi.on("session_shutdown", (_event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    sessionGeneration += 1;
+    menuController.abort(new DOMException("Statusline session shut down", "AbortError"));
+    activeSessionManager = void 0;
+    previewPalettePreset = void 0;
+    activeGitStatusTarget = void 0;
+    abortGitStatusRefresh("Statusline session shut down");
+    clearGitStatusDebounce();
+    pendingGitStatusRefresh = void 0;
+    runtime.gitStatus = void 0;
+    runtime.activeTools.clear();
+    runtime.isStreaming = false;
+    runtime.duplicateExtensions = [];
+    runtime.extensionStatusIconAliases = EMPTY_EXTENSION_STATUS_ICON_ALIASES2;
+    ctx.ui.setFooter(void 0);
+    ctx.ui.setStatus(STATUSLINE_KEY2, void 0);
+    runtime.requestRender = void 0;
+  });
+  pi.on("model_select", () => refresh());
+  pi.on("thinking_level_select", (event) => {
+    runtime.thinkingLevel = event.level;
+    refresh();
+  });
+  pi.on("agent_start", (_event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    runtime.isStreaming = true;
+    refresh();
+  });
+  pi.on("agent_end", (_event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    runtime.activeTools.clear();
+    scheduleGitStatusRefreshForContext(ctx);
+    refresh();
+  });
+  pi.on("agent_settled", (_event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    runtime.isStreaming = false;
+    runtime.activeTools.clear();
+    refresh();
+  });
+  pi.on("turn_start", (_event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    runtime.turnCount += 1;
+    runtime.isStreaming = true;
+    refresh();
+  });
+  pi.on("turn_end", (_event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    scheduleGitStatusRefreshForContext(ctx);
+    refresh();
+  });
+  pi.on("tool_execution_start", (event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    const currentCount = runtime.activeTools.get(event.toolName) ?? 0;
+    runtime.activeTools.set(event.toolName, currentCount + 1);
+    refresh();
+  });
+  pi.on("tool_execution_end", (event, ctx) => {
+    if (!ownsRuntime(ctx)) return;
+    const currentCount = runtime.activeTools.get(event.toolName) ?? 0;
+    if (currentCount <= 1) runtime.activeTools.delete(event.toolName);
+    else runtime.activeTools.set(event.toolName, currentCount - 1);
+    scheduleGitStatusRefreshForContext(ctx);
+    refresh();
+  });
+}
+function formatSettingsDiagnostics(loaded) {
+  const details = loaded.diagnostics.slice(0, 5).map((item) => item.message);
+  const remaining = loaded.diagnostics.length - details.length;
+  return [
+    `pi-statusline settings: ${details.join("; ")}`,
+    ...remaining > 0 ? [`+${remaining} more`] : []
+  ].join(" ");
+}
+export {
+  statusline as default
+};
+//# sourceMappingURL=index.ts.map