principles-disciple 1.8.1 → 1.8.2

package/tests/index.integration.test.ts

@@ -0,0 +1,179 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import plugin from '../src/index';
+import * as fs from 'fs';
+
+vi.mock('fs');
+
+describe('Plugin Integration', () => {
+  let mockApi: any;
+  let registeredHooks: Map<string, Function>;
+  let registeredServices: any[];
+  let registeredCommands: any[];
+  let registeredRoutes: any[];
+
+  beforeEach(() => {
+    registeredHooks = new Map();
+    registeredServices = [];
+    registeredCommands = [];
+    registeredRoutes = [];
+
+    mockApi = {
+      logger: {
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+      },
+      pluginConfig: { language: 'en' },
+      resolvePath: vi.fn((p: string) => `/resolved/${p}`),
+      on: vi.fn((hookName: string, handler: Function) => {
+        registeredHooks.set(hookName, handler);
+      }),
+      registerService: vi.fn((service: any) => {
+        registeredServices.push(service);
+      }),
+      registerCommand: vi.fn((command: any) => {
+        registeredCommands.push(command);
+      }),
+      registerHttpRoute: vi.fn((route: any) => {
+        registeredRoutes.push(route);
+      }),
+      registerTool: vi.fn(),
+    };
+
+    vi.mocked(fs.existsSync).mockReturnValue(false);
+    vi.mocked(fs.mkdirSync).mockReturnValue(undefined);
+    vi.mocked(fs.copyFileSync).mockReturnValue(undefined);
+  });
+
+  afterEach(() => {
+    vi.resetAllMocks();
+  });
+
+  describe('register()', () => {
+    it('should NOT call resolvePath(".") during register', () => {
+      plugin.register(mockApi);
+
+      // 关键：register 不应该调用 resolvePath('.')
+      // 因为它会返回进程工作目录，而不是配置的 workspace
+      expect(mockApi.resolvePath).not.toHaveBeenCalled();
+    });
+
+    it('should register all required hooks', () => {
+      plugin.register(mockApi);
+
+      const expectedHooks = [
+        'before_prompt_build',
+        'before_tool_call',
+        'after_tool_call',
+        'before_reset',
+        'before_compaction',
+        'llm_output',
+        'subagent_spawning',
+        'subagent_ended',
+      ];
+
+      for (const hook of expectedHooks) {
+        expect(registeredHooks.has(hook)).toBe(true);
+      }
+    });
+
+    it('registers the Principles Console HTTP route', () => {
+      plugin.register(mockApi);
+
+      expect(registeredRoutes).toHaveLength(1);
+      expect(registeredRoutes[0]).toEqual(expect.objectContaining({
+        path: '/plugins/principles',
+        auth: 'plugin',
+        match: 'prefix',
+        handler: expect.any(Function),
+      }));
+    });
+
+    it('should use ctx.workspaceDir from hook context, not from register', async () => {
+      plugin.register(mockApi);
+
+      const handler = registeredHooks.get('before_prompt_build');
+      expect(handler).toBeDefined();
+
+      // 模拟正确的 workspaceDir 来自 context
+      const mockCtx = {
+        workspaceDir: '/correct/workspace/from/config',
+        sessionKey: 'test-session',
+        trigger: 'user',
+      };
+
+      // 调用 handler
+      await handler({ prompt: 'test', messages: [] }, mockCtx);
+
+      // 验证没有使用 resolvePath 的返回值
+      expect(mockApi.resolvePath).not.toHaveBeenCalled();
+    });
+
+    it('should register EvolutionWorker service', () => {
+      plugin.register(mockApi);
+
+      const serviceIds = registeredServices.map((service) => service.id);
+      expect(serviceIds).toContain('principles-evolution-worker');
+      expect(serviceIds).toContain('principles-disciple-trajectory');
+    });
+
+    it('should register all slash commands', () => {
+      plugin.register(mockApi);
+
+      const commandNames = registeredCommands.map(c => c.name);
+      const expectedCommands = [
+        'pd-init',
+        'pd-okr',
+        'pd-evolve',
+        'pd-bootstrap',
+        'pd-research',
+        'pd-thinking',
+        'pd-status',
+        'pd-daily',
+        'pd-grooming',
+        'pd-help'
+      ];
+      for (const cmd of expectedCommands) {
+        expect(commandNames).toContain(cmd);
+      }
+    });
+  });
+
+  describe('workspaceDir source verification', () => {
+    it('before_tool_call should use ctx.workspaceDir', () => {
+      plugin.register(mockApi);
+
+      const handler = registeredHooks.get('before_tool_call');
+      const mockCtx = { workspaceDir: '/workspace/from/context' };
+
+      // 调用 handler（不会 block）
+      handler({ tool: 'write', params: {} }, mockCtx);
+
+      // 关键：不应该调用 resolvePath
+      expect(mockApi.resolvePath).not.toHaveBeenCalled();
+    });
+
+    it('after_tool_call should use ctx.workspaceDir', () => {
+      plugin.register(mockApi);
+
+      const handler = registeredHooks.get('after_tool_call');
+      const mockCtx = { workspaceDir: '/workspace/from/context' };
+
+      handler({ tool: 'write', result: { success: true } }, mockCtx);
+
+      expect(mockApi.resolvePath).not.toHaveBeenCalled();
+    });
+
+    it('llm_output should use ctx.workspaceDir', () => {
+      plugin.register(mockApi);
+
+      const handler = registeredHooks.get('llm_output');
+      const mockCtx = { workspaceDir: '/workspace/from/context' };
+
+      handler({ assistantTexts: ['test'] }, mockCtx);
+
+      expect(mockApi.resolvePath).not.toHaveBeenCalled();
+    });
+  });
+});

