triflux 10.0.0 → 10.0.2

package/hooks/error-context.mjs

@@ -0,0 +1,148 @@
+#!/usr/bin/env node
+// hooks/error-context.mjs — PostToolUseFailure 훅
+//
+// 도구 실패 시 에러 패턴을 분석하여 해결 힌트를 additionalContext로 주입한다.
+// Claude가 동일 에러를 반복하지 않도록 구체적 가이드를 제공.
+
+import { readFileSync } from "node:fs";
+
+// ── 에러 패턴 → 해결 힌트 매핑 ─────────────────────────────
+const ERROR_HINTS = [
+  // Node.js / npm
+  {
+    pattern: /ENOENT.*no such file or directory/i,
+    hint: "파일/디렉토리가 존재하지 않습니다. 경로를 확인하거나 mkdir -p로 디렉토리를 먼저 생성하세요.",
+  },
+  {
+    pattern: /EACCES.*permission denied/i,
+    hint: "권한 부족. Windows에서는 관리자 권한, Unix에서는 chmod/sudo를 확인하세요.",
+  },
+  {
+    pattern: /EADDRINUSE/i,
+    hint: "포트가 이미 사용 중입니다. lsof -i :{port} 또는 netstat -ano | findstr :{port}로 확인 후 프로세스를 종료하세요.",
+  },
+  {
+    pattern: /ERR_MODULE_NOT_FOUND|Cannot find module/i,
+    hint: "모듈을 찾을 수 없습니다. npm install을 실행하거나, import 경로에 .mjs/.js 확장자를 명시하세요.",
+  },
+  {
+    pattern: /ETARGET|ERR_INVALID_PACKAGE_TARGET/i,
+    hint: "패키지 버전 해석 실패. package.json의 exports 필드 또는 의존성 버전을 확인하세요.",
+  },
+  {
+    pattern: /npm ERR! code E40[134]/i,
+    hint: "npm 인증 오류. npm login 또는 .npmrc 토큰을 확인하세요.",
+  },
+
+  // Git
+  {
+    pattern: /fatal: not a git repository/i,
+    hint: "git 저장소가 아닙니다. git init 또는 올바른 디렉토리로 이동하세요.",
+  },
+  {
+    pattern: /merge conflict|CONFLICT.*Merge/i,
+    hint: "병합 충돌 발생. 충돌 파일을 수동 해결 후 git add + git commit 하세요.",
+  },
+  {
+    pattern: /rejected.*non-fast-forward/i,
+    hint: "원격에 새 커밋이 있습니다. git pull --rebase 후 다시 push하세요.",
+  },
+  {
+    pattern: /fatal: refusing to merge unrelated histories/i,
+    hint: "--allow-unrelated-histories 플래그가 필요할 수 있습니다.",
+  },
+
+  // Python
+  {
+    pattern: /ModuleNotFoundError/i,
+    hint: "Python 모듈 미설치. pip install 또는 가상환경 활성화를 확인하세요.",
+  },
+  {
+    pattern: /SyntaxError.*invalid syntax/i,
+    hint: "Python 문법 오류. Python 버전(2 vs 3) 호환성도 확인하세요.",
+  },
+
+  // Windows 특이
+  {
+    pattern: /is not recognized as an internal or external command/i,
+    hint: "명령어를 찾을 수 없습니다. PATH 환경변수를 확인하거나 절대 경로를 사용하세요.",
+  },
+  {
+    pattern: /execution policy/i,
+    hint: "PowerShell 실행 정책 제한. -ExecutionPolicy Bypass 플래그를 추가하세요.",
+  },
+  {
+    pattern: /The process cannot access the file because it is being used/i,
+    hint: "파일이 다른 프로세스에 의해 잠겨 있습니다. 해당 프로세스를 종료하거나 잠시 후 재시도하세요.",
+  },
+
+  // 일반
+  {
+    pattern: /timeout|timed out|ETIMEDOUT/i,
+    hint: "타임아웃 발생. 네트워크 상태를 확인하거나 timeout 값을 늘리세요.",
+  },
+  {
+    pattern: /out of memory|heap|ENOMEM/i,
+    hint: "메모리 부족. --max-old-space-size를 늘리거나 데이터 크기를 줄이세요.",
+  },
+  {
+    pattern: /ECONNREFUSED/i,
+    hint: "연결 거부. 대상 서버/서비스가 실행 중인지 확인하세요.",
+  },
+];
+
+function readStdin() {
+  try {
+    return readFileSync(0, "utf8");
+  } catch {
+    return "";
+  }
+}
+
+function findHints(errorText) {
+  const hints = [];
+  for (const rule of ERROR_HINTS) {
+    if (rule.pattern.test(errorText)) {
+      hints.push(rule.hint);
+    }
+  }
+  return hints;
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) process.exit(0);
+
+  let input;
+  try {
+    input = JSON.parse(raw);
+  } catch {
+    process.exit(0);
+  }
+
+  // tool_output 또는 error 필드에서 에러 텍스트 추출
+  const errorText = [
+    input.tool_output || "",
+    input.error || "",
+    input.tool_input?.command || "",
+    JSON.stringify(input.tool_result || ""),
+  ].join("\n");
+
+  const hints = findHints(errorText);
+  if (hints.length === 0) process.exit(0);
+
+  const toolName = input.tool_name || "Unknown";
+  const output = {
+    systemMessage:
+      `[error-context] ${toolName} 실패 — 해결 힌트:\n` +
+      hints.map((h) => `  → ${h}`).join("\n"),
+  };
+
+  process.stdout.write(JSON.stringify(output));
+}
+
+try {
+  main();
+} catch {
+  process.exit(0);
+}

