@triflux/core 10.50.1 → 10.51.0

package/hub/pipeline/gates/consensus.mjs

@@ -1,106 +0,0 @@
-// hub/pipeline/gates/consensus.mjs — Consensus Quality Gate
-//
-// N개 결과의 합의도를 평가하여 5단계 분기 결정
-// proceed(>=90%) / proceed_warn(>=75%) / retry(<75%+재시도) / escalate(<75%+감독) / abort
-
-/** 단계별 합의 임계값 (%) */
-export const STAGE_THRESHOLDS = {
-  plan: 50,
-  define: 75,
-  execute: 75,
-  verify: 80,
-  security: 100,
-};
-
-/** 환경변수 기반 기본 임계값 (기본 75) */
-function getDefaultThreshold() {
-  const env =
-    typeof process !== "undefined" && process.env?.TRIFLUX_CONSENSUS_THRESHOLD;
-  if (env != null && env !== "") {
-    const parsed = Number(env);
-    if (!Number.isNaN(parsed) && parsed >= 0 && parsed <= 100) return parsed;
-  }
-  return 75;
-}
-
-/**
- * 성공률 기반 5단계 분기 결정
- * @param {number} successRate - 합의 성공률 (0-100)
- * @param {number} retryCount - 현재 재시도 횟수
- * @param {number} maxRetries - 최대 재시도 횟수
- * @param {string} [mode] - 실행 모드 ('supervised' | 기타)
- * @returns {'proceed' | 'proceed_warn' | 'retry' | 'escalate' | 'abort'}
- */
-export function evaluateQualityBranch(
-  successRate,
-  retryCount,
-  maxRetries,
-  mode,
-) {
-  if (successRate >= 90) return "proceed";
-  if (successRate >= 75) return "proceed_warn";
-
-  // <75%: 재시도 가능 여부에 따라 분기
-  if (retryCount < maxRetries) return "retry";
-  if (mode === "supervised") return "escalate";
-  return "abort";
-}
-
-/**
- * N개 결과의 합의도 평가
- * @param {Array<{ success: boolean }>} results - 평가 대상 결과 배열
- * @param {object} [options]
- * @param {string} [options.stage] - 파이프라인 단계 (STAGE_THRESHOLDS 키)
- * @param {number} [options.threshold] - 합의 임계값 직접 지정 (stage보다 우선)
- * @param {number} [options.retryCount=0] - 현재 재시도 횟수
- * @param {number} [options.maxRetries=2] - 최대 재시도 횟수
- * @param {string} [options.mode] - 실행 모드 ('supervised' 등)
- * @returns {{ successRate: number, threshold: number, decision: string, reasoning: string, results: Array }}
- */
-export function evaluateConsensus(results, options = {}) {
-  if (!Array.isArray(results) || results.length === 0) {
-    return {
-      successRate: 0,
-      threshold: options.threshold ?? getDefaultThreshold(),
-      decision: "abort",
-      reasoning: "평가 대상 결과가 없습니다.",
-      results: [],
-    };
-  }
-
-  const retryCount = options.retryCount ?? 0;
-  const maxRetries = options.maxRetries ?? 2;
-  const mode = options.mode;
-
-  // 임계값 결정: 직접 지정 > stage별 > 환경변수 > 기본 75
-  const threshold =
-    options.threshold ??
-    (options.stage && STAGE_THRESHOLDS[options.stage]) ??
-    getDefaultThreshold();
-
-  const successCount = results.filter((r) => r.success).length;
-  const successRate = Math.round((successCount / results.length) * 100);
-
-  const decision = evaluateQualityBranch(
-    successRate,
-    retryCount,
-    maxRetries,
-    mode,
-  );
-
-  const reasoningMap = {
-    proceed: `합의율 ${successRate}% (>= 90%): 전원 합의. 진행.`,
-    proceed_warn: `합의율 ${successRate}% (>= 75%): 부분 합의. 경고와 함께 진행.`,
-    retry: `합의율 ${successRate}% (< 75%): 재시도 ${retryCount + 1}/${maxRetries} 가능.`,
-    escalate: `합의율 ${successRate}% (< 75%): 감독 모드 에스컬레이션.`,
-    abort: `합의율 ${successRate}% (< 75%): 합의 실패. 중단.`,
-  };
-
-  return {
-    successRate,
-    threshold,
-    decision,
-    reasoning: reasoningMap[decision],
-    results,
-  };
-}

package/hub/pipeline/gates/index.mjs

@@ -1,9 +0,0 @@
-// hub/pipeline/gates/index.mjs — Quality Gates re-export
-
-export { CRITERIA, runConfidenceCheck } from "./confidence.mjs";
-export {
-  evaluateConsensus,
-  evaluateQualityBranch,
-  STAGE_THRESHOLDS,
-} from "./consensus.mjs";
-export { QUESTIONS, RED_FLAGS, runSelfCheck } from "./selfcheck.mjs";

