pinglet-cli 0.6.2 → 0.8.0

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 };
+}

package/dist/hud/index.js

@@ -0,0 +1,41 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadHudConfig = loadHudConfig;
+exports.renderHudLines = renderHudLines;
+const config_1 = require("./config");
+const git_1 = require("./git");
+const memory_1 = require("./memory");
+const render_1 = require("./render");
+const speed_1 = require("./speed");
+const transcript_1 = require("./transcript");
+/** config.json의 `hud` 섹션을 정규화해 돌려준다 (없으면 기본값 = full 프리셋). */
+function loadHudConfig(config) {
+    return (0, config_1.normalizeHudConfig)(config.hud);
+}
+/**
+ * statusline tick에서 호출 — payload가 없으면(수동 실행 등) HUD 줄을 그리지 않는다.
+ * transcript는 비동기 스트림으로, git은 비동기 서브프로세스로 읽으며 네트워크는 쓰지 않는다.
+ * 로컬 잠금 밖에서 실행되므로 다른 훅을 막지 않는다.
+ */
+async function renderHudLines(hud, payload, now = Date.now()) {
+    if (!hud.enabled)
+        return [];
+    const hasPayload = !!(payload.model || payload.context_window || payload.cwd || payload.transcript_path);
+    if (!hasPayload)
+        return [];
+    const { display, gitStatus } = hud;
+    const needsTranscript = display.showTools || display.showSkills || display.showAgents || display.showTodos ||
+        display.showSessionName || display.showDuration || display.showPromptCache || display.showAdvisor ||
+        display.showSessionTokens || display.showCompactions || display.showEffortLevel;
+    const transcriptPath = typeof payload.transcript_path === "string" ? payload.transcript_path : undefined;
+    const cwd = typeof payload.cwd === "string" ? payload.cwd : payload.workspace?.current_dir;
+    const [transcript, git] = await Promise.all([
+        needsTranscript ? (0, transcript_1.parseTranscript)(transcriptPath) : Promise.resolve({ tools: [], agents: [], todos: [], skills: [] }),
+        gitStatus.enabled ? (0, git_1.getGitStatus)(cwd) : Promise.resolve(null),
+    ]);
+    const memory = display.showMemoryUsage && hud.lineLayout === "expanded" && hud.elementOrder.includes("memory")
+        ? (0, memory_1.getMemoryUsage)(now)
+        : null;
+    const speed = display.showSpeed ? (0, speed_1.getOutputSpeed)(payload, now) : null;
+    return (0, render_1.renderHud)({ config: hud, payload, transcript, gitStatus: git, memory, speed, now });
+}

package/dist/hud/labels.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.hudLabel = hudLabel;
+exports.resetHudLabels = resetHudLabels;
+const render_1 = require("../render");
+/** HUD 고정 문구 — statusline 언어 판정(detectLocale)을 따른다. */
+const TABLE = {
+    en: {
+        context: "Context",
+        usage: "Usage",
+        weekly: "Weekly",
+        resetsIn: "resets in",
+        resets: "resets",
+        at: "at",
+        limitReached: "Limit reached",
+        allTodosComplete: "All todos complete",
+        in: "in",
+        cache: "cache",
+        cost: "Cost",
+        more: "more",
+        skills: "Skills",
+        approxRam: "Approx RAM",
+        promptCache: "Cache",
+        until: "until",
+        expired: "expired",
+        hit: "hit",
+        advisor: "Advisor",
+        tokens: "Tokens",
+        tok: "tok",
+        out: "out",
+        tokPerSec: "tok/s",
+        compactions: "Compactions",
+    },
+    ko: {
+        context: "컨텍스트",
+        usage: "사용량",
+        weekly: "주간",
+        resetsIn: "리셋까지",
+        resets: "리셋",
+        at: "",
+        limitReached: "한도 도달",
+        allTodosComplete: "할 일 모두 완료",
+        in: "입력",
+        cache: "캐시",
+        cost: "비용",
+        more: "개 더",
+        skills: "스킬",
+        approxRam: "RAM",
+        promptCache: "캐시",
+        until: "만료",
+        expired: "만료됨",
+        hit: "히트",
+        advisor: "자문 모델",
+        tokens: "토큰",
+        tok: "토큰",
+        out: "출력",
+        tokPerSec: "tok/s",
+        compactions: "압축",
+    },
+    ja: {
+        context: "コンテキスト",
+        usage: "使用量",
+        weekly: "週間",
+        resetsIn: "リセットまで",
+        resets: "リセット",
+        at: "",
+        limitReached: "上限到達",
+        allTodosComplete: "Todo すべて完了",
+        in: "入力",
+        cache: "キャッシュ",
+        cost: "コスト",
+        more: "件",
+        skills: "スキル",
+        approxRam: "RAM",
+        promptCache: "キャッシュ",
+        until: "期限",
+        expired: "期限切れ",
+        hit: "ヒット",
+        advisor: "アドバイザー",
+        tokens: "トークン",
+        tok: "トークン",
+        out: "出力",
+        tokPerSec: "tok/s",
+        compactions: "圧縮",
+    },
+};
+let cached = null;
+function hudLabel(key) {
+    cached ??= TABLE[(0, render_1.detectLocale)()];
+    return cached[key];
+}
+/** 테스트용 — 언어 판정 캐시를 비운다. */
+function resetHudLabels() {
+    cached = null;
+}

