@winspan/claude-forge 8.41.0 → 8.51.0

package/tests/unit/storage/tasks-stale-gc.test.ts

@@ -0,0 +1,86 @@
+/**
+ * 单测：completeStaleActiveTasks
+ *
+ * 覆盖：
+ *   - 空表返回 0
+ *   - 1 idle 超阈值 + 1 未超：只关超的那条
+ *   - status='completed' 的 task 不被改动
+ *   - end_time IS NULL 的 task 不被纳入 GC
+ */
+
+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-gc-test';
+
+function openStorage(tmp: string): SQLiteStorage {
+  return new SQLiteStorage(join(tmp, 'data.db'));
+}
+
+describe('completeStaleActiveTasks', () => {
+  let tmp: string;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    tmp = mkdtempSync(join(tmpdir(), 'forge-stale-gc-'));
+    storage = openStorage(tmp);
+  });
+
+  afterEach(() => {
+    try { storage.close(); } catch { /* ignore */ }
+    rmSync(tmp, { recursive: true, force: true });
+  });
+
+  it('空表返回 0', () => {
+    expect(storage.completeStaleActiveTasks(10)).toBe(0);
+  });
+
+  it('1 idle 超阈值 + 1 未超：只关超的那条', () => {
+    // 写 2 条 active task
+    storage.writeTask({ id: 'old-task', session_id: SESSION, title: 'old', start_time: '2026-01-01T00:00:00.000Z' });
+    storage.writeTask({ id: 'new-task', session_id: SESSION, title: 'new', start_time: '2026-01-01T01:00:00.000Z' });
+
+    // 用 DB 直接操作设置 end_time，让 old-task idle 15 分钟前，new-task 仅 3 分钟前
+    const db = storage.getDatabase();
+    db.prepare(`UPDATE tasks SET end_time = datetime('now', '-15 minutes') WHERE id = ?`).run('old-task');
+    db.prepare(`UPDATE tasks SET end_time = datetime('now', '-3 minutes') WHERE id = ?`).run('new-task');
+
+    const changed = storage.completeStaleActiveTasks(10);
+    expect(changed).toBe(1);
+
+    const oldTask = storage.getTask('old-task');
+    expect(oldTask?.status).toBe('completed');
+
+    const newTask = storage.getTask('new-task');
+    expect(newTask?.status).toBe('active');
+  });
+
+  it('status=completed 的 task 不被改动', () => {
+    storage.writeTask({ id: 'done-task', session_id: SESSION, title: 'done', start_time: '2026-01-01T00:00:00.000Z' });
+    storage.updateTask('done-task', { status: 'completed' });
+
+    // 设置很久以前的 end_time
+    const db = storage.getDatabase();
+    db.prepare(`UPDATE tasks SET end_time = datetime('now', '-60 minutes') WHERE id = ?`).run('done-task');
+
+    const changed = storage.completeStaleActiveTasks(10);
+    expect(changed).toBe(0);
+
+    const task = storage.getTask('done-task');
+    expect(task?.status).toBe('completed');
+  });
+
+  it('end_time IS NULL 的 task 不被纳入 GC', () => {
+    // 写 active task，end_time 保持 NULL（从未 linkEventToTask）
+    storage.writeTask({ id: 'null-end', session_id: SESSION, title: 'null-end', start_time: '2026-01-01T00:00:00.000Z' });
+
+    const changed = storage.completeStaleActiveTasks(10);
+    expect(changed).toBe(0);
+
+    const task = storage.getTask('null-end');
+    expect(task?.status).toBe('active');
+  });
+});

package/tests/unit/storage.test.ts

