@dommaker/harness 0.16.6 → 0.16.8

package/src/core/validators/checkpoint.ts

@@ -1,12 +1,10 @@
 /**
- * 检查点验证引擎
- * 
- * 在每个步骤执行后，自动验证检查点是否满足
+ * 检查点验证引擎（编排层，工单 23）
+ *
+ * 在每个步骤执行后，自动验证检查点是否满足。
+ * 各检查族实现位于 check-handlers/{file,command,output,http}.ts。
  */
 
-import * as fs from 'fs';
-import * as path from 'path';
-import { execAsync } from '../../utils/exec';
 import type {
   Checkpoint,
   CheckpointCheck,
@@ -15,7 +13,20 @@ import type {
   CheckpointContext,
   CheckType,
 } from '../../types/checkpoint';
-
+import {
+  checkFileExists,
+  checkFileNotEmpty,
+  checkFileContains,
+  checkFileNotContains,
+} from './check-handlers/file';
+import { checkCommandSuccess, checkCommandOutput } from './check-handlers/command';
+import {
+  checkOutputContains,
+  checkOutputNotContains,
+  checkOutputMatches,
+  checkJsonPath,
+} from './check-handlers/output';
+import { checkHttpStatus, checkHttpBody } from './check-handlers/http';
 
 /**
  * 检查点验证器
@@ -91,35 +102,35 @@ export class CheckpointValidator {
   }
 
   /**
-   * 执行单个检查项
+   * 执行单个检查项（分发至 check-handlers/ 各族）
    */
   private async executeCheck(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
     try {
       switch (check.type) {
         case 'file_exists':
-          return await this.checkFileExists(check, context);
+          return await checkFileExists(check, context);
         case 'file_not_empty':
-          return await this.checkFileNotEmpty(check, context);
+          return await checkFileNotEmpty(check, context);
         case 'file_contains':
-          return await this.checkFileContains(check, context);
+          return await checkFileContains(check, context);
         case 'file_not_contains':
-          return await this.checkFileNotContains(check, context);
+          return await checkFileNotContains(check, context);
         case 'command_success':
-          return await this.checkCommandSuccess(check, context);
+          return await checkCommandSuccess(check, context);
         case 'command_output':
-          return await this.checkCommandOutput(check, context);
+          return await checkCommandOutput(check, context);
         case 'output_contains':
-          return await this.checkOutputContains(check, context);
+          return await checkOutputContains(check, context);
         case 'output_not_contains':
-          return await this.checkOutputNotContains(check, context);
+          return await checkOutputNotContains(check, context);
         case 'output_matches':
-          return await this.checkOutputMatches(check, context);
+          return await checkOutputMatches(check, context);
         case 'json_path':
-          return await this.checkJsonPath(check, context);
+          return await checkJsonPath(check, context);
         case 'http_status':
-          return await this.checkHttpStatus(check, context);
+          return await checkHttpStatus(check, context);
         case 'http_body':
-          return await this.checkHttpBody(check, context);
+          return await checkHttpBody(check, context);
         case 'custom':
           return await this.checkCustom(check, context);
         default:
@@ -140,346 +151,13 @@ export class CheckpointValidator {
     }
   }
 
-  /**
-   * 检查文件是否存在
-   */
-  private async checkFileExists(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const filePath = this.resolvePath(check.config.path || '', context.workdir);
-    const exists = fs.existsSync(filePath);
-
-    return {
-      checkId: check.id,
-      passed: exists,
-      message: exists ? `文件存在: ${filePath}` : `文件不存在: ${filePath}`,
-      actual: exists,
-      expected: true,
-    };
-  }
-
-  /**
-   * 检查文件非空
-   */
-  private async checkFileNotEmpty(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const filePath = this.resolvePath(check.config.path || '', context.workdir);
-    
-    if (!fs.existsSync(filePath)) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `文件不存在: ${filePath}`,
-        actual: false,
-        expected: true,
-      };
-    }
-
-    const stats = fs.statSync(filePath);
-    const notEmpty = stats.size > 0;
-
-    return {
-      checkId: check.id,
-      passed: notEmpty,
-      message: notEmpty ? `文件非空: ${filePath}` : `文件为空: ${filePath}`,
-      actual: stats.size,
-      expected: '> 0',
-    };
-  }
-
-  /**
-   * 检查文件包含内容
-   */
-  private async checkFileContains(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const filePath = this.resolvePath(check.config.path || '', context.workdir);
-    const content = check.config.content || '';
-
-    if (!fs.existsSync(filePath)) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `文件不存在: ${filePath}`,
-        actual: null,
-        expected: content,
-      };
-    }
-
-    const fileContent = fs.readFileSync(filePath, 'utf-8');
-    const contains = fileContent.includes(content);
-
-    return {
-      checkId: check.id,
-      passed: contains,
-      message: contains ? `文件包含内容: ${content}` : `文件不包含内容: ${content}`,
-      actual: contains,
-      expected: true,
-    };
-  }
-
-  /**
-   * 检查文件不包含内容
-   */
-  private async checkFileNotContains(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const filePath = this.resolvePath(check.config.path || '', context.workdir);
-    const content = check.config.content || '';
-
-    if (!fs.existsSync(filePath)) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `文件不存在: ${filePath}`,
-        actual: null,
-        expected: `不包含: ${content}`,
-      };
-    }
-
-    const fileContent = fs.readFileSync(filePath, 'utf-8');
-    const notContains = !fileContent.includes(content);
-
-    return {
-      checkId: check.id,
-      passed: notContains,
-      message: notContains ? `文件不包含内容: ${content}` : `文件包含内容: ${content}`,
-      actual: !notContains,
-      expected: false,
-    };
-  }
-
-  /**
-   * 检查命令执行成功
-   */
-  private async checkCommandSuccess(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const command = check.config.command || '';
-
-    try {
-      const { stdout, stderr } = await execAsync(command, { cwd: context.workdir });
-      return {
-        checkId: check.id,
-        passed: true,
-        message: `命令执行成功: ${command}`,
-        actual: stdout.trim(),
-        expected: 'exit code 0',
-      };
-    } catch (error: any) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `命令执行失败: ${command}`,
-        actual: error.message,
-        expected: 'exit code 0',
-        error: error.message,
-      };
-    }
-  }
-
-  /**
-   * 检查命令输出
-   */
-  private async checkCommandOutput(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const command = check.config.command || '';
-    const expected = String(check.config.expected || '');
-
-    try {
-      const { stdout } = await execAsync(command, { cwd: context.workdir });
-      const actual = stdout.trim();
-      const matches = actual.includes(expected);
-
-      return {
-        checkId: check.id,
-        passed: matches,
-        message: matches ? `命令输出匹配: ${expected}` : `命令输出不匹配: ${expected}`,
-        actual,
-        expected,
-      };
-    } catch (error: any) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `命令执行失败: ${command}`,
-        actual: error.message,
-        expected,
-        error: error.message,
-      };
-    }
-  }
-
-  /**
-   * 检查输出包含内容
-   */
-  private async checkOutputContains(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const output = this.stringifyOutput(context.output);
-    const content = check.config.content || String(check.config.expected || '');
-    const contains = output.includes(content);
-
-    return {
-      checkId: check.id,
-      passed: contains,
-      message: contains ? `输出包含内容: ${content}` : `输出不包含内容: ${content}`,
-      actual: contains,
-      expected: true,
-    };
-  }
-
-  /**
-   * 检查输出不包含内容
-   */
-  private async checkOutputNotContains(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const output = this.stringifyOutput(context.output);
-    const content = check.config.content || String(check.config.expected || '');
-    const notContains = !output.includes(content);
-
-    return {
-      checkId: check.id,
-      passed: notContains,
-      message: notContains ? `输出不包含内容: ${content}` : `输出包含内容: ${content}`,
-      actual: !notContains,
-      expected: false,
-    };
-  }
-
-  /**
-   * 检查输出匹配正则
-   */
-  private async checkOutputMatches(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const output = this.stringifyOutput(context.output);
-    const pattern = check.config.pattern || '';
-    const regex = new RegExp(pattern, 'gm');
-    const matches = regex.test(output);
-
-    return {
-      checkId: check.id,
-      passed: matches,
-      message: matches ? `输出匹配正则: ${pattern}` : `输出不匹配正则: ${pattern}`,
-      actual: matches,
-      expected: true,
-    };
-  }
-
-  /**
-   * 检查 JSON 路径
-   */
-  private async checkJsonPath(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const jsonPath = check.config.jsonPath || '';
-    const expected = check.config.expected;
-
-    let actual: any;
-    try {
-      actual = this.getJsonValue(context.output, jsonPath);
-    } catch (error) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `JSON 路径无效: ${jsonPath}`,
-        actual: null,
-        expected,
-        error: (error as Error).message,
-      };
-    }
-
-    const matches = JSON.stringify(actual) === JSON.stringify(expected);
-
-    return {
-      checkId: check.id,
-      passed: matches,
-      message: matches ? `JSON 路径匹配: ${jsonPath}` : `JSON 路径不匹配: ${jsonPath}`,
-      actual,
-      expected,
-    };
-  }
-
-  /**
-   * HTTP 调用重试（处理 httpbin rate-limit 503/429）
-   */
-  private async fetchWithRetry(url: string, init?: RequestInit, retries = 3): Promise<Response> {
-    let lastError: unknown;
-    for (let i = 0; i <= retries; i++) {
-      try {
-        const response = await fetch(url, init);
-        // 5xx / 429 → 重试，指数退避
-        if (!response.ok && i < retries && (response.status >= 500 || response.status === 429)) {
-          await new Promise(r => setTimeout(r, 2000 * (i + 1)));
-          continue;
-        }
-        return response;
-      } catch (e) {
-        lastError = e;
-        if (i < retries) await new Promise(r => setTimeout(r, 2000 * (i + 1)));
-      }
-    }
-    throw lastError;
-  }
-
-  /**
-   * 检查 HTTP 状态码
-   */
-  private async checkHttpStatus(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const url = check.config.url || '';
-    const expected = check.config.expectedStatus || check.config.expected || 200;
-
-    try {
-      const response = await this.fetchWithRetry(url, { signal: AbortSignal.timeout(10000) });
-      const actual = response.status;
-      const matches = actual === expected;
-
-      return {
-        checkId: check.id,
-        passed: matches,
-        message: matches ? `HTTP 状态码匹配: ${expected}` : `HTTP 状态码不匹配: ${actual} != ${expected}`,
-        actual,
-        expected,
-      };
-    } catch (error: any) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `HTTP 请求失败: ${url}`,
-        actual: error.message,
-        expected,
-        error: error.message,
-      };
-    }
-  }
-
-  /**
-   * 检查 HTTP 响应体
-   */
-  private async checkHttpBody(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
-    const url = check.config.url || '';
-    const expected = String(check.config.expected || '');
-
-    try {
-      const response = await this.fetchWithRetry(url, {
-        method: check.config.method || 'GET',
-        headers: check.config.headers,
-        body: check.config.body ? JSON.stringify(check.config.body) : undefined,
-        signal: AbortSignal.timeout(10000),
-      });
-      const actual = await response.text();
-      const contains = actual.includes(expected);
-
-      return {
-        checkId: check.id,
-        passed: contains,
-        message: contains ? `HTTP 响应体包含: ${expected}` : `HTTP 响应体不包含: ${expected}`,
-        actual,
-        expected,
-      };
-    } catch (error: any) {
-      return {
-        checkId: check.id,
-        passed: false,
-        message: `HTTP 请求失败: ${url}`,
-        actual: error.message,
-        expected,
-        error: error.message,
-      };
-    }
-  }
-
   /**
    * 自定义检查
    */
   private async checkCustom(check: CheckpointCheck, context: CheckpointContext): Promise<CheckResult> {
     // 检查是否有自定义处理器
     const handler = context.customHandlers?.get(check.config.customFunction || '');
-    
+
     if (handler) {
       return await handler(check.config);
     }
@@ -491,57 +169,4 @@ export class CheckpointValidator {
       error: 'Custom check not implemented',
     };
   }