package/dist/hud/memory.js

@@ -0,0 +1,123 @@
+"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.parseVmStat = parseVmStat;
+exports.parseLinuxMeminfo = parseLinuxMeminfo;
+exports.toMemoryInfo = toMemoryInfo;
+exports.getMemoryUsage = getMemoryUsage;
+exports.formatBytes = formatBytes;
+const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const path = __importStar(require("path"));
+const child_process_1 = require("child_process");
+const config_1 = require("../config");
+const storage_1 = require("../storage");
+const CACHE_PATH = path.join(config_1.PINGLET_DIR, "hud-cache", "memory.json");
+const MEMORY_CACHE_MS = 5_000;
+function parseVmStat(output) {
+    const pageSize = output.match(/page size of (\d+) bytes/);
+    const active = output.match(/Pages active:\s+(\d+)/);
+    const wired = output.match(/Pages wired down:\s+(\d+)/);
+    if (!pageSize || !active || !wired)
+        return null;
+    return { pageSize: Number(pageSize[1]), active: Number(active[1]), wired: Number(wired[1]) };
+}
+function parseLinuxMeminfo(output) {
+    const total = output.match(/^MemTotal:\s+(\d+)\s+kB/m);
+    const available = output.match(/^MemAvailable:\s+(\d+)\s+kB/m);
+    if (!total || !available)
+        return null;
+    return { totalBytes: Number(total[1]) * 1024, freeBytes: Number(available[1]) * 1024 };
+}
+function readRaw() {
+    const fallback = () => ({ totalBytes: os.totalmem(), freeBytes: os.freemem() });
+    try {
+        if (process.platform === "darwin") {
+            const parsed = parseVmStat((0, child_process_1.execFileSync)("/usr/bin/vm_stat", { encoding: "utf8", timeout: 2000, stdio: ["ignore", "pipe", "ignore"] }));
+            if (!parsed)
+                return fallback();
+            const totalBytes = os.totalmem();
+            return { totalBytes, freeBytes: totalBytes - (parsed.active + parsed.wired) * parsed.pageSize };
+        }
+        if (process.platform === "linux") {
+            return parseLinuxMeminfo(fs.readFileSync("/proc/meminfo", "utf8")) ?? fallback();
+        }
+    }
+    catch {
+        // 플랫폼 도구 실패 — Node 값으로.
+    }
+    return fallback();
+}
+function toMemoryInfo(raw) {
+    if (!Number.isFinite(raw.totalBytes) || raw.totalBytes <= 0)
+        return null;
+    const free = Number.isFinite(raw.freeBytes) ? Math.min(Math.max(raw.freeBytes, 0), raw.totalBytes) : 0;
+    const usedBytes = raw.totalBytes - free;
+    return {
+        totalBytes: raw.totalBytes,
+        usedBytes,
+        usedPercent: Math.min(100, Math.max(0, Math.round((usedBytes / raw.totalBytes) * 100))),
+    };
+}
+function getMemoryUsage(now = Date.now()) {
+    try {
+        const cached = JSON.parse(fs.readFileSync(CACHE_PATH, "utf8"));
+        if (cached && typeof cached.checkedAt === "number" && now - cached.checkedAt < MEMORY_CACHE_MS)
+            return cached.info;
+    }
+    catch {
+        // 캐시 없음
+    }
+    const info = toMemoryInfo(readRaw());
+    try {
+        (0, storage_1.atomicWrite)(CACHE_PATH, JSON.stringify({ checkedAt: now, info }));
+    }
+    catch {
+        // 캐시 실패는 표시에 영향을 주면 안 된다.
+    }
+    return info;
+}
+function formatBytes(bytes) {
+    if (!Number.isFinite(bytes) || bytes <= 0)
+        return "0 B";
+    const units = ["B", "KB", "MB", "GB", "TB"];
+    let value = bytes;
+    let unit = 0;
+    while (value >= 1024 && unit < units.length - 1) {
+        value /= 1024;
+        unit++;
+    }
+    return `${value.toFixed(value >= 10 || unit === 0 ? 0 : 1)} ${units[unit]}`;
+}