package/hub/pipeline/gates/selfcheck.mjs

@@ -1,120 +0,0 @@
-// hub/pipeline/gates/selfcheck.mjs — Post-Execution Self-Check (Hallucination Detection)
-//
-// exec → verify → [selfcheck] → complete/fix
-// 4대 필수 질문 + 7대 할루시네이션 Red Flag 탐지
-
-export const RED_FLAGS = [
-  {
-    id: "test_pass_no_output",
-    pattern: /테스트\s*(?:가\s*)?통과/,
-    label: '"테스트 통과" (출력 없이)',
-  },
-  {
-    id: "everything_works",
-    pattern: /모든\s*게?\s*작동/,
-    label: '"모든게 작동" (증거 없이)',
-  },
-  {
-    id: "no_changes_with_diff",
-    pattern: /변경\s*(?:사항\s*)?없/,
-    label: '"변경 없음" (diff 있는데)',
-  },
-  {
-    id: "backward_compatible",
-    pattern: /호환성\s*(?:이\s*)?유지/,
-    label: '"호환성 유지" (검증 없이)',
-  },
-  {
-    id: "performance_improved",
-    pattern: /성능\s*(?:이\s*)?개선/,
-    label: '"성능 개선" (벤치마크 없이)',
-  },
-  {
-    id: "security_enhanced",
-    pattern: /보안\s*(?:이\s*)?강화/,
-    label: '"보안 강화" (증거 없이)',
-  },
-  {
-    id: "error_handling_done",
-    pattern: /에러\s*처리\s*(?:가\s*)?완료/,
-    label: '"에러 처리 완료" (catch 블록만)',
-  },
-];
-
-export const QUESTIONS = [
-  {
-    id: "tests_passing",
-    label: "모든 테스트 통과?",
-    evidenceKey: "testOutput",
-  },
-  {
-    id: "requirements_met",
-    label: "모든 요구사항 충족?",
-    evidenceKey: "requirementChecklist",
-  },
-  { id: "no_assumptions", label: "검증 없는 가정?", evidenceKey: "references" },
-  { id: "evidence_provided", label: "증거 있는가?", evidenceKey: "artifacts" },
-];
-
-/**
- * Red Flag 스캔 — 텍스트에서 할루시네이션 패턴 탐지
- * @param {string} text - 스캔 대상 텍스트
- * @param {object} context - { hasDiff?, evidence? }
- * @returns {Array<{ id: string, label: string }>}
- */
-function detectRedFlags(text, context = {}) {
-  const flags = [];
-  const evidence = context.evidence || {};
-
-  for (const rf of RED_FLAGS) {
-    if (!rf.pattern.test(text)) continue;
-
-    // "변경 없음"은 실제 diff가 있을 때만 Red Flag
-    if (rf.id === "no_changes_with_diff" && !context.hasDiff) continue;
-
-    // "테스트 통과"는 testOutput 증거가 없을 때만 Red Flag
-    if (rf.id === "test_pass_no_output" && evidence.testOutput) continue;
-
-    // 기타 Red Flag는 해당 id의 반증이 있으면 스킵
-    if (evidence[rf.id]) continue;
-
-    flags.push({ id: rf.id, label: rf.label });
-  }
-
-  return flags;
-}
-
-/**
- * Self-Check 실행
- * @param {string|object} execResult - 실행 결과 (텍스트 또는 객체)
- * @param {string|object} verifyResult - 검증 결과 (텍스트 또는 객체)
- * @param {object} requirements - { hasDiff?, evidence? }
- * @param {boolean} [requirements.hasDiff] - diff 존재 여부
- * @param {object} [requirements.evidence] - { testOutput, requirementChecklist, references, artifacts }
- * @returns {{ passed: boolean, score: number, flags: Array, checklist: Array }}
- */
-export function runSelfCheck(execResult, verifyResult, requirements = {}) {
-  const normalize = (v) =>
-    typeof v === "string" ? v : v != null ? JSON.stringify(v) : "";
-  const text = [normalize(execResult), normalize(verifyResult)].join("\n");
-
-  const flags = detectRedFlags(text, requirements);
-
-  const evidence = requirements.evidence || {};
-  const checklist = QUESTIONS.map((q) => {
-    const ev = evidence[q.evidenceKey];
-    const passed =
-      ev != null && (typeof ev === "string" ? ev.trim().length > 0 : true);
-    return { id: q.id, label: q.label, passed, evidence: ev || null };
-  });
-
-  const allQuestionsPassed = checklist.every((q) => q.passed);
-  const passed = flags.length === 0 && allQuestionsPassed;
-
-  // 점수: 기본 100, Red Flag당 -15, 실패 질문당 -20
-  const flagPenalty = flags.length * 15;
-  const questionPenalty = checklist.filter((q) => !q.passed).length * 20;
-  const score = Math.max(0, 100 - flagPenalty - questionPenalty);
-
-  return { passed, score, flags, checklist };
-}

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;
-}