triflux 10.0.0 → 10.0.2

package/scripts/lib/handoff.mjs

@@ -0,0 +1,171 @@
+import { execSync } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { basename, resolve } from "node:path";
+import { findAllClaudeMdPaths } from "./claudemd-scanner.mjs";
+
+function runCommand(command, cwd, executor = execSync) {
+  try {
+    const output = executor(command, {
+      cwd,
+      encoding: "utf8",
+      stdio: ["ignore", "pipe", "ignore"],
+      windowsHide: true,
+    });
+    return String(output || "").trimEnd();
+  } catch {
+    return "";
+  }
+}
+
+function parseStatusLines(statusText) {
+  const lines = String(statusText || "").split(/\r?\n/u).filter(Boolean);
+  const changedFiles = [];
+  const status = [];
+
+  for (const line of lines) {
+    const normalized = line.trimEnd();
+    if (!normalized) continue;
+
+    const rawStatus = normalized.slice(0, 2).trim() || "??";
+    const rawPath = normalized.slice(3).trim();
+    const filePath = rawPath.includes(" -> ") ? rawPath.split(" -> ").at(-1)?.trim() : rawPath;
+    if (!filePath) continue;
+
+    changedFiles.push(filePath);
+    status.push({ path: filePath, status: rawStatus });
+  }
+
+  return {
+    changedFiles: Array.from(new Set(changedFiles)),
+    status,
+  };
+}
+
+function normalizeDecisionLine(line) {
+  return String(line || "")
+    .trim()
+    .replace(/^[-*]\s+/u, "")
+    .trim();
+}
+
+function parseDecisionFile(decisionFile) {
+  if (!decisionFile) return [];
+  const absolute = resolve(decisionFile);
+  if (!existsSync(absolute)) return [];
+
+  const raw = readFileSync(absolute, "utf8");
+  return raw
+    .split(/\r?\n/u)
+    .map(normalizeDecisionLine)
+    .filter((line) => line.length > 0);
+}
+
+function normalizeDecisions(decisions, decisionFile) {
+  const merged = [
+    ...(Array.isArray(decisions) ? decisions : []),
+    ...parseDecisionFile(decisionFile),
+  ]
+    .map(normalizeDecisionLine)
+    .filter(Boolean);
+
+  return Array.from(new Set(merged));
+}
+
+function formatAheadBehind(value) {
+  if (!value) return null;
+  const [behindRaw, aheadRaw] = value.split(/\s+/u);
+  const behind = Number.parseInt(behindRaw, 10);
+  const ahead = Number.parseInt(aheadRaw, 10);
+  if (!Number.isFinite(behind) || !Number.isFinite(ahead)) return null;
+  return { ahead, behind };
+}
+
+export function collectHandoffContext(options = {}) {
+  const cwd = resolve(options.cwd || process.cwd());
+  const executor = typeof options.commandRunner === "function" ? options.commandRunner : execSync;
+  const target = options.target === "local" ? "local" : "remote";
+  const decisions = normalizeDecisions(options.decisions, options.decisionFile);
+  const generatedAt = options.generatedAt || new Date().toISOString();
+  const claudeMdPaths = Array.isArray(options.claudeMdPaths)
+    ? options.claudeMdPaths
+    : findAllClaudeMdPaths({
+      cwd,
+      homeDir: options.homeDir,
+    });
+
+  const gitRoot = runCommand("git rev-parse --show-toplevel", cwd, executor);
+  const branch = runCommand("git rev-parse --abbrev-ref HEAD", cwd, executor) || null;
+  const shortStatus = runCommand("git status --short", cwd, executor);
+  const diffStat = runCommand("git diff --stat --no-color", cwd, executor);
+  const upstreamRaw = runCommand("git rev-list --left-right --count @{upstream}...HEAD", cwd, executor);
+  const parsedStatus = parseStatusLines(shortStatus);
+
+  return {
+    generatedAt,
+    target,
+    cwd,
+    gitRoot: gitRoot || null,
+    repository: gitRoot ? basename(gitRoot) : basename(cwd),
+    branch,
+    upstream: formatAheadBehind(upstreamRaw),
+    changedFiles: parsedStatus.changedFiles,
+    fileStatus: parsedStatus.status,
+    diffStat,
+    decisions,
+    claudeMdPaths,
+  };
+}
+
+export function buildHandoffPrompt(context) {
+  const safeContext = context || collectHandoffContext();
+  const branch = safeContext.branch || "unknown";
+  const upstream = safeContext.upstream
+    ? `ahead ${safeContext.upstream.ahead}, behind ${safeContext.upstream.behind}`
+    : "unknown";
+  const changedFiles = safeContext.changedFiles.length > 0
+    ? safeContext.changedFiles.map((file) => `- ${file}`).join("\n")
+    : "- 변경 파일 없음";
+  const decisions = safeContext.decisions.length > 0
+    ? safeContext.decisions.map((decision) => `- ${decision}`).join("\n")
+    : "- 명시된 결정사항 없음";
+  const claudeMdList = Array.isArray(safeContext.claudeMdPaths) && safeContext.claudeMdPaths.length > 0
+    ? safeContext.claudeMdPaths.map((path) => `- ${path}`).join("\n")
+    : "- 자동 탐지된 CLAUDE.md 없음";
+  const diffStat = safeContext.diffStat || "(diff stat 없음)";
+
+  return [
+    "## TFX Remote Handoff",
+    `- generated_at: ${safeContext.generatedAt}`,
+    `- target: ${safeContext.target}`,
+    `- repository: ${safeContext.repository}`,
+    `- branch: ${branch} (${upstream})`,
+    `- cwd: ${safeContext.cwd}`,
+    "",
+    "### 변경 파일",
+    changedFiles,
+    "",
+    "### 변경 요약 (git diff --stat)",
+    "```",
+    diffStat,
+    "```",
+    "",
+    "### 결정사항",
+    decisions,
+    "",
+    "### CLAUDE.md 참조",
+    claudeMdList,
+    "",
+    "### 다음 세션 지시",
+    "- 위 변경사항을 먼저 검토하고 누락된 테스트를 확인하세요.",
+    "- 필요 시 CLAUDE.md 지침을 재확인한 뒤 작업을 이어가세요.",
+    "- 작업 완료 후 변경 파일과 검증 결과를 요약하세요.",
+  ].join("\n");
+}
+
+export function serializeHandoff(options = {}) {
+  const context = collectHandoffContext(options);
+  return {
+    ...context,
+    prompt: buildHandoffPrompt(context),
+  };
+}

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 [];
+  }
+}

