triflux 10.3.4 → 10.7.0

package/hub/intent.mjs

@@ -1,9 +1,9 @@
 // hub/intent.mjs — Intent Classification Engine
 // 사용자 요청의 "진짜 의도"를 분석 → 카테고리 분류 → 최적 에이전트/모델 자동 선택
 
-import { execFileSync } from 'node:child_process';
-import crypto from 'node:crypto';
-import { whichCommand } from './platform.mjs';
+import { execFileSync } from "node:child_process";
+import crypto from "node:crypto";
+import { whichCommand } from "./platform.mjs";
 
 /** 캐시 엔트리: { category, confidence, ts } */
 const _intentCache = new Map();
@@ -15,12 +15,12 @@ let _codexAvailable = null;
 /** @experimental 런타임 미연결 — 향후 통합 예정 */
 function _isCodexAvailable() {
   if (_codexAvailable !== null) return _codexAvailable;
-  _codexAvailable = Boolean(whichCommand('codex'));
+  _codexAvailable = Boolean(whichCommand("codex"));
   return _codexAvailable;
 }
 
 function _promptHash(prompt) {
-  return crypto.createHash('md5').update(prompt).digest('hex');
+  return crypto.createHash("md5").update(prompt).digest("hex");
 }
 
 function _getCached(hash) {
@@ -36,16 +36,17 @@ function _getCached(hash) {
 function _tryCodexClassify(prompt) {
   try {
     const raw = execFileSync(
-      'codex',
-      ['exec', `Classify intent: ${prompt}. Reply JSON: {intent, confidence}`],
-      { timeout: 8000, encoding: 'utf8' }
+      "codex",
+      ["exec", `Classify intent: ${prompt}. Reply JSON: {intent, confidence}`],
+      { timeout: 8000, encoding: "utf8" },
     );
     // JSON 블록 추출 (응답에 다른 텍스트가 섞일 수 있음)
     const match = raw.match(/\{[\s\S]*?\}/);
     if (!match) return null;
     const parsed = JSON.parse(match[0]);
-    const intent = typeof parsed.intent === 'string' ? parsed.intent : null;
-    const confidence = typeof parsed.confidence === 'number' ? parsed.confidence : null;
+    const intent = typeof parsed.intent === "string" ? parsed.intent : null;
+    const confidence =
+      typeof parsed.confidence === "number" ? parsed.confidence : null;
     if (!intent || confidence === null) return null;
     // intent가 알려진 카테고리여야 함
     if (!INTENT_CATEGORIES[intent]) return null;
@@ -60,30 +61,144 @@ function _tryCodexClassify(prompt) {
  * triflux 특화 의도 카테고리 (10개)
  */
 export const INTENT_CATEGORIES = {
-  implement:  { agent: 'executor',       mcp: 'implement', effort: 'codex53_high' },
-  debug:      { agent: 'debugger',       mcp: 'implement', effort: 'codex53_high' },
-  analyze:    { agent: 'analyst',        mcp: 'analyze',   effort: 'gpt54_xhigh' },
-  design:     { agent: 'architect',      mcp: 'analyze',   effort: 'gpt54_xhigh' },
-  review:     { agent: 'code-reviewer',  mcp: 'review',    effort: 'codex53_high' },
-  document:   { agent: 'writer',         mcp: 'docs',      effort: 'pro' },
-  research:   { agent: 'scientist',      mcp: 'analyze',   effort: 'codex53_high' },
-  'quick-fix':{ agent: 'build-fixer',    mcp: 'implement', effort: 'codex53_low' },
-  explain:    { agent: 'writer',         mcp: 'docs',      effort: 'flash' },
-  test:       { agent: 'test-engineer',  mcp: null,         effort: null },
+  implement: { agent: "executor", mcp: "implement", effort: "codex53_high" },
+  debug: { agent: "debugger", mcp: "implement", effort: "codex53_high" },
+  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt54_xhigh" },
+  design: { agent: "architect", mcp: "analyze", effort: "gpt54_xhigh" },
+  review: { agent: "code-reviewer", mcp: "review", effort: "codex53_high" },
+  document: { agent: "writer", mcp: "docs", effort: "pro" },
+  research: { agent: "scientist", mcp: "analyze", effort: "codex53_high" },
+  "quick-fix": {
+    agent: "build-fixer",
+    mcp: "implement",
+    effort: "codex53_low",
+  },
+  explain: { agent: "writer", mcp: "docs", effort: "flash" },
+  test: { agent: "test-engineer", mcp: null, effort: null },
 };
 
 /** @internal 키워드 → 카테고리 매핑 패턴 */
 const KEYWORD_PATTERNS = [
-  { category: 'implement', keywords: ['구현', '만들', '추가', '생성', '작성', '빌드', 'implement', 'create', 'add', 'build', 'make', 'develop'], weight: 1.0 },
-  { category: 'debug',     keywords: ['버그', '에러', '오류', '고쳐', '수정', '디버그', 'fix', 'bug', 'error', 'debug', 'troubleshoot', 'crash', 'broken'], weight: 1.0 },
-  { category: 'analyze',   keywords: ['분석', '조사', '파악', 'analyze', 'investigate', 'examine', 'inspect'], weight: 0.9 },
-  { category: 'design',    keywords: ['설계', '아키텍처', '디자인', '구조', 'design', 'architect', 'structure'], weight: 0.9 },
-  { category: 'review',    keywords: ['리뷰', '검토', '코드리뷰', 'review', 'code review', 'audit'], weight: 1.0 },
-  { category: 'document',  keywords: ['문서', '도큐먼트', '문서화', 'document', 'docs', 'documentation', 'readme'], weight: 0.9 },
-  { category: 'research',  keywords: ['리서치', '연구', '탐색', 'research', 'explore', 'study'], weight: 0.8 },
-  { category: 'quick-fix', keywords: ['빠르게', '간단히', '급한', 'quick fix', 'hotfix', 'quick'], weight: 0.85 },
-  { category: 'explain',   keywords: ['설명', '뭐야', '알려', '이해', 'explain', 'what is', 'how does', 'tell me', 'describe'], weight: 1.0 },
-  { category: 'test',      keywords: ['테스트', '테스팅', '시험', '검증', 'test', 'testing', 'spec', 'unit test'], weight: 1.0 },
+  {
+    category: "implement",
+    keywords: [
+      "구현",
+      "만들",
+      "추가",
+      "생성",
+      "작성",
+      "빌드",
+      "implement",
+      "create",
+      "add",
+      "build",
+      "make",
+      "develop",
+    ],
+    weight: 1.0,
+  },
+  {
+    category: "debug",
+    keywords: [
+      "버그",
+      "에러",
+      "오류",
+      "고쳐",
+      "수정",
+      "디버그",
+      "fix",
+      "bug",
+      "error",
+      "debug",
+      "troubleshoot",
+      "crash",
+      "broken",
+    ],
+    weight: 1.0,
+  },
+  {
+    category: "analyze",
+    keywords: [
+      "분석",
+      "조사",
+      "파악",
+      "analyze",
+      "investigate",
+      "examine",
+      "inspect",
+    ],
+    weight: 0.9,
+  },
+  {
+    category: "design",
+    keywords: [
+      "설계",
+      "아키텍처",
+      "디자인",
+      "구조",
+      "design",
+      "architect",
+      "structure",
+    ],
+    weight: 0.9,
+  },
+  {
+    category: "review",
+    keywords: ["리뷰", "검토", "코드리뷰", "review", "code review", "audit"],
+    weight: 1.0,
+  },
+  {
+    category: "document",
+    keywords: [
+      "문서",
+      "도큐먼트",
+      "문서화",
+      "document",
+      "docs",
+      "documentation",
+      "readme",
+    ],
+    weight: 0.9,
+  },
+  {
+    category: "research",
+    keywords: ["리서치", "연구", "탐색", "research", "explore", "study"],
+    weight: 0.8,
+  },
+  {
+    category: "quick-fix",
+    keywords: ["빠르게", "간단히", "급한", "quick fix", "hotfix", "quick"],
+    weight: 0.85,
+  },
+  {
+    category: "explain",
+    keywords: [
+      "설명",
+      "뭐야",
+      "알려",
+      "이해",
+      "explain",
+      "what is",
+      "how does",
+      "tell me",
+      "describe",
+    ],
+    weight: 1.0,
+  },
+  {
+    category: "test",
+    keywords: [
+      "테스트",
+      "테스팅",
+      "시험",
+      "검증",
+      "test",
+      "testing",
+      "spec",
+      "unit test",
+    ],
+    weight: 1.0,
+  },
 ];
 
 /**
@@ -93,8 +208,8 @@ const KEYWORD_PATTERNS = [
  * @returns {{ category: string, confidence: number }}
  */
 export function quickClassify(prompt) {
-  if (!prompt || typeof prompt !== 'string' || !prompt.trim()) {
-    return { category: 'implement', confidence: 0.1 };
+  if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
+    return { category: "implement", confidence: 0.1 };
   }
 
   const lower = prompt.toLowerCase().trim();
@@ -118,11 +233,14 @@ export function quickClassify(prompt) {
   }
 
   if (!bestCategory) {
-    return { category: 'implement', confidence: 0.3 };
+    return { category: "implement", confidence: 0.3 };
   }
 
   // 매칭 품질 기반 신뢰도 (0.5~0.95 범위) — matchCount 기준으로 정규화 (3개 매칭이면 최대)
-  const confidence = Math.min(0.95, 0.5 + (Math.min(bestMatchCount, 3) / 3) * 0.45);
+  const confidence = Math.min(
+    0.95,
+    0.5 + (Math.min(bestMatchCount, 3) / 3) * 0.45,
+  );
   return { category: bestCategory, confidence };
 }
 
@@ -135,17 +253,22 @@ export function quickClassify(prompt) {
  * @returns {{ category: string, confidence: number, reasoning: string, routing: { agent: string, mcp: string|null, effort: string|null } }}
  */
 export function classifyIntent(prompt) {
-  const hash = _promptHash(String(prompt ?? ''));
+  const hash = _promptHash(String(prompt ?? ""));
 
   // 캐시 확인
   const cached = _getCached(hash);
   if (cached) {
-    const routing = INTENT_CATEGORIES[cached.category] || INTENT_CATEGORIES.implement;
+    const routing =
+      INTENT_CATEGORIES[cached.category] || INTENT_CATEGORIES.implement;
     return {
       category: cached.category,
       confidence: cached.confidence,
       reasoning: `cache-hit: ${cached.category} (${cached.confidence.toFixed(2)})`,
-      routing: { agent: routing.agent, mcp: routing.mcp, effort: routing.effort },
+      routing: {
+        agent: routing.agent,
+        mcp: routing.mcp,
+        effort: routing.effort,
+      },
     };
   }
 
@@ -161,7 +284,7 @@ export function classifyIntent(prompt) {
     reasoning = `keyword-match: ${category} (${confidence.toFixed(2)})`;
   } else if (_isCodexAvailable()) {
     // Codex triage
-    const codexResult = _tryCodexClassify(String(prompt ?? ''));
+    const codexResult = _tryCodexClassify(String(prompt ?? ""));
     if (codexResult && codexResult.confidence > 0.8) {
       category = codexResult.category;
       confidence = codexResult.confidence;

package/hub/lib/cache-guard.mjs

@@ -1,4 +1,10 @@
-import { accessSync, constants, existsSync, readFileSync, readdirSync } from "node:fs";
+import {
+  accessSync,
+  constants,
+  existsSync,
+  readdirSync,
+  readFileSync,
+} from "node:fs";
 import http from "node:http";
 import https from "node:https";
 import { basename, join, relative } from "node:path";
@@ -7,7 +13,10 @@ const NETWORK_TIMEOUT_MS = 3_000;
 
 function toIssuePath(cacheDir, filePath) {
   const relPath = relative(cacheDir, filePath);
-  return (relPath && relPath.length > 0 ? relPath : basename(filePath)).replace(/\\/g, "/");
+  return (relPath && relPath.length > 0 ? relPath : basename(filePath)).replace(
+    /\\/g,
+    "/",
+  );
 }
 
 function collectCacheFiles(cacheDir) {
@@ -45,19 +54,28 @@ function probeUrl(url) {
 
     try {
       const parsed = new URL(url);
-      const transport = parsed.protocol === "https:" ? https : parsed.protocol === "http:" ? http : null;
+      const transport =
+        parsed.protocol === "https:"
+          ? https
+          : parsed.protocol === "http:"
+            ? http
+            : null;
       if (!transport) {
         finish(false);
         return;
       }
 
-      const request = transport.request(parsed, {
-        method: "HEAD",
-        headers: { "user-agent": "triflux-cache-guard" },
-      }, (response) => {
-        response.resume();
-        finish(true);
-      });
+      const request = transport.request(
+        parsed,
+        {
+          method: "HEAD",
+          headers: { "user-agent": "triflux-cache-guard" },
+        },
+        (response) => {
+          response.resume();
+          finish(true);
+        },
+      );
 
       request.setTimeout(NETWORK_TIMEOUT_MS, () => {
         request.destroy(new Error("timeout"));
@@ -88,23 +106,31 @@ export function validateRuntimeCachePaths(cacheDir) {
   } catch (error) {
     return {
       ok: false,
-      issues: [{
-        file: ".",
-        error: error instanceof Error ? error.message : String(error),
-      }],
+      issues: [
+        {
+          file: ".",
+          error: error instanceof Error ? error.message : String(error),
+        },
+      ],
     };
   }
 }
 
 export async function checkNetworkAvailability(urls) {
-  const targets = [...new Set((Array.isArray(urls) ? urls : []).filter(Boolean))];
+  const targets = [
+    ...new Set((Array.isArray(urls) ? urls : []).filter(Boolean)),
+  ];
   if (targets.length === 0) {
     return { online: true, reachable: [], unreachable: [] };
   }
 
   const results = await Promise.all(targets.map((url) => probeUrl(url)));
-  const reachable = results.filter((result) => result.ok).map((result) => result.url);
-  const unreachable = results.filter((result) => !result.ok).map((result) => result.url);
+  const reachable = results
+    .filter((result) => result.ok)
+    .map((result) => result.url);
+  const unreachable = results
+    .filter((result) => !result.ok)
+    .map((result) => result.url);
 
   return {
     online: unreachable.length === 0,

package/hub/lib/mcp-response-cache.mjs

@@ -2,29 +2,36 @@
 // Deep 스킬에서 3개 모델이 같은 context7 문서를 요청하면 1번만 호출, 나머지는 캐시 hit.
 // 파일 기반 영속 + 메모리 기반 핫캐시 이중 구조.
 
-import { existsSync, mkdirSync, readFileSync, writeFileSync, readdirSync, unlinkSync, statSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { homedir } from 'node:os';
-
-const DEFAULT_CACHE_DIR = join(homedir(), '.triflux', 'mcp-cache');
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_CACHE_DIR = join(homedir(), ".triflux", "mcp-cache");
 const DEFAULT_MAX_ENTRIES = 500;
 
 // 서버별 TTL (ms)
 const SERVER_TTL = Object.freeze({
-  'context7':     60 * 60 * 1000,   // 1시간 — 라이브러리 문서는 자주 안 바뀜
-  'brave-search': 10 * 60 * 1000,   // 10분 — 웹 검색
-  'exa':          10 * 60 * 1000,   // 10분
-  'tavily':       10 * 60 * 1000,   // 10분
-  'serena':       5 * 60 * 1000,    // 5분 — 코드 분석 (코드 변경 가능)
-  'jira':         2 * 60 * 1000,    // 2분 — 이슈 상태 자주 변경
-  'notion':       5 * 60 * 1000,    // 5분
-  '_default':     5 * 60 * 1000,    // 기본 5분
+  context7: 60 * 60 * 1000, // 1시간 — 라이브러리 문서는 자주 안 바뀜
+  "brave-search": 10 * 60 * 1000, // 10분 — 웹 검색
+  exa: 10 * 60 * 1000, // 10분
+  tavily: 10 * 60 * 1000, // 10분
+  serena: 5 * 60 * 1000, // 5분 — 코드 분석 (코드 변경 가능)
+  jira: 2 * 60 * 1000, // 2분 — 이슈 상태 자주 변경
+  notion: 5 * 60 * 1000, // 5분
+  _default: 5 * 60 * 1000, // 기본 5분
 });
 
 function hashKey(server, method, params) {
   const payload = JSON.stringify({ server, method, params });
-  return createHash('sha256').update(payload).digest('hex').slice(0, 16);
+  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
 }
 
 /**
@@ -82,7 +89,7 @@ export function createMcpResponseCache(opts = {}) {
     const path = getCachePath(key);
     if (existsSync(path)) {
       try {
-        const entry = JSON.parse(readFileSync(path, 'utf8'));
+        const entry = JSON.parse(readFileSync(path, "utf8"));
         if (Date.now() - entry.ts < ttl) {
           hits++;
           hot.set(key, entry);
@@ -90,8 +97,14 @@ export function createMcpResponseCache(opts = {}) {
           return { hit: true, data: entry.data };
         }
         // expired — 삭제
-        try { unlinkSync(path); } catch { /* ignore */ }
-      } catch { /* corrupt file */ }
+        try {
+          unlinkSync(path);
+        } catch {
+          /* ignore */
+        }
+      } catch {
+        /* corrupt file */
+      }
     }
 
     misses++;
@@ -115,8 +128,10 @@ export function createMcpResponseCache(opts = {}) {
 
     // 파일
     try {
-      writeFileSync(getCachePath(key), JSON.stringify(entry), 'utf8');
-    } catch { /* best-effort */ }
+      writeFileSync(getCachePath(key), JSON.stringify(entry), "utf8");
+    } catch {
+      /* best-effort */
+    }
   }
 
   function evictIfNeeded() {
@@ -134,21 +149,28 @@ export function createMcpResponseCache(opts = {}) {
     let pruned = 0;
     try {
       for (const name of readdirSync(cacheDir)) {
-        if (!name.endsWith('.json')) continue;
+        if (!name.endsWith(".json")) continue;
         const path = join(cacheDir, name);
         try {
-          const entry = JSON.parse(readFileSync(path, 'utf8'));
-          const ttl = getTtl(entry.server || '_default');
+          const entry = JSON.parse(readFileSync(path, "utf8"));
+          const ttl = getTtl(entry.server || "_default");
           if (Date.now() - entry.ts >= ttl) {
             unlinkSync(path);
             pruned++;
           }
         } catch {
           // corrupt — 삭제
-          try { unlinkSync(path); pruned++; } catch { /* ignore */ }
+          try {
+            unlinkSync(path);
+            pruned++;
+          } catch {
+            /* ignore */
+          }
         }
       }
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
     return pruned;
   }
 
@@ -159,8 +181,12 @@ export function createMcpResponseCache(opts = {}) {
   function stats() {
     let diskFiles = 0;
     try {
-      diskFiles = readdirSync(cacheDir).filter((n) => n.endsWith('.json')).length;
-    } catch { /* ignore */ }
+      diskFiles = readdirSync(cacheDir).filter((n) =>
+        n.endsWith(".json"),
+      ).length;
+    } catch {
+      /* ignore */
+    }
 
     const total = hits + misses;
     return {
@@ -168,7 +194,7 @@ export function createMcpResponseCache(opts = {}) {
       misses,
       hotSize: hot.size,
       diskFiles,
-      hitRate: total > 0 ? `${((hits / total) * 100).toFixed(1)}%` : '0%',
+      hitRate: total > 0 ? `${((hits / total) * 100).toFixed(1)}%` : "0%",
     };
   }
 
@@ -177,11 +203,17 @@ export function createMcpResponseCache(opts = {}) {
     hot.clear();
     try {
       for (const name of readdirSync(cacheDir)) {
-        if (name.endsWith('.json')) {
-          try { unlinkSync(join(cacheDir, name)); } catch { /* ignore */ }
+        if (name.endsWith(".json")) {
+          try {
+            unlinkSync(join(cacheDir, name));
+          } catch {
+            /* ignore */
+          }
         }
       }
-    } catch { /* ignore */ }
+    } catch {
+      /* ignore */
+    }
     hits = 0;
     misses = 0;
   }
@@ -192,7 +224,9 @@ export function createMcpResponseCache(opts = {}) {
     prune,
     stats,
     clear,
-    get cacheDir() { return cacheDir; },
+    get cacheDir() {
+      return cacheDir;
+    },
   });
 }