@winspan/claude-forge 8.53.2 → 8.54.3

package/tests/integration/web-trace.integration.test.ts

@@ -1,175 +0,0 @@
-/**
- * Integration safety-net for /api/trace/:commit.
- *
- * H2 Phase 1: lock the response shape + error branches before migrating
- * trace's inline SQL (event_breakdown / agent_calls / skills aggregation)
- * into EventOperations / SkillOperations.
- *
- * Approach: spin up a real tmp git repository, create a commit, optionally
- * attach a git note containing `forge-session: <id>`, then assert each
- * branch of the route handler.
- *
- * Coverage:
- *   - 400 when ?project query is missing / non-absolute / not a directory /
- *     not a git repo
- *   - 404 when commit ref cannot be resolved
- *   - 200 with empty sessions[] when HEAD has no git note
- *   - 200 with non-empty sessions[] (shape validated) when a note links to
- *     a session row in storage
- */
-
-import { describe, it, expect, beforeAll, afterAll, beforeEach, afterEach } from 'vitest';
-import express, { type Application } from 'express';
-import request from 'supertest';
-import { execFileSync } from 'node:child_process';
-import fs from 'node:fs';
-import os from 'node:os';
-import path from 'node:path';
-import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
-import { registerTraceRoutes } from '../../src/web/routes/trace.js';
-
-const SESSION = 'sess-trace-int-abcdef01';
-
-function git(args: string[], cwd: string): string {
-  return execFileSync('git', args, {
-    cwd, stdio: 'pipe', timeout: 10000,
-    env: {
-      ...process.env,
-      GIT_AUTHOR_NAME: 'forge-test',
-      GIT_AUTHOR_EMAIL: 'forge@test.local',
-      GIT_COMMITTER_NAME: 'forge-test',
-      GIT_COMMITTER_EMAIL: 'forge@test.local',
-    },
-  }).toString().trim();
-}
-
-describe('GET /api/trace/:commit (safety-net)', () => {
-  let app: Application;
-  let storage: SQLiteStorage;
-  let repoDir: string;
-  let nonGitDir: string;
-  let commitWithNote: string;
-  let commitWithoutNote: string;
-
-  beforeAll(() => {
-    // 1) tmp git repo with two commits
-    repoDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-trace-repo-'));
-    git(['init', '-q', '-b', 'main'], repoDir);
-    fs.writeFileSync(path.join(repoDir, 'a.txt'), 'one');
-    git(['add', '.'], repoDir);
-    git(['commit', '-q', '-m', 'first commit'], repoDir);
-    commitWithoutNote = git(['rev-parse', 'HEAD'], repoDir);
-
-    fs.writeFileSync(path.join(repoDir, 'b.txt'), 'two');
-    git(['add', '.'], repoDir);
-    git(['commit', '-q', '-m', 'second commit'], repoDir);
-    commitWithNote = git(['rev-parse', 'HEAD'], repoDir);
-
-    // Attach a git note to the second commit so the route can resolve a session
-    git(['notes', 'add', '-m', `forge-session: ${SESSION}`, commitWithNote], repoDir);
-
-    // 2) a sibling tmp directory that is *not* a git repo
-    nonGitDir = fs.mkdtempSync(path.join(os.tmpdir(), 'forge-trace-nogit-'));
-  });
-
-  afterAll(() => {
-    try { fs.rmSync(repoDir, { recursive: true, force: true }); } catch { /* ignore */ }
-    try { fs.rmSync(nonGitDir, { recursive: true, force: true }); } catch { /* ignore */ }
-  });
-
-  beforeEach(() => {
-    storage = new SQLiteStorage(':memory:');
-    app = express();
-    app.use(express.json());
-    registerTraceRoutes(app, { storage });
-  });
-
-  afterEach(() => {
-    storage.close();
-  });
-
-  it('returns 400 when ?project query parameter is missing', async () => {
-    const res = await request(app).get(`/api/trace/${commitWithNote}`);
-    expect(res.status).toBe(400);
-    expect(res.body.error).toMatch(/project/i);
-  });
-
-  it('returns 400 when project path is relative', async () => {
-    const res = await request(app)
-      .get(`/api/trace/${commitWithNote}`)
-      .query({ project: 'relative/path' });
-    expect(res.status).toBe(400);
-    expect(res.body.error).toMatch(/absolute/i);
-  });
-
-  it('returns 400 when project path is not a git repo', async () => {
-    const res = await request(app)
-      .get(`/api/trace/${commitWithNote}`)
-      .query({ project: nonGitDir });
-    expect(res.status).toBe(400);
-    expect(res.body.error).toMatch(/git repository/i);
-  });
-
-  it('returns 404 when commit cannot be resolved', async () => {
-    const res = await request(app)
-      .get('/api/trace/nonexistent-commit-ref-zzz')
-      .query({ project: repoDir });
-    expect(res.status).toBe(404);
-    expect(res.body.error).toMatch(/resolve commit/i);
-  });
-
-  it('returns 200 with empty sessions[] when HEAD has no git note', async () => {
-    const res = await request(app)
-      .get(`/api/trace/${commitWithoutNote}`)
-      .query({ project: repoDir });
-    expect(res.status).toBe(200);
-    expect(res.body.commit).toBe(commitWithoutNote);
-    expect(typeof res.body.message).toBe('string');
-    expect(Array.isArray(res.body.sessions)).toBe(true);
-    expect(res.body.sessions).toEqual([]);
-  });
-
-  it('returns 200 with sessions[] entries when commit has a forge-session note', async () => {
-    // Seed storage so the session resolves; route looks up by session_id /
-    // session_id startsWith
-    storage.writeEvent({
-      session_id: SESSION,
-      project_path: repoDir,
-      timestamp: new Date().toISOString(),
-      hook_type: 'UserPromptSubmit',
-      user_prompt: 'hello',
-    });
-    storage.writeEvent({
-      session_id: SESSION,
-      project_path: repoDir,
-      timestamp: new Date().toISOString(),
-      hook_type: 'PreToolUse',
-      tool_name: 'Bash',
-      tool_input: { command: 'ls' },
-    });
-
-    const res = await request(app)
-      .get(`/api/trace/${commitWithNote}`)
-      .query({ project: repoDir });
-
-    expect(res.status).toBe(200);
-    expect(res.body.commit).toBe(commitWithNote);
-    expect(Array.isArray(res.body.sessions)).toBe(true);
-    expect(res.body.sessions.length).toBe(1);
-
-    const session = res.body.sessions[0];
-    // Session should have been found and hydrated with detail fields
-    expect(session.session_id).toBe(SESSION);
-    expect(session.found).toBe(true);
-    expect(session).toHaveProperty('event_count');
-    expect(session).toHaveProperty('event_breakdown');
-    expect(session).toHaveProperty('agent_calls');
-    expect(session).toHaveProperty('skills');
-    expect(typeof session.event_breakdown).toBe('object');
-    expect(Array.isArray(session.agent_calls)).toBe(true);
-    expect(Array.isArray(session.skills)).toBe(true);
-    // We wrote one PreToolUse + one UserPromptSubmit
-    expect(session.event_breakdown.PreToolUse).toBe(1);
-    expect(session.event_breakdown.UserPromptSubmit).toBe(1);
-  });
-});

