principles-disciple 1.8.1 → 1.8.2

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

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+import { EvolutionLogger, createTraceId, STAGE_LABELS, STAGE_COLORS, disposeAllEvolutionLoggers } from '../../src/core/evolution-logger.js';
+import { TrajectoryDatabase } from '../../src/core/trajectory.js';
+
+describe('EvolutionLogger', () => {
+  let tempDir: string;
+  let trajectory: TrajectoryDatabase;
+
+  beforeEach(() => {
+    tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-evolution-logger-'));
+    trajectory = new TrajectoryDatabase({ workspaceDir: tempDir });
+  });
+
+  afterEach(() => {
+    trajectory.dispose();
+    disposeAllEvolutionLoggers();  // Clear logger cache to prevent memory leaks
+    try {
+      fs.rmSync(tempDir, { recursive: true, force: true });
+    } catch {
+      // Windows file lock issue - ignore
+    }
+  });
+
+  describe('createTraceId', () => {
+    it('creates a unique trace ID', () => {
+      const id1 = createTraceId();
+      const id2 = createTraceId();
+      expect(id1).toMatch(/^ev_[a-z0-9]+_[a-f0-9]{6}$/);
+      expect(id2).toMatch(/^ev_[a-z0-9]+_[a-f0-9]{6}$/);
+      expect(id1).not.toBe(id2);
+    });
+  });
+
+  describe('log and getEvents', () => {
+    it('logs an evolution event to trajectory database', () => {
+      const traceId = createTraceId();
+      const logger = new EvolutionLogger(tempDir, trajectory);
+      logger.log({
+        traceId,
+        stage: 'pain_detected',
+        level: 'info',
+        message: 'Tool bash failed on package.json',
+        summary: '检测到痛点：工具 bash 在 package.json 失败',
+        metadata: { toolName: 'bash', filePath: 'package.json', score: 35 },
+      });
+
+      const events = trajectory.listEvolutionEvents(traceId);
+      expect(events).toHaveLength(1);
+      expect(events[0].traceId).toBe(traceId);
+      expect(events[0].stage).toBe('pain_detected');
+      expect(events[0].summary).toBe('检测到痛点：工具 bash 在 package.json 失败');
+    });
+
+    it('logs multiple events and retrieves them', () => {
+      const traceId1 = createTraceId();
+      const traceId2 = createTraceId();
+      const logger = new EvolutionLogger(tempDir, trajectory);
+
+      logger.log({
+        traceId: traceId1,
+        stage: 'pain_detected',
+        level: 'info',
+        message: 'Event 1',
+        summary: '事件 1',
+      });
+      logger.log({
+        traceId: traceId2,
+        stage: 'queued',
+        level: 'info',
+        message: 'Event 2',
+        summary: '事件 2',
+      });
+      logger.log({
+        traceId: traceId1,
+        stage: 'started',
+        level: 'info',
+        message: 'Event 3',
+        summary: '事件 3',
+      });
+
+      const events1 = trajectory.listEvolutionEvents(traceId1);
+      expect(events1).toHaveLength(2);
+      expect(events1[0].stage).toBe('pain_detected');
+      expect(events1[1].stage).toBe('started');
+
+      const events2 = trajectory.listEvolutionEvents(traceId2);
+      expect(events2).toHaveLength(1);
+      expect(events2[0].stage).toBe('queued');
+    });
+  });
+
+  describe('STAGE_LABELS and STAGE_COLORS', () => {
+    it('provides Chinese labels for stages', () => {
+      expect(STAGE_LABELS['pain_detected']).toBe('痛点检测');
+      expect(STAGE_LABELS['queued']).toBe('加入队列');
+      expect(STAGE_LABELS['completed']).toBe('完成');
+    });
+
+    it('provides colors for stages', () => {
+      expect(STAGE_COLORS['pain_detected']).toBe('#ef4444'); // red
+      expect(STAGE_COLORS['queued']).toBe('#f59e0b'); // amber
+      expect(STAGE_COLORS['completed']).toBe('#22c55e'); // green
+    });
+  });
+
+  describe('convenience methods', () => {
+    it('logPainDetected creates correct event', () => {
+      const traceId = createTraceId();
+      const logger = new EvolutionLogger(tempDir, trajectory);
+
+      logger.logPainDetected({
+        traceId,
+        source: 'tool_failure',
+        reason: 'Bash command failed',
+        score: 45,
+        toolName: 'bash',
+        filePath: 'package.json',
+      });
+
+      const events = trajectory.listEvolutionEvents(traceId);
+      expect(events).toHaveLength(1);
+      expect(events[0].stage).toBe('pain_detected');
+      expect(events[0].summary).toContain('检测到痛点');
+    });
+
+    it('logCompleted creates correct event', () => {
+      const traceId = createTraceId();
+      const taskId = 'task_abc123';
+      const logger = new EvolutionLogger(tempDir, trajectory);
+
+      logger.logCompleted({
+        traceId,
+        taskId,
+        resolution: 'marker_detected',
+        principlesGenerated: 2,
+      });
+
+      const events = trajectory.listEvolutionEvents(traceId);
+      expect(events).toHaveLength(1);
+      expect(events[0].stage).toBe('completed');
+      expect(events[0].summary).toContain('完成');
+      expect(events[0].summary).toContain('2 条原则');
+    });
+  });
+});

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