package/hooks/hook-adaptive-collector.mjs

@@ -0,0 +1,86 @@
+#!/usr/bin/env node
+
+import { existsSync, readFileSync } from 'node:fs';
+import { basename, join } from 'node:path';
+import { pathToFileURL } from 'node:url';
+
+import { createAdaptiveEngine } from '../hub/adaptive.mjs';
+
+let engine = null;
+let createEngine = createAdaptiveEngine;
+
+function readStdin() {
+  try {
+    return readFileSync(0, 'utf8');
+  } catch {
+    return '';
+  }
+}
+
+function inferProjectSlug(cwd = process.cwd()) {
+  const packagePath = join(cwd, 'package.json');
+  if (existsSync(packagePath)) {
+    try {
+      const pkg = JSON.parse(readFileSync(packagePath, 'utf8'));
+      if (typeof pkg.name === 'string' && pkg.name.trim()) return pkg.name.trim();
+    } catch {}
+  }
+  return basename(cwd) || 'default';
+}
+
+function getEngine() {
+  if (engine) return engine;
+  engine = createEngine({
+    projectSlug: inferProjectSlug(),
+    repoRoot: process.cwd(),
+  });
+  engine.startSession?.();
+  return engine;
+}
+
+function buildErrorContext(event = {}) {
+  return {
+    exitCode: event.exitCode,
+    stderr: String(event.stderr || '').slice(0, 500),
+    tool: event.tool,
+    command: String(event.command || '').slice(0, 200),
+    timestamp: new Date().toISOString(),
+  };
+}
+
+export default function hookAdaptiveCollector(event = {}) {
+  if (Number(event.exitCode) === 0) return null;
+  if (!event.tool || event.tool === 'Read') return null;
+
+  const result = getEngine().handleError(buildErrorContext(event));
+  if (result?.diagnosed) {
+    console.error(`[adaptive] 에러 패턴 감지: ${result.rule?.id || 'unknown'}`);
+    if (result.promoted) {
+      console.error(`[adaptive] 규칙 승격 → Tier ${result.rule?.tier ?? '?'}`);
+    }
+  }
+  return result;
+}
+
+export function __setAdaptiveCollectorFactoryForTests(factory) {
+  createEngine = factory;
+  engine = null;
+}
+
+export function __resetAdaptiveCollectorForTests() {
+  createEngine = createAdaptiveEngine;
+  engine = null;
+}
+
+function main() {
+  const raw = readStdin();
+  if (!raw.trim()) return;
+  try {
+    hookAdaptiveCollector(JSON.parse(raw));
+  } catch {}
+}
+
+const isEntrypoint = process.argv[1] && pathToFileURL(process.argv[1]).href === import.meta.url;
+if (isEntrypoint) {
+  main();
+}

package/hooks/hook-manager.mjs

