principles-disciple 1.8.0 → 1.8.2

package/tests/core/risk-calculator.test.ts

@@ -0,0 +1,168 @@
+import { describe, it, expect, vi } from 'vitest';
+import { estimateLineChanges, assessRiskLevel, getTargetFileLineCount, calculatePercentageThreshold } from '../../src/core/risk-calculator.js';
+import * as ioUtils from '../../src/utils/io.js';
+import * as fs from 'fs';
+
+vi.mock('../../src/utils/io.js');
+vi.mock('fs');
+
+describe('Risk Calculator', () => {
+    it('should estimate line changes correctly for write_file', () => {
+        const lines = estimateLineChanges({
+            toolName: 'write_file',
+            params: { content: 'line1\nline2\nline3' }
+        });
+        expect(lines).toBe(3);
+    });
+
+    it('should estimate line changes correctly for replace', () => {
+        const lines = estimateLineChanges({
+            toolName: 'replace',
+            params: { new_string: 'a\nb\nc\nd\ne' }
+        });
+        expect(lines).toBe(5);
+    });
+
+    it('should estimate 50 for delete_file', () => {
+        const lines = estimateLineChanges({
+            toolName: 'delete_file',
+            params: {}
+        });
+        expect(lines).toBe(50);
+    });
+
+    it('should assess risk level correctly', () => {
+        // High risk path, large change
+        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(true);
+        let level = assessRiskLevel('src/core.ts', { toolName: 'write', params: { content: Array(105).fill('a').join('\n') } }, ['src/']);
+        expect(level).toBe('CRITICAL');
+
+        // High risk path, small change
+        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(true);
+        level = assessRiskLevel('src/core.ts', { toolName: 'write', params: { content: 'a\nb' } }, ['src/']);
+        expect(level).toBe('HIGH');
+
+        // Low risk path, large change
+        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(false);
+        level = assessRiskLevel('docs/readme.md', { toolName: 'write', params: { content: Array(105).fill('a').join('\n') } }, ['src/']);
+        expect(level).toBe('HIGH');
+
+        // Low risk path, medium change
+        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(false);
+        level = assessRiskLevel('docs/readme.md', { toolName: 'write', params: { content: Array(15).fill('a').join('\n') } }, ['src/']);
+        expect(level).toBe('MEDIUM');
+
+        // Low risk path, small change
+        vi.mocked(ioUtils.isRisky).mockReturnValueOnce(false);
+        level = assessRiskLevel('docs/readme.md', { toolName: 'write', params: { content: 'a\nb' } }, ['src/']);
+        expect(level).toBe('LOW');
+    });
+});
+
+describe('getTargetFileLineCount', () => {
+    it('should return line count when file exists and is readable', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => true } as any);
+        vi.mocked(fs.readFileSync).mockReturnValue('line1\nline2\nline3\n');
+        
+        const count = getTargetFileLineCount('/some/file.txt');
+        expect(count).toBe(4);
+    });
+
+    it('should return null when file does not exist', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(false);
+        
+        const count = getTargetFileLineCount('/nonexistent/file.txt');
+        expect(count).toBeNull();
+    });
+
+    it('should return null when path is not a regular file', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => false } as any);
+        
+        const count = getTargetFileLineCount('/some/directory');
+        expect(count).toBeNull();
+    });
+
+    it('should return null and log error when file cannot be read', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => true } as any);
+        vi.mocked(fs.readFileSync).mockImplementation(() => {
+            const err = new Error('Permission denied');
+            (err as any).code = 'EACCES';
+            throw err;
+        });
+        
+        const consoleSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+        
+        const count = getTargetFileLineCount('/some/file.txt');
+        expect(count).toBeNull();
+        expect(consoleSpy).toHaveBeenCalledWith(
+            expect.stringContaining('[PD:RISK_CALC] Failed to read file'),
+            expect.objectContaining({ code: 'EACCES' })
+        );
+        
+        consoleSpy.mockRestore();
+    });
+
+    it('should return 1 for file with no newlines', () => {
+        vi.mocked(fs.existsSync).mockReturnValue(true);
+        vi.mocked(fs.statSync).mockReturnValue({ isFile: () => true } as any);
+        vi.mocked(fs.readFileSync).mockReturnValue('single line content');
+        
+        const count = getTargetFileLineCount('/some/file.txt');
+        expect(count).toBe(1);
+    });
+});
+
+describe('calculatePercentageThreshold', () => {
+    it('should calculate percentage correctly', () => {
+        // 10% of 100 lines = 10 lines
+        const limit = calculatePercentageThreshold(100, 10, 5);
+        expect(limit).toBe(10);
+    });
+
+    it('should enforce minimum floor', () => {
+        // 5% of 100 lines = 5 lines, but min is 20, so result is 20
+        const limit = calculatePercentageThreshold(100, 5, 20);
+        expect(limit).toBe(20);
+    });
+
+    it('should round correctly', () => {
+        // 10% of 99 lines = 9.9, rounds to 10
+        const limit = calculatePercentageThreshold(99, 10, 5);
+        expect(limit).toBe(10);
+    });
+
+    it('should handle zero percentage', () => {
+        const limit = calculatePercentageThreshold(100, 0, 20);
+        expect(limit).toBe(20); // minLines is the floor
+    });
+
+    it('should handle 100 percentage', () => {
+        const limit = calculatePercentageThreshold(100, 100, 20);
+        expect(limit).toBe(100);
+    });
+
+    it('should clamp negative percentage to 0', () => {
+        const limit = calculatePercentageThreshold(100, -10, 20);
+        expect(limit).toBe(20); // minLines is the floor
+    });
+
+    it('should clamp percentage over 100 to 100', () => {
+        const limit = calculatePercentageThreshold(100, 150, 20);
+        expect(limit).toBe(100);
+    });
+
+    it('should respect maxLines upper bound', () => {
+        // 15% of 1000 lines = 150, but max is 100
+        const limit = calculatePercentageThreshold(1000, 15, 20, 100);
+        expect(limit).toBe(100);
+    });
+
+    it('should use minLines when both floor and ceiling apply', () => {
+        // 1% of 100 lines = 1, but min is 20, ceiling doesn't apply
+        const limit = calculatePercentageThreshold(100, 1, 20, 50);
+        expect(limit).toBe(20);
+    });
+});

