@triflux/core 10.1.0 → 10.26.0

package/hooks/hook-orchestrator.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+
 // hooks/hook-orchestrator.mjs — 범용 훅 체이닝 엔진
 //
 // settings.json에 이벤트당 하나만 등록. stdin JSON에서 이벤트명+툴명을 읽고
@@ -19,15 +20,30 @@
 //   CLAUDE_PLUGIN_ROOT    — ${PLUGIN_ROOT} 치환용
 //   HOME / USERPROFILE    — ${HOME} 치환용
 
-import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
-import { join, dirname } from "node:path";
+import { execFile, execFileSync } from "node:child_process";
+import { createHash } from "node:crypto";
+import {
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync,
+} from "node:fs";
+import { tmpdir } from "node:os";
+import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
-import { execFileSync, execFile } from "node:child_process";
 import { PLUGIN_ROOT } from "./lib/resolve-root.mjs";
 
 const __dirname = dirname(fileURLToPath(import.meta.url));
 const REGISTRY_PATH =
   process.env.TRIFLUX_HOOK_REGISTRY || join(__dirname, "hook-registry.json");
+const HOOK_CACHE_DIR =
+  process.env.TRIFLUX_HOOK_CACHE_DIR ||
+  join(tmpdir(), "triflux-hook-orchestrator-cache");
+const HOOK_CACHE_TTL_MS = Math.max(
+  0,
+  Number.parseInt(process.env.TRIFLUX_HOOK_CACHE_TTL_MS || "1500", 10) || 1500,
+);
 
 // ── stdin 읽기 ──────────────────────────────────────────────
 function readStdin() {
@@ -75,6 +91,57 @@ function matchesMatcher(hookMatcher, toolName, eventInput) {
   });
 }
 
+function shouldDedupePreToolUseBash(eventName, toolName) {
+  return eventName === "PreToolUse" && toolName === "Bash";
+}
+
+function buildHookCachePath(stdinData) {
+  const digest = createHash("sha1").update(stdinData).digest("hex");
+  return join(HOOK_CACHE_DIR, `pretool-bash-${digest}.json`);
+}
+
+function readHookCache(stdinData) {
+  if (HOOK_CACHE_TTL_MS <= 0) return null;
+
+  const cachePath = buildHookCachePath(stdinData);
+  if (!existsSync(cachePath)) return null;
+
+  try {
+    const cached = JSON.parse(readFileSync(cachePath, "utf8"));
+    const ageMs = Date.now() - Number(cached?.ts || 0);
+    if (!Number.isFinite(ageMs) || ageMs < 0 || ageMs > HOOK_CACHE_TTL_MS) {
+      unlinkSync(cachePath);
+      return null;
+    }
+    return cached;
+  } catch {
+    try {
+      unlinkSync(cachePath);
+    } catch {}
+    return null;
+  }
+}
+
+function writeHookCache(stdinData, payload) {
+  if (HOOK_CACHE_TTL_MS <= 0) return;
+
+  try {
+    mkdirSync(HOOK_CACHE_DIR, { recursive: true });
+    writeFileSync(
+      buildHookCachePath(stdinData),
+      JSON.stringify({ ts: Date.now(), ...payload }),
+      "utf8",
+    );
+  } catch {
+    // 캐시 실패는 훅 실행에 영향 주지 않음
+  }
+}
+
+function shouldShortCircuitPreToolUseBash(result) {
+  if (!result || result.code === 2) return true;
+  return result.code === 0 && Boolean(result.stdout?.trim());
+}
+
 // ── 단일 훅 실행 ────────────────────────────────────────────
 function executeHook(hook, stdinData) {
   const cmd = resolveCommand(hook.command);
@@ -84,7 +151,8 @@ function executeHook(hook, stdinData) {
   // "bash script.sh" → ["bash", ["script.sh"]]
   // 따옴표 처리 포함
   const parts = parseCommand(cmd);
-  if (parts.length === 0) return { code: 1, stdout: "", stderr: "empty command" };
+  if (parts.length === 0)
+    return { code: 1, stdout: "", stderr: "empty command" };
 
   const [executable, ...args] = parts;
 
@@ -114,20 +182,35 @@ function executeHookAsync(hook, stdinData) {
     const cmd = resolveCommand(hook.command);
     const timeout = (hook.timeout || 10) * 1000;
     const parts = parseCommand(cmd);
-    if (parts.length === 0) { resolve({ code: 1, stdout: "", stderr: "empty command" }); return; }
+    if (parts.length === 0) {
+      resolve({ code: 1, stdout: "", stderr: "empty command" });
+      return;
+    }
     const [executable, ...args] = parts;
-    const child = execFile(executable, args, {
-      timeout,
-      encoding: "utf8",
-      windowsHide: true,
-      cwd: process.cwd(),
-      env: { ...process.env },
-    }, (err, stdout, stderr) => {
-      if (err) resolve({ code: err.status ?? 1, stdout: stdout || "", stderr: stderr || "" });
-      else resolve({ code: 0, stdout: stdout || "", stderr: "" });
-    });
-    if (stdinData) { child.stdin.write(stdinData); child.stdin.end(); }
-    else child.stdin.end();
+    const child = execFile(
+      executable,
+      args,
+      {
+        timeout,
+        encoding: "utf8",
+        windowsHide: true,
+        cwd: process.cwd(),
+        env: { ...process.env },
+      },
+      (err, stdout, stderr) => {
+        if (err)
+          resolve({
+            code: err.status ?? 1,
+            stdout: stdout || "",
+            stderr: stderr || "",
+          });
+        else resolve({ code: 0, stdout: stdout || "", stderr: "" });
+      },
+    );
+    if (stdinData) {
+      child.stdin.write(stdinData);
+      child.stdin.end();
+    } else child.stdin.end();
   });
 }
 
