principles-disciple 1.8.1 → 1.8.2

package/tests/core/empathy-keyword-matcher.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import {
+  matchEmpathyKeywords,
+  loadKeywordStore,
+  saveKeywordStore,
+  shouldTriggerOptimization,
+  createDefaultKeywordStore,
+  applyKeywordUpdates,
+  getKeywordStoreSummary,
+} from '../../src/core/empathy-keyword-matcher.js';
+import {
+  EMPATHY_SEED_KEYWORDS,
+  DEFAULT_EMPATHY_KEYWORD_CONFIG,
+  scoreToSeverity,
+  severityToPenalty,
+} from '../../src/core/empathy-types.js';
+
+// Mock fs to avoid file system dependencies
+vi.mock('fs', () => ({
+  existsSync: vi.fn(() => false),
+  readFileSync: vi.fn(() => ''),
+  writeFileSync: vi.fn(),
+  mkdirSync: vi.fn(),
+  rmSync: vi.fn(),
+}));
+
+describe('Empathy Keyword Matcher', () => {
+  describe('createDefaultKeywordStore', () => {
+    it('should create store with Chinese keywords', () => {
+      const store = createDefaultKeywordStore('zh');
+
+      expect(store.version).toBe(1);
+      expect(Object.keys(store.terms).length).toBeGreaterThan(0);
+
+      const chineseTerms = Object.keys(store.terms).filter(t => /[\u4e00-\u9fa5]/.test(t));
+      expect(chineseTerms.length).toBeGreaterThan(0);
+    });
+
+    it('should create store with only English keywords', () => {
+      const store = createDefaultKeywordStore('en');
+
+      const chineseTerms = Object.keys(store.terms).filter(t => /[\u4e00-\u9fa5]/.test(t));
+      expect(chineseTerms.length).toBe(0);
+    });
+
+    it('should differentiate FPR based on keyword specificity', () => {
+      const store = createDefaultKeywordStore('zh');
+
+      // Strong anger keywords should have low FPR
+      expect(store.terms['垃圾'].falsePositiveRate).toBe(0.05);
+      expect(store.terms['废物'].falsePositiveRate).toBe(0.05);
+
+      // Generic negation should have higher FPR
+      expect(store.terms['不对'].falsePositiveRate).toBe(0.3);
+      expect(store.terms['不行'].falsePositiveRate).toBe(0.35);
+
+      // All FPR values should be in reasonable range
+      for (const entry of Object.values(store.terms)) {
+        expect(entry.falsePositiveRate).toBeGreaterThanOrEqual(0.05);
+        expect(entry.falsePositiveRate).toBeLessThanOrEqual(0.35);
+      }
+    });
+  });
+
+  describe('matchEmpathyKeywords', () => {
+    it('should detect keywords in Chinese text', () => {
+      const store = createDefaultKeywordStore('zh');
+      const result = matchEmpathyKeywords('这个不对，你搞错了', store);
+      
+      expect(result.matched).toBe(true);
+      expect(result.matchedTerms.length).toBeGreaterThan(0);
+    });
+
+    it('should detect keywords in English text', () => {
+      const store = createDefaultKeywordStore('en');
+      const result = matchEmpathyKeywords('This is garbage', store);
+      
+      expect(result.matched).toBe(true);
+      expect(result.matchedTerms).toContain('garbage');
+    });
+
+    it('should return no match for empty text', () => {
+      const store = createDefaultKeywordStore('zh');
+      const result = matchEmpathyKeywords('', store);
+      
+      expect(result.matched).toBe(false);
+      expect(result.score).toBe(0);
+    });
+
+    it('should calculate severity correctly', () => {
+      const store = createDefaultKeywordStore('zh');
+      const result = matchEmpathyKeywords('垃圾 蠢 废物', store);
+      
+      expect(result.severity).toBe('severe');
+    });
+
+    it('should respect matchThreshold', () => {
+      const store = createDefaultKeywordStore('zh');
+      const strictConfig = { ...DEFAULT_EMPATHY_KEYWORD_CONFIG, matchThreshold: 0.95 };
+      const result = matchEmpathyKeywords('不行啊', store, strictConfig);
+      
+      expect(result.matched).toBe(false);
+    });
+
+    it('should cap score at 1.0', () => {
+      const store = createDefaultKeywordStore('zh');
+      const result = matchEmpathyKeywords('垃圾 蠢 废物 白做 浪费时间', store);
+      
+      expect(result.score).toBeLessThanOrEqual(1);
+    });
+
+    it('should handle null/undefined gracefully', () => {
+      const store = createDefaultKeywordStore('zh');
+      
+      expect(matchEmpathyKeywords(null as any, store).matched).toBe(false);
+      expect(matchEmpathyKeywords(undefined as any, store).matched).toBe(false);
+    });
+  });
+
+  describe('applyKeywordUpdates', () => {
+    it('should add new keywords', () => {
+      const store = createDefaultKeywordStore('zh');
+      const updates = {
+        'newKeyword': {
+          action: 'add' as const,
+          weight: 0.7,
+          falsePositiveRate: 0.15,
+        },
+      };
+
+      const result = applyKeywordUpdates(store, updates);
+      
+      expect(result.added).toBe(1);
+      expect(store.terms['newKeyword']).toBeDefined();
+    });
+
+    it('should remove keywords', () => {
+      const store = createDefaultKeywordStore('zh');
+      const firstTerm = Object.keys(store.terms)[0];
+      const updates = {
+        [firstTerm]: {
+          action: 'remove' as const,
+        },
+      };
+
+      const result = applyKeywordUpdates(store, updates);
+      
+      expect(result.removed).toBe(1);
+      expect(store.terms[firstTerm]).toBeUndefined();
+    });
+  });
+
+  describe('shouldTriggerOptimization', () => {
+    it('should return true when turns exceed interval', () => {
+      const store = createDefaultKeywordStore('zh');
+      expect(shouldTriggerOptimization(store, 150)).toBe(true);
+    });
+
+    it('should return false when turns are below interval', () => {
+      const store = createDefaultKeywordStore('zh');
+      expect(shouldTriggerOptimization(store, 10)).toBe(false);
+    });
+  });
+
+  describe('getKeywordStoreSummary', () => {
+    it('should return correct counts', () => {
+      const store = createDefaultKeywordStore('zh');
+      const summary = getKeywordStoreSummary(store);
+      
+      expect(summary.totalTerms).toBe(Object.keys(store.terms).length);
+      expect(summary.seedTerms).toBeGreaterThan(0);
+    });
+
+    it('should return top hit terms sorted', () => {
+      const store = createDefaultKeywordStore('zh');
+      
+      // Simulate hits
+      for (let i = 0; i < 5; i++) matchEmpathyKeywords('垃圾', store);
+      for (let i = 0; i < 3; i++) matchEmpathyKeywords('不对', store);
+      
+      const summary = getKeywordStoreSummary(store);
+      
+      expect(summary.topHitTerms.length).toBeGreaterThan(0);
+      // Verify sorted order
+      for (let i = 0; i < summary.topHitTerms.length - 1; i++) {
+        expect(summary.topHitTerms[i].hitCount).toBeGreaterThanOrEqual(
+          summary.topHitTerms[i + 1].hitCount
+        );
+      }
+    });
+  });
+
+  describe('Utility Functions', () => {
+    it('scoreToSeverity should map correctly', () => {
+      expect(scoreToSeverity(0.1)).toBe('mild');
+      expect(scoreToSeverity(0.4)).toBe('moderate');
+      expect(scoreToSeverity(0.8)).toBe('severe');
+    });
+
+    it('severityToPenalty should return correct values', () => {
+      expect(severityToPenalty('mild')).toBe(10);
+      expect(severityToPenalty('moderate')).toBe(25);
+      expect(severityToPenalty('severe')).toBe(40);
+    });
+  });
+});

