@triflux/core 10.50.1 → 10.50.2

package/hub/quality/deslop.mjs

@@ -1,274 +0,0 @@
-/**
- * Anti-Slop Code Pass
- * AI 생성 코드에서 불필요한 요소를 자동 탐지/제거하는 정적 분석 모듈
- */
-
-import { readdir, readFile, stat, writeFile } from "node:fs/promises";
-import { join } from "node:path";
-
-/** @type {ReadonlyArray<{type: string, pattern: RegExp, severity: string, autoFixable: boolean, multiline: boolean}>} */
-export const SLOP_PATTERNS = Object.freeze([
-  {
-    type: "trivial_comment",
-    pattern: /^\s*\/\/\s*(import|define|set|get|return|export)\s/i,
-    severity: "low",
-    autoFixable: true,
-    multiline: false,
-  },
-  {
-    type: "empty_catch",
-    pattern: /catch\s*\([^)]*\)\s*\{\s*\}/,
-    severity: "med",
-    autoFixable: false,
-    multiline: true,
-  },
-  {
-    type: "console_debug",
-    pattern: /^\s*console\.(log|debug|info)\(/,
-    severity: "low",
-    autoFixable: true,
-    multiline: false,
-  },
-  {
-    type: "useless_jsdoc",
-    pattern: /\/\*\*\s*\n\s*\*\s*\n\s*\*\//,
-    severity: "low",
-    autoFixable: true,
-    multiline: true,
-  },
-  {
-    type: "rethrow_only",
-    pattern: /catch\s*\((\w+)\)\s*\{\s*throw\s+\1\s*;?\s*\}/,
-    severity: "med",
-    autoFixable: false,
-    multiline: true,
-  },
-  {
-    type: "redundant_type",
-    pattern:
-      /:\s*(string|number|boolean)\s*=\s*('[^']*'|"[^"]*"|\d+|true|false)/,
-    severity: "low",
-    autoFixable: false,
-    multiline: false,
-  },
-  {
-    type: "commented_code",
-    pattern:
-      /^\s*\/\/\s*(const |let |var |function |class |if\s*\(|for\s*\(|while\s*\(|return |await )/,
-    severity: "low",
-    autoFixable: true,
-    multiline: false,
-  },
-]);
-
-const SEVERITY_WEIGHT = { low: 2, med: 5 };
-
-/**
- * 파일 내용에서 slop 패턴 탐지
- * @param {string} content - 파일 내용
- * @param {string} [filePath] - 파일 경로 (보고용)
- * @returns {{ issues: Array<{line: number, type: string, severity: string, suggestion: string, text: string, autoFixable: boolean}>, score: number }}
- */
-export function detectSlop(content, filePath = "") {
-  const lines = content.split("\n");
-  const issues = [];
-
-  for (const sp of SLOP_PATTERNS) {
-    if (sp.multiline) continue;
-    for (let i = 0; i < lines.length; i++) {
-      if (sp.pattern.test(lines[i])) {
-        issues.push({
-          line: i + 1,
-          type: sp.type,
-          severity: sp.severity,
-          suggestion: `${sp.type} 패턴 감지`,
-          text: lines[i].trim(),
-          autoFixable: sp.autoFixable,
-          file: filePath,
-        });
-      }
-    }
-  }
-
-  for (const sp of SLOP_PATTERNS) {
-    if (!sp.multiline) continue;
-    const regex = new RegExp(
-      sp.pattern.source,
-      sp.pattern.flags.replace("g", "") + "g",
-    );
-    let match;
-    while ((match = regex.exec(content)) !== null) {
-      const line = content.substring(0, match.index).split("\n").length;
-      issues.push({
-        line,
-        type: sp.type,
-        severity: sp.severity,
-        suggestion: `${sp.type} 패턴 감지`,
-        text: match[0].split("\n")[0].trim(),
-        autoFixable: sp.autoFixable,
-        file: filePath,
-      });
-    }
-  }
-
-  issues.sort((a, b) => a.line - b.line);
-
-  const totalPenalty = issues.reduce(
-    (sum, i) => sum + (SEVERITY_WEIGHT[i.severity] || 2),
-    0,
-  );
-  const score = Math.max(0, 100 - totalPenalty);
-
-  return { issues, score };
-}
-
-/**
- * 자동 수정 (safe transforms만)
- * @param {string} content - 파일 내용
- * @param {Array<{type: string, autoFixable: boolean}>} issues - detectSlop 결과
- * @returns {{ fixed: string, applied: number, skipped: number }}
- */
-export function autoFixSlop(content, issues) {
-  if (!issues || issues.length === 0)
-    return { fixed: content, applied: 0, skipped: 0 };
-
-  const fixable = issues.filter((i) => i.autoFixable);
-  const skipped = issues.length - fixable.length;
-
-  if (fixable.length === 0) return { fixed: content, applied: 0, skipped };
-
-  let fixed = content;
-  let applied = 0;
-
-  // Multi-line: useless_jsdoc 제거
-  if (fixable.some((i) => i.type === "useless_jsdoc")) {
-    const matches = fixed.match(/\/\*\*\s*\n\s*\*\s*\n\s*\*\/\n?/g);
-    if (matches) {
-      fixed = fixed.replace(/\/\*\*\s*\n\s*\*\s*\n\s*\*\/\n?/g, "");
-      applied += matches.length;
-    }
-  }
-
-  // Line-level: trivial_comment, console_debug, commented_code 제거
-  const lineTypes = new Set(
-    fixable
-      .filter((i) =>
-        ["trivial_comment", "console_debug", "commented_code"].includes(i.type),
-      )
-      .map((i) => i.type),
-  );
-
-  if (lineTypes.size > 0) {
-    const linePatterns = SLOP_PATTERNS.filter((p) => lineTypes.has(p.type));
-    const lines = fixed.split("\n");
-    const result = [];
-    for (const line of lines) {
-      let remove = false;
-      for (const p of linePatterns) {
-        if (p.pattern.test(line)) {
-          remove = true;
-          applied++;
-          break;
-        }
-      }
-      if (!remove) result.push(line);
-    }
-    fixed = result.join("\n");
-  }
-
-  return { fixed, applied, skipped };
-}
-
-function matchesGlob(filePath, pattern) {
-  const normalized = "/" + filePath.replace(/\\/g, "/");
-
-  // **/*.ext → 확장자 매칭
-  if (pattern.startsWith("**/*.")) {
-    const ext = pattern.slice(4);
-    return normalized.endsWith(ext);
-  }
-
-  // *.ext → 확장자 매칭 (디렉토리 무관)
-  if (pattern.startsWith("*.") && !pattern.includes("/")) {
-    const ext = pattern.slice(1);
-    return normalized.endsWith(ext);
-  }
-
-  // **/dir/** → 디렉토리 포함 여부
-  const dirMatch = pattern.match(/^\*\*\/([^*]+)\/\*\*$/);
-  if (dirMatch) {
-    return normalized.includes("/" + dirMatch[1] + "/");
-  }
-
-  return false;
-}
-
-/**
- * 디렉토리 전체 스캔
- * @param {string} dirPath - 스캔 대상 디렉토리
- * @param {object} [opts]
- * @param {string[]} [opts.include] - 포함할 glob 패턴
- * @param {string[]} [opts.exclude] - 제외할 glob 패턴
- * @param {boolean} [opts.autoFix] - 자동 수정 여부
- * @returns {Promise<{ files: Array<{path: string, issues: Array, score: number}>, summary: object }>}
- */
-export async function scanDirectory(dirPath, opts = {}) {
-  const {
-    include = ["**/*.mjs", "**/*.js", "**/*.ts"],
-    exclude = ["**/node_modules/**", "**/dist/**", "**/.git/**"],
-    autoFix = false,
-  } = opts;
-
-  const entries = await readdir(dirPath, { recursive: true });
-  const files = [];
-
-  for (const entry of entries) {
-    const normalized = entry.replace(/\\/g, "/");
-    const fullPath = join(dirPath, entry);
-
-    let st;
-    try {
-      st = await stat(fullPath);
-    } catch {
-      continue;
-    }
-    if (!st.isFile()) continue;
-
-    const included = include.some((p) => matchesGlob(normalized, p));
-    const excluded = exclude.some((p) => matchesGlob(normalized, p));
-    if (!included || excluded) continue;
-
-    const fileContent = await readFile(fullPath, "utf-8");
-    const { issues, score } = detectSlop(fileContent, normalized);
-
-    if (autoFix && issues.length > 0) {
-      const { fixed, applied } = autoFixSlop(fileContent, issues);
-      if (applied > 0) await writeFile(fullPath, fixed, "utf-8");
-    }
-
-    files.push({ path: normalized, issues, score });
-  }
-
-  const totalIssues = files.reduce((sum, f) => sum + f.issues.length, 0);
-  const avgScore =
-    files.length > 0
-      ? Math.round(files.reduce((sum, f) => sum + f.score, 0) / files.length)
-      : 100;
-
-  const byType = {};
-  for (const f of files) {
-    for (const issue of f.issues) {
-      byType[issue.type] = (byType[issue.type] || 0) + 1;
-    }
-  }
-
-  return {
-    files,
-    summary: {
-      totalFiles: files.length,
-      totalIssues,
-      averageScore: avgScore,
-      byType,
-    },
-  };
-}

package/hub/research.mjs

@@ -1,155 +0,0 @@
-// hub/research.mjs — 자율 웹 리서치 엔진 코어
-// 검색 쿼리 생성 → 결과 정규화 → 보고서 빌드 → 저장
-
-import { mkdirSync, writeFileSync } from "node:fs";
-import { join, resolve } from "node:path";
-import { TFX_REPORTS_DIR } from "./paths.mjs";
-
-/**
- * @experimental 런타임 미연결 — 향후 통합 예정
- * @experimental
- * 주제에서 검색 쿼리 3-5개를 자동 생성한다.
- * 한국어 주제 → 한국어 + 영어 혼합, 영어 주제 → 영어 쿼리.
- * @param {string} topic - 리서치 주제
- * @param {'ko'|'en'|'auto'} [lang='auto'] - 언어 힌트
- * @returns {string[]} 검색 쿼리 배열
- */
-export function generateQueries(topic, lang = "auto") {
-  if (!topic || typeof topic !== "string" || !topic.trim()) return [];
-
-  const t = topic.trim();
-  const detectedLang = lang === "auto" ? detectLang(t) : lang;
-
-  if (detectedLang === "ko") {
-    return [
-      `${t} 정리`,
-      `${t} 비교 분석`,
-      `${t} 최신 동향 ${new Date().getFullYear()}`,
-      `${toEnglishQuery(t)} overview`,
-      `${toEnglishQuery(t)} comparison ${new Date().getFullYear()}`,
-    ];
-  }
-
-  return [
-    `${t} overview`,
-    `${t} comparison`,
-    `${t} best practices ${new Date().getFullYear()}`,
-    `${t} pros and cons`,
-  ];
-}
-
-/**
- * 검색 원시 결과를 정규화한다. 중복 URL 제거 + 빈/null 필터링.
- * @param {Array<object|null|undefined>} rawResults - 검색 엔진 원시 결과
- * @returns {Array<{title: string, url: string, snippet: string}>}
- */
-export function normalizeResults(rawResults) {
-  if (!Array.isArray(rawResults)) return [];
-
-  const seen = new Set();
-  const out = [];
-
-  for (const r of rawResults) {
-    if (!r || typeof r !== "object") continue;
-    const url = (r.url || r.link || "").trim();
-    const title = (r.title || r.name || "").trim();
-    const snippet = (r.snippet || r.description || r.content || "").trim();
-
-    if (!url || seen.has(url)) continue;
-    seen.add(url);
-    out.push({ title, url, snippet });
-  }
-
-  return out;
-}
-
-/**
- * 리서치 보고서를 마크다운으로 빌드한다.
- * @param {string} topic - 리서치 주제
- * @param {string[]} findings - 핵심 발견 목록
- * @param {Array<{title: string, url: string, snippet: string}>} sources - 출처 목록
- * @returns {string} 마크다운 문자열
- */
-export function buildReport(topic, findings, sources) {
-  const date = new Date().toISOString().split("T")[0];
-  const findingsSection = (findings || [])
-    .map((f, i) => `${i + 1}. ${f}`)
-    .join("\n");
-  const sourcesSection = (sources || [])
-    .map(
-      (s) =>
-        `- [${s.title || s.url}](${s.url})${s.snippet ? ` — ${s.snippet}` : ""}`,
-    )
-    .join("\n");
-
-  return `# Research: ${topic}
-Date: ${date}
-
-## Executive Summary
-${topic}에 대한 자동 리서치 결과입니다.
-
-## Key Findings
-${findingsSection || "_발견 없음_"}
-
-## Actionable Recommendations
-리서치 결과를 바탕으로 다음 단계를 검토하세요.
-
-## Sources
-${sourcesSection || "_출처 없음_"}
-`;
-}
-
-/**
- * 보고서를 .tfx/reports/research-{timestamp}.md에 저장한다.
- * @param {string} topic - 리서치 주제 (파일명 생성용)
- * @param {string} content - 마크다운 보고서 내용
- * @param {string} [baseDir=process.cwd()] - 프로젝트 루트 경로
- * @returns {string} 저장된 파일 경로
- */
-export function saveReport(topic, content, baseDir = process.cwd()) {
-  const dir = join(baseDir, TFX_REPORTS_DIR);
-  const resolvedDir = resolve(dir);
-  const expectedBase = resolve(baseDir || TFX_REPORTS_DIR);
-  if (!resolvedDir.startsWith(expectedBase)) {
-    throw new Error("Invalid report directory: path traversal detected");
-  }
-  mkdirSync(dir, { recursive: true });
-
-  const ts = new Date()
-    .toISOString()
-    .replace(/[:.]/g, "-")
-    .replace("T", "_")
-    .slice(0, 19);
-  const slug = (topic || "untitled")
-    .replace(/[^a-zA-Z0-9가-힣\s-]/g, "")
-    .replace(/\s+/g, "-")
-    .slice(0, 40)
-    .toLowerCase();
-  const filename = `research-${ts}-${slug}.md`;
-  const filepath = join(dir, filename);
-
-  writeFileSync(filepath, content, "utf-8");
-  return filepath;
-}
-
-// ── internal helpers ──
-
-/**
- * 텍스트에 한글이 포함되어 있으면 'ko', 아니면 'en'
- * @param {string} text
- * @returns {'ko'|'en'}
- */
-function detectLang(text) {
-  return /[가-힣]/.test(text) ? "ko" : "en";
-}
-
-/**
- * 한국어 토픽에서 영어 검색 쿼리용 문자열 추출.
- * 영문/숫자만 남기고, 없으면 원문 그대로 반환.
- * @param {string} text
- * @returns {string}
- */
-function toEnglishQuery(text) {
-  const eng = text.replace(/[가-힣\s]+/g, " ").trim();
-  return eng || text;
-}

package/hub/role-control-events.mjs

@@ -1,113 +0,0 @@
-const EVENT_NAMES = new Set(["capability.degraded", "drift.detected"]);
-const CONTROL_ACTIONS = new Set([
-  "log_only",
-  "candidate_exclude",
-  "adapter_disable",
-  "role_failover",
-  "dispatch_block",
-  "manager_disable",
-]);
-const OPTIONAL_FIELDS = [
-  "project_id",
-  "role_key_wire",
-  "candidate_agent_id",
-  "transport_id",
-  "capability",
-  "expected_version",
-  "observed_version",
-  "trace_id",
-  "error_code",
-];
-
-export const ROLE_CONTROL_EVENT_SCHEMA_VERSION = "tfx.role-control-event.v1";
-export const ROLE_CONTROL_EVENT_FIELDS = Object.freeze([
-  "schema_version",
-  "event",
-  "event_id",
-  "module",
-  "dur_ms",
-  "control_action",
-  "reason_code",
-  ...OPTIONAL_FIELDS,
-]);
-
-function eventError(code, message = code) {
-  const error = new Error(message);
-  error.code = code;
-  return error;
-}
-
-function defaultEventId() {
-  return (
-    globalThis.crypto?.randomUUID?.() ??
-    `evt_${Math.random().toString(36).slice(2)}`
-  );
-}
-
-function validateRequired(event) {
-  if (!EVENT_NAMES.has(event.event))
-    throw eventError("ROLE_CONTROL_EVENT_INVALID");
-  if (typeof event.event_id !== "string" || !event.event_id) {
-    throw eventError("ROLE_CONTROL_EVENT_REQUIRED");
-  }
-  if (typeof event.module !== "string" || !event.module) {
-    throw eventError("ROLE_CONTROL_EVENT_REQUIRED");
-  }
-  if (!Number.isFinite(event.dur_ms) || event.dur_ms < 0) {
-    throw eventError("ROLE_CONTROL_EVENT_REQUIRED");
-  }
-  if (!CONTROL_ACTIONS.has(event.control_action)) {
-    throw eventError("ROLE_CONTROL_EVENT_REQUIRED");
-  }
-  if (typeof event.reason_code !== "string" || !event.reason_code) {
-    throw eventError("ROLE_CONTROL_EVENT_REQUIRED");
-  }
-}
-
-/**
- * Build an allowlisted event object. Unknown domain fields are intentionally
- * discarded before the event reaches a logger.
- */
-export function buildRoleControlEvent(
-  input = {},
-  { eventId = defaultEventId } = {},
-) {
-  const event = {
-    schema_version: ROLE_CONTROL_EVENT_SCHEMA_VERSION,
-    event: input.event,
-    event_id: input.event_id ?? eventId(),
-    module: input.module,
-    dur_ms: input.dur_ms,
-    control_action: input.control_action,
-    reason_code: input.reason_code,
-  };
-  for (const field of OPTIONAL_FIELDS) {
-    if (input[field] !== undefined) event[field] = input[field];
-  }
-  validateRequired(event);
-  return event;
-}
-
-export function buildCapabilityDegradedEvent(input = {}, options = {}) {
-  return buildRoleControlEvent(
-    { ...input, event: "capability.degraded" },
-    options,
-  );
-}
-
-export function buildDriftDetectedEvent(input = {}, options = {}) {
-  return buildRoleControlEvent({ ...input, event: "drift.detected" }, options);
-}
-
-/**
- * Pino-style loggers receive event as an object field and as the message.
- */
-export function emitRoleControlEvent(log, event, level = "warn") {
-  if (!log || typeof log[level] !== "function") {
-    throw eventError("ROLE_CONTROL_LOGGER_INVALID");
-  }
-  const sanitized = buildRoleControlEvent(event, {
-    eventId: () => event?.event_id,
-  });
-  log[level](sanitized, sanitized.event);
-}