@dommaker/harness 0.13.0 → 0.13.2

package/src/core/constraints/__tests__/interceptor.test.ts

@@ -0,0 +1,251 @@
+/**
+ * ConstraintInterceptor 测试
+ */
+
+import { ConstraintInterceptor, constraintInterceptor } from '../interceptor';
+import { constraintChecker } from '../checker';
+import type { Constraint, ConstraintContext, ConstraintTrigger } from '../../../types/constraint';
+import type { EnforcementExecutor, EnforcementResult } from '../../../types/enforcement';
+
+// Mock constraintChecker
+jest.mock('../checker', () => ({
+  constraintChecker: {
+    getConstraints: jest.fn(),
+    check: jest.fn().mockResolvedValue({ satisfied: true }),
+  },
+}));
+
+const mockChecker = constraintChecker as jest.Mocked<typeof constraintChecker>;
+
+describe('ConstraintInterceptor', () => {
+  let interceptor: ConstraintInterceptor;
+
+  const mockCheck = jest.fn().mockResolvedValue({ satisfied: true });
+
+  const mockIronLaw = {
+    id: 'test_iron_law',
+    rule: 'Test Iron Law',
+    message: 'Test iron law message',
+    level: 'iron_law' as const,
+    trigger: 'code_implementation',
+    enforcement: 'test-enforcement',
+    check: mockCheck,
+  };
+
+  const mockGuideline = {
+    id: 'test_guideline',
+    rule: 'Test Guideline',
+    message: 'Test guideline message',
+    level: 'guideline' as const,
+    trigger: 'code_implementation',
+    enforcement: 'guideline-enforcement',
+    check: mockCheck,
+  };
+
+  const mockContext: ConstraintContext = {
+    operation: 'code_implementation',
+    projectPath: '/test',
+  };
+
+  const mockExecutor: EnforcementExecutor = {
+    execute: jest.fn(),
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    // Use the singleton instance
+    interceptor = ConstraintInterceptor.getInstance();
+    // Clear any previous state
+    interceptor.clearSkips();
+    interceptor.setEnabled(true);
+
+    mockChecker.getConstraints.mockReturnValue({
+      ironLaws: { test_iron_law: mockIronLaw },
+      guidelines: { test_guideline: mockGuideline },
+      tips: {},
+    });
+  });
+
+  describe('getInstance', () => {
+    it('should return singleton instance', () => {
+      const instance1 = ConstraintInterceptor.getInstance();
+      const instance2 = ConstraintInterceptor.getInstance();
+      expect(instance1).toBe(instance2);
+    });
+  });
+
+  describe('register', () => {
+    it('should register executor', () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      expect(interceptor.hasExecutor('test-enforcement')).toBe(true);
+    });
+  });
+
+  describe('registerBatch', () => {
+    it('should register multiple executors', () => {
+      interceptor.registerBatch([
+        { enforcementId: 'exec1', executor: mockExecutor },
+        { enforcementId: 'exec2', executor: mockExecutor },
+      ]);
+      expect(interceptor.hasExecutor('exec1')).toBe(true);
+      expect(interceptor.hasExecutor('exec2')).toBe(true);
+    });
+  });
+
+  describe('unregister', () => {
+    it('should unregister executor', () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      const result = interceptor.unregister('test-enforcement');
+      expect(result).toBe(true);
+      expect(interceptor.hasExecutor('test-enforcement')).toBe(false);
+    });
+
+    it('should return false if not exists', () => {
+      const result = interceptor.unregister('nonexistent');
+      expect(result).toBe(false);
+    });
+  });
+
+  describe('getExecutor', () => {
+    it('should return registered executor', () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      const executor = interceptor.getExecutor('test-enforcement');
+      expect(executor).toBe(mockExecutor);
+    });
+
+    it('should return undefined if not registered', () => {
+      const executor = interceptor.getExecutor('nonexistent');
+      expect(executor).toBeUndefined();
+    });
+  });
+
+  describe('getRegistrations', () => {
+    it('should return all registrations', () => {
+      interceptor.unregister('test-enforcement'); // Clear any existing
+      interceptor.register('test-enforcement', mockExecutor);
+      const registrations = interceptor.getRegistrations();
+      const found = registrations.find(r => r.id === 'test-enforcement');
+      expect(found).toBeDefined();
+    });
+  });
+
+  describe('setEnabled', () => {
+    it('should disable interceptor', () => {
+      interceptor.setEnabled(false);
+      interceptor.register('test-enforcement', mockExecutor);
+
+      const result = interceptor.intercept('code_implementation', mockContext);
+      // When disabled, should pass without checking
+      expect(result).resolves.toHaveProperty('passed', true);
+    });
+  });
+
+  describe('skip', () => {
+    it('should skip specified enforcements', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      interceptor.skip(['test-enforcement']);
+
+      const result = await interceptor.intercept('code_implementation', mockContext);
+      expect(result.constraints.some(c => c.skipped)).toBe(true);
+    });
+  });
+
+  describe('clearSkips', () => {
+    it('should clear all skips', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      interceptor.skip(['test-enforcement']);
+      interceptor.clearSkips();
+
+      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
+      await interceptor.intercept('code_implementation', mockContext);
+      expect(mockExecutor.execute).toHaveBeenCalled();
+    });
+  });
+
+  describe('intercept', () => {
+    it('should pass when all constraints satisfied', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      interceptor.register('guideline-enforcement', mockExecutor);
+
+      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
+
+      const result = await interceptor.intercept('code_implementation', mockContext);
+      expect(result.passed).toBe(true);
+      expect(result.violations.length).toBe(0);
+    });
+
+    it('should fail on iron law violation', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: false });
+
+      await expect(interceptor.intercept('code_implementation', mockContext)).rejects.toThrow();
+    });
+
+    it('should record guideline violation without throwing', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      interceptor.register('guideline-enforcement', mockExecutor);
+
+      (mockExecutor.execute as jest.Mock)
+        .mockResolvedValueOnce({ passed: true })  // iron law passes
+        .mockResolvedValueOnce({ passed: false }); // guideline fails
+
+      const result = await interceptor.intercept('code_implementation', mockContext);
+      expect(result.passed).toBe(true); // guidelines don't block
+      expect(result.violations.length).toBe(1);
+    });
+
+    it('should handle missing executor', async () => {
+      // No constraints at all
+      mockChecker.getConstraints.mockReturnValue({
+        ironLaws: {},
+        guidelines: {},
+        tips: {},
+      });
+
+      const result = await interceptor.intercept('code_implementation', mockContext);
+      expect(result.passed).toBe(true);
+      expect(result.constraints.length).toBe(0);
+    });
+
+    it('should handle executor error for iron law', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      (mockExecutor.execute as jest.Mock).mockRejectedValue(new Error('Executor error'));
+
+      await expect(interceptor.intercept('code_implementation', mockContext)).rejects.toThrow();
+    });
+  });
+
+  describe('claim', () => {
+    it('should pass when constraints satisfied', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
+
+      await expect(interceptor.claim('code_implementation', mockContext)).resolves.not.toThrow();
+    });
+
+    it('should throw on violation', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: false });
+
+      await expect(interceptor.claim('code_implementation', mockContext)).rejects.toThrow();
+    });
+  });
+
+  describe('canProceed', () => {
+    it('should return true when passed', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      (mockExecutor.execute as jest.Mock).mockResolvedValue({ passed: true });
+
+      const result = await interceptor.canProceed('code_implementation', mockContext);
+      expect(result).toBe(true);
+    });
+
+    it('should return false on error', async () => {
+      interceptor.register('test-enforcement', mockExecutor);
+      (mockExecutor.execute as jest.Mock).mockRejectedValue(new Error('Error'));
+
+      const result = await interceptor.canProceed('code_implementation', mockContext);
+      expect(result).toBe(false);
+    });
+  });
+});