package/tests/core/event-log.test.ts

@@ -0,0 +1,181 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { EventLogService, EventLog } from '../../src/core/event-log.js';
+import type { DailyStats, DeepReflectionEventData } from '../../src/types/event-types.js';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('EventLog', () => {
+  let tempDir: string;
+  let eventLog: EventLog;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'event-log-test-'));
+    eventLog = new EventLog(tempDir);
+  });
+
+  afterEach(() => {
+    eventLog.dispose();
+    fs.rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('recordDeepReflection', () => {
+    it('should record deep reflection event', () => {
+      const data: DeepReflectionEventData = {
+        modelId: 'claude-sonnet-4',
+        modelSelectionMode: 'auto',
+        confidenceScore: 0.85,
+        insightsGenerated: 3,
+        durationMs: 1500,
+        passed: true
+      };
+
+      eventLog.recordDeepReflection('session-1', data);
+      eventLog.flush();
+
+      const eventsFile = path.join(tempDir, 'logs', 'events.jsonl');
+      const content = fs.readFileSync(eventsFile, 'utf-8');
+      const event = JSON.parse(content.trim());
+
+      expect(event.type).toBe('deep_reflection');
+      expect(event.category).toBe('passed');
+      expect(event.data.modelId).toBe('claude-sonnet-4');
+      expect(event.data.modelSelectionMode).toBe('auto');
+    });
+  });
+
+  describe('DailyStats', () => {
+    it('should aggregate tool call statistics correctly', () => {
+      // Record multiple tool calls
+      eventLog.recordToolCall('s1', { toolName: 'write', error: undefined });
+      eventLog.recordToolCall('s1', { toolName: 'read', error: undefined });
+      eventLog.recordToolCall('s1', { toolName: 'write', error: 'EACCES' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      // This is the critical assertion - ensures DailyStats.tools field exists
+      expect(stats.tools).toBeDefined();
+      expect(stats.tools.total).toBe(3);
+      expect(stats.tools.success).toBe(2);
+      expect(stats.tools.failure).toBe(1);
+    });
+
+    it('should have correct DailyStats structure', () => {
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      // Verify all required fields exist
+      expect(stats.date).toBe(today);
+      expect(stats.createdAt).toBeDefined();
+      expect(stats.updatedAt).toBeDefined();
+      
+      // Tools field (the one that was missing)
+      expect(stats.tools).toEqual({
+        total: 0,
+        success: 0,
+        failure: 0
+      });
+      
+      // ToolCalls field
+      expect(stats.toolCalls).toBeDefined();
+      expect(stats.toolCalls.total).toBe(0);
+      
+      // Errors field
+      expect(stats.errors).toBeDefined();
+      
+      // Pain field
+      expect(stats.pain).toBeDefined();
+      
+      // GFI field
+      expect(stats.gfi).toBeDefined();
+      
+      // Evolution field
+      expect(stats.evolution).toBeDefined();
+      
+      // Hooks field
+      expect(stats.hooks).toBeDefined();
+      
+      // Deep Reflection field
+      expect(stats.deepReflection).toBeDefined();
+    });
+
+    it('should increment tools.failure on error', () => {
+      eventLog.recordToolCall('s1', { toolName: 'bash', error: 'ENOENT' });
+
+      const today = new Date().toISOString().slice(0, 10);
+      const stats = eventLog.getDailyStats(today);
+
+      expect(stats.tools.failure).toBe(1);
+      expect(stats.tools.success).toBe(0);
+    });
+  });
+
+  describe('EventLogService', () => {
+    it('should provide singleton access', () => {
+      const logger1 = EventLogService.get(tempDir);
+      const logger2 = EventLogService.get(tempDir);
+
+      expect(logger1).toBe(logger2);
+      
+      logger1.dispose();
+    });
+
+    it('should dispose and clear all cached instances', () => {
+      const dirA = fs.mkdtempSync(path.join(os.tmpdir(), 'event-log-service-a-'));
+      const dirB = fs.mkdtempSync(path.join(os.tmpdir(), 'event-log-service-b-'));
+
+      try {
+        const loggerA = EventLogService.get(dirA);
+        const loggerB = EventLogService.get(dirB);
+
+        const disposeSpyA = vi.spyOn(loggerA, 'dispose');
+        const disposeSpyB = vi.spyOn(loggerB, 'dispose');
+
+        EventLogService.disposeAll();
+
+        expect(disposeSpyA).toHaveBeenCalled();
+        expect(disposeSpyB).toHaveBeenCalled();
+        expect(EventLogService.get(dirA)).not.toBe(loggerA);
+      } finally {
+        EventLogService.disposeAll();
+        fs.rmSync(dirA, { recursive: true, force: true });
+        fs.rmSync(dirB, { recursive: true, force: true });
+      }
+    });
+  });
+
+  describe('session empathy aggregation', () => {
+    it('should deduplicate the same empathy event across file and buffer using eventId', () => {
+      eventLog.recordPainSignal('session-1', {
+        source: 'user_empathy',
+        score: 12,
+        reason: 'duplicate check',
+        origin: 'assistant_self_report',
+        severity: 'mild',
+        confidence: 1,
+        detection_mode: 'structured',
+        deduped: false,
+        eventId: 'evt-1',
+      });
+      eventLog.flush();
+
+      eventLog.recordPainSignal('session-1', {
+        source: 'user_empathy',
+        score: 12,
+        reason: 'duplicate check',
+        origin: 'assistant_self_report',
+        severity: 'mild',
+        confidence: 1,
+        detection_mode: 'structured',
+        deduped: false,
+        eventId: 'evt-1',
+      });
+
+      const stats = eventLog.getEmpathyStats('session', 'session-1');
+
+      expect(stats.totalEvents).toBe(1);
+      expect(stats.totalPenaltyScore).toBe(12);
+    });
+  });
+});

package/tests/core/evolution-e2e.test.ts

@@ -0,0 +1,58 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { EvolutionReducerImpl } from '../../src/core/evolution-reducer.js';
+import { handleEvolutionStatusCommand } from '../../src/commands/evolution-status.js';
+
+const tempDirs: string[] = [];
+function makeTempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-evolution-e2e-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('evolution loop e2e', () => {
+  it('runs pain -> create principle -> status query -> rollback flow', () => {
+    const workspace = makeTempDir();
+    const reducer = new EvolutionReducerImpl({ workspaceDir: workspace });
+
+    // Emit pain (no longer creates principle automatically)
+    reducer.emitSync({
+      ts: new Date().toISOString(),
+      type: 'pain_detected',
+      data: {
+        painId: 'pain-e2e-1',
+        painType: 'tool_failure',
+        source: 'write',
+        reason: 'write failed on risky file',
+      },
+    });
+
+    // Create principle from diagnosis
+    const principleId = reducer.createPrincipleFromDiagnosis({
+      painId: 'pain-e2e-1',
+      painType: 'tool_failure',
+      triggerPattern: 'file write operation fails on risky files',
+      action: 'verify file permissions before writing',
+      source: 'write',
+    });
+
+    const p = reducer.getProbationPrinciples()[0];
+    expect(p).toBeDefined();
+
+    const statusBefore = handleEvolutionStatusCommand({ config: { workspaceDir: workspace, language: 'en' } } as any);
+    expect(statusBefore.text).toContain('probation principles: 1');
+
+    reducer.rollbackPrinciple(p.id, 'manual validation failed');
+
+    const statusAfter = handleEvolutionStatusCommand({ config: { workspaceDir: workspace, language: 'en' } } as any);
+    expect(statusAfter.text).toContain('deprecated principles: 1');
+  });
+});