principles-disciple 1.107.0 → 1.108.0

package/tests/core/pain-context-extractor.test.ts

@@ -1,279 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-const TEST_AGENTS_DIR = path.join(os.tmpdir(), 'pd-test-agents-' + Date.now());
-
-// Set env before module load
-process.env.PD_TEST_AGENTS_DIR = TEST_AGENTS_DIR;
-
-describe('Pain Context Extractor', () => {
-  beforeEach(() => {
-    // Clean up test directory
-    if (fs.existsSync(TEST_AGENTS_DIR)) {
-      fs.rmSync(TEST_AGENTS_DIR, { recursive: true, force: true });
-    }
-    fs.mkdirSync(path.join(TEST_AGENTS_DIR, 'main', 'sessions'), { recursive: true });
-    fs.mkdirSync(path.join(TEST_AGENTS_DIR, 'builder', 'sessions'), { recursive: true });
-  });
-
-  afterEach(() => {
-    if (fs.existsSync(TEST_AGENTS_DIR)) {
-      fs.rmSync(TEST_AGENTS_DIR, { recursive: true, force: true });
-    }
-  });
-
-  function createSessionFile(
-    sessionId: string,
-    lines: string[],
-    agentId: string = 'main',
-  ): string {
-    const dir = path.join(TEST_AGENTS_DIR, agentId, 'sessions');
-    fs.mkdirSync(dir, { recursive: true });
-    const filePath = path.join(dir, `${sessionId}.jsonl`);
-    fs.writeFileSync(filePath, lines.join('\n'), 'utf8');
-    return filePath;
-  }
-
-  function makeMessage(
-    role: string,
-    textParts: string[] = [],
-    extra: Record<string, unknown> = {},
-  ): string {
-    return JSON.stringify({
-      type: 'message',
-      message: {
-        role,
-        content: textParts.map((t) => ({ type: 'text', text: t })),
-        ...extra,
-      },
-    });
-  }
-
-  function makeToolCallMessage(
-    toolCalls: Array<{ id: string; name: string; arguments?: Record<string, unknown> }>,
-  ): string {
-    return JSON.stringify({
-      type: 'message',
-      message: {
-        role: 'assistant',
-        content: toolCalls.map((tc) => ({
-          type: 'toolCall',
-          id: tc.id || 'tc1',
-          name: tc.name || 'read_file',
-          arguments: tc.arguments || {},
-        })),
-      },
-    });
-  }
-
-  function makeToolResult(
-    toolName: string,
-    toolCallId: string,
-    textParts: string[] = [],
-    details: Record<string, unknown> = {},
-  ): string {
-    return JSON.stringify({
-      type: 'message',
-      message: {
-        role: 'toolResult',
-        toolName,
-        toolCallId,
-        content: textParts.map((t) => ({ type: 'text', text: t })),
-        details,
-      },
-    });
-  }
-
-  describe('extractRecentConversation', () => {
-    it('returns empty string for non-existent session', async () => {
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('nonexistent', 'main');
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for short session ID', async () => {
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('ab', 'main');
-      expect(result).toBe('');
-    });
-
-    it('rejects path traversal session IDs', async () => {
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result1 = await extractRecentConversation('../../etc/passwd', 'main');
-      expect(result1).toBe('');
-      const result2 = await extractRecentConversation('sess/../../../etc/shadow', 'main');
-      expect(result2).toBe('');
-    });
-
-    it('rejects path traversal agent IDs', async () => {
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('sess1', '../../etc');
-      expect(result).toBe('');
-    });
-
-    it('extracts user and assistant messages', async () => {
-      createSessionFile('sess1', [
-        makeMessage('user', ['Hello, please help me']),
-        makeMessage('assistant', ['Sure, I can help with that']),
-        makeMessage('user', ['Fix the bug in auth.ts']),
-        makeMessage('assistant', ['I found the issue and fixed it']),
-      ], 'main');
-
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('sess1', 'main');
-
-      expect(result).toContain('[User]');
-      expect(result).toContain('[Assistant]');
-    });
-
-    it('skips system prompt injection patterns', async () => {
-      createSessionFile('sess3', [
-        makeMessage('user', ['<evolution_task><pain_score>50</pain_score>']),
-        makeMessage('user', ['Real user input: fix the login bug']),
-      ], 'main');
-
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('sess3', 'main');
-
-      expect(result).not.toContain('<evolution_task>');
-      expect(result).toContain('Real user input');
-    });
-
-    it('handles empty file gracefully', async () => {
-      const emptyPath = path.join(TEST_AGENTS_DIR, 'main', 'sessions', 'sess-empty.jsonl');
-      fs.writeFileSync(emptyPath, '');
-
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('sess-empty', 'main');
-      expect(result).toBe('');
-    });
-
-    it('skips oversized lines (>100KB)', async () => {
-      const bigLine = makeMessage('user', ['x'.repeat(150_000)]);
-      createSessionFile('sess-big', [
-        bigLine,
-        makeMessage('user', ['Normal input']),
-      ], 'main');
-
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('sess-big', 'main');
-
-      expect(result).toContain('Normal input');
-    });
-
-    it('uses custom agent ID', async () => {
-      createSessionFile('sess-builder', [
-        makeMessage('user', ['Builder task']),
-      ], 'builder');
-
-      const { extractRecentConversation } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractRecentConversation('sess-builder', 'builder');
-      expect(result).toContain('Builder task');
-    });
-  });
-
-  describe('extractFailedToolContext', () => {
-    it('returns empty string for non-existent session', async () => {
-      const { extractFailedToolContext } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractFailedToolContext('nonexistent', 'main', 'read_file');
-      expect(result).toBe('');
-    });
-
-    it('returns empty string for missing toolName', async () => {
-      const { extractFailedToolContext } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractFailedToolContext('sess1', 'main', '');
-      expect(result).toBe('');
-    });
-
-    it('extracts failed tool call with correlation', async () => {
-      createSessionFile('sess-fail', [
-        makeMessage('user', ['system init']),  // safeTail strips first line for small files
-        makeToolCallMessage([{
-          id: 'tc-fail',
-          name: 'read_file',
-          arguments: { file_path: '/etc/passwd' },
-        }]),
-        makeToolResult('read_file', 'tc-fail', ['Permission denied'], {
-          exitCode: 1,
-          isError: true,
-        }),
-      ], 'main');
-
-      const { extractFailedToolContext } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractFailedToolContext('sess-fail', 'main', 'read_file');
-
-      expect(result).toContain('Tool Call: read_file');
-      expect(result).toContain('Exit Code: 1');
-    });
-
-    it('ignores successful tool results', async () => {
-      createSessionFile('sess-ok', [
-        makeMessage('user', ['system init']),
-        makeToolCallMessage([{ id: 'tc-ok', name: 'read_file' }]),
-        makeToolResult('read_file', 'tc-ok', ['File contents'], {
-          exitCode: 0,
-          isError: false,
-        }),
-      ], 'main');
-
-      const { extractFailedToolContext } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      const result = await extractFailedToolContext('sess-ok', 'main', 'read_file');
-
-      expect(result).toBe('');
-    });
-
-    it('filters by file path when provided', async () => {
-      createSessionFile('sess-filter', [
-        makeMessage('user', ['system init']),
-        makeToolCallMessage([{
-          id: 'tc1',
-          name: 'edit',
-          arguments: { file_path: '/src/auth.ts' },
-        }]),
-        makeToolResult('edit', 'tc1', ['ENOENT'], { exitCode: 1, isError: true }),
-      ], 'main');
-
-      const { extractFailedToolContext } = await import(
-        '../../src/core/pain-context-extractor.js'
-      );
-      // With matching file path, should return result
-      const result = await extractFailedToolContext(
-        'sess-filter',
-        'main',
-        'edit',
-        '/src/auth.ts',
-      );
-
-      expect(result).toContain('Tool Call: edit');
-      expect(result).toContain('Exit Code: 1');
-    });
-  });
-});