@@ -0,0 +1,50 @@
+import * as fs from 'fs';
+import * as os from 'os';
+import * as path from 'path';
+import { afterEach, describe, expect, it } from 'vitest';
+import { migrateLegacyEvolutionData } from '../../src/core/evolution-migration.js';
+
+const tempDirs: string[] = [];
+
+function makeTempDir(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-evolution-migration-'));
+  tempDirs.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  for (const dir of tempDirs.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe('migrateLegacyEvolutionData', () => {
+  it('imports legacy files into evolution stream as legacy_import events', () => {
+    const workspace = makeTempDir();
+    fs.mkdirSync(path.join(workspace, '.principles'), { recursive: true });
+    fs.mkdirSync(path.join(workspace, 'memory'), { recursive: true });
+    fs.writeFileSync(path.join(workspace, 'memory', 'ISSUE_LOG.md'), 'Issue A\nIssue B\n');
+    fs.writeFileSync(path.join(workspace, '.principles', 'PRINCIPLES.md'), '# P\nRule A\n');
+
+    const result = migrateLegacyEvolutionData(workspace);
+
+    expect(result.importedEvents).toBe(2);
+    const streamPath = path.join(workspace, 'memory', 'evolution.jsonl');
+    const events = fs.readFileSync(streamPath, 'utf8').trim().split('\n').map(line => JSON.parse(line));
+    expect(events).toHaveLength(2);
+    expect(events.every(event => event.type === 'legacy_import')).toBe(true);
+  });
+
+  it('is idempotent when migration runs multiple times', () => {
+    const workspace = makeTempDir();
+    fs.mkdirSync(path.join(workspace, '.principles'), { recursive: true });
+    fs.mkdirSync(path.join(workspace, 'memory'), { recursive: true });
+    fs.writeFileSync(path.join(workspace, 'memory', 'ISSUE_LOG.md'), 'Issue A\n');
+
+    const first = migrateLegacyEvolutionData(workspace);
+    const second = migrateLegacyEvolutionData(workspace);
+
+    expect(first.importedEvents).toBe(1);
+    expect(second.importedEvents).toBe(0);
+  });
+});

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

@@ -0,0 +1,21 @@
+import { describe, expect, it } from 'vitest';
+import { PathResolver } from '../../src/core/path-resolver.js';
+import { PD_FILES, resolvePdPath } from '../../src/core/paths.js';
+
+describe('evolution path keys', () => {
+  it('defines evolution stream related paths in PD_FILES', () => {
+    expect(PD_FILES.EVOLUTION_STREAM).toBe('memory/evolution.jsonl');
+    expect(PD_FILES.EVOLUTION_LOCK).toBe('memory/.locks/evolution');
+    expect(PD_FILES.PRINCIPLE_BLACKLIST).toBe('.state/principle_blacklist.json');
+  });
+
+  it('resolves evolution paths via resolvePdPath and PathResolver', () => {
+    const workspaceDir = '/tmp/workspace';
+    expect(resolvePdPath(workspaceDir, 'EVOLUTION_STREAM')).toBe('/tmp/workspace/memory/evolution.jsonl');
+
+    const resolver = new PathResolver({ workspaceDir });
+    expect(resolver.resolve('EVOLUTION_STREAM')).toBe('/tmp/workspace/memory/evolution.jsonl');
+    expect(resolver.resolve('EVOLUTION_LOCK')).toBe('/tmp/workspace/memory/.locks/evolution');
+    expect(resolver.resolve('PRINCIPLE_BLACKLIST')).toBe('/tmp/workspace/.state/principle_blacklist.json');
+  });
+});