@winspan/claude-forge 8.50.6 → 8.51.0

package/tests/unit/storage/schema-missing.test.ts

@@ -0,0 +1,81 @@
+/**
+ * H3: schema.sql 缺失时 fail-fast
+ *
+ * 覆盖 base.ts::initSchema 的两个分支：
+ *   1. schema.sql 存在 → 正常初始化 8 张表
+ *   2. schema.sql 缺失 → 立即抛 Error，不再走旧 inline fallback（events 表不会被创建）
+ *
+ * case 2 的实现：用 vi.doMock + 动态 import，对 'node:fs' 的 existsSync 做选择性 mock —
+ * 只让 schema.sql 路径返回 false，其他路径保留真实行为（避免破坏 mkdirSync 的目录检查）。
+ */
+
+import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import Database from 'better-sqlite3';
+
+describe('H3: schema.sql missing fail-fast', () => {
+  let tmp: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h3-schema-missing-'));
+    dbPath = join(tmp, 'data.db');
+  });
+
+  afterEach(() => {
+    vi.resetModules();
+    vi.restoreAllMocks();
+    vi.doUnmock('node:fs');
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('case 1: schema.sql 存在 → 正常初始化，sessions 表已创建', async () => {
+    const { SQLiteStorage } = await import('../../../src/core/storage/sqlite.js');
+    const storage = new SQLiteStorage(dbPath);
+    const db = storage.getDatabase();
+
+    const row = db
+      .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'`)
+      .get();
+    expect(row).toBeTruthy();
+
+    storage.close();
+  });
+
+  it('case 2: schema.sql 缺失 → 抛 Error，且未创建任何业务表（确认不走旧 fallback）', async () => {
+    vi.resetModules();
+
+    // 选择性 mock：只让 schema.sql 返回 false，其余路径保留真实 fs 行为
+    vi.doMock('node:fs', async () => {
+      const realFs = await vi.importActual<typeof import('node:fs')>('node:fs');
+      return {
+        ...realFs,
+        existsSync: (p: import('node:fs').PathLike) => {
+          const s = typeof p === 'string' ? p : p.toString();
+          if (s.endsWith('schema.sql')) return false;
+          return realFs.existsSync(p);
+        },
+      };
+    });
+
+    const { SQLiteStorage } = await import('../../../src/core/storage/sqlite.js');
+    expect(() => new SQLiteStorage(dbPath)).toThrow(/schema\.sql not found/);
+
+    // 验证未走旧 inline fallback：events 表不应存在
+    const raw = new Database(dbPath);
+    const eventsRow = raw
+      .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='events'`)
+      .get();
+    expect(eventsRow).toBeFalsy();
+
+    // sessions 表也不存在（schema.sql 完全没跑）
+    const sessionsRow = raw
+      .prepare(`SELECT name FROM sqlite_master WHERE type='table' AND name='sessions'`)
+      .get();
+    expect(sessionsRow).toBeFalsy();
+
+    raw.close();
+  });
+});

package/tests/unit/storage/session-operations-aggregates.test.ts

@@ -0,0 +1,120 @@
+/**
+ * H2: SessionOperations 新增 aggregate / count / query 方法测试
+ *
+ * 覆盖 4 个方法：
+ *   countAllSessions
+ *   aggregateDailySessionCounts
+ *   querySessionsByTimeRange
+ *   countSessionsByRange
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import type { ForgeEvent } from '../../../src/core/types.js';
+
+describe('SessionOperations H2 aggregates', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h2-sessions-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function makeEvent(overrides: Partial<ForgeEvent>): ForgeEvent {
+    return {
+      session_id: 's1',
+      project_path: '/tmp/proj',
+      timestamp: '2026-05-10T10:00:00.000Z',
+      hook_type: 'UserPromptSubmit',
+      user_prompt: 'hello',
+      ...overrides,
+    };
+  }
+
+  describe('countAllSessions', () => {
+    it('空表返回 0', () => {
+      expect(storage.countAllSessions()).toBe(0);
+    });
+    it('多 session 返回总数', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a' }));
+      storage.writeEvent(makeEvent({ session_id: 'b' }));
+      storage.writeEvent(makeEvent({ session_id: 'a' })); // same session, upsert
+      expect(storage.countAllSessions()).toBe(2);
+    });
+  });
+
+  describe('aggregateDailySessionCounts', () => {
+    it('按 date(start_time) 分组', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', timestamp: '2026-05-10T15:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'c', timestamp: '2026-05-11T10:00:00.000Z' }));
+      const r = storage.aggregateDailySessionCounts({ since: '2026-05-01T00:00:00.000Z' });
+      expect(r).toEqual([
+        { date: '2026-05-10', count: 2 },
+        { date: '2026-05-11', count: 1 },
+      ]);
+    });
+    it('until 过滤排除上界', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', timestamp: '2026-05-20T10:00:00.000Z' }));
+      const r = storage.aggregateDailySessionCounts({
+        since: '2026-05-01T00:00:00.000Z',
+        until: '2026-05-15T00:00:00.000Z',
+      });
+      expect(r).toEqual([{ date: '2026-05-10', count: 1 }]);
+    });
+    it('空返回空数组', () => {
+      expect(storage.aggregateDailySessionCounts({ since: '2026-05-01T00:00:00.000Z' })).toEqual([]);
+    });
+  });
+
+  describe('querySessionsByTimeRange', () => {
+    it('按 start_time DESC，区间过滤', () => {
+      storage.writeEvent(makeEvent({ session_id: 'old', timestamp: '2026-05-01T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'mid', timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'new', timestamp: '2026-05-15T10:00:00.000Z' }));
+      const r = storage.querySessionsByTimeRange({ since: '2026-05-05T00:00:00.000Z' });
+      expect(r.length).toBe(2);
+      expect(r[0].session_id).toBe('new');
+      expect(r[1].session_id).toBe('mid');
+    });
+    it('暴露 first_prompt 字段', () => {
+      storage.writeEvent(makeEvent({
+        session_id: 'a',
+        timestamp: '2026-05-10T10:00:00.000Z',
+        user_prompt: 'hello world',
+      }));
+      const r = storage.querySessionsByTimeRange({ since: '2026-05-01T00:00:00.000Z' });
+      expect(r[0].first_prompt).toBe('hello world');
+    });
+  });
+
+  describe('countSessionsByRange', () => {
+    it('空表返回 0', () => {
+      expect(storage.countSessionsByRange({ since: '2026-05-01T00:00:00.000Z' })).toBe(0);
+    });
+    it('区间内 session 计数', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', timestamp: '2026-05-01T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'c', timestamp: '2026-05-20T10:00:00.000Z' }));
+      expect(storage.countSessionsByRange({
+        since: '2026-05-05T00:00:00.000Z',
+        until: '2026-05-15T00:00:00.000Z',
+      })).toBe(1);
+    });
+    it('无 until 不限上界', () => {
+      storage.writeEvent(makeEvent({ session_id: 'a', timestamp: '2026-05-10T10:00:00.000Z' }));
+      storage.writeEvent(makeEvent({ session_id: 'b', timestamp: '2026-05-20T10:00:00.000Z' }));
+      expect(storage.countSessionsByRange({ since: '2026-05-01T00:00:00.000Z' })).toBe(2);
+    });
+  });
+});

package/tests/unit/storage/skill-operations-counts.test.ts

@@ -0,0 +1,106 @@
+/**
+ * H2: SkillOperations 新增 count / query 方法测试
+ *
+ * 覆盖 4 个方法：
+ *   countAllSkillInvocations
+ *   countSkillInvocationsBySession
+ *   countDistinctSkillsSince
+ *   queryDistinctSkillIdsBySession
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import type { SkillInvocationRow } from '../../../src/core/storage/rows.js';
+
+describe('SkillOperations H2 counts', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h2-skills-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  function makeInv(overrides: Partial<SkillInvocationRow>): Omit<SkillInvocationRow, 'created_at'> {
+    return {
+      id: `inv-${Math.random().toString(36).slice(2, 10)}`,
+      route_request_id: null,
+      session_id: 's1',
+      agent_id: null,
+      skill_id: 'skill-a',
+      invocation_type: 'manual',
+      reason: null,
+      workflow: null,
+      phase: null,
+      feature_slug: null,
+      artifact_path: null,
+      depth: 0,
+      success: 1,
+      error: null,
+      timestamp: Date.now(),
+      ...overrides,
+    };
+  }
+
+  describe('countAllSkillInvocations', () => {
+    it('空表返回 0', () => {
+      expect(storage.countAllSkillInvocations()).toBe(0);
+    });
+    it('多条返回总数', () => {
+      storage.writeSkillInvocation(makeInv({ id: 'a' }));
+      storage.writeSkillInvocation(makeInv({ id: 'b' }));
+      storage.writeSkillInvocation(makeInv({ id: 'c' }));
+      expect(storage.countAllSkillInvocations()).toBe(3);
+    });
+  });
+
+  describe('countSkillInvocationsBySession', () => {
+    it('未匹配 session 返回 0', () => {
+      expect(storage.countSkillInvocationsBySession('nope')).toBe(0);
+    });
+    it('按 session_id 计数', () => {
+      storage.writeSkillInvocation(makeInv({ id: 'a', session_id: 's1' }));
+      storage.writeSkillInvocation(makeInv({ id: 'b', session_id: 's1' }));
+      storage.writeSkillInvocation(makeInv({ id: 'c', session_id: 's2' }));
+      expect(storage.countSkillInvocationsBySession('s1')).toBe(2);
+      expect(storage.countSkillInvocationsBySession('s2')).toBe(1);
+    });
+  });
+
+  describe('countDistinctSkillsSince', () => {
+    it('空表返回 0', () => {
+      expect(storage.countDistinctSkillsSince(0)).toBe(0);
+    });
+    it('distinct skill_id 计数，since 过滤', () => {
+      const now = Date.now();
+      storage.writeSkillInvocation(makeInv({ id: 'a', skill_id: 'x', timestamp: now }));
+      storage.writeSkillInvocation(makeInv({ id: 'b', skill_id: 'x', timestamp: now }));
+      storage.writeSkillInvocation(makeInv({ id: 'c', skill_id: 'y', timestamp: now }));
+      storage.writeSkillInvocation(makeInv({ id: 'd', skill_id: 'z', timestamp: now - 1_000_000 }));
+      expect(storage.countDistinctSkillsSince(now)).toBe(2);  // x, y
+      expect(storage.countDistinctSkillsSince(0)).toBe(3);    // x, y, z
+    });
+  });
+
+  describe('queryDistinctSkillIdsBySession', () => {
+    it('未匹配返回空', () => {
+      expect(storage.queryDistinctSkillIdsBySession('nope')).toEqual([]);
+    });
+    it('按 session 返回 distinct skill_id', () => {
+      storage.writeSkillInvocation(makeInv({ id: 'a', session_id: 's1', skill_id: 'x' }));
+      storage.writeSkillInvocation(makeInv({ id: 'b', session_id: 's1', skill_id: 'x' }));
+      storage.writeSkillInvocation(makeInv({ id: 'c', session_id: 's1', skill_id: 'y' }));
+      storage.writeSkillInvocation(makeInv({ id: 'd', session_id: 's2', skill_id: 'z' }));
+      const r = storage.queryDistinctSkillIdsBySession('s1');
+      expect(r.sort()).toEqual(['x', 'y']);
+    });
+  });
+});

package/tests/unit/storage/skills-aggregates.test.ts

@@ -0,0 +1,104 @@
+/**
+ * H1 storage aggregates: skill_invocations
+ *
+ * 覆盖：
+ *   - 空表返回 []
+ *   - success=1/0 分别计数
+ *   - 按 total 降序
+ *   - since 过滤边界
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+
+const SESSION = 'sess-s';
+
+function makeInv(overrides: {
+  id: string;
+  skill_id: string;
+  success: 0 | 1;
+  timestamp: number;
+  error?: string | null;
+}) {
+  return {
+    id: overrides.id,
+    route_request_id: null,
+    session_id: SESSION,
+    agent_id: null,
+    skill_id: overrides.skill_id,
+    invocation_type: 'dynamic' as const,
+    reason: null,
+    workflow: null,
+    phase: null,
+    feature_slug: null,
+    artifact_path: null,
+    depth: 0,
+    success: overrides.success,
+    error: overrides.error ?? null,
+    timestamp: overrides.timestamp,
+  };
+}
+
+describe('storage.aggregateSkillInvocationsBySkill', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h1-skills-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('空表返回 []', () => {
+    expect(storage.aggregateSkillInvocationsBySkill({ since: 0 })).toEqual([]);
+  });
+
+  it('success=1/0 分别计数；按 total 降序', () => {
+    const now = Date.now();
+    // tdd: 2 success + 1 failed = 3
+    storage.writeSkillInvocation(makeInv({ id: 'i1', skill_id: 'tdd', success: 1, timestamp: now }));
+    storage.writeSkillInvocation(makeInv({ id: 'i2', skill_id: 'tdd', success: 1, timestamp: now }));
+    storage.writeSkillInvocation(makeInv({ id: 'i3', skill_id: 'tdd', success: 0, timestamp: now, error: 'boom' }));
+    // debug: 1 success
+    storage.writeSkillInvocation(makeInv({ id: 'i4', skill_id: 'debug', success: 1, timestamp: now }));
+
+    const r = storage.aggregateSkillInvocationsBySkill({ since: 0 });
+    expect(r).toHaveLength(2);
+    // 排序：tdd 3 > debug 1
+    expect(r[0]).toEqual({ skill_id: 'tdd', total: 3, success: 2, failed: 1 });
+    expect(r[1]).toEqual({ skill_id: 'debug', total: 1, success: 1, failed: 0 });
+  });
+
+  it('since 过滤（旧 invocation 被排除）', () => {
+    const old = Date.now() - 10 * 24 * 3600 * 1000;
+    const fresh = Date.now();
+    storage.writeSkillInvocation(makeInv({ id: 'old', skill_id: 'tdd', success: 1, timestamp: old }));
+    storage.writeSkillInvocation(makeInv({ id: 'new', skill_id: 'tdd', success: 1, timestamp: fresh }));
+
+    const sevenDaysAgo = Date.now() - 7 * 24 * 3600 * 1000;
+    const r = storage.aggregateSkillInvocationsBySkill({ since: sevenDaysAgo });
+    expect(r).toHaveLength(1);
+    expect(r[0]).toEqual({ skill_id: 'tdd', total: 1, success: 1, failed: 0 });
+  });
+
+  it('since 边界：>= 通过', () => {
+    storage.writeSkillInvocation(makeInv({ id: 'b1', skill_id: 'tdd', success: 1, timestamp: 1000 }));
+    storage.writeSkillInvocation(makeInv({ id: 'b2', skill_id: 'tdd', success: 1, timestamp: 2000 }));
+
+    const r1 = storage.aggregateSkillInvocationsBySkill({ since: 2000 });
+    expect(r1[0].total).toBe(1);
+
+    const r2 = storage.aggregateSkillInvocationsBySkill({ since: 1000 });
+    expect(r2[0].total).toBe(2);
+
+    const r3 = storage.aggregateSkillInvocationsBySkill({ since: 2001 });
+    expect(r3).toEqual([]);
+  });
+});

package/tests/unit/storage/sqlite-refactor-harness.test.ts

@@ -228,8 +228,8 @@ describe('SQLiteStorage - Characterization Tests (Pre-Refactor)', () => {
   });
 
   describe('Token Usage Operations', () => {
-    it('recordTokenUsage and getTokenUsageBySession work correctly', () => {
-      storage.recordTokenUsage({
+    it('writeTokenUsage and getTokenUsageBySession work correctly', () => {
+      storage.writeTokenUsage({
         session_id: 'session-1',
         input_tokens: 100,
         output_tokens: 50,
@@ -243,7 +243,7 @@ describe('SQLiteStorage - Characterization Tests (Pre-Refactor)', () => {
     });
 
     it('listTokenUsage returns usage records', () => {
-      storage.recordTokenUsage({
+      storage.writeTokenUsage({
         session_id: 'session-1',
         input_tokens: 100,
         output_tokens: 50,

package/tests/unit/storage/task-operations-counts.test.ts

@@ -0,0 +1,46 @@
+/**
+ * H2: TaskOperations 新增 countTasksByRange 方法测试
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+
+describe('TaskOperations H2: countTasksByRange', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-h2-tasks-'));
+    storage = new SQLiteStorage(join(tmp, 'data.db'));
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('空表返回 0', () => {
+    expect(storage.countTasksByRange({ since: '2026-05-01T00:00:00.000Z' })).toBe(0);
+  });
+
+  it('按 start_time 区间过滤', () => {
+    storage.writeTask({ id: 't1', session_id: 's1', title: 'old', start_time: '2026-05-01T10:00:00.000Z' });
+    storage.writeTask({ id: 't2', session_id: 's1', title: 'mid', start_time: '2026-05-10T10:00:00.000Z' });
+    storage.writeTask({ id: 't3', session_id: 's1', title: 'new', start_time: '2026-05-20T10:00:00.000Z' });
+
+    expect(storage.countTasksByRange({
+      since: '2026-05-05T00:00:00.000Z',
+      until: '2026-05-15T00:00:00.000Z',
+    })).toBe(1);
+  });
+
+  it('无 until 不限上界', () => {
+    storage.writeTask({ id: 't1', session_id: 's1', title: 'a', start_time: '2026-05-10T10:00:00.000Z' });
+    storage.writeTask({ id: 't2', session_id: 's1', title: 'b', start_time: '2026-05-20T10:00:00.000Z' });
+
+    expect(storage.countTasksByRange({ since: '2026-05-01T00:00:00.000Z' })).toBe(2);
+  });
+});