package/tests/core/pain-lifecycle.test.ts

@@ -1,38 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-import { clearPainFlag, PAIN_FLAG_FILENAME } from '../../src/core/pain-lifecycle.js';
-import { resolvePdPath } from '../../src/core/paths.js';
-
-describe('PainLifecycle', () => {
-    const workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pain-lifecycle-test-'));
-    const painFlagPath = resolvePdPath(workspaceDir, 'PAIN_FLAG');
-
-    beforeEach(() => {
-        const stateDir = path.dirname(painFlagPath);
-        if (!fs.existsSync(stateDir)) {
-            fs.mkdirSync(stateDir, { recursive: true });
-        }
-    });
-
-    afterEach(() => {
-        if (fs.existsSync(painFlagPath)) fs.unlinkSync(painFlagPath);
-    });
-
-    it('should delete .pain_flag file when it exists', () => {
-        fs.writeFileSync(painFlagPath, 'source: test\nscore: 80\nreason: test\ntime: 2026-01-01\n', 'utf8');
-        expect(fs.existsSync(painFlagPath)).toBe(true);
-        clearPainFlag(workspaceDir);
-        expect(fs.existsSync(painFlagPath)).toBe(false);
-    });
-
-    it('should not throw when .pain_flag does not exist', () => {
-        expect(fs.existsSync(painFlagPath)).toBe(false);
-        expect(() => clearPainFlag(workspaceDir)).not.toThrow();
-    });
-
-    it('should export correct filename constant', () => {
-        expect(PAIN_FLAG_FILENAME).toBe('.pain_flag');
-    });
-});

