@triflux/core 10.0.0-alpha.1

package/scripts/lib/context.mjs

@@ -0,0 +1,67 @@
+/**
+ * 요청별 로그 컨텍스트 전파 (AsyncLocalStorage 기반).
+ *
+ * Hub HTTP 서버의 요청마다 correlationId를 자동 할당하여,
+ * 하나의 요청에서 발생한 모든 로그를 추적할 수 있다.
+ *
+ * 사용법:
+ *   import { getLogger, getCorrelationId, withRequestContext } from './lib/context.mjs';
+ *
+ *   // 미들웨어에서 컨텍스트 생성
+ *   withRequestContext({ method: 'POST', path: '/bridge/result' }, () => {
+ *     const log = getLogger();
+ *     log.info({ agentId }, 'bridge.result_received');
+ *   });
+ *
+ *   // 내부 함수에서 자동 상관 ID
+ *   function processResult() {
+ *     const log = getLogger();
+ *     log.info('result.processed'); // correlationId 자동 포함
+ *   }
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+import { randomUUID } from 'node:crypto';
+
+import { logger } from './logger.mjs';
+
+/** @type {AsyncLocalStorage<{logger: import('pino').Logger, correlationId: string}>} */
+export const asyncLocalStorage = new AsyncLocalStorage();
+
+/**
+ * 현재 요청 컨텍스트의 로거를 반환한다.
+ * 요청 컨텍스트 밖에서 호출하면 기본 로거를 반환한다.
+ *
+ * @returns {import('pino').Logger}
+ */
+export function getLogger() {
+  return asyncLocalStorage.getStore()?.logger || logger;
+}
+
+/**
+ * 현재 요청의 상관 ID를 반환한다.
+ *
+ * @returns {string|undefined}
+ */
+export function getCorrelationId() {
+  return asyncLocalStorage.getStore()?.correlationId;
+}
+
+/**
+ * 요청 컨텍스트를 생성하고 콜백을 실행한다.
+ *
+ * @param {object} context — 컨텍스트 필드 (method, path 등)
+ * @param {string} [context.correlationId] — 외부에서 전달된 상관 ID (없으면 자동 생성)
+ * @param {function} callback — 컨텍스트 내에서 실행할 함수
+ * @returns {*}
+ */
+export function withRequestContext(context, callback) {
+  const correlationId = context.correlationId || randomUUID();
+  const { correlationId: _, ...rest } = context;
+
+  const store = {
+    correlationId,
+    logger: logger.child({ correlationId, ...rest }),
+  };
+
+  return asyncLocalStorage.run(store, callback);
+}

package/scripts/lib/cross-review-utils.mjs

