@winspan/claude-forge 8.41.0 → 8.51.0

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

@@ -0,0 +1,175 @@
+/**
+ * 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

@@ -0,0 +1,161 @@
+/**
+ * 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

@@ -0,0 +1,99 @@
+/**
+ * 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

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