package/tests/performance/database.benchmark.ts

@@ -1,161 +0,0 @@
-/**
- * Database Query Performance Benchmark
- *
- * Measures:
- * - Query execution time
- * - Index effectiveness
- * - Memory usage
- */
-
-import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
-import path from 'path';
-import { homedir } from 'os';
-
-interface QueryBenchmark {
-  name: string;
-  duration: number;
-  iterations: number;
-  avgTime: number;
-  throughput: number;
-}
-
-class DatabaseBenchmark {
-  private storage: SQLiteStorage;
-
-  constructor() {
-    const dbPath = path.join(homedir(), '.claude-forge', 'data.db');
-    this.storage = new SQLiteStorage(dbPath);
-  }
-
-  /**
-   * Benchmark event queries
-   */
-  benchmarkEventQueries(): QueryBenchmark {
-    const iterations = 100;
-    const startTime = performance.now();
-
-    for (let i = 0; i < iterations; i++) {
-      this.storage.queryEvents({ limit: 50 });
-    }
-
-    const endTime = performance.now();
-    const duration = endTime - startTime;
-
-    return {
-      name: 'Event Queries (limit 50)',
-      duration,
-      iterations,
-      avgTime: duration / iterations,
-      throughput: (iterations / duration) * 1000,
-    };
-  }
-
-  /**
-   * Benchmark session queries
-   */
-  benchmarkSessionQueries(): QueryBenchmark {
-    const iterations = 100;
-    const startTime = performance.now();
-
-    for (let i = 0; i < iterations; i++) {
-      this.storage.querySessions({ limit: 10 });
-    }
-
-    const endTime = performance.now();
-    const duration = endTime - startTime;
-
-    return {
-      name: 'Session Queries (limit 10)',
-      duration,
-      iterations,
-      avgTime: duration / iterations,
-      throughput: (iterations / duration) * 1000,
-    };
-  }
-
-  /**
-   * Benchmark decision queries
-   */
-  benchmarkDecisionQueries(): QueryBenchmark {
-    const iterations = 100;
-    const startTime = performance.now();
-
-    for (let i = 0; i < iterations; i++) {
-      this.storage.queryDecisions({ limit: 50 });
-    }
-
-    const endTime = performance.now();
-    const duration = endTime - startTime;
-
-    return {
-      name: 'Decision Queries (limit 50)',
-      duration,
-      iterations,
-      avgTime: duration / iterations,
-      throughput: (iterations / duration) * 1000,
-    };
-  }
-
-  /**
-   * Benchmark event count
-   */
-  benchmarkEventCount(): QueryBenchmark {
-    const iterations = 1000;
-    const startTime = performance.now();
-
-    for (let i = 0; i < iterations; i++) {
-      this.storage.countEvents({});
-    }
-
-    const endTime = performance.now();
-    const duration = endTime - startTime;
-
-    return {
-      name: 'Event Count',
-      duration,
-      iterations,
-      avgTime: duration / iterations,
-      throughput: (iterations / duration) * 1000,
-    };
-  }
-
-  /**
-   * Print benchmark results
-   */
-  printResults(result: QueryBenchmark): void {
-    console.log(`\n📊 ${result.name}`);
-    console.log(`  Duration: ${result.duration.toFixed(2)}ms`);
-    console.log(`  Iterations: ${result.iterations}`);
-    console.log(`  Avg Time: ${result.avgTime.toFixed(4)}ms`);
-    console.log(`  Throughput: ${result.throughput.toFixed(0)} queries/sec`);
-  }
-
-  /**
-   * Run all benchmarks
-   */
-  runAll(): void {
-    console.log('=== Database Query Performance Benchmark ===');
-
-    const eventResult = this.benchmarkEventQueries();
-    this.printResults(eventResult);
-
-    const sessionResult = this.benchmarkSessionQueries();
-    this.printResults(sessionResult);
-
-    const decisionResult = this.benchmarkDecisionQueries();
-    this.printResults(decisionResult);
-
-    const countResult = this.benchmarkEventCount();
-    this.printResults(countResult);
-
-    console.log('\n=== Summary ===');
-    console.log(`Event Queries: ${eventResult.avgTime.toFixed(2)}ms avg`);
-    console.log(`Session Queries: ${sessionResult.avgTime.toFixed(2)}ms avg`);
-    console.log(`Decision Queries: ${decisionResult.avgTime.toFixed(2)}ms avg`);
-    console.log(`Event Count: ${countResult.avgTime.toFixed(4)}ms avg`);
-  }
-}
-
-// Run benchmark
-const benchmark = new DatabaseBenchmark();
-benchmark.runAll();

