@winspan/claude-forge 8.53.2 → 8.54.3

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

@@ -1,86 +0,0 @@
-/**
- * 单测：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

@@ -1,172 +0,0 @@
-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

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

@@ -1,201 +0,0 @@
-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();
-    });
-  });
-});