@@ -0,0 +1,365 @@
+#!/usr/bin/env node
+// hooks/hook-manager.mjs — 훅 우선순위 매니저
+//
+// 사용법:
+//   node hook-manager.mjs scan            — 현재 settings.json 훅 스캔 → JSON 리포트
+//   node hook-manager.mjs diff            — 오케스트레이터 적용 시 변경점 미리보기
+//   node hook-manager.mjs apply           — settings.json에 오케스트레이터 적용
+//   node hook-manager.mjs restore         — 백업에서 원래 settings.json 훅 복원
+//   node hook-manager.mjs set-priority <hookId> <priority>  — 특정 훅 우선순위 변경
+//   node hook-manager.mjs toggle <hookId>                   — 특정 훅 활성/비활성 토글
+//   node hook-manager.mjs status          — 오케스트레이터 적용 상태 확인
+//
+// Claude 대화에서 AskUserQuestion으로 UI를 제공하며 내부적으로 이 명령들을 호출합니다.
+
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { PLUGIN_ROOT } from "./lib/resolve-root.mjs";
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+const HOME = process.env.HOME || process.env.USERPROFILE || "";
+const SETTINGS_PATH = join(HOME, ".claude", "settings.json");
+const BACKUP_PATH = join(HOME, ".claude", "settings.hooks-backup.json");
+const BUNDLED_REGISTRY_PATH = join(__dirname, "hook-registry.json");
+const REGISTRY_PATH = join(HOME, ".claude", "cache", "hook-registry.json");
+
+function ensureUserRegistry() {
+  if (!existsSync(REGISTRY_PATH) && existsSync(BUNDLED_REGISTRY_PATH)) {
+    mkdirSync(dirname(REGISTRY_PATH), { recursive: true });
+    writeFileSync(REGISTRY_PATH, readFileSync(BUNDLED_REGISTRY_PATH, "utf8"), "utf8");
+  }
+}
+
+// ── 유틸리티 ────────────────────────────────────────────────
+
+function loadJSON(path) {
+  if (!existsSync(path)) return null;
+  try {
+    return JSON.parse(readFileSync(path, "utf8"));
+  } catch {
+    return null;
+  }
+}
+
+function saveJSON(path, data) {
+  writeFileSync(path, JSON.stringify(data, null, 2) + "\n", "utf8");
+}
+
+function getNodeExe() {
+  return process.execPath || "node";
+}
+
+// ── scan: 현재 settings.json 훅 분석 ───────────────────────
+
+function scan() {
+  ensureUserRegistry();
+  const settings = loadJSON(SETTINGS_PATH);
+  if (!settings?.hooks) {
+    return { status: "no_hooks", message: "settings.json에 훅이 없습니다.", events: {} };
+  }
+
+  const registry = loadJSON(REGISTRY_PATH);
+  const report = { status: "ok", events: {}, unregistered: [] };
+
+  for (const [event, matchers] of Object.entries(settings.hooks)) {
+    report.events[event] = { hooks: [], count: 0 };
+
+    for (const matcher of matchers) {
+      for (const hook of matcher.hooks || []) {
+        const cmd = hook.command || "";
+        const hookInfo = {
+          event,
+          matcher: matcher.matcher || "*",
+          command: cmd,
+          timeout: hook.timeout,
+          type: hook.type || "command",
+          source: identifySource(cmd),
+          registryMatch: null,
+        };
+
+        // 레지스트리에서 매칭 찾기
+        if (registry?.events?.[event]) {
+          const match = registry.events[event].find(
+            (r) => normalizeCmd(resolveVars(r.command)) === normalizeCmd(cmd)
+          );
+          if (match) {
+            hookInfo.registryMatch = { id: match.id, priority: match.priority };
+          } else {
+            report.unregistered.push(hookInfo);
+          }
+        }
+
+        report.events[event].hooks.push(hookInfo);
+        report.events[event].count++;
+      }
+    }
+  }
+
+  return report;
+}
+
+function identifySource(cmd) {
+  if (/triflux/i.test(cmd) || /\$\{?CLAUDE_PLUGIN_ROOT\}?/i.test(cmd)) return "triflux";
+  if (/oh-my-claudecode|omc/i.test(cmd)) return "omc";
+  if (/session-vault/i.test(cmd)) return "session-vault";
+  if (/compact-helper/i.test(cmd)) return "compact-helper";
+  if (/headless-guard|tfx-gate/i.test(cmd)) return "omc";
+  if (/mcp-cleanup/i.test(cmd)) return "system";
+  return "unknown";
+}
+
+function normalizeCmd(cmd) {
+  return cmd.replace(/["']/g, "").replace(/\\/g, "/").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
+function resolveVars(cmd) {
+  return cmd
+    .replace(/\$\{PLUGIN_ROOT\}/g, PLUGIN_ROOT)
+    .replace(/\$\{CLAUDE_PLUGIN_ROOT\}/g, PLUGIN_ROOT)
+    .replace(/\$\{HOME\}/g, HOME)
+    .replace(/\$HOME\b/g, HOME);
+}
+
+// ── diff: 적용 시 변경점 미리보기 ───────────────────────────
+
+function diff() {
+  ensureUserRegistry();
+  const settings = loadJSON(SETTINGS_PATH);
+  if (!settings?.hooks) return { status: "no_hooks", changes: [] };
+
+  const registry = loadJSON(REGISTRY_PATH);
+  if (!registry) return { status: "no_registry", changes: [] };
+
+  const changes = [];
+  const currentEvents = Object.keys(settings.hooks);
+  const registryEvents = Object.keys(registry.events);
+  const allEvents = [...new Set([...currentEvents, ...registryEvents])];
+
+  for (const event of allEvents) {
+    const currentHooks = settings.hooks[event] || [];
+    const registryHooks = registry.events[event] || [];
+
+    const currentCount = currentHooks.reduce((n, m) => n + (m.hooks?.length || 0), 0);
+    const registryCount = registryHooks.filter((h) => h.enabled !== false).length;
+
+    if (currentCount === 1 && isOrchestrator(currentHooks)) {
+      changes.push({ event, action: "already_orchestrated", currentCount, registryCount });
+    } else if (currentCount > 0 || registryCount > 0) {
+      changes.push({
+        event,
+        action: "will_replace",
+        currentCount,
+        registryCount,
+        detail: `${currentCount}개 개별 훅 → 1개 오케스트레이터 (내부 ${registryCount}개 순차 실행)`,
+      });
+    }
+  }
+
+  return { status: "ok", changes };
+}
+
+function isOrchestrator(matchers) {
+  if (!matchers || matchers.length !== 1) return false;
+  const hooks = matchers[0]?.hooks || [];
+  return hooks.length === 1 && (hooks[0]?.command || "").includes("hook-orchestrator");
+}
+
+// ── apply: 오케스트레이터 적용 ──────────────────────────────
+
+function apply() {
+  ensureUserRegistry();
+  const settings = loadJSON(SETTINGS_PATH);
+  if (!settings) return { status: "error", message: "settings.json을 찾을 수 없습니다." };
+
+  const registry = loadJSON(REGISTRY_PATH);
+  if (!registry) return { status: "error", message: "hook-registry.json을 찾을 수 없습니다." };
+
+  // 백업
+  if (settings.hooks && !existsSync(BACKUP_PATH)) {
+    saveJSON(BACKUP_PATH, { hooks: settings.hooks, backedUpAt: new Date().toISOString() });
+  }
+
+  // 오케스트레이터 명령 생성
+  const nodeExe = getNodeExe();
+  const orchestratorPath = join(PLUGIN_ROOT, "hooks", "hook-orchestrator.mjs");
+  const orchestratorCmd = `"${nodeExe}" "${orchestratorPath}"`;
+
+  // 모든 이벤트를 하나의 오케스트레이터로 통합
+  const newHooks = {};
+  const registryEvents = Object.keys(registry.events);
+
+  // 레지스트리에 없는 기존 이벤트도 보존
+  const allEvents = [
+    ...new Set([...registryEvents, ...Object.keys(settings.hooks || {})]),
+  ];
+
+  for (const event of allEvents) {
+    const registryEntries = registry.events[event] || [];
+    const enabledEntries = registryEntries.filter((h) => h.enabled !== false);
+
+    if (enabledEntries.length > 0) {
+      // 레지스트리에 있으면 → 오케스트레이터로 교체
+      // 가장 큰 timeout을 기준으로 오케스트레이터 timeout 설정
+      const maxTimeout = Math.max(...enabledEntries.map((h) => h.timeout || 10)) + 5;
+
+      newHooks[event] = [
+        {
+          matcher: "*",
+          hooks: [
+            {
+              type: "command",
+              command: orchestratorCmd,
+              timeout: maxTimeout,
+            },
+          ],
+        },
+      ];
+    } else {
+      // 레지스트리에 없으면 기존 유지
+      if (settings.hooks?.[event]) {
+        newHooks[event] = settings.hooks[event];
+      }
+    }
+  }
+
+  settings.hooks = newHooks;
+  saveJSON(SETTINGS_PATH, settings);
+
+  return {
+    status: "applied",
+    message: `오케스트레이터 적용 완료. ${registryEvents.length}개 이벤트가 순차 실행으로 전환됩니다.`,
+    events: registryEvents,
+    backupPath: BACKUP_PATH,
+  };
+}
+
+// ── restore: 백업에서 복원 ──────────────────────────────────
+
+function restore() {
+  if (!existsSync(BACKUP_PATH)) {
+    return { status: "no_backup", message: "백업 파일이 없습니다. apply 전에는 복원할 수 없습니다." };
+  }
+
+  const backup = loadJSON(BACKUP_PATH);
+  if (!backup?.hooks) {
+    return { status: "error", message: "백업 파일이 손상되었습니다." };
+  }
+
+  const settings = loadJSON(SETTINGS_PATH);
+  if (!settings) return { status: "error", message: "settings.json을 찾을 수 없습니다." };
+
+  settings.hooks = backup.hooks;
+  saveJSON(SETTINGS_PATH, settings);
+
+  return {
+    status: "restored",
+    message: `원래 훅 설정이 복원되었습니다. (백업 시점: ${backup.backedUpAt})`,
+  };
+}
+
+// ── set-priority: 우선순위 변경 ─────────────────────────────
+
+function setPriority(hookId, priority) {
+  ensureUserRegistry();
+  const registry = loadJSON(REGISTRY_PATH);
+  if (!registry) return { status: "error", message: "레지스트리를 찾을 수 없습니다." };
+
+  const numPriority = parseInt(priority, 10);
+  if (isNaN(numPriority)) return { status: "error", message: "priority는 숫자여야 합니다." };
+
+  let found = false;
+  for (const hooks of Object.values(registry.events)) {
+    const hook = hooks.find((h) => h.id === hookId);
+    if (hook) {
+      hook.priority = numPriority;
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) return { status: "not_found", message: `훅 '${hookId}'를 찾을 수 없습니다.` };
+
+  saveJSON(REGISTRY_PATH, registry);
+  return { status: "ok", message: `${hookId}의 우선순위가 ${numPriority}로 변경되었습니다.` };
+}
+
+// ── toggle: 활성/비활성 토글 ────────────────────────────────
+
+function toggle(hookId) {
+  ensureUserRegistry();
+  const registry = loadJSON(REGISTRY_PATH);
+  if (!registry) return { status: "error", message: "레지스트리를 찾을 수 없습니다." };
+
+  let found = false;
+  let newState = false;
+  for (const hooks of Object.values(registry.events)) {
+    const hook = hooks.find((h) => h.id === hookId);
+    if (hook) {
+      hook.enabled = !(hook.enabled !== false);
+      newState = hook.enabled;
+      found = true;
+      break;
+    }
+  }
+
+  if (!found) return { status: "not_found", message: `훅 '${hookId}'를 찾을 수 없습니다.` };
+
+  saveJSON(REGISTRY_PATH, registry);
+  return { status: "ok", message: `${hookId}: ${newState ? "활성화" : "비활성화"}` };
+}
+
+// ── status: 현재 적용 상태 ──────────────────────────────────
+
+function status() {
+  const settings = loadJSON(SETTINGS_PATH);
+  if (!settings?.hooks) return { orchestrated: false, message: "훅 없음" };
+
+  let orchestrated = 0;
+  let individual = 0;
+
+  for (const [event, matchers] of Object.entries(settings.hooks)) {
+    if (isOrchestrator(matchers)) {
+      orchestrated++;
+    } else {
+      individual++;
+    }
+  }
+
+  const hasBackup = existsSync(BACKUP_PATH);
+
+  return {
+    orchestrated: orchestrated > 0,
+    orchestratedEvents: orchestrated,
+    individualEvents: individual,
+    hasBackup,
+    message: orchestrated > 0
+      ? `오케스트레이터 적용 중: ${orchestrated}개 이벤트 통합, ${individual}개 개별 유지`
+      : `오케스트레이터 미적용. ${individual}개 이벤트가 개별 훅으로 실행 중`,
+  };
+}
+
+// ── CLI 진입점 ──────────────────────────────────────────────
+
+const [, , command, ...args] = process.argv;
+
+const commands = {
+  scan: () => scan(),
+  diff: () => diff(),
+  apply: () => apply(),
+  restore: () => restore(),
+  "set-priority": () => setPriority(args[0], args[1]),
+  toggle: () => toggle(args[0]),
+  status: () => status(),
+};
+
+if (!command || !commands[command]) {
+  console.log(JSON.stringify({
+    error: "사용법: node hook-manager.mjs <scan|diff|apply|restore|set-priority|toggle|status>",
+    commands: Object.keys(commands),
+  }));
+  process.exit(1);
+}
+
+const result = commands[command]();
+console.log(JSON.stringify(result, null, 2));