triflux 3.2.0-dev.1 → 3.2.0-dev.10

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "triflux",
-  "version": "3.2.0-dev.1",
+  "version": "3.2.0-dev.10",
   "description": "CLI-first multi-model orchestrator for Claude Code — route tasks to Codex, Gemini, and Claude",
   "type": "module",
   "bin": {
@@ -26,7 +26,11 @@
   ],
   "scripts": {
     "setup": "node scripts/setup.mjs",
-    "postinstall": "node scripts/setup.mjs"
+    "postinstall": "node scripts/setup.mjs",
+    "test": "node --test tests/**/*.test.mjs",
+    "test:unit": "node --test tests/unit/**/*.test.mjs",
+    "test:integration": "node --test tests/integration/**/*.test.mjs",
+    "test:route-smoke": "node --test scripts/test-tfx-route-no-claude-native.mjs"
   },
   "engines": {
     "node": ">=18.0.0"

package/scripts/__tests__/keyword-detector.test.mjs

@@ -0,0 +1,234 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { compileRules, loadRules, matchRules, resolveConflicts } from "../lib/keyword-rules.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const projectRoot = resolve(__dirname, "..", "..");
+const rulesPath = join(projectRoot, "hooks", "keyword-rules.json");
+const detectorScriptPath = join(projectRoot, "scripts", "keyword-detector.mjs");
+
+// keyword-detector는 import 시 main()이 실행되므로, 테스트 로딩 단계에서만 안전하게 비활성화한다.
+const previousDisable = process.env.TRIFLUX_DISABLE_MAGICWORDS;
+const previousLog = console.log;
+process.env.TRIFLUX_DISABLE_MAGICWORDS = "1";
+console.log = () => {};
+const detectorModule = await import("../keyword-detector.mjs");
+console.log = previousLog;
+if (previousDisable === undefined) {
+  delete process.env.TRIFLUX_DISABLE_MAGICWORDS;
+} else {
+  process.env.TRIFLUX_DISABLE_MAGICWORDS = previousDisable;
+}
+
+const { extractPrompt, sanitizeForKeywordDetection } = detectorModule;
+
+function loadCompiledRules() {
+  const rules = loadRules(rulesPath);
+  assert.equal(rules.length, 19);
+  return compileRules(rules);
+}
+
+function runDetector(prompt) {
+  const payload = { prompt, cwd: projectRoot };
+  const result = spawnSync(process.execPath, [detectorScriptPath], {
+    input: JSON.stringify(payload),
+    encoding: "utf8"
+  });
+
+  assert.equal(result.status, 0, result.stderr);
+  assert.ok(result.stdout.trim(), "keyword-detector 출력이 비어 있습니다.");
+  return JSON.parse(result.stdout.trim());
+}
+
+test("extractPrompt: prompt/message.content/parts[].text 우선순위", () => {
+  assert.equal(
+    extractPrompt({
+      prompt: "from prompt",
+      message: { content: "from message" },
+      parts: [{ text: "from parts" }]
+    }),
+    "from prompt"
+  );
+
+  assert.equal(
+    extractPrompt({
+      prompt: "   ",
+      message: { content: "from message" },
+      parts: [{ text: "from parts" }]
+    }),
+    "from message"
+  );
+
+  assert.equal(
+    extractPrompt({
+      message: { content: [{ text: "from message-part" }] },
+      parts: [{ text: "from parts" }]
+    }),
+    "from message-part"
+  );
+
+  assert.equal(extractPrompt({ parts: [{ text: "from parts" }] }), "from parts");
+});
+
+test("sanitizeForKeywordDetection: 코드블록/URL/파일경로/XML 태그 제거", () => {
+  const input = [
+    "정상 문장",
+    "```sh",
+    "tfx multi",
+    "```",
+    "https://example.com/path?q=1",
+    "C:\\Users\\SSAFY\\Desktop\\Projects\\tools\\triflux",
+    "./hooks/keyword-rules.json",
+    "<tag>jira 이슈 생성</tag>"
+  ].join("\n");
+
+  const sanitized = sanitizeForKeywordDetection(input);
+
+  assert.ok(sanitized.includes("정상 문장"));
+  assert.ok(!sanitized.includes("tfx multi"));
+  assert.ok(!sanitized.includes("https://"));
+  assert.ok(!sanitized.includes("C:\\Users\\"));
+  assert.ok(!sanitized.includes("./hooks/keyword-rules.json"));
+  assert.ok(!sanitized.includes("<tag>"));
+  assert.ok(!sanitized.includes("jira 이슈 생성"));
+});
+
+test("loadRules: 유효한 JSON 로드", () => {
+  const rules = loadRules(rulesPath);
+  assert.equal(rules.length, 19);
+  assert.equal(rules.filter((rule) => rule.skill).length, 9);
+  assert.equal(rules.filter((rule) => rule.mcp_route).length, 10);
+});
+
+test("loadRules: 잘못된 파일 처리", () => {
+  const tempDir = mkdtempSync(join(tmpdir(), "triflux-rules-"));
+  const invalidPath = join(tempDir, "invalid.json");
+  writeFileSync(invalidPath, "{ invalid json", "utf8");
+
+  const malformed = loadRules(invalidPath);
+  const missing = loadRules(join(tempDir, "missing.json"));
+
+  assert.deepEqual(malformed, []);
+  assert.deepEqual(missing, []);
+
+  rmSync(tempDir, { recursive: true, force: true });
+});
+
+test("compileRules: 정규식 컴파일 성공", () => {
+  const rules = loadRules(rulesPath);
+  const compiled = compileRules(rules);
+  assert.equal(compiled.length, 19);
+  for (const rule of compiled) {
+    assert.ok(Array.isArray(rule.compiledPatterns));
+    assert.ok(rule.compiledPatterns.length > 0);
+    for (const pattern of rule.compiledPatterns) {
+      assert.ok(pattern instanceof RegExp);
+    }
+  }
+});
+
+test("compileRules: 정규식 컴파일 실패", () => {
+  const compiled = compileRules([
+    {
+      id: "bad-pattern",
+      priority: 1,
+      patterns: [{ source: "[", flags: "" }],
+      skill: "tfx-multi",
+      supersedes: [],
+      exclusive: false,
+      state: null,
+      mcp_route: null
+    }
+  ]);
+
+  assert.deepEqual(compiled, []);
+});
+
+test("matchRules: tfx 키워드 매칭", () => {
+  const compiledRules = loadCompiledRules();
+  const cases = [
+    { text: "tfx multi 세션 시작", expectedId: "tfx-multi" },
+    { text: "tfx auto 돌려줘", expectedId: "tfx-auto" },
+    { text: "tfx codex 로 실행", expectedId: "tfx-codex" },
+    { text: "tfx gemini 로 실행", expectedId: "tfx-gemini" },
+    { text: "canceltfx", expectedId: "tfx-cancel" }
+  ];
+
+  for (const { text, expectedId } of cases) {
+    const clean = sanitizeForKeywordDetection(text);
+    const matches = matchRules(compiledRules, clean);
+    assert.ok(matches.some((match) => match.id === expectedId), `${text} => ${expectedId} 미매칭`);
+  }
+});
+
+test("matchRules: MCP 라우팅 매칭", () => {
+  const compiledRules = loadCompiledRules();
+  const cases = [
+    { text: "노션 페이지 조회해줘", expectedId: "notion-route", expectedRoute: "gemini" },
+    { text: "jira 이슈 생성", expectedId: "jira-route", expectedRoute: "codex" },
+    { text: "크롬 열고 로그인", expectedId: "chrome-route", expectedRoute: "gemini" },
+    { text: "이메일 보내줘", expectedId: "mail-route", expectedRoute: "gemini" },
+    { text: "캘린더 일정 생성", expectedId: "calendar-route", expectedRoute: "gemini" },
+    { text: "playwright 테스트 작성", expectedId: "playwright-route", expectedRoute: "gemini" },
+    { text: "canva 디자인 생성", expectedId: "canva-route", expectedRoute: "gemini" }
+  ];
+
+  for (const { text, expectedId, expectedRoute } of cases) {
+    const matches = matchRules(compiledRules, sanitizeForKeywordDetection(text));
+    const matched = matches.find((match) => match.id === expectedId);
+    assert.ok(matched, `${text} => ${expectedId} 미매칭`);
+    assert.equal(matched.mcp_route, expectedRoute);
+  }
+});
+
+test("matchRules: 일반 대화는 매칭 없음", () => {
+  const compiledRules = loadCompiledRules();
+  const matches = matchRules(compiledRules, sanitizeForKeywordDetection("오늘 점심 메뉴 추천해줘"));
+  assert.deepEqual(matches, []);
+});
+
+test("resolveConflicts: priority 정렬 및 supersedes 처리", () => {
+  const resolved = resolveConflicts([
+    { id: "rule-c", priority: 3, supersedes: [], exclusive: false },
+    { id: "rule-b", priority: 2, supersedes: ["rule-c"], exclusive: false },
+    { id: "rule-a", priority: 1, supersedes: [], exclusive: false },
+    { id: "rule-a", priority: 1, supersedes: [], exclusive: false }
+  ]);
+
+  assert.deepEqual(
+    resolved.map((rule) => rule.id),
+    ["rule-a", "rule-b"]
+  );
+});
+
+test("resolveConflicts: exclusive 처리", () => {
+  const resolved = resolveConflicts([
+    { id: "normal", priority: 1, supersedes: [], exclusive: false },
+    { id: "exclusive", priority: 0, supersedes: [], exclusive: true },
+    { id: "later", priority: 2, supersedes: [], exclusive: false }
+  ]);
+
+  assert.deepEqual(resolved.map((rule) => rule.id), ["exclusive"]);
+});
+
+test("코드블록 내 키워드: sanitize 후 매칭 안 됨", () => {
+  const compiledRules = loadCompiledRules();
+  const input = ["```txt", "tfx multi", "jira 이슈 생성", "```"].join("\n");
+  const clean = sanitizeForKeywordDetection(input);
+  const matches = matchRules(compiledRules, clean);
+  assert.deepEqual(matches, []);
+});
+
+test("OMC 키워드와 triflux 키워드 비간섭 + TRIFLUX 네임스페이스", () => {
+  const omcLike = runDetector("my tfx multi 세션 보여줘");
+  assert.equal(omcLike.suppressOutput, true);
+
+  const triflux = runDetector("tfx multi 세션 시작");
+  const additionalContext = triflux?.hookSpecificOutput?.additionalContext || "";
+  assert.match(additionalContext, /^\[TRIFLUX MAGIC KEYWORD: tfx-multi\]/);
+});

package/scripts/hub-ensure.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+// SessionStart 훅에서 호출되는 Hub 보장 스크립트.
+// - /status 기반 헬스체크
+// - 비정상 시 Hub를 detached로 기동
+
+import { existsSync, readFileSync } from "fs";
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { spawn } from "child_process";
+import { fileURLToPath } from "url";
+
+const LOOPBACK_HOSTS = new Set(["127.0.0.1", "localhost", "::1"]);
+const PLUGIN_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const HUB_PID_FILE = join(homedir(), ".claude", "cache", "tfx-hub", "hub.pid");
+
+function formatHostForUrl(host) {
+  return host.includes(":") ? `[${host}]` : host;
+}
+
+function buildHubBaseUrl(host, port) {
+  return `http://${formatHostForUrl(host)}:${port}`;
+}
+
+function resolveHubTarget() {
+  const envPortRaw = Number(process.env.TFX_HUB_PORT || "");
+  const envPort = Number.isFinite(envPortRaw) && envPortRaw > 0 ? envPortRaw : null;
+  const target = {
+    host: "127.0.0.1",
+    port: envPort || 27888,
+  };
+
+  if (existsSync(HUB_PID_FILE)) {
+    try {
+      const info = JSON.parse(readFileSync(HUB_PID_FILE, "utf8"));
+      if (!envPort) {
+        const pidPort = Number(info?.port);
+        if (Number.isFinite(pidPort) && pidPort > 0) target.port = pidPort;
+      }
+      if (typeof info?.host === "string") {
+        const host = info.host.trim();
+        if (LOOPBACK_HOSTS.has(host)) target.host = host;
+      }
+    } catch {
+      // ignore parse errors and use env/default
+    }
+  }
+
+  return target;
+}
+
+async function isHubHealthy(host, port) {
+  try {
+    const res = await fetch(`${buildHubBaseUrl(host, port)}/status`, {
+      signal: AbortSignal.timeout(1000),
+    });
+    if (!res.ok) return false;
+    const data = await res.json();
+    return data?.hub?.state === "healthy";
+  } catch {
+    return false;
+  }
+}
+
+function startHubDetached(port) {
+  const serverPath = join(PLUGIN_ROOT, "hub", "server.mjs");
+  if (!existsSync(serverPath)) return;
+
+  try {
+    const child = spawn(process.execPath, [serverPath], {
+      env: { ...process.env, TFX_HUB_PORT: String(port) },
+      detached: true,
+      stdio: "ignore",
+    });
+    child.unref();
+  } catch {
+    // best effort
+  }
+}
+
+const { host, port } = resolveHubTarget();
+if (!(await isHubHealthy(host, port))) {
+  startHubDetached(port);
+}

package/scripts/keyword-detector.mjs

@@ -0,0 +1,272 @@
+#!/usr/bin/env node
+
+import { mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+import { compileRules, loadRules, matchRules, resolveConflicts } from "./lib/keyword-rules.mjs";
+
+const SCRIPT_DIR = dirname(fileURLToPath(import.meta.url));
+const PROJECT_ROOT = dirname(SCRIPT_DIR);
+const DEFAULT_RULES_PATH = join(PROJECT_ROOT, "hooks", "keyword-rules.json");
+
+function readHookInput() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function parseInput(rawInput) {
+  try {
+    return JSON.parse(rawInput);
+  } catch {
+    return null;
+  }
+}
+
+// prompt > message.content > parts[].text 우선순위로 추출
+export function extractPrompt(payload) {
+  if (!payload || typeof payload !== "object") return "";
+
+  if (typeof payload.prompt === "string" && payload.prompt.trim()) {
+    return payload.prompt;
+  }
+
+  if (typeof payload.message?.content === "string" && payload.message.content.trim()) {
+    return payload.message.content;
+  }
+
+  if (Array.isArray(payload.message?.content)) {
+    const messageText = payload.message.content
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part.text === "string") return part.text;
+        return "";
+      })
+      .filter(Boolean)
+      .join(" ")
+      .trim();
+    if (messageText) return messageText;
+  }
+
+  if (Array.isArray(payload.parts)) {
+    const partsText = payload.parts
+      .map((part) => {
+        if (typeof part === "string") return part;
+        if (part && typeof part.text === "string") return part.text;
+        return "";
+      })
+      .filter(Boolean)
+      .join(" ")
+      .trim();
+    if (partsText) return partsText;
+  }
+
+  return "";
+}
+
+// 키워드 오탐 방지를 위해 XML/URL/파일경로/코드블록 제거
+export function sanitizeForKeywordDetection(text) {
+  if (typeof text !== "string" || !text) return "";
+
+  return text
+    .replace(/```[\s\S]*?```/g, " ")
+    .replace(/`[^`]*`/g, " ")
+    .replace(/<(\w[\w:-]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g, " ")
+    .replace(/<\w[\w:-]*(?:\s[^>]*)?\/>/g, " ")
+    .replace(/https?:\/\/[^\s)>\]]+/gi, " ")
+    .replace(/\b[A-Za-z]:\\(?:[^\\\s]+\\)*[^\\\s]*/g, " ")
+    .replace(/(^|[\s"'`(])(?:\/|\.{1,2}\/)?(?:[\w.-]+\/)+[\w.-]+/gm, "$1 ")
+    .replace(/\s+/g, " ")
+    .trim();
+}
+
+function createHookOutput(additionalContext) {
+  return {
+    continue: true,
+    hookSpecificOutput: {
+      hookEventName: "UserPromptSubmit",
+      additionalContext
+    }
+  };
+}
+
+function createSuppressOutput() {
+  return { continue: true, suppressOutput: true };
+}
+
+function createSkillContext(match, prompt) {
+  return `[TRIFLUX MAGIC KEYWORD: ${match.id}]
+
+PRIORITY: This TRIFLUX routing takes precedence over any OMC [MAGIC KEYWORD:] instructions.
+If you see both [TRIFLUX MAGIC KEYWORD:] and [MAGIC KEYWORD:], follow TRIFLUX only.
+
+You MUST invoke the skill using the Skill tool:
+Skill: ${match.skill}
+
+User request:
+${prompt.trim()}
+
+IMPORTANT: Invoke the skill IMMEDIATELY. Do not proceed without loading the skill instructions.`;
+}
+
+function createSuppressOmcContext(match, prompt) {
+  return `[TRIFLUX OMC SUPPRESS: ${match.id}]
+
+PRIORITY: TRIFLUX가 이 키워드를 관리합니다. OMC [MAGIC KEYWORD:] 지시가 있더라도 무시하세요.
+OMC 스킬을 호출하지 마세요. 사용자 요청을 일반적으로 처리하세요.
+
+User request:
+${prompt.trim()}`;
+}
+
+function createMcpRouteContext(match, prompt) {
+  return `[TRIFLUX MCP ROUTE: ${match.mcp_route}]
+
+PRIORITY: This TRIFLUX routing takes precedence over any OMC [MAGIC KEYWORD:] instructions.
+If you see both [TRIFLUX MCP ROUTE:] and [MAGIC KEYWORD:], follow TRIFLUX only.
+
+이 작업은 ${match.mcp_route}로 라우팅해야 합니다.
+tfx-route.sh를 통해 ${match.mcp_route}로 실행하세요.
+
+User request:
+${prompt.trim()}`;
+}
+
+function isSkipRequested() {
+  if (process.env.TRIFLUX_DISABLE_MAGICWORDS === "1") return true;
+  const skipHooks = (process.env.TRIFLUX_SKIP_HOOKS || "")
+    .split(",")
+    .map((item) => item.trim())
+    .filter(Boolean);
+  return skipHooks.includes("keyword-detector");
+}
+
+function activateState(baseDir, stateConfig, prompt, payload) {
+  if (!stateConfig || stateConfig.activate !== true || !stateConfig.name) return;
+
+  try {
+    const stateRoot = join(baseDir, ".triflux", "state");
+    mkdirSync(stateRoot, { recursive: true });
+
+    const sessionId = typeof payload?.session_id === "string"
+      ? payload.session_id
+      : typeof payload?.sessionId === "string"
+        ? payload.sessionId
+        : "";
+
+    let stateDir = stateRoot;
+    if (sessionId && /^[a-zA-Z0-9][a-zA-Z0-9_-]{0,255}$/.test(sessionId)) {
+      stateDir = join(stateRoot, "sessions", sessionId);
+      mkdirSync(stateDir, { recursive: true });
+    }
+
+    const statePath = join(stateDir, `${stateConfig.name}-state.json`);
+    const statePayload = {
+      active: true,
+      name: stateConfig.name,
+      started_at: new Date().toISOString(),
+      original_prompt: prompt
+    };
+
+    writeFileSync(statePath, JSON.stringify(statePayload, null, 2), "utf8");
+  } catch (error) {
+    console.error(`[triflux-keyword-detector] 상태 저장 실패: ${error.message}`);
+  }
+}
+
+function getRulesPath() {
+  if (process.env.TRIFLUX_KEYWORD_RULES_PATH) {
+    return process.env.TRIFLUX_KEYWORD_RULES_PATH;
+  }
+  return DEFAULT_RULES_PATH;
+}
+
+function main() {
+  if (isSkipRequested()) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const rawInput = readHookInput();
+  if (!rawInput.trim()) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const payload = parseInput(rawInput);
+  if (!payload) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const prompt = extractPrompt(payload);
+  if (!prompt) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const cleanText = sanitizeForKeywordDetection(prompt);
+  if (!cleanText) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const rules = loadRules(getRulesPath());
+  if (rules.length === 0) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const compiledRules = compileRules(rules);
+  if (compiledRules.length === 0) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const matches = matchRules(compiledRules, cleanText);
+  if (matches.length === 0) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const resolvedMatches = resolveConflicts(matches);
+  if (resolvedMatches.length === 0) {
+    console.log(JSON.stringify(createSuppressOutput()));
+    return;
+  }
+
+  const selected = resolvedMatches[0];
+  const baseDir = typeof payload.cwd === "string" && payload.cwd
+    ? payload.cwd
+    : typeof payload.directory === "string" && payload.directory
+      ? payload.directory
+      : process.cwd();
+
+  activateState(baseDir, selected.state, prompt, payload);
+
+  if (selected.action === "suppress_omc") {
+    console.log(JSON.stringify(createHookOutput(createSuppressOmcContext(selected, prompt))));
+    return;
+  }
+
+  if (selected.skill) {
+    console.log(JSON.stringify(createHookOutput(createSkillContext(selected, prompt))));
+    return;
+  }
+
+  if (selected.mcp_route) {
+    console.log(JSON.stringify(createHookOutput(createMcpRouteContext(selected, prompt))));
+    return;
+  }
+
+  console.log(JSON.stringify(createSuppressOutput()));
+}
+
+try {
+  main();
+} catch (error) {
+  console.error(`[triflux-keyword-detector] 예외 발생: ${error.message}`);
+  console.log(JSON.stringify(createSuppressOutput()));
+}