@triflux/core 10.0.3 → 10.25.1

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();
@@ -12,14 +12,15 @@ 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'));
+  _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) {
@@ -35,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;
@@ -54,32 +56,154 @@ function _tryCodexClassify(prompt) {
   }
 }
 
-/** triflux 특화 의도 카테고리 (10개) */
+/**
+ * @experimental
+ * 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 },
+  // 모델 정책 (2026-04-25):
+  // - gpt-5.5 = 메인 (코드 포함 모든 메인 직무, fast tier 가능)
+  // - gpt-5.4-mini = 자잘/부가/가성비 (fast tier 가능)
+  // - gpt-5.3-codex = escalation 가성비 중간 (fast 미지원)
+  // - gpt-5.4 폐기, gpt-5.5 로 격상
+  implement: { agent: "executor", mcp: "implement", effort: "gpt55_high" },
+  debug: { agent: "debugger", mcp: "implement", effort: "gpt55_xhigh" },
+  analyze: { agent: "analyst", mcp: "analyze", effort: "gpt55_xhigh" },
+  design: { agent: "architect", mcp: "analyze", effort: "gpt55_xhigh" },
+  review: { agent: "code-reviewer", mcp: "review", effort: "gpt55_high" },
+  document: { agent: "writer", mcp: "docs", effort: "pro" },
+  research: { agent: "scientist", mcp: "analyze", effort: "gpt55_high" },
+  "quick-fix": {
+    agent: "build-fixer",
+    mcp: "implement",
+    effort: "gpt55_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,
+  },
 ];
 
 /**
@@ -89,8 +213,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();
@@ -114,11 +238,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 };
 }
 
@@ -131,17 +258,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,
+      },
     };
   }
 
@@ -157,7 +289,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/bash-path.mjs

@@ -0,0 +1,73 @@
+import { existsSync } from "node:fs";
+
+const GIT_BASH_PATHS = Object.freeze([
+  "C:/Program Files/Git/bin/bash.exe",
+  "C:/Program Files/Git/usr/bin/bash.exe",
+  "C:/Program Files (x86)/Git/bin/bash.exe",
+  "C:/Program Files (x86)/Git/usr/bin/bash.exe",
+]);
+
+/**
+ * Resolve a concrete Git Bash executable on Windows.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.platform=process.platform]
+ * @param {(path: string) => boolean} [opts.exists=existsSync]
+ * @returns {string | null}
+ */
+export function resolveGitBashExecutable(opts = {}) {
+  const { platform = process.platform, exists = existsSync } = opts;
+
+  if (platform !== "win32") {
+    return null;
+  }
+
+  return GIT_BASH_PATHS.find((candidate) => exists(candidate)) || null;
+}
+
+/**
+ * Resolve a Windows-safe bash executable.
+ * On Windows we prefer Git Bash over bare `bash`, which may resolve to WSL.
+ *
+ * @param {object} [opts]
+ * @param {string} [opts.platform=process.platform]
+ * @param {(path: string) => boolean} [opts.exists=existsSync]
+ * @returns {string}
+ */
+export function resolveBashExecutable(opts = {}) {
+  return resolveGitBashExecutable(opts) || "bash";
+}
+
+function shellQuote(command) {
+  return `'${String(command).replace(/'/g, `'"'"'`)}'`;
+}
+
+/**
+ * Wrap .sh script command strings so Windows always runs them through Bash.
+ * This prevents shell:true child launches from treating a script path like an
+ * openable file association instead of an executable script.
+ *
+ * @param {string} command
+ * @param {object} [opts]
+ * @param {string} [opts.bashCommand]
+ * @returns {string}
+ */
+export function ensureBashScriptExecution(command, opts = {}) {
+  const text = String(command || "").trim();
+  if (!text) return text;
+
+  if (!/\.sh(?:\s|$)/iu.test(text)) {
+    return text;
+  }
+
+  if (
+    /^(?:\s*[A-Za-z_][A-Za-z0-9_]*=(?:"[^"]*"|'[^']*'|\S+)\s+)*(?:bash(?:\.exe)?|sh)\b/iu.test(
+      text,
+    )
+  ) {
+    return text;
+  }
+
+  const bashCommand = opts.bashCommand || resolveBashExecutable();
+  return `${bashCommand} -lc ${shellQuote(text)}`;
+}

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/env-detect.mjs

