principles-disciple 1.8.0 → 1.8.2

package/tests/tools/deep-reflect.test.ts

@@ -0,0 +1,232 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { createDeepReflectTool, deepReflectTool } from '../../src/tools/deep-reflect.js';
+import { EventLogService } from '../../src/core/event-log.js';
+import type { OpenClawPluginApi, PluginRuntime } from '../../src/openclaw-sdk.js';
+
+vi.mock('../../src/service/subagent-workflow/deep-reflect-workflow-manager.js', () => ({
+    DeepReflectWorkflowManager: vi.fn().mockImplementation(function() {
+        return globalThis.__DR_MOCK_MANAGER;
+    }),
+    deepReflectWorkflowSpec: { workflowType: 'deep_reflect' },
+}));
+
+vi.mock('../../src/core/config.js', () => ({
+    loadConfig: vi.fn(() => ({ mode: 'enabled', enabled: true, timeout_ms: 300 })),
+}));
+
+vi.mock('../../src/core/paths.js', () => ({
+    resolvePdPath: vi.fn((_dir: string, key: string) => {
+        const base = globalThis.__TEST_TEMP_DIR || '/tmp';
+        if (key === 'STATE_DIR') return path.join(base, '.state');
+        if (key === 'REFLECTION_LOG') return path.join(base, 'memory', 'REFLECTION_LOG.md');
+        if (key === 'PAIN_SETTINGS') return path.join(base, '.principles', 'PAIN_SETTINGS.json');
+        return path.join(base, key);
+    }),
+}));
+
+declare global {
+    var __TEST_TEMP_DIR: string | undefined;
+    var __DR_MOCK_MANAGER: any;
+}
+
+describe('createDeepReflectTool (workflow helper path)', () => {
+    let mockApi: OpenClawPluginApi;
+    let tempDir: string;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'deep-reflect-test-'));
+        globalThis.__TEST_TEMP_DIR = tempDir;
+
+        fs.mkdirSync(path.join(tempDir, '.state', 'logs'), { recursive: true });
+        fs.mkdirSync(path.join(tempDir, 'memory'), { recursive: true });
+
+        const mockSubagent = {
+            run: vi.fn().mockResolvedValue({ runId: 'test-run-123' }),
+            waitForRun: vi.fn().mockResolvedValue({ status: 'ok' }),
+            getSessionMessages: vi.fn().mockResolvedValue({ messages: [], assistantTexts: [] }),
+            deleteSession: vi.fn().mockResolvedValue(undefined),
+        };
+
+        mockApi = {
+            id: "test-plugin",
+            name: "Test Plugin",
+            source: "local",
+            workspaceDir: tempDir,
+            config: { workspaceDir: tempDir },
+            runtime: { subagent: mockSubagent } as unknown as PluginRuntime,
+            logger: { info: vi.fn(), error: vi.fn(), warn: vi.fn(), debug: vi.fn() },
+            registerTool: vi.fn(),
+            registerHook: vi.fn(),
+            registerHttpRoute: vi.fn(),
+            registerService: vi.fn(),
+            registerCommand: vi.fn(),
+            resolvePath: vi.fn((p: string) => path.join(tempDir, p)),
+            on: vi.fn(),
+        };
+
+        globalThis.__DR_MOCK_MANAGER = {
+            startWorkflow: vi.fn().mockResolvedValue({
+                workflowId: 'wf-test-123',
+                childSessionKey: 'agent:main:subagent:workflow-test-123',
+                state: 'active',
+            }),
+            dispose: vi.fn(),
+            store: {
+                getWorkflow: vi.fn().mockReturnValue({
+                    workflow_id: 'wf-test-123',
+                    state: 'completed',
+                    child_session_key: 'agent:main:subagent:workflow-test-123',
+                }),
+            },
+        };
+    });
+
+    afterEach(() => {
+        fs.rmSync(tempDir, { recursive: true, force: true });
+        globalThis.__TEST_TEMP_DIR = undefined;
+        globalThis.__DR_MOCK_MANAGER = undefined;
+        vi.clearAllMocks();
+    });
+
+    const executeTool = async (rawParams: Record<string, unknown>) => {
+        const tool = createDeepReflectTool(mockApi);
+        return tool.execute('test-call-id', rawParams);
+    };
+
+    describe('参数验证', () => {
+        it('context 为空时应返回错误', async () => {
+            const result = await executeTool({ context: '' });
+            expect(result.content[0].text).toContain('必须提供反思上下文');
+        });
+
+        it('workspaceDir 缺失时应返回错误', async () => {
+            const noWsApi = {
+                ...mockApi,
+                workspaceDir: undefined,
+                config: {},
+                resolvePath: vi.fn(() => undefined),
+            };
+            const tool = createDeepReflectTool(noWsApi as any);
+            const result = await tool.execute('test-call-id', { context: 'test' });
+            // effectiveWorkspaceDir resolves to undefined, tool should fail gracefully
+            expect(result.content[0].text).toMatch(/失败|required|Workspace/i);
+        });
+    });
+
+    describe('workflow 执行', () => {
+        it('应创建 DeepReflectWorkflowManager 并调用 startWorkflow', async () => {
+            const { DeepReflectWorkflowManager } = await import('../../src/service/subagent-workflow/deep-reflect-workflow-manager.js');
+            const reflectionLogPath = path.join(tempDir, 'memory', 'REFLECTION_LOG.md');
+            fs.writeFileSync(reflectionLogPath, `# Reflection Log\n\n### Insights\nTest insight here\n\n`);
+
+            const result = await executeTool({ context: 'Need to improve caching.' });
+
+            expect(DeepReflectWorkflowManager).toHaveBeenCalledWith({
+                workspaceDir: tempDir,
+                logger: mockApi.logger,
+                subagent: mockApi.runtime.subagent,
+            });
+            expect(globalThis.__DR_MOCK_MANAGER.startWorkflow).toHaveBeenCalled();
+            expect(result.content[0].text).toContain('Test insight here');
+        });
+
+        it('应传递正确的 taskInput 给 startWorkflow', async () => {
+            const { DeepReflectWorkflowManager } = await import('../../src/service/subagent-workflow/deep-reflect-workflow-manager.js');
+            const reflectionLogPath = path.join(tempDir, 'memory', 'REFLECTION_LOG.md');
+            fs.writeFileSync(reflectionLogPath, `# Reflection Log\n\n### Insights\nDone\n\n`);
+
+            await executeTool({ context: 'Test context', depth: 3 });
+
+            expect(DeepReflectWorkflowManager).toHaveBeenCalledWith(
+                expect.objectContaining({ workspaceDir: tempDir })
+            );
+            const startArgs = globalThis.__DR_MOCK_MANAGER.startWorkflow.mock.calls[0][1];
+            expect(startArgs.taskInput).toEqual({
+                context: 'Test context',
+                depth: 3,
+                model_id: undefined,
+            });
+        });
+    });
+
+    describe('超时处理', () => {
+        it('workflow 超时应返回超时提示', async () => {
+            // Create PAIN_SETTINGS.json to override default 60s timeout
+            const settingsPath = path.join(tempDir, '.principles', 'PAIN_SETTINGS.json');
+            fs.mkdirSync(path.dirname(settingsPath), { recursive: true });
+            fs.writeFileSync(settingsPath, JSON.stringify({ deep_reflection: { timeout_ms: 300 } }));
+
+            globalThis.__DR_MOCK_MANAGER.store.getWorkflow.mockReturnValue({
+                workflow_id: 'wf-test-123',
+                state: 'active',
+            });
+
+            const result = await executeTool({ context: 'Timeout test.' });
+
+            expect(result.content[0].text).toContain('超时');
+            expect(globalThis.__DR_MOCK_MANAGER.dispose).toHaveBeenCalled();
+        }, 10000);
+    });
+
+    describe('错误处理', () => {
+        it('workflow terminal_error 应返回错误信息', async () => {
+            globalThis.__DR_MOCK_MANAGER.store.getWorkflow.mockReturnValue({
+                workflow_id: 'wf-test-123',
+                state: 'terminal_error',
+            });
+
+            const result = await executeTool({ context: 'Error test.' });
+
+            expect(result.content[0].text).toContain('失败');
+            expect(globalThis.__DR_MOCK_MANAGER.dispose).toHaveBeenCalled();
+        });
+
+        it('startWorkflow 抛出异常应返回友好错误', async () => {
+            globalThis.__DR_MOCK_MANAGER.startWorkflow.mockRejectedValue(new Error('Network error'));
+
+            const result = await executeTool({ context: 'Crash test.' });
+
+            expect(result.content[0].text).toContain('失败');
+            expect(result.content[0].text).toContain('Network error');
+        });
+    });
+
+    describe('向后兼容：model_id 参数', () => {
+        it('当传入 model_id 时，应输出警告日志', async () => {
+            const reflectionLogPath = path.join(tempDir, 'memory', 'REFLECTION_LOG.md');
+            fs.writeFileSync(reflectionLogPath, `# Reflection Log\n\n### Insights\nDone\n\n`);
+
+            await executeTool({ model_id: 'T-01', context: 'Test.' });
+
+            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
+                expect.stringContaining('deprecated')
+            );
+        });
+    });
+
+    describe('工具参数定义', () => {
+        it('model_id 应为可选参数', () => {
+            const schema = deepReflectTool.parameters;
+            const hasModelId = 'model_id' in schema.properties;
+            if (hasModelId) {
+                const required = (schema as any).required || [];
+                expect(required).not.toContain('model_id');
+            }
+        });
+
+        it('context 应为必需参数', () => {
+            const schema = deepReflectTool.parameters;
+            const required = (schema as any).required || [];
+            expect(required).toContain('context');
+        });
+
+        it('depth 应为可选参数', () => {
+            const schema = deepReflectTool.parameters;
+            const required = (schema as any).required || [];
+            expect(required).not.toContain('depth');
+        });
+    });
+});