package/tests/core/session-tracker.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import {
+    trackToolRead,
+    trackLlmOutput,
+    getSession,
+    clearSession,
+    trackFriction,
+    resetFriction,
+    initPersistence,
+    trackBlock,
+    recordThinkingCheckpoint,
+} from '../../src/core/session-tracker.js';
+
+describe('Session Tracker', () => {
+    const sessionId = 'test-session-1';
+    let tempDir: string | null = null;
+
+    beforeEach(() => {
+        clearSession(sessionId);
+    });
+
+    afterEach(() => {
+        if (tempDir) {
+            fs.rmSync(tempDir, { recursive: true, force: true });
+            tempDir = null;
+        }
+        vi.useRealTimers();
+        clearSession('session-a');
+        clearSession('session-b');
+    });
+
+    it('should track tool reads per file', () => {
+        trackToolRead(sessionId, 'src/main.ts');
+        trackToolRead(sessionId, 'src/main.ts');
+        trackToolRead(sessionId, 'docs/README.md');
+
+        const state = getSession(sessionId);
+        expect(state).toBeDefined();
+        expect(state?.toolReadsByFile['src/main.ts']).toBe(2);
+        expect(state?.toolReadsByFile['docs/README.md']).toBe(1);
+    });
+
+    it('should detect stuck loops (paralysis) on high input / tiny output', () => {
+        // 1st turn
+        trackLlmOutput(sessionId, { input: 100, output: 500 });
+        // 2nd turn
+        trackLlmOutput(sessionId, { input: 8500, output: 20 });
+        // 3rd turn
+        trackLlmOutput(sessionId, { input: 8800, output: 15 });
+        // 4th turn
+        trackLlmOutput(sessionId, { input: 9000, output: 10 });
+        // 5th turn
+        trackLlmOutput(sessionId, { input: 9100, output: 8 });
+
+        let state = getSession(sessionId);
+        expect(state?.stuckLoops).toBe(0); // Needs > 5 turns total
+
+        // 6th turn (should trigger loop detection)
+        trackLlmOutput(sessionId, { input: 9200, output: 10 });
+        state = getSession(sessionId);
+        expect(state?.stuckLoops).toBe(1);
+
+        // 7th turn (continues loop)
+        trackLlmOutput(sessionId, { input: 9300, output: 5 });
+        state = getSession(sessionId);
+        expect(state?.stuckLoops).toBe(2);
+
+        // 8th turn (breaks out, high output)
+        trackLlmOutput(sessionId, { input: 9400, output: 300 });
+        state = getSession(sessionId);
+        expect(state?.stuckLoops).toBe(1); // decrements
+    });
+
+    it('should accumulate friction and reset on success', () => {
+        const errorHash = 'abc-123';
+        
+        // 1st error
+        trackFriction(sessionId, 30, errorHash);
+        let state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(30);
+        expect(state?.consecutiveErrors).toBe(1);
+
+        // 2nd identical error (multiplier 1.5^1 = 1.5)
+        trackFriction(sessionId, 30, errorHash);
+        state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(30 + (30 * 1.5)); // 75
+        expect(state?.consecutiveErrors).toBe(2);
+
+        // 3rd identical error (multiplier 1.5^2 = 2.25)
+        trackFriction(sessionId, 30, errorHash);
+        state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(75 + (30 * 2.25)); // 75 + 67.5 = 142.5
+        expect(state?.consecutiveErrors).toBe(3);
+
+        // Success should reset GFI
+        resetFriction(sessionId);
+        state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(0);
+        expect(state?.consecutiveErrors).toBe(0);
+        expect(state?.gfiBySource).toEqual({});
+    });
+
+    it('should reset multiplier on different error hash', () => {
+        trackFriction(sessionId, 30, 'hash-1');
+        trackFriction(sessionId, 30, 'hash-2');
+        
+        let state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(60); // 30 + 30
+        expect(state?.consecutiveErrors).toBe(1); // reset to 1 for new hash
+    });
+
+    it('should rollback only the empathy source slice instead of wiping total gfi', () => {
+        trackFriction(sessionId, 30, 'tool_failure_hash');
+        trackFriction(sessionId, 20, 'user_empathy_moderate', undefined, { source: 'user_empathy' });
+
+        let state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(50);
+        expect(state?.gfiBySource).toEqual({
+            'unattributed:tool_failure_hash': 30,
+            user_empathy: 20,
+        });
+
+        resetFriction(sessionId, undefined, { source: 'user_empathy', amount: 20 });
+
+        state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(30);
+        expect(state?.gfiBySource).toEqual({
+            'unattributed:tool_failure_hash': 30,
+        });
+        expect(state?.consecutiveErrors).toBe(0);
+        expect(state?.lastErrorHash).toBe('');
+        expect(state?.lastErrorSource).toBe('');
+    });
+
+    it('should clamp slice rollback amount and preserve other source ledger entries', () => {
+        trackFriction(sessionId, 10, 'tool_failure_hash');
+        trackFriction(sessionId, 15, 'user_empathy_mild', undefined, { source: 'user_empathy' });
+        trackFriction(sessionId, 5, 'system_empathy_warn', undefined, { source: 'system_infer' });
+
+        resetFriction(sessionId, undefined, { source: 'user_empathy', amount: 999 });
+
+        const state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(15);
+        expect(state?.gfiBySource).toEqual({
+            'unattributed:tool_failure_hash': 10,
+            system_infer: 5,
+        });
+    });
+
+    it('should ignore slice rollback for a source that does not exist', () => {
+        trackFriction(sessionId, 12, 'tool_failure_hash');
+
+        resetFriction(sessionId, undefined, { source: 'user_empathy', amount: 7 });
+
+        const state = getSession(sessionId);
+        expect(state?.currentGfi).toBe(12);
+        expect(state?.gfiBySource).toEqual({
+            'unattributed:tool_failure_hash': 12,
+        });
+        expect(state?.consecutiveErrors).toBe(1);
+        expect(state?.lastErrorHash).toBe('tool_failure_hash');
+    });
+
+    it('should persist multiple sessions independently instead of overwriting the previous debounce timer', () => {
+        vi.useFakeTimers();
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-session-persist-'));
+        initPersistence(tempDir);
+
+        trackFriction('session-a', 10, 'hash-a', tempDir);
+        trackFriction('session-b', 15, 'hash-b', tempDir);
+
+        vi.advanceTimersByTime(1000);
+
+        expect(fs.existsSync(path.join(tempDir, 'sessions', 'session-a.json'))).toBe(true);
+        expect(fs.existsSync(path.join(tempDir, 'sessions', 'session-b.json'))).toBe(true);
+    });
+
+    it('should refresh control activity timestamps for block and thinking updates', () => {
+        trackBlock(sessionId);
+        let state = getSession(sessionId);
+        const blockTs = state?.lastControlActivityAt ?? 0;
+        expect(blockTs).toBeGreaterThan(0);
+
+        recordThinkingCheckpoint(sessionId);
+        state = getSession(sessionId);
+        expect((state?.lastControlActivityAt ?? 0) >= blockTs).toBe(true);
+    });
+});