package/src/core/constraints/__tests__/prompt-injection.test.ts

@@ -0,0 +1,89 @@
+/**
+ * Tests for prompt-injection.ts
+ *
+ * formatConstraintsForPrompt is pure logic — no file I/O, no external state.
+ */
+
+import { formatConstraintsForPrompt } from '../prompt-injection';
+
+describe('formatConstraintsForPrompt', () => {
+  it('returns constraints with injectPrompt for deploy role', () => {
+    const result = formatConstraintsForPrompt('deploy');
+    // deploy maps to ['diagnosis'], analysis_verification_gate has diagnosis trigger
+    expect(result).toContain('## 行为约束（前置声明）');
+    expect(result).toContain('analysis_verification_gate');
+  });
+
+  it('returns constraints with injectPrompt for monitor role', () => {
+    const result = formatConstraintsForPrompt('monitor');
+    // monitor maps to ['monitoring', 'diagnosis']
+    expect(result).toContain('## 行为约束（前置声明）');
+    expect(result).toContain('analysis_verification_gate');
+  });
+
+  it('returns constraints with injectPrompt for triage role', () => {
+    const result = formatConstraintsForPrompt('triage');
+    // triage maps to ['triage', 'diagnosis'], analysis_verification_gate has diagnosis trigger
+    expect(result).toContain('## 行为约束（前置声明）');
+    expect(result).toContain('analysis_verification_gate');
+  });
+
+  it('returns formatted constraints for analyst role', () => {
+    const result = formatConstraintsForPrompt('analyst');
+    // analyst has triggers: design_request, api_change, code_implementation
+    expect(result).toContain('## 行为约束（前置声明）');
+    expect(result).toContain('铁律');
+    expect(result).toContain('指导原则');
+    expect(result).not.toContain('提示');
+  });
+
+  it('returns formatted constraints for executor role', () => {
+    const result = formatConstraintsForPrompt('executor');
+    // executor has the most triggers
+    expect(result).toContain('## 行为约束（前置声明）');
+    expect(result).toContain('铁律');
+    expect(result).toContain('指导原则');
+    expect(result).toContain('提示');
+  });
+
+  it('returns formatted constraints for reviewer role', () => {
+    const result = formatConstraintsForPrompt('reviewer');
+    // reviewer triggers: code_implementation
+    expect(result).toContain('## 行为约束（前置声明）');
+    expect(result).toContain('指导原则'); // has injectPrompt guidelines with code_implementation trigger
+  });
+
+  it('includes constraint IDs in the output', () => {
+    const result = formatConstraintsForPrompt('executor');
+    // Should contain some known constraint IDs
+    expect(result).toContain('**no_self_approval**');
+    expect(result).toContain('**incremental_progress**');
+  });
+
+  it('only includes constraints with promptInjection field', () => {
+    const result = formatConstraintsForPrompt('executor');
+    // docs_freshness has no promptInjection field so should not appear
+    expect(result).not.toContain('**docs_freshness**');
+  });
+
+  it('sorts constraints by level: iron_law, guideline, tip', () => {
+    const result = formatConstraintsForPrompt('executor');
+    const ironLawIdx = result.indexOf('### 铁律（绝对禁止，无例外）');
+    const guidelineIdx = result.indexOf('### 指导原则（优先建议）');
+    const tipIdx = result.indexOf('### 提示');
+
+    // Iron law section should appear before guideline section
+    expect(ironLawIdx).toBeLessThan(guidelineIdx);
+
+    // Tip section should appear last (if present)
+    // Note: tips with executor triggers may or may not exist
+    if (tipIdx >= 0) {
+      expect(guidelineIdx).toBeLessThan(tipIdx);
+    }
+  });
+
+  it('handles unknown role gracefully', () => {
+    const result = formatConstraintsForPrompt('unknown' as any);
+    expect(result).toBe('');
+  });
+});

