triflux 10.9.21 → 10.9.23

package/tui/core.mjs

@@ -0,0 +1,266 @@
+#!/usr/bin/env node
+// tui/core.mjs — triflux interactive TUI primitives
+import readline from "node:readline";
+
+// ── ANSI Colors (hud/colors.mjs schema) ──
+export const RESET = "\x1b[0m";
+export const DIM = "\x1b[2m";
+export const BOLD = "\x1b[1m";
+export const RED = "\x1b[31m";
+export const GREEN = "\x1b[32m";
+export const YELLOW = "\x1b[33m";
+export const CYAN = "\x1b[36m";
+export const AMBER = "\x1b[38;5;214m";
+export const BLUE = "\x1b[38;5;39m";
+export const WHITE = "\x1b[97m";
+export const GRAY = "\x1b[38;5;245m";
+
+// ── Screen ──
+
+export function clear() {
+  process.stdout.write("\x1b[2J\x1b[H");
+}
+
+export function hideCursor() {
+  process.stdout.write("\x1b[?25l");
+}
+
+export function showCursor() {
+  process.stdout.write("\x1b[?25h");
+}
+
+function moveUp(n) {
+  if (n > 0) process.stdout.write(`\x1b[${n}A`);
+}
+
+function clearLine() {
+  process.stdout.write("\x1b[2K\r");
+}
+
+// ── Rendering ──
+
+export function box(title, width = 50) {
+  const inner = width - 2;
+  const padded = ` ${title} `.slice(0, inner);
+  const left = Math.floor((inner - padded.length) / 2);
+  const right = inner - left - padded.length;
+  console.log(`  ${DIM}┌${"─".repeat(inner)}┐${RESET}`);
+  console.log(
+    `  ${DIM}│${RESET}${" ".repeat(left)}${BOLD}${AMBER}${padded}${RESET}${" ".repeat(right)}${DIM}│${RESET}`,
+  );
+  console.log(`  ${DIM}└${"─".repeat(inner)}┘${RESET}`);
+}
+
+export function divider(width = 50) {
+  console.log(`  ${DIM}${"─".repeat(width - 2)}${RESET}`);
+}
+
+export function table(headers, rows, { indent = 2 } = {}) {
+  const pad = " ".repeat(indent);
+  const widths = headers.map((h, i) =>
+    Math.max(
+      stripAnsi(h).length,
+      ...rows.map((r) => stripAnsi(String(r[i] ?? "")).length),
+    ),
+  );
+
+  const top = widths.map((w) => "─".repeat(w + 2)).join("┬");
+  const mid = widths.map((w) => "─".repeat(w + 2)).join("┼");
+  const bot = widths.map((w) => "─".repeat(w + 2)).join("┴");
+
+  const fmtRow = (cells, color = "") =>
+    cells
+      .map((c, i) => {
+        const s = String(c ?? "");
+        const visible = stripAnsi(s).length;
+        return ` ${color}${s}${color ? RESET : ""}${" ".repeat(Math.max(0, widths[i] - visible))} `;
+      })
+      .join("│");
+
+  console.log(`${pad}┌${top}┐`);
+  console.log(`${pad}│${fmtRow(headers, BOLD)}│`);
+  console.log(`${pad}├${mid}┤`);
+  for (const row of rows) {
+    console.log(`${pad}│${fmtRow(row)}│`);
+  }
+  console.log(`${pad}└${bot}┘`);
+}
+
+export function ok(msg) {
+  console.log(`  ${GREEN}✓${RESET} ${msg}`);
+}
+export function warn(msg) {
+  console.log(`  ${YELLOW}⚠${RESET} ${msg}`);
+}
+export function fail(msg) {
+  console.log(`  ${RED}✗${RESET} ${msg}`);
+}
+export function info(msg) {
+  console.log(`  ${CYAN}ℹ${RESET} ${msg}`);
+}
+
+export function label(key, value) {
+  console.log(`  ${DIM}${key}:${RESET} ${BOLD}${value}${RESET}`);
+}
+
+// ── Input: Arrow-key Select ──
+
+export async function select(title, options, { initial = 0 } = {}) {
+  if (!process.stdin.isTTY) {
+    console.log(`\n  ${BOLD}${title}${RESET}`);
+    for (let i = 0; i < options.length; i++) {
+      const o = typeof options[i] === "string" ? options[i] : options[i].label;
+      console.log(`  ${DIM}${i + 1}.${RESET} ${o}`);
+    }
+    const answer = await input(
+      `선택 (1-${options.length})`,
+      String(initial + 1),
+    );
+    const idx = parseInt(answer, 10) - 1;
+    return idx >= 0 && idx < options.length
+      ? { index: idx, value: options[idx] }
+      : null;
+  }
+
+  readline.emitKeypressEvents(process.stdin);
+  process.stdin.setRawMode(true);
+  process.stdin.resume();
+  hideCursor();
+
+  let cursor = initial;
+  const total = options.length;
+
+  const getLabel = (o) => (typeof o === "string" ? o : o.label);
+  const getHint = (o) =>
+    typeof o === "object" && o.hint ? ` ${DIM}${o.hint}${RESET}` : "";
+
+  const render = (first = false) => {
+    if (!first) moveUp(total);
+    for (let i = 0; i < total; i++) {
+      clearLine();
+      const active = i === cursor;
+      const prefix = active ? `  ${CYAN}❯${RESET} ` : "    ";
+      const text = active
+        ? `${BOLD}${getLabel(options[i])}${RESET}`
+        : `${DIM}${getLabel(options[i])}${RESET}`;
+      process.stdout.write(`${prefix}${text}${getHint(options[i])}\n`);
+    }
+  };
+
+  console.log(`\n  ${BOLD}${title}${RESET}\n`);
+  render(true);
+
+  return new Promise((resolve) => {
+    const onKey = (_str, key) => {
+      if (!key) return;
+      if (key.name === "up" || key.name === "k") {
+        cursor = (cursor - 1 + total) % total;
+        render();
+      } else if (key.name === "down" || key.name === "j") {
+        cursor = (cursor + 1) % total;
+        render();
+      } else if (key.name === "return") {
+        cleanup();
+        showCursor();
+        resolve({ index: cursor, value: options[cursor] });
+      } else if (key.name === "escape" || (key.ctrl && key.name === "c")) {
+        cleanup();
+        showCursor();
+        resolve(null);
+      }
+    };
+
+    const cleanup = () => {
+      process.stdin.removeListener("keypress", onKey);
+      process.stdin.setRawMode(false);
+      process.stdin.pause();
+    };
+
+    process.stdin.on("keypress", onKey);
+  });
+}
+
+// ── Input: Confirm ──
+
+export async function confirm(message, defaultYes = true) {
+  const hint = defaultYes
+    ? `${BOLD}Y${RESET}${DIM}/n${RESET}`
+    : `${DIM}y/${RESET}${BOLD}N${RESET}`;
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`  ${CYAN}?${RESET} ${message} [${hint}] `, (answer) => {
+      rl.close();
+      const a = answer.trim().toLowerCase();
+      if (a === "") resolve(defaultYes);
+      else resolve(a === "y" || a === "yes");
+    });
+  });
+}
+
+// ── Input: Text ──
+
+export async function input(message, defaultValue = "") {
+  const hint = defaultValue ? ` ${DIM}(${defaultValue})${RESET}` : "";
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  });
+
+  return new Promise((resolve) => {
+    rl.question(`  ${CYAN}?${RESET} ${message}${hint}: `, (answer) => {
+      rl.close();
+      resolve(answer.trim() || defaultValue);
+    });
+  });
+}
+
+// ── Spinner ──
+
+export function spinner(message) {
+  const frames = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+  let i = 0;
+  hideCursor();
+  const id = setInterval(() => {
+    clearLine();
+    process.stdout.write(
+      `  ${CYAN}${frames[i++ % frames.length]}${RESET} ${message}`,
+    );
+  }, 80);
+
+  return {
+    stop(finalMsg) {
+      clearInterval(id);
+      clearLine();
+      if (finalMsg) process.stdout.write(`${finalMsg}\n`);
+      showCursor();
+    },
+    update(msg) {
+      message = msg;
+    },
+  };
+}
+
+// ── Utils ──
+
+export function stripAnsi(str) {
+  return str.replace(/\x1b\[[0-9;]*m/g, "");
+}
+
+export function sleep(ms) {
+  return new Promise((r) => setTimeout(r, ms));
+}
+
+// graceful exit
+export function onExit(fn) {
+  const handler = () => {
+    showCursor();
+    fn?.();
+    process.exit(0);
+  };
+  process.on("SIGINT", handler);
+  process.on("SIGTERM", handler);
+}

package/tui/doctor.mjs

@@ -0,0 +1,375 @@
+#!/usr/bin/env node
+// tui/doctor.mjs — Interactive triflux doctor TUI
+import { execFileSync } from "node:child_process";
+import { existsSync, readdirSync, readFileSync, unlinkSync } from "node:fs";
+import { homedir } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import {
+  BOLD,
+  box,
+  clear,
+  confirm,
+  DIM,
+  divider,
+  fail,
+  GRAY,
+  GREEN,
+  info,
+  label,
+  ok,
+  onExit,
+  RED,
+  RESET,
+  select,
+  showCursor,
+  spinner,
+  table,
+  warn,
+  YELLOW,
+} from "./core.mjs";
+
+const PKG_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const CLAUDE_DIR = join(homedir(), ".claude");
+const CACHE_DIR = join(CLAUDE_DIR, "cache");
+
+const CACHE_FILES = [
+  { name: "claude-usage-cache.json", desc: "Claude 사용량" },
+  { name: ".claude-refresh-lock", desc: "리프레시 락" },
+  { name: "codex-rate-limits-cache.json", desc: "Codex 레이트 리밋" },
+  { name: "gemini-quota-cache.json", desc: "Gemini 쿼터" },
+  { name: "gemini-project-id.json", desc: "Gemini 프로젝트 ID" },
+  { name: "gemini-session-cache.json", desc: "Gemini 세션" },
+  { name: "gemini-rpm-tracker.json", desc: "Gemini RPM" },
+  { name: "sv-accumulator.json", desc: "절약량 누적" },
+  { name: "mcp-inventory.json", desc: "MCP 인벤토리" },
+  { name: "cli-issues.jsonl", desc: "CLI 이슈 로그" },
+  { name: "triflux-update-check.json", desc: "업데이트 체크" },
+  { name: "tfx-preflight.json", desc: "Preflight 캐시 (CLI/Hub 가용성)" },
+];
+
+// ── Run triflux doctor --json ──
+
+function runDoctor(mode = "check") {
+  const args = [join(PKG_ROOT, "bin", "triflux.mjs"), "doctor", "--json"];
+  if (mode === "fix") args.push("--fix");
+
+  try {
+    const out = execFileSync(process.execPath, args, {
+      timeout: 30000,
+      encoding: "utf8",
+      windowsHide: true,
+    });
+    // Extract JSON from output (may have ANSI/text before it)
+    const jsonMatch = out.match(/\{[\s\S]*\}$/m);
+    if (jsonMatch) return JSON.parse(jsonMatch[0]);
+  } catch (e) {
+    if (e.stdout) {
+      const jsonMatch = e.stdout.match(/\{[\s\S]*\}$/m);
+      if (jsonMatch) return JSON.parse(jsonMatch[0]);
+    }
+  }
+  return null;
+}
+
+// ── Display Results ──
+
+function statusIcon(status) {
+  const map = {
+    ok: `${GREEN}✓${RESET}`,
+    missing: `${RED}✗${RESET}`,
+    partial: `${YELLOW}⚠${RESET}`,
+    warning: `${YELLOW}⚠${RESET}`,
+    optional_missing: `${GRAY}○${RESET}`,
+  };
+  return map[status] || `${GRAY}?${RESET}`;
+}
+
+function showReport(report) {
+  if (!report) {
+    fail("진단 결과를 가져올 수 없습니다.");
+    return;
+  }
+
+  console.log();
+  const statusColor =
+    report.issue_count === 0 ? GREEN : report.issue_count <= 2 ? YELLOW : RED;
+  label(
+    "상태",
+    `${statusColor}${report.issue_count === 0 ? "정상" : `${report.issue_count}개 이슈`}${RESET}`,
+  );
+  label("모드", report.mode);
+  console.log();
+
+  const headers = ["항목", "상태", "비고"];
+  const rows = (report.checks || []).map((c) => {
+    let note = "";
+    if (c.version) note = `v${c.version}`;
+    if (c.missing_profiles?.length)
+      note = `누락: ${c.missing_profiles.join(", ")}`;
+    if (c.fix) note += note ? ` → ${c.fix}` : c.fix;
+    if (c.path && !c.fix) note = c.path;
+
+    const icon =
+      c.status === "ok"
+        ? statusIcon("ok")
+        : c.optional
+          ? statusIcon("optional_missing")
+          : statusIcon(c.status);
+
+    return [
+      `${icon} ${c.name}`,
+      c.status === "ok" ? `${GREEN}정상${RESET}` : `${RED}${c.status}${RESET}`,
+      note ? `${DIM}${note}${RESET}` : "",
+    ];
+  });
+
+  if (rows.length > 0) table(headers, rows);
+
+  // Actions (from fix/reset mode)
+  if (report.actions?.length > 0) {
+    console.log();
+    info(`수행된 작업: ${report.actions.length}개`);
+    for (const action of report.actions) {
+      const icon =
+        action.status === "ok" ? `${GREEN}✓${RESET}` : `${RED}✗${RESET}`;
+      console.log(
+        `    ${icon} ${action.type}: ${action.name || action.path || ""}`,
+      );
+    }
+  }
+}
+
+// ── Cache Management ──
+
+function getCacheStatus() {
+  const results = [];
+  for (const { name, desc } of CACHE_FILES) {
+    const fp = join(CACHE_DIR, name);
+    if (existsSync(fp)) {
+      let size = 0;
+      try {
+        size = readFileSync(fp).length;
+      } catch {}
+      let hasError = false;
+      try {
+        const parsed = JSON.parse(readFileSync(fp, "utf8"));
+        hasError = !!parsed.error;
+      } catch {
+        hasError = true;
+      }
+      results.push({ name, desc, exists: true, size, hasError });
+    } else {
+      results.push({ name, desc, exists: false, size: 0, hasError: false });
+    }
+  }
+  return results;
+}
+
+function showCacheStatus() {
+  const caches = getCacheStatus();
+  const existing = caches.filter((c) => c.exists);
+
+  if (existing.length === 0) {
+    info("캐시 파일 없음 (깨끗한 상태)");
+    return;
+  }
+
+  console.log();
+  const headers = ["캐시", "크기", "상태"];
+  const rows = existing.map((c) => [
+    c.desc,
+    c.size < 1024 ? `${c.size}B` : `${(c.size / 1024).toFixed(1)}KB`,
+    c.hasError ? `${RED}에러${RESET}` : `${GREEN}정상${RESET}`,
+  ]);
+  table(headers, rows);
+}
+
+async function selectiveReset() {
+  const caches = getCacheStatus().filter((c) => c.exists);
+  if (caches.length === 0) {
+    info("삭제할 캐시 파일이 없습니다.");
+    return;
+  }
+
+  const options = [
+    { label: "전체 삭제", hint: `${caches.length}개 파일` },
+    { label: "에러 캐시만 삭제", hint: "손상된 파일만" },
+    { label: "선택 삭제", hint: "하나씩 선택" },
+    { label: "취소", hint: "" },
+  ];
+
+  const choice = await select("삭제 방식", options);
+  if (!choice || choice.index === 3) return;
+
+  let targets = [];
+  if (choice.index === 0) {
+    targets = caches;
+  } else if (choice.index === 1) {
+    targets = caches.filter((c) => c.hasError);
+    if (targets.length === 0) {
+      info("에러 상태의 캐시가 없습니다.");
+      return;
+    }
+  } else {
+    for (const c of caches) {
+      const del = await confirm(`${c.desc} (${c.name}) 삭제?`, c.hasError);
+      if (del) targets.push(c);
+    }
+  }
+
+  if (targets.length === 0) return;
+
+  if (!(await confirm(`${targets.length}개 캐시 파일을 삭제하시겠습니까?`)))
+    return;
+
+  let deleted = 0;
+  for (const c of targets) {
+    try {
+      unlinkSync(join(CACHE_DIR, c.name));
+      ok(`삭제: ${c.desc}`);
+      deleted++;
+    } catch (e) {
+      fail(`삭제 실패: ${c.desc} — ${e.message}`);
+    }
+  }
+
+  ok(`${BOLD}${deleted}개${RESET} 캐시 파일 삭제 완료`);
+}
+
+// ── Orphan Teams ──
+
+async function checkOrphanTeams() {
+  const teamsDir = join(CLAUDE_DIR, "teams");
+  if (!existsSync(teamsDir)) {
+    info("teams 디렉토리 없음");
+    return;
+  }
+
+  const entries = readdirSync(teamsDir).filter((e) => !e.startsWith("."));
+  if (entries.length === 0) {
+    ok("잔존 팀 없음");
+    return;
+  }
+
+  warn(`${entries.length}개 팀 세션 발견`);
+  for (const e of entries) {
+    console.log(`    ${DIM}${e}${RESET}`);
+  }
+
+  if (await confirm("잔존 팀 정리를 시도하시겠습니까?", false)) {
+    const spin = spinner("팀 정리 중...");
+    try {
+      // Delegate to triflux's cleanup
+      execFileSync(
+        process.execPath,
+        [join(PKG_ROOT, "bin", "triflux.mjs"), "doctor", "--fix"],
+        {
+          timeout: 30000,
+          stdio: "ignore",
+          windowsHide: true,
+        },
+      );
+      spin.stop();
+      ok("팀 정리 완료");
+    } catch {
+      spin.stop();
+      warn("팀 정리 실패 — 수동 삭제가 필요할 수 있습니다");
+    }
+  }
+}
+
+// ── Main Menu ──
+
+const MENU = [
+  { label: "진단 (Diagnose)", hint: "읽기 전용 검사" },
+  { label: "수정 (Fix)", hint: "자동 수정 + 진단" },
+  { label: "캐시 관리 (Cache)", hint: "캐시 조회/선택 삭제" },
+  { label: "팀 세션 정리 (Teams)", hint: "잔존 팀 감지/정리" },
+  { label: "전체 초기화 (Reset)", hint: "캐시 전체 삭제 + 재생성" },
+  { label: "종료", hint: "Ctrl+C" },
+];
+
+async function main() {
+  onExit(() => {});
+  clear();
+
+  while (true) {
+    box("triflux Doctor", 46);
+    console.log();
+
+    const choice = await select("작업 선택", MENU);
+    if (!choice || choice.index === 5) {
+      console.log();
+      info("종료합니다.");
+      showCursor();
+      break;
+    }
+
+    console.log();
+
+    switch (choice.index) {
+      case 0: {
+        const spin = spinner("진단 중...");
+        const report = runDoctor("check");
+        spin.stop();
+        showReport(report);
+        break;
+      }
+
+      case 1: {
+        if (!(await confirm("자동 수정을 실행하시겠습니까?"))) break;
+        const spin = spinner("수정 + 진단 중...");
+        const report = runDoctor("fix");
+        spin.stop();
+        showReport(report);
+        break;
+      }
+
+      case 2: {
+        showCacheStatus();
+        console.log();
+        await selectiveReset();
+        break;
+      }
+
+      case 3: {
+        await checkOrphanTeams();
+        break;
+      }
+
+      case 4: {
+        if (
+          !(await confirm(
+            `${RED}전체 캐시를 초기화${RESET}하시겠습니까?`,
+            false,
+          ))
+        )
+          break;
+        const spin = spinner("초기화 + 재생성 중...");
+        try {
+          execFileSync(
+            process.execPath,
+            [join(PKG_ROOT, "bin", "triflux.mjs"), "doctor", "--reset"],
+            { timeout: 60000, encoding: "utf8", windowsHide: true },
+          );
+          spin.stop();
+          ok("전체 초기화 + 재생성 완료");
+        } catch {
+          spin.stop();
+          warn("초기화 중 일부 실패 — triflux doctor --reset으로 재시도");
+        }
+        break;
+      }
+    }
+
+    console.log();
+    divider(46);
+  }
+}
+
+main().catch((e) => {
+  showCursor();
+  console.error(e);
+  process.exit(1);
+});