principles-disciple 1.8.0 → 1.8.2

package/tests/task-compliance.test.ts

@@ -0,0 +1,166 @@
+/**
+ * Task Compliance Tests
+ *
+ * Tests the validateTaskCompliance function added in P0 improvement (Pain #671cfd17)
+ */
+
+import { describe, it, expect } from 'vitest';
+
+// Note: The validateTaskCompliance logic was originally in agent-spawn.ts
+// but has been removed. We test the compliance validation logic here.
+
+function validateTaskCompliance(task: string): {
+  valid: boolean;
+  violations: string[];
+  warnings: string[];
+} {
+  const violations: string[] = [];
+  const warnings: string[] = [];
+  const taskLower = task.toLowerCase();
+
+  // 检测"代劳"行为 - 违反"指导优于代劳"原则
+  if (taskLower.includes('为他') || taskLower.includes('代替') || taskLower.includes('帮他')) {
+    if (!taskLower.includes('指导') && !taskLower.includes('让他自己') && !taskLower.includes('指示')) {
+      violations.push(
+        '⚠️ 可能违反"指导优于代劳"原则：任务包含"为他/代替/帮他"，但没有"指导/让他自己/指示"的表述。' +
+        '\n协议要求：优先指导目标智能体自己完成，而非代替执行。'
+      );
+    }
+  }
+
+  // 检测技能安装/修改操作 - 要求包含验证步骤
+  if (taskLower.includes('安装') || taskLower.includes('install') ||
+      taskLower.includes('删除') || taskLower.includes('delete') ||
+      taskLower.includes('修改') || taskLower.includes('edit') ||
+      taskLower.includes('创建') || taskLower.includes('create')) {
+    if (!taskLower.includes('验证') && !taskLower.includes('检查') &&
+        !taskLower.includes('确认') && !taskLower.includes('verify')) {
+      warnings.push(
+        '⚠️ 可能缺少"完成性思维"：安装/修改操作应该包含"验证/检查/确认"步骤。' +
+        '\n协议要求：任务完成 = 执行 + 验证 + 确认'
+      );
+    }
+  }
+
+  return {
+    valid: violations.length === 0,
+    violations,
+    warnings
+  };
+}
+
+describe('Task Compliance Validation', () => {
+  describe('代劳违规检测', () => {
+    it('should detect "代替" without guidance', () => {
+      const result = validateTaskCompliance('代替Bridge安装技能X');
+      expect(result.valid).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0]).toContain('指导优于代劳');
+    });
+
+    it('should detect "为他" without guidance', () => {
+      const result = validateTaskCompliance('为他安装技能X');
+      expect(result.valid).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0]).toContain('指导优于代劳');
+    });
+
+    it('should detect "帮他" without guidance', () => {
+      const result = validateTaskCompliance('帮他安装技能X');
+      expect(result.valid).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.violations[0]).toContain('指导优于代劳');
+    });
+
+    it('should allow "代替" with guidance', () => {
+      const result = validateTaskCompliance('指导Bridge自己安装技能X，并验证他能正常使用');
+      expect(result.valid).toBe(true);
+      expect(result.violations.length).toBe(0);
+    });
+
+    it('should allow "让他自己" phrasing', () => {
+      const result = validateTaskCompliance('指示他让他自己完成安装');
+      expect(result.valid).toBe(true);
+      expect(result.violations.length).toBe(0);
+    });
+  });
+
+  describe('验证缺失检测', () => {
+    it('should warn about "安装" without verification', () => {
+      const result = validateTaskCompliance('安装技能X');
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings[0]).toContain('完成性思维');
+    });
+
+    it('should warn about "install" without verification', () => {
+      const result = validateTaskCompliance('install skill X');
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings[0]).toContain('完成性思维');
+    });
+
+    it('should warn about "修改" without verification', () => {
+      const result = validateTaskCompliance('修改配置文件');
+      expect(result.warnings.length).toBeGreaterThan(0);
+      expect(result.warnings[0]).toContain('完成性思维');
+    });
+
+    it('should allow "安装" with verification', () => {
+      const result = validateTaskCompliance('安装技能X并验证功能');
+      expect(result.warnings.length).toBe(0);
+    });
+
+    it('should allow "修改" with check', () => {
+      const result = validateTaskCompliance('修改配置文件并检查结果');
+      expect(result.warnings.length).toBe(0);
+    });
+
+    it('should allow "创建" with confirm', () => {
+      const result = validateTaskCompliance('创建新文件并确认写入成功');
+      expect(result.warnings.length).toBe(0);
+    });
+  });
+
+  describe('复合场景', () => {
+    it('should detect both violation and warning', () => {
+      const result = validateTaskCompliance('代替他安装技能X');
+      expect(result.valid).toBe(false);
+      expect(result.violations.length).toBeGreaterThan(0);
+      expect(result.warnings.length).toBeGreaterThan(0);
+    });
+
+    it('should allow valid guidance task', () => {
+      const result = validateTaskCompliance('指导Bridge自己安装技能X，并验证安装成功');
+      expect(result.valid).toBe(true);
+      expect(result.violations.length).toBe(0);
+      expect(result.warnings.length).toBe(0);
+    });
+
+    it('should be valid for non-modification tasks', () => {
+      const result = validateTaskCompliance('分析代码结构，找出性能瓶颈');
+      expect(result.valid).toBe(true);
+      expect(result.violations.length).toBe(0);
+      expect(result.warnings.length).toBe(0);
+    });
+  });
+
+  describe('边界情况', () => {
+    it('should handle empty task', () => {
+      const result = validateTaskCompliance('');
+      expect(result.valid).toBe(true);
+      expect(result.violations.length).toBe(0);
+      expect(result.warnings.length).toBe(0);
+    });
+
+    it('should handle case-insensitive detection', () => {
+      const result1 = validateTaskCompliance('代替他安装');
+      const result2 = validateTaskCompliance('代替他安装');
+      expect(result1.valid).toBe(result2.valid);
+    });
+
+    it('should detect mixed language violations', () => {
+      const result = validateTaskCompliance('Help him install the skill');
+      // English "help him" should not trigger since we only check Chinese keywords
+      expect(result.valid).toBe(true); // or adjust if needed
+    });
+  });
+});

