pinglet-cli 0.6.2 → 0.7.0

package/dist/commands/statusline.js

@@ -34,6 +34,7 @@ var __importStar = (this && this.__importStar) || (function () {
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.runStatusline = runStatusline;
+exports.writeStatusline = writeStatusline;
 const fs = __importStar(require("fs"));
 const config_1 = require("../config");
 const cache_1 = require("../cache");
@@ -42,6 +43,7 @@ const picker_1 = require("../picker");
 const queue_1 = require("../queue");
 const claude_1 = require("../adapters/claude");
 const runtime_1 = require("../runtime");
+const hud_1 = require("../hud");
 /**
  * online 캐시 유효 기간 — refresh(≈5분) 2주기. 서버의 온라인 판정 창
  * (ONLINE_WINDOW_MS 10분)과 정렬해, 서버가 이미 오프라인으로 세는 시점에
@@ -61,7 +63,8 @@ function onlineOthers(now) {
 }
 function readPayload() {
     try {
-        return JSON.parse(fs.readFileSync(0, "utf8"));
+        const parsed = JSON.parse(fs.readFileSync(0, "utf8"));
+        return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : {};
     }
     catch {
         return {};
@@ -138,15 +141,18 @@ function rotateSpinner(state, now) {
     };
 }
 /**
- * Claude Code statusLine hook 진입점.
+ * Claude Code statusLine hook 진입점 (로컬 잠금 안, 동기).
  * - spinner 회전(pool=1): ROTATE_MS마다 다음 메시지를 armed (설정 핫리로드로 즉시 반영)
  * - 노출 측정: stdin payload의 cost 델타로 armed 메시지의 실제 표시 시간을 누적
- * - statusline 표시: 지금 함께 켜져 있는 터미널 수
  * - flush/refresh 백그라운드 트리거 (Claude 사용 중 항상 호출되므로 이 경로에서)
+ * 출력할 줄과 payload를 돌려주면 호출부가 잠금을 놓고 `writeStatusline`으로 HUD까지 그린다.
  */
 function runStatusline() {
-    if (!fs.existsSync(config_1.CONFIG_PATH) || !(0, config_1.loadConfig)().adapters.claude)
-        return;
+    if (!fs.existsSync(config_1.CONFIG_PATH))
+        return undefined;
+    const config = (0, config_1.loadConfig)();
+    if (!config.adapters.claude)
+        return undefined;
     const payload = readPayload();
     const state = (0, cache_1.loadState)();
     const now = Date.now();
@@ -165,6 +171,23 @@ function runStatusline() {
         state.lastTickAt = now;
         (0, cache_1.saveState)(state);
     }
+    const lines = [];
     const others = onlineOthers(now);
-    process.stdout.write(others !== null ? (0, render_1.formatOnlineNow)(others) : "");
+    if (others !== null)
+        lines.push((0, render_1.formatOnlineNow)(others));
+    return { payload, lines, hud: (0, hud_1.loadHudConfig)(config) };
+}
+/**
+ * 잠금 밖에서 HUD(모델·컨텍스트·사용량·활동)를 그려 "함께 코딩 중" 줄 아래에 출력한다.
+ * HUD는 실패해도 위 줄에 영향을 주면 안 된다.
+ */
+async function writeStatusline(tick, now = Date.now(), write = (text) => { process.stdout.write(text); }) {
+    const lines = [...tick.lines];
+    try {
+        lines.push(...(await (0, hud_1.renderHudLines)(tick.hud, tick.payload, now)));
+    }
+    catch {
+        // 손상된 transcript·git 오류 등 — 이번 tick은 HUD 없이 그린다.
+    }
+    write(lines.join("\n"));
 }

package/dist/config.js

@@ -93,6 +93,7 @@ function loadConfig() {
         const object = (v) => !!v && typeof v === "object" && !Array.isArray(v);
         if (typeof existing.apiBaseUrl !== "string" || typeof existing.createdAt !== "string" ||
             (existing.userToken !== undefined && typeof existing.userToken !== "string") ||
+            (existing.hud !== undefined && !object(existing.hud)) ||
             (existing.installations !== undefined && !object(existing.installations)) ||
             (existing.adapters !== undefined && !object(existing.adapters))) {
             throw new Error(`Invalid ${exports.CONFIG_PATH}; original file preserved.`);

package/dist/hud/colors.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.quotaBar = exports.contextBar = exports.critical = exports.warning = exports.label = exports.gitBranch = exports.git = exports.project = exports.model = exports.dim = exports.magenta = exports.cyan = exports.red = exports.yellow = exports.green = exports.RESET = void 0;
+exports.contextColor = contextColor;
+exports.quotaColor = quotaColor;
+exports.RESET = "\x1b[0m";
+const DIM = "\x1b[2m";
+const ANSI_BY_NAME = {
+    dim: DIM,
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    magenta: "\x1b[35m",
+    cyan: "\x1b[36m",
+    brightBlue: "\x1b[94m",
+    brightMagenta: "\x1b[95m",
+};
+function resolveAnsi(value, fallback) {
+    if (value === undefined || value === null)
+        return fallback;
+    if (typeof value === "number")
+        return `\x1b[38;5;${value}m`;
+    if (typeof value === "string" && value.startsWith("#") && value.length === 7) {
+        const r = parseInt(value.slice(1, 3), 16);
+        const g = parseInt(value.slice(3, 5), 16);
+        const b = parseInt(value.slice(5, 7), 16);
+        return `\x1b[38;2;${r};${g};${b}m`;
+    }
+    return ANSI_BY_NAME[value] ?? fallback;
+}
+const colorize = (text, ansi) => `${ansi}${text}${exports.RESET}`;
+const green = (t) => colorize(t, ANSI_BY_NAME.green);
+exports.green = green;
+const yellow = (t) => colorize(t, ANSI_BY_NAME.yellow);
+exports.yellow = yellow;
+const red = (t) => colorize(t, ANSI_BY_NAME.red);
+exports.red = red;
+const cyan = (t) => colorize(t, ANSI_BY_NAME.cyan);
+exports.cyan = cyan;
+const magenta = (t) => colorize(t, ANSI_BY_NAME.magenta);
+exports.magenta = magenta;
+const dim = (t) => colorize(t, DIM);
+exports.dim = dim;
+const model = (t, c) => colorize(t, resolveAnsi(c.model, ANSI_BY_NAME.cyan));
+exports.model = model;
+const project = (t, c) => colorize(t, resolveAnsi(c.project, ANSI_BY_NAME.yellow));
+exports.project = project;
+const git = (t, c) => colorize(t, resolveAnsi(c.git, ANSI_BY_NAME.magenta));
+exports.git = git;
+const gitBranch = (t, c) => colorize(t, resolveAnsi(c.gitBranch, ANSI_BY_NAME.cyan));
+exports.gitBranch = gitBranch;
+const label = (t, c) => colorize(t, resolveAnsi(c.label, DIM));
+exports.label = label;
+const warning = (t, c) => colorize(t, resolveAnsi(c.warning, ANSI_BY_NAME.yellow));
+exports.warning = warning;
+const critical = (t, c) => colorize(t, resolveAnsi(c.critical, ANSI_BY_NAME.red));
+exports.critical = critical;
+function contextColor(percent, c, thresholds) {
+    if (percent >= thresholds.critical)
+        return resolveAnsi(c.critical, ANSI_BY_NAME.red);
+    if (percent >= thresholds.warning)
+        return resolveAnsi(c.warning, ANSI_BY_NAME.yellow);
+    return resolveAnsi(c.context, ANSI_BY_NAME.green);
+}
+function quotaColor(percent, c) {
+    if (percent >= 90)
+        return resolveAnsi(c.critical, ANSI_BY_NAME.red);
+    if (percent >= 75)
+        return resolveAnsi(c.usageWarning, ANSI_BY_NAME.brightMagenta);
+    return resolveAnsi(c.usage, ANSI_BY_NAME.brightBlue);
+}
+function bar(percent, width, ansi, c) {
+    const safeWidth = Math.max(0, Math.round(width));
+    const safePercent = Number.isFinite(percent) ? Math.min(100, Math.max(0, percent)) : 0;
+    const filled = Math.round((safePercent / 100) * safeWidth);
+    return `${ansi}${c.barFilled.repeat(filled)}${DIM}${c.barEmpty.repeat(safeWidth - filled)}${exports.RESET}`;
+}
+const contextBar = (percent, width, c, thresholds) => bar(percent, width, contextColor(percent, c, thresholds), c);
+exports.contextBar = contextBar;
+const quotaBar = (percent, width, c) => bar(percent, width, quotaColor(percent, c), c);
+exports.quotaBar = quotaBar;

package/dist/hud/config.js

@@ -0,0 +1,300 @@
+"use strict";
+/**
+ * HUD 설정 — claude-hud(jarrodwatts/claude-hud)와 같은 키 체계를 쓴다.
+ * `~/.pinglet/config.json`의 `hud` 섹션에 저장되며, 값이 없거나 잘못되면
+ * 기본값으로 되돌린다 (statusline 렌더 경로에서 예외를 던지지 않기 위해).
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRESETS = exports.TOGGLE_KEYS = exports.DEFAULT_HUD_CONFIG = exports.DEFAULT_MERGE_GROUPS = exports.KNOWN_FIRST_LINE_SEGMENTS = exports.KNOWN_ELEMENTS = exports.DEFAULT_ELEMENT_ORDER = void 0;
+exports.setToggle = setToggle;
+exports.applyPreset = applyPreset;
+exports.normalizeHudConfig = normalizeHudConfig;
+exports.DEFAULT_ELEMENT_ORDER = [
+    "project",
+    "context",
+    "usage",
+    "promptCache",
+    "memory",
+    "tools",
+    "skills",
+    "agents",
+    "todos",
+];
+exports.KNOWN_ELEMENTS = new Set(exports.DEFAULT_ELEMENT_ORDER);
+exports.KNOWN_FIRST_LINE_SEGMENTS = new Set([
+    "model",
+    "project",
+    "advisor",
+    "sessionName",
+    "duration",
+    "cost",
+    "speed",
+]);
+/** 컨텍스트·사용량·캐시는 한 줄로 묶는다 (폭이 모자라면 렌더러가 다시 나눈다). */
+exports.DEFAULT_MERGE_GROUPS = [["context", "usage", "promptCache"]];
+/** 설정 파일에 없을 때 쓰는 기본값 — claude-hud의 "full" 프리셋과 같다. */
+exports.DEFAULT_HUD_CONFIG = {
+    enabled: true,
+    lineLayout: "expanded",
+    showSeparators: false,
+    pathLevels: 1,
+    maxWidth: null,
+    forceMaxWidth: false,
+    elementOrder: [...exports.DEFAULT_ELEMENT_ORDER],
+    projectLineOrder: [],
+    gitStatus: {
+        enabled: true,
+        showDirty: true,
+        showAheadBehind: true,
+        showFileStats: true,
+        branchOverflow: "truncate",
+        pushWarningThreshold: 0,
+        pushCriticalThreshold: 0,
+    },
+    display: {
+        showModel: true,
+        modelFormat: "full",
+        showProject: true,
+        showContextBar: true,
+        contextValue: "percent",
+        showTokenBreakdown: true,
+        showUsage: true,
+        usageValue: "percent",
+        usageBarEnabled: true,
+        showResetLabel: true,
+        usageCompact: false,
+        showModelScopedUsage: true,
+        timeFormat: "relative",
+        showTools: true,
+        toolNameMaxLength: 0,
+        toolsMaxVisible: 4,
+        showSkills: true,
+        showAgents: true,
+        showTodos: true,
+        showSessionName: true,
+        showDuration: true,
+        showCost: true,
+        showSpeed: true,
+        showEffortLevel: true,
+        effortFormat: "full",
+        showSessionTokens: true,
+        showCompactions: true,
+        showMemoryUsage: true,
+        showPromptCache: true,
+        promptCacheTtlSeconds: 300,
+        showCacheHitRate: true,
+        showAdvisor: true,
+        advisorOverride: "",
+        mergeGroups: exports.DEFAULT_MERGE_GROUPS.map((group) => [...group]),
+        contextWarningThreshold: 70,
+        contextCriticalThreshold: 85,
+        usageThreshold: 0,
+        sevenDayThreshold: 80,
+    },
+    colors: {
+        context: "green",
+        usage: "brightBlue",
+        warning: "yellow",
+        usageWarning: "brightMagenta",
+        critical: "red",
+        model: "cyan",
+        project: "yellow",
+        git: "magenta",
+        gitBranch: "cyan",
+        label: "dim",
+        barFilled: "█",
+        barEmpty: "░",
+    },
+};
+/** `pinglet hud --show/--hide`에서 받는 토글 이름 → 설정 경로. */
+exports.TOGGLE_KEYS = {
+    model: "display.showModel",
+    project: "display.showProject",
+    context: "display.showContextBar",
+    "context-bar": "display.showContextBar",
+    usage: "display.showUsage",
+    "model-scoped-usage": "display.showModelScopedUsage",
+    tools: "display.showTools",
+    skills: "display.showSkills",
+    agents: "display.showAgents",
+    todos: "display.showTodos",
+    memory: "display.showMemoryUsage",
+    "prompt-cache": "display.showPromptCache",
+    "cache-hit": "display.showCacheHitRate",
+    advisor: "display.showAdvisor",
+    "session-name": "display.showSessionName",
+    duration: "display.showDuration",
+    cost: "display.showCost",
+    speed: "display.showSpeed",
+    effort: "display.showEffortLevel",
+    "session-tokens": "display.showSessionTokens",
+    compactions: "display.showCompactions",
+    "token-breakdown": "display.showTokenBreakdown",
+    "usage-bar": "display.usageBarEnabled",
+    "reset-label": "display.showResetLabel",
+    "usage-compact": "display.usageCompact",
+    git: "gitStatus.enabled",
+    "git-dirty": "gitStatus.showDirty",
+    "git-ahead-behind": "gitStatus.showAheadBehind",
+    "git-files": "gitStatus.showFileStats",
+};
+/** 프리셋이 손대는 토글 — 나머지 키는 프리셋을 바꿔도 그대로 둔다. */
+const PRESET_TOGGLES = [
+    "model", "project", "context", "usage", "model-scoped-usage", "tools", "skills", "agents", "todos",
+    "memory", "prompt-cache", "cache-hit", "advisor", "session-name", "duration", "cost", "speed", "effort",
+    "session-tokens", "compactions", "git", "git-ahead-behind", "git-files",
+];
+/**
+ * 프리셋 — claude-hud의 setup/configure 흐름과 같은 세 단계.
+ *   full:      모두 켜기
+ *   essential: 활동 줄(tools/skills/agents/todos) + 모델·프로젝트·컨텍스트·git 브랜치, 정보 최소
+ *   minimal:   모델명 + context bar만
+ */
+exports.PRESETS = {
+    full: new Set(PRESET_TOGGLES),
+    essential: new Set([
+        "model", "project", "context", "usage", "model-scoped-usage", "prompt-cache", "cache-hit",
+        "tools", "skills", "agents", "todos", "git",
+    ]),
+    minimal: new Set(["model", "context"]),
+};
+function setToggle(config, name, value) {
+    const target = exports.TOGGLE_KEYS[name];
+    if (!target)
+        return;
+    const [section, key] = target.split(".");
+    config[section][key] = value;
+}
+function applyPreset(config, preset) {
+    const next = structuredClone(config);
+    const on = exports.PRESETS[preset];
+    for (const name of PRESET_TOGGLES)
+        setToggle(next, name, on.has(name));
+    // 프리셋은 배치까지 정하므로 병합 그룹도 기본값(컨텍스트·사용량·캐시 한 줄)으로 되돌린다.
+    next.display.mergeGroups = exports.DEFAULT_MERGE_GROUPS.map((group) => [...group]);
+    return next;
+}
+const isObject = (v) => !!v && typeof v === "object" && !Array.isArray(v);
+const bool = (v, fallback) => (typeof v === "boolean" ? v : fallback);
+const oneOf = (v, allowed, fallback) => allowed.includes(v) ? v : fallback;
+const int = (v, fallback, min = 0, max = 100_000) => typeof v === "number" && Number.isFinite(v) && v >= min && v <= max ? Math.trunc(v) : fallback;
+function uniqueKnown(value, known) {
+    if (!Array.isArray(value))
+        return [];
+    const out = [];
+    for (const item of value) {
+        if (typeof item === "string" && known.has(item) && !out.includes(item))
+            out.push(item);
+    }
+    return out;
+}
+const COLOR_NAMES = [
+    "dim", "red", "green", "yellow", "magenta", "cyan", "brightBlue", "brightMagenta",
+];
+function colorValue(value, fallback) {
+    if (typeof value === "number" && Number.isInteger(value) && value >= 0 && value <= 255)
+        return value;
+    if (typeof value === "string" && /^#[0-9a-fA-F]{6}$/.test(value))
+        return value;
+    if (typeof value === "string" && COLOR_NAMES.includes(value))
+        return value;
+    return fallback;
+}
+/** 바 문자: 제어·서식 문자를 제외한 단일 grapheme만 허용한다 (터미널 방어). */
+function barChar(value, fallback) {
+    if (typeof value !== "string" || value.length === 0 || value.length > 4)
+        return fallback;
+    if (/[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u.test(value))
+        return fallback;
+    return Array.from(value).length === 1 ? value : fallback;
+}
+/** 어떤 입력이 와도 유효한 HudConfig를 돌려준다. 알 수 없는 키는 버린다. */
+function normalizeHudConfig(raw) {
+    const d = exports.DEFAULT_HUD_CONFIG;
+    if (!isObject(raw))
+        return structuredClone(d);
+    const display = isObject(raw.display) ? raw.display : {};
+    const git = isObject(raw.gitStatus) ? raw.gitStatus : {};
+    const colors = isObject(raw.colors) ? raw.colors : {};
+    const elementOrder = uniqueKnown(raw.elementOrder, exports.KNOWN_ELEMENTS);
+    const mergeGroups = Array.isArray(display.mergeGroups)
+        ? display.mergeGroups
+            .map((group) => uniqueKnown(group, exports.KNOWN_ELEMENTS))
+            .filter((group) => group.length > 1)
+        : d.display.mergeGroups.map((group) => [...group]);
+    const warning = int(display.contextWarningThreshold, d.display.contextWarningThreshold, 0, 100);
+    const critical = int(display.contextCriticalThreshold, d.display.contextCriticalThreshold, 0, 100);
+    return {
+        enabled: bool(raw.enabled, d.enabled),
+        lineLayout: oneOf(raw.lineLayout, ["compact", "expanded"], d.lineLayout),
+        showSeparators: bool(raw.showSeparators, d.showSeparators),
+        pathLevels: oneOf(raw.pathLevels, [1, 2, 3, "full"], d.pathLevels),
+        maxWidth: typeof raw.maxWidth === "number" && raw.maxWidth > 0 ? Math.min(1000, Math.trunc(raw.maxWidth)) : null,
+        forceMaxWidth: bool(raw.forceMaxWidth, d.forceMaxWidth),
+        elementOrder: elementOrder.length > 0 ? elementOrder : [...d.elementOrder],
+        projectLineOrder: uniqueKnown(raw.projectLineOrder, exports.KNOWN_FIRST_LINE_SEGMENTS),
+        gitStatus: {
+            enabled: bool(git.enabled, d.gitStatus.enabled),
+            showDirty: bool(git.showDirty, d.gitStatus.showDirty),
+            showAheadBehind: bool(git.showAheadBehind, d.gitStatus.showAheadBehind),
+            showFileStats: bool(git.showFileStats, d.gitStatus.showFileStats),
+            branchOverflow: oneOf(git.branchOverflow, ["truncate", "wrap"], d.gitStatus.branchOverflow),
+            pushWarningThreshold: int(git.pushWarningThreshold, d.gitStatus.pushWarningThreshold, 0, 10_000),
+            pushCriticalThreshold: int(git.pushCriticalThreshold, d.gitStatus.pushCriticalThreshold, 0, 10_000),
+        },
+        display: {
+            showModel: bool(display.showModel, d.display.showModel),
+            modelFormat: oneOf(display.modelFormat, ["full", "compact", "short"], d.display.modelFormat),
+            showProject: bool(display.showProject, d.display.showProject),
+            showContextBar: bool(display.showContextBar, d.display.showContextBar),
+            contextValue: oneOf(display.contextValue, ["percent", "tokens", "remaining", "both"], d.display.contextValue),
+            showTokenBreakdown: bool(display.showTokenBreakdown, d.display.showTokenBreakdown),
+            showUsage: bool(display.showUsage, d.display.showUsage),
+            usageValue: oneOf(display.usageValue, ["percent", "remaining"], d.display.usageValue),
+            usageBarEnabled: bool(display.usageBarEnabled, d.display.usageBarEnabled),
+            showResetLabel: bool(display.showResetLabel, d.display.showResetLabel),
+            usageCompact: bool(display.usageCompact, d.display.usageCompact),
+            showModelScopedUsage: bool(display.showModelScopedUsage, d.display.showModelScopedUsage),
+            timeFormat: oneOf(display.timeFormat, ["relative", "absolute", "both"], d.display.timeFormat),
+            showTools: bool(display.showTools, d.display.showTools),
+            toolNameMaxLength: int(display.toolNameMaxLength, d.display.toolNameMaxLength, 0, 64),
+            toolsMaxVisible: int(display.toolsMaxVisible, d.display.toolsMaxVisible, 0, 20),
+            showSkills: bool(display.showSkills, d.display.showSkills),
+            showAgents: bool(display.showAgents, d.display.showAgents),
+            showTodos: bool(display.showTodos, d.display.showTodos),
+            showSessionName: bool(display.showSessionName, d.display.showSessionName),
+            showDuration: bool(display.showDuration, d.display.showDuration),
+            showCost: bool(display.showCost, d.display.showCost),
+            showSpeed: bool(display.showSpeed, d.display.showSpeed),
+            showEffortLevel: bool(display.showEffortLevel, d.display.showEffortLevel),
+            effortFormat: oneOf(display.effortFormat, ["full", "symbol", "text"], d.display.effortFormat),
+            showSessionTokens: bool(display.showSessionTokens, d.display.showSessionTokens),
+            showCompactions: bool(display.showCompactions, d.display.showCompactions),
+            showMemoryUsage: bool(display.showMemoryUsage, d.display.showMemoryUsage),
+            showPromptCache: bool(display.showPromptCache, d.display.showPromptCache),
+            promptCacheTtlSeconds: int(display.promptCacheTtlSeconds, d.display.promptCacheTtlSeconds, 1, 86_400),
+            showCacheHitRate: bool(display.showCacheHitRate, d.display.showCacheHitRate),
+            showAdvisor: bool(display.showAdvisor, d.display.showAdvisor),
+            advisorOverride: typeof display.advisorOverride === "string" ? display.advisorOverride.slice(0, 64) : "",
+            mergeGroups,
+            contextWarningThreshold: Math.min(warning, critical),
+            contextCriticalThreshold: critical,
+            usageThreshold: int(display.usageThreshold, d.display.usageThreshold, 0, 100),
+            sevenDayThreshold: int(display.sevenDayThreshold, d.display.sevenDayThreshold, 0, 100),
+        },
+        colors: {
+            context: colorValue(colors.context, d.colors.context),
+            usage: colorValue(colors.usage, d.colors.usage),
+            warning: colorValue(colors.warning, d.colors.warning),
+            usageWarning: colorValue(colors.usageWarning, d.colors.usageWarning),
+            critical: colorValue(colors.critical, d.colors.critical),
+            model: colorValue(colors.model, d.colors.model),
+            project: colorValue(colors.project, d.colors.project),
+            git: colorValue(colors.git, d.colors.git),
+            gitBranch: colorValue(colors.gitBranch, d.colors.gitBranch),
+            label: colorValue(colors.label, d.colors.label),
+            barFilled: barChar(colors.barFilled, d.colors.barFilled),
+            barEmpty: barChar(colors.barEmpty, d.colors.barEmpty),
+        },
+    };
+}

package/dist/hud/git.js

@@ -0,0 +1,218 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseFileStats = parseFileStats;
+exports.parseNumstat = parseNumstat;
+exports.getGitStatus = getGitStatus;
+const child_process_1 = require("child_process");
+const path = __importStar(require("path"));
+const GIT_MAX_OUTPUT_BYTES = 1024 * 1024;
+const BRANCH_MAX_LEN = 64;
+const GIT_ENV = {
+    ...process.env,
+    GIT_OPTIONAL_LOCKS: "0",
+    GIT_TERMINAL_PROMPT: "0",
+    GCM_INTERACTIVE: "Never",
+};
+function git(cwd, args, timeout) {
+    return new Promise((resolve, reject) => {
+        (0, child_process_1.execFile)("git", args, { cwd, env: GIT_ENV, encoding: "utf8", timeout, maxBuffer: GIT_MAX_OUTPUT_BYTES, windowsHide: true }, (error, stdout) => (error ? reject(error) : resolve(stdout)));
+    });
+}
+function sanitizeBranch(value) {
+    const cleaned = value.replace(/[\p{Cc}\p{Cf}]/gu, "").trim();
+    return cleaned.length > BRANCH_MAX_LEN ? `${cleaned.slice(0, BRANCH_MAX_LEN - 1)}…` : cleaned;
+}
+async function resolveRef(cwd) {
+    const branch = (await git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"], 1000)).trim();
+    if (branch && branch !== "HEAD")
+        return branch;
+    try {
+        const tag = (await git(cwd, ["describe", "--tags", "--exact-match", "HEAD"], 1000)).trim();
+        if (tag)
+            return tag;
+    }
+    catch {
+        // 태그가 없는 detached HEAD — 짧은 SHA로.
+    }
+    const sha = (await git(cwd, ["rev-parse", "--short", "HEAD"], 1000)).trim();
+    return sha ? `detached:${sha}` : null;
+}
+function parsePorcelainPath(field) {
+    if (field.startsWith('"') && field.endsWith('"')) {
+        try {
+            return JSON.parse(field);
+        }
+        catch {
+            return field.slice(1, -1);
+        }
+    }
+    return field;
+}
+/** `git status --porcelain` → 파일 개수와 추적 파일 목록 (Starship과 같은 분류). */
+function parseFileStats(porcelain) {
+    const stats = { modified: 0, added: 0, deleted: 0, untracked: 0, trackedFiles: [] };
+    for (const line of porcelain.split("\n").filter(Boolean)) {
+        if (line.length < 2)
+            continue;
+        const index = line[0];
+        const worktree = line[1];
+        const pathField = line.slice(2).trimStart();
+        if (line.startsWith("??")) {
+            stats.untracked++;
+        }
+        else if (index === "A") {
+            stats.added++;
+            const fullPath = parsePorcelainPath(pathField);
+            stats.trackedFiles.push({ basename: fullPath.split("/").pop() ?? fullPath, fullPath, type: "added" });
+        }
+        else if (index === "D" || worktree === "D") {
+            stats.deleted++;
+            const fullPath = parsePorcelainPath(pathField);
+            stats.trackedFiles.push({ basename: fullPath.split("/").pop() ?? fullPath, fullPath, type: "deleted" });
+        }
+        else if (index === "M" || worktree === "M" || index === "R" || index === "C") {
+            stats.modified++;
+            // 이름 변경은 "old -> new"로 오므로 목적지 경로를 쓴다.
+            const fullPath = parsePorcelainPath(pathField.split(" -> ").pop() ?? pathField);
+            stats.trackedFiles.push({ basename: fullPath.split("/").pop() ?? fullPath, fullPath, type: "modified" });
+        }
+    }
+    return stats;
+}
+/** numstat의 이름 변경 표기(`old => new`, `dir/{old => new}`)를 목적지 경로로 바꾼다. */
+function numstatDestination(filePath) {
+    const brace = filePath.match(/^(.*)\{(.*) => (.*)\}(.*)$/);
+    if (brace)
+        return `${brace[1]}${brace[3]}${brace[4]}`.replace(/\/{2,}/g, "/");
+    const arrow = filePath.indexOf(" => ");
+    return arrow === -1 ? filePath : filePath.slice(arrow + 4);
+}
+function parseNumstat(output, trackedPaths) {
+    const total = { added: 0, deleted: 0 };
+    const perFile = new Map();
+    for (const line of output.trim().split("\n").filter(Boolean)) {
+        const parts = line.split("\t");
+        if (parts.length < 3)
+            continue;
+        const added = parseInt(parts[0], 10);
+        const deleted = parseInt(parts[1], 10);
+        if (Number.isNaN(added) || Number.isNaN(deleted))
+            continue; // binary
+        let filePath = parts[2];
+        if (!trackedPaths.has(filePath)) {
+            const destination = numstatDestination(filePath);
+            if (trackedPaths.has(destination))
+                filePath = destination;
+        }
+        total.added += added;
+        total.deleted += deleted;
+        perFile.set(filePath, { added, deleted });
+    }
+    return { total, perFile };
+}
+function buildGitHubRefUrl(remote, ref) {
+    const base = remote
+        .replace(/^git@github\.com:/, "https://github.com/")
+        .replace(/^ssh:\/\/git@github\.com\//, "https://github.com/")
+        .replace(/\.git$/, "");
+    if (!base.startsWith("https://github.com/"))
+        return undefined;
+    const detached = ref.match(/^detached:([0-9a-f]+)$/);
+    if (detached)
+        return `${base}/commit/${detached[1]}`;
+    return `${base}/tree/${ref.split("/").map(encodeURIComponent).join("/")}`;
+}
+async function getGitStatus(cwd) {
+    if (!cwd || !path.isAbsolute(cwd))
+        return null;
+    let branch;
+    try {
+        branch = await resolveRef(cwd);
+    }
+    catch {
+        return null;
+    }
+    if (!branch)
+        return null;
+    let isDirty = false;
+    let fileStats;
+    let lineDiff;
+    try {
+        const out = (await git(cwd, ["-c", "core.quotePath=false", "--no-optional-locks", "status", "--porcelain"], 1000)).trim();
+        isDirty = out.length > 0;
+        if (isDirty)
+            fileStats = parseFileStats(out);
+    }
+    catch {
+        // status 실패는 배지에서 dirty 표시만 빠진다.
+    }
+    if (isDirty) {
+        try {
+            const out = await git(cwd, ["-c", "core.quotePath=false", "--no-optional-locks", "diff", "--numstat", "HEAD"], 2000);
+            const tracked = new Set(fileStats?.trackedFiles.map((f) => f.fullPath) ?? []);
+            const { total, perFile } = parseNumstat(out, tracked);
+            lineDiff = total;
+            for (const file of fileStats?.trackedFiles ?? []) {
+                const diff = perFile.get(file.fullPath);
+                if (diff)
+                    file.lineDiff = diff;
+            }
+        }
+        catch {
+            // 줄 수 차이는 선택 정보.
+        }
+    }
+    let ahead = 0;
+    let behind = 0;
+    try {
+        const parts = (await git(cwd, ["rev-list", "--left-right", "--count", "@{upstream}...HEAD"], 1000)).trim().split(/\s+/);
+        if (parts.length === 2) {
+            behind = parseInt(parts[0], 10) || 0;
+            ahead = parseInt(parts[1], 10) || 0;
+        }
+    }
+    catch {
+        // upstream 없음
+    }
+    let branchUrl;
+    try {
+        branchUrl = buildGitHubRefUrl((await git(cwd, ["remote", "get-url", "origin"], 1000)).trim(), branch);
+    }
+    catch {
+        // origin 없음
+    }
+    return { branch: sanitizeBranch(branch), isDirty, ahead, behind, fileStats, lineDiff, branchUrl };
+}