L2keka/server/src/services/code-quality.ts

import path from 'path';

/**
 * 代码质量确定性评估（2026-08-27）：防"光有数量没有质量"。
 *
 * 数量（行数/功能数/测试数）可以靠复制粘贴/空壳堆出来；质量必须用确定性信号压制。
 * 三个核心质量指标：
 * 1. 空壳率 stubRatio —— 空函数/TODO/占位占比（数量虚胖的直接证据）
 * 2. 重复率 dupRatio —— 复制粘贴占比（灌水代码的直接证据）
 * 3. 测试有效度 testValidity —— 测试断言数/核心功能覆盖（只测边角料的测试无价值）
 *
 * 输出 qualityScore 0~100 + 各指标明细，供"规模与功能点/实现完整度"评分绑定与硬规则。
 */

export interface CodeQualityResult {
  applicable: boolean;
  // 空壳
  stubRatio: number;            // 0~1，空壳函数/占位占比
  stubHits: { file: string; line: number }[];
  // 重复
  dupRatio: number;             // 0~1，重复代码行占比
  // 测试有效度
  testAssertionCount: number;   // 测试文件中断言总数
  testFunctionCount: number;    // 测试函数数
  testValidityRatio: number;    // 0~1，测试有效性（断言数足够、覆盖核心）
  qualityScore: number;         // 0~100 综合质量分
  toPrompt: string;
}

