principles-disciple 1.8.0 → 1.8.2

package/tests/hooks/pain.test.ts

@@ -0,0 +1,141 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { handleAfterToolCall } from '../../src/hooks/pain';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as ioUtils from '../../src/utils/io';
+import { WorkspaceContext } from '../../src/core/workspace-context';
+import { EventLogService } from '../../src/core/event-log';
+import { setInjectedProbationIds, clearSession } from '../../src/core/session-tracker';
+
+vi.mock('fs');
+vi.mock('../../src/utils/io.js');
+vi.mock('../../src/core/workspace-context');
+vi.mock('../../src/core/event-log');
+
+const mockEmitSync = vi.fn();
+const mockRecordProbationFeedback = vi.fn();
+
+describe('Post-Write Checks & Pain Hook', () => {
+  const workspaceDir = '/mock/workspace';
+  const mockEventLog = {
+    recordToolCall: vi.fn(),
+    recordPainSignal: vi.fn(),
+  };
+  const mockConfig = {
+    get: vi.fn().mockReturnValue(30),
+  };
+
+  const mockWctx = {
+    workspaceDir,
+    stateDir: '/mock/state',
+    config: mockConfig,
+    eventLog: mockEventLog,
+    trajectory: {
+      recordToolCall: vi.fn(),
+      recordPainEvent: vi.fn(),
+    },
+    evolutionReducer: {
+      emitSync: mockEmitSync,
+      recordProbationFeedback: mockRecordProbationFeedback,
+      getPrincipleById: vi.fn().mockImplementation((id: string) => id === 'p-match' ? ({ contextTags: ['write'], trigger: 'write' }) : ({ contextTags: ['bash'], trigger: 'bash' })),
+    },
+    resolve: vi.fn().mockImplementation((key) => {
+        if (key === 'PROFILE') return path.join(workspaceDir, '.principles', 'PROFILE.json');
+        return '';
+    }),
+  };
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockEmitSync.mockReset();
+    mockRecordProbationFeedback.mockReset();
+    vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
+    vi.mocked(EventLogService.get).mockReturnValue(mockEventLog as any);
+    clearSession('s-success');
+  });
+
+  it('should ignore non-write tools', () => {
+    const mockCtx = { workspaceDir, sessionId: 's1' };
+    const mockEvent = { toolName: 'read', params: {}, result: { exitCode: 0 }, error: undefined };
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+    
+    // Should still create context
+    expect(WorkspaceContext.fromHookContext).toHaveBeenCalled();
+    expect(fs.writeFileSync).not.toHaveBeenCalled();
+    expect(mockEmitSync).not.toHaveBeenCalled();
+  });
+
+  it('should capture pain on tool error with correct source', () => {
+    const mockCtx = { workspaceDir, sessionId: 's1', api: { logger: {} } };
+    const mockEvent = { 
+        toolName: 'write', 
+        params: { file_path: 'src/main.ts' },
+        error: 'Permission denied',
+        result: { exitCode: 1 } 
+    };
+
+    vi.mocked(ioUtils.normalizePath).mockReturnValue('src/main.ts');
+    vi.mocked(ioUtils.isRisky).mockReturnValue(false);
+    vi.mocked(ioUtils.serializeKvLines).mockReturnValue('mocked-pain-flag-content');
+
+    vi.mocked(fs.existsSync).mockReturnValue(true);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(fs.writeFileSync).toHaveBeenCalled();
+    const callArgs = vi.mocked(fs.writeFileSync).mock.calls[0];
+    expect(callArgs[0]).toContain('.pain_flag');
+
+    expect(mockEmitSync.toHaveBeenCalledWith(expect.objectContaining({
+      type: 'pain_detected',
+      data: expect.objectContaining({
+        painType: 'tool_failure',
+        source: 'write',
+      }),
+    }));
+    expect(mockWctx.trajectory.recordToolCall).toHaveBeenCalledWith(expect.objectContaining({
+      sessionId: 's1',
+      toolName: 'write',
+      outcome: 'failure',
+    }));
+  });
+
+
+  it('should only attribute success feedback to matching probation principles', () => {
+    const mockCtx = { workspaceDir, sessionId: 's-success', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'write',
+      params: { file_path: 'src/main.ts' },
+      result: { exitCode: 0 },
+      error: undefined,
+    };
+
+    setInjectedProbationIds('s-success', ['p-match', 'p-other'], workspaceDir);
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockRecordProbationFeedback).toHaveBeenCalledWith('p-match', true);
+    expect(mockRecordProbationFeedback).not.toHaveBeenCalledWith('p-other', true);
+  });
+
+  it('should emit evolution pain event for manual pain command', () => {
+    const mockCtx = { workspaceDir, sessionId: 's2', api: { logger: {} } };
+    const mockEvent = {
+      toolName: 'pain',
+      params: { input: 'Need help' },
+      result: { exitCode: 0 },
+      error: undefined,
+    };
+
+    handleAfterToolCall(mockEvent as any, mockCtx as any);
+
+    expect(mockEmitSync).toHaveBeenCalledWith(expect.objectContaining({
+      type: 'pain_detected',
+      data: expect.objectContaining({
+        painType: 'user_frustration',
+        source: 'pain',
+      }),
+    }));
+  });
+
+});