@@ -0,0 +1,172 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+import type { ForgeEvent } from '../../src/core/types.js';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+describe('SQLiteStorage', () => {
+  let storage: SQLiteStorage;
+  let tempDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'forge-test-'));
+    dbPath = join(tempDir, 'test.db');
+    storage = new SQLiteStorage(dbPath);
+  });
+
+  afterEach(() => {
+    storage.close();
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('writeEvent', () => {
+    it('stores an event', () => {
+      const event: ForgeEvent = {
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+        tool_name: 'Bash',
+        tool_input: { command: 'ls' },
+      };
+
+      storage.writeEvent(event);
+
+      const events = storage.queryEvents({ session_id: 'test-session' });
+      expect(events).toHaveLength(1);
+      expect(events[0].tool_name).toBe('Bash');
+    });
+  });
+
+  describe('queryEvents', () => {
+    beforeEach(() => {
+      storage.writeEvent({
+        session_id: 'session-1',
+        project_path: '/project-a',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+      });
+      storage.writeEvent({
+        session_id: 'session-2',
+        project_path: '/project-a',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PostToolUse',
+      });
+    });
+
+    it('retrieves events by session_id', () => {
+      const events = storage.queryEvents({ session_id: 'session-1' });
+      expect(events).toHaveLength(1);
+      expect(events[0].session_id).toBe('session-1');
+    });
+
+    it('retrieves events by project_path', () => {
+      const events = storage.queryEvents({ project_path: '/project-a' });
+      expect(events).toHaveLength(2);
+    });
+  });
+
+  describe('countEvents', () => {
+    it('counts total events', () => {
+      storage.writeEvent({
+        session_id: 'test',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+      });
+      expect(storage.countEvents({})).toBe(1);
+    });
+  });
+
+  describe('searchEvents', () => {
+    beforeEach(() => {
+      storage.writeEvent({
+        session_id: 'search-session',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'fix the authentication bug',
+      });
+      storage.writeEvent({
+        session_id: 'search-session',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'add new feature',
+      });
+    });
+
+    it('should search events by query string', () => {
+      const events = storage.searchEvents({
+        session_id: 'search-session',
+        query: 'authentication',
+      });
+      expect(events).toHaveLength(1);
+      expect(events[0].user_prompt).toContain('authentication');
+    });
+
+    it('should return empty array when no match', () => {
+      const events = storage.searchEvents({
+        session_id: 'search-session',
+        query: 'nonexistent',
+      });
+      expect(events).toHaveLength(0);
+    });
+  });
+
+  describe('session management', () => {
+    it('should create session from events', () => {
+      storage.writeEvent({
+        session_id: 'new-session',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'first prompt',
+      });
+
+      const sessions = storage.querySessions({ limit: 10 });
+      const session = sessions.find(s => s.session_id === 'new-session');
+      expect(session).toBeDefined();
+      expect(session?.first_prompt).toContain('first prompt');
+    });
+
+    it('should update session event count', () => {
+      storage.writeEvent({
+        session_id: 'count-session',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+      });
+      storage.writeEvent({
+        session_id: 'count-session',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+      });
+
+      const sessions = storage.querySessions({ limit: 10 });
+      const session = sessions.find(s => s.session_id === 'count-session');
+      expect(session?.event_count).toBeGreaterThanOrEqual(2);
+    });
+  });
+
+  describe('error handling', () => {
+    it('should handle invalid event data gracefully', () => {
+      const invalidEvent = {
+        session_id: '',
+        project_path: '/test',
+        timestamp: 'invalid-timestamp',
+        hook_type: 'InvalidType',
+      } as unknown as ForgeEvent;
+
+      expect(() => storage.writeEvent(invalidEvent)).toThrow();
+    });
+
+    it('should handle database query errors', () => {
+      storage.close();
+      expect(() => storage.queryEvents({ session_id: 'test' })).toThrow();
+    });
+  });
+});

package/tests/unit/token-usage.test.ts