const TODO_RE = /\b(TODO|FIXME|XXX|HACK|not\s*implemented|暂不|待实现|待接入)\b/i;
const STUB_BODY_RE = /pass\b|\.\.\.|throw\s+new\s+Error\(['"]not\s*implemented|return\s+null\s*;?\s*$/;

/**
 * 从文件列表计算代码质量指标。
 */
export function computeCodeQuality(files: { path: string; content?: string }[]): CodeQualityResult {
  const empty: CodeQualityResult = {
    applicable: false, stubRatio: 0, stubHits: [], dupRatio: 0,
    testAssertionCount: 0, testFunctionCount: 0, testValidityRatio: 0,
    qualityScore: 0, toPrompt: '',
  };

  const code = (files || []).filter(f =>
    /\.(ts|tsx|js|jsx|mjs|cjs|py|java|go|rs)$/i.test(f.path) &&
    typeof f.content === 'string' &&
    !/node_modules|dist|build|__pycache__|\.d\.ts$|coverage/i.test(f.path));
  if (code.length === 0) return empty;
  empty.applicable = true;

  // ---- 1. 空壳率 ----
  let totalFuncs = 0, stubFuncs = 0;
  const stubHits: { file: string; line: number }[] = [];
  let todoCount = 0;

  for (const f of code) {
    const lines = f.content!.split('\n');
    const isPy = /\.py$/i.test(f.path);
    const isTS = /\.(ts|tsx|js|jsx|mjs|cjs)$/i.test(f.path);

    // 函数定义检测（语言相关）
    let defStart = -1;
    for (let i = 0; i < lines.length; i++) {
      const l = lines[i].trim();
      if (isPy) {
        const m = l.match(/^\s*def\s+(\w+)\s*\(/);
        if (m) {
          totalFuncs++;
          defStart = i;
          // 检查后续几行是否空壳（pass / return None / docstring-only）
          let isStub = false;
          for (let j = i + 1; j < Math.min(i + 8, lines.length); j++) {
            const inner = lines[j].trim();
            if (inner.startsWith('"""') || inner.startsWith("'''") || inner.startsWith('#')) continue;
            if (!inner) continue;
            if (/^\s*(pass|\.\.\.|return\s*(None|''|"")|raise\s+NotImplementedError|raise\s+NotImplementedException)\s*$/.test(inner)) {
              isStub = true;
            }
            break;
          }
          if (isStub) { stubFuncs++; stubHits.push({ file: f.path, line: i + 1 }); }
        }
      } else if (isTS) {
        const m = l.match(/^(?:export\s+)?(?:async\s+)?function\s+\w+\s*\(|^const\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>|^export\s+const\s+\w+\s*=\s*(?:async\s*)?\([^)]*\)\s*=>/);
        if (m) {
          totalFuncs++;
          // 检查函数体是否空（{ } 内无内容，或直接 return 字面量）
          let bodyStart = -1;
          for (let j = i; j < Math.min(i + 6, lines.length); j++) {
            if (lines[j].includes('{')) { bodyStart = j; break; }
          }
          if (bodyStart >= 0) {
            const rest = lines.slice(bodyStart).join('\n').slice(0, 120);
            if (/^\s*\{\s*\}/.test(rest) || /=>\s*\{\s*\}\s*;?$/.test(rest)) {
              stubFuncs++; stubHits.push({ file: f.path, line: i + 1 });
            }
          }
        }
      } else if (/\.(java|go|rs)$/i.test(f.path)) {
        // Java/Go/Rust: func|fn|public 方法
        const m = l.match(/^\s*(?:public|private|protected)?\s*(?:static\s+)?(?:func\s+\w+|fn\s+\w+|[\w<>,\[\] ]+\s+\w+\s*\()/);
        if (m) {
          totalFuncs++;
          const rest = lines.slice(i).join('\n').slice(0, 200);
          if (/\{\s*\}/.test(rest) || /\{\s*panic!?\("not implemented|return\s+nil\s*$/.test(rest)) {
            stubFuncs++; stubHits.push({ file: f.path, line: i + 1 });
          }
        }
      }
      if (TODO_RE.test(l)) todoCount++;
    }
  }
  const stubRatio = totalFuncs > 0 ? stubFuncs / totalFuncs : 0;

  // ---- 2. 重复率（行级归一化 MD5）----
  const md5 = new Map<string, number>();
  let hashTotal = 0, dupLines = 0;
  for (const f of code) {
    const lines = f.content!.split('\n').map(l => l.trim()).filter(l => l.length > 25 && !l.startsWith('//') && !l.startsWith('#'));
    for (const l of lines) {
      const h = require('crypto').createHash('md5').update(l).digest('hex');
      md5.set(h, (md5.get(h) || 0) + 1);
      hashTotal++;
    }
  }
  for (const cnt of md5.values()) if (cnt > 1) dupLines += cnt;
  const dupRatio = hashTotal > 0 ? dupLines / hashTotal : 0;

  // ---- 3. 测试有效度 ----
  const testFiles = code.filter(f => /(^|[\\/])(test|tests|spec|__tests__)[\\/_.-]|\.test\.|\.spec\./i.test(f.path));
  let assertions = 0, testFuncs = 0;
  for (const f of testFiles) {
    const c = f.content!;
    assertions += (c.match(/\b(assert|expect|assertThat|assertTrue|assertEquals|assertEqual|self\.assert)\b|\.to(Be|Equal|Match|Contain)|assert\./g) || []).length;
    testFuncs += (c.match(/\b(def\s+test_|it\(|test\(|@Test|func\s+Test)/g) || []).length;
  }
  // 测试有效度：每个测试函数平均有断言才有效（且覆盖率信息由 tryTest 提供）
  const testValidityRatio = testFuncs > 0 ? Math.min(1, assertions / (testFuncs * 2)) : (testFiles.length > 0 ? 0.3 : 0);

  // ---- 综合质量分（0~100）----
  // 空壳率权重 40、重复率权重 30、测试有效度权重 30
  const stubScore = Math.max(0, 40 * (1 - stubRatio * 4));       // stub>25% → 0
  const dupScore = Math.max(0, 30 * (1 - dupRatio * 2));         // dup>50% → 0
  const testScore = 30 * testValidityRatio;
  const qualityScore = Math.round(stubScore + dupScore + testScore);

  // ---- 输出文本 ----
  const pct = (n: number) => Math.round(n * 100) + '%';
  const lines: string[] = [
    `代码质量确定性评估（${code.length} 个源码文件）`,
    `- 空壳率：${pct(stubRatio)}（${stubFuncs}/${totalFuncs} 函数为占位/空壳，密度 ${todoCount} 处 TODO）${stubRatio > 0.15 ? ' ⚠️偏高，存在数量虚胖风险' : ''}`,
    `- 重复率：${pct(dupRatio)}（行级 MD5 归一化）${dupRatio > 0.3 ? ' ⚠️偏高，存在灌水风险' : ''}`,
    `- 测试有效度：${pct(testValidityRatio)}（${testFiles.length} 个测试文件，${assertions} 个断言 / ${testFuncs} 个测试函数）${testValidityRatio < 0.5 ? ' ⚠️测试偏弱，可能只测边角料' : ''}`,
    `- 质量分：${qualityScore}/100（空壳率40 + 重复率30 + 测试有效度30）`,
  ];
  if (stubHits.length > 0) {
    lines.push(`- 空壳函数示例：${stubHits.slice(0, 5).map(h => `${h.file}:${h.line}`).join(', ')}`);
  }

  return {
    applicable: true,
    stubRatio,
    stubHits: stubHits.slice(0, 10),
    dupRatio,
    testAssertionCount: assertions,
    testFunctionCount: testFuncs,
    testValidityRatio,
    qualityScore,
    toPrompt: '\n## 代码质量评估（确定性证据）\n' + lines.join('\n'),
  };
}