@winspan/claude-forge 8.41.0 → 8.50.6

package/tests/integration/tasks-filter.integration.test.ts

@@ -0,0 +1,154 @@
+/**
+ * Integration tests for Tasks filter + pagination.
+ * Uses a real in-memory SQLite database to verify JOIN accuracy and COUNT correctness.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+
+function ts(offsetMs = 0): string {
+  return new Date(Date.UTC(2026, 0, 1) + offsetMs).toISOString();
+}
+
+const PROJECT_A = '/workspace/project-alpha';
+const PROJECT_B = '/workspace/project-beta';
+const PROJECT_C = '/workspace/project-gamma';
+
+describe('Tasks filter + pagination integration', () => {
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    // Seed sessions
+    const db = storage.getDatabase();
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-a', PROJECT_A, ts());
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-b', PROJECT_B, ts());
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-c', PROJECT_C, ts());
+    db.prepare(`INSERT INTO sessions (session_id, project_path, start_time) VALUES (?, ?, ?)`).run('sess-a2', PROJECT_A, ts());
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('JOIN preserves project_path from sessions', () => {
+    storage.writeTask({ id: 't1', session_id: 'sess-a', title: 'alpha task', start_time: ts() });
+    const result = storage.queryTasksFiltered({ limit: 10, offset: 0 });
+    expect(result.items).toHaveLength(1);
+    expect(result.items[0].project_path).toBe(PROJECT_A);
+    expect(result.total).toBe(1);
+    expect(result.has_more).toBe(false);
+  });
+
+  it('COUNT(*) matches items length when no pagination', () => {
+    storage.writeTask({ id: 't1', session_id: 'sess-a', title: 'task1', start_time: ts() });
+    storage.writeTask({ id: 't2', session_id: 'sess-b', title: 'task2', start_time: ts(1000) });
+    storage.writeTask({ id: 't3', session_id: 'sess-c', title: 'task3', start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ limit: 100 });
+    expect(result.total).toBe(3);
+    expect(result.items).toHaveLength(3);
+    expect(result.has_more).toBe(false);
+  });
+
+  it('COUNT remains constant across pages (A8)', () => {
+    for (let i = 0; i < 7; i++) {
+      storage.writeTask({ id: `pg${i}`, session_id: 'sess-a', title: `task ${i}`, start_time: ts(i * 1000) });
+    }
+    const page1 = storage.queryTasksFiltered({ limit: 4, offset: 0 });
+    const page2 = storage.queryTasksFiltered({ limit: 4, offset: 4 });
+
+    expect(page1.total).toBe(7);
+    expect(page2.total).toBe(7); // total is consistent
+    expect(page1.items).toHaveLength(4);
+    expect(page2.items).toHaveLength(3);
+    expect(page1.has_more).toBe(true);
+    expect(page2.has_more).toBe(false);
+
+    // No overlap between pages
+    const p1ids = page1.items.map(t => t.id);
+    const p2ids = page2.items.map(t => t.id);
+    expect(p1ids.some(id => p2ids.includes(id))).toBe(false);
+  });
+
+  it('project filter via JOIN correctly isolates tasks (A2)', () => {
+    storage.writeTask({ id: 'ta', session_id: 'sess-a', title: 'alpha', start_time: ts() });
+    storage.writeTask({ id: 'tb', session_id: 'sess-b', title: 'beta',  start_time: ts(1000) });
+    storage.writeTask({ id: 'tc', session_id: 'sess-c', title: 'gamma', start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ project: PROJECT_A });
+    expect(result.total).toBe(1);
+    expect(result.items[0].id).toBe('ta');
+    expect(result.items[0].project_path).toBe(PROJECT_A);
+  });
+
+  it('multi-project OR filter returns union correctly (A3)', () => {
+    storage.writeTask({ id: 'ta', session_id: 'sess-a', title: 'alpha', start_time: ts() });
+    storage.writeTask({ id: 'tb', session_id: 'sess-b', title: 'beta',  start_time: ts(1000) });
+    storage.writeTask({ id: 'tc', session_id: 'sess-c', title: 'gamma', start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ project: [PROJECT_A, PROJECT_B] });
+    expect(result.total).toBe(2);
+    const ids = result.items.map(t => t.id).sort();
+    expect(ids).toEqual(['ta', 'tb']);
+  });
+
+  it('search filter uses LIKE on title (A5)', () => {
+    storage.writeTask({ id: 't1', session_id: 'sess-a', title: '重构数据库连接池', start_time: ts() });
+    storage.writeTask({ id: 't2', session_id: 'sess-a', title: 'fix build CI',    start_time: ts(1000) });
+    storage.writeTask({ id: 't3', session_id: 'sess-b', title: '重构 API 层',      start_time: ts(2000) });
+
+    const result = storage.queryTasksFiltered({ search: '重构' });
+    expect(result.total).toBe(2);
+    const ids = result.items.map(t => t.id).sort();
+    expect(ids).toEqual(['t1', 't3']);
+  });
+
+  it('from/to date range filter uses string comparison on start_time (A4)', () => {
+    storage.writeTask({ id: 'early', session_id: 'sess-a', title: 'early', start_time: '2026-01-01T00:00:00.000Z' });
+    storage.writeTask({ id: 'mid',   session_id: 'sess-a', title: 'mid',   start_time: '2026-01-15T12:00:00.000Z' });
+    storage.writeTask({ id: 'late',  session_id: 'sess-a', title: 'late',  start_time: '2026-02-01T00:00:00.000Z' });
+
+    const result = storage.queryTasksFiltered({
+      from: '2026-01-01T00:00:00.000Z',
+      to:   '2026-01-31T23:59:59.000Z',
+    });
+    expect(result.total).toBe(2);
+    const ids = result.items.map(t => t.id).sort();
+    expect(ids).toEqual(['early', 'mid']);
+  });
+
+  it('queryTaskProjects returns distinct paths with tasks only', () => {
+    // sess-a and sess-a2 both point to PROJECT_A
+    storage.writeTask({ id: 't1', session_id: 'sess-a',  title: 'a', start_time: ts() });
+    storage.writeTask({ id: 't2', session_id: 'sess-a2', title: 'b', start_time: ts(1000) });
+    storage.writeTask({ id: 't3', session_id: 'sess-b',  title: 'c', start_time: ts(2000) });
+    // sess-c has no tasks — should not appear
+
+    const projects = storage.queryTaskProjects();
+    expect(projects).toHaveLength(2);
+    expect(projects).toContain(PROJECT_A);
+    expect(projects).toContain(PROJECT_B);
+    expect(projects).not.toContain(PROJECT_C);
+  });
+
+  it('limit clamp: storage-level enforces max 200', () => {
+    for (let i = 0; i < 5; i++) {
+      storage.writeTask({ id: `lc${i}`, session_id: 'sess-a', title: `t${i}`, start_time: ts(i * 1000) });
+    }
+    const result = storage.queryTasksFiltered({ limit: 999 });
+    // Storage clamps to 200 internally
+    expect(result.items.length).toBeLessThanOrEqual(200);
+    expect(result.total).toBe(5);
+  });
+
+  it('has_more is accurate at boundary (exactly limit items)', () => {
+    for (let i = 0; i < 4; i++) {
+      storage.writeTask({ id: `bnd${i}`, session_id: 'sess-a', title: `t${i}`, start_time: ts(i * 1000) });
+    }
+    const result = storage.queryTasksFiltered({ limit: 4, offset: 0 });
+    expect(result.total).toBe(4);
+    expect(result.items).toHaveLength(4);
+    expect(result.has_more).toBe(false); // offset(0) + items(4) == total(4) → no more
+  });
+});

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);
+});