package/tests/tools/model-index.test.ts

@@ -0,0 +1,246 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+// 导入待测试的函数
+import { loadModelIndex } from '../../src/tools/model-index.js';
+import type { OpenClawPluginApi } from '../../src/openclaw-sdk.js';
+
+describe('loadModelIndex', () => {
+    let tempDir: string;
+    let mockApi: OpenClawPluginApi;
+
+    beforeEach(() => {
+        // 创建临时目录
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'model-index-test-'));
+        
+        mockApi = {
+            id: "test-plugin",
+            name: "Test Plugin",
+            source: "local",
+            config: {},
+            runtime: {} as any,
+            logger: {
+                info: vi.fn(),
+                error: vi.fn(),
+                warn: vi.fn(),
+                debug: vi.fn(),
+            },
+            registerTool: vi.fn(),
+            registerHook: vi.fn(),
+            registerHttpRoute: vi.fn(),
+            registerChannel: vi.fn(),
+            registerGatewayMethod: vi.fn(),
+            registerCli: vi.fn(),
+            registerService: vi.fn(),
+            registerProvider: vi.fn(),
+            registerCommand: vi.fn(),
+            resolvePath: vi.fn(),
+            on: vi.fn(),
+        } as unknown as OpenClawPluginApi;
+    });
+
+    afterEach(() => {
+        // 清理临时目录
+        fs.rmSync(tempDir, { recursive: true, force: true });
+    });
+
+    describe('边界情况', () => {
+        it('当 workspaceDir 为 undefined 时，应返回默认消息', () => {
+            const result = loadModelIndex(undefined, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+        });
+
+        it('当 workspaceDir 为空字符串时，应返回默认消息', () => {
+            const result = loadModelIndex('', mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+        });
+    });
+
+    describe('索引文件存在', () => {
+        it('应返回索引文件内容', () => {
+            const modelsDir = path.join(tempDir, '.principles', 'models');
+            fs.mkdirSync(modelsDir, { recursive: true });
+            
+            const indexContent = `# 扩展思维模型索引
+
+| ID | 名称 | 适用场景 |
+|----|------|----------|
+| MARKETING_4P | 营销4P | 营销策略 |
+`;
+            fs.writeFileSync(path.join(modelsDir, '_INDEX.md'), indexContent);
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toContain('扩展思维模型索引');
+            expect(result).toContain('MARKETING_4P');
+        });
+    });
+
+    describe('索引文件不存在', () => {
+        it('当 models 目录不存在时，应返回默认消息（无警告）', () => {
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+            expect(mockApi.logger!.warn).not.toHaveBeenCalled();
+        });
+
+        it('当 models 目录存在但索引文件不存在时，应返回默认消息并输出警告日志', () => {
+            const modelsDir = path.join(tempDir, '.principles', 'models');
+            fs.mkdirSync(modelsDir, { recursive: true });
+            
+            // 创建一个模型文件，但不创建索引文件
+            fs.writeFileSync(path.join(modelsDir, 'marketing_4p.md'), '# 营销4P模型');
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
+                expect.stringContaining('_INDEX.md not found')
+            );
+        });
+    });
+
+    describe('文件大小限制', () => {
+        it('当索引文件超过 50KB 时，应返回默认消息并输出警告日志', () => {
+            const modelsDir = path.join(tempDir, '.principles', 'models');
+            fs.mkdirSync(modelsDir, { recursive: true });
+            
+            // 创建一个超过 50KB 的文件
+            const largeContent = 'x'.repeat(51 * 1024);
+            fs.writeFileSync(path.join(modelsDir, '_INDEX.md'), largeContent);
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Index file too large')
+            );
+        });
+
+        it('当索引文件刚好 50KB 时，应正常返回内容', () => {
+            const modelsDir = path.join(tempDir, '.principles', 'models');
+            fs.mkdirSync(modelsDir, { recursive: true });
+            
+            // 创建一个刚好 50KB 的文件
+            const exactContent = 'x'.repeat(50 * 1024);
+            fs.writeFileSync(path.join(modelsDir, '_INDEX.md'), exactContent);
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe(exactContent);
+        });
+    });
+
+    describe('错误处理', () => {
+        it('当读取文件失败时，应返回默认消息并记录错误日志', () => {
+            const modelsDir = path.join(tempDir, '.principles', 'models');
+            fs.mkdirSync(modelsDir, { recursive: true });
+            
+            const indexPath = path.join(modelsDir, '_INDEX.md');
+            
+            // 创建一个目录而非文件，导致读取失败
+            fs.mkdirSync(indexPath, { recursive: true });
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Failed to load model index')
+            );
+        });
+    });
+
+    describe('api 参数可选', () => {
+        it('当 api 为 undefined 时，不应抛出错误', () => {
+            const result = loadModelIndex(tempDir);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+        });
+    });
+
+    describe('自定义路径支持', () => {
+        it('应从配置文件读取自定义 modelsDir', () => {
+            const stateDir = path.join(tempDir, '.state');
+            fs.mkdirSync(stateDir, { recursive: true });
+            
+            const config = {
+                deep_reflection: {
+                    modelsDir: 'custom-models'
+                }
+            };
+            fs.writeFileSync(path.join(stateDir, 'pain_settings.json'), JSON.stringify(config));
+
+            const customModelsDir = path.join(tempDir, 'custom-models');
+            fs.mkdirSync(customModelsDir, { recursive: true });
+            
+            const indexContent = `# 自定义模型索引\n|CUSTOM|自定义模型|测试|`;
+            fs.writeFileSync(path.join(customModelsDir, '_INDEX.md'), indexContent);
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toContain('自定义模型');
+            expect(mockApi.logger!.debug).toHaveBeenCalledWith(
+                expect.stringContaining('custom-models')
+            );
+        });
+
+        it('支持绝对路径的自定义 modelsDir', () => {
+            const stateDir = path.join(tempDir, '.state');
+            fs.mkdirSync(stateDir, { recursive: true });
+            
+            const absCustomDir = fs.mkdtempSync(path.join(os.tmpdir(), 'abs-models-'));
+            
+            const config = {
+                deep_reflection: {
+                    modelsDir: absCustomDir
+                }
+            };
+            fs.writeFileSync(path.join(stateDir, 'pain_settings.json'), JSON.stringify(config));
+
+            const indexContent = `# 绝对路径模型\n|ABS|绝对路径|测试|`;
+            fs.writeFileSync(path.join(absCustomDir, '_INDEX.md'), indexContent);
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toContain('绝对路径');
+            
+            fs.rmSync(absCustomDir, { recursive: true, force: true });
+        });
+
+        it('当配置无效时应回退到默认路径', () => {
+            const stateDir = path.join(tempDir, '.state');
+            fs.mkdirSync(stateDir, { recursive: true });
+            
+            const config = {
+                deep_reflection: {
+                    modelsDir: 123
+                }
+            };
+            fs.writeFileSync(path.join(stateDir, 'pain_settings.json'), JSON.stringify(config));
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+        });
+
+        it('当自定义路径不存在时应返回默认消息', () => {
+            const stateDir = path.join(tempDir, '.state');
+            fs.mkdirSync(stateDir, { recursive: true });
+            
+            const config = {
+                deep_reflection: {
+                    modelsDir: 'non-existent-path'
+                }
+            };
+            fs.writeFileSync(path.join(stateDir, 'pain_settings.json'), JSON.stringify(config));
+
+            const result = loadModelIndex(tempDir, mockApi);
+            
+            expect(result).toBe('（暂无扩展思维模型）');
+        });
+    });
+});

