@triflux/core 10.0.0-alpha.1

package/hub/token-mode.mjs

@@ -0,0 +1,224 @@
+// hub/token-mode.mjs — Token Efficiency Mode
+// GAP 분석 P2 #7: 심볼 통신 + 약어로 30-50% 토큰 절감
+
+/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
+export const COMPACT_RULES = [
+  // ── 심볼 치환 (긴 매칭 우선 정렬) ──
+  { from: ['greater than or equal'],                to: '≥',  type: 'symbol' },
+  { from: ['less than or equal'],                   to: '≤',  type: 'symbol' },
+  { from: ['results in', '결과적으로'],             to: '→',  type: 'symbol' },
+  { from: ['therefore', '따라서'],                  to: '∴',  type: 'symbol' },
+  { from: ['because', '왜냐하면'],                  to: '∵',  type: 'symbol' },
+  { from: ['approximately', '대략'],                to: '≈',  type: 'symbol' },
+  { from: ['not equal', '같지 않'],                 to: '≠',  type: 'symbol' },
+  { from: ['in progress', '진행 중'],               to: '⏳', type: 'symbol' },
+  { from: ['completed', '완료'],                    to: '✓',  type: 'symbol' },
+  { from: ['success', '성공'],                      to: '✓',  type: 'symbol' },
+  { from: ['failure', '실패'],                      to: '✗',  type: 'symbol' },
+  { from: ['warning', '경고'],                      to: '⚠',  type: 'symbol' },
+  { from: ['error', '에러'],                        to: '✗',  type: 'symbol' },
+  { from: ['pending', '대기'],                      to: '⏸',  type: 'symbol' },
+
+  // ── 약어 (긴 매칭 우선 정렬) ──
+  { from: ['configuration', '설정'],                to: 'cfg',    type: 'abbrev' },
+  { from: ['implementation', '구현'],               to: 'impl',   type: 'abbrev' },
+  { from: ['architecture', '아키텍처'],             to: 'arch',   type: 'abbrev' },
+  { from: ['dependency', '의존성'],                 to: 'dep',    type: 'abbrev' },
+  { from: ['function', '함수'],                     to: 'fn',     type: 'abbrev' },
+  { from: ['parameter', '파라미터'],                to: 'param',  type: 'abbrev' },
+  { from: ['repository', '저장소'],                 to: 'repo',   type: 'abbrev' },
+  { from: ['environment', '환경'],                  to: 'env',    type: 'abbrev' },
+  { from: ['variable', '변수'],                     to: 'var',    type: 'abbrev' },
+  { from: ['directory', '디렉토리'],                to: 'dir',    type: 'abbrev' },
+
+  // ── 한국어 동사/명령형 약어 ──
+  { from: ['구현해'],   to: 'impl',    type: 'abbrev' },
+  { from: ['확인해'],   to: 'check',   type: 'abbrev' },
+  { from: ['수정해'],   to: 'fix',     type: 'abbrev' },
+  { from: ['테스트'],   to: 'test',    type: 'abbrev' },
+  { from: ['리뷰'],     to: 'review',  type: 'abbrev' },
+  { from: ['분석'],     to: 'analyze', type: 'abbrev' },
+  { from: ['설계'],     to: 'design',  type: 'abbrev' },
+  { from: ['문서화'],   to: 'docs',    type: 'abbrev' },
+];
+
+/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
+export const REVIEW_RULES = [
+  { from: ['looks good to me', 'lgtm'],    to: '✓lgtm',   type: 'abbrev' },
+  { from: ['needs changes', '수정 필요'],  to: '✗chg',    type: 'abbrev' },
+  { from: ['nitpick', '사소한'],           to: 'nit',     type: 'abbrev' },
+  { from: ['blocking', '블로킹'],          to: 'blk',     type: 'abbrev' },
+  { from: ['suggestion', '제안'],          to: 'sug',     type: 'abbrev' },
+  { from: ['question', '질문'],            to: 'q',       type: 'abbrev' },
+  { from: ['approved', '승인'],            to: '✓apv',    type: 'abbrev' },
+  { from: ['request changes', '변경 요청'], to: '✗req',   type: 'abbrev' },
+];
+
+/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
+export const DESIGN_RULES = [
+  { from: ['component', '컴포넌트'],       to: 'cmp',     type: 'abbrev' },
+  { from: ['interface', '인터페이스'],     to: 'iface',   type: 'abbrev' },
+  { from: ['abstraction', '추상화'],       to: 'abs',     type: 'abbrev' },
+  { from: ['pattern', '패턴'],             to: 'ptn',     type: 'abbrev' },
+  { from: ['dependency injection', '의존성 주입'], to: 'di', type: 'abbrev' },
+  { from: ['single responsibility', '단일 책임'],  to: 'srp', type: 'abbrev' },
+  { from: ['open closed', '개방 폐쇄'],    to: 'ocp',     type: 'abbrev' },
+  { from: ['inheritance', '상속'],         to: 'inh',     type: 'abbrev' },
+];
+
+/** @type {Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>} */
+export const DOCS_RULES = [
+  { from: ['description', '설명'],         to: 'desc',    type: 'abbrev' },
+  { from: ['example', '예시'],             to: 'ex',      type: 'abbrev' },
+  { from: ['reference', '참조'],           to: 'ref',     type: 'abbrev' },
+  { from: ['introduction', '소개'],        to: 'intro',   type: 'abbrev' },
+  { from: ['deprecated', '사용 중단'],     to: 'dep',     type: 'abbrev' },
+  { from: ['optional', '선택적'],          to: 'opt',     type: 'abbrev' },
+  { from: ['required', '필수'],            to: 'req',     type: 'abbrev' },
+  { from: ['returns', '반환'],             to: 'ret',     type: 'abbrev' },
+];
+
+// ── 프로필 맵 ──
+
+/** @type {Record<string, Array<{ from: string[], to: string, type: 'symbol'|'abbrev' }>>} */
+const PROFILE_MAP = {
+  default: COMPACT_RULES,
+  review:  [...COMPACT_RULES, ...REVIEW_RULES],
+  design:  [...COMPACT_RULES, ...DESIGN_RULES],
+  docs:    [...COMPACT_RULES, ...DOCS_RULES],
+};
+
+// ── 내부: 정렬된 치환 쌍 빌드 헬퍼 ──
+
+/**
+ * 규칙 배열로부터 패턴 쌍을 빌드하고 긴 패턴 우선 정렬
+ * @param {Array<{ from: string[], to: string }>} rules
+ * @returns {Array<{ pattern: string, to: string, len: number }>}
+ */
+function buildCompactPairs(rules) {
+  const pairs = [];
+  for (const rule of rules) {
+    for (const keyword of rule.from) {
+      pairs.push({ pattern: keyword, to: rule.to, len: keyword.length });
+    }
+  }
+  pairs.sort((a, b) => b.len - a.len);
+  return pairs;
+}
+
+/**
+ * 규칙 배열로부터 확장 쌍을 빌드
+ * @param {Array<{ from: string[], to: string }>} rules
+ * @returns {Array<{ symbol: string, restore: string }>}
+ */
+function buildExpandPairs(rules) {
+  return rules.map((rule) => ({ symbol: rule.to, restore: rule.from[0] }));
+}
+
+// 기본 프로필 쌍 (기존 동작 유지)
+const _compactPairs = buildCompactPairs(COMPACT_RULES);
+const _expandPairs = buildExpandPairs(COMPACT_RULES);
+
+// ── 코드 블록 보호 유틸 ──
+
+const CODE_BLOCK_RE = /```[\s\S]*?```/g;
+
+/**
+ * 코드 블록을 플레이스홀더로 치환, 변환 후 복원
+ * @param {string} text
+ * @param {(segment: string) => string} transform
+ * @returns {string}
+ */
+function withCodeProtection(text, transform) {
+  const blocks = [];
+  const placeholder = '\x00CB';
+  let idx = 0;
+  const masked = text.replace(CODE_BLOCK_RE, (match) => {
+    blocks.push(match);
+    return `${placeholder}${idx++}${placeholder}`;
+  });
+
+  const transformed = transform(masked);
+
+  // 플레이스홀더 복원
+  return transformed.replace(
+    new RegExp(`${placeholder}(\\d+)${placeholder}`, 'g'),
+    (_, i) => blocks[Number(i)],
+  );
+}
+
+// ── compact 모드 상태 ──
+
+let _compactMode = false;
+
+/**
+ * compact 모드 활성 여부
+ * @returns {boolean}
+ */
+export function isCompactMode() {
+  return _compactMode;
+}
+
+/**
+ * 텍스트를 compact 모드로 변환
+ * 심볼 치환 + 약어 적용, 코드 블록 내부는 보호
+ * @param {string} text
+ * @returns {string}
+ */
+export function compactify(text) {
+  if (!text || typeof text !== 'string') return text ?? '';
+  _compactMode = true;
+
+  return withCodeProtection(text, (segment) => {
+    let result = segment;
+    for (const { pattern, to } of _compactPairs) {
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const re = new RegExp(escaped, 'gi');
+      result = result.replace(re, to);
+    }
+    return result;
+  });
+}
+
+/**
+ * 텍스트를 compact 모드로 변환 (도메인 프로필 선택 가능)
+ * @param {string} text
+ * @param {'default'|'review'|'design'|'docs'} [profile='default'] — 도메인 프로필
+ * @returns {string}
+ */
+export function applyCompactRules(text, profile = 'default') {
+  if (!text || typeof text !== 'string') return text ?? '';
+
+  const rules = PROFILE_MAP[profile] ?? COMPACT_RULES;
+  const pairs = buildCompactPairs(rules);
+
+  return withCodeProtection(text, (segment) => {
+    let result = segment;
+    for (const { pattern, to } of pairs) {
+      const escaped = pattern.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const re = new RegExp(escaped, 'gi');
+      result = result.replace(re, to);
+    }
+    return result;
+  });
+}
+
+/**
+ * compact 텍스트를 원래 형태로 복원 (best-effort)
+ * @param {string} text
+ * @returns {string}
+ */
+export function expand(text) {
+  if (!text || typeof text !== 'string') return text ?? '';
+  _compactMode = false;
+
+  return withCodeProtection(text, (segment) => {
+    let result = segment;
+    for (const { symbol, restore } of _expandPairs) {
+      const escaped = symbol.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const re = new RegExp(escaped, 'g');
+      result = result.replace(re, restore);
+    }
+    return result;
+  });
+}

package/hub/workers/worker-utils.mjs

@@ -0,0 +1,104 @@
+// hub/workers/worker-utils.mjs — 워커 공통 유틸리티
+// claude-worker, gemini-worker, pipe 등에서 공유하는 순수 유틸 함수 모음.
+
+export const DEFAULT_TIMEOUT_MS = 15 * 60 * 1000;
+export const DEFAULT_KILL_GRACE_MS = 1000;
+
+export function toStringList(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => String(item ?? '').trim())
+    .filter(Boolean);
+}
+
+export function safeJsonParse(line) {
+  try {
+    return JSON.parse(line);
+  } catch {
+    return null;
+  }
+}
+
+export function createWorkerError(message, details = {}) {
+  const error = new Error(message);
+  Object.assign(error, details);
+  return error;
+}
+
+function sleep(delayMs) {
+  return new Promise((resolve) => {
+    const timer = setTimeout(resolve, Math.max(0, delayMs));
+    timer.unref?.();
+  });
+}
+
+export async function withRetry(fn, opts = {}) {
+  const {
+    maxAttempts = 3,
+    baseDelayMs = 1000,
+    maxDelayMs = 15000,
+    shouldRetry = () => true,
+  } = opts;
+
+  let lastError;
+
+  for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+    try {
+      return await fn();
+    } catch (error) {
+      lastError = error;
+      if (attempt >= maxAttempts || !shouldRetry(error, attempt)) {
+        throw error;
+      }
+
+      const delay = Math.min(baseDelayMs * 2 ** (attempt - 1), maxDelayMs)
+        * (0.5 + Math.random() * 0.5);
+      await sleep(delay);
+    }
+  }
+
+  throw lastError;
+}
+
+export function appendTextFragments(value, parts) {
+  if (value == null) return;
+
+  if (typeof value === 'string') {
+    const trimmed = value.trim();
+    if (trimmed) parts.push(trimmed);
+    return;
+  }
+
+  if (Array.isArray(value)) {
+    for (const item of value) appendTextFragments(item, parts);
+    return;
+  }
+
+  if (typeof value !== 'object') return;
+
+  if (typeof value.text === 'string') appendTextFragments(value.text, parts);
+  if (typeof value.response === 'string') appendTextFragments(value.response, parts);
+  if (typeof value.result === 'string') appendTextFragments(value.result, parts);
+  if (value.content != null) appendTextFragments(value.content, parts);
+  if (value.message != null) appendTextFragments(value.message, parts);
+}
+
+export function extractText(value) {
+  const parts = [];
+  appendTextFragments(value, parts);
+  return parts.join('\n').trim();
+}
+
+export function terminateChild(child, killGraceMs) {
+  if (!child || child.exitCode !== null || child.killed) return;
+
+  try { child.stdin.end(); } catch {}
+  try { child.kill(); } catch {}
+
+  const timer = setTimeout(() => {
+    if (child.exitCode === null) {
+      try { child.kill('SIGKILL'); } catch {}
+    }
+  }, killGraceMs);
+  timer.unref?.();
+}

package/hud/colors.mjs

@@ -0,0 +1,88 @@
+// ============================================================================
+// ANSI 색상 (OMC colors.js 스키마 일치)
+// ============================================================================
+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 CLAUDE_ORANGE = "\x1b[38;2;232;112;64m"; // #E87040 (Claude 공식 오렌지)
+export const CODEX_WHITE = "\x1b[97m"; // bright white (SGR 37은 Windows Terminal에서 연회색 매핑)
+export const GEMINI_BLUE = "\x1b[38;5;39m";
+
+export function green(t) { return `${GREEN}${t}${RESET}`; }
+export function yellow(t) { return `${YELLOW}${t}${RESET}`; }
+export function red(t) { return `${RED}${t}${RESET}`; }
+export function cyan(t) { return `${CYAN}${t}${RESET}`; }
+export function dim(t) { return `${DIM}${t}${RESET}`; }
+export function bold(t) { return `${BOLD}${t}${RESET}`; }
+export function claudeOrange(t) { return `${CLAUDE_ORANGE}${t}${RESET}`; }
+export function codexWhite(t) { return `${CODEX_WHITE}${t}${RESET}`; }
+export function geminiBlue(t) { return `${GEMINI_BLUE}${t}${RESET}`; }
+
+export function colorByPercent(value, text) {
+  if (value >= 85) return red(text);
+  if (value >= 70) return yellow(text);
+  if (value >= 50) return cyan(text);
+  return green(text);
+}
+
+export function colorCooldown(seconds, text) {
+  if (seconds > 120) return red(text);
+  if (seconds > 0) return yellow(text);
+  return dim(text);
+}
+
+export function colorParallel(current, cap) {
+  if (current >= cap) return green(`${current}/${cap}`);
+  if (current > 1) return yellow(`${current}/${cap}`);
+  return red(`${current}/${cap}`);
+}
+
+export const GAUGE_WIDTH = 5;
+export const GAUGE_BLOCKS = ["░", "▒", "▓", "█"]; // 밝기 0~3
+
+export function coloredBar(percent, width = GAUGE_WIDTH, baseColor = null) {
+  const safePercent = Math.min(100, Math.max(0, percent));
+  const perBlock = 100 / width;
+
+  // 상태별 색상
+  let barColor;
+  if (safePercent >= 85) barColor = RED;
+  else if (safePercent >= 70) barColor = YELLOW;
+  else barColor = baseColor || GREEN;
+
+  let bar = "";
+  for (let i = 0; i < width; i++) {
+    const blockStart = i * perBlock;
+    const blockEnd = (i + 1) * perBlock;
+
+    if (safePercent >= blockEnd) {
+      bar += "█"; // 완전 채움
+    } else if (safePercent > blockStart) {
+      // 프론티어: 구간 내 진행률
+      const progress = (safePercent - blockStart) / perBlock;
+      if (progress >= 0.75) bar += "▓";
+      else if (progress >= 0.33) bar += "▒";
+      else bar += "░";
+    } else {
+      bar += "░"; // 미도달
+    }
+  }
+
+  // 채워진 부분 = barColor, 빈 부분 = DIM
+  const filledEnd = Math.ceil(safePercent / perBlock);
+  const coloredPart = barColor + bar.slice(0, filledEnd) + RESET;
+  const dimPart = filledEnd < width ? DIM + bar.slice(filledEnd) + RESET : "";
+
+  return coloredPart + dimPart;
+}
+
+// 프로바이더별 색상 % (< 70%: 프로바이더 색, ≥ 70%: 경고색)
+export function colorByProvider(value, text, providerColorFn) {
+  if (value >= 85) return red(text);
+  if (value >= 70) return yellow(text);
+  return providerColorFn(text);
+}

package/hud/constants.mjs

@@ -0,0 +1,81 @@
+// ============================================================================
+// 상수 / 경로
+// ============================================================================
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+export const VERSION = "2.0";
+
+export const QOS_PATH = join(homedir(), ".omc", "state", "cli_qos_profile.json");
+export const ACCOUNTS_CONFIG_PATH = join(homedir(), ".omc", "router", "accounts.json");
+export const ACCOUNTS_STATE_PATH = join(homedir(), ".omc", "state", "cli_accounts_state.json");
+
+// tfx-multi 상태 (v2.2 HUD 통합)
+export const TEAM_STATE_PATH = join(homedir(), ".claude", "cache", "tfx-hub", "team-state.json");
+
+// Claude OAuth Usage API (api.anthropic.com/api/oauth/usage)
+export const CLAUDE_CREDENTIALS_PATH = join(homedir(), ".claude", ".credentials.json");
+export const CLAUDE_USAGE_CACHE_PATH = join(homedir(), ".claude", "cache", "claude-usage-cache.json");
+export const OMC_PLUGIN_USAGE_CACHE_PATH = join(homedir(), ".claude", "plugins", "oh-my-claudecode", ".usage-cache.json");
+export const CLAUDE_USAGE_STALE_MS_SOLO = 5 * 60 * 1000; // OMC 없을 때: 5분 캐시
+export const CLAUDE_USAGE_STALE_MS_WITH_OMC = 15 * 60 * 1000; // OMC 있을 때: 15분 (OMC가 30초마다 갱신)
+export const CLAUDE_USAGE_429_BACKOFF_MS = 10 * 60 * 1000; // 429 에러 시 10분 backoff
+export const GEMINI_429_BASE_DELAY_MS = 2000;
+export const GEMINI_429_MAX_RETRIES = 3;
+export const GEMINI_429_COOLDOWN_MS = 30000;
+export const CLAUDE_USAGE_ERROR_BACKOFF_MS = 3 * 60 * 1000; // 기타 에러 시 3분 backoff
+export const CLAUDE_API_TIMEOUT_MS = 10_000;
+export const FIVE_HOUR_MS = 5 * 60 * 60 * 1000;
+export const SEVEN_DAY_MS = 7 * 24 * 60 * 60 * 1000;
+export const ONE_DAY_MS = 24 * 60 * 60 * 1000;
+export const DEFAULT_OAUTH_CLIENT_ID = "9d1c250a-e61b-44d9-88ed-5944d1962f5e";
+
+export const CODEX_AUTH_PATH = join(homedir(), ".codex", "auth.json");
+export const CODEX_QUOTA_CACHE_PATH = join(homedir(), ".claude", "cache", "codex-rate-limits-cache.json");
+export const CODEX_QUOTA_STALE_MS = 15 * 1000; // 15초
+export const CODEX_MIN_BUCKETS = 2;
+
+// Gemini 쿼터 API 관련
+export const GEMINI_OAUTH_PATH = join(homedir(), ".gemini", "oauth_creds.json");
+export const GEMINI_QUOTA_CACHE_PATH = join(homedir(), ".claude", "cache", "gemini-quota-cache.json");
+export const GEMINI_PROJECT_CACHE_PATH = join(homedir(), ".claude", "cache", "gemini-project-id.json");
+export const GEMINI_SESSION_CACHE_PATH = join(homedir(), ".claude", "cache", "gemini-session-cache.json");
+export const GEMINI_RPM_TRACKER_PATH = join(homedir(), ".claude", "cache", "gemini-rpm-tracker.json");
+export const SV_ACCUMULATOR_PATH = join(homedir(), ".claude", "cache", "sv-accumulator.json");
+// 이전 .omc/ 경로 fallback (기존 환경 호환)
+export const LEGACY_GEMINI_QUOTA_CACHE = join(homedir(), ".omc", "state", "gemini_quota_cache.json");
+export const LEGACY_GEMINI_PROJECT_CACHE = join(homedir(), ".omc", "state", "gemini_project_id.json");
+export const LEGACY_GEMINI_SESSION_CACHE = join(homedir(), ".omc", "state", "gemini_session_tokens_cache.json");
+export const LEGACY_GEMINI_RPM_TRACKER = join(homedir(), ".omc", "state", "gemini_rpm_tracker.json");
+export const LEGACY_SV_ACCUMULATOR = join(homedir(), ".omc", "state", "sv-accumulator.json");
+
+export const GEMINI_RPM_WINDOW_MS = 60 * 1000; // 60초 슬라이딩 윈도우
+export const GEMINI_QUOTA_STALE_MS = 5 * 60 * 1000; // 5분
+export const GEMINI_SESSION_STALE_MS = 15 * 1000; // 15초
+export const GEMINI_API_TIMEOUT_MS = 3000; // 3초
+
+export const ACCOUNT_LABEL_WIDTH = 10;
+export const PROVIDER_PREFIX_WIDTH = 2;
+export const PERCENT_CELL_WIDTH = 3;
+export const TIME_CELL_INNER_WIDTH = 6;
+export const SV_CELL_WIDTH = 5;
+
+export const CLAUDE_REFRESH_FLAG = "--refresh-claude-usage";
+export const CODEX_REFRESH_FLAG = "--refresh-codex-rate-limits";
+export const GEMINI_REFRESH_FLAG = "--refresh-gemini-quota";
+export const GEMINI_SESSION_REFRESH_FLAG = "--refresh-gemini-session";
+
+// 모바일/Termux 컴팩트 모드 감지
+export const HUD_CONFIG_PATH = join(homedir(), ".omc", "config", "hud.json");
+export const COMPACT_COLS_THRESHOLD = 80;
+export const MINIMAL_COLS_THRESHOLD = 60;
+
+// rows 임계값 상수 (selectTier 에서 tier 결정에 사용)
+export const ROWS_BUDGET_FULL = 40;
+export const ROWS_BUDGET_LARGE = 35;
+export const ROWS_BUDGET_MEDIUM = 28;
+export const ROWS_BUDGET_SMALL = 22;
+
+// Gemini Pro 풀 공유 그룹: 같은 remainingFraction을 공유하는 모델 ID들
+export const GEMINI_PRO_POOL = new Set(["gemini-2.5-pro", "gemini-3-pro-preview", "gemini-3.1-pro-preview"]);
+export const GEMINI_FLASH_POOL = new Set(["gemini-2.5-flash", "gemini-3-flash-preview"]);