@triflux/core 10.0.0-alpha.1

package/hub/pipeline/transitions.mjs

@@ -0,0 +1,124 @@
+// hub/pipeline/transitions.mjs — 파이프라인 단계 전이 규칙
+//
+// plan → prd → confidence → exec → deslop → verify → selfcheck → complete/fix
+// fix → exec/verify/complete/failed
+// complete, failed = 터미널 상태
+
+export const PHASES = [
+  'plan', 'prd', 'confidence', 'exec', 'deslop', 'verify', 'selfcheck',
+  'fix', 'complete', 'failed',
+];
+
+export const TERMINAL = new Set(['complete', 'failed']);
+
+export const ALLOWED = {
+  'plan':       ['prd'],
+  'prd':        ['confidence'],
+  'confidence': ['exec', 'failed'],
+  'exec':       ['deslop'],
+  'deslop':     ['verify'],
+  'verify':     ['selfcheck', 'fix', 'failed'],
+  'selfcheck':  ['complete', 'fix'],
+  'fix':        ['exec', 'verify', 'complete', 'failed'],
+  'complete':   [],
+  'failed':     [],
+};
+
+/**
+ * 전이 가능 여부 확인
+ * @param {string} from - 현재 단계
+ * @param {string} to - 다음 단계
+ * @returns {boolean}
+ */
+export function canTransition(from, to) {
+  const targets = ALLOWED[from];
+  if (!targets) return false;
+  return targets.includes(to);
+}
+
+/**
+ * 상태 전이 실행 — fix loop 바운딩 포함
+ * @param {object} state - 파이프라인 상태 객체
+ * @param {string} nextPhase - 다음 단계
+ * @returns {{ ok: boolean, state?: object, error?: string }}
+ */
+export function transitionPhase(state, nextPhase) {
+  const current = state.phase;
+
+  if (!canTransition(current, nextPhase)) {
+    return {
+      ok: false,
+      error: `전이 불가: ${current} → ${nextPhase}. 허용: [${(ALLOWED[current] || []).join(', ')}]`,
+    };
+  }
+
+  const next = { ...state, phase: nextPhase, updated_at: Date.now() };
+
+  // fix 단계 진입 시 attempt 증가 + 바운딩
+  if (nextPhase === 'fix') {
+    next.fix_attempt = (state.fix_attempt || 0) + 1;
+    if (next.fix_attempt > (state.fix_max || 3)) {
+      return {
+        ok: false,
+        error: `fix loop 초과: ${state.fix_max || 3}회 도달`,
+      };
+    }
+  }
+
+  // fix → exec 재진입 시 (fix 후 재실행)
+  if (current === 'fix' && nextPhase === 'exec') {
+    // fix_attempt 유지 (이미 fix 진입 시 증가됨)
+  }
+
+  // verify → fix → ... → verify 반복 후 fix_max 초과 시 ralph loop
+  if (nextPhase === 'failed' && current === 'fix') {
+    // ralph loop 반복 증가
+    next.ralph_iteration = (state.ralph_iteration || 0) + 1;
+    if (next.ralph_iteration > (state.ralph_max || 10)) {
+      // 최종 실패 — ralph loop도 초과
+      next.phase = 'failed';
+    }
+  }
+
+  // phase_history 기록
+  const history = Array.isArray(state.phase_history) ? [...state.phase_history] : [];
+  history.push({ from: current, to: nextPhase, at: Date.now() });
+  next.phase_history = history;
+
+  return { ok: true, state: next };
+}
+
+/**
+ * ralph loop 재시작 전이
+ * fix_max 초과 시 plan으로 돌아가며 ralph_iteration 증가
+ * @param {object} state - 현재 상태
+ * @returns {{ ok: boolean, state?: object, error?: string }}
+ */
+export function ralphRestart(state) {
+  if (TERMINAL.has(state.phase)) {
+    return { ok: false, error: '터미널 상태에서 재시작 불가' };
+  }
+
+  const iteration = (state.ralph_iteration || 0) + 1;
+  if (iteration > (state.ralph_max || 10)) {
+    return {
+      ok: false,
+      error: `ralph loop 초과: ${iteration}/${state.ralph_max || 10}회. 최종 실패.`,
+    };
+  }
+
+  const history = Array.isArray(state.phase_history) ? [...state.phase_history] : [];
+  history.push({ from: state.phase, to: 'plan', at: Date.now(), ralph_restart: true });
+
+  return {
+    ok: true,
+    state: {
+      ...state,
+      phase: 'plan',
+      fix_attempt: 0,
+      ralph_iteration: iteration,
+      phase_history: history,
+      updated_at: Date.now(),
+    },
+  };
+}