@@ -0,0 +1,51 @@
+import { join } from "node:path";
+
+export const SESSION_TTL_SEC = 30 * 60;
+export const STATE_REL_PATH = join(".omc", "state", "cross-review.json");
+
+export function readStdin() {
+  return new Promise((resolve) => {
+    let raw = "";
+    process.stdin.setEncoding("utf8");
+    process.stdin.on("data", (chunk) => {
+      raw += chunk;
+    });
+    process.stdin.on("end", () => resolve(raw));
+    process.stdin.on("error", () => resolve(""));
+  });
+}
+
+export function parseJson(raw) {
+  try {
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export function nowSec() {
+  return Math.floor(Date.now() / 1000);
+}
+
+export function resolveBaseDir(payload) {
+  if (typeof payload?.cwd === "string" && payload.cwd.trim()) return payload.cwd;
+  if (typeof payload?.directory === "string" && payload.directory.trim()) return payload.directory;
+  return process.cwd();
+}
+
+export function shouldTrackPath(filePath) {
+  if (typeof filePath !== "string" || !filePath.trim()) return false;
+
+  const lower = filePath.toLowerCase();
+  if (lower.startsWith(".omc/") || lower.startsWith(".claude/")) return false;
+  if (lower === "package-lock.json" || lower.endsWith("/package-lock.json")) return false;
+  if (/\.(md|lock|yml|yaml)$/i.test(lower)) return false;
+  return true;
+}
+
+export function expectedReviewer(author) {
+  if (author === "claude") return "codex";
+  if (author === "codex") return "claude";
+  if (author === "gemini") return "claude";
+  return "";
+}

package/scripts/lib/env-probe.mjs

@@ -0,0 +1,241 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join, dirname } from "node:path";
+import { homedir } from "node:os";
+import { execSync, spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { createHash } from "node:crypto";
+import { whichCommand, whichCommandAsync } from "../../hub/platform.mjs";
+
+const DEFAULT_STATUS_URL = "http://127.0.0.1:27888/status";
+const _sab = new Int32Array(new SharedArrayBuffer(4));
+const CLI_PROBE_CACHE = new Map();
+const CLI_PROBE_PROMISES = new Map();
+
+const __filename = fileURLToPath(import.meta.url);
+const DEFAULT_PKG_ROOT = join(dirname(__filename), "..", "..");
+
+function sleepSync(ms) {
+  Atomics.wait(_sab, 0, 0, ms);
+}
+
+function fetchHubStatus({
+  execSyncFn = execSync,
+  statusUrl = DEFAULT_STATUS_URL,
+  timeout = 3000,
+} = {}) {
+  const response = execSyncFn(`curl -sf ${statusUrl}`, {
+    timeout,
+    encoding: "utf8",
+    windowsHide: true,
+  });
+  const data = JSON.parse(response);
+  return {
+    ok: true,
+    state: data?.hub?.state || "unknown",
+    pid: data?.pid,
+  };
+}
+
+function normalizeCliName(name) {
+  return String(name ?? "").trim() || null;
+}
+
+function toCliResult(path) {
+  return path ? { ok: true, path } : { ok: false };
+}
+
+function cloneCliResult(result) {
+  return result?.ok ? { ...result } : { ok: false };
+}
+
+function readCachedCliResult(name) {
+  const cached = CLI_PROBE_CACHE.get(name);
+  return cached ? cloneCliResult(cached) : null;
+}
+
+function storeCliResult(name, result) {
+  const snapshot = cloneCliResult(result);
+  CLI_PROBE_CACHE.set(name, snapshot);
+  return cloneCliResult(snapshot);
+}
+
+function buildCliProbeOptions(options = {}) {
+  return {
+    timeout: options.timeout ?? 2000,
+    env: options.env,
+    cwd: options.cwd,
+    platform: options.platform,
+  };
+}
+
+function normalizeCliNames(names) {
+  return [...new Set((names || []).map(normalizeCliName).filter(Boolean))];
+}
+
+function mapCliResults(names, results) {
+  return names.reduce((acc, name, index) => ({
+    ...acc,
+    [name]: results[index],
+  }), {});
+}
+
+async function resolveCliProbe(name, options = {}) {
+  const path = await (options.whichCommandAsyncFn || whichCommandAsync)(name, {
+    ...buildCliProbeOptions(options),
+    execFileFn: options.execFileFn,
+  });
+  return toCliResult(path);
+}
+
+export async function checkCli(name, options = {}) {
+  const cliName = normalizeCliName(name);
+  if (!cliName) return { ok: false };
+
+  const cached = readCachedCliResult(cliName);
+  if (cached) return cached;
+
+  const pending = CLI_PROBE_PROMISES.get(cliName);
+  if (pending) return pending.then(cloneCliResult);
+
+  const nextProbe = resolveCliProbe(cliName, options)
+    .then((result) => storeCliResult(cliName, result))
+    .catch(() => storeCliResult(cliName, { ok: false }))
+    .finally(() => {
+      CLI_PROBE_PROMISES.delete(cliName);
+    });
+
+  CLI_PROBE_PROMISES.set(cliName, nextProbe);
+  return nextProbe.then(cloneCliResult);
+}
+
+export function checkCliSync(name, options = {}) {
+  const cliName = normalizeCliName(name);
+  if (!cliName) return { ok: false };
+
+  const cached = readCachedCliResult(cliName);
+  if (cached) return cached;
+
+  const path = (options.whichCommandFn || whichCommand)(cliName, buildCliProbeOptions(options));
+  return storeCliResult(cliName, toCliResult(path));
+}
+
+export async function probeClis(names, options = {}) {
+  const cliNames = normalizeCliNames(names);
+  const results = await Promise.all(cliNames.map((name) => checkCli(name, options)));
+  return mapCliResults(cliNames, results);
+}
+
+export function resetCliProbeCache() {
+  CLI_PROBE_CACHE.clear();
+  CLI_PROBE_PROMISES.clear();
+}
+
+export function detectCodexAuthState({
+  homeDir = homedir(),
+  existsSyncFn = existsSync,
+  readFileSyncFn = readFileSync,
+} = {}) {
+  try {
+    const authPath = join(homeDir, ".codex", "auth.json");
+    if (!existsSyncFn(authPath)) return { plan: "unknown", source: "no_auth", fingerprint: "no_auth" };
+
+    const auth = JSON.parse(readFileSyncFn(authPath, "utf8"));
+    if (auth.auth_mode !== "chatgpt") {
+      const fingerprint = createHash("sha256")
+        .update(JSON.stringify({
+          auth_mode: auth.auth_mode || "api_key",
+          has_api_key: Boolean(auth.api_key || auth.apiKey),
+        }))
+        .digest("hex");
+      return { plan: "api", source: "api_key", fingerprint };
+    }
+
+    const token = auth.tokens?.id_token || auth.tokens?.access_token;
+    if (!token) {
+      return {
+        plan: "unknown",
+        source: "no_token",
+        fingerprint: createHash("sha256")
+          .update(JSON.stringify({ auth_mode: auth.auth_mode || "chatgpt", token: null }))
+          .digest("hex"),
+      };
+    }
+
+    const payload = JSON.parse(Buffer.from(token.split(".")[1], "base64url").toString());
+    const plan = payload?.["https://api.openai.com/auth"]?.chatgpt_plan_type || "unknown";
+    const fingerprint = createHash("sha256")
+      .update(JSON.stringify({
+        auth_mode: auth.auth_mode || "chatgpt",
+        plan,
+        sub: payload?.sub || null,
+        exp: payload?.exp || null,
+      }))
+      .digest("hex");
+    return { plan, source: "jwt", fingerprint };
+  } catch {
+    return { plan: "unknown", source: "error", fingerprint: "error" };
+  }
+}
+
+export function detectCodexPlan(options = {}) {
+  const { plan, source } = detectCodexAuthState(options);
+  return { plan, source };
+}
+
+export function checkHub({
+  pkgRoot = DEFAULT_PKG_ROOT,
+  statusUrl = DEFAULT_STATUS_URL,
+  restart = true,
+  requestTimeoutMs = 3000,
+  pollAttempts = 8,
+  pollIntervalMs = 500,
+  execSyncFn = execSync,
+  spawnFn = spawn,
+  existsSyncFn = existsSync,
+  sleepSyncFn = sleepSync,
+} = {}) {
+  try {
+    return fetchHubStatus({
+      execSyncFn,
+      statusUrl,
+      timeout: requestTimeoutMs,
+    });
+  } catch {}
+
+  if (!restart) return { ok: false, state: "unreachable", restart: "disabled" };
+
+  const serverPath = join(pkgRoot, "hub", "server.mjs");
+  if (!existsSyncFn(serverPath)) return { ok: false, state: "unreachable", restart: "no_server" };
+
+  try {
+    const child = spawnFn(process.execPath, [serverPath], {
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true,
+    });
+    child.unref();
+  } catch {
+    return { ok: false, state: "unreachable", restart: "spawn_failed" };
+  }
+
+  for (let i = 0; i < pollAttempts; i++) {
+    sleepSyncFn(pollIntervalMs);
+    try {
+      const status = fetchHubStatus({
+        execSyncFn,
+        statusUrl,
+        timeout: Math.min(requestTimeoutMs, 1000),
+      });
+      if (status.state === "healthy") {
+        return { ...status, restarted: true };
+      }
+    } catch {}
+  }
+
+  return { ok: false, state: "unreachable", restart: "timeout" };
+}
+
+export {
+  DEFAULT_PKG_ROOT,
+  DEFAULT_STATUS_URL,
+};

package/scripts/lib/gemini-profiles.mjs

@@ -0,0 +1,85 @@
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+
+const DEFAULT_GEMINI_PROFILES = {
+  model: "gemini-3.1-pro-preview",
+  profiles: {
+    pro31: { model: "gemini-3.1-pro-preview", hint: "3.1 Pro — 플래그십 (1M ctx, 멀티모달)" },
+    flash3: { model: "gemini-3-flash-preview", hint: "3.0 Flash — 빠른 응답, 비용 효율" },
+    pro25: { model: "gemini-2.5-pro", hint: "2.5 Pro — 안정 (추론 강화)" },
+    flash25: { model: "gemini-2.5-flash", hint: "2.5 Flash — 경량 범용" },
+    lite25: { model: "gemini-2.5-flash-lite", hint: "2.5 Flash Lite — 최경량" },
+  },
+};
+
+const DEFAULT_PROFILE_COUNT = Object.keys(DEFAULT_GEMINI_PROFILES.profiles).length;
+
+function ensureGeminiProfiles({
+  geminiDir = join(homedir(), ".gemini"),
+  profilesPath = join(geminiDir, "triflux-profiles.json"),
+} = {}) {
+  try {
+    if (!existsSync(geminiDir)) mkdirSync(geminiDir, { recursive: true });
+
+    if (!existsSync(profilesPath)) {
+      writeFileSync(profilesPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+      return {
+        ok: true,
+        created: true,
+        added: DEFAULT_PROFILE_COUNT,
+        count: DEFAULT_PROFILE_COUNT,
+        message: null,
+      };
+    }
+
+    let cfg;
+    try {
+      cfg = JSON.parse(readFileSync(profilesPath, "utf8"));
+    } catch {
+      try { copyFileSync(profilesPath, profilesPath + `.bak.${Date.now()}`); } catch {}
+      writeFileSync(profilesPath, JSON.stringify(DEFAULT_GEMINI_PROFILES, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+      return {
+        ok: true,
+        created: true,
+        added: DEFAULT_PROFILE_COUNT,
+        count: DEFAULT_PROFILE_COUNT,
+        message: null,
+      };
+    }
+
+    if (!cfg || typeof cfg !== "object" || Array.isArray(cfg)) cfg = {};
+    if (!cfg.profiles || typeof cfg.profiles !== "object" || Array.isArray(cfg.profiles)) cfg.profiles = {};
+
+    let added = 0;
+    for (const [name, value] of Object.entries(DEFAULT_GEMINI_PROFILES.profiles)) {
+      if (!cfg.profiles[name]) {
+        cfg.profiles[name] = value;
+        added++;
+      }
+    }
+    if (!cfg.model) cfg.model = DEFAULT_GEMINI_PROFILES.model;
+
+    if (added > 0) {
+      writeFileSync(profilesPath, JSON.stringify(cfg, null, 2) + "\n", { encoding: "utf8", mode: 0o600 });
+    }
+
+    return {
+      ok: true,
+      created: false,
+      added,
+      count: Object.keys(cfg.profiles).length,
+      message: null,
+    };
+  } catch (error) {
+    return {
+      ok: false,
+      created: false,
+      added: 0,
+      count: 0,
+      message: error.message,
+    };
+  }
+}
+
+export { DEFAULT_GEMINI_PROFILES, ensureGeminiProfiles };

package/scripts/lib/hook-utils.mjs

@@ -0,0 +1,14 @@
+export function nudge(message) {
+  process.stdout.write(JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: "PreToolUse",
+      additionalContext: message,
+    },
+  }));
+  process.exit(0);
+}
+
+export function deny(reason) {
+  process.stderr.write(reason);
+  process.exit(2);
+}

package/scripts/lib/keyword-rules.mjs

@@ -0,0 +1,166 @@
+import { readFileSync } from "node:fs";
+
+const VALID_MCP_ROUTES = new Set(["codex", "gemini", "claude"]);
+
+function logRuleError(message, error) {
+  if (error) {
+    console.error(`[triflux-keyword-rules] ${message}: ${error.message}`);
+    return;
+  }
+  console.error(`[triflux-keyword-rules] ${message}`);
+}
+
+function normalizePattern(pattern) {
+  if (!pattern || typeof pattern.source !== "string") return null;
+  if (typeof pattern.flags !== "string") return null;
+  return { source: pattern.source, flags: pattern.flags };
+}
+
+function normalizeState(state) {
+  if (state == null) return null;
+  if (typeof state !== "object") return null;
+  if (typeof state.activate !== "boolean") return null;
+  if (typeof state.name !== "string" || !state.name.trim()) return null;
+  return { activate: state.activate, name: state.name.trim() };
+}
+
+function normalizeRule(rule) {
+  if (!rule || typeof rule !== "object") return null;
+  if (typeof rule.id !== "string" || !rule.id.trim()) return null;
+  if (!Array.isArray(rule.patterns) || rule.patterns.length === 0) return null;
+  if (typeof rule.priority !== "number" || !Number.isFinite(rule.priority)) return null;
+
+  const patterns = rule.patterns.map(normalizePattern).filter(Boolean);
+  if (patterns.length === 0) return null;
+
+  const skill = typeof rule.skill === "string" && rule.skill.trim() ? rule.skill.trim() : null;
+  const action = typeof rule.action === "string" && rule.action.trim() ? rule.action.trim() : null;
+  const mcpRoute = typeof rule.mcp_route === "string" && VALID_MCP_ROUTES.has(rule.mcp_route)
+    ? rule.mcp_route
+    : null;
+
+  if (!skill && !mcpRoute && !action) return null;
+
+  const supersedes = Array.isArray(rule.supersedes)
+    ? rule.supersedes.filter((id) => typeof id === "string" && id.trim()).map((id) => id.trim())
+    : [];
+
+  const state = normalizeState(rule.state);
+  if (rule.state != null && state == null) return null;
+
+  return {
+    id: rule.id.trim(),
+    patterns,
+    skill,
+    action,
+    priority: rule.priority,
+    supersedes,
+    exclusive: rule.exclusive === true,
+    state,
+    mcp_route: mcpRoute
+  };
+}
+
+// 외부 JSON 규칙 로드 + 스키마 검증
+export function loadRules(rulesPath) {
+  try {
+    const raw = readFileSync(rulesPath, "utf8");
+    const parsed = JSON.parse(raw);
+    if (!parsed || !Array.isArray(parsed.rules)) {
+      logRuleError(`규칙 형식이 올바르지 않습니다: ${rulesPath}`);
+      return [];
+    }
+
+    const normalized = parsed.rules.map(normalizeRule).filter(Boolean);
+    return normalized;
+  } catch (error) {
+    logRuleError(`규칙 파일을 읽을 수 없습니다: ${rulesPath}`, error);
+    return [];
+  }
+}
+
+// pattern.source / flags를 RegExp로 컴파일
+export function compileRules(rules) {
+  return rules.map((rule) => {
+    try {
+      return { ...rule, compiledPatterns: rule.patterns.map((p) => new RegExp(p.source, p.flags)) };
+    } catch (error) {
+      logRuleError(`정규식 컴파일 실패: ${rule.id}`, error);
+      return null;
+    }
+  }).filter(Boolean);
+}
+
+// 입력 텍스트에서 매칭된 규칙 목록 반환
+export function matchRules(compiledRules, cleanText) {
+  if (!Array.isArray(compiledRules) || typeof cleanText !== "string" || !cleanText) {
+    return [];
+  }
+
+  const matches = [];
+
+  for (const rule of compiledRules) {
+    if (!Array.isArray(rule.compiledPatterns) || rule.compiledPatterns.length === 0) {
+      continue;
+    }
+
+    const matched = rule.compiledPatterns.some((pattern) => {
+      pattern.lastIndex = 0;
+      return pattern.test(cleanText);
+    });
+
+    if (!matched) continue;
+
+    matches.push({
+      id: rule.id,
+      skill: rule.skill,
+      action: rule.action,
+      priority: rule.priority,
+      supersedes: rule.supersedes || [],
+      exclusive: rule.exclusive === true,
+      state: rule.state || null,
+      mcp_route: rule.mcp_route || null
+    });
+  }
+
+  return matches;
+}
+
+// priority 정렬 + supersedes + exclusive 처리
+export function resolveConflicts(matches) {
+  try {
+    if (!Array.isArray(matches) || matches.length === 0) return [];
+
+    const sorted = [...matches].sort((a, b) => {
+      if (a.priority !== b.priority) return a.priority - b.priority;
+      return String(a.id).localeCompare(String(b.id));
+    });
+
+    const deduped = [];
+    const seen = new Set();
+    for (const match of sorted) {
+      if (seen.has(match.id)) continue;
+      deduped.push(match);
+      seen.add(match.id);
+    }
+
+    const superseded = new Set();
+    const resolved = [];
+
+    for (const match of deduped) {
+      if (superseded.has(match.id)) continue;
+      resolved.push(match);
+      for (const targetId of match.supersedes || []) {
+        superseded.add(targetId);
+      }
+    }
+
+    const exclusiveMatch = resolved.find((match) => match.exclusive === true);
+    if (exclusiveMatch) return [exclusiveMatch];
+
+    return resolved;
+  } catch (error) {
+    logRuleError("규칙 충돌 해결 실패", error);
+    return [];
+  }
+}