@@ -170,11 +253,19 @@ function mergeOutputs(accumulated, newOutput) {
 
     // hookSpecificOutput 머지 — additionalContext는 누적, 나머지는 덮어쓰기
     if (parsed.hookSpecificOutput) {
-      if (accumulated.hookSpecificOutput?.additionalContext && parsed.hookSpecificOutput.additionalContext) {
+      if (
+        accumulated.hookSpecificOutput?.additionalContext &&
+        parsed.hookSpecificOutput.additionalContext
+      ) {
         parsed.hookSpecificOutput.additionalContext =
-          accumulated.hookSpecificOutput.additionalContext + "\n" + parsed.hookSpecificOutput.additionalContext;
+          accumulated.hookSpecificOutput.additionalContext +
+          "\n" +
+          parsed.hookSpecificOutput.additionalContext;
       }
-      accumulated.hookSpecificOutput = { ...accumulated.hookSpecificOutput, ...parsed.hookSpecificOutput };
+      accumulated.hookSpecificOutput = {
+        ...accumulated.hookSpecificOutput,
+        ...parsed.hookSpecificOutput,
+      };
     }
     // systemMessage는 누적
     if (parsed.systemMessage) {
@@ -220,7 +311,12 @@ function recordRouteOutcome(slug, mode, outcome) {
 
   const weights = existsSync(weightsPath)
     ? JSON.parse(readFileSync(weightsPath, "utf8"))
-    : { updated_at: null, total_routes: 0, overrides: 0, weights: { mode_bias: {}, profile_bias: {}, depth_bias: {} } };
+    : {
+        updated_at: null,
+        total_routes: 0,
+        overrides: 0,
+        weights: { mode_bias: {}, profile_bias: {}, depth_bias: {} },
+      };
 
   weights.total_routes++;
   weights.updated_at = new Date().toISOString();
@@ -247,6 +343,23 @@ function recordRouteOutcome(slug, mode, outcome) {
   writeFileSync(weightsPath, JSON.stringify(weights, null, 2), "utf8");
 }
 
+function isHubTokenMonitorSnapshot(snapshot) {
+  if (!snapshot || typeof snapshot !== "object") return false;
+  return (
+    Object.hasOwn(snapshot, "requestTokens") ||
+    Object.hasOwn(snapshot, "responseTokens") ||
+    Object.hasOwn(snapshot, "totalUpdates") ||
+    (snapshot.byTool && typeof snapshot.byTool === "object")
+  );
+}
+
+function readCompactNudgePercent(snapshot) {
+  if (isHubTokenMonitorSnapshot(snapshot)) return null;
+  const percent = Number(snapshot?.percent ?? 0);
+  if (!Number.isFinite(percent)) return null;
+  return Math.max(0, Math.min(100, percent));
+}
+
 // ── 메인 ────────────────────────────────────────────────────
 async function main() {
   // CLI: --record-route <slug> <mode> <outcome>
@@ -284,6 +397,50 @@ async function main() {
 
   if (!eventName) process.exit(0);
 
+  const dedupePreToolUseBash = shouldDedupePreToolUseBash(eventName, toolName);
+  if (dedupePreToolUseBash) {
+    const cached = readHookCache(stdinRaw);
+    if (cached?.stderr) process.stderr.write(cached.stderr);
+    if (cached?.blocked) process.exit(2);
+    if (cached?.mergedOutput) {
+      process.stdout.write(JSON.stringify(cached.mergedOutput));
+    }
+    if (cached) process.exit(0);
+  }
+
+  // ── SessionStart fast-path ──
+  // TRIFLUX_HOOK_FAST_PATH=false로 비활성화 가능 (rollback)
+  if (
+    eventName === "SessionStart" &&
+    process.env.TRIFLUX_HOOK_FAST_PATH !== "false"
+  ) {
+    try {
+      const { execute } = await import("./session-start-fast.mjs");
+      const result = await execute(stdinRaw);
+      if (result.stdout?.trim()) {
+        const output = { additionalContext: result.stdout.trim() };
+        process.stdout.write(JSON.stringify(output));
+      }
+
+      // external source 훅 (session-vault 등)은 기존 방식으로 실행
+      const allHooks = registry.events.SessionStart || [];
+      const externalHooks = allHooks.filter(
+        (h) => h.enabled !== false && h.source !== "triflux",
+      );
+      for (const hook of externalHooks) {
+        const hookResult = executeHookAsync(hook, stdinRaw);
+        hookResult.catch(() => {}); // fire-and-forget for external hooks
+      }
+
+      process.exit(0);
+    } catch (err) {
+      // fast-path 실패 시 기존 방식으로 폴백
+      process.stderr.write(
+        `[orchestrator] fast-path failed, falling back: ${err.message}\n`,
+      );
+    }
+  }
+
   // 이벤트에 해당하는 훅 목록
   const hooks = registry.events[eventName];
   if (!hooks || hooks.length === 0) process.exit(0);
@@ -309,34 +466,92 @@ async function main() {
 
   let mergedOutput = null;
   let blocked = false;
+  let blockingStderr = "";
 
-  for (const group of groups) {
-    if (blocked) break;
-
-    if (group.hooks.length === 1) {
-      // 단일 훅 — 기존 동기 실행
-      const result = executeHook(group.hooks[0], stdinRaw);
+  if (dedupePreToolUseBash) {
+    for (const hook of matched) {
+      const result = executeHook(hook, stdinRaw);
       if (result.code === 2) {
-        if (result.stderr) process.stderr.write(result.stderr);
+        blockingStderr = result.stderr || "";
+        if (blockingStderr) process.stderr.write(blockingStderr);
         blocked = true;
         break;
       }
       if (result.code === 0 && result.stdout.trim()) {
         mergedOutput = mergeOutputs(mergedOutput, result.stdout.trim());
       }
-    } else {
-      // 같은 priority 다중 훅 — 비동기 병렬 실행
-      const results = await Promise.all(group.hooks.map((h) => executeHookAsync(h, stdinRaw)));
-      for (const result of results) {
+      if (shouldShortCircuitPreToolUseBash(result)) {
+        break;
+      }
+    }
+  } else {
+    for (const group of groups) {
+      if (blocked) break;
+
+      if (group.hooks.length === 1) {
+        // 단일 훅 — 기존 동기 실행
+        const result = executeHook(group.hooks[0], stdinRaw);
         if (result.code === 2) {
-          if (result.stderr) process.stderr.write(result.stderr);
+          blockingStderr = result.stderr || "";
+          if (blockingStderr) process.stderr.write(blockingStderr);
           blocked = true;
           break;
         }
         if (result.code === 0 && result.stdout.trim()) {
           mergedOutput = mergeOutputs(mergedOutput, result.stdout.trim());
         }
+      } else {
+        // 같은 priority 다중 훅 — 비동기 병렬 실행
+        const results = await Promise.all(
+          group.hooks.map((h) => executeHookAsync(h, stdinRaw)),
+        );
+        for (const result of results) {
+          if (result.code === 2) {
+            blockingStderr = result.stderr || "";
+            if (blockingStderr) process.stderr.write(blockingStderr);
+            blocked = true;
+            break;
+          }
+          if (result.code === 0 && result.stdout.trim()) {
+            mergedOutput = mergeOutputs(mergedOutput, result.stdout.trim());
+          }
+        }
+      }
+    }
+  }
+
+  // ── PostToolUse: 컨텍스트 압축 nudge (인라인, 프로세스 추가 없음) ──
+  if (eventName === "PostToolUse" && toolName !== "Bash" && !blocked) {
+    try {
+      const home = process.env.HOME || process.env.USERPROFILE || "";
+      const snapshotPath = join(
+        home,
+        ".claude",
+        "cache",
+        "tfx-hub",
+        "context-monitor.json",
+      );
+      const nudgeMarker = join(tmpdir(), "tfx-compact-nudge-sent");
+      if (existsSync(snapshotPath) && !existsSync(nudgeMarker)) {
+        const snap = JSON.parse(readFileSync(snapshotPath, "utf8"));
+        const percent = readCompactNudgePercent(snap);
+        if (percent != null && percent >= 80) {
+          const level = percent >= 90 ? "critical" : "warn";
+          const msg =
+            level === "critical"
+              ? `[context ${percent}%] 컨텍스트 ${percent}% 사용. /compact 또는 에이전트 분할을 강력 권장합니다.`
+              : `[context ${percent}%] 컨텍스트 ${percent}% 사용. 마일스톤이면 /compact를 권장합니다.`;
+          mergedOutput = mergeOutputs(
+            mergedOutput,
+            JSON.stringify({ systemMessage: msg }),
+          );
+          if (level === "warn") {
+            writeFileSync(nudgeMarker, new Date().toISOString());
+          }
+        }
       }
+    } catch {
+      /* 컨텍스트 모니터 읽기 실패 무시 */
     }
   }
 
@@ -345,20 +560,37 @@ async function main() {
     try {
       const input = JSON.parse(stdinRaw);
       const skillName = input.tool_input?.skill || "";
-      if (skillName && skillName.startsWith("tfx-")) {
+      if (skillName?.startsWith("tfx-")) {
         const mode = skillName.replace(/^tfx-/, "");
         const gitRoot = process.env.GIT_WORK_TREE || process.cwd();
         const slug = gitRoot.split(/[\\/]/).pop() || "unknown";
         recordRouteOutcome(slug, mode, "completion");
       }
-    } catch { /* 가중치 기록 실패 무시 */ }
+    } catch {
+      /* 가중치 기록 실패 무시 */
+    }
   }
 
   // 결과 출력
   if (blocked) {
+    if (dedupePreToolUseBash) {
+      writeHookCache(stdinRaw, {
+        blocked: true,
+        mergedOutput: null,
+        stderr: blockingStderr,
+      });
+    }
     process.exit(2);
   }
 
+  if (dedupePreToolUseBash) {
+    writeHookCache(stdinRaw, {
+      blocked: false,
+      mergedOutput,
+      stderr: "",
+    });
+  }
+
   if (mergedOutput) {
     process.stdout.write(JSON.stringify(mergedOutput));
   }