package/tests/ui/app.test.tsx

@@ -0,0 +1,114 @@
+// @vitest-environment jsdom
+
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { cleanup, render, screen, waitFor, fireEvent } from '@testing-library/react';
+import React from 'react';
+import { App } from '../../ui/src/App';
+
+// Mock localStorage
+const localStorageMock = (() => {
+  let store: Record<string, string> = {};
+  return {
+    getItem: (key: string) => store[key] || null,
+    setItem: (key: string, value: string) => { store[key] = value; },
+    removeItem: (key: string) => { delete store[key]; },
+    clear: () => { store = {}; },
+  };
+})();
+
+Object.defineProperty(window, 'localStorage', { value: localStorageMock });
+
+describe('Principles Console App', () => {
+  beforeEach(() => {
+    localStorageMock.clear();
+  });
+
+  afterEach(() => {
+    cleanup();
+    vi.unstubAllGlobals();
+    window.history.replaceState({}, '', '/');
+  });
+
+  it('shows login page when not authenticated', async () => {
+    window.history.replaceState({}, '', '/plugins/principles/');
+    vi.stubGlobal('fetch', vi.fn((input: RequestInfo | URL) => {
+      return Promise.resolve(new Response(JSON.stringify({ error: 'Unauthorized' }), { status: 401 }));
+    }));
+
+    render(<App />);
+
+    await waitFor(() => {
+      expect(screen.getByText('Principles Console')).toBeTruthy();
+      expect(screen.getByText('AI Agent 进化流程监控平台')).toBeTruthy();
+    });
+  });
+
+  it('renders the overview page after successful login', async () => {
+    window.history.replaceState({}, '', '/plugins/principles/overview');
+    let overviewCallCount = 0;
+
+    vi.stubGlobal('fetch', vi.fn((input: RequestInfo | URL, init?: RequestInit) => {
+      const url = String(input);
+
+      if (url.includes('/api/central/overview') || url.includes('/api/overview')) {
+        overviewCallCount++;
+        const hasAuth = init?.headers && JSON.stringify(init.headers).includes('Bearer');
+
+        if (hasAuth || overviewCallCount > 1) {
+          return Promise.resolve(new Response(JSON.stringify({
+            workspaceDir: '/workspace',
+            generatedAt: '2026-03-19T10:00:00.000Z',
+            dataFreshness: '2026-03-19T10:00:00.000Z',
+            summary: {
+              repeatErrorRate: 0.2,
+              userCorrectionRate: 0.1,
+              pendingSamples: 2,
+              approvedSamples: 1,
+              thinkingCoverageRate: 0.4,
+              painEvents: 3,
+              principleEventCount: 5,
+            },
+            dailyTrend: [],
+            topRegressions: [],
+            sampleQueue: { counters: { pending: 2 }, preview: [] },
+            thinkingSummary: { activeModels: 2, dormantModels: 7, effectiveModels: 1, coverageRate: 0.4 },
+            centralInfo: { workspaceCount: 3, workspaces: ['workspace-main', 'workspace-builder', 'workspace-pm'] },
+          }), { status: 200 }));
+        }
+
+        return Promise.resolve(new Response(JSON.stringify({ error: 'Unauthorized' }), { status: 401 }));
+      }
+
+      return Promise.resolve(new Response(JSON.stringify({
+        configs: [],
+        workspaces: [],
+        summary: { totalModels: 0, activeModels: 0, dormantModels: 0, effectiveModels: 0, coverageRate: 0 },
+        topModels: [],
+        dormantModels: [],
+        effectiveModels: [],
+        scenarioMatrix: [],
+        coverageTrend: [],
+      }), { status: 200 }));
+    }));
+
+    render(<App />);
+
+    // Wait for login page
+    await waitFor(() => {
+      expect(screen.getByPlaceholderText('请输入您的 Gateway Token')).toBeTruthy();
+    });
+
+    // Enter token and submit
+    const input = screen.getByPlaceholderText('请输入您的 Gateway Token');
+    fireEvent.change(input, { target: { value: 'test-token-123' } });
+
+    const loginButton = screen.getByRole('button', { name: /登 录/ });
+    fireEvent.click(loginButton);
+
+    // Wait for overview page
+    await waitFor(() => {
+      expect(screen.getByText('Workspace health and queue pressure')).toBeTruthy();
+      expect(screen.getByText('Pending Samples')).toBeTruthy();
+    }, { timeout: 5000 });
+  });
+});