@@ -0,0 +1,144 @@
+/**
+ * Token usage tracking tests
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { SQLiteStorage } from '../../src/core/storage/sqlite.js';
+import { TokenTracker } from '../../src/core/utils/token-tracker.js';
+import { mkdtempSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+
+describe('Token Usage Tracking', () => {
+  let storage: SQLiteStorage;
+  let tracker: TokenTracker;
+  let tempDir: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'forge-test-'));
+    storage = new SQLiteStorage(join(tempDir, 'test.db'));
+    tracker = new TokenTracker(storage, {
+      budgetPerSession: 10000,
+      warningThreshold: 0.8,
+    });
+  });
+
+  afterEach(() => {
+    storage.close();
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  it('should record token usage', () => {
+    storage.writeTokenUsage({
+      session_id: 'test-session-1',
+      input_tokens: 100,
+      output_tokens: 200,
+      model: 'claude-opus-4-7',
+      tool_name: 'Task',
+    });
+
+    const usage = storage.getTokenUsageBySession('test-session-1');
+    expect(usage.input_tokens).toBe(100);
+    expect(usage.output_tokens).toBe(200);
+    expect(usage.total_tokens).toBe(300);
+  });
+
+  it('should accumulate token usage across multiple calls', () => {
+    const sessionId = 'test-session-2';
+
+    storage.writeTokenUsage({
+      session_id: sessionId,
+      input_tokens: 100,
+      output_tokens: 200,
+    });
+
+    storage.writeTokenUsage({
+      session_id: sessionId,
+      input_tokens: 50,
+      output_tokens: 100,
+    });
+
+    const usage = storage.getTokenUsageBySession(sessionId);
+    expect(usage.input_tokens).toBe(150);
+    expect(usage.output_tokens).toBe(300);
+    expect(usage.total_tokens).toBe(450);
+  });
+
+  it('should list token usage records', () => {
+    const sessionId = 'test-session-4';
+
+    storage.writeTokenUsage({
+      session_id: sessionId,
+      input_tokens: 100,
+      output_tokens: 200,
+      model: 'claude-opus-4-7',
+      tool_name: 'Task',
+    });
+
+    storage.writeTokenUsage({
+      session_id: sessionId,
+      input_tokens: 50,
+      output_tokens: 100,
+      model: 'claude-sonnet-4',
+      tool_name: 'classify',
+    });
+
+    const records = storage.listTokenUsage({ session_id: sessionId });
+    expect(records).toHaveLength(2);
+    // Verify both records exist (order may vary due to timestamp precision)
+    const toolNames = records.map(r => r.tool_name);
+    expect(toolNames).toContain('Task');
+    expect(toolNames).toContain('classify');
+  });
+
+  it('should handle token tracker recording', () => {
+    const sessionId = 'test-session-5';
+
+    tracker.record({
+      session_id: sessionId,
+      usage: { input_tokens: 100, output_tokens: 200 },
+      model: 'claude-opus-4-7',
+      tool_name: 'Task',
+    });
+
+    const usage = tracker.getSessionUsage(sessionId);
+    expect(usage.total_tokens).toBe(300);
+    expect(usage.budget).toBe(10000);
+    expect(usage.usage_ratio).toBeCloseTo(0.03);
+  });
+
+  it('should not throw on budget check', () => {
+    const sessionId = 'test-session-6';
+
+    // Record usage exceeding budget
+    tracker.record({
+      session_id: sessionId,
+      usage: { input_tokens: 8000, output_tokens: 3000 },
+    });
+
+    // Should not throw, just log warning
+    const usage = tracker.getSessionUsage(sessionId);
+    expect(usage.total_tokens).toBe(11000);
+    expect(usage.usage_ratio).toBeGreaterThan(1.0);
+  });
+
+  it('should handle missing methodology_execution_id', () => {
+    const sessionId = 'test-session-7';
+
+    storage.writeTokenUsage({
+      session_id: sessionId,
+      input_tokens: 100,
+      output_tokens: 200,
+    });
+
+    const usage = storage.getTokenUsageBySession(sessionId);
+    expect(usage.total_tokens).toBe(300);
+  });
+
+  it('should return zero for non-existent session', () => {
+    const usage = storage.getTokenUsageBySession('non-existent');
+    expect(usage.total_tokens).toBe(0);
+    expect(usage.input_tokens).toBe(0);
+    expect(usage.output_tokens).toBe(0);
+  });
+});

package/tests/unit/type-guards.test.ts

@@ -0,0 +1,201 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import Database from 'better-sqlite3';
+import { EventEmitter } from 'node:events';
+import { EventOperations } from '../../src/core/storage/events.js';
+import type { ForgeEvent } from '../../src/core/types.js';
+import fs from 'node:fs';
+import path from 'node:path';
+import { tmpdir } from 'node:os';
+
+describe('Type Guards - EventOperations', () => {
+  let db: Database.Database;
+  let emitter: EventEmitter & { upsertSession: (event: ForgeEvent) => void };
+  let eventOps: EventOperations;
+  let dbPath: string;
+
+  beforeEach(() => {
+    // Create temporary database
+    dbPath = path.join(tmpdir(), `test-${Date.now()}.db`);
+    db = new Database(dbPath);
+
+    // Create events table
+    db.exec(`
+      CREATE TABLE IF NOT EXISTS events (
+        event_id TEXT PRIMARY KEY,
+        session_id TEXT NOT NULL,
+        project_path TEXT NOT NULL,
+        timestamp TEXT NOT NULL,
+        hook_type TEXT NOT NULL,
+        tool_name TEXT,
+        tool_input TEXT,
+        tool_output TEXT,
+        user_prompt TEXT,
+        ai_response TEXT,
+        distilled INTEGER DEFAULT 0
+      )
+    `);
+
+    // Create mock emitter
+    emitter = Object.assign(new EventEmitter(), {
+      upsertSession: () => {},
+    });
+
+    eventOps = new EventOperations(db, emitter);
+  });
+
+  afterEach(() => {
+    db.close();
+    if (fs.existsSync(dbPath)) {
+      fs.unlinkSync(dbPath);
+    }
+  });
+
+  describe('writeEvent validation', () => {
+    it('should accept valid event', () => {
+      const validEvent: ForgeEvent = {
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'test prompt',
+      };
+
+      expect(() => eventOps.writeEvent(validEvent)).not.toThrow();
+    });
+
+    it('should reject event with missing session_id', () => {
+      const invalidEvent = {
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+      } as unknown as ForgeEvent;
+
+      expect(() => eventOps.writeEvent(invalidEvent)).toThrow('Invalid event data');
+    });
+
+    it('should reject event with empty session_id', () => {
+      const invalidEvent: ForgeEvent = {
+        session_id: '',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+      };
+
+      expect(() => eventOps.writeEvent(invalidEvent)).toThrow('Invalid event data');
+    });
+
+    it('should reject event with missing project_path', () => {
+      const invalidEvent = {
+        session_id: 'test-session',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+      } as unknown as ForgeEvent;
+
+      expect(() => eventOps.writeEvent(invalidEvent)).toThrow('Invalid event data');
+    });
+
+    it('should reject event with empty timestamp', () => {
+      const invalidEvent = {
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: '',
+        hook_type: 'UserPromptSubmit',
+      } as unknown as ForgeEvent;
+
+      expect(() => eventOps.writeEvent(invalidEvent)).toThrow('Invalid event data');
+    });
+
+    it('should reject event with invalid hook_type', () => {
+      const invalidEvent = {
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'InvalidHookType',
+      } as unknown as ForgeEvent;
+
+      expect(() => eventOps.writeEvent(invalidEvent)).toThrow('Invalid event data');
+    });
+
+    it('should accept event with optional fields', () => {
+      const validEvent: ForgeEvent = {
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+        tool_name: 'TestTool',
+        tool_input: { param: 'value' },
+        tool_output: { result: 'success' },
+      };
+
+      expect(() => eventOps.writeEvent(validEvent)).not.toThrow();
+    });
+  });
+
+  describe('rowToEvent validation', () => {
+    it('should handle valid database row', () => {
+      const validRow = {
+        event_id: 'test-event-id',
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'UserPromptSubmit',
+        tool_name: null,
+        tool_input: null,
+        tool_output: null,
+        user_prompt: 'test prompt',
+        ai_response: null,
+      };
+
+      const event = eventOps.rowToEvent(validRow);
+      expect(event.event_id).toBe('test-event-id');
+      expect(event.session_id).toBe('test-session');
+      expect(event.hook_type).toBe('UserPromptSubmit');
+    });
+
+    it('should handle row with JSON fields', () => {
+      const validRow = {
+        event_id: 'test-event-id',
+        session_id: 'test-session',
+        project_path: '/test/project',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+        tool_name: 'TestTool',
+        tool_input: JSON.stringify({ param: 'value' }),
+        tool_output: JSON.stringify({ result: 'success' }),
+        user_prompt: null,
+        ai_response: null,
+      };
+
+      const event = eventOps.rowToEvent(validRow);
+      expect(event.tool_name).toBe('TestTool');
+      expect(event.tool_input).toEqual({ param: 'value' });
+      expect(event.tool_output).toEqual({ result: 'success' });
+    });
+
+    it('should return safe fallback for invalid row', () => {
+      const invalidRow = {
+        event_id: 123, // Should be string
+        session_id: null, // Should be string
+        project_path: undefined,
+        timestamp: 'invalid',
+        hook_type: 'InvalidType',
+      };
+
+      const event = eventOps.rowToEvent(invalidRow);
+      // Should not throw, but return safe defaults
+      expect(event.session_id).toBe('unknown');
+      expect(event.hook_type).toBe('UserPromptSubmit');
+    });
+
+    it('should handle missing fields gracefully', () => {
+      const incompleteRow = {
+        event_id: 'test-id',
+      };
+
+      const event = eventOps.rowToEvent(incompleteRow);
+      // Should return safe fallback
+      expect(event.event_id).toBeDefined();
+      expect(event.session_id).toBeDefined();
+    });
+  });
+});