package/tests/hooks/progressive-trust-gate.test.ts

@@ -0,0 +1,277 @@
+/**
+ * Tests for Progressive Trust Gate Module (EP-Only Version)
+ *
+ * 2026-03-29: EP System 是唯一的门控机制
+ * - 不再有 Trust Score (30-100) 系统
+ * - 不再有 Stage 1-4 分级
+ * - 不再有基于行数的限制
+ * - EP (Evolution Points) 是唯一的门控机制
+ */
+
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import type { PluginHookBeforeToolCallEvent } from '../../src/openclaw-sdk.js';
+import {
+  checkProgressiveTrustGate,
+  buildEvolutionGateReason,
+} from '../../src/hooks/progressive-trust-gate.js';
+import { checkEvolutionGate } from '../../src/core/evolution-engine.js';
+
+// Mock dependencies
+vi.mock('../../src/core/workspace-context.js', () => ({
+  WorkspaceContext: {
+    fromHookContext: vi.fn(() => mockWctx)
+  }
+}));
+
+vi.mock('../../src/utils/io.js', () => ({
+  planStatus: vi.fn(() => 'READY'),
+  normalizePath: vi.fn((p) => p),
+  isRisky: vi.fn(() => false)
+}));
+
+vi.mock('../../src/utils/glob-match.js', () => ({
+  matchesAnyPattern: vi.fn(() => false)
+}));
+
+vi.mock('../../src/core/risk-calculator.js', () => ({
+  assessRiskLevel: vi.fn(() => 'LOW'),
+  estimateLineChanges: vi.fn(() => 10)
+}));
+
+vi.mock('../../src/core/evolution-engine.js', () => ({
+  checkEvolutionGate: vi.fn(() => ({ allowed: true, currentTier: 1 }))
+}));
+
+vi.mock('../../src/hooks/gate-block-helper.js', () => ({
+  recordGateBlockAndReturn: vi.fn((wctx, params) => ({
+    block: true,
+    blockReason: params.reason || 'Blocked'
+  }))
+}));
+
+// Mock workspace context - simplified for EP-only
+const mockWctx = {
+  config: {
+    get: vi.fn(() => ({}))
+  },
+  eventLog: {
+    recordGateBlock: vi.fn(),
+    recordPlanApproval: vi.fn()
+  },
+  trajectory: {
+    recordGateBlock: vi.fn()
+  },
+  resolve: vi.fn((key) => key)
+};
+
+describe('progressive-trust-gate (EP-Only)', () => {
+  describe('checkProgressiveTrustGate - EP System', () => {
+    let mockEvent: PluginHookBeforeToolCallEvent;
+    let mockLogger: any;
+
+    beforeEach(() => {
+      mockEvent = {
+        toolName: 'edit',
+        params: {
+          file_path: '/test/file.ts',
+          content: 'test content\n'.repeat(10)
+        }
+      } as any;
+
+      mockLogger = {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn()
+      };
+
+      // Reset EP mock
+      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
+
+      vi.clearAllMocks();
+    });
+
+    it('should allow when EP system allows', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
+
+      const result = checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/file.ts',
+        false,
+        100, // Even large changes are allowed by EP
+        mockLogger,
+        { workspaceDir: '/test', sessionId: 'test-session' },
+        {}
+      );
+
+      // EP allows, so result should be undefined (allow)
+      expect(result).toBeUndefined();
+    });
+
+    it('should block when EP system denies', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({
+        allowed: false,
+        currentTier: 1,
+        reason: 'EP Tier 1 limit: 150 lines max'
+      });
+
+      const result = checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/file.ts',
+        false,
+        200,
+        mockLogger,
+        { workspaceDir: '/test', sessionId: 'test-session' },
+        {}
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+      expect(result?.blockReason).toContain('EP');
+    });
+
+    it('should log EP decision info', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 2 });
+
+      checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/file.ts',
+        false,
+        10,
+        mockLogger,
+        { workspaceDir: '/test', sessionId: 'test-session' },
+        {}
+      );
+
+      expect(mockLogger.info).toHaveBeenCalledWith(
+        expect.stringContaining('EP Gate:')
+      );
+    });
+
+    it('should allow risky path when EP allows', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({
+        allowed: true,
+        currentTier: 4, // Tree tier - can access risk paths
+        reason: 'Tier 4 unlocked'
+      });
+
+      const result = checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/risk-path',
+        true, // risky
+        500,
+        mockLogger,
+        { workspaceDir: '/test', sessionId: 'test-session' },
+        {}
+      );
+
+      expect(result).toBeUndefined();
+    });
+
+    it('should block risky path when EP denies', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({
+        allowed: false,
+        currentTier: 2, // Sprout tier - cannot access risk paths
+        reason: 'Risk paths require Tree tier'
+      });
+
+      const result = checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/risk-path',
+        true, // risky
+        10,
+        mockLogger,
+        { workspaceDir: '/test', sessionId: 'test-session' },
+        {}
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+    });
+
+    it('should skip check when no workspaceDir', () => {
+      const result = checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/file.ts',
+        false,
+        10,
+        mockLogger,
+        { sessionId: 'test-session' }, // No workspaceDir
+        {}
+      );
+
+      expect(result).toBeUndefined();
+      expect(mockLogger.warn).toHaveBeenCalledWith(
+        expect.stringContaining('No workspaceDir')
+      );
+    });
+
+    it('should pass correct parameters to checkEvolutionGate', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
+
+      checkProgressiveTrustGate(
+        mockEvent,
+        mockWctx as any,
+        '/test/file.ts',
+        true, // isRiskPath
+        100,
+        mockLogger,
+        { workspaceDir: '/test', sessionId: 'test-session' },
+        {}
+      );
+
+      expect(checkEvolutionGate).toHaveBeenCalledWith('/test', {
+        toolName: 'edit',
+        isRiskPath: true,
+      });
+    });
+  });
+
+  describe('buildEvolutionGateReason', () => {
+    it('should build EP gate rejection reason with tier info', () => {
+      const reason = buildEvolutionGateReason(2, 'Sprout', 'Max 50 lines');
+
+      expect(reason).toContain('EP Gate');
+      expect(reason).toContain('Tier 2');
+      expect(reason).toContain('Sprout');
+      expect(reason).toContain('Max 50 lines');
+    });
+
+    it('should handle unknown tier name', () => {
+      const reason = buildEvolutionGateReason(99, 'Unknown', 'Some restriction');
+
+      expect(reason).toContain('EP Gate');
+      expect(reason).toContain('Tier 99');
+      expect(reason).toContain('Unknown');
+    });
+  });
+
+  describe('EP Tier Names', () => {
+    it('should pass correct tier info to checkEvolutionGate', () => {
+      vi.mocked(checkEvolutionGate).mockReturnValue({ allowed: true, currentTier: 1 });
+      const event = { toolName: 'edit', params: { file_path: '/test.ts', content: '' } } as any;
+      const logger = { info: vi.fn() };
+
+      checkProgressiveTrustGate(
+        event,
+        mockWctx as any,
+        '/test.ts',
+        false,
+        10,
+        logger,
+        { workspaceDir: '/test' },
+        {}
+      );
+
+      expect(checkEvolutionGate).toHaveBeenCalledWith('/test', {
+        toolName: 'edit',
+        isRiskPath: false,
+      });
+    });
+  });
+});