package/src/core/constraints/check-cache.ts

@@ -0,0 +1,96 @@
+/**
+ * CheckCache — 约束检查缓存（S7）
+ *
+ * 缓存 git diff 和 src/ 递归扫描结果，减少重复 I/O。
+ * 同一请求内多次 checkConstraints 调用共享缓存。
+ *
+ * 用法：
+ * ```typescript
+ * const cache = new CheckCache({ ttlMs: 5000 });
+ * const diff = await cache.get('git_diff', projectPath, () => runCommand('git diff --cached', projectPath));
+ * ```
+ */
+
+interface CacheEntry {
+  value: unknown;
+  expiresAt: number;
+}
+
+export interface CheckCacheConfig {
+  /** 缓存 TTL（毫秒），默认 5000 */
+  ttlMs: number;
+}
+
+export class CheckCache {
+  private store = new Map<string, CacheEntry>();
+  private ttlMs: number;
+
+  constructor(config?: CheckCacheConfig) {
+    this.ttlMs = config?.ttlMs ?? 5000;
+  }
+
+  /**
+   * 获取缓存值（miss 时执行 fn 并缓存结果）
+   *
+   * @param namespace 命名空间（如 'git_diff', 'src_scan'）
+   * @param key 缓存键（如 projectPath）
+   * @param fn miss 时的计算函数
+   */
+  async get<T>(
+    namespace: string,
+    key: string,
+    fn: () => Promise<T>,
+  ): Promise<T> {
+    const cacheKey = `${namespace}:${key}`;
+    const entry = this.store.get(cacheKey);
+
+    if (entry && Date.now() < entry.expiresAt) {
+      return entry.value as T;
+    }
+
+    const value = await fn();
+    this.store.set(cacheKey, {
+      value,
+      expiresAt: Date.now() + this.ttlMs,
+    });
+    return value;
+  }
+
+  /**
+   * 同步版本（用于 readdirSync 等同步操作）
+   */
+  getSync<T>(
+    namespace: string,
+    key: string,
+    fn: () => T,
+  ): T {
+    const cacheKey = `${namespace}:${key}`;
+    const entry = this.store.get(cacheKey);
+
+    if (entry && Date.now() < entry.expiresAt) {
+      return entry.value as T;
+    }
+
+    const value = fn();
+    this.store.set(cacheKey, {
+      value,
+      expiresAt: Date.now() + this.ttlMs,
+    });
+    return value;
+  }
+
+  /**
+   * 使指定命名空间缓存失效
+   */
+  invalidate(namespace?: string): void {
+    if (namespace) {
+      for (const key of this.store.keys()) {
+        if (key.startsWith(`${namespace}:`)) {
+          this.store.delete(key);
+        }
+      }
+    } else {
+      this.store.clear();
+    }
+  }
+}