package/tests/test-utils.ts

@@ -0,0 +1,48 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { WorkspaceContext } from '../src/core/workspace-context.js';
+
+/**
+ * Creates a WorkspaceContext for testing purposes.
+ * If no workspaceDir is provided, a temporary directory is created.
+ */
+export function createTestContext(overrides: { workspaceDir?: string, stateDir?: string } = {}): WorkspaceContext {
+    let workspaceDir = overrides.workspaceDir;
+
+    if (!workspaceDir) {
+        workspaceDir = fs.mkdtempSync(path.join(os.tmpdir(), 'pd-test-'));
+    }
+
+    // Ensure it's absolute
+    workspaceDir = path.resolve(workspaceDir);
+
+    const mockCtx = {
+        workspaceDir,
+        stateDir: overrides.stateDir
+    };
+
+    // We use fromHookContext but bypass the cache for tests to ensure isolation
+    // Actually, clearCache might be better
+    WorkspaceContext.clearCache();
+    return WorkspaceContext.fromHookContext(mockCtx);
+}
+
+/**
+ * Safely removes a directory, ignoring Windows EPERM/ENOTEMPTY errors.
+ * Windows file locks can cause these errors when file handles are still held.
+ * The OS will eventually clean up temp directories, so it's safe to ignore.
+ */
+export function safeRmDir(dir: string): void {
+    try {
+        if (fs.existsSync(dir)) {
+            fs.rmSync(dir, { recursive: true, force: true });
+        }
+    } catch (err: any) {
+        // On Windows, ignore EPERM/ENOTEMPTY errors (file handle still held)
+        // The OS will clean up temp directories eventually
+        if (process.platform !== 'win32' || (err?.code !== 'EPERM' && err?.code !== 'ENOTEMPTY')) {
+            throw err;
+        }
+    }
+}

package/tests/tools/critique-prompt.test.ts

