principles-disciple 1.8.0 → 1.8.2

package/tests/hooks/thinking-gate.test.ts

@@ -0,0 +1,313 @@
+/**
+ * Thinking OS Checkpoint Tests (P-10)
+ * 
+ * Tests the mandatory deep thinking checkpoint before high-risk operations.
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { handleBeforeToolCall } from '../../src/hooks/gate.js';
+import { recordThinkingCheckpoint, hasRecentThinking, clearSession } from '../../src/core/session-tracker.js';
+import { WorkspaceContext } from '../../src/core/workspace-context.js';
+import * as riskCalculator from '../../src/core/risk-calculator.js';
+import * as evolutionEngine from '../../src/core/evolution-engine.js';
+import * as fs from 'fs';
+import * as path from 'path';
+
+vi.mock('../../src/core/workspace-context.js');
+vi.mock('../../src/core/risk-calculator.js');
+vi.mock('../../src/core/evolution-engine.js', () => ({
+  checkEvolutionGate: vi.fn().mockReturnValue({ allowed: true, currentTier: 3, reason: undefined }),
+  getEvolutionEngine: vi.fn().mockReturnValue({
+    getTier: vi.fn().mockReturnValue(3),
+    getPoints: vi.fn().mockReturnValue(200),
+  }),
+}));
+
+const MOCK_SESSION_ID = 'test-thinking-session-001';
+// Use os.tmpdir() for cross-platform compatibility
+const MOCK_WORKSPACE = require('os').tmpdir() + '/pd-test-thinking-workspace';
+const PROFILE_PATH = path.join(MOCK_WORKSPACE, '.principles', 'PROFILE.json');
+
+// Profile with thinking checkpoint ENABLED for testing
+const TEST_PROFILE = {
+  thinking_checkpoint: {
+    enabled: true,
+    window_ms: 5 * 60 * 1000,
+    high_risk_tools: ['run_shell_command', 'delete_file', 'move_file', 'sessions_spawn', 'write', 'edit'],
+  },
+};
+
+function createMockContext(overrides = {}) {
+  return {
+    sessionId: MOCK_SESSION_ID,
+    workspaceDir: MOCK_WORKSPACE,
+    pluginConfig: {},
+    logger: { info: () => {}, error: () => {}, warn: () => {} },
+    ...overrides,
+  };
+}
+
+function createMockEvent(toolName: string, params: Record<string, any> = {}) {
+  return {
+    toolName,
+    params,
+  };
+}
+
+// Mock evolution object for WorkspaceContext
+const mockEvolution = {
+  getTier: vi.fn().mockReturnValue(3),
+  getPoints: vi.fn().mockReturnValue(200),
+};
+
+// Mock WorkspaceContext that will be returned from fromHookContext
+const mockWctx = {
+  workspaceDir: MOCK_WORKSPACE,
+  stateDir: path.join(MOCK_WORKSPACE, '.principles'),
+  config: {
+    get: vi.fn().mockImplementation((key) => {
+      if (key === 'gfi_gate') return {
+        enabled: true,
+        thresholds: { low_risk_block: 70, high_risk_block: 40, large_change_block: 50 },
+        large_change_lines: 50,
+        ep_tier_multipliers: { '1': 0.5, '2': 0.75, '3': 1.0, '4': 1.5, '5': 2.0 },
+        bash_safe_patterns: [],
+        bash_dangerous_patterns: [],
+      };
+      return undefined;
+    }),
+  },
+  eventLog: { recordGateBlock: vi.fn(), recordPlanApproval: vi.fn(), recordGfiGateBlock: vi.fn() },
+  trajectory: { recordGateBlock: vi.fn(), recordTaskOutcome: vi.fn() },
+  evolution: mockEvolution,
+  resolve: vi.fn().mockImplementation((key) => {
+    if (key === 'PROFILE') return path.join(MOCK_WORKSPACE, '.principles', 'PROFILE.json');
+    if (key === 'PLAN') return path.join(MOCK_WORKSPACE, 'PLAN.md');
+    return '';
+  }),
+};
+
+describe('Thinking OS Checkpoint (P-10)', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    vi.useFakeTimers();
+    clearSession(MOCK_SESSION_ID);
+    // Create workspace directory and PROFILE.json with checkpoint enabled
+    fs.mkdirSync(path.dirname(PROFILE_PATH), { recursive: true });
+    fs.writeFileSync(PROFILE_PATH, JSON.stringify(TEST_PROFILE));
+    // Mock WorkspaceContext.fromHookContext to return our mock with evolution
+    vi.mocked(WorkspaceContext.fromHookContext).mockReturnValue(mockWctx as any);
+    vi.mocked(riskCalculator.assessRiskLevel).mockReturnValue('LOW');
+    vi.mocked(riskCalculator.estimateLineChanges).mockReturnValue(1);
+  });
+
+  afterEach(() => {
+    // Clean up PROFILE.json
+    if (fs.existsSync(PROFILE_PATH)) {
+      fs.unlinkSync(PROFILE_PATH);
+    }
+  });
+
+  describe('Blocking high-risk operations without thinking', () => {
+    it('should block write tool without recent thinking', () => {
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+      expect(result?.blockReason).toContain('deep_reflect');
+    });
+
+    it('should block exec tool without recent thinking', () => {
+      const result = handleBeforeToolCall(
+        createMockEvent('run_shell_command', { command: 'ls -la' }),
+        createMockContext()
+      );
+      
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+    });
+
+    it('should block edit tool without recent thinking', () => {
+      const result = handleBeforeToolCall(
+        createMockEvent('edit', { file_path: '/test/file.ts', old_string: 'a', new_string: 'b' }),
+        createMockContext()
+      );
+      
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+    });
+
+    it('should block sessions_spawn without recent thinking', () => {
+      const result = handleBeforeToolCall(
+        createMockEvent('sessions_spawn', { task: 'Use pd-explorer skill' }),
+        createMockContext()
+      );
+
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+    });
+  });
+
+  describe('Allowing operations after thinking', () => {
+    it('should allow write tool after recording thinking checkpoint', () => {
+      // Record thinking
+      recordThinkingCheckpoint(MOCK_SESSION_ID, MOCK_WORKSPACE);
+      
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      
+      // Should not be blocked by thinking gate (may be blocked by other gates like risk path)
+      // If blocked, the reason should NOT be about thinking checkpoint
+      if (result?.block) {
+        expect(result.blockReason).not.toContain('Thinking OS');
+      }
+    });
+
+    it('should allow exec tool after recording thinking checkpoint', () => {
+      recordThinkingCheckpoint(MOCK_SESSION_ID, MOCK_WORKSPACE);
+      
+      const result = handleBeforeToolCall(
+        createMockEvent('run_shell_command', { command: 'echo hello' }),
+        createMockContext()
+      );
+      
+      if (result?.block) {
+        expect(result.blockReason).not.toContain('Thinking OS');
+      }
+    });
+  });
+
+  describe('Session state tracking', () => {
+    it('should initially have no recent thinking', () => {
+      expect(hasRecentThinking(MOCK_SESSION_ID)).toBe(false);
+    });
+
+    it('should have recent thinking after recording checkpoint', () => {
+      recordThinkingCheckpoint(MOCK_SESSION_ID, MOCK_WORKSPACE);
+      expect(hasRecentThinking(MOCK_SESSION_ID)).toBe(true);
+    });
+
+    it('should expire after time window passes', async () => {
+      recordThinkingCheckpoint(MOCK_SESSION_ID, MOCK_WORKSPACE);
+      expect(hasRecentThinking(MOCK_SESSION_ID, 1000)).toBe(true);
+      vi.advanceTimersByTime(150);
+      expect(hasRecentThinking(MOCK_SESSION_ID, 100)).toBe(false);
+    });
+  });
+
+  describe('Non-high-risk tools bypass', () => {
+    it('should not block read tool', () => {
+      const result = handleBeforeToolCall(
+        createMockEvent('read', { file_path: '/test/file.ts' }),
+        createMockContext()
+      );
+      expect(result).toBeUndefined();
+    });
+
+    it('should not block web_search tool', () => {
+      const result = handleBeforeToolCall(
+        createMockEvent('web_search', { query: 'test' }),
+        createMockContext()
+      );
+      expect(result).toBeUndefined();
+    });
+  });
+
+  describe('Boundary: thinking_checkpoint config variations', () => {
+    it('should not crash when PROFILE.json is missing', () => {
+      // Remove PROFILE.json
+      if (fs.existsSync(PROFILE_PATH)) {
+        fs.unlinkSync(PROFILE_PATH);
+      }
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      // Should not crash, should use defaults (checkpoint disabled)
+      expect(result).toBeUndefined();
+    });
+
+    it('should not crash when thinking_checkpoint is null', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: null }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      expect(result).toBeUndefined();
+    });
+
+    it('should not crash when thinking_checkpoint.enabled is null', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: { enabled: null } }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      expect(result).toBeUndefined();
+    });
+
+    it('should not crash when high_risk_tools is null', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: { enabled: true, high_risk_tools: null } }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      // Should use default high_risk_tools list
+      expect(result).toBeUndefined();
+    });
+
+    it('should not block any tool when high_risk_tools is empty array', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: { enabled: true, high_risk_tools: [] } }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      // Empty list = no tools are high risk
+      expect(result).toBeUndefined();
+    });
+
+    it('should not crash when thinking_checkpoint is invalid type (string)', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: "invalid" }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      expect(result).toBeUndefined();
+    });
+
+    it('should not crash when PROFILE.json is malformed JSON', () => {
+      fs.writeFileSync(PROFILE_PATH, '{ invalid json }');
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      // Should fall back to defaults
+      expect(result).toBeUndefined();
+    });
+
+    it('should respect custom high_risk_tools list', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: { enabled: true, high_risk_tools: ['write'] } }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      // write is in the list, should be blocked
+      expect(result).toBeDefined();
+      expect(result?.block).toBe(true);
+    });
+
+    it('should not block tool not in custom high_risk_tools list', () => {
+      fs.writeFileSync(PROFILE_PATH, JSON.stringify({ thinking_checkpoint: { enabled: true, high_risk_tools: ['delete_file'] } }));
+      const result = handleBeforeToolCall(
+        createMockEvent('write', { file_path: '/test/file.ts', content: 'test' }),
+        createMockContext()
+      );
+      // write is NOT in the list, should not be blocked
+      expect(result).toBeUndefined();
+    });
+  });
+});

package/tests/http/principles-console-route.test.ts

@@ -0,0 +1,140 @@
+import { describe, expect, it, vi, beforeEach, afterEach } from 'vitest';
+import { EventEmitter } from 'node:events';
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import { createPrinciplesConsoleRoute } from '../../src/http/principles-console-route.js';
+import { ControlUiQueryService } from '../../src/service/control-ui-query-service.js';
+
+vi.mock('../../src/service/control-ui-query-service.js');
+
+// Store original env
+const originalHome = process.env.HOME;
+
+beforeEach(() => {
+  // Set HOME to a non-existent path to prevent reading real config
+  process.env.HOME = '/nonexistent-test-home';
+});
+
+afterEach(() => {
+  process.env.HOME = originalHome;
+});
+
+class MockResponse extends EventEmitter {
+  statusCode = 200;
+  headers = new Map<string, string>();
+  body = '';
+
+  setHeader(name: string, value: string) {
+    this.headers.set(name.toLowerCase(), value);
+  }
+
+  end(chunk?: Buffer | string) {
+    if (chunk) {
+      this.body += typeof chunk === 'string' ? chunk : chunk.toString('utf8');
+    }
+  }
+}
+
+function createRequest(method: string, url: string, body?: string, headers?: Record<string, string>): IncomingMessage {
+  const req = new EventEmitter() as IncomingMessage & AsyncIterable<Buffer>;
+  (req as any).method = method;
+  (req as any).url = url;
+  (req as any).headers = headers || {};
+  req[Symbol.asyncIterator] = async function* () {
+    if (body) {
+      yield Buffer.from(body);
+    }
+  };
+  return req as IncomingMessage;
+}
+
+describe('principles-console-route', () => {
+  it('serves overview JSON from the plugin API route', async () => {
+    vi.mocked(ControlUiQueryService).mockImplementation(function MockControlUiQueryService() {
+      return {
+        getOverview: () => ({ workspaceDir: '/workspace', generatedAt: 'now', dataFreshness: null }),
+        dispose: vi.fn(),
+      } as any;
+    } as any);
+
+    const route = createPrinciplesConsoleRoute({
+      rootDir: '/plugin',
+      resolvePath: vi.fn(() => '/workspace'),
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    } as any);
+
+    const response = new MockResponse() as unknown as ServerResponse;
+    const handled = await route.handler(
+      createRequest('GET', '/plugins/principles/api/overview'),
+      response,
+    );
+
+    expect(handled).toBe(true);
+    expect((response as any).statusCode).toBe(200);
+    expect((response as any).body).toContain('"workspaceDir": "/workspace"');
+  });
+
+  it('rejects unsupported asset methods with 405', async () => {
+    const route = createPrinciplesConsoleRoute({
+      rootDir: '/plugin',
+      resolvePath: vi.fn(() => '/workspace'),
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    } as any);
+
+    const response = new MockResponse() as unknown as ServerResponse;
+    const handled = await route.handler(
+      createRequest('POST', '/plugins/principles/assets/app.js'),
+      response,
+    );
+
+    expect(handled).toBe(true);
+    expect((response as any).statusCode).toBe(405);
+  });
+
+  it('returns 400 for invalid review JSON bodies', async () => {
+    vi.mocked(ControlUiQueryService).mockImplementation(function MockControlUiQueryService() {
+      return {
+        dispose: vi.fn(),
+      } as any;
+    } as any);
+
+    const route = createPrinciplesConsoleRoute({
+      rootDir: '/plugin',
+      resolvePath: vi.fn(() => '/workspace'),
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    } as any);
+
+    const response = new MockResponse() as unknown as ServerResponse;
+    const handled = await route.handler(
+      createRequest('POST', '/plugins/principles/api/samples/sample-1/review', '{invalid'),
+      response,
+    );
+
+    expect(handled).toBe(true);
+    expect((response as any).statusCode).toBe(400);
+    expect((response as any).body).toContain('valid JSON');
+  });
+
+  it('returns 404 for unknown thinking model details', async () => {
+    vi.mocked(ControlUiQueryService).mockImplementation(function MockControlUiQueryService() {
+      return {
+        getThinkingModelDetail: () => null,
+        dispose: vi.fn(),
+      } as any;
+    } as any);
+
+    const route = createPrinciplesConsoleRoute({
+      rootDir: '/plugin',
+      resolvePath: vi.fn(() => '/workspace'),
+      logger: { info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+    } as any);
+
+    const response = new MockResponse() as unknown as ServerResponse;
+    const handled = await route.handler(
+      createRequest('GET', '/plugins/principles/api/thinking/models/unknown'),
+      response,
+    );
+
+    expect(handled).toBe(true);
+    expect((response as any).statusCode).toBe(404);
+  });
+});

package/tests/hygiene-tracker.test.ts

@@ -0,0 +1,77 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { HygieneTracker } from '../src/core/hygiene/tracker.js';
+
+vi.mock('fs');
+
+describe('HygieneTracker', () => {
+  const stateDir = '/tmp/pd-state';
+  const statsFile = path.join(stateDir, 'hygiene-stats.json');
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    (fs.existsSync as any).mockImplementation((p: string) => false);
+    vi.useFakeTimers();
+    vi.setSystemTime(new Date('2026-03-11T12:00:00Z'));
+  });
+
+  it('should initialize with empty stats if file does not exist', () => {
+    const tracker = new HygieneTracker(stateDir);
+    const stats = tracker.getStats();
+    expect(stats.date).toBe('2026-03-11');
+    expect(stats.persistenceCount).toBe(0);
+    expect(fs.mkdirSync).toHaveBeenCalledWith(stateDir, { recursive: true });
+  });
+
+  it('should record and verify JSON content on persistence', () => {
+    const tracker = new HygieneTracker(stateDir);
+    tracker.recordPersistence({
+      ts: '2026-03-11T12:05:00Z',
+      tool: 'write_file',
+      path: 'memory/notes.md',
+      type: 'memory',
+      contentLength: 500
+    });
+
+    const stats = tracker.getStats();
+    expect(stats.persistenceCount).toBe(1);
+    expect(stats.totalCharsPersisted).toBe(500);
+    expect(stats.persistenceByFile['notes.md']).toBe(1);
+
+    // Verify write content
+    expect(fs.writeFileSync).toHaveBeenCalled();
+    const lastWriteCall = vi.mocked(fs.writeFileSync).mock.calls[0];
+    const writtenData = JSON.parse(lastWriteCall[1] as string);
+    expect(writtenData['2026-03-11'].persistenceCount).toBe(1);
+  });
+
+  it('should reset stats when date changes', () => {
+    const tracker = new HygieneTracker(stateDir);
+    tracker.recordPersistence({
+      ts: '2026-03-11T12:00:00Z',
+      tool: 'write_file',
+      path: 'memory/old.md',
+      type: 'memory',
+      contentLength: 100
+    });
+
+    expect(tracker.getStats().persistenceCount).toBe(1);
+
+    // Move to next day
+    vi.setSystemTime(new Date('2026-03-12T09:00:00Z'));
+    
+    const newStats = tracker.getStats();
+    expect(newStats.date).toBe('2026-03-12');
+    expect(newStats.persistenceCount).toBe(0); // Should be reset
+  });
+
+  it('should handle corrupted JSON gracefully', () => {
+    (fs.existsSync as any).mockImplementation((p: string) => p === statsFile);
+    (fs.readFileSync as any).mockReturnValue('invalid json {');
+    
+    const tracker = new HygieneTracker(stateDir);
+    expect(tracker.getStats().persistenceCount).toBe(0);
+    expect(fs.renameSync).toHaveBeenCalled(); // Should backup corrupted file
+  });
+});