package/tests/semantic-matcher.test.ts

@@ -1,99 +0,0 @@
-/**
- * Test semantic skill matcher with real API
- */
-
-import { SemanticSkillMatcher } from '../src/skills/semantic-matcher.js';
-import { OFFICIAL_SKILLS } from '../src/skills/official-skills.js';
-
-const testCases = [
-  {
-    prompt: '帮我写一个测试驱动开发的例子',
-    expectedSkill: 'official-tdd',
-  },
-  {
-    prompt: 'I need to debug this authentication bug',
-    expectedSkill: 'official-debug',
-  },
-  {
-    prompt: '这段遗留代码需要重构，但没有测试覆盖',
-    expectedSkill: 'official-harness-engineering',
-  },
-  {
-    prompt: 'Help me design a RESTful API for user management',
-    expectedSkill: 'official-api-design',
-  },
-  {
-    prompt: 'Install the latest version of Node.js',
-    expectedSkill: null,
-  },
-];
-
-async function runTests() {
-  console.log('=== Semantic Skill Matcher Test ===\n');
-
-  const apiKey = process.env.ANTHROPIC_API_KEY;
-  if (!apiKey) {
-    console.error('ERROR: ANTHROPIC_API_KEY not set');
-    process.exit(1);
-  }
-
-  const matcher = new SemanticSkillMatcher(apiKey);
-  const skills = OFFICIAL_SKILLS.map(s => ({
-    id: s.name,
-    name: s.name,
-    keywords: s.keywords,
-    content: s.content,
-    path: '<built-in>',
-    isOfficial: true,
-  }));
-
-  let passed = 0;
-  let failed = 0;
-
-  for (const testCase of testCases) {
-    console.log(`Prompt: "${testCase.prompt}"`);
-    console.log(`Expected: ${testCase.expectedSkill || 'null'}`);
-
-    try {
-      const result = await matcher.match(skills, {
-        prompt: testCase.prompt,
-      });
-
-      const matchedId = result?.skill.id || null;
-      const success = matchedId === testCase.expectedSkill;
-
-      if (success) {
-        passed++;
-        console.log(`✓ Got: ${matchedId || 'null'}`);
-        if (result) {
-          console.log(`  Confidence: ${result.confidence}%`);
-          console.log(`  Reasoning: ${result.reasoning}`);
-        }
-      } else {
-        failed++;
-        console.log(`✗ Got: ${matchedId || 'null'}`);
-        if (result) {
-          console.log(`  Confidence: ${result.confidence}%`);
-          console.log(`  Reasoning: ${result.reasoning}`);
-        }
-      }
-    } catch (err) {
-      failed++;
-      console.log(`✗ Error: ${err}`);
-    }
-
-    console.log();
-  }
-
-  console.log(`\n=== Results ===`);
-  console.log(`Passed: ${passed}/${testCases.length}`);
-  console.log(`Failed: ${failed}/${testCases.length}`);
-  console.log(`Success Rate: ${((passed / testCases.length) * 100).toFixed(1)}%`);
-
-  process.exit(failed > 0 ? 1 : 0);
-}
-
-runTests().catch(err => {
-  console.error('Test failed:', err);
-  process.exit(1);
-});