@@ -0,0 +1,145 @@
+// hub/lib/env-detect.mjs — 쉘/터미널/멀티플렉서 환경 감지
+import { execFileSync } from "node:child_process";
+import { platform as osPlatform } from "node:os";
+
+let _cached = null;
+let _shellCache = null;
+let _terminalCache = null;
+let _multiplexerCache = null;
+
+const PIPE_OPTS = { encoding: "utf8", timeout: 3000, stdio: "pipe" };
+
+/**
+ * 기본 쉘 감지
+ * Windows: pwsh → powershell (full path + version)
+ * Unix: $SHELL → /bin/sh (+ version)
+ */
+export function detectShell() {
+  if (_shellCache) return _shellCache;
+
+  const platform = osPlatform();
+
+  if (platform === "win32") {
+    try {
+      const path = execFileSync("where", ["pwsh.exe"], PIPE_OPTS)
+        .trim()
+        .split(/\r?\n/)[0];
+      let version = null;
+      try {
+        version = execFileSync(
+          path,
+          [
+            "-NoLogo",
+            "-NoProfile",
+            "-Command",
+            "$PSVersionTable.PSVersion.ToString()",
+          ],
+          PIPE_OPTS,
+        ).trim();
+      } catch {}
+      _shellCache = { name: "pwsh", path, version };
+    } catch {
+      try {
+        const path = execFileSync("where", ["powershell.exe"], PIPE_OPTS)
+          .trim()
+          .split(/\r?\n/)[0];
+        _shellCache = { name: "powershell", path, version: null };
+      } catch {
+        _shellCache = {
+          name: "powershell",
+          path: "",
+          version: null,
+          installHint: "pwsh: winget install Microsoft.PowerShell",
+        };
+      }
+    }
+    return _shellCache;
+  }
+
+  const shellPath = process.env.SHELL || "/bin/sh";
+  const name = shellPath.split("/").pop() || "sh";
+  let version = null;
+  try {
+    version = execFileSync(shellPath, ["--version"], PIPE_OPTS).trim();
+  } catch {}
+  _shellCache = { name, path: shellPath, version };
+  return _shellCache;
+}
+
+/**
+ * 터미널 에뮬레이터 감지
+ */
+export function detectTerminal() {
+  if (_terminalCache) return _terminalCache;
+
+  const platform = osPlatform();
+  if (platform === "win32") {
+    try {
+      execFileSync("where", ["wt.exe"], PIPE_OPTS);
+      _terminalCache = { name: "windows-terminal", hasWt: true };
+    } catch {
+      _terminalCache = {
+        name: "unknown",
+        hasWt: false,
+        installHint: "wt: winget install Microsoft.WindowsTerminal",
+      };
+    }
+    return _terminalCache;
+  }
+
+  if (process.env.TERM_PROGRAM === "WarpTerminal") {
+    _terminalCache = { name: "warp", hasWt: false };
+  } else if (process.env.TERM_PROGRAM === "Alacritty") {
+    _terminalCache = { name: "alacritty", hasWt: false };
+  } else if (process.env.KITTY_WINDOW_ID) {
+    _terminalCache = { name: "kitty", hasWt: false };
+  } else if (process.env.TERM_PROGRAM === "iTerm.app") {
+    _terminalCache = { name: "iterm2", hasWt: false };
+  } else if (process.env.TERM_PROGRAM === "Apple_Terminal") {
+    _terminalCache = { name: "terminal-app", hasWt: false };
+  } else {
+    _terminalCache = { name: "unknown", hasWt: false };
+  }
+  return _terminalCache;
+}
+
+/**
+ * 멀티플렉서 감지 (tmux)
+ */
+export function detectMultiplexer() {
+  if (_multiplexerCache) return _multiplexerCache;
+
+  try {
+    const cmd = osPlatform() === "win32" ? "where" : "which";
+    const path = execFileSync(cmd, ["tmux"], PIPE_OPTS).trim();
+    _multiplexerCache = { name: "tmux", path };
+  } catch {
+    const hint =
+      osPlatform() === "win32"
+        ? "tmux: install tmux in WSL or MSYS2"
+        : undefined;
+    _multiplexerCache = {
+      name: "none",
+      path: null,
+      ...(hint ? { installHint: hint } : {}),
+    };
+  }
+  return _multiplexerCache;
+}
+
+/**
+ * 통합 환경 정보 조회 (레이지 싱글톤 캐시)
+ * @returns {{ shell: object, terminal: object, multiplexer: object, platform: string }}
+ */
+export function getEnvironment() {
+  if (_cached) return _cached;
+
+  _cached = Object.freeze({
+    shell: detectShell(),
+    terminal: detectTerminal(),
+    multiplexer: detectMultiplexer(),
+    platform: osPlatform(),
+  });
+
+  return _cached;
+}