@@ -0,0 +1,260 @@
+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 { buildCritiquePromptV2 } from '../../src/tools/critique-prompt.js';
+import type { OpenClawPluginApi } from '../../src/openclaw-sdk.js';
+
+describe('buildCritiquePromptV2', () => {
+    let tempDir: string;
+    let mockApi: OpenClawPluginApi;
+
+    beforeEach(() => {
+        tempDir = fs.mkdtempSync(path.join(os.tmpdir(), 'critique-prompt-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('应包含 "Critical Analysis Engine" 标识', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试上下文',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('Critical Analysis Engine');
+        });
+
+        it('应包含用户上下文', () => {
+            const result = buildCritiquePromptV2({
+                context: '这是一个关于营销策略的计划',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('这是一个关于营销策略的计划');
+        });
+    });
+
+    describe('元认知模型说明', () => {
+        it('应说明元认知模型已继承，不应重复列出 T-01 到 T-09', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            // 应包含继承说明
+            expect(result).toContain('Meta-Cognitive Models');
+            expect(result).toContain('inherited');
+            expect(result).toContain('thinking_os');
+            
+            // 不应重复列出具体的元认知模型
+            expect(result).not.toContain('T-01: Map Before Territory');
+            expect(result).not.toContain('T-02: Constraints as Lighthouses');
+            expect(result).not.toContain('T-09: Divide and Conquer');
+        });
+    });
+
+    describe('模型选择指南', () => {
+        it('应包含 Step 1/2/3 选择指南', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('Model Selection Guidelines');
+            expect(result).toContain('Step 1');
+            expect(result).toContain('Step 2');
+            expect(result).toContain('Step 3');
+        });
+
+        it('Step 1 应包含任务类型判断指导', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('general planning');
+            expect(result).toContain('domain-specific');
+        });
+
+        it('Step 3 应包含 Fallback 说明', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('Fallback');
+            expect(result).toContain('Meta-Cognitive Models');
+        });
+    });
+
+    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 = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('Domain-Specific Models');
+            expect(result).toContain('MARKETING_4P');
+        });
+
+        it('当无索引文件时，应显示默认消息', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('暂无扩展思维模型');
+        });
+    });
+
+    describe('深度指令', () => {
+        it('depth=1 时应使用轻量分析指令', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: 1,
+            });
+
+            expect(result).toContain('quick');
+        });
+
+        it('depth=2 时应使用平衡分析指令', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: 2,
+            });
+
+            expect(result).toContain('balanced');
+        });
+
+        it('depth=3 时应使用详尽分析指令', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: 3,
+            });
+
+            expect(result).toContain('thorough');
+        });
+
+        it('默认 depth 应为 2', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                // 不指定 depth
+            });
+
+            expect(result).toContain('balanced');
+        });
+    });
+
+    describe('深度边界值验证', () => {
+        it('depth=0 时应 fallback 到 2 并输出警告', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: 0,
+                api: mockApi,
+            });
+
+            expect(result).toContain('balanced');
+            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Invalid depth value 0')
+            );
+        });
+
+        it('depth=4 时应 fallback 到 2 并输出警告', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: 4,
+                api: mockApi,
+            });
+
+            expect(result).toContain('balanced');
+            expect(mockApi.logger!.warn).toHaveBeenCalledWith(
+                expect.stringContaining('Invalid depth value 4')
+            );
+        });
+
+        it('depth=-1 时应 fallback 到 2', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: -1,
+                api: mockApi,
+            });
+
+            expect(result).toContain('balanced');
+        });
+
+        it('depth=999 时应 fallback 到 2', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+                depth: 999,
+                api: mockApi,
+            });
+
+            expect(result).toContain('balanced');
+        });
+    });
+
+    describe('输出结构', () => {
+        it('应包含要求的输出结构', () => {
+            const result = buildCritiquePromptV2({
+                context: '测试',
+                workspaceDir: tempDir,
+            });
+
+            expect(result).toContain('Blind Spots');
+            expect(result).toContain('Risk Warnings');
+            expect(result).toContain('Alternative Approaches');
+            expect(result).toContain('Recommendations');
+            expect(result).toContain('Confidence Level');
+        });
+    });
+});