package/tests/skill-matcher.test.ts

@@ -1,110 +0,0 @@
-/**
- * Test script for enhanced skill matcher
- * Validates that the new algorithm reduces false positives
- */
-
-import { SkillRegistry } from '../src/skills/registry.js';
-
-interface TestCase {
-  prompt: string;
-  expectedSkill: string | null;
-  description: string;
-}
-
-const testCases: TestCase[] = [
-  // Positive cases (should match)
-  {
-    prompt: '帮我写一个测试驱动开发的例子',
-    expectedSkill: 'official-tdd',
-    description: 'TDD 明确意图',
-  },
-  {
-    prompt: 'I need to debug this authentication bug',
-    expectedSkill: 'official-debug',
-    description: 'Debug 明确意图',
-  },
-  {
-    prompt: '这段遗留代码需要重构，但没有测试覆盖',
-    expectedSkill: 'official-harness-engineering',
-    description: 'Harness Engineering 场景',
-  },
-  {
-    prompt: 'Help me design a RESTful API for user management',
-    expectedSkill: 'official-api-design',
-    description: 'API 设计明确意图',
-  },
-
-  // Negative cases (should NOT match - old algorithm would match)
-  {
-    prompt: 'Install the latest version of Node.js',
-    expectedSkill: null,
-    description: '包含 "test" 但不是测试场景',
-  },
-  {
-    prompt: 'The application is working fine, no bugs',
-    expectedSkill: null,
-    description: '包含 "bug" 但不是调试场景',
-  },
-  {
-    prompt: 'Create a new React component from scratch',
-    expectedSkill: null,
-    description: '新功能开发，不应匹配 harness',
-  },
-  {
-    prompt: 'Update the README documentation',
-    expectedSkill: null,
-    description: '简单文档更新，不应匹配复杂技能',
-  },
-];
-
-async function runTests() {
-  console.log('=== Enhanced Skill Matcher Test ===\n');
-
-  const registry = new SkillRegistry();
-  let passed = 0;
-  let failed = 0;
-
-  for (const testCase of testCases) {
-    const matched = await registry.match(testCase.prompt);
-    const matchedId = matched?.id || null;
-    const success = matchedId === testCase.expectedSkill;
-
-    if (success) {
-      passed++;
-      console.log(`✓ ${testCase.description}`);
-      console.log(`  Prompt: "${testCase.prompt}"`);
-      console.log(`  Expected: ${testCase.expectedSkill || 'null'}, Got: ${matchedId || 'null'}\n`);
-    } else {
-      failed++;
-      console.log(`✗ ${testCase.description}`);
-      console.log(`  Prompt: "${testCase.prompt}"`);
-      console.log(`  Expected: ${testCase.expectedSkill || 'null'}, Got: ${matchedId || 'null'}`);
-
-      // Show detailed match results for debugging
-      if (registry.matchWithDetails) {
-        const details = await registry.matchWithDetails(testCase.prompt);
-        if (details.length > 0) {
-          console.log(`  Top matches:`);
-          details.slice(0, 3).forEach(d => {
-            console.log(`    - ${d.skill.id}: ${d.confidence}% (${d.matchedKeywords.join(', ')})`);
-          });
-        } else {
-          console.log(`  No matches found (all below threshold)`);
-        }
-      }
-      console.log();
-    }
-  }
-
-  console.log(`\n=== Results ===`);
-  console.log(`Passed: ${passed}/${testCases.length}`);
-  console.log(`Failed: ${failed}/${testCases.length}`);
-  console.log(`Success Rate: ${((passed / testCases.length) * 100).toFixed(1)}%`);
-
-  process.exit(failed > 0 ? 1 : 0);
-}
-
-runTests().catch(err => {
-  console.error('Test failed:', err);
-  process.exit(1);
-});