@triflux/core 10.0.3 → 10.25.1

package/hub/routing/complexity.mjs

@@ -10,42 +10,126 @@ const COMPLEXITY_INDICATORS = {
   // 높은 복잡도 (0.7-1.0)
   high: {
     keywords: [
-      'refactor', 'architecture', 'security', 'migration', 'distributed',
-      'concurrent', 'parallel', 'optimization', 'performance', 'scalability',
-      'cryptograph', 'encryption', 'authentication', 'authorization',
-      'database schema', 'data model', 'state machine', 'event-driven',
-      'microservice', 'orchestrat', 'pipeline', 'workflow',
+      "refactor",
+      "architecture",
+      "security",
+      "migration",
+      "distributed",
+      "concurrent",
+      "parallel",
+      "optimization",
+      "performance",
+      "scalability",
+      "cryptograph",
+      "encryption",
+      "authentication",
+      "authorization",
+      "database schema",
+      "data model",
+      "state machine",
+      "event-driven",
+      "microservice",
+      "orchestrat",
+      "pipeline",
+      "workflow",
       // 한국어
-      '리팩터링', '리팩토링', '아키텍처', '보안', '마이그레이션', '분산',
-      '동시성', '병렬', '최적화', '성능', '확장성',
-      '암호화', '인증', '인가', '데이터베이스 스키마', '데이터 모델',
-      '상태 머신', '이벤트 드리븐', '마이크로서비스', '오케스트레이션',
+      "리팩터링",
+      "리팩토링",
+      "아키텍처",
+      "보안",
+      "마이그레이션",
+      "분산",
+      "동시성",
+      "병렬",
+      "최적화",
+      "성능",
+      "확장성",
+      "암호화",
+      "인증",
+      "인가",
+      "데이터베이스 스키마",
+      "데이터 모델",
+      "상태 머신",
+      "이벤트 드리븐",
+      "마이크로서비스",
+      "오케스트레이션",
     ],
     weight: 0.85,
   },
   // 중간 복잡도 (0.4-0.7)
   medium: {
     keywords: [
-      'implement', 'integrate', 'api', 'endpoint', 'middleware',
-      'validation', 'error handling', 'testing', 'debug', 'fix bug',
-      'configuration', 'deploy', 'ci/cd', 'docker', 'container',
-      'cache', 'queue', 'webhook', 'notification', 'logging',
+      "implement",
+      "integrate",
+      "api",
+      "endpoint",
+      "middleware",
+      "validation",
+      "error handling",
+      "testing",
+      "debug",
+      "fix bug",
+      "configuration",
+      "deploy",
+      "ci/cd",
+      "docker",
+      "container",
+      "cache",
+      "queue",
+      "webhook",
+      "notification",
+      "logging",
       // 한국어
-      '구현', '통합', '엔드포인트', '미들웨어', '유효성 검사',
-      '에러 처리', '오류 처리', '테스트', '디버깅', '버그 수정',
-      '설정', '배포', '컨테이너', '캐시', '알림', '로깅',
+      "구현",
+      "통합",
+      "엔드포인트",
+      "미들웨어",
+      "유효성 검사",
+      "에러 처리",
+      "오류 처리",
+      "테스트",
+      "디버깅",
+      "버그 수정",
+      "설정",
+      "배포",
+      "컨테이너",
+      "캐시",
+      "알림",
+      "로깅",
     ],
     weight: 0.55,
   },
   // 낮은 복잡도 (0.1-0.4)
   low: {
     keywords: [
-      'readme', 'comment', 'typo', 'rename', 'format', 'lint',
-      'update version', 'bump', 'add dependency', 'install',
-      'simple', 'trivial', 'minor', 'small change', 'one-liner',
+      "readme",
+      "comment",
+      "typo",
+      "rename",
+      "format",
+      "lint",
+      "update version",
+      "bump",
+      "add dependency",
+      "install",
+      "simple",
+      "trivial",
+      "minor",
+      "small change",
+      "one-liner",
       // 한국어
-      '문서화', '주석', '오타', '이름 변경', '포맷', '버전 업데이트',
-      '의존성 추가', '설치', '간단', '사소한', '소규모', '한 줄',
+      "문서화",
+      "주석",
+      "오타",
+      "이름 변경",
+      "포맷",
+      "버전 업데이트",
+      "의존성 추가",
+      "설치",
+      "간단",
+      "사소한",
+      "소규모",
+      "한 줄",
     ],
     weight: 0.2,
   },
@@ -98,7 +182,7 @@ function semanticDepth(text) {
  * @returns {number} 0-1
  */
 function taskScope(text) {
-  const lines = text.split('\n').filter((l) => l.trim().length > 0);
+  const lines = text.split("\n").filter((l) => l.trim().length > 0);
   const sentences = text.split(/[.!?]+/).filter((s) => s.trim().length > 0);
   const fileRefs = (text.match(/[\w\-/]+\.\w{1,5}/g) || []).length;
 
@@ -118,9 +202,22 @@ function taskScope(text) {
 function uncertainty(text) {
   const lower = text.toLowerCase();
   const uncertainWords = [
-    'maybe', 'perhaps', 'might', 'could', 'possibly', 'unclear',
-    'not sure', 'investigate', 'explore', 'research', 'try',
-    'consider', 'evaluate', 'assess', 'determine', 'figure out',
+    "maybe",
+    "perhaps",
+    "might",
+    "could",
+    "possibly",
+    "unclear",
+    "not sure",
+    "investigate",
+    "explore",
+    "research",
+    "try",
+    "consider",
+    "evaluate",
+    "assess",
+    "determine",
+    "figure out",
   ];
   let count = 0;
   for (const w of uncertainWords) {
@@ -138,11 +235,17 @@ function uncertainty(text) {
  * @returns {{ score: number, breakdown: { lexical: number, semantic: number, scope: number, uncertainty: number } }}
  */
 export function scoreComplexity(taskDescription) {
-  if (!taskDescription || typeof taskDescription !== 'string') {
-    return { score: 0, breakdown: { lexical: 0, semantic: 0, scope: 0, uncertainty: 0 } };
+  if (!taskDescription || typeof taskDescription !== "string") {
+    return {
+      score: 0,
+      breakdown: { lexical: 0, semantic: 0, scope: 0, uncertainty: 0 },
+    };
   }
 
-  const words = taskDescription.toLowerCase().split(/\s+/).filter((w) => w.length > 0);
+  const words = taskDescription
+    .toLowerCase()
+    .split(/\s+/)
+    .filter((w) => w.length > 0);
   const lexical = lexicalComplexity(words);
   const semantic = semanticDepth(taskDescription);
   const scope = taskScope(taskDescription);
@@ -150,7 +253,7 @@ export function scoreComplexity(taskDescription) {
 
   // 가중 합산: 어휘(20%) + 시맨틱(35%) + 범위(25%) + 불확실성(20%)
   const score = Math.min(
-    lexical * 0.20 + semantic * 0.35 + scope * 0.25 + uncertain * 0.20,
+    lexical * 0.2 + semantic * 0.35 + scope * 0.25 + uncertain * 0.2,
     1,
   );
 

package/hub/routing/index.mjs

@@ -2,16 +2,16 @@
 // Q-Learning 동적 라우팅 + agent-map.json 정적 폴백
 // 환경변수 TRIFLUX_DYNAMIC_ROUTING=true 로 옵트인 (기본 false)
 
-import { createRequire } from 'node:module';
-import { QLearningRouter } from './q-learning.mjs';
-import { scoreComplexity } from './complexity.mjs';
+import { createRequire } from "node:module";
+import { scoreComplexity } from "./complexity.mjs";
+import { QLearningRouter } from "./q-learning.mjs";
 
 const _require = createRequire(import.meta.url);
 
 /** agent-map.json 정적 매핑 */
 let AGENT_MAP;
 try {
-  AGENT_MAP = _require('../team/agent-map.json');
+  AGENT_MAP = _require("../team/agent-map.json");
 } catch {
   AGENT_MAP = {};
 }
@@ -37,7 +37,7 @@ function getRouter() {
  */
 function isDynamicRoutingEnabled() {
   const env = process.env.TRIFLUX_DYNAMIC_ROUTING;
-  return env === 'true' || env === '1';
+  return env === "true" || env === "1";
 }
 
 /**
@@ -48,19 +48,19 @@ function isDynamicRoutingEnabled() {
  * @param {string} [taskDescription=''] — 작업 설명 (동적 라우팅용)
  * @returns {{ cliType: string, source: 'dynamic' | 'static', confidence: number, complexity: number }}
  */
-export function resolveRoute(agentType, taskDescription = '') {
+export function resolveRoute(agentType, taskDescription = "") {
   // 정적 기본값
   const staticCli = AGENT_MAP[agentType] || agentType;
   const { score: complexity } = scoreComplexity(taskDescription);
 
   // 동적 라우팅 비활성화 시 정적 매핑 반환
   if (!isDynamicRoutingEnabled()) {
-    return { cliType: staticCli, source: 'static', confidence: 1, complexity };
+    return { cliType: staticCli, source: "static", confidence: 1, complexity };
   }
 
   // 작업 설명 없으면 정적 폴백
   if (!taskDescription || taskDescription.trim().length === 0) {
-    return { cliType: staticCli, source: 'static', confidence: 1, complexity };
+    return { cliType: staticCli, source: "static", confidence: 1, complexity };
   }
 
   const router = getRouter();
@@ -68,12 +68,17 @@ export function resolveRoute(agentType, taskDescription = '') {
 
   // 신뢰도 기준 미달 시 정적 폴백
   if (prediction.confidence < 0.6) {
-    return { cliType: staticCli, source: 'static', confidence: prediction.confidence, complexity };
+    return {
+      cliType: staticCli,
+      source: "static",
+      confidence: prediction.confidence,
+      complexity,
+    };
   }
 
   return {
     cliType: prediction.action,
-    source: 'dynamic',
+    source: "dynamic",
     confidence: prediction.confidence,
     complexity,
   };
@@ -113,5 +118,5 @@ export function routerStatus() {
 }
 
 // re-export for convenience
-export { scoreComplexity } from './complexity.mjs';
-export { QLearningRouter, ACTIONS } from './q-learning.mjs';
+export { scoreComplexity } from "./complexity.mjs";
+export { ACTIONS, QLearningRouter } from "./q-learning.mjs";

package/hub/routing/q-learning.mjs

@@ -2,44 +2,84 @@
 // agent-map.json 폴백을 유지하면서, 작업 결과 피드백으로 가중치를 학습한다.
 // 외부 의존성 없음 (fs, path, crypto만 사용)
 
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { join } from 'node:path';
-import { createHash } from 'node:crypto';
-import { createRequire } from 'node:module';
-import { homedir } from 'node:os';
-import { scoreComplexity } from './complexity.mjs';
+import { createHash } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { scoreComplexity } from "./complexity.mjs";
 
 const _require = createRequire(import.meta.url);
 
 /** agent-map.json 정적 매핑 (폴백용) */
 let AGENT_MAP;
 try {
-  AGENT_MAP = _require('../team/agent-map.json');
+  AGENT_MAP = _require("../team/agent-map.json");
 } catch {
   AGENT_MAP = {};
 }
 
 /** 사용 가능한 CLI 액션 */
-const ACTIONS = ['codex', 'gemini', 'claude', 'haiku', 'sonnet'];
+const ACTIONS = ["codex", "gemini", "claude", "haiku", "sonnet"];
 
 /** 특성 벡터 키워드 (48차원, 에이전트 타입 기반) */
 const FEATURE_KEYWORDS = [
   // 실행/구현 (codex 친화)
-  'implement', 'execute', 'build', 'fix', 'debug', 'code', 'refactor', 'test',
+  "implement",
+  "execute",
+  "build",
+  "fix",
+  "debug",
+  "code",
+  "refactor",
+  "test",
   // 분석/설계 (claude/sonnet 친화)
-  'analyze', 'architect', 'plan', 'review', 'security', 'optimize', 'research', 'evaluate',
+  "analyze",
+  "architect",
+  "plan",
+  "review",
+  "security",
+  "optimize",
+  "research",
+  "evaluate",
   // 디자인/문서 (gemini 친화)
-  'design', 'ui', 'ux', 'frontend', 'visual', 'document', 'write', 'explain',
+  "design",
+  "ui",
+  "ux",
+  "frontend",
+  "visual",
+  "document",
+  "write",
+  "explain",
   // 간단/빠른 (haiku 친화)
-  'simple', 'quick', 'trivial', 'rename', 'format', 'lint', 'typo', 'minor',
+  "simple",
+  "quick",
+  "trivial",
+  "rename",
+  "format",
+  "lint",
+  "typo",
+  "minor",
   // 한국어 — 실행/구현 (codex 친화)
-  '구현', '빌드', '수정', '디버깅', '리팩터링', '테스트',
+  "구현",
+  "빌드",
+  "수정",
+  "디버깅",
+  "리팩터링",
+  "테스트",
   // 한국어 — 분석/설계 (claude/sonnet 친화)
-  '분석', '아키텍처', '설계', '검토', '보안', '최적화',
+  "분석",
+  "아키텍처",
+  "설계",
+  "검토",
+  "보안",
+  "최적화",
   // 한국어 — 디자인/문서 (gemini 친화)
-  '디자인', '문서화',
+  "디자인",
+  "문서화",
   // 한국어 — 간단/빠른 (haiku 친화)
-  '간단', '사소한',
+  "간단",
+  "사소한",
 ];
 
 /**
@@ -66,7 +106,7 @@ function extractFeatures(text) {
  * @returns {string}
  */
 function stateKey(features) {
-  const hash = createHash('sha256').update(features.join(',')).digest('hex');
+  const hash = createHash("sha256").update(features.join(",")).digest("hex");
   return hash.slice(0, 16);
 }
 
@@ -131,9 +171,11 @@ export class QLearningRouter {
     this._epsilon = opts.epsilon ?? 0.3;
     this._epsilonDecay = opts.epsilonDecay ?? 0.995;
     // epsilon=0 시에도 최소 탐색 보장 (pure-exploit 방지)
-    this._epsilonMin = opts.epsilonMin ?? Math.max(0.01, Math.min(0.05, this._epsilon));
+    this._epsilonMin =
+      opts.epsilonMin ?? Math.max(0.01, Math.min(0.05, this._epsilon));
     this._minConfidence = opts.minConfidence ?? 0.6;
-    this._modelPath = opts.modelPath ?? join(homedir(), '.omc', 'routing-model.json');
+    this._modelPath =
+      opts.modelPath ?? join(homedir(), ".omc", "routing-model.json");
 
     /** @type {Map<string, Map<string, number>>} state -> (action -> Q-value) */
     this._qTable = new Map();
@@ -200,13 +242,16 @@ export class QLearningRouter {
     }
 
     // 신뢰도 계산: 방문 횟수 기반 (최소 10회 이상이면 안정)
-    const confidence = visits >= 10
-      ? Math.min(visits / 50, 1)
-      : visits / 10;
+    const confidence = visits >= 10 ? Math.min(visits / 50, 1) : visits / 10;
 
     const { score: complexity } = scoreComplexity(taskDescription);
 
-    const result = { action, confidence, exploration: isExploration, complexity };
+    const result = {
+      action,
+      confidence,
+      exploration: isExploration,
+      complexity,
+    };
     // 탐색(랜덤) 결과는 캐싱하지 않음 — 매번 새로운 랜덤 액션 생성
     if (!isExploration) this._cache.set(state, result);
     return result;
@@ -241,7 +286,10 @@ export class QLearningRouter {
     this._totalUpdates++;
 
     // 엡실론 감쇠
-    this._epsilon = Math.max(this._epsilonMin, this._epsilon * this._epsilonDecay);
+    this._epsilon = Math.max(
+      this._epsilonMin,
+      this._epsilon * this._epsilonDecay,
+    );
 
     // 캐시 무효화 (해당 상태)
     this._cache.clear();
@@ -251,7 +299,7 @@ export class QLearningRouter {
    * Q-table을 JSON 파일로 영속화
    */
   save() {
-    const dir = join(this._modelPath, '..');
+    const dir = join(this._modelPath, "..");
     if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 
     const data = {
@@ -269,7 +317,7 @@ export class QLearningRouter {
       data.visitCounts[state] = count;
     }
 
-    writeFileSync(this._modelPath, JSON.stringify(data, null, 2), 'utf8');
+    writeFileSync(this._modelPath, JSON.stringify(data, null, 2), "utf8");
   }
 
   /**
@@ -280,7 +328,7 @@ export class QLearningRouter {
     if (!existsSync(this._modelPath)) return false;
 
     try {
-      const raw = readFileSync(this._modelPath, 'utf8');
+      const raw = readFileSync(this._modelPath, "utf8");
       const data = JSON.parse(raw);
       if (data.version !== 1) return false;
 
@@ -333,4 +381,4 @@ export class QLearningRouter {
 }
 
 // 모듈 레벨 export
-export { ACTIONS, FEATURE_KEYWORDS, extractFeatures, stateKey, LRUCache };
+export { ACTIONS, extractFeatures, FEATURE_KEYWORDS, LRUCache, stateKey };