@dommaker/harness 0.13.0 → 0.13.2

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

@@ -0,0 +1,320 @@
+/**
+ * autoEvolve 函数测试
+ */
+
+import type { ExecutionTrace, TraceAnomaly } from '../../types/trace';
+import type { Diagnosis } from '../../monitoring/constraint-doctor';
+import type { ConstraintProposal, ProposalReviewResult } from '../../monitoring/constraint-evolver';
+import type { ExecutionResult } from '../../constraints/lifecycle-runner';
+
+jest.mock('../../monitoring/constraint-doctor', () => {
+  const mockDiagnose = jest.fn();
+  const mockSetData = jest.fn();
+  const actual = jest.requireActual('../../monitoring/constraint-doctor');
+
+  return {
+    ...actual,
+    ConstraintDoctor: jest.fn().mockImplementation(() => ({
+      diagnose: mockDiagnose,
+      setData: mockSetData,
+    })),
+    createDoctor: jest.fn(),
+    get mockDiagnose() { return mockDiagnose; },
+    get mockSetData() { return mockSetData; },
+  };
+});
+
+jest.mock('../../monitoring/constraint-evolver', () => {
+  const mockPropose = jest.fn();
+  const mockReview = jest.fn();
+  const actual = jest.requireActual('../../monitoring/constraint-evolver');
+
+  return {
+    ...actual,
+    ConstraintEvolver: jest.fn().mockImplementation(() => ({
+      propose: mockPropose,
+      review: mockReview,
+    })),
+    createEvolver: jest.fn(),
+    get mockPropose() { return mockPropose; },
+    get mockReview() { return mockReview; },
+  };
+});
+
+jest.mock('../../constraints/lifecycle-runner', () => {
+  const mockExecute = jest.fn();
+  const actual = jest.requireActual('../../constraints/lifecycle-runner');
+
+  return {
+    ...actual,
+    ConstraintLifecycleRunner: jest.fn().mockImplementation(() => ({
+      execute: mockExecute,
+    })),
+    get mockExecute() { return mockExecute; },
+  };
+});
+
+function makeProposal(overrides: Record<string, unknown> = {}): ConstraintProposal {
+  return {
+    id: 'test-proposal',
+    proposedAt: Date.now(),
+    diagnosisId: 'test-diag',
+    constraintId: 'test-constraint',
+    type: 'add_exception',
+    content: { proposed: 'test', description: 'Test' },
+    reasoning: 'Test',
+    expectedOutcome: 'ok',
+    risk: { level: 'low', description: 'Low risk' },
+    implementation: { files: [], linesChanged: 1, testsRequired: true },
+    status: 'proposed',
+    ...overrides,
+  } as unknown as ConstraintProposal;
+}
+
+function makeDiagnosis(overrides: Record<string, unknown> = {}): Diagnosis {
+  return {
+    anomalyId: 'test-anomaly',
+    constraintId: 'test-constraint',
+    diagnosedAt: Date.now(),
+    needsChange: true,
+    rootCause: { primary: 'Test', evidence: [] },
+    impact: { severity: 'low', scope: 'single_project', userImpact: 'Test' },
+    recommendations: [{ type: 'add_exception', content: 'test', expectedOutcome: 'ok', implementationCost: 'low' }],
+    urgency: 'low',
+    ...overrides,
+  } as unknown as Diagnosis;
+}
+
+describe('autoEvolve', () => {
+  const mockDiagnose = (jest.requireMock('../../monitoring/constraint-doctor') as any).mockDiagnose;
+  const mockPropose = (jest.requireMock('../../monitoring/constraint-evolver') as any).mockPropose;
+  const mockReview = (jest.requireMock('../../monitoring/constraint-evolver') as any).mockReview;
+  const mockExecute = (jest.requireMock('../../constraints/lifecycle-runner') as any).mockExecute;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('无异常时应该返回空结果', async () => {
+    const { autoEvolve } = await import('../auto-evolve');
+
+    const result = await autoEvolve([], []);
+
+    expect(result.diagnoses).toEqual([]);
+    expect(result.proposals).toEqual([]);
+    expect(result.autoApproved).toBe(0);
+    expect(result.needsReview).toBe(0);
+    expect(result.executions).toEqual([]);
+    expect(mockDiagnose).not.toHaveBeenCalled();
+  });
+
+  it('异常不需要变更时应该跳过', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test anomaly',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    const traces: ExecutionTrace[] = [];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis({ needsChange: false }));
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve(traces, anomalies);
+
+    expect(result.diagnoses).toHaveLength(1);
+    expect(result.proposals).toEqual([]);
+    expect(mockPropose).not.toHaveBeenCalled();
+  });
+
+  it('提案为 null 时应该跳过', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis());
+    mockPropose.mockResolvedValue(null);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies);
+
+    expect(result.proposals).toEqual([]);
+  });
+
+  it('低风险提案应自动批准并执行', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis());
+    mockPropose.mockResolvedValue(makeProposal({ id: 'proposal-1' }));
+    mockReview.mockReturnValue({ accepted: true, comment: 'Auto-approved' } as ProposalReviewResult);
+    mockExecute.mockReturnValue({
+      proposalId: 'proposal-1',
+      constraintId: 'test-constraint',
+      action: 'add_exception',
+      success: true,
+      details: 'Added exception',
+    } as ExecutionResult);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies, { autoApproveLowRisk: true });
+
+    expect(result.autoApproved).toBe(1);
+    expect(result.proposals).toHaveLength(1);
+    expect(result.proposals[0].status).toBe('implemented');
+    expect(result.executions).toHaveLength(1);
+    expect(mockExecute).toHaveBeenCalled();
+  });
+
+  it('审核拒绝时应标记为 reviewing', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis());
+    mockPropose.mockResolvedValue(makeProposal({ id: 'proposal-rejected', risk: { level: 'medium', description: 'Medium risk' } }));
+    mockReview.mockReturnValue({ accepted: false, comment: 'Needs human review' } as ProposalReviewResult);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies, { autoApproveLowRisk: true });
+
+    expect(result.autoApproved).toBe(0);
+    expect(result.needsReview).toBe(1);
+    expect(result.proposals[0].status).toBe('reviewing');
+    expect(mockExecute).not.toHaveBeenCalled();
+  });
+
+  it('执行失败时 status 应保持 accepted', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis());
+    mockPropose.mockResolvedValue(makeProposal({ id: 'proposal-fail-exec' }));
+    mockReview.mockReturnValue({ accepted: true, comment: 'Auto-approved' } as ProposalReviewResult);
+    mockExecute.mockReturnValue({
+      proposalId: 'proposal-fail-exec',
+      constraintId: 'test-constraint',
+      action: 'add_exception',
+      success: false,
+      details: 'Execution failed',
+    } as ExecutionResult);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies);
+
+    expect(result.executions[0].success).toBe(false);
+    expect(result.proposals[0].status).toBe('accepted');
+  });
+
+  it('审核返回 modifications 时应合并到内容', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis());
+    mockPropose.mockResolvedValue(makeProposal({
+      id: 'proposal-mod',
+      content: { proposed: 'old_value', description: 'Test' },
+    }));
+    mockReview.mockReturnValue({
+      accepted: false,
+      comment: 'Needs moderation',
+      modifications: { proposed: 'new_value' },
+    } as unknown as ProposalReviewResult);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies);
+
+    expect(result.proposals[0].content.proposed).toBe('new_value');
+  });
+
+  it('autoApproveLowRisk=false 时全部进入 reviewing', async () => {
+    const anomalies: TraceAnomaly[] = [{
+      type: 'high_bypass_rate',
+      constraintId: 'test-constraint',
+      level: 'guideline',
+      message: 'Test',
+      data: { currentRate: 0.5, threshold: 0.3 },
+      detectedAt: Date.now(),
+    }];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis());
+    mockPropose.mockResolvedValue(makeProposal({ id: 'proposal-no-auto' }));
+    mockReview.mockReturnValue({ accepted: true, comment: 'Auto-approved' } as ProposalReviewResult);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies, { autoApproveLowRisk: false });
+
+    expect(result.autoApproved).toBe(0);
+    expect(result.needsReview).toBe(1);
+    expect(mockExecute).not.toHaveBeenCalled();
+  });
+
+  it('多个异常应该都为 auto-evolve 流程', async () => {
+    const anomalies: TraceAnomaly[] = [
+      {
+        type: 'high_bypass_rate',
+        constraintId: 'constraint-1',
+        level: 'guideline',
+        message: 'Test 1',
+        data: { currentRate: 0.5, threshold: 0.3 },
+        detectedAt: Date.now(),
+      },
+      {
+        type: 'low_pass_rate',
+        constraintId: 'constraint-2',
+        level: 'guideline',
+        message: 'Test 2',
+        data: { currentRate: 0.1, threshold: 0.5 },
+        detectedAt: Date.now(),
+      },
+    ];
+
+    mockDiagnose.mockResolvedValue(makeDiagnosis({ constraintId: 'constraint-1' }));
+    mockPropose.mockResolvedValue(makeProposal({ id: 'multi-proposal', constraintId: 'constraint-1' }));
+    mockReview.mockReturnValue({ accepted: true, comment: 'Auto-approved' } as ProposalReviewResult);
+    mockExecute.mockReturnValue({
+      proposalId: 'multi-proposal',
+      constraintId: 'constraint-1',
+      action: 'add_exception',
+      success: true,
+      details: 'Done',
+    } as ExecutionResult);
+
+    const { autoEvolve } = await import('../auto-evolve');
+    const result = await autoEvolve([], anomalies);
+
+    expect(result.diagnoses).toHaveLength(2);
+    expect(result.proposals).toHaveLength(2);
+  });
+});