package/hub/platform.mjs

@@ -0,0 +1,225 @@
+import os from 'node:os';
+import path from 'node:path';
+import { execFile, execFileSync, execSync } from 'node:child_process';
+
+export const IS_WINDOWS = process.platform === 'win32';
+export const IS_MAC = process.platform === 'darwin';
+export const IS_LINUX = process.platform === 'linux';
+export const TEMP_DIR = IS_WINDOWS ? os.tmpdir() : '/tmp';
+export const PATH_SEP = path.sep;
+
+function getPathApi(platform) {
+  return platform === 'win32' ? path.win32 : path.posix;
+}
+
+function coercePathInput(value, platform) {
+  const text = String(value ?? '');
+  if (platform === 'win32') {
+    return text.replaceAll('/', '\\');
+  }
+  return text.replaceAll('\\', '/');
+}
+
+function sanitizePipeSegment(value) {
+  return String(value ?? '')
+    .trim()
+    .replace(/[<>:"/\\|?*\u0000-\u001f]+/gu, '-')
+    .replace(/-+/g, '-')
+    .replace(/^-|-$/g, '');
+}
+
+function buildWhichCommandSpec(name, options = {}) {
+  const commandName = String(name ?? '').trim();
+  if (!commandName) return null;
+
+  const platform = options.platform || process.platform;
+  return {
+    lookupCommand: platform === 'win32' ? 'where' : 'which',
+    args: [commandName],
+    execOptions: {
+      encoding: 'utf8',
+      timeout: options.timeout ?? 5000,
+      stdio: ['ignore', 'pipe', 'ignore'],
+      windowsHide: true,
+      env: options.env || process.env,
+      cwd: options.cwd,
+    },
+  };
+}
+
+function parseWhichCommandOutput(output) {
+  return String(output)
+    .split(/\r?\n/u)
+    .map((line) => line.trim())
+    .find(Boolean) || null;
+}
+
+function execFileAsync(command, args, options, execFileFn = execFile) {
+  return new Promise((resolve, reject) => {
+    execFileFn(command, args, options, (error, stdout) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+      resolve(stdout);
+    });
+  });
+}
+
+/**
+ * 경로를 플랫폼에 맞게 정규화합니다.
+ * Windows 환경에서는 역슬래시(\)를 슬래시(/)로 변환하여 반환합니다.
+ * 
+ * @param {string} value - 정규화할 경로 문자열
+ * @param {object} [options] - 옵션
+ * @param {string} [options.platform] - 대상 플랫폼 (기본값: process.platform)
+ * @returns {string} 정규화된 경로
+ */
+export function normalizePath(value, options = {}) {
+  const platform = options.platform || process.platform;
+  const pathApi = getPathApi(platform);
+  const normalized = pathApi.normalize(coercePathInput(value, platform));
+
+  if (platform === 'win32') {
+    return normalized.replaceAll('\\', '/');
+  }
+  return normalized;
+}
+
+/**
+ * 시스템에서 실행 가능한 명령의 절대 경로를 찾습니다.
+ * Windows에서는 'where', Unix 계열에서는 'which' 명령을 사용합니다.
+ * 
+ * @param {string} name - 찾을 명령어 이름
+ * @param {object} [options] - 옵션
+ * @param {string} [options.platform] - 대상 플랫폼
+ * @param {number} [options.timeout=5000] - 검색 타임아웃 (ms)
+ * @param {object} [options.env] - 환경 변수
+ * @param {string} [options.cwd] - 작업 디렉토리
+ * @returns {string|null} 명령어의 절대 경로 또는 찾지 못한 경우 null
+ */
+export function whichCommand(name, options = {}) {
+  const spec = buildWhichCommandSpec(name, options);
+  if (!spec) return null;
+
+  try {
+    const output = execFileSync(spec.lookupCommand, spec.args, spec.execOptions);
+    return parseWhichCommandOutput(output);
+  } catch {
+    return null;
+  }
+}
+
+export async function whichCommandAsync(name, options = {}) {
+  const spec = buildWhichCommandSpec(name, options);
+  if (!spec) return null;
+
+  try {
+    const output = await execFileAsync(
+      spec.lookupCommand,
+      spec.args,
+      spec.execOptions,
+      options.execFileFn || execFile,
+    );
+    return parseWhichCommandOutput(output);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * 프로세스를 종료합니다.
+ * Windows에서는 트리 구조 종료(/T) 및 강제 종료(/F)를 지원합니다.
+ * 
+ * @param {number|string} pid - 종료할 프로세스 ID
+ * @param {object} [options] - 옵션
+ * @param {string} [options.platform] - 대상 플랫폼
+ * @param {string} [options.signal='SIGTERM'] - 전송할 신호
+ * @param {boolean} [options.tree=false] - 자식 프로세스까지 포함하여 종료할지 여부
+ * @param {boolean} [options.force=false] - 강제 종료 여부
+ * @param {number} [options.timeout=5000] - 타임아웃 (ms)
+ * @returns {boolean} 종료 성공 여부
+ */
+export function killProcess(pid, options = {}) {
+  const numericPid = Number.parseInt(String(pid), 10);
+  if (!Number.isInteger(numericPid) || numericPid <= 0) return false;
+
+  const platform = options.platform || process.platform;
+  const signal = options.signal || 'SIGTERM';
+  const tree = options.tree === true;
+  const force = options.force === true || signal === 'SIGKILL';
+
+  try {
+    if (platform === 'win32' && (tree || force)) {
+      const command = [
+        'taskkill',
+        '/PID',
+        String(numericPid),
+        tree ? '/T' : '',
+        force ? '/F' : '',
+      ]
+        .filter(Boolean)
+        .join(' ');
+      execSync(command, {
+        stdio: 'ignore',
+        timeout: options.timeout ?? 5000,
+        windowsHide: true,
+      });
+      return true;
+    }
+
+    process.kill(numericPid, signal);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 플랫폼별 IPC 파이프 또는 소켓 경로를 생성합니다.
+ * Windows에서는 네임드 파이프 경로를, Unix 계열에서는 도메인 소켓 파일 경로를 반환합니다.
+ * 
+ * @param {string} name - 파이프/소켓 기본 이름
+ * @param {number|string} [pid=process.pid] - 프로세스 ID (식별자 추가용)
+ * @param {object} [options] - 옵션
+ * @param {string} [options.platform] - 대상 플랫폼
+ * @param {string} [options.tempDir] - 임시 디렉토리 경로 (Unix 전용)
+ * @returns {string} 플랫폼별 파이프/소켓 경로
+ */
+export function pipePath(name, pid = process.pid, options = {}) {
+  const platform = options.platform || process.platform;
+  const safeName = sanitizePipeSegment(name) || 'triflux';
+  const suffix = pid == null || pid === '' ? safeName : `${safeName}-${pid}`;
+
+  if (platform === 'win32') {
+    return `\\\\.\\pipe\\${suffix}`;
+  }
+
+  const baseDir = options.tempDir || TEMP_DIR;
+  return path.posix.join(baseDir, `${suffix}.sock`);
+}
+
+/**
+ * 특정 경로가 대상 디렉토리 내부에 포함되는지 확인합니다.
+ * 대소문자 구분 및 상대 경로 처리를 플랫폼 규격에 맞게 수행합니다.
+ * 
+ * @param {string} resolvedPath - 검사할 절대 경로
+ * @param {string} dir - 기준이 되는 대상 디렉토리 경로
+ * @param {object} [options] - 옵션
+ * @param {string} [options.platform] - 대상 플랫폼
+ * @returns {boolean} 포함 여부
+ */
+export function isPathWithin(resolvedPath, dir, options = {}) {
+  if (!resolvedPath || !dir) return false;
+
+  const platform = options.platform || process.platform;
+  const pathApi = getPathApi(platform);
+  const left = pathApi.resolve(coercePathInput(resolvedPath, platform));
+  const right = pathApi.resolve(coercePathInput(dir, platform));
+
+  const normalizedLeft = platform === 'win32' ? left.toLowerCase() : left;
+  const normalizedRight = platform === 'win32' ? right.toLowerCase() : right;
+  const relative = pathApi.relative(normalizedRight, normalizedLeft);
+
+  return relative === '' || (!relative.startsWith('..') && !pathApi.isAbsolute(relative));
+}

package/hub/quality/deslop.mjs

@@ -0,0 +1,253 @@
+/**
+ * Anti-Slop Code Pass
+ * AI 생성 코드에서 불필요한 요소를 자동 탐지/제거하는 정적 분석 모듈
+ */
+
+import { readdir, readFile, writeFile, stat } from 'node:fs/promises';
+import { join, relative } 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 },
+  };
+}