@winspan/claude-forge 8.41.0 → 8.50.6

package/src/web/routes/sessions.ts

@@ -0,0 +1,262 @@
+import type { Application } from 'express';
+import type { RouteContext } from './types.js';
+
+/**
+ * /api/sessions* — session lists, per-session detail, timeline.
+ *
+ * Also hosts /api/injections since they are session-adjacent views.
+ */
+export function registerSessionsRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  // Sessions: list with first prompt
+  app.get('/api/sessions', (req, res) => {
+    const limit = parseInt(req.query.limit as string) || 10;
+    const projectPath = req.query.project as string | undefined;
+    const sessions = storage.querySessions({ project_path: projectPath, limit });
+    res.json(sessions);
+  });
+
+  // Injections: query injection history
+  app.get('/api/injections', (req, res) => {
+    const limit = parseInt(req.query.limit as string) || 50;
+    const sessionId = req.query.session as string | undefined;
+    const eventId = req.query.event as string | undefined;
+    const handler = req.query.handler as string | undefined;
+    const injections = storage.queryInjections({
+      session_id: sessionId,
+      event_id: eventId,
+      source_handler: handler,
+      limit,
+    });
+    res.json(injections);
+  });
+
+  // Session Events Search: server-side filtering
+  app.get('/api/sessions/:sessionId/events/search', (req, res) => {
+    const { sessionId } = req.params;
+    const { q, tool_name, hook_type, limit = '100', offset = '0' } = req.query;
+
+    const sessions = storage.querySessions({ limit: 1000 });
+    const session = sessions.find(s => s.session_id === sessionId || s.session_id.startsWith(sessionId));
+
+    if (!session) {
+      res.status(404).json({ error: 'Session not found' });
+      return;
+    }
+
+    const results = storage.searchEvents({
+      session_id: session.session_id,
+      query: q as string | undefined,
+      tool_name: tool_name as string | undefined,
+      hook_type: hook_type as string | undefined,
+      limit: parseInt(limit as string, 10),
+      offset: parseInt(offset as string, 10),
+    });
+
+    res.json({ events: results, total: results.length, session_id: session.session_id });
+  });
+
+  // Session Detail: task-grouped session data
+  app.get('/api/sessions/:sessionId/detail', (req, res) => {
+    const sessionId = req.params.sessionId;
+    const eventLimit = parseInt(req.query.eventLimit as string) || 200;
+    const eventOffset = parseInt(req.query.eventOffset as string) || 0;
+
+    const sessions = storage.querySessions({ limit: 1000 });
+    const session = sessions.find(s => s.session_id === sessionId || s.session_id.startsWith(sessionId));
+    if (!session) {
+      res.status(404).json({ error: 'Session not found' });
+      return;
+    }
+
+    const fullSessionId = session.session_id;
+    const tasks = storage.queryTasks({ session_id: fullSessionId });
+    const totalEvents = storage.countEvents({ session_id: fullSessionId });
+    const allEvents = storage.queryEvents({ session_id: fullSessionId, limit: eventLimit, offset: eventOffset });
+    const allInjections = storage.queryInjections({ session_id: fullSessionId, limit: 200 });
+
+    const buildTaskDetail = (events: typeof allEvents, injections: typeof allInjections) => {
+      const prompts = events
+        .filter(e => e.hook_type === 'UserPromptSubmit' && (e.user_prompt || (e.tool_input as any)?.user_prompt))
+        .map(e => ({ timestamp: e.timestamp, content: e.user_prompt || (e.tool_input as any)?.user_prompt }));
+
+      const toolUsage: Record<string, number> = {};
+      events.forEach(e => { if (e.tool_name) toolUsage[e.tool_name] = (toolUsage[e.tool_name] || 0) + 1; });
+
+      const filesChanged = [...new Set(
+        events
+          .filter(e => (e.tool_name === 'Edit' || e.tool_name === 'Write') && (e.tool_input as any)?.file_path)
+          .map(e => (e.tool_input as any).file_path),
+      )];
+
+      const commits = events
+        .filter(e => e.tool_name === 'Bash' && (e.tool_input as any)?.command?.includes('git commit'))
+        .map(e => {
+          const cmd = (e.tool_input as any)?.command || '';
+          const match = cmd.match(/git commit.*-m\s+["']([^"']+)["']/);
+          return { timestamp: e.timestamp, message: match ? match[1] : 'commit' };
+        });
+
+      return { prompts, events: events.slice(0, 200), injections, summary: { toolUsage, filesChanged, commits } };
+    };
+
+    if (tasks.length === 0) {
+      const detail = buildTaskDetail(allEvents, allInjections);
+      const virtualTask = {
+        id: 'virtual',
+        session_id: fullSessionId,
+        title: session.first_prompt || '(未分类任务)',
+        start_time: session.start_time,
+        end_time: session.end_time,
+        status: 'completed' as const,
+        event_count: allEvents.length,
+        ...detail,
+      };
+      res.json({ session, tasks: [virtualTask], total_events: totalEvents, event_limit: eventLimit, event_offset: eventOffset });
+      return;
+    }
+
+    const taskDetails = tasks.map(task => {
+      const taskEventIds = new Set(storage.getTaskEventIds(task.id));
+      const events = allEvents.filter(e => taskEventIds.has(e.event_id ?? ''));
+      const injections = allInjections.filter(i => i.event_id && taskEventIds.has(i.event_id));
+      const detail = buildTaskDetail(events, injections);
+      return { ...task, ...detail };
+    });
+
+    res.json({ session, tasks: taskDetails, total_events: totalEvents, event_limit: eventLimit, event_offset: eventOffset });
+  });
+
+  // Session timeline: detailed event timeline for a session
+  app.get('/api/sessions/:id/timeline', (req, res) => {
+    const sessionIdPrefix = req.params.id;
+    const limit = parseInt(req.query.limit as string) || 50;
+    const offset = parseInt(req.query.offset as string) || 0;
+
+    const sessions = storage.querySessions({ limit: 1000 });
+    const session = sessions.find(s => s.session_id.startsWith(sessionIdPrefix));
+
+    if (!session) {
+      res.status(404).json({ error: 'Session not found' });
+      return;
+    }
+
+    const fullSessionId = session.session_id;
+    const events = storage.queryEvents({ session_id: fullSessionId, limit: 2000 });
+    const injections = storage.queryInjections({ session_id: fullSessionId, limit: 200 });
+
+    // Build timeline: merge events and injections, sort by timestamp
+    const timeline: Array<{
+      timestamp: string;
+      type: 'user_input' | 'injection' | 'tool_call' | 'quality_check';
+      data: any;
+    }> = [];
+
+    // User inputs
+    events
+      .filter(e => e.hook_type === 'UserPromptSubmit' && (e.user_prompt || (e.tool_input as any)?.user_prompt))
+      .forEach(e => {
+        timeline.push({
+          timestamp: e.timestamp,
+          type: 'user_input',
+          data: { content: e.user_prompt || (e.tool_input as any)?.user_prompt },
+        });
+      });
+
+    // Injections (truncate content for preview)
+    injections.forEach(inj => {
+      timeline.push({
+        timestamp: inj.timestamp,
+        type: 'injection',
+        data: {
+          source: inj.source_handler,
+          injection_type: inj.injection_type,
+          content: inj.content.slice(0, 500),
+          length: inj.content.length,
+          truncated: inj.content.length > 500,
+        },
+      });
+    });
+
+    // Tool calls (truncate large fields)
+    events
+      .filter(e => e.tool_name && e.hook_type === 'PreToolUse')
+      .forEach(e => {
+        const toolInput = e.tool_input as any;
+        const toolOutput = e.tool_output as any;
+
+        const truncateField = (obj: any, maxLen = 200): any => {
+          if (!obj) return obj;
+          if (typeof obj === 'string') return obj.length > maxLen ? obj.slice(0, maxLen) + '...' : obj;
+          if (Array.isArray(obj)) return obj.slice(0, 5);
+          if (typeof obj === 'object') {
+            const result: any = {};
+            for (const [k, v] of Object.entries(obj)) {
+              result[k] = truncateField(v, maxLen);
+            }
+            return result;
+          }
+          return obj;
+        };
+
+        timeline.push({
+          timestamp: e.timestamp,
+          type: 'tool_call',
+          data: {
+            tool: e.tool_name,
+            input: truncateField(toolInput),
+            output: truncateField(toolOutput),
+            success: !toolOutput?.error,
+          },
+        });
+      });
+
+    // Quality checks (from PostToolUse events with quality gate results)
+    events
+      .filter(e => e.hook_type === 'PostToolUse' && (e.tool_output as any)?.quality_check)
+      .forEach(e => {
+        const qc = (e.tool_output as any).quality_check;
+        timeline.push({
+          timestamp: e.timestamp,
+          type: 'quality_check',
+          data: qc,
+        });
+      });
+
+    // Sort by timestamp
+    timeline.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+
+    // Paginate
+    const total = timeline.length;
+    const paginatedTimeline = timeline.slice(offset, offset + limit);
+
+    // Summary
+    const commits = events
+      .filter(e => e.tool_name === 'Bash' && (e.tool_input as any)?.command?.includes('git commit'))
+      .map(e => {
+        const cmd = (e.tool_input as any)?.command || '';
+        const match = cmd.match(/git commit.*-m\s+["']([^"']+)["']/);
+        return { message: match ? match[1] : 'commit' };
+      });
+
+    const filesChanged = [...new Set(
+      events
+        .filter(e => (e.tool_name === 'Edit' || e.tool_name === 'Write') && (e.tool_input as any)?.file_path)
+        .map(e => (e.tool_input as any).file_path),
+    )];
+
+    res.json({
+      session,
+      timeline: paginatedTimeline,
+      total,
+      offset,
+      limit,
+      hasMore: offset + limit < total,
+      summary: {
+        commits,
+        filesChanged,
+      },
+    });
+  });
+}

