@winspan/claude-forge 8.41.0 → 8.50.6

package/tests/unit/web/routes-events.test.ts

@@ -0,0 +1,101 @@
+/**
+ * Unit tests for /api/events route (list + SSE smoke).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerEventsRoutes } from '../../../src/web/routes/events.js';
+
+const PROJECT = '/tmp/proj';
+
+function ts(offsetMs = 0): string {
+  return new Date(Date.UTC(2026, 0, 1) + offsetMs).toISOString();
+}
+
+describe('Events Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerEventsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe('GET /api/events', () => {
+    it('returns empty list initially', async () => {
+      const res = await request(app).get('/api/events');
+      expect(res.status).toBe(200);
+      expect(res.body).toEqual([]);
+    });
+
+    it('returns events ordered by timestamp desc', async () => {
+      storage.writeEvent({
+        session_id: 's1', project_path: PROJECT, timestamp: ts(0),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+      });
+      storage.writeEvent({
+        session_id: 's1', project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'PreToolUse', tool_name: 'Edit',
+      });
+      const res = await request(app).get('/api/events');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(2);
+      expect(res.body[0].tool_name).toBe('Edit');
+    });
+
+    it('respects limit query param', async () => {
+      for (let i = 0; i < 5; i++) {
+        storage.writeEvent({
+          session_id: 's1', project_path: PROJECT, timestamp: ts(i * 100),
+          hook_type: 'PreToolUse', tool_name: 'Bash',
+        });
+      }
+      const res = await request(app).get('/api/events').query({ limit: 2 });
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(2);
+    });
+
+    it('filters by session id', async () => {
+      storage.writeEvent({
+        session_id: 's1', project_path: PROJECT, timestamp: ts(0),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+      });
+      storage.writeEvent({
+        session_id: 's2', project_path: PROJECT, timestamp: ts(0),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+      });
+      const res = await request(app).get('/api/events').query({ session: 's2' });
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].session_id).toBe('s2');
+    });
+  });
+
+  describe('GET /api/events/stream (SSE)', () => {
+    it('returns 200 with text/event-stream content type', async () => {
+      const server = app.listen(0);
+      const port = (server.address() as { port: number }).port;
+      try {
+        const res = await fetch(`http://127.0.0.1:${port}/api/events/stream`);
+        expect(res.status).toBe(200);
+        expect(res.headers.get('content-type')).toContain('text/event-stream');
+        // Read first chunk and bail
+        const reader = res.body!.getReader();
+        const { value } = await reader.read();
+        const text = new TextDecoder().decode(value);
+        expect(text).toContain('"connected"');
+        await reader.cancel();
+      } finally {
+        await new Promise<void>((resolve) => server.close(() => resolve()));
+      }
+    });
+  });
+});

package/tests/unit/web/routes-sessions.test.ts

@@ -0,0 +1,181 @@
+/**
+ * Unit tests for /api/sessions* routes (sessions list, detail, timeline, search).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerSessionsRoutes } from '../../../src/web/routes/sessions.js';
+
+const SESSION_ID = 'sess-aaaa-bbbb';
+const PROJECT = '/tmp/proj';
+
+function ts(offsetMs = 0): string {
+  return new Date(Date.UTC(2026, 0, 1, 0, 0, 0) + offsetMs).toISOString();
+}
+
+describe('Session Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerSessionsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe('GET /api/sessions', () => {
+    it('returns empty array initially', async () => {
+      const res = await request(app).get('/api/sessions');
+      expect(res.status).toBe(200);
+      expect(Array.isArray(res.body)).toBe(true);
+      expect(res.body).toHaveLength(0);
+    });
+
+    it('returns sessions list after events written', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID,
+        project_path: PROJECT,
+        timestamp: ts(),
+        hook_type: 'UserPromptSubmit',
+        user_prompt: 'hello world',
+      });
+
+      const res = await request(app).get('/api/sessions');
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].session_id).toBe(SESSION_ID);
+      expect(res.body[0].first_prompt).toBe('hello world');
+    });
+
+    it('honours project filter', async () => {
+      storage.writeEvent({
+        session_id: 's1', project_path: '/a', timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'a',
+      });
+      storage.writeEvent({
+        session_id: 's2', project_path: '/b', timestamp: ts(1000),
+        hook_type: 'UserPromptSubmit', user_prompt: 'b',
+      });
+
+      const res = await request(app).get('/api/sessions').query({ project: '/b' });
+      expect(res.status).toBe(200);
+      expect(res.body).toHaveLength(1);
+      expect(res.body[0].session_id).toBe('s2');
+    });
+  });
+
+  describe('GET /api/sessions/:sessionId/detail', () => {
+    it('returns 404 for non-existent session', async () => {
+      const res = await request(app).get('/api/sessions/does-not-exist/detail');
+      expect(res.status).toBe(404);
+      expect(res.body.error).toBe('Session not found');
+    });
+
+    it('returns task-grouped detail (virtual task when no tasks)', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'do thing',
+      });
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'PreToolUse', tool_name: 'Edit',
+        tool_input: { file_path: '/x.ts' },
+      });
+
+      const res = await request(app).get(`/api/sessions/${SESSION_ID}/detail`);
+      expect(res.status).toBe(200);
+      expect(res.body.session.session_id).toBe(SESSION_ID);
+      expect(res.body.tasks).toHaveLength(1);
+      expect(res.body.tasks[0].id).toBe('virtual');
+      expect(res.body.tasks[0].summary.toolUsage.Edit).toBe(1);
+      expect(res.body.tasks[0].summary.filesChanged).toContain('/x.ts');
+    });
+
+    it('supports session id prefix lookup', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'hi',
+      });
+      const prefix = SESSION_ID.slice(0, 8);
+      const res = await request(app).get(`/api/sessions/${prefix}/detail`);
+      expect(res.status).toBe(200);
+      expect(res.body.session.session_id).toBe(SESSION_ID);
+    });
+  });
+
+  describe('GET /api/sessions/:sessionId/events/search', () => {
+    it('returns 404 when session does not exist', async () => {
+      const res = await request(app).get('/api/sessions/missing/events/search');
+      expect(res.status).toBe(404);
+    });
+
+    it('filters events by query string', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'banana smoothie',
+      });
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'UserPromptSubmit', user_prompt: 'apple pie',
+      });
+
+      const res = await request(app)
+        .get(`/api/sessions/${SESSION_ID}/events/search`)
+        .query({ q: 'banana' });
+      expect(res.status).toBe(200);
+      expect(res.body.session_id).toBe(SESSION_ID);
+      expect(res.body.events).toHaveLength(1);
+      expect(res.body.events[0].user_prompt).toContain('banana');
+    });
+  });
+
+  describe('GET /api/sessions/:id/timeline', () => {
+    it('returns 404 for unknown session prefix', async () => {
+      const res = await request(app).get('/api/sessions/zzz/timeline');
+      expect(res.status).toBe(404);
+    });
+
+    it('returns timeline with user inputs and tool calls', async () => {
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(),
+        hook_type: 'UserPromptSubmit', user_prompt: 'go',
+      });
+      storage.writeEvent({
+        session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(1000),
+        hook_type: 'PreToolUse', tool_name: 'Bash',
+        tool_input: { command: 'git commit -m "feat: stuff"' },
+      });
+
+      const res = await request(app).get(`/api/sessions/${SESSION_ID}/timeline`);
+      expect(res.status).toBe(200);
+      expect(res.body.session.session_id).toBe(SESSION_ID);
+      expect(res.body.timeline.length).toBeGreaterThanOrEqual(2);
+      expect(res.body.timeline.some((t: { type: string }) => t.type === 'user_input')).toBe(true);
+      expect(res.body.timeline.some((t: { type: string }) => t.type === 'tool_call')).toBe(true);
+      expect(res.body.summary.commits[0].message).toBe('feat: stuff');
+    });
+
+    it('paginates timeline entries', async () => {
+      for (let i = 0; i < 5; i++) {
+        storage.writeEvent({
+          session_id: SESSION_ID, project_path: PROJECT, timestamp: ts(i * 100),
+          hook_type: 'UserPromptSubmit', user_prompt: `q${i}`,
+        });
+      }
+      const res = await request(app)
+        .get(`/api/sessions/${SESSION_ID}/timeline`)
+        .query({ limit: 2, offset: 1 });
+      expect(res.status).toBe(200);
+      expect(res.body.timeline).toHaveLength(2);
+      expect(res.body.total).toBe(5);
+      expect(res.body.hasMore).toBe(true);
+    });
+  });
+});

package/tests/unit/web/routes-skill-stats.test.ts

@@ -0,0 +1,179 @@
+/**
+ * Unit tests for /api/skill-stats/* and /api/routing/stats routes.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerSkillStatsRoutes } from '../../../src/web/routes/skill-stats.js';
+
+const SESSION = 'sess-skill';
+const PROJECT = '/tmp/proj';
+
+describe('Skill Stats Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerSkillStatsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  describe('GET /api/skill-stats/distribution', () => {
+    it('returns zero counts when no routing events', async () => {
+      const res = await request(app).get('/api/skill-stats/distribution');
+      expect(res.status).toBe(200);
+      expect(res.body.windowHours).toBe(168);
+      expect(Array.isArray(res.body.distribution)).toBe(true);
+      const map = Object.fromEntries(
+        res.body.distribution.map((d: { type: string; count: number }) => [d.type, d.count]),
+      );
+      expect(map.agent).toBe(0);
+      expect(map.skill).toBe(0);
+      expect(map.none).toBe(0);
+    });
+
+    it('counts routing events grouped by type', async () => {
+      const now = Date.now();
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p1', intent_json: '{}', routed_to_type: 'agent', routed_to_name: 'researcher',
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p2', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'official-tdd',
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p3', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'official-tdd',
+      });
+
+      const res = await request(app).get('/api/skill-stats/distribution');
+      expect(res.status).toBe(200);
+      const map = Object.fromEntries(
+        res.body.distribution.map((d: { type: string; count: number }) => [d.type, d.count]),
+      );
+      expect(map.agent).toBe(1);
+      expect(map.skill).toBe(2);
+    });
+  });
+
+  describe('GET /api/skill-stats/frequency', () => {
+    it('returns skill call frequency sorted by count desc', async () => {
+      const now = Date.now();
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p1', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'tdd',
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p2', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'debug',
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p3', intent_json: '{}', routed_to_type: 'skill', routed_to_name: 'tdd',
+      });
+
+      const res = await request(app).get('/api/skill-stats/frequency');
+      expect(res.status).toBe(200);
+      expect(res.body.frequency[0]).toEqual({ name: 'tdd', count: 2 });
+      expect(res.body.frequency[1]).toEqual({ name: 'debug', count: 1 });
+    });
+  });
+
+  describe('GET /api/skill-stats/invocations', () => {
+    it('aggregates invocations grouped by skill_id', async () => {
+      const now = Date.now();
+      storage.writeSkillInvocation({
+        id: 'si-1', route_request_id: null, session_id: SESSION,
+        agent_id: null, skill_id: 'official-tdd',
+        invocation_type: 'dynamic', reason: null,
+        workflow: null, phase: null, feature_slug: null, artifact_path: null,
+        depth: 0, success: 1, error: null, timestamp: now,
+      });
+      storage.writeSkillInvocation({
+        id: 'si-2', route_request_id: null, session_id: SESSION,
+        agent_id: null, skill_id: 'official-tdd',
+        invocation_type: 'dynamic', reason: null,
+        workflow: null, phase: null, feature_slug: null, artifact_path: null,
+        depth: 0, success: 0, error: 'boom', timestamp: now,
+      });
+      storage.writeSkillInvocation({
+        id: 'si-3', route_request_id: null, session_id: SESSION,
+        agent_id: null, skill_id: 'official-debug',
+        invocation_type: 'dynamic', reason: null,
+        workflow: null, phase: null, feature_slug: null, artifact_path: null,
+        depth: 0, success: 1, error: null, timestamp: now,
+      });
+
+      const res = await request(app).get('/api/skill-stats/invocations').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.days).toBe(7);
+      expect(res.body.total).toBe(3);
+      const tdd = res.body.invocations.find((i: { skill_id: string }) => i.skill_id === 'official-tdd');
+      expect(tdd.total).toBe(2);
+      expect(tdd.success).toBe(1);
+      expect(tdd.failed).toBe(1);
+    });
+
+    it('respects days window (excludes old invocations)', async () => {
+      const old = Date.now() - 10 * 24 * 3600 * 1000;
+      storage.writeSkillInvocation({
+        id: 'si-old', route_request_id: null, session_id: SESSION,
+        agent_id: null, skill_id: 'official-tdd',
+        invocation_type: 'dynamic', reason: null,
+        workflow: null, phase: null, feature_slug: null, artifact_path: null,
+        depth: 0, success: 1, error: null, timestamp: old,
+      });
+      const res = await request(app).get('/api/skill-stats/invocations').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.total).toBe(0);
+    });
+  });
+
+  describe('GET /api/routing/stats', () => {
+    it('returns zero stats when no routing events', async () => {
+      const res = await request(app).get('/api/routing/stats').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.total).toBe(0);
+      expect(res.body.agentCalls).toBe(0);
+      expect(res.body.agentRate).toBe(0);
+      expect(res.body.byAgent).toEqual([]);
+    });
+
+    it('aggregates agent obey rate and breakdown', async () => {
+      const now = Date.now();
+      // 3 events: 2 obeyed researcher, 1 not obeyed
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p1', intent_json: '{}', routed_to_type: 'agent',
+        routed_to_name: 'researcher', obeyed: 1,
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p2', intent_json: '{}', routed_to_type: 'agent',
+        routed_to_name: 'researcher', obeyed: 1,
+      });
+      storage.writeRoutingEvent({
+        session_id: SESSION, project_path: PROJECT, ts: now,
+        prompt: 'p3', intent_json: '{}', routed_to_type: 'agent',
+        routed_to_name: 'tester', obeyed: 0,
+      });
+
+      const res = await request(app).get('/api/routing/stats').query({ days: 7 });
+      expect(res.status).toBe(200);
+      expect(res.body.total).toBe(3);
+      expect(res.body.agentCalls).toBe(2);
+      expect(res.body.noAgent).toBe(1);
+      expect(res.body.agentRate).toBeCloseTo(66.7, 0);
+      expect(res.body.byAgent).toEqual([{ agent: 'researcher', count: 2 }]);
+    });
+  });
+});

package/tests/unit/web/routes-stats.test.ts

@@ -0,0 +1,92 @@
+/**
+ * Unit tests for /api/stats route (system-wide stats for the dashboard).
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import express, { type Application } from 'express';
+import request from 'supertest';
+import { SQLiteStorage } from '../../../src/core/storage/sqlite.js';
+import { registerStatsRoutes } from '../../../src/web/routes/stats.js';
+
+const SESSION = 'sess-stats';
+const PROJECT = '/tmp/proj';
+
+function ts(offsetMs = 0): string {
+  // Use very-recent timestamps so daily activity windows include them.
+  return new Date(Date.now() - offsetMs).toISOString();
+}
+
+describe('Stats Routes', () => {
+  let app: Application;
+  let storage: SQLiteStorage;
+
+  beforeEach(() => {
+    storage = new SQLiteStorage(':memory:');
+    app = express();
+    app.use(express.json());
+    registerStatsRoutes(app, { storage });
+  });
+
+  afterEach(() => {
+    storage.close();
+  });
+
+  it('returns zero values when database is empty', async () => {
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.totalSessions).toBe(0);
+    expect(res.body.totalEvents).toBe(0);
+    expect(res.body.toolUsage).toEqual({});
+    expect(res.body.dailyActivity).toEqual([]);
+    expect(res.body.skillInvocations).toBe(0);
+  });
+
+  it('returns aggregate counts after events written', async () => {
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: ts(0),
+      hook_type: 'UserPromptSubmit', user_prompt: 'q1',
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: ts(0),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'ls' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: ts(0),
+      hook_type: 'PreToolUse', tool_name: 'Bash', tool_input: { command: 'pwd' },
+    });
+    storage.writeEvent({
+      session_id: SESSION, project_path: PROJECT, timestamp: ts(0),
+      hook_type: 'PreToolUse', tool_name: 'Edit', tool_input: { file_path: '/x' },
+    });
+
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.totalEvents).toBe(4);
+    expect(res.body.totalSessions).toBe(1);
+    expect(res.body.toolUsage.Bash).toBe(2);
+    expect(res.body.toolUsage.Edit).toBe(1);
+    expect(Array.isArray(res.body.dailyActivity)).toBe(true);
+    expect(res.body.dailyActivity.length).toBeGreaterThanOrEqual(1);
+  });
+
+  it('counts skill invocations', async () => {
+    storage.writeSkillInvocation({
+      id: 'si-1', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-tdd',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+    storage.writeSkillInvocation({
+      id: 'si-2', route_request_id: null, session_id: SESSION,
+      agent_id: null, skill_id: 'official-debug',
+      invocation_type: 'dynamic', reason: null,
+      workflow: null, phase: null, feature_slug: null, artifact_path: null,
+      depth: 0, success: 1, error: null, timestamp: Date.now(),
+    });
+
+    const res = await request(app).get('/api/stats');
+    expect(res.status).toBe(200);
+    expect(res.body.skillInvocations).toBe(2);
+  });
+});