-
-  /**
-   * 解析路径
-   */
-  private resolvePath(relativePath: string, workdir: string): string {
-    if (path.isAbsolute(relativePath)) {
-      return relativePath;
-    }
-    return path.join(workdir, relativePath);
-  }
-
-  /**
-   * 将输出转换为字符串
-   */
-  private stringifyOutput(output: any): string {
-    if (typeof output === 'string') {
-      return output;
-    }
-    if (output === null || output === undefined) {
-      return '';
-    }
-    return JSON.stringify(output);
-  }
-
-  /**
-   * 获取 JSON 值
-   */
-  private getJsonValue(obj: any, jsonPath: string): any {
-    const parts = jsonPath.split('.');
-    let current = obj;
-
-    for (const part of parts) {
-      if (current === null || current === undefined) {
-        return undefined;
-      }
-      current = current[part];
-    }
-
-    return current;
-  }
-}
-
-// 导出单例
-export const checkpointValidator = CheckpointValidator.getInstance();
-
-/**
- * 快捷函数：验证检查点
- */
-export async function validateCheckpoint(
-  checkpoint: Checkpoint,
-  context: CheckpointContext
-): Promise<CheckpointResult> {
-  return checkpointValidator.validate(checkpoint, context);
 }

package/src/core/validators/cso.ts

