@triflux/core 10.50.1 → 10.50.2

package/hub/intent.mjs

@@ -1,321 +0,0 @@
-// hub/intent.mjs — Intent Classification Engine
-// 사용자 요청의 "진짜 의도"를 분석 → 카테고리 분류 → 최적 에이전트/모델 자동 선택
-
-import { execFileSync } from "node:child_process";
-import crypto from "node:crypto";
-import { resolveCodexAgentPolicy } from "../scripts/lib/agent-route-policy.mjs";
-import { whichCommand } from "./platform.mjs";
-
-/** 캐시 엔트리: { category, confidence, ts } */
-const _intentCache = new Map();
-const CACHE_TTL_MS = 5 * 60 * 1000; // 5분
-
-/** codex 설치 여부 (프로세스당 1회 확인) */
-let _codexAvailable = null;
-
-/** @experimental 런타임 미연결 — 향후 통합 예정 */
-function _isCodexAvailable() {
-  if (_codexAvailable !== null) return _codexAvailable;
-  _codexAvailable = Boolean(whichCommand("codex"));
-  return _codexAvailable;
-}
-
-function _promptHash(prompt) {
-  return crypto.createHash("md5").update(prompt).digest("hex");
-}
-
-function _getCached(hash) {
-  const entry = _intentCache.get(hash);
-  if (!entry) return null;
-  if (Date.now() - entry.ts > CACHE_TTL_MS) {
-    _intentCache.delete(hash);
-    return null;
-  }
-  return entry;
-}
-
-function _tryCodexClassify(prompt) {
-  try {
-    const raw = execFileSync(
-      "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;
-    if (!intent || confidence === null) return null;
-    // intent가 알려진 카테고리여야 함
-    if (!INTENT_CATEGORIES[intent]) return null;
-    return { category: intent, confidence };
-  } catch {
-    return null;
-  }
-}
-
-/**
- * @experimental
- * triflux 특화 의도 카테고리 (10개)
- */
-export const INTENT_CATEGORIES = {
-  implement: { agent: "executor", mcp: "implement" },
-  debug: { agent: "debugger", mcp: "implement" },
-  analyze: { agent: "analyst", mcp: "analyze" },
-  design: { agent: "architect", mcp: "analyze" },
-  review: { agent: "code-reviewer", mcp: "review" },
-  document: { agent: "writer", mcp: "docs" },
-  research: { agent: "scientist", mcp: "analyze" },
-  "quick-fix": { agent: "build-fixer", mcp: "implement" },
-  explain: { agent: "writer", mcp: "docs" },
-  test: { agent: "test-engineer", mcp: null },
-};
-
-function routingFor(category) {
-  const route = INTENT_CATEGORIES[category] || INTENT_CATEGORIES.implement;
-  return {
-    agent: route.agent,
-    mcp: route.mcp,
-    effort: resolveCodexAgentPolicy(route.agent).profile,
-  };
-}
-
-/** @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,
-  },
-];
-
-/**
- * 키워드 기반 빠른 분류 (0-cost, Codex 호출 없이)
- * 고신뢰(>0.8) 시 Codex triage 건너뜀
- * @param {string} prompt - 사용자 프롬프트
- * @returns {{ category: string, confidence: number }}
- */
-export function quickClassify(prompt) {
-  if (!prompt || typeof prompt !== "string" || !prompt.trim()) {
-    return { category: "implement", confidence: 0.1 };
-  }
-
-  const lower = prompt.toLowerCase().trim();
-  let bestCategory = null;
-  let bestScore = 0;
-  let bestMatchCount = 0;
-
-  for (const { category, keywords, weight } of KEYWORD_PATTERNS) {
-    let matchCount = 0;
-    for (const kw of keywords) {
-      if (lower.includes(kw)) matchCount++;
-    }
-    if (matchCount > 0) {
-      const score = (matchCount / keywords.length) * weight;
-      if (score > bestScore) {
-        bestScore = score;
-        bestCategory = category;
-        bestMatchCount = matchCount;
-      }
-    }
-  }
-
-  if (!bestCategory) {
-    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,
-  );
-  return { category: bestCategory, confidence };
-}
-
-/**
- * 전체 의도 분류 — routing 정보 포함
- * Codex triage 경로: codex 설치 시 실행, confidence > 0.8이면 즉시 반환
- * quickClassify가 고신뢰(>0.8)이면 Codex 건너뜀
- * 결과는 md5 해시 기반 Map에 5분 TTL로 캐싱
- * @param {string} 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 cached = _getCached(hash);
-  if (cached) {
-    const routing = routingFor(cached.category);
-    return {
-      category: cached.category,
-      confidence: cached.confidence,
-      reasoning: `cache-hit: ${cached.category} (${cached.confidence.toFixed(2)})`,
-      routing,
-    };
-  }
-
-  // quickClassify 먼저
-  const quick = quickClassify(prompt);
-
-  let category = quick.category;
-  let confidence = quick.confidence;
-  let reasoning;
-
-  // quickClassify가 고신뢰(>0.8)이면 Codex 건너뜀
-  if (quick.confidence > 0.8) {
-    reasoning = `keyword-match: ${category} (${confidence.toFixed(2)})`;
-  } else if (_isCodexAvailable()) {
-    // Codex triage
-    const codexResult = _tryCodexClassify(String(prompt ?? ""));
-    if (codexResult && codexResult.confidence > 0.8) {
-      category = codexResult.category;
-      confidence = codexResult.confidence;
-      reasoning = `codex-triage: ${category} (${confidence.toFixed(2)})`;
-    } else {
-      reasoning = `keyword-match(codex-fallback): ${category} (${confidence.toFixed(2)})`;
-    }
-  } else {
-    reasoning = `keyword-match: ${category} (${confidence.toFixed(2)})`;
-  }
-
-  // 캐시 저장
-  _intentCache.set(hash, { category, confidence, ts: Date.now() });
-
-  const routing = routingFor(category);
-  return {
-    category,
-    confidence,
-    reasoning,
-    routing,
-  };
-}
-
-/**
- * 분류 히스토리 기반 학습 (reflexion 연동 가능)
- * @param {string} prompt
- * @param {string} actualCategory - 실제 카테고리
- */
-export function refineClassification(prompt, actualCategory) {
-  // reflexion 연동 시 store에 오분류 기록 저장 예정
-  void prompt;
-  void actualCategory;
-}

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

@@ -1,239 +0,0 @@
-// hub/lib/mcp-response-cache.mjs — MCP 응답 캐시 (LRU + TTL)
-// Deep 스킬에서 3개 모델이 같은 context7 문서를 요청하면 1번만 호출, 나머지는 캐시 hit.
-// 파일 기반 영속 + 메모리 기반 핫캐시 이중 구조.
-
-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분
-});
-
-function hashKey(server, method, params) {
-  const payload = JSON.stringify({ server, method, params });
-  return createHash("sha256").update(payload).digest("hex").slice(0, 16);
-}
-
-/**
- * MCP 응답 캐시 생성.
- * @param {object} [opts]
- * @param {string} [opts.cacheDir] — 캐시 디렉토리
- * @param {number} [opts.maxEntries] — 최대 엔트리 수 (LRU)
- * @returns {McpResponseCache}
- */
-export function createMcpResponseCache(opts = {}) {
-  const cacheDir = opts.cacheDir || DEFAULT_CACHE_DIR;
-  const maxEntries = opts.maxEntries || DEFAULT_MAX_ENTRIES;
-
-  mkdirSync(cacheDir, { recursive: true });
-
-  // 메모리 핫캐시 (Map — insertion order = LRU)
-  const hot = new Map();
-
-  let hits = 0;
-  let misses = 0;
-
-  function getTtl(server) {
-    return SERVER_TTL[server] || SERVER_TTL._default;
-  }
-
-  function getCachePath(key) {
-    return join(cacheDir, `${key}.json`);
-  }
-
-  /**
-   * 캐시 조회.
-   * @param {string} server — MCP 서버 이름
-   * @param {string} method — MCP 메서드
-   * @param {*} params — 요청 파라미터
-   * @returns {{ hit: boolean, data?: * }}
-   */
-  function get(server, method, params) {
-    const key = hashKey(server, method, params);
-    const ttl = getTtl(server);
-
-    // 1) 메모리 핫캐시
-    if (hot.has(key)) {
-      const entry = hot.get(key);
-      if (Date.now() - entry.ts < ttl) {
-        hits++;
-        // LRU: 삭제 후 재삽입 (Map은 insertion order)
-        hot.delete(key);
-        hot.set(key, entry);
-        return { hit: true, data: entry.data };
-      }
-      hot.delete(key);
-    }
-
-    // 2) 파일 캐시
-    const path = getCachePath(key);
-    if (existsSync(path)) {
-      try {
-        const entry = JSON.parse(readFileSync(path, "utf8"));
-        if (Date.now() - entry.ts < ttl) {
-          hits++;
-          hot.set(key, entry);
-          evictIfNeeded();
-          return { hit: true, data: entry.data };
-        }
-        // expired — 삭제
-        try {
-          unlinkSync(path);
-        } catch {
-          /* ignore */
-        }
-      } catch {
-        /* corrupt file */
-      }
-    }
-
-    misses++;
-    return { hit: false };
-  }
-
-  /**
-   * 캐시 저장.
-   * @param {string} server
-   * @param {string} method
-   * @param {*} params
-   * @param {*} data — 응답 데이터
-   */
-  function set(server, method, params, data) {
-    const key = hashKey(server, method, params);
-    const entry = { ts: Date.now(), server, method, data };
-
-    // 메모리
-    hot.set(key, entry);
-    evictIfNeeded();
-
-    // 파일
-    try {
-      writeFileSync(getCachePath(key), JSON.stringify(entry), "utf8");
-    } catch {
-      /* best-effort */
-    }
-  }
-
-  function evictIfNeeded() {
-    while (hot.size > maxEntries) {
-      const oldest = hot.keys().next().value;
-      hot.delete(oldest);
-    }
-  }
-
-  /**
-   * 만료된 파일 캐시 정리.
-   * @returns {number} 삭제된 파일 수
-   */
-  function prune() {
-    let pruned = 0;
-    try {
-      for (const name of readdirSync(cacheDir)) {
-        if (!name.endsWith(".json")) continue;
-        const path = join(cacheDir, name);
-        try {
-          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 */
-          }
-        }
-      }
-    } catch {
-      /* ignore */
-    }
-    return pruned;
-  }
-
-  /**
-   * 캐시 통계.
-   * @returns {{ hits, misses, hotSize, diskFiles, hitRate }}
-   */
-  function stats() {
-    let diskFiles = 0;
-    try {
-      diskFiles = readdirSync(cacheDir).filter((n) =>
-        n.endsWith(".json"),
-      ).length;
-    } catch {
-      /* ignore */
-    }
-
-    const total = hits + misses;
-    return {
-      hits,
-      misses,
-      hotSize: hot.size,
-      diskFiles,
-      hitRate: total > 0 ? `${((hits / total) * 100).toFixed(1)}%` : "0%",
-    };
-  }
-
-  /** 전체 캐시 초기화. */
-  function clear() {
-    hot.clear();
-    try {
-      for (const name of readdirSync(cacheDir)) {
-        if (name.endsWith(".json")) {
-          try {
-            unlinkSync(join(cacheDir, name));
-          } catch {
-            /* ignore */
-          }
-        }
-      }
-    } catch {
-      /* ignore */
-    }
-    hits = 0;
-    misses = 0;
-  }
-
-  return Object.freeze({
-    get,
-    set,
-    prune,
-    stats,
-    clear,
-    get cacheDir() {
-      return cacheDir;
-    },
-  });
-}
-
-// 싱글톤 인스턴스 (Hub 프로세스 내에서 공유)
-let _instance = null;
-
-export function getMcpResponseCache(opts) {
-  if (!_instance) _instance = createMcpResponseCache(opts);
-  return _instance;
-}