package/src/evolution/auto-evolve.ts

@@ -0,0 +1,98 @@
+/**
+ * 约束自动进化
+ *
+ * 纯计算：接收 traces + anomalies，返回进化结果。
+ * 不读写文件，数据存储由调用方负责。
+ */
+
+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 { ConstraintLifecycleRunner } from '../constraints/lifecycle-runner';
+import type { ExecutionResult } from '../constraints/lifecycle-runner';
+
+export interface AutoEvolveOptions {
+  /** 自动审核低风险提案（默认 true） */
+  autoApproveLowRisk?: boolean;
+  /** LLM adapter（用于深度诊断，可选） */
+  llm?: LLMAdapter;
+}
+
+export interface AutoEvolveResult {
+  /** 诊断结果 */
+  diagnoses: Diagnosis[];
+  /** 提案列表 */
+  proposals: ConstraintProposal[];
+  /** 自动审核通过数 */
+  autoApproved: number;
+  /** 需要人工审核数 */
+  needsReview: number;
+  /** 执行结果 */
+  executions: ExecutionResult[];
+}
+
+/**
+ * 自动进化：traces + anomalies → 诊断 → 提案 → 审核 → 执行
+ *
+ * 纯计算，不读写文件。调用方负责数据存储。
+ */
+export async function autoEvolve(
+  traces: ExecutionTrace[],
+  anomalies: TraceAnomaly[],
+  options?: AutoEvolveOptions,
+): Promise<AutoEvolveResult> {
+  const { autoApproveLowRisk = true, llm } = options ?? {};
+
+  const doctor = new ConstraintDoctor({ enabled: !!llm }, llm);
+  doctor.setData(traces);
+
+  const evolver = new ConstraintEvolver();
+  const runner = new ConstraintLifecycleRunner();
+
+  const diagnoses: Diagnosis[] = [];
+  const proposals: ConstraintProposal[] = [];
+  const executions: ExecutionResult[] = [];
+  let autoApproved = 0;
+  let needsReview = 0;
+
+  // 1. 诊断每个异常
+  for (const anomaly of anomalies) {
+    const diagnosis = await doctor.diagnose(anomaly);
+    diagnoses.push(diagnosis);
+
+    if (!diagnosis.needsChange) continue;
+
+    // 2. 生成提案
+    const proposal = await evolver.propose(diagnosis);
+    if (!proposal) continue;
+
+    // 3. 审核
+    const review = evolver.review(proposal);
+
+    if (review.accepted && autoApproveLowRisk) {
+      proposal.status = 'accepted';
+      autoApproved++;
+
+      // 4. 执行
+      const result = runner.execute(proposal);
+      executions.push(result);
+      if (result.success) {
+        proposal.status = 'implemented';
+      }
+    } else {
+      proposal.status = 'reviewing';
+      needsReview++;
+      if (review.modifications) {
+        Object.assign(proposal.content, review.modifications);
+      }
+    }
+
+    proposal.reviewComment = review.comment;
+    proposals.push(proposal);
+  }
+
+  return { diagnoses, proposals, autoApproved, needsReview, executions };
+}

