principles-disciple 1.35.0 → 1.37.0

package/tests/core/pain-score.property.test.ts

@@ -0,0 +1,205 @@
+/**
+ * Property-based tests for Pain Score computation
+ * 
+ * These tests verify INVARIANTS - mathematical properties that MUST hold
+ * for ALL possible inputs, not just a few hand-picked examples.
+ * 
+ * Using fast-check for property-based testing.
+ */
+
+import { describe, it, expect } from 'vitest';
+import fc from 'fast-check';
+import { computePainScore, painSeverityLabel } from '../../src/core/pain.js';
+
+// ─────────────────────────────────────────────────────────────────────
+// PROPERTY 1: Score Range Invariant
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Property: Pain Score Range Invariant', () => {
+  it('INVARIANT: Score MUST be in [0, 100] for ALL inputs', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: -255, max: 255 }),    // exitCode (包括边界和无效值)
+        fc.boolean(),                            // isSpiral
+        fc.boolean(),                            // missingTestCommand
+        fc.integer({ min: -100, max: 200 }),    // softScore (包括越界值)
+        (exitCode, isSpiral, missingTest, softScore) => {
+          const result = computePainScore(exitCode, isSpiral, missingTest, softScore);
+          
+          // 不变量：分数必须在有效范围内
+          return result >= 0 && result <= 100;
+        }
+      ),
+      { numRuns: 1000 }  // 运行 1000 次随机测试
+    );
+  });
+
+  it('INVARIANT: Score MUST be a valid number (not NaN/Infinity)', () => {
+    fc.assert(
+      fc.property(
+        fc.integer(),
+        fc.boolean(),
+        fc.boolean(),
+        fc.integer(),
+        (exitCode, isSpiral, missingTest, softScore) => {
+          const result = computePainScore(exitCode, isSpiral, missingTest, softScore);
+          return Number.isFinite(result);
+        }
+      )
+    );
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PROPERTY 2: Monotonicity Invariant
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Property: Monotonicity Invariant', () => {
+  it('INVARIANT: Spiral MUST increase or maintain score', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 255 }),
+        fc.boolean(),
+        fc.integer({ min: 0, max: 100 }),
+        (exitCode, missingTest, softScore) => {
+          const normal = computePainScore(exitCode, false, missingTest, softScore);
+          const spiral = computePainScore(exitCode, true, missingTest, softScore);
+          
+          // 不变量：spiral 情况分数必须 >= 正常情况
+          return spiral >= normal;
+        }
+      )
+    );
+  });
+
+  it('INVARIANT: Missing test command MUST increase or maintain score', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 255 }),
+        fc.boolean(),
+        fc.integer({ min: 0, max: 100 }),
+        (exitCode, isSpiral, softScore) => {
+          const withTest = computePainScore(exitCode, isSpiral, false, softScore);
+          const withoutTest = computePainScore(exitCode, isSpiral, true, softScore);
+          
+          // 不变量：缺少测试命令时分数必须 >= 有测试命令时
+          return withoutTest >= withTest;
+        }
+      )
+    );
+  });
+
+  it('INVARIANT: Higher softScore MUST produce higher or equal total score', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 255 }),
+        fc.boolean(),
+        fc.boolean(),
+        fc.integer({ min: 0, max: 50 }),
+        fc.integer({ min: 50, max: 100 }),  // 始终 >= 第一个 softScore
+        (exitCode, isSpiral, missingTest, softLow, softHigh) => {
+          const scoreLow = computePainScore(exitCode, isSpiral, missingTest, softLow);
+          const scoreHigh = computePainScore(exitCode, isSpiral, missingTest, softHigh);
+          
+          // 不变量：更高的 softScore 必须产生更高或相等的总分
+          return scoreHigh >= scoreLow;
+        }
+      )
+    );
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PROPERTY 3: Exit Code Effect Invariant
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Property: Exit Code Effect Invariant', () => {
+  it('INVARIANT: Non-zero exitCode MUST add penalty', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 1, max: 255 }),  // 非零 exitCode
+        fc.boolean(),
+        fc.boolean(),
+        fc.integer({ min: 0, max: 100 }),
+        (exitCode, isSpiral, missingTest, softScore) => {
+          const result = computePainScore(exitCode, isSpiral, missingTest, softScore);
+          
+          // 不变量：非零 exitCode 必须添加惩罚（>= exit_code_penalty）
+          // exit_code_penalty 默认是 70
+          return result >= 70;
+        }
+      )
+    );
+  });
+
+  it('INVARIANT: Zero exitCode MUST NOT add exit penalty', () => {
+    fc.assert(
+      fc.property(
+        fc.boolean(),
+        fc.boolean(),
+        fc.integer({ min: 0, max: 100 }),
+        (isSpiral, missingTest, softScore) => {
+          const result = computePainScore(0, isSpiral, missingTest, softScore);
+          
+          // 不变量：零 exitCode 时不添加 exit_code_penalty
+          // 所以分数应该只来自 softScore + spiral_penalty + missing_test_penalty
+          const expectedMax = softScore + (isSpiral ? 40 : 0) + (missingTest ? 30 : 0);
+          return result <= expectedMax;
+        }
+      )
+    );
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PROPERTY 4: Severity Label Invariant
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Property: Severity Label Invariant', () => {
+  it('INVARIANT: Severity label MUST match score range', () => {
+    fc.assert(
+      fc.property(
+        fc.integer({ min: 0, max: 100 }),
+        fc.boolean(),
+        (score, isSpiral) => {
+          const label = painSeverityLabel(score, isSpiral);
+          
+          // 不变量：spiral 情况必须是 critical
+          if (isSpiral) {
+            return label === 'critical';
+          }
+          
+          // 不变量：severity label 必须与 score 对应
+          if (score >= 70) return label === 'high';
+          if (score >= 40) return label === 'medium';
+          if (score >= 20) return label === 'low';
+          return label === 'info';
+        }
+      )
+    );
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// PROPERTY 5: Idempotence Invariant
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Property: Idempotence Invariant', () => {
+  it('INVARIANT: Same inputs MUST produce same output (pure function)', () => {
+    fc.assert(
+      fc.property(
+        fc.integer(),
+        fc.boolean(),
+        fc.boolean(),
+        fc.integer(),
+        (exitCode, isSpiral, missingTest, softScore) => {
+          const result1 = computePainScore(exitCode, isSpiral, missingTest, softScore);
+          const result2 = computePainScore(exitCode, isSpiral, missingTest, softScore);
+          
+          // 不变量：纯函数必须幂等
+          return result1 === result2;
+        }
+      )
+    );
+  });
+});

package/tests/integration/chaos-resilience.test.ts

@@ -0,0 +1,348 @@
+/**
+ * Chaos Engineering Tests for Principles Disciple
+ * 
+ * These tests inject failures and verify RESILIENCE - the system's ability
+ * to recover gracefully from unexpected conditions.
+ * 
+ * Based on real production data showing:
+ * - 13 failed diagnostician tasks in worker-status.json
+ * - Concurrent write scenarios
+ * - Corrupted file recovery needs
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { 
+  buildPainFlag, 
+  writePainFlag, 
+  readPainFlagData,
+  validatePainFlag 
+} from '../../src/core/pain.js';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+
+// Helper to safely remove directories
+function safeRmDir(dir: string): void {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+    // ignore
+  }
+}
+
+// ─────────────────────────────────────────────────────────────────────
+// CHAOS 1: File System Failures
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Chaos: File System Failures', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-chaos-fs-'));
+    stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    safeRmDir(workspaceDir);
+  });
+
+  it('RESILIENCE: readPainFlagData MUST NOT crash on corrupted file', () => {
+    const painFlagPath = path.join(stateDir, '.pain_flag');
+    
+    // 写入损坏的数据
+    fs.writeFileSync(painFlagPath, 'invalid content {{{ not kv format');
+    
+    // 必须不崩溃
+    const result = readPainFlagData(workspaceDir);
+    
+    // 验证：返回安全默认值
+    expect(result).toBeDefined();
+    expect(typeof result).toBe('object');
+  });
+
+  it('RESILIENCE: readPainFlagData MUST handle empty file', () => {
+    const painFlagPath = path.join(stateDir, '.pain_flag');
+    fs.writeFileSync(painFlagPath, '');
+    
+    const result = readPainFlagData(workspaceDir);
+    
+    expect(result).toBeDefined();
+  });
+
+  it('RESILIENCE: readPainFlagData MUST handle missing file gracefully', () => {
+    // 不创建文件
+    const result = readPainFlagData(workspaceDir);
+    
+    expect(result).toBeDefined();
+  });
+
+  it('RESILIENCE: validatePainFlag MUST handle invalid object inputs', () => {
+    // 各种无效对象输入
+    const invalidInputs: Record<string, string>[] = [
+      {},
+      { source: '' },
+      { source: 'test', score: 'invalid' },
+      { source: 'test', score: '50' },
+      { source: 'test', score: '50', time: '' },
+    ];
+
+    for (const input of invalidInputs) {
+      const result = validatePainFlag(input);
+      expect(Array.isArray(result)).toBe(true);  // 返回缺失字段列表
+    }
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// CHAOS 2: Concurrent Operations
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Chaos: Concurrent Operations', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-chaos-concurrent-'));
+    stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    safeRmDir(workspaceDir);
+  });
+
+  it('RESILIENCE: Sequential writes MUST preserve last value', () => {
+    const painFlagPath = path.join(stateDir, '.pain_flag');
+    
+    // 连续写入 100 次
+    for (let i = 0; i < 100; i++) {
+      writePainFlag(workspaceDir, buildPainFlag({
+        source: 'sequential_test',
+        score: String(i),
+        reason: `Iteration ${i}`,
+      }));
+    }
+    
+    // 验证：最后一次写入生效
+    const result = readPainFlagData(workspaceDir);
+    expect(result.score).toBe('99');
+    expect(result.reason).toBe('Iteration 99');
+  });
+
+  it('RESILIENCE: File MUST NOT contain corrupted data after writes', () => {
+    const painFlagPath = path.join(stateDir, '.pain_flag');
+    
+    for (let i = 0; i < 50; i++) {
+      writePainFlag(workspaceDir, buildPainFlag({
+        source: `test_${i}`,
+        score: String(i),
+        reason: `Test ${i}`,
+        session_id: `session-${i}`,
+        agent_id: 'test-agent',
+      }));
+    }
+    
+    const content = fs.readFileSync(painFlagPath, 'utf-8');
+    
+    // 不应该有损坏的内容
+    expect(content).not.toContain('undefined');
+    expect(content).not.toContain('[object Object]');
+    expect(content).not.toContain('NaN');
+    expect(content).not.toContain('null');
+    expect(content).not.toContain('function');
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// CHAOS 3: Database Resilience
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Chaos: Database Resilience', () => {
+  let workspaceDir: string;
+  let trajectory: TrajectoryDatabase;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-chaos-db-'));
+    trajectory = new TrajectoryDatabase({ workspaceDir });
+  });
+
+  afterEach(() => {
+    trajectory?.dispose();
+    safeRmDir(workspaceDir);
+  });
+
+  it('RESILIENCE: Database MUST handle dispose and reopen correctly', () => {
+    // 写入数据
+    trajectory.recordSession({ 
+      sessionId: 'test-session', 
+      startedAt: new Date().toISOString() 
+    });
+    trajectory.recordToolCall({
+      sessionId: 'test-session',
+      toolName: 'test_tool',
+      outcome: 'success',
+    });
+    
+    // 关闭
+    trajectory.dispose();
+    
+    // 重新打开
+    const trajectory2 = new TrajectoryDatabase({ workspaceDir });
+    
+    // 验证数据仍然存在
+    const stats = trajectory2.getDataStats();
+    expect(stats.toolCalls).toBe(1);
+    
+    trajectory2.dispose();
+  });
+
+  it('RESILIENCE: Database MUST handle invalid session gracefully', () => {
+    // 写入不存在的 session 的 tool call
+    // 当前实现会自动创建 session
+    expect(() => {
+      trajectory.recordToolCall({
+        sessionId: 'non-existent-session',
+        toolName: 'test',
+        outcome: 'success',
+      });
+    }).not.toThrow();
+  });
+
+  it('RESILIENCE: Database MUST handle duplicate session recording', () => {
+    // 多次记录同一个 session
+    for (let i = 0; i < 5; i++) {
+      trajectory.recordSession({ 
+        sessionId: 'same-session', 
+        startedAt: new Date().toISOString() 
+      });
+    }
+    
+    // 验证只有一个 session
+    const stats = trajectory.getDataStats();
+    expect(stats.toolCalls).toBe(0);  // 没有 tool calls
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// CHAOS 4: Malformed Input Recovery
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Chaos: Malformed Input Recovery', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-chaos-input-'));
+    stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    safeRmDir(workspaceDir);
+  });
+
+  it('RESILIENCE: buildPainFlag MUST handle all edge cases', () => {
+    const edgeCases = [
+      { source: '', score: '50', reason: '' },
+      { source: 'a'.repeat(10000), score: '50', reason: 'x'.repeat(10000) },
+      { source: 'test', score: '-1', reason: 'negative score' },
+      { source: 'test', score: '101', reason: 'overflow score' },
+      { source: 'test', score: '50.5', reason: 'decimal score' },
+      { source: 'test', score: 'NaN', reason: 'NaN score' },
+      { source: 'test\nwith\nnewlines', score: '50', reason: 'multiline\nreason' },
+      { source: 'test<script>', score: '50', reason: 'xss<script>alert(1)</script>' },
+    ];
+
+    for (const input of edgeCases) {
+      expect(() => buildPainFlag(input)).not.toThrow();
+    }
+  });
+
+  it('RESILIENCE: writePainFlag MUST sanitize special characters', () => {
+    writePainFlag(workspaceDir, buildPainFlag({
+      source: 'test\nwith\nnewlines',
+      score: '50',
+      reason: 'reason\twith\ttabs',
+    }));
+
+    const content = fs.readFileSync(path.join(stateDir, '.pain_flag'), 'utf-8');
+    
+    // 文件应该可以正常读取
+    expect(content).toBeDefined();
+    expect(content.length).toBeGreaterThan(0);
+  });
+});
+
+// ─────────────────────────────────────────────────────────────────────
+// CHAOS 5: Edge Case Discovery (based on production data)
+// ─────────────────────────────────────────────────────────────────────
+
+describe('Chaos: Production Data Patterns', () => {
+  let workspaceDir: string;
+  let stateDir: string;
+
+  beforeEach(() => {
+    workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-chaos-prod-'));
+    stateDir = path.join(workspaceDir, '.state');
+    fs.mkdirSync(stateDir, { recursive: true });
+  });
+
+  afterEach(() => {
+    safeRmDir(workspaceDir);
+  });
+
+  it('RESILIENCE: Pain flag without session_id MUST be valid', () => {
+    // 生产数据中 session_id 可能为空
+    writePainFlag(workspaceDir, buildPainFlag({
+      source: 'tool_failure',
+      score: '80',
+      reason: 'Test without session',
+      session_id: '',
+      agent_id: '',
+    }));
+
+    const result = readPainFlagData(workspaceDir);
+    expect(result.source).toBe('tool_failure');
+    expect(result.score).toBe('80');
+  });
+
+  it('RESILIENCE: Multiple pain sources MUST be distinguishable', () => {
+    const sources = [
+      'tool_failure',
+      'user_feedback', 
+      'human_intervention',
+      'manual',
+      'gate_block',
+    ];
+
+    for (const source of sources) {
+      writePainFlag(workspaceDir, buildPainFlag({
+        source,
+        score: '50',
+        reason: `Test ${source}`,
+      }));
+    }
+
+    // 最后一个写入应该生效
+    const result = readPainFlagData(workspaceDir);
+    expect(result.source).toBe('gate_block');
+  });
+
+  it('RESILIENCE: Timestamp MUST be valid ISO format', () => {
+    writePainFlag(workspaceDir, buildPainFlag({
+      source: 'test',
+      score: '50',
+      reason: 'timestamp test',
+    }));
+
+    const result = readPainFlagData(workspaceDir);
+    
+    // 验证时间戳是有效的 ISO 格式
+    const timestamp = new Date(result.time);
+    expect(timestamp).toBeInstanceOf(Date);
+    expect(isNaN(timestamp.getTime())).toBe(false);
+  });
+});