@dommaker/harness 1.4.0 → 1.6.0

package/src/core/session/startup.ts

@@ -1,253 +0,0 @@
-/**
- * SessionStartup - Session 启动检查点验证
- * 
- * 确保 Agent 启动时必须先读上下文，防止"失忆"乱搞。
- */
-
-import { execAsync } from '../../utils/exec';
-import * as fs from 'fs/promises';
-import * as path from 'path';
-import * as yaml from 'js-yaml';
-import type {
-  StartupCheckpoints,
-  StartupCheckpointResult,
-  StartupCheckpointType,
-  TaskListJson,
-} from '../../types/session';
-
-
-const DEFAULT_TIMEOUT = 30000; // 30 seconds
-
-export class SessionStartup {
-  private checkpoints: StartupCheckpoints;
-  private workDir: string;
-
-  constructor(workDir: string, checkpoints: StartupCheckpoints) {
-    this.workDir = workDir;
-    this.checkpoints = checkpoints;
-  }
-
-  async run(): Promise<{ success: boolean; results: StartupCheckpointResult[]; errors: string[] }> {
-    const results: StartupCheckpointResult[] = [];
-    const errors: string[] = [];
-
-    // 1. Run required checkpoints
-    for (const type of this.checkpoints.required) {
-      const result = await this.runCheckpoint(type);
-      results.push(result);
-      if (!result.success) {
-        errors.push(`Required checkpoint failed: ${type} - ${result.error}`);
-      }
-    }
-
-    // 2. Run optional checkpoints (don't fail on error)
-    for (const type of this.checkpoints.optional || []) {
-      const result = await this.runCheckpoint(type);
-      results.push(result);
-    }
-
-    return {
-      success: errors.length === 0,
-      results,
-      errors,
-    };
-  }
-
-  private async runCheckpoint(type: StartupCheckpointType): Promise<StartupCheckpointResult> {
-    const start = Date.now();
-
-    try {
-      let data: any;
-
-      switch (type) {
-        case 'pwd':
-          data = await this.checkPwd();
-          break;
-        case 'git_log':
-          data = await this.checkGitLog();
-          break;
-        case 'git_status':
-          data = await this.checkGitStatus();
-          break;
-        case 'read_progress':
-          data = await this.checkProgress();
-          break;
-        case 'read_task_list':
-          data = await this.checkTaskList();
-          break;
-        case 'init_sh':
-          data = await this.checkInitSh();
-          break;
-        case 'basic_verification':
-          data = await this.checkBasicVerification();
-          break;
-        case 'load_context':
-          data = await this.checkLoadContext();
-          break;
-        default:
-          throw new Error(`Unknown checkpoint type: ${type}`);
-      }
-
-      return { type, success: true, data, duration: Date.now() - start };
-    } catch (error: any) {
-      return { type, success: false, error: error.message, duration: Date.now() - start };
-    }
-  }
-
-  private async checkPwd(): Promise<string> {
-    return this.workDir;
-  }
-
-  private async checkGitLog(): Promise<string[]> {
-    try {
-      const { stdout } = await execAsync('git log --oneline -10', { cwd: this.workDir });
-      return stdout.split('\n').filter(Boolean);
-    } catch {
-      return [];
-    }
-  }
-
-  private async checkGitStatus(): Promise<{ staged: string[]; unstaged: string[]; untracked: string[] }> {
-    try {
-      const { stdout } = await execAsync('git status --porcelain', { cwd: this.workDir });
-      const staged: string[] = [], unstaged: string[] = [], untracked: string[] = [];
-      
-      for (const line of stdout.split('\n').filter(Boolean)) {
-        const status = line.substring(0, 2);
-        const file = line.substring(3);
-        if (status.includes('??')) untracked.push(file);
-        else if (status.match(/[MADRC]/)) staged.push(file);
-        else unstaged.push(file);
-      }
-      
-      return { staged, unstaged, untracked };
-    } catch {
-      return { staged: [], unstaged: [], untracked: [] };
-    }
-  }
-
-  private async checkProgress(): Promise<any> {
-    const progressPath = path.join(this.workDir, '.harness', 'progress.yml');
-    try {
-      const content = await fs.readFile(progressPath, 'utf-8');
-      return yaml.load(content) as any;
-    } catch {
-      return null;
-    }
-  }
-
-  private async checkTaskList(): Promise<TaskListJson | null> {
-    // Try tasks.yml first (existing format)
-    const tasksPath = path.join(this.workDir, 'tasks.yml');
-    try {
-      const content = await fs.readFile(tasksPath, 'utf-8');
-      return yaml.load(content) as TaskListJson;
-    } catch {
-      // Try tasks.json
-      const jsonPath = path.join(this.workDir, 'tasks.json');
-      try {
-        const content = await fs.readFile(jsonPath, 'utf-8');
-        return JSON.parse(content);
-      } catch {
-        return null;
-      }
-    }
-  }
-
-  private async checkInitSh(): Promise<boolean> {
-    const initPath = path.join(this.workDir, 'init.sh');
-    try {
-      await fs.access(initPath);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  private async checkBasicVerification(): Promise<{ hasPackageJson: boolean; hasTests: boolean; hasReadme: boolean }> {
-    const [hasPackageJson, hasTests, hasReadme] = await Promise.all([
-      fs.access(path.join(this.workDir, 'package.json')).then(() => true).catch(() => false),
-      this.hasTestFiles(),
-      fs.access(path.join(this.workDir, 'README.md')).then(() => true).catch(() => false),
-    ]);
-    return { hasPackageJson, hasTests, hasReadme };
-  }
-
-  private async hasTestFiles(): Promise<boolean> {
-    const testPatterns = ['test', 'spec', '__tests__'];
-    try {
-      const files = await fs.readdir(this.workDir);
-      return files.some(f => testPatterns.some(p => f.toLowerCase().includes(p)));
-    } catch {
-      return false;
-    }
-  }
-
-  private async checkLoadContext(): Promise<any> {
-    const context: Record<string, string> = {};
-    const files = this.checkpoints.contextFiles || [];
-
-    for (const file of files) {
-      try {
-        context[file] = await fs.readFile(path.join(this.workDir, file), 'utf-8');
-      } catch {}
-    }
-
-    return context;
-  }
-
-  /**
-   * Get current task from task list
-   */
-  async getCurrentTask(): Promise<{ task: any; index: number } | null> {
-    const taskList = await this.checkTaskList();
-    if (!taskList?.tasks) return null;
-
-    for (let i = 0; i < taskList.tasks.length; i++) {
-      const task = taskList.tasks[i];
-      if (task && !task.passes) {
-        return { task, index: i };
-      }
-    }
-    
-    return null;
-  }
-
-  /**
-   * Generate startup report
-   */
-  generateReport(results: StartupCheckpointResult[]): string {
-    const lines: string[] = ['## Session Startup Report\n'];
-    
-    for (const result of results) {
-      const icon = result.success ? '✅' : '❌';
-      lines.push(`${icon} ${result.type} (${result.duration}ms)`);
-      if (result.error) {
-        lines.push(`   Error: ${result.error}`);
-      }
-    }
-    
-    return lines.join('\n');
-  }
-}
-
-export const createSessionStartup = (workDir: string, checkpoints: StartupCheckpoints) => 
-  new SessionStartup(workDir, checkpoints);
-
-/**
- * Default startup checkpoints for code workflows
- */
-export const DEFAULT_CODE_CHECKPOINTS: StartupCheckpoints = {
-  required: ['pwd', 'git_log', 'read_task_list'],
-  optional: ['read_progress', 'init_sh', 'basic_verification'],
-  timeout: DEFAULT_TIMEOUT,
-};
-
-/**
- * Minimal startup checkpoints
- */
-export const MINIMAL_CHECKPOINTS: StartupCheckpoints = {
-  required: ['pwd', 'read_task_list'],
-  optional: [],
-  timeout: DEFAULT_TIMEOUT,
-};

package/src/failure/constraint-handler.ts

@@ -1,171 +0,0 @@
-/**
- * ConstraintViolationHandler — 约束违规统一处理（S4）
- *
- * 问题：ConstraintViolationError 在 4 个调用点有 4 种行为：
- *   1. 抛异常阻断（checker.ts）
- *   2. 返回 null（report.ts catch 后返回空数据）
- *   3. 返回 403 HTTP 状态
- *   4. console.warn 静默吞掉
- *
- * 解决：提供 3 种标准化处理策略，消除 ad-hoc catch 行为。
- */
-
-import type { ConstraintCheckResult } from '../types/constraint';
-
-/**
- * 违规处理策略
- */
-export type ViolationStrategy = 'BLOCK' | 'COLLECT' | 'SAFE_BOOLEAN';
-
-/**
- * 违规处理结果
- */
-export interface ViolationHandlingResult {
-  /** 策略 */
-  strategy: ViolationStrategy;
-  /** 检查结果（COLLECT 策略时总是有值） */
-  checkResult?: ConstraintCheckResult;
-  /** 是否有违规（SAFE_BOOLEAN 策略时为 false） */
-  hasViolation: boolean;
-  /** 违规数量 */
-  violationCount: number;
-}
-
-/**
- * 约束违规处理器
- *
- * 用法：
- * ```typescript
- * const handler = new ConstraintViolationHandler();
- *
- * // 策略 1: BLOCK — 抛异常阻断（Iron Laws 默认）
- * await handler.execute(checkFn, 'BLOCK');
- *
- * // 策略 2: COLLECT — 收集违规不抛异常（用于报告生成）
- * const result = await handler.execute(checkFn, 'COLLECT');
- * // result.checkResult 总是有值
- *
- * // 策略 3: SAFE_BOOLEAN — 返回真/假（用于 canProceed 类方法）
- * const ok = await handler.execute(checkFn, 'SAFE_BOOLEAN');
- * // ok.hasViolation 为 true/false
- * ```
- */
-export class ConstraintViolationHandler {
-  /**
-   * 执行约束检查并统一处理结果
-   *
-   * @param checkFn 约束检查函数（可能抛出 ConstraintViolationError）
-   * @param strategy 处理策略
-   * @returns 标准化结果
-   */
-  async execute(
-    checkFn: () => Promise<ConstraintCheckResult>,
-    strategy: ViolationStrategy
-  ): Promise<ViolationHandlingResult> {
-    switch (strategy) {
-      case 'BLOCK':
-        return this.handleBlock(checkFn);
-      case 'COLLECT':
-        return this.handleCollect(checkFn);
-      case 'SAFE_BOOLEAN':
-        return this.handleSafeBoolean(checkFn);
-    }
-  }
-
-  /**
-   * BLOCK 策略：违规即抛出，无违规返回结果
-   */
-  private async handleBlock(
-    checkFn: () => Promise<ConstraintCheckResult>
-  ): Promise<ViolationHandlingResult> {
-    const result = await checkFn();
-    return {
-      strategy: 'BLOCK',
-      checkResult: result,
-      hasViolation: !result.passed,
-      violationCount: result.ironLaws.filter(r => !r.satisfied).length,
-    };
-  }
-
-  /**
-   * COLLECT 策略：捕获异常，收集所有违规，不抛出
-   */
-  private async handleCollect(
-    checkFn: () => Promise<ConstraintCheckResult>
-  ): Promise<ViolationHandlingResult> {
-    try {
-      const result = await checkFn();
-      const ironViolations = result.ironLaws.filter(r => !r.satisfied).length;
-      const guideViolations = result.warningCount;
-      return {
-        strategy: 'COLLECT',
-        checkResult: result,
-        hasViolation: !result.passed || guideViolations > 0,
-        violationCount: ironViolations + guideViolations,
-      };
-    } catch {
-      // 捕获 ConstraintViolationError，返回失败结果
-      const empty: ConstraintCheckResult = {
-        ironLaws: [],
-        guidelines: [],
-        passed: false,
-        warningCount: 0,
-      };
-      return {
-        strategy: 'COLLECT',
-        checkResult: empty,
-        hasViolation: true,
-        violationCount: 1,
-      };
-    }
-  }
-
-  /**
-   * SAFE_BOOLEAN 策略：不抛异常，只返回 boolean
-   */
-  private async handleSafeBoolean(
-    checkFn: () => Promise<ConstraintCheckResult>
-  ): Promise<ViolationHandlingResult> {
-    try {
-      const result = await checkFn();
-      return {
-        strategy: 'SAFE_BOOLEAN',
-        hasViolation: !result.passed,
-        violationCount: result.ironLaws.filter(r => !r.satisfied).length,
-      };
-    } catch {
-      return {
-        strategy: 'SAFE_BOOLEAN',
-        hasViolation: true,
-        violationCount: 1,
-      };
-    }
-  }
-}
-
-/**
- * 快捷：BLOCK 策略执行检查
- */
-export async function executeWithBlock(
-  checkFn: () => Promise<ConstraintCheckResult>
-): Promise<ViolationHandlingResult> {
-  return new ConstraintViolationHandler().execute(checkFn, 'BLOCK');
-}
-
-/**
- * 快捷：COLLECT 策略执行检查
- */
-export async function executeWithCollect(
-  checkFn: () => Promise<ConstraintCheckResult>
-): Promise<ViolationHandlingResult> {
-  return new ConstraintViolationHandler().execute(checkFn, 'COLLECT');
-}
-
-/**
- * 快捷：SAFE_BOOLEAN 策略执行检查
- */
-export async function executeWithSafeBoolean(
-  checkFn: () => Promise<ConstraintCheckResult>
-): Promise<ViolationHandlingResult> {
-  return new ConstraintViolationHandler().execute(checkFn, 'SAFE_BOOLEAN');
-}

package/src/knowledge/__tests__/lifecycle-hooks.test.ts

@@ -1,140 +0,0 @@
-/**
- * KnowledgeLifecycleHooks 测试
- */
-
-import { KnowledgeLifecycleHooks } from '../lifecycle-hooks';
-import { FileKnowledgeStore as KnowledgeStore } from '../store';
-import { KnowledgeQuery } from '../query';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-
-describe('KnowledgeLifecycleHooks', () => {
-  let store: KnowledgeStore;
-  let query: KnowledgeQuery;
-  let hooks: KnowledgeLifecycleHooks;
-  let tmpDir: string;
-
-  beforeEach(() => {
-    tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'hooks-test-'));
-    store = new KnowledgeStore({ baseDir: path.join(tmpDir, 'knowledge') });
-    query = new KnowledgeQuery(store);
-    hooks = new KnowledgeLifecycleHooks({ store, query });
-  });
-
-  afterEach(() => {
-    fs.rmSync(tmpDir, { recursive: true, force: true });
-  });
-
-  function saveEntry(overrides: any = {}) {
-    store.save({
-      id: overrides.id || `test-${Math.random().toString(36).slice(2, 6)}`,
-      type: 'decision',
-      title: 'Test Decision',
-      content: 'Some content',
-      maturity: 'verified',
-      layer: 'project',
-      created: new Date().toISOString(),
-      lastReferenced: new Date().toISOString(),
-      contributors: [],
-      projects: [],
-      tags: [],
-      applicablePhases: [],
-      sourceReferences: [],
-      referencedBy: [],
-      executionResults: [],
-      consumptionMode: 'reference',
-      origin: 'agent',
-      ...overrides,
-    });
-  }
-
-  describe('onSessionStart', () => {
-    it('应该返回空数组当无知识条目', () => {
-      const sources = hooks.onSessionStart();
-      expect(sources.length).toBe(0);
-    });
-
-    it('应该注入知识条目为 ContextSource', () => {
-      saveEntry({ id: 'dec-001', title: 'Use TypeScript', content: 'Always use TS', tags: ['typescript', 'best-practice'] });
-      const sources = hooks.onSessionStart({ budget: 8000 });
-      expect(sources.length).toBe(1);
-      expect(sources[0].type).toBe('knowledge');
-      expect(sources[0].priority).toBe(3);
-      expect(sources[0].content).toContain('Use TypeScript');
-      expect(sources[0].content).toContain('typescript');
-    });
-
-    it('应该排除指定条目', () => {
-      saveEntry({ id: 'ex-1', title: 'Excluded' });
-      const sources = hooks.onSessionStart({ budget: 8000, exclude: ['ex-1'] });
-      expect(sources.length).toBe(0);
-    });
-  });
-
-  describe('onTaskComplete', () => {
-    it('应该从错误中提取 pitfall', () => {
-      const result = hooks.onTaskComplete({
-        taskDescription: 'Fix login bug',
-        errors: ['TypeError: Cannot read property of undefined'],
-      });
-
-      expect(result.entries.length).toBe(1);
-      expect(result.entries[0].type).toBe('pitfall');
-      expect(result.entries[0].tags).toContain('auto-extract');
-      expect(result.source).toBe('archive');
-    });
-
-    it('应该从决策中提取 decision', () => {
-      const result = hooks.onTaskComplete({
-        taskDescription: 'Choose architecture',
-        decisions: ['使用微服务架构因为需要独立部署'],
-      });
-
-      expect(result.entries.length).toBe(1);
-      expect(result.entries[0].type).toBe('decision');
-    });
-
-    it('应该限制提取数量', () => {
-      const errors = Array.from({ length: 10 }, (_, i) => `Error ${i}`);
-      const result = hooks.onTaskComplete({
-        taskDescription: 'Test',
-        errors,
-      });
-
-      expect(result.entries.length).toBeLessThanOrEqual(3);
-    });
-
-    it('应该处理空上下文', () => {
-      const result = hooks.onTaskComplete({ taskDescription: 'Empty' });
-      expect(result.entries.length).toBe(0);
-    });
-  });
-
-  describe('onError', () => {
-    it('应该从错误中提取知识', () => {
-      const result = hooks.onError(new Error('Connection timeout'), {
-        taskDescription: 'API call',
-        stackTrace: 'at line 42',
-      });
-
-      expect(result.entries.length).toBe(1);
-      expect(result.entries[0].type).toBe('pitfall');
-      expect(result.entries[0].content).toContain('Connection timeout');
-      expect(result.entries[0].content).toContain('API call');
-      expect(result.source).toBe('error');
-    });
-
-    it('应该保存到知识库', () => {
-      hooks.onError(new Error('Test error'));
-      const entries = store.list({ excludeArchived: false });
-      expect(entries.length).toBe(1);
-      expect(entries[0].title).toContain('Test error');
-    });
-
-    it('应该处理无上下文的错误', () => {
-      const result = hooks.onError(new Error('Simple error'));
-      expect(result.entries.length).toBe(1);
-    });
-  });
-});