package/tests/index.shadow-routing.integration.test.ts

@@ -0,0 +1,140 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import plugin from '../src/index.js';
+import {
+  registerTrainingRun,
+  startTrainingRun,
+  completeTrainingRun,
+  registerCheckpoint,
+  attachEvalSummary,
+  markCheckpointDeployable,
+} from '../src/core/model-training-registry.js';
+import { advancePromotion, DEFAULT_BASELINE_METRICS } from '../src/core/promotion-gate.js';
+import { bindCheckpointToWorkerProfile, enableRoutingForProfile } from '../src/core/model-deployment-registry.js';
+import { computeShadowStats } from '../src/core/shadow-observation-registry.js';
+
+function makeTmpDir(): string {
+  return fs.mkdtempSync(path.join(os.tmpdir(), 'pd-shadow-hook-test-'));
+}
+
+function rmdir(dir: string): void {
+  try {
+    if (fs.existsSync(dir)) {
+      fs.rmSync(dir, { recursive: true, force: true });
+    }
+  } catch {
+    // ignore cleanup errors
+  }
+}
+
+function setupShadowReadyReaderCheckpoint(stateDir: string): string {
+  const run = registerTrainingRun(stateDir, {
+    targetModelFamily: 'qwen2.5-7b-reader',
+    datasetFingerprint: 'fp-dataset',
+    exportId: 'export-1',
+    sampleCount: 10,
+    configFingerprint: 'fp-config',
+  });
+  startTrainingRun(stateDir, run.trainRunId);
+  completeTrainingRun(stateDir, run.trainRunId);
+
+  const checkpoint = registerCheckpoint(stateDir, {
+    trainRunId: run.trainRunId,
+    targetModelFamily: 'qwen2.5-7b-reader',
+    artifactPath: path.join(stateDir, 'checkpoints', 'ckpt-reader'),
+  });
+
+  attachEvalSummary(stateDir, checkpoint.checkpointId, {
+    evalId: 'eval-1',
+    checkpointId: checkpoint.checkpointId,
+    benchmarkId: 'bench-1',
+    targetModelFamily: 'qwen2.5-7b-reader',
+    mode: 'reduced_prompt',
+    baselineScore: 0.5,
+    candidateScore: 0.7,
+    delta: 0.2,
+    verdict: 'pass',
+  });
+  markCheckpointDeployable(stateDir, checkpoint.checkpointId, true);
+  advancePromotion(stateDir, {
+    checkpointId: checkpoint.checkpointId,
+    targetProfile: 'local-reader',
+    baselineMetrics: DEFAULT_BASELINE_METRICS,
+    orchestratorReviewPassed: true,
+    reviewNote: 'shadow ready for test',
+  });
+  bindCheckpointToWorkerProfile(stateDir, 'local-reader', checkpoint.checkpointId);
+  enableRoutingForProfile(stateDir, 'local-reader');
+  return checkpoint.checkpointId;
+}
+
+describe('plugin shadow routing integration', () => {
+  let tmpDir: string;
+
+  beforeEach(() => {
+    tmpDir = makeTmpDir();
+  });
+
+  afterEach(() => {
+    rmdir(tmpDir);
+  });
+
+  it('records and completes shadow observations from runtime subagent hooks', async () => {
+    const checkpointId = setupShadowReadyReaderCheckpoint(tmpDir);
+    const hooks = new Map<string, Function>();
+
+    const api: any = {
+      logger: { info() {}, warn() {}, error() {}, debug() {} },
+      pluginConfig: { language: 'en' },
+      rootDir: tmpDir,
+      resolvePath: (p: string) => (p === '.' ? tmpDir : path.join(tmpDir, p)),
+      registerHttpRoute() {},
+      on(name: string, handler: Function) {
+        hooks.set(name, handler);
+      },
+      registerService() {},
+      registerCommand() {},
+      registerTool() {},
+    };
+
+    plugin.register(api);
+
+    const spawning = hooks.get('subagent_spawning');
+    const ended = hooks.get('subagent_ended');
+    expect(spawning).toBeTypeOf('function');
+    expect(ended).toBeTypeOf('function');
+
+    for (let i = 0; i < 5; i++) {
+      const sessionKey = `agent:local-reader:test-child-${i}`;
+      spawning!(
+        {
+          childSessionKey: sessionKey,
+          agentId: 'local-reader',
+          mode: 'run',
+          threadRequested: false,
+          label: 'shadow-test',
+        },
+        { workspaceDir: tmpDir }
+      );
+
+      ended!(
+        {
+          targetSessionKey: sessionKey,
+          targetKind: 'subagent',
+          reason: 'completed',
+          outcome: 'ok',
+        },
+        { workspaceDir: tmpDir }
+      );
+    }
+
+    const stats = computeShadowStats(tmpDir, { checkpointId, windowMs: 7 * 24 * 60 * 60 * 1000 });
+    expect(stats).not.toBeNull();
+    expect(stats!.totalCount).toBe(5);
+    expect(stats!.acceptedCount).toBe(5);
+    expect(stats!.rejectRate).toBe(0);
+    expect(stats!.isStatisticallySignificant).toBe(true);
+  });
+});

package/tests/index.test.ts

@@ -0,0 +1,9 @@
+import { describe, it, expect } from 'vitest';
+import plugin from '../src/index';
+
+describe('OpenClaw Plugin Scaffolding', () => {
+  it('should export a valid register function', () => {
+    expect(plugin).toBeDefined();
+    expect(typeof plugin.register).toBe('function');
+  });
+});