@@ -72,7 +72,7 @@ export class CSOValidator {
   /**
    * 验证描述
    */
-  private validateDescription(description: string, type: string): CSOValidationResult {
+  private validateDescription(description: string, _type: string): CSOValidationResult {
     const issues: CSOIssue[] = [];
 
     // 检查是否有工作流总结关键词

package/src/core/validators/passes-gate.ts

@@ -281,12 +281,12 @@ export class PassesGate {
   /**
    * 运行测试
    */
-  private async runTest(workDir: string, task?: DynamicTask): Promise<TaskTestResult> {
+  private async runTest(workDir: string, _task?: DynamicTask): Promise<TaskTestResult> {
     const testCommand = await this.detectTestCommand(workDir);
     const timestamp = new Date();
 
     try {
-      const { stdout, stderr } = await execAsync(testCommand, {
+      const { stdout } = await execAsync(testCommand, {
         cwd: workDir,
         maxBuffer: 10 * 1024 * 1024, // 10MB buffer
       });

package/src/dashboard/stats.ts

@@ -4,7 +4,7 @@
  * 纯函数，从原始数据计算统计指标
  */
 
-import type { KnowledgeEntry, KnowledgeType, MaturityLevel } from '../knowledge/types';
+import type { KnowledgeEntry, KnowledgeType } from '../knowledge/types';
 import type { KnowledgeOverview, KnowledgeFlow } from './types';
 
 /**

package/src/dashboard/types.ts

@@ -4,7 +4,7 @@
  * harness 提供数据，studio 负责渲染
  */
 
-import type { KnowledgeType, MaturityLevel } from '../knowledge/types';
+import type { KnowledgeType } from '../knowledge/types';
 import type { ConstraintLayer, DeprecationStatus } from '../constraints/types';
 
 // ── 知识库全景 ───────────────────────────────────────────

package/src/evolution/__tests__/auto-evolve.test.ts

@@ -3,8 +3,7 @@
  */
 
 import type { ExecutionTrace, TraceAnomaly } from '../../types/trace';
-import type { Diagnosis } from '../../monitoring/constraint-doctor';
-import type { ConstraintProposal, ProposalReviewResult } from '../../monitoring/constraint-evolver';
+import type { Diagnosis, ConstraintProposal, ProposalReviewResult } from '../../types/monitoring-types';
 import type { ExecutionResult } from '../../constraints/lifecycle-runner';
 
 jest.mock('../../monitoring/constraint-doctor', () => {

package/src/evolution/auto-evolve.ts

@@ -8,9 +8,9 @@
 import type { ExecutionTrace, TraceAnomaly } from '../types/trace';
 import type { LLMAdapter } from '../llm/types';
 import { ConstraintDoctor } from '../monitoring/constraint-doctor';
-import type { Diagnosis } from '../monitoring/constraint-doctor';
 import { ConstraintEvolver } from '../monitoring/constraint-evolver';
-import type { ConstraintProposal } from '../monitoring/constraint-evolver';
+import { getConstraint } from '../core/constraints/definitions';
+import type { Diagnosis, ConstraintProposal } from '../types/monitoring-types';
 import { ConstraintLifecycleRunner } from '../constraints/lifecycle-runner';
 import type { ExecutionResult } from '../constraints/lifecycle-runner';
 
@@ -49,7 +49,7 @@ export async function autoEvolve(
   const doctor = new ConstraintDoctor({ enabled: !!llm }, llm);
   doctor.setData(traces);
 
-  const evolver = new ConstraintEvolver();
+  const evolver = new ConstraintEvolver(undefined, getConstraint);
   const runner = new ConstraintLifecycleRunner();
 
   const diagnoses: Diagnosis[] = [];