@winspan/claude-forge 8.41.0 → 8.50.6

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

@@ -0,0 +1,314 @@
+/**
+ * Characterization tests for SQLiteStorage refactoring
+ *
+ * Purpose: Capture current behavior before refactoring sqlite.ts
+ * These tests document ACTUAL behavior, not necessarily CORRECT behavior
+ */
+
+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 - Characterization Tests (Pre-Refactor)', () => {
+  let storage: SQLiteStorage;
+  let tempDir: string;
+  let dbPath: string;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'forge-harness-'));
+    dbPath = join(tempDir, 'test.db');
+    storage = new SQLiteStorage(dbPath);
+  });
+
+  afterEach(() => {
+    storage.close();
+    rmSync(tempDir, { recursive: true, force: true });
+  });
+
+  describe('Event Operations', () => {
+    it('writeEvent stores event and triggers session upsert', () => {
+      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');
+      expect(events[0].session_id).toBe('test-session');
+
+      // Verify session was auto-created
+      const sessions = storage.querySessions({ limit: 10 });
+      expect(sessions.length).toBeGreaterThan(0);
+      expect(sessions[0].session_id).toBe('test-session');
+    });
+
+    it('queryEvents filters by session_id', () => {
+      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',
+      });
+
+      const events = storage.queryEvents({ session_id: 'session-1' });
+      expect(events).toHaveLength(1);
+      expect(events[0].session_id).toBe('session-1');
+    });
+
+    it('countEvents returns total count', () => {
+      storage.writeEvent({
+        session_id: 'test',
+        project_path: '/test',
+        timestamp: new Date().toISOString(),
+        hook_type: 'PreToolUse',
+      });
+      expect(storage.countEvents()).toBe(1);
+    });
+  });
+
+  describe('Session Operations', () => {
+    it('querySessions returns session summaries', () => {
+      storage.writeEvent({
+        session_id: 'session-1',
+        project_path: '/project-a',
+        timestamp: '2026-01-01T00:00:00Z',
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'Test prompt',
+      });
+
+      const sessions = storage.querySessions({ limit: 10 });
+      expect(sessions).toHaveLength(1);
+      expect(sessions[0].session_id).toBe('session-1');
+      expect(sessions[0].first_prompt).toBe('Test prompt');
+      expect(sessions[0].event_count).toBe(1);
+    });
+
+    it('upsertSession updates existing session', () => {
+      const event1: ForgeEvent = {
+        session_id: 'session-1',
+        project_path: '/project-a',
+        timestamp: '2026-01-01T00:00:00Z',
+        hook_type: 'PreToolUse',
+      };
+      storage.writeEvent(event1);
+
+      const event2: ForgeEvent = {
+        session_id: 'session-1',
+        project_path: '/project-a',
+        timestamp: '2026-01-01T01:00:00Z',
+        hook_type: 'PostToolUse',
+      };
+      storage.writeEvent(event2);
+
+      const sessions = storage.querySessions({ limit: 10 });
+      expect(sessions).toHaveLength(1);
+      expect(sessions[0].event_count).toBe(2);
+    });
+  });
+
+  describe('Task Operations', () => {
+    it('writeTask and queryTasks work correctly', () => {
+      storage.writeTask({
+        id: 'task-1',
+        session_id: 'session-1',
+        title: 'Test Task',
+        start_time: '2026-01-01T00:00:00Z',
+      });
+
+      const tasks = storage.queryTasks({ session_id: 'session-1' });
+      expect(tasks).toHaveLength(1);
+      expect(tasks[0].id).toBe('task-1');
+      expect(tasks[0].title).toBe('Test Task');
+    });
+
+    it('updateTask modifies task fields', () => {
+      storage.writeTask({
+        id: 'task-1',
+        session_id: 'session-1',
+        title: 'Test Task',
+        start_time: '2026-01-01T00:00:00Z',
+      });
+
+      storage.updateTask('task-1', {
+        status: 'completed',
+        end_time: '2026-01-01T01:00:00Z',
+      });
+
+      const tasks = storage.queryTasks({ session_id: 'session-1' });
+      expect(tasks[0].status).toBe('completed');
+      expect(tasks[0].end_time).toBe('2026-01-01T01:00:00Z');
+    });
+
+    it('linkEventToTask associates events with tasks', () => {
+      storage.writeTask({
+        id: 'task-1',
+        session_id: 'session-1',
+        title: 'Test Task',
+        start_time: '2026-01-01T00:00:00Z',
+      });
+
+      storage.writeEvent({
+        event_id: 'event-1',
+        session_id: 'session-1',
+        project_path: '/test',
+        timestamp: '2026-01-01T00:00:00Z',
+        hook_type: 'PreToolUse',
+      });
+
+      storage.linkEventToTask('task-1', 'event-1');
+
+      const eventIds = storage.getTaskEventIds('task-1');
+      expect(eventIds).toContain('event-1');
+    });
+  });
+
+  describe('Injection Operations', () => {
+    it('writeInjection and queryInjections work correctly', () => {
+      storage.writeInjection({
+        session_id: 'session-1',
+        timestamp: '2026-01-01T00:00:00Z',
+        source_handler: 'test-handler',
+        injection_type: 'systemMessage',
+        content: 'Test injection',
+      });
+
+      const injections = storage.queryInjections({ session_id: 'session-1' });
+      expect(injections).toHaveLength(1);
+      expect(injections[0].content).toBe('Test injection');
+    });
+  });
+
+  describe('Routing Operations', () => {
+    it('writeRoutingEvent and queryRoutingEvents work correctly', () => {
+      const id = storage.writeRoutingEvent({
+        session_id: 'session-1',
+        project_path: '/test',
+        ts: Date.now(),
+        prompt: 'test prompt',
+        intent_json: '{}',
+      });
+
+      expect(id).toBeGreaterThan(0);
+
+      const events = storage.queryRoutingEvents({ session_id: 'session-1' });
+      expect(events).toHaveLength(1);
+      expect(events[0].prompt).toBe('test prompt');
+    });
+
+    it('updateRoutingEvent modifies routing event', () => {
+      const id = storage.writeRoutingEvent({
+        session_id: 'session-1',
+        project_path: '/test',
+        ts: Date.now(),
+        prompt: 'test prompt',
+        intent_json: '{}',
+      });
+
+      storage.updateRoutingEvent(id, { obeyed: 1 });
+
+      const events = storage.queryRoutingEvents({ session_id: 'session-1' });
+      expect(events[0].obeyed).toBe(1);
+    });
+  });
+
+  describe('Token Usage Operations', () => {
+    it('recordTokenUsage and getTokenUsageBySession work correctly', () => {
+      storage.recordTokenUsage({
+        session_id: 'session-1',
+        input_tokens: 100,
+        output_tokens: 50,
+        model: 'claude-opus-4',
+      });
+
+      const usage = storage.getTokenUsageBySession('session-1');
+      expect(usage.input_tokens).toBe(100);
+      expect(usage.output_tokens).toBe(50);
+      expect(usage.total_tokens).toBe(150);
+    });
+
+    it('listTokenUsage returns usage records', () => {
+      storage.recordTokenUsage({
+        session_id: 'session-1',
+        input_tokens: 100,
+        output_tokens: 50,
+      });
+
+      const records = storage.listTokenUsage({ session_id: 'session-1' });
+      expect(records).toHaveLength(1);
+      expect(records[0].input_tokens).toBe(100);
+    });
+  });
+
+  describe('Skill Invocation Operations', () => {
+    it('writeSkillInvocation and querySkillInvocations work correctly', () => {
+      storage.writeSkillInvocation({
+        id: 'skill-1',
+        route_request_id: 'route-1',
+        session_id: 'session-1',
+        agent_id: 'agent-1',
+        skill_id: 'test-skill',
+        invocation_type: 'auto',
+        reason: 'test/phase',
+        workflow: 'test',
+        phase: 'phase',
+        feature_slug: null,
+        artifact_path: null,
+        depth: 0,
+        success: 1,
+        error: null,
+        timestamp: Date.now(),
+      });
+
+      const invocations = storage.querySkillInvocations({ session_id: 'session-1' });
+      expect(invocations).toHaveLength(1);
+      expect(invocations[0].skill_id).toBe('test-skill');
+    });
+  });
+
+  describe('Maintenance Operations', () => {
+    it('cleanOldEvents removes old events', () => {
+      storage.writeEvent({
+        session_id: 'test',
+        project_path: '/test',
+        timestamp: '2020-01-01T00:00:00Z',
+        hook_type: 'PreToolUse',
+      });
+
+      const deleted = storage.cleanOldEvents(30);
+      expect(deleted).toBe(1);
+    });
+
+    it('vacuum runs without error', () => {
+      expect(() => storage.vacuum()).not.toThrow();
+    });
+  });
+
+  describe('Database Accessors', () => {
+    it('getDatabase returns database instance', () => {
+      const db = storage.getDatabase();
+      expect(db).toBeDefined();
+    });
+
+    it('getDbPath returns database path', () => {
+      const path = storage.getDbPath();
+      expect(path).toBe(dbPath);
+    });
+  });
+});
+

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.recordTokenUsage({
+      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.recordTokenUsage({
+      session_id: sessionId,
+      input_tokens: 100,
+      output_tokens: 200,
+    });
+
+    storage.recordTokenUsage({
+      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.recordTokenUsage({
+      session_id: sessionId,
+      input_tokens: 100,
+      output_tokens: 200,
+      model: 'claude-opus-4-7',
+      tool_name: 'Task',
+    });
+
+    storage.recordTokenUsage({
+      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.recordTokenUsage({
+      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);
+  });
+});