package/src/evolution/index.ts

@@ -0,0 +1 @@
+export * from './auto-evolve';

package/src/failure/CONTEXT.md

@@ -0,0 +1,24 @@
+# failure/
+
+## 职责
+失败处理：错误分类(可扩展规则)、失败记录(文件存储)、约束违规统一处理策略。
+
+## 核心导出
+- `ErrorClassifier` — 错误分类器(可配置规则)
+- `FailureRecorder` — 失败记录器(文件存储)
+- `ConstraintViolationHandler` — 约束违规处理: block / collect / safeBoolean 三种策略
+- `types.ts` — 错误分类/记录类型定义
+
+## 依赖关系
+- 依赖 `src/types/constraint` ConstraintViolationError
+- 依赖 `src/core/constraints/` 约束检查结果
+- 被 `src/core/constraints/interceptor.ts` 消费
+
+## 约定
+- 分类规则可扩展(自定义 ErrorClassifierConfig)
+- 失败记录存储在 .harness/ 目录
+- 不包含业务逻辑，只提供通用能力
+
+## 注意事项
+- S4 统一处理策略：executeWithBlock / executeWithCollect / executeWithSafeBoolean
+- 分类器基于规则匹配，不调用 LLM

package/src/failure/classifier.ts

@@ -0,0 +1,156 @@
+/**
+ * 错误分类器
+ *
+ * 纯函数分类能力，不包含业务逻辑
+ */
+
+import type {
+  ErrorType,
+  FailureLevel,
+  ErrorClassificationRule,
+  ClassificationResult,
+} from './types';
+import {
+  ErrorType as ErrorTypeEnum,
+  FailureLevel as FailureLevelEnum,
+  DEFAULT_CLASSIFICATION_RULES,
+  DEFAULT_LEVEL_MAPPING,
+} from './types';
+
+/**
+ * 错误分类器配置
+ */
+export interface ErrorClassifierConfig {
+  /** 自定义分类规则 */
+  rules?: ErrorClassificationRule[];
+  /** 自定义等级映射 */
+  levelMapping?: Partial<Record<ErrorType, FailureLevel>>;
+}
+
+/**
+ * 错误分类器
+ *
+ * 用法：
+ * ```typescript
+ * const classifier = new ErrorClassifier();
+ * const result = classifier.classify(new Error('test failed'));
+ * // result.type === ErrorType.TEST_FAILED
+ * ```
+ */
+export class ErrorClassifier {
+  private rules: ErrorClassificationRule[];
+  private levelMapping: Record<ErrorType, FailureLevel>;
+
+  constructor(config?: ErrorClassifierConfig) {
+    // 合并默认规则和自定义规则
+    this.rules = config?.rules
+      ? [...config.rules, ...DEFAULT_CLASSIFICATION_RULES]
+      : DEFAULT_CLASSIFICATION_RULES;
+
+    // 合并默认等级映射和自定义映射
+    this.levelMapping = {
+      ...DEFAULT_LEVEL_MAPPING,
+      ...config?.levelMapping,
+    };
+  }
+
+  /**
+   * 分类错误
+   */
+  classify(error: Error): ClassificationResult {
+    const message = error.message.toLowerCase();
+    const name = error.name?.toLowerCase() || '';
+
+    // 遍历规则，按优先级匹配
+    for (const rule of this.rules) {
+      if (this.matchRule(message, name, rule)) {
+        return {
+          type: rule.type,
+          level: rule.level ?? this.levelMapping[rule.type],
+          matchedRule: rule,
+          originalError: error,
+        };
+      }
+    }
+
+    // 未知错误
+    return {
+      type: ErrorTypeEnum.UNKNOWN,
+      level: this.levelMapping[ErrorTypeEnum.UNKNOWN],
+      originalError: error,
+    };
+  }
+
+  /**
+   * 获取错误类型对应的失败等级
+   */
+  getLevel(type: ErrorType): FailureLevel {
+    return this.levelMapping[type] ?? FailureLevelEnum.L2;
+  }
+
+  /**
+   * 添加自定义规则
+   */
+  addRule(rule: ErrorClassificationRule): void {
+    // 自定义规则插入到前面，优先匹配
+    this.rules.unshift(rule);
+  }
+
+  /**
+   * 获取所有规则
+   */
+  getRules(): ErrorClassificationRule[] {
+    return [...this.rules];
+  }
+
+  /**
+   * 匹配规则
+   */
+  private matchRule(message: string, name: string, rule: ErrorClassificationRule): boolean {
+    // 检查关键词
+    if (rule.keywords && rule.keywords.length > 0) {
+      const textToMatch = `${message} ${name}`;
+      const hasKeyword = rule.keywords.some((kw) =>
+        textToMatch.includes(kw.toLowerCase())
+      );
+      if (hasKeyword) {
+        return true;
+      }
+    }
+
+    // 检查正则模式
+    if (rule.patterns && rule.patterns.length > 0) {
+      const textToMatch = `${message} ${name}`;
+      const hasPattern = rule.patterns.some((pattern) => pattern.test(textToMatch));
+      if (hasPattern) {
+        return true;
+      }
+    }
+
+    return false;
+  }
+}
+
+/**
+ * 创建错误分类器
+ */
+export function createErrorClassifier(
+  config?: ErrorClassifierConfig
+): ErrorClassifier {
+  return new ErrorClassifier(config);
+}
+
+/**
+ * 快速分类错误（无需创建实例）
+ */
+export function classifyError(error: Error): ErrorType {
+  const classifier = new ErrorClassifier();
+  return classifier.classify(error).type;
+}
+
+/**
+ * 快速获取失败等级
+ */
+export function getFailureLevel(type: ErrorType): FailureLevel {
+  return DEFAULT_LEVEL_MAPPING[type] ?? FailureLevelEnum.L2;
+}