principles-disciple 1.32.0 → 1.34.0

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

@@ -1,232 +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';
-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

@@ -1,246 +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';
-
-// 导入待测试的函数
-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

@@ -1,114 +0,0 @@
-// @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 });
-  });
-});