package/scripts/lib/logger.mjs

@@ -0,0 +1,105 @@
+/**
+ * Logify — triflux 구조화 로깅 설정
+ *
+ * 사용법:
+ *   import { logger, createModuleLogger } from './lib/logger.mjs';
+ *
+ *   // 기본 로거
+ *   logger.info({ taskId: 'abc' }, 'task.started');
+ *
+ *   // 모듈별 로거
+ *   const log = createModuleLogger('hub');
+ *   log.info({ port: 27888 }, 'server.started');
+ *   log.error({ err }, 'server.error');
+ *
+ * 이벤트 네이밍: {도메인}.{액션} 형식
+ *   hub.started, hub.stopped, route.started, route.completed,
+ *   worker.spawned, worker.completed, worker.timeout,
+ *   mcp.connected, mcp.disconnected, mcp.error,
+ *   team.created, team.deleted, task.claimed, task.completed,
+ *   pipe.connected, pipe.message, pipe.error,
+ *   http.request, http.response, http.error
+ *
+ * 로그 레벨 가이드:
+ *   debug  — 개발/트러블슈팅용 (변수 값, MCP 메시지, 캐시 키)
+ *   info   — 정상 흐름 상태 변경 (서버 시작, 워커 완료, 팀 생성)
+ *   warn   — 위험 신호 (재시도 발생, 쿼타 임박, 느린 워커)
+ *   error  — 작업 실패 (CLI 실행 실패, MCP 연결 끊김)
+ *   fatal  — 프로세스 위협 (DB 연결 불가, 포트 충돌)
+ */
+import pino from 'pino';
+
+const isDev = process.env.NODE_ENV !== 'production';
+
+export const logger = pino({
+  level: process.env.LOG_LEVEL || (isDev ? 'debug' : 'info'),
+
+  // 모든 로그에 포함되는 기본 필드
+  base: {
+    service: process.env.SERVICE_NAME || 'triflux',
+    env: process.env.NODE_ENV || 'development',
+  },
+
+  // 레벨을 대문자로 출력 (AI 파싱 용이)
+  formatters: {
+    level: (label) => ({ level: label.toUpperCase() }),
+  },
+
+  // ISO 8601 타임스탬프
+  timestamp: pino.stdTimeFunctions.isoTime,
+
+  // 민감정보 자동 필터링
+  redact: {
+    paths: [
+      'password',
+      'token',
+      'apiKey',
+      'secret',
+      'authorization',
+      '*.password',
+      '*.token',
+      '*.apiKey',
+      '*.secret',
+      'req.headers.authorization',
+      'req.headers.cookie',
+      'hubToken',
+    ],
+    remove: true,
+  },
+
+  // 개발 환경: 컬러 콘솔 출력
+  transport: isDev
+    ? {
+        target: 'pino-pretty',
+        options: {
+          colorize: true,
+          translateTime: 'yyyy-mm-dd HH:MM:ss',
+          ignore: 'pid,hostname',
+        },
+      }
+    : undefined,
+});
+
+/**
+ * 모듈별 Child Logger 생성.
+ * 모듈 이름이 모든 로그에 자동 포함된다.
+ *
+ * @param {string} module — 모듈 이름 (hub, route, worker, mcp, team 등)
+ * @returns {import('pino').Logger}
+ */
+export function createModuleLogger(module) {
+  return logger.child({ module });
+}
+
+// 정상 종료 시 버퍼 flush 보장
+process.on('uncaughtException', (err) => {
+  logger.fatal({ err }, 'process.uncaught_exception');
+  logger.flush();
+  process.exit(1);
+});
+
+process.on('unhandledRejection', (reason) => {
+  logger.fatal({ reason: String(reason) }, 'process.unhandled_rejection');
+  logger.flush();
+  process.exit(1);
+});