package/src/web/routes/skill-stats.ts

@@ -0,0 +1,132 @@
+import type { Application } from 'express';
+import type { RouteContext } from './types.js';
+
+/**
+ * /api/skill-stats/* — Skill usage statistics and analytics
+ *
+ * Provides data for the Skill Statistics dashboard:
+ *   - /api/skill-stats/distribution — routing type distribution (agent/skill/none)
+ *   - /api/skill-stats/frequency — skill usage frequency
+ *   - /api/skill-stats/trend — skill usage rate trend over time
+ */
+export function registerSkillStatsRoutes(app: Application, ctx: RouteContext): void {
+  const { storage } = ctx;
+
+  // Routing type distribution (for pie chart)
+  app.get('/api/skill-stats/distribution', (req, res) => {
+    const windowHours = parseInt((req.query.window as string) || '168'); // default 7d
+    const since = Date.now() - windowHours * 3600 * 1000;
+    const events = storage.queryRoutingEvents({ since_ts: since, limit: 10000 });
+
+    const distribution: Record<string, number> = {
+      agent: 0,
+      skill: 0,
+      none: 0,
+    };
+
+    for (const e of events) {
+      const type = e.routed_to_type || 'none';
+      distribution[type] = (distribution[type] || 0) + 1;
+    }
+
+    const result = Object.entries(distribution).map(([type, count]) => ({
+      type,
+      count,
+    }));
+
+    res.json({ windowHours, distribution: result });
+  });
+
+  // Skill usage frequency (for bar chart)
+  app.get('/api/skill-stats/frequency', (req, res) => {
+    const windowHours = parseInt((req.query.window as string) || '168');
+    const since = Date.now() - windowHours * 3600 * 1000;
+    const events = storage.queryRoutingEvents({ since_ts: since, limit: 10000 });
+
+    const frequency = new Map<string, number>();
+
+    for (const e of events) {
+      if (e.routed_to_type === 'skill' && e.routed_to_name) {
+        frequency.set(e.routed_to_name, (frequency.get(e.routed_to_name) || 0) + 1);
+      }
+    }
+
+    const result = Array.from(frequency.entries())
+      .map(([name, count]) => ({ name, count }))
+      .sort((a, b) => b.count - a.count);
+
+    res.json({ windowHours, frequency: result });
+  });
+
+  // Skill usage rate trend over time (for line chart)
+  app.get('/api/skill-stats/trend', (req, res) => {
+    const windowHours = parseInt((req.query.window as string) || '168');
+    const since = Date.now() - windowHours * 3600 * 1000;
+    const events = storage.queryRoutingEvents({ since_ts: since, limit: 10000 });
+
+    // Group by day
+    const dailyStats = new Map<string, { total: number; skill: number }>();
+
+    for (const e of events) {
+      const day = new Date(e.ts).toISOString().split('T')[0];
+      const stats = dailyStats.get(day) || { total: 0, skill: 0 };
+      stats.total++;
+      if (e.routed_to_type === 'skill') {
+        stats.skill++;
+      }
+      dailyStats.set(day, stats);
+    }
+
+    const result = Array.from(dailyStats.entries())
+      .map(([day, stats]) => ({
+        day,
+        skillRate: stats.total > 0 ? Math.round((stats.skill / stats.total) * 100) : 0,
+      }))
+      .sort((a, b) => a.day.localeCompare(b.day));
+
+    res.json({ windowHours, trend: result });
+  });
+
+  // Skill invocations from skill_invocations table (real call records)
+  app.get('/api/skill-stats/invocations', (req, res) => {
+    const days = parseInt((req.query.days as string) || '7');
+    const since = Date.now() - days * 24 * 3600 * 1000;
+    const invocations = storage.querySkillInvocations({ since, limit: 1000 });
+
+    const stats = new Map<string, { skill_id: string; total: number; success: number; failed: number }>();
+    for (const inv of invocations) {
+      const cur = stats.get(inv.skill_id) || { skill_id: inv.skill_id, total: 0, success: 0, failed: 0 };
+      cur.total++;
+      if (inv.success === 1) cur.success++;
+      else cur.failed++;
+      stats.set(inv.skill_id, cur);
+    }
+
+    const result = Array.from(stats.values()).sort((a, b) => b.total - a.total);
+    res.json({ days, total: invocations.length, invocations: result });
+  });
+
+  // Routing/Agent call rate stats
+  app.get('/api/routing/stats', (req, res) => {
+    const days = parseInt((req.query.days as string) || '7');
+    const since = Date.now() - days * 24 * 3600 * 1000;
+    const events = storage.queryRoutingEvents({ since_ts: since, limit: 10000 });
+
+    const total = events.length;
+    const agentCalls = events.filter(e => e.obeyed === 1).length;
+    const noAgent = total - agentCalls;
+    const agentRate = total > 0 ? Math.round((agentCalls / total) * 1000) / 10 : 0;
+
+    const byAgentMap = new Map<string, number>();
+    for (const e of events) {
+      if (e.routed_to_name && e.obeyed === 1) {
+        byAgentMap.set(e.routed_to_name, (byAgentMap.get(e.routed_to_name) || 0) + 1);
+      }
+    }
+    const byAgent = Array.from(byAgentMap.entries())
+      .map(([agent, count]) => ({ agent, count }))
+      .sort((a, b) => b.count - a.count);
+
+    res.json({ days, total, agentCalls, noAgent, agentRate, byAgent });
+  });
+}