package/tests/core/pain-signal-adapter.test.ts

@@ -1,116 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import type { PainSignalAdapter } from '../../src/core/pain-signal-adapter.js';
-import type { PainSignal } from '../../src/core/pain-signal.js';
-import { validatePainSignal } from '../../src/core/pain-signal.js';
-
-// ---------------------------------------------------------------------------
-// Mock Framework Event
-// ---------------------------------------------------------------------------
-
-/** Simulated framework-specific event for testing */
-interface MockToolCallEvent {
-  toolName: string;
-  success: boolean;
-  errorMessage?: string;
-  sessionId: string;
-  agentId: string;
-  timestamp: string;
-}
-
-// ---------------------------------------------------------------------------
-// Test Adapter Implementation
-// ---------------------------------------------------------------------------
-
-/** Test adapter that translates MockToolCallEvent to PainSignal */
-const mockAdapter: PainSignalAdapter<MockToolCallEvent> = {
-  capture(event: MockToolCallEvent): PainSignal | null {
-    // Per D-02: pure translation. Only failed tool calls produce signals.
-    if (event.success) return null;
-
-    // Return null for malformed events
-    if (!event.toolName || !event.errorMessage) return null;
-
-    return {
-      source: 'tool_failure',
-      score: 75,
-      timestamp: event.timestamp,
-      reason: `Tool ${event.toolName} failed: ${event.errorMessage}`,
-      sessionId: event.sessionId,
-      agentId: event.agentId,
-      traceId: `test-${Date.now()}`,
-      triggerTextPreview: event.errorMessage.slice(0, 100),
-      domain: 'coding',
-      severity: 'high',
-      context: { toolName: event.toolName },
-    };
-  },
-};
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-function mockToolFailure(overrides: Partial<MockToolCallEvent> = {}): MockToolCallEvent {
-  return {
-    toolName: 'edit_file',
-    success: false,
-    errorMessage: 'File not found: test.ts',
-    sessionId: 'session-001',
-    agentId: 'main',
-    timestamp: '2026-04-17T00:00:00.000Z',
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tests
-// ---------------------------------------------------------------------------
-
-describe('PainSignalAdapter', () => {
-  it('captures a failed tool call as PainSignal', () => {
-    const result = mockAdapter.capture(mockToolFailure());
-    expect(result).not.toBeNull();
-    expect(result!.source).toBe('tool_failure');
-  });
-
-  it('returns null for successful tool calls', () => {
-    const result = mockAdapter.capture({ success: true } as MockToolCallEvent);
-    expect(result).toBeNull();
-  });
-
-  it('returns null for malformed events missing toolName', () => {
-    const result = mockAdapter.capture({
-      success: false,
-      toolName: '',
-      errorMessage: 'err',
-      sessionId: 's-1',
-      agentId: 'a-1',
-      timestamp: '2026-04-17T00:00:00.000Z',
-    });
-    expect(result).toBeNull();
-  });
-
-  it('returns null for malformed events missing errorMessage', () => {
-    const result = mockAdapter.capture({
-      success: false,
-      toolName: 'edit',
-      errorMessage: undefined,
-      sessionId: 's-1',
-      agentId: 'a-1',
-      timestamp: '2026-04-17T00:00:00.000Z',
-    });
-    expect(result).toBeNull();
-  });
-
-  it('produces signals that pass validatePainSignal', () => {
-    const signal = mockAdapter.capture(mockToolFailure());
-    expect(signal).not.toBeNull();
-    const result = validatePainSignal(signal!);
-    expect(result.valid).toBe(true);
-  });
-
-  it('satisfies the PainSignalAdapter interface type contract', () => {
-    const adapter: PainSignalAdapter<MockToolCallEvent> = mockAdapter;
-    expect(typeof adapter.capture).toBe('function');
-  });
-});

package/tests/core/pain-signal.test.ts

@@ -1,190 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import {
-  PainSignalSchema,
-  validatePainSignal,
-  deriveSeverity,
-  type PainSignal,
-} from '../../src/core/pain-signal.js';
-import { Value } from '@sinclair/typebox/value';
-
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-
-/** Produces a valid minimal PainSignal object. */
-function validSignal(overrides: Partial<PainSignal> = {}): PainSignal {
-  return {
-    source: 'tool_failure',
-    score: 75,
-    timestamp: '2026-04-17T00:00:00.000Z',
-    reason: 'Build failed with exit code 1',
-    sessionId: 'session-001',
-    agentId: 'main',
-    traceId: 'trace-abc',
-    triggerTextPreview: 'npm run build',
-    domain: 'coding',
-    severity: 'high',
-    context: {},
-    ...overrides,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// PainSignalSchema
-// ---------------------------------------------------------------------------
-
-describe('PainSignalSchema', () => {
-  it('accepts a valid signal', () => {
-    const signal = validSignal();
-    expect(Value.Check(PainSignalSchema, signal)).toBe(true);
-  });
-
-  it('rejects signal with missing required source', () => {
-    const signal = validSignal();
-    delete (signal as Record<string, unknown>).source;
-    expect(Value.Check(PainSignalSchema, signal)).toBe(false);
-  });
-
-  it('rejects signal with missing required reason', () => {
-    const signal = validSignal();
-    delete (signal as Record<string, unknown>).reason;
-    expect(Value.Check(PainSignalSchema, signal)).toBe(false);
-  });
-
-  it('rejects score below 0', () => {
-    const signal = validSignal({ score: -1 });
-    expect(Value.Check(PainSignalSchema, signal)).toBe(false);
-  });
-
-  it('rejects score above 100', () => {
-    const signal = validSignal({ score: 101 });
-    expect(Value.Check(PainSignalSchema, signal)).toBe(false);
-  });
-
-  it('rejects empty source string', () => {
-    const signal = validSignal({ source: '' });
-    expect(Value.Check(PainSignalSchema, signal)).toBe(false);
-  });
-
-  it('accepts empty optional fields (sessionId, agentId, etc.)', () => {
-    const signal = validSignal({
-      sessionId: '',
-      agentId: '',
-      traceId: '',
-      triggerTextPreview: '',
-    });
-    expect(Value.Check(PainSignalSchema, signal)).toBe(true);
-  });
-
-  it('accepts any string for domain', () => {
-    const signal = validSignal({ domain: 'writing' });
-    expect(Value.Check(PainSignalSchema, signal)).toBe(true);
-  });
-
-  it('accepts context with mixed value types', () => {
-    const signal = validSignal({ context: { filePath: '/src/index.ts', lineCount: 42 } });
-    expect(Value.Check(PainSignalSchema, signal)).toBe(true);
-  });
-});
-
-// ---------------------------------------------------------------------------
-// deriveSeverity
-// ---------------------------------------------------------------------------
-
-describe('deriveSeverity', () => {
-  it('returns "low" for scores 0-39', () => {
-    expect(deriveSeverity(0)).toBe('low');
-    expect(deriveSeverity(20)).toBe('low');
-    expect(deriveSeverity(39)).toBe('low');
-  });
-
-  it('returns "medium" for scores 40-69', () => {
-    expect(deriveSeverity(40)).toBe('medium');
-    expect(deriveSeverity(55)).toBe('medium');
-    expect(deriveSeverity(69)).toBe('medium');
-  });
-
-  it('returns "high" for scores 70-89', () => {
-    expect(deriveSeverity(70)).toBe('high');
-    expect(deriveSeverity(80)).toBe('high');
-    expect(deriveSeverity(89)).toBe('high');
-  });
-
-  it('returns "critical" for scores 90-100', () => {
-    expect(deriveSeverity(90)).toBe('critical');
-    expect(deriveSeverity(95)).toBe('critical');
-    expect(deriveSeverity(100)).toBe('critical');
-  });
-});
-
-// ---------------------------------------------------------------------------
-// validatePainSignal
-// ---------------------------------------------------------------------------
-
-describe('validatePainSignal', () => {
-  it('validates a correct signal and returns it typed', () => {
-    const input = validSignal();
-    const result = validatePainSignal(input);
-    expect(result.valid).toBe(true);
-    expect(result.errors).toEqual([]);
-    expect(result.signal).toEqual(input);
-  });
-
-  it('fills default domain when missing', () => {
-    const input = validSignal();
-    delete (input as Record<string, unknown>).domain;
-    const result = validatePainSignal(input);
-    expect(result.valid).toBe(true);
-    expect(result.signal?.domain).toBe('coding');
-  });
-
-  it('fills default severity from score when missing', () => {
-    const input = validSignal({ score: 45 });
-    delete (input as Record<string, unknown>).severity;
-    const result = validatePainSignal(input);
-    expect(result.valid).toBe(true);
-    expect(result.signal?.severity).toBe('medium');
-  });
-
-  it('fills default context when missing', () => {
-    const input = validSignal();
-    delete (input as Record<string, unknown>).context;
-    const result = validatePainSignal(input);
-    expect(result.valid).toBe(true);
-    expect(result.signal?.context).toEqual({});
-  });
-
-  it('rejects non-object input', () => {
-    const result = validatePainSignal('not an object');
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('Input must be a non-null object');
-  });
-
-  it('rejects null input', () => {
-    const result = validatePainSignal(null);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('Input must be a non-null object');
-  });
-
-  it('rejects array input', () => {
-    const result = validatePainSignal([1, 2, 3]);
-    expect(result.valid).toBe(false);
-    expect(result.errors).toContain('Input must be a non-null object');
-  });
-
-  it('reports errors for missing required fields', () => {
-    const result = validatePainSignal({});
-    expect(result.valid).toBe(false);
-    expect(result.errors.length).toBeGreaterThan(0);
-  });
-
-  it('rejects invalid score type', () => {
-    const result = validatePainSignal({ ...validSignal(), score: 'high' });
-    expect(result.valid).toBe(false);
-  });
-
-  it('rejects invalid severity value', () => {
-    const result = validatePainSignal({ ...validSignal(), severity: 'extreme' });
-    expect(result.valid).toBe(false);
-  });
-});