pinglet-cli 0.6.2 → 0.7.0

package/dist/hud/transcript.js

@@ -0,0 +1,481 @@
+"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.HUD_CACHE_DIR = exports.PROMPT_CACHE_TTL_1H = exports.PROMPT_CACHE_TTL_5M = void 0;
+exports.sanitizeText = sanitizeText;
+exports.parseTranscript = parseTranscript;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const readline = __importStar(require("readline"));
+const crypto_1 = require("crypto");
+const config_1 = require("../config");
+const storage_1 = require("../storage");
+const CACHE_VERSION = 4;
+const CACHE_DIR = path.join(config_1.PINGLET_DIR, "hud-cache");
+const NAME_MAX_LEN = 64;
+const TEXT_MAX_LEN = 120;
+const TOOLS_KEPT = 20;
+const AGENTS_KEPT = 10;
+const MESSAGE_USAGE_MAX = 4096;
+exports.PROMPT_CACHE_TTL_5M = 300;
+exports.PROMPT_CACHE_TTL_1H = 3600;
+const emptyTranscript = () => ({ tools: [], agents: [], todos: [], skills: [] });
+/** 클라이언트 안에서만 처리되는 user 기록 — 요청을 보내지 않으므로 캐시를 갱신하지 않는다. */
+const LOCAL_ONLY_USER_TEXT_PREFIXES = [
+    "<command-name>",
+    "<command-message>",
+    "<local-command-",
+    "[Request interrupted by user",
+];
+/** 터미널에 그리기 전 방어선 — ANSI·제어·서식 문자를 제거하고 길이를 제한한다. */
+function sanitizeText(value, maxLen = TEXT_MAX_LEN) {
+    if (typeof value !== "string")
+        return "";
+    const cleaned = value
+        // eslint-disable-next-line no-control-regex
+        .replace(/\x1b\[[0-9;]*[A-Za-z]/g, "")
+        .replace(/[\p{Cc}\p{Cf}]/gu, "")
+        .replace(/\s+/g, " ")
+        .trim();
+    return cleaned.length > maxLen ? `${cleaned.slice(0, maxLen - 1)}…` : cleaned;
+}
+function cachePath(transcriptPath) {
+    const hash = (0, crypto_1.createHash)("sha256").update(transcriptPath).digest("hex").slice(0, 32);
+    return path.join(CACHE_DIR, `${hash}.json`);
+}
+function readCache(file) {
+    try {
+        const parsed = JSON.parse(fs.readFileSync(file, "utf8"));
+        if (parsed?.version !== CACHE_VERSION || !parsed.data)
+            return null;
+        return parsed;
+    }
+    catch {
+        return null;
+    }
+}
+/** doctor/uninstall --purge 용: 캐시 디렉터리 경로. */
+exports.HUD_CACHE_DIR = CACHE_DIR;
+async function parseTranscript(transcriptPath) {
+    if (!transcriptPath)
+        return emptyTranscript();
+    let canonical;
+    let stat;
+    try {
+        canonical = fs.realpathSync(transcriptPath);
+        stat = fs.statSync(canonical);
+        if (!stat.isFile())
+            return emptyTranscript();
+    }
+    catch {
+        return emptyTranscript();
+    }
+    const file = cachePath(canonical);
+    const cached = readCache(file);
+    if (cached && cached.transcriptPath === canonical && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+        return cached.data;
+    }
+    const { data, complete } = await parseFile(canonical);
+    if (complete) {
+        try {
+            (0, storage_1.atomicWrite)(file, JSON.stringify({ version: CACHE_VERSION, transcriptPath: canonical, mtimeMs: stat.mtimeMs, size: stat.size, data }));
+        }
+        catch {
+            // 캐시 실패는 표시에 영향을 주면 안 된다.
+        }
+    }
+    return data;
+}
+const positive = (v) => typeof v === "number" && Number.isFinite(v) && v > 0;
+const tokenCount = (v) => (typeof v === "number" && Number.isFinite(v) ? Math.max(0, Math.trunc(v)) : 0);
+/** 이번 요청이 실제로 쓴 캐시 TTL. 캐시만 읽은 요청은 둘 다 0이라 undefined (이전 판정 유지). */
+function detectCacheTtl(creation) {
+    if (!creation)
+        return undefined;
+    if (positive(creation.ephemeral_5m_input_tokens))
+        return exports.PROMPT_CACHE_TTL_5M;
+    if (positive(creation.ephemeral_1h_input_tokens))
+        return exports.PROMPT_CACHE_TTL_1H;
+    return undefined;
+}
+/** user 기록이 실제 요청의 시작인지 — 로컬 슬래시 명령 출력·중단 마커는 아니다. */
+function isRequestStart(entry) {
+    const content = entry.message?.content;
+    if (typeof content === "string")
+        return !LOCAL_ONLY_USER_TEXT_PREFIXES.some((p) => content.startsWith(p));
+    if (Array.isArray(content)) {
+        return content.some((b) => b?.type === "tool_result") ||
+            !content.some((b) => b?.type === "text" && LOCAL_ONLY_USER_TEXT_PREFIXES.some((p) => (b.text ?? "").startsWith(p)));
+    }
+    return true;
+}
+/**
+ * 같은 API 응답을 Claude Code가 2~3번 기록하므로 message.id별 최대값의 증가분만 더한다.
+ * id가 없는 기록은 직전 기록과 usage 지문이 같으면 중복으로 본다.
+ */
+class SessionTokenAccumulator {
+    total = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+    byMessageId = new Map();
+    lastFingerprint;
+    add(messageId, usage) {
+        if (messageId !== null) {
+            this.lastFingerprint = undefined;
+            const prior = this.byMessageId.get(messageId);
+            if (!prior && this.byMessageId.size >= MESSAGE_USAGE_MAX) {
+                const oldest = this.byMessageId.keys().next().value;
+                if (oldest !== undefined)
+                    this.byMessageId.delete(oldest);
+            }
+            const base = prior ?? { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+            this.total.inputTokens += Math.max(0, usage.inputTokens - base.inputTokens);
+            this.total.outputTokens += Math.max(0, usage.outputTokens - base.outputTokens);
+            this.total.cacheCreationTokens += Math.max(0, usage.cacheCreationTokens - base.cacheCreationTokens);
+            this.total.cacheReadTokens += Math.max(0, usage.cacheReadTokens - base.cacheReadTokens);
+            this.byMessageId.set(messageId, {
+                inputTokens: Math.max(base.inputTokens, usage.inputTokens),
+                outputTokens: Math.max(base.outputTokens, usage.outputTokens),
+                cacheCreationTokens: Math.max(base.cacheCreationTokens, usage.cacheCreationTokens),
+                cacheReadTokens: Math.max(base.cacheReadTokens, usage.cacheReadTokens),
+            });
+            return;
+        }
+        const fingerprint = `${usage.inputTokens}|${usage.outputTokens}|${usage.cacheCreationTokens}|${usage.cacheReadTokens}`;
+        const duplicate = fingerprint === this.lastFingerprint;
+        this.lastFingerprint = fingerprint;
+        if (duplicate)
+            return;
+        this.total.inputTokens += usage.inputTokens;
+        this.total.outputTokens += usage.outputTokens;
+        this.total.cacheCreationTokens += usage.cacheCreationTokens;
+        this.total.cacheReadTokens += usage.cacheReadTokens;
+    }
+    reset() {
+        this.lastFingerprint = undefined;
+    }
+}
+async function parseFile(transcriptPath) {
+    const tools = new Map();
+    const agents = new Map();
+    const skills = new Set();
+    let todos = [];
+    const taskIdToIndex = new Map();
+    const queueCompletion = new Map();
+    const tokens = new SessionTokenAccumulator();
+    let sessionStart;
+    let slug;
+    let customTitle;
+    let advisorModel;
+    let compactionCount = 0;
+    let ultracodeActive;
+    let lastRequestUsage;
+    // prompt cache 시계 — 메인 대화(isSidechain 아님)만 본다.
+    let prevMainChainAt;
+    let cacheAnchorAt;
+    let cacheTtl;
+    let cacheRequestId;
+    let cacheRequestAnchorAt;
+    let cachePendingRequestAt;
+    let complete = false;
+    try {
+        const rl = readline.createInterface({ input: fs.createReadStream(transcriptPath), crlfDelay: Infinity });
+        for await (const line of rl) {
+            if (!line.trim()) {
+                tokens.reset();
+                continue;
+            }
+            let entry;
+            try {
+                entry = JSON.parse(line);
+            }
+            catch {
+                tokens.reset();
+                continue;
+            }
+            if (!entry || typeof entry !== "object")
+                continue;
+            const ts = entry.timestamp ? Date.parse(entry.timestamp) : NaN;
+            const timestamp = Number.isNaN(ts) ? Date.now() : ts;
+            if (sessionStart === undefined && !Number.isNaN(ts))
+                sessionStart = ts;
+            if (entry.type === "custom-title" && typeof entry.customTitle === "string") {
+                customTitle = sanitizeText(entry.customTitle, NAME_MAX_LEN);
+            }
+            else if (typeof entry.slug === "string") {
+                slug = sanitizeText(entry.slug, NAME_MAX_LEN);
+            }
+            if (entry.type === "assistant" && typeof entry.advisorModel === "string" && entry.advisorModel) {
+                advisorModel = sanitizeText(entry.advisorModel, NAME_MAX_LEN) || advisorModel;
+            }
+            // ultracode 상태: 마커 attachment(한 턴 늦을 수 있음)와 /effort 명령 출력(즉시) — 파일 순서대로 마지막 값.
+            if (entry.type === "attachment") {
+                if (entry.attachment?.type === "ultra_effort_enter")
+                    ultracodeActive = true;
+                else if (entry.attachment?.type === "ultra_effort_exit")
+                    ultracodeActive = false;
+            }
+            if (entry.type === "user" && typeof entry.message?.content === "string") {
+                const match = entry.message.content.match(/^<local-command-stdout>Set effort level to (\w+)/);
+                if (match)
+                    ultracodeActive = match[1].toLowerCase() === "ultracode";
+            }
+            if (entry.type === "assistant" && entry.message?.usage) {
+                const usage = entry.message.usage;
+                const id = typeof entry.message.id === "string" && entry.message.id.length > 0 && entry.message.id.length <= 128 ? entry.message.id : null;
+                const normalized = {
+                    inputTokens: tokenCount(usage.input_tokens),
+                    outputTokens: tokenCount(usage.output_tokens),
+                    cacheCreationTokens: tokenCount(usage.cache_creation_input_tokens),
+                    cacheReadTokens: tokenCount(usage.cache_read_input_tokens),
+                };
+                tokens.add(id, normalized);
+                if (entry.isSidechain !== true && normalized.inputTokens + normalized.cacheCreationTokens + normalized.cacheReadTokens > 0) {
+                    lastRequestUsage = normalized;
+                }
+            }
+            else {
+                tokens.reset();
+            }
+            if (entry.type === "system" && entry.subtype === "compact_boundary" && !Number.isNaN(ts))
+                compactionCount++;
+            // 백그라운드 에이전트의 실제 완료 시각은 queue-operation 기록에 있다 (tool_result는 시작 시각).
+            if (entry.type === "queue-operation" && entry.operation === "enqueue" && typeof entry.content === "string" && !Number.isNaN(ts)) {
+                const toolUseId = entry.content.match(/<tool-use-id>([^<]+)<\/tool-use-id>/);
+                if (toolUseId && /<task-id>[^<]+<\/task-id>/.test(entry.content))
+                    queueCompletion.set(toolUseId[1], ts);
+            }
+            if (entry.isSidechain !== true && !Number.isNaN(ts)) {
+                if (entry.type === "assistant") {
+                    // 같은 requestId를 공유하는 기록은 한 요청 — 첫 기록 직전의 메인 대화 기록이 요청 시작이다.
+                    const requestId = typeof entry.requestId === "string" && entry.requestId.length <= 128 ? entry.requestId : undefined;
+                    if (requestId === undefined || requestId !== cacheRequestId) {
+                        cacheRequestId = requestId;
+                        cacheRequestAnchorAt = prevMainChainAt;
+                    }
+                    cacheAnchorAt = cacheRequestAnchorAt !== undefined && cacheRequestAnchorAt <= ts ? cacheRequestAnchorAt : ts;
+                    const detected = detectCacheTtl(entry.message?.usage?.cache_creation);
+                    if (detected !== undefined)
+                        cacheTtl = detected;
+                    cachePendingRequestAt = undefined;
+                }
+                // 응답이 아직 안 적힌 요청도 이미 캐시를 갱신했다 — 그 요청을 연 기록이 살아 있는 기준점.
+                if (entry.type === "user" && isRequestStart(entry))
+                    cachePendingRequestAt = ts;
+                prevMainChainAt = ts;
+            }
+            const blocks = entry.message?.content;
+            if (!Array.isArray(blocks))
+                continue;
+            for (const block of blocks) {
+                if (!block || typeof block !== "object")
+                    continue;
+                if (block.type === "tool_use" && typeof block.id === "string" && typeof block.name === "string") {
+                    const name = sanitizeText(block.name, NAME_MAX_LEN);
+                    const input = block.input && typeof block.input === "object" ? block.input : {};
+                    if (name === "Skill") {
+                        const skill = sanitizeText(input.skill, NAME_MAX_LEN);
+                        if (skill)
+                            skills.add(skill);
+                    }
+                    if (name === "Task" || name === "Agent") {
+                        agents.set(block.id, {
+                            id: block.id,
+                            type: sanitizeText(input.subagent_type, 24) || "agent",
+                            model: sanitizeText(input.model, 40) || undefined,
+                            description: sanitizeText(input.description, 40) || undefined,
+                            status: "running",
+                            startTime: timestamp,
+                            background: input.run_in_background === true,
+                        });
+                    }
+                    else if (name === "TodoWrite") {
+                        const next = normalizeTodos(input.todos);
+                        if (next) {
+                            todos = next;
+                            taskIdToIndex.clear();
+                        }
+                    }
+                    else if (name === "TaskCreate") {
+                        const subject = sanitizeText(input.subject) || sanitizeText(input.description) || "Untitled task";
+                        todos.push({ content: subject, status: normalizeTaskStatus(input.status) ?? "pending" });
+                        const taskId = input.taskId;
+                        const key = typeof taskId === "string" || typeof taskId === "number" ? String(taskId) : block.id;
+                        taskIdToIndex.set(key, todos.length - 1);
+                    }
+                    else if (name === "TaskUpdate") {
+                        const index = resolveTaskIndex(input.taskId, taskIdToIndex, todos.length);
+                        if (index !== null) {
+                            const status = normalizeTaskStatus(input.status);
+                            if (status)
+                                todos[index].status = status;
+                            const subject = sanitizeText(input.subject) || sanitizeText(input.description);
+                            if (subject)
+                                todos[index].content = subject;
+                        }
+                    }
+                    else {
+                        tools.set(block.id, {
+                            id: block.id,
+                            name,
+                            target: extractTarget(name, input),
+                            status: "running",
+                            startTime: timestamp,
+                        });
+                    }
+                }
+                if (block.type === "tool_result" && typeof block.tool_use_id === "string") {
+                    const tool = tools.get(block.tool_use_id);
+                    if (tool) {
+                        tool.status = block.is_error ? "error" : "completed";
+                        tool.endTime = timestamp;
+                    }
+                    const agent = agents.get(block.tool_use_id);
+                    if (agent) {
+                        const resolved = sanitizeText(entry.toolUseResult?.resolvedModel, 40);
+                        if (resolved)
+                            agent.model = resolved;
+                        if (entry.toolUseResult?.isAsync === true || entry.toolUseResult?.status === "async_launched") {
+                            agent.background = true;
+                        }
+                        if (!agent.background)
+                            agent.endTime = timestamp;
+                    }
+                }
+            }
+        }
+        complete = true;
+    }
+    catch {
+        // 읽는 중 오류 — 지금까지 모은 결과로 그린다 (캐시에는 남기지 않는다).
+    }
+    for (const [toolUseId, endTime] of queueCompletion) {
+        const agent = agents.get(toolUseId);
+        if (agent?.background) {
+            agent.endTime = endTime;
+            agent.status = "completed";
+        }
+    }
+    for (const agent of agents.values()) {
+        if (agent.status === "running" && agent.endTime !== undefined)
+            agent.status = "completed";
+    }
+    // 응답 없는 요청은 시계를 앞으로 당길 때만 채택한다 (시계가 꼬인 기록은 무시).
+    const anchor = cachePendingRequestAt !== undefined && (cacheAnchorAt === undefined || cachePendingRequestAt > cacheAnchorAt)
+        ? cachePendingRequestAt
+        : cacheAnchorAt;
+    return {
+        complete,
+        data: {
+            tools: Array.from(tools.values()).slice(-TOOLS_KEPT),
+            agents: Array.from(agents.values()).slice(-AGENTS_KEPT),
+            todos,
+            skills: Array.from(skills),
+            sessionStart,
+            sessionName: customTitle ?? slug,
+            advisorModel,
+            promptCacheAnchorAt: anchor,
+            promptCacheTtlSeconds: cacheTtl,
+            sessionTokens: tokens.total,
+            lastRequestUsage,
+            compactionCount,
+            ultracodeActive,
+        },
+    };
+}
+function normalizeTodos(value) {
+    if (!Array.isArray(value))
+        return null;
+    const out = [];
+    for (const item of value) {
+        if (!item || typeof item !== "object")
+            continue;
+        const todo = item;
+        const content = sanitizeText(todo.content);
+        if (!content)
+            continue;
+        out.push({ content, status: normalizeTaskStatus(todo.status) ?? "pending" });
+    }
+    return out;
+}
+function normalizeTaskStatus(status) {
+    switch (status) {
+        case "pending":
+        case "not_started":
+            return "pending";
+        case "in_progress":
+        case "running":
+            return "in_progress";
+        case "completed":
+        case "complete":
+        case "done":
+            return "completed";
+        default:
+            return null;
+    }
+}
+function resolveTaskIndex(taskId, map, length) {
+    if (typeof taskId !== "string" && typeof taskId !== "number")
+        return null;
+    const key = String(taskId);
+    const mapped = map.get(key);
+    if (mapped !== undefined)
+        return mapped;
+    if (/^\d+$/.test(key)) {
+        const index = Number.parseInt(key, 10) - 1;
+        if (index >= 0 && index < length)
+            return index;
+    }
+    return null;
+}
+/** 도구별로 한 줄 요약에 쓸 대상 — 파일 경로, 패턴, 명령 앞부분. */
+function extractTarget(name, input) {
+    switch (name) {
+        case "Read":
+        case "Write":
+        case "Edit":
+            return sanitizeText(input.file_path ?? input.path) || undefined;
+        case "Glob":
+        case "Grep":
+            return sanitizeText(input.pattern) || undefined;
+        case "Skill":
+            return sanitizeText(input.skill, NAME_MAX_LEN) || undefined;
+        case "Bash": {
+            const cmd = sanitizeText(input.command);
+            if (!cmd)
+                return undefined;
+            return cmd.length > 30 ? `${cmd.slice(0, 30).trimEnd()}...` : cmd;
+        }
+    }
+    return undefined;
+}

package/dist/hud/width.js

@@ -0,0 +1,194 @@
+"use strict";
+/**
+ * 터미널 셀 폭 계산과 폭 맞춤 — claude-hud와 같은 규칙.
+ *   - SGR(색)과 OSC 8(하이퍼링크) escape는 폭 0
+ *   - 한중일 문자·이모지는 2칸
+ *   - 폭을 넘는 줄은 구분자(" | ", " │ ")에서 감고, 그래도 넘치면 말줄임표로 자른다
+ * statusline이 터미널 폭을 넘으면 Claude Code가 줄을 감아 HUD 줄 수가 흔들리므로
+ * 렌더러가 먼저 폭에 맞춘다.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.stripAnsi = stripAnsi;
+exports.visualWidth = visualWidth;
+exports.truncateToWidth = truncateToWidth;
+exports.wrapLineToWidth = wrapLineToWidth;
+exports.terminalWidth = terminalWidth;
+exports.adaptiveBarWidth = adaptiveBarWidth;
+exports.safeHyperlink = safeHyperlink;
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_PATTERN = /^(?:\x1b\[[0-9;]*m|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\))/;
+// eslint-disable-next-line no-control-regex
+const ANSI_ESCAPE_GLOBAL = /(?:\x1b\[[0-9;]*m|\x1b\][^\x07\x1b]*(?:\x07|\x1b\\))/g;
+// eslint-disable-next-line no-control-regex
+const OSC8_OPEN_OR_CLOSE = /\x1b\]8;;([^\x07\x1b]*)(?:\x07|\x1b\\)/g;
+const OSC8_CLOSE = "\x1b]8;;\x1b\\";
+const RESET = "\x1b[0m";
+function stripAnsi(text) {
+    return text.replace(ANSI_ESCAPE_GLOBAL, "");
+}
+function codePointWidth(cp) {
+    if (cp === 0)
+        return 0;
+    if (cp < 0x20 || (cp >= 0x7f && cp < 0xa0))
+        return 0;
+    if (cp >= 0x300 && cp <= 0x36f)
+        return 0; // combining
+    if (cp === 0x200b || cp === 0x200d || cp === 0xfe0e || cp === 0xfe0f)
+        return 0;
+    if ((cp >= 0x1100 && cp <= 0x115f) ||
+        (cp >= 0x2e80 && cp <= 0xa4cf) ||
+        (cp >= 0xac00 && cp <= 0xd7a3) ||
+        (cp >= 0xf900 && cp <= 0xfaff) ||
+        (cp >= 0xfe30 && cp <= 0xfe4f) ||
+        (cp >= 0xff00 && cp <= 0xff60) ||
+        (cp >= 0xffe0 && cp <= 0xffe6) ||
+        (cp >= 0x1f300 && cp <= 0x1f64f) ||
+        (cp >= 0x1f900 && cp <= 0x1f9ff) ||
+        (cp >= 0x20000 && cp <= 0x3fffd)) {
+        return 2;
+    }
+    return 1;
+}
+function visualWidth(text) {
+    let width = 0;
+    for (const ch of stripAnsi(text))
+        width += codePointWidth(ch.codePointAt(0) ?? 0);
+    return width;
+}
+/** escape를 보존하면서 표시 폭 maxVisible 까지만 남긴다. */
+function sliceVisible(text, maxVisible) {
+    if (maxVisible <= 0)
+        return "";
+    let out = "";
+    let width = 0;
+    let i = 0;
+    while (i < text.length) {
+        const escape = ANSI_ESCAPE_PATTERN.exec(text.slice(i));
+        if (escape) {
+            out += escape[0];
+            i += escape[0].length;
+            continue;
+        }
+        const cp = text.codePointAt(i) ?? 0;
+        const ch = String.fromCodePoint(cp);
+        const w = codePointWidth(cp);
+        if (width + w > maxVisible)
+            break;
+        out += ch;
+        width += w;
+        i += ch.length;
+    }
+    return out;
+}
+/** 잘린 자리에서 OSC 8 링크가 열려 있으면 닫아, 말줄임표까지 밑줄이 이어지지 않게 한다. */
+function closeOpenHyperlink(text) {
+    let last = null;
+    let match;
+    OSC8_OPEN_OR_CLOSE.lastIndex = 0;
+    while ((match = OSC8_OPEN_OR_CLOSE.exec(text)) !== null)
+        last = match;
+    return last && last[1].length > 0 ? OSC8_CLOSE : "";
+}
+function truncateToWidth(text, maxWidth) {
+    if (maxWidth <= 0 || visualWidth(text) <= maxWidth)
+        return text;
+    const suffix = maxWidth >= 3 ? "..." : ".".repeat(maxWidth);
+    const sliced = sliceVisible(text, Math.max(0, maxWidth - suffix.length));
+    return `${sliced}${closeOpenHyperlink(sliced)}${suffix}${RESET}`;
+}
+/** " | " / " │ " 구분자 위치로 줄을 나눈다 (escape 안의 문자는 구분자로 보지 않는다). */
+function splitWrapParts(line) {
+    const parts = [];
+    let currentStart = 0;
+    let separator = "";
+    let i = 0;
+    while (i < line.length) {
+        const escape = ANSI_ESCAPE_PATTERN.exec(line.slice(i));
+        if (escape) {
+            i += escape[0].length;
+            continue;
+        }
+        const found = line.startsWith(" | ", i) ? " | " : line.startsWith(" │ ", i) ? " │ " : null;
+        if (found) {
+            parts.push({ separator, segment: line.slice(currentStart, i) });
+            separator = found;
+            i += found.length;
+            currentStart = i;
+            continue;
+        }
+        i++;
+    }
+    parts.push({ separator, segment: line.slice(currentStart) });
+    // 첫 세그먼트가 "[model" 처럼 열린 대괄호로 시작하면 닫히는 세그먼트까지 묶어 모델 배지가 갈라지지 않게 한다.
+    const firstVisible = stripAnsi(parts[0].segment).trimStart();
+    if (firstVisible.startsWith("[") && !stripAnsi(parts[0].segment).includes("]") && parts.length > 1) {
+        let merged = parts[0].segment;
+        let consume = 1;
+        while (consume < parts.length) {
+            const next = parts[consume];
+            merged += `${next.separator}${next.segment}`;
+            consume++;
+            if (stripAnsi(next.segment).includes("]"))
+                break;
+        }
+        return [{ separator: "", segment: merged }, ...parts.slice(consume)];
+    }
+    return parts;
+}
+/** 폭을 넘는 줄을 구분자에서 감는다. 한 세그먼트가 그 자체로 넘치면 자른다. */
+function wrapLineToWidth(line, maxWidth) {
+    if (maxWidth <= 0 || visualWidth(line) <= maxWidth)
+        return [line];
+    const parts = splitWrapParts(line);
+    if (parts.length <= 1)
+        return [truncateToWidth(line, maxWidth)];
+    const wrapped = [];
+    let current = parts[0].segment;
+    for (const part of parts.slice(1)) {
+        const candidate = `${current}${part.separator}${part.segment}`;
+        if (visualWidth(candidate) <= maxWidth) {
+            current = candidate;
+            continue;
+        }
+        wrapped.push(truncateToWidth(current, maxWidth));
+        current = part.segment;
+    }
+    if (current)
+        wrapped.push(truncateToWidth(current, maxWidth));
+    return wrapped;
+}
+function terminalWidth(configured, force = false) {
+    if (force && configured !== null)
+        return configured;
+    const env = Number.parseInt(process.env.COLUMNS ?? "", 10);
+    if (Number.isFinite(env) && env > 0)
+        return Math.min(1000, env);
+    const cols = process.stdout?.columns;
+    if (typeof cols === "number" && cols > 0)
+        return Math.min(1000, cols);
+    return configured;
+}
+/** 진행 바 폭 — 넓은 터미널 10칸, 중간 6칸, 좁으면 4칸 (claude-hud와 동일). */
+function adaptiveBarWidth(width) {
+    if (width === null)
+        return 10;
+    if (width >= 100)
+        return 10;
+    if (width >= 60)
+        return 6;
+    return 4;
+}
+/** OSC 8 하이퍼링크. https:/file: 만 허용하고, 그 외에는 텍스트만 돌려준다. */
+function safeHyperlink(uri, text) {
+    if (!uri)
+        return text;
+    try {
+        const parsed = new URL(uri.replace(/[\p{Cc}\p{Cf}]/gu, ""));
+        if (parsed.protocol !== "https:" && parsed.protocol !== "file:")
+            return text;
+        return `\x1b]8;;${parsed.toString()}\x1b\\${text}\x1b]8;;\x1b\\`;
+    }
+    catch {
+        return text;
+    }
+}