triflux 7.1.4 → 7.2.1

package/hub/team/tui-viewer.mjs

@@ -22,6 +22,14 @@ if (!SESSION) {
   process.exit(1);
 }
 
+// ── psmux 존재 확인 ──
+try {
+  execFileSync("psmux", ["--version"], { encoding: "utf8", timeout: 2000 });
+} catch {
+  process.stderr.write("ERROR: psmux not found or not executable. Install psmux before running tui-viewer.\n");
+  process.exit(1);
+}
+
 const tui = createLogDashboard({ refreshMs: 0 });
 const startTime = Date.now();
 tui.setStartTime(startTime);
@@ -38,6 +46,7 @@ function listPanes() {
       return { index: parseInt(index, 10), title: title || "", pid };
     });
   } catch {
+    // psmux 미설치 또는 세션 없음 — 빈 목록 반환
     return [];
   }
 }
@@ -49,6 +58,7 @@ function capturePane(paneIdx, lines = 5) {
       "capture-pane", "-t", `${SESSION}:0.${paneIdx}`, "-p",
     ], { encoding: "utf8", timeout: 2000 }).trim().split("\n").slice(-lines).join("\n");
   } catch {
+    // pane 캡처 실패 (pane 종료 또는 세션 소멸) — 빈 문자열 반환
     return "";
   }
 }
@@ -62,6 +72,7 @@ function checkResultFile(paneName) {
     if (content.trim().length === 0) return null;
     return processHandoff(content, { exitCode: 0, resultFile });
   } catch {
+    // result 파일 파싱 실패 — null 반환하여 진행 중으로 처리
     return null;
   }
 }
@@ -69,9 +80,22 @@ function checkResultFile(paneName) {
 // ── 메인 폴링 ──
 const POLL_MS = 1000;
 const workerState = new Map(); // paneName → { paneIdx, done }
+let emptyPollCount = 0;
 
 function poll() {
   const panes = listPanes();
+
+  // 세션 사망 감지: 워커 pane이 없는 상태가 지속되면 자동 종료
+  if (!panes.some(p => p.index !== 0)) {
+    emptyPollCount++;
+    const threshold = workerState.size === 0 ? 15 : 10;
+    if (emptyPollCount >= threshold) {
+      tui.close(); clearInterval(timer); clearInterval(doneCheck); process.exit(0);
+    }
+  } else {
+    emptyPollCount = 0;
+  }
+
   // pane 0 = 대시보드 (자기 자신), pane 1+ = 워커
   for (const pane of panes) {
     if (pane.index === 0) continue; // 자기 자신 건너뜀
@@ -111,7 +135,7 @@ function poll() {
     // 완료 감지: (1) result 파일 존재, (2) 셸 프롬프트 복귀, (3) "tokens used" 텍스트
     const resultFile = join(RESULT_DIR, `${SESSION}-${paneName}.txt`);
     let resultSize = 0;
-    try { resultSize = statSync(resultFile).size; } catch {}
+    try { resultSize = statSync(resultFile).size; } catch { /* 파일 미존재 — size 0 유지 */ }
 
     const shellReturned = /^(PS\s|>|\$)\s*/.test(lastLine) && lines.length > 2;
     const tokensLine = lines.find(l => /tokens?\s+used/i.test(l));
@@ -152,5 +176,5 @@ const doneCheck = setInterval(() => {
   }
 }, 2000);
 
-process.on("SIGINT", () => { tui.close(); clearInterval(timer); process.exit(0); });
-setTimeout(() => { tui.close(); clearInterval(timer); process.exit(0); }, 10 * 60 * 1000);
+process.on("SIGINT", () => { tui.close(); clearInterval(timer); clearInterval(doneCheck); process.exit(0); });
+setTimeout(() => { tui.close(); clearInterval(timer); clearInterval(doneCheck); process.exit(0); }, 10 * 60 * 1000);

package/hub/team/tui.mjs

@@ -131,6 +131,7 @@ export function createLogDashboard(opts = {}) {
     render,
     getWorkers() { return new Map(workers); },
     getFrameCount() { return frameCount; },
+    getPipelineState() { return { ...pipeline }; },
     close() {
       if (closed) return;
       if (timer) clearInterval(timer);

package/hub/token-mode.mjs

@@ -20,39 +20,105 @@ export const COMPACT_RULES = [
   { 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: ['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 {Array<{ pattern: RegExp, to: string }>} */
-const _compactPairs = [];
+/** @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],
+};
 
-for (const rule of COMPACT_RULES) {
-  for (const keyword of rule.from) {
-    _compactPairs.push({ pattern: keyword, to: rule.to, len: keyword.length });
+// ── 내부: 정렬된 치환 쌍 빌드 헬퍼 ──
+
+/**
+ * 규칙 배열로부터 패턴 쌍을 빌드하고 긴 패턴 우선 정렬
+ * @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;
 }
-// greedy: 긴 패턴 먼저
-_compactPairs.sort((a, b) => b.len - a.len);
 
-/** @type {Array<{ pattern: RegExp, to: string }>} */
-const _expandPairs = [];
-
-for (const rule of COMPACT_RULES) {
-  // expand 시 첫 번째 from 값(영어 우선)으로 복원
-  _expandPairs.push({ symbol: rule.to, restore: rule.from[0] });
+/**
+ * 규칙 배열로부터 확장 쌍을 빌드
+ * @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;
@@ -114,6 +180,29 @@ export function compactify(text) {
   });
 }
 
+/**
+ * 텍스트를 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
@@ -121,6 +210,7 @@ export function compactify(text) {
  */
 export function expand(text) {
   if (!text || typeof text !== 'string') return text ?? '';
+  _compactMode = false;
 
   return withCodeProtection(text, (segment) => {
     let result = segment;