agentboss 0.1.0

package/server/api/metrics.js

@@ -0,0 +1,277 @@
+/**
+ * Metrics API routes for Agent Boss.
+ *
+ * Provides endpoints for dimension scores, daily/hourly summaries, session
+ * listings with pagination, trend computation, and cross-tool comparisons.
+ *
+ * @author Felix
+ */
+
+const router = require('express').Router();
+
+const {
+  getDailySummaries,
+  getHourlyActivity,
+  getSessionsByDateRange,
+  countSessionsByDateRange,
+} = require('../db/queries');
+
+// ---------------------------------------------------------------------------
+// Date helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Format a Date as YYYY-MM-DD.
+ * @param {Date} d
+ * @returns {string}
+ */
+function fmt(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${dd}`;
+}
+
+/**
+ * Get the date N days ago as YYYY-MM-DD.
+ * @param {number} n
+ * @returns {string}
+ */
+function daysAgo(n) {
+  const d = new Date();
+  d.setDate(d.getDate() - n);
+  return fmt(d);
+}
+
+/**
+ * Get yesterday as YYYY-MM-DD.
+ * @returns {string}
+ */
+function yesterday() {
+  return daysAgo(1);
+}
+
+/**
+ * Get today as YYYY-MM-DD.
+ * @returns {string}
+ */
+function today() {
+  return fmt(new Date());
+}
+
+/**
+ * Compute period boundaries for trend comparison.
+ * @param {string} period  'week' or 'month'
+ * @returns {{ current: {from: string, to: string}, previous: {from: string, to: string} }}
+ */
+function trendPeriods(period) {
+  const now = new Date();
+  if (period === 'month') {
+    // Current: last 30 days, Previous: 30 days before that
+    return {
+      current: { from: daysAgo(30), to: fmt(now) },
+      previous: { from: daysAgo(60), to: daysAgo(31) },
+    };
+  }
+  // Default: week
+  return {
+    current: { from: daysAgo(7), to: fmt(now) },
+    previous: { from: daysAgo(14), to: daysAgo(8) },
+  };
+}
+
+/**
+ * Sum key metrics from daily summary rows.
+ * @param {object[]} summaries
+ * @returns {object}
+ */
+function sumSummaries(summaries) {
+  let sessions = 0;
+  let cost = 0;
+  let activeMinutes = 0;
+  let errors = 0;
+  let tokensInput = 0;
+  let tokensOutput = 0;
+
+  for (const s of summaries) {
+    sessions += s.session_count || 0;
+    cost += s.cost_usd || 0;
+    activeMinutes += s.active_minutes || 0;
+    errors += s.error_count || 0;
+    tokensInput += s.tokens_input || 0;
+    tokensOutput += s.tokens_output || 0;
+  }
+
+  return {
+    sessions,
+    cost: Math.round(cost * 100) / 100,
+    activeMinutes,
+    errors,
+    tokensInput,
+    tokensOutput,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Routes
+// ---------------------------------------------------------------------------
+
+/**
+ * Create the metrics router with database access.
+ *
+ * @param {object} db  sql.js Database instance
+ * @returns {import('express').Router}
+ */
+module.exports = function (db) {
+  // GET /api/metrics/daily?from=&to=
+  router.get('/daily', (req, res) => {
+    try {
+      const from = req.query.from || daysAgo(7);
+      const to = req.query.to || today();
+      const data = getDailySummaries(db, from, to);
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from, to },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'METRICS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/metrics/hourly?date=
+  router.get('/hourly', (req, res) => {
+    try {
+      const date = req.query.date || yesterday();
+      const data = getHourlyActivity(db, date);
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: date, to: date },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'METRICS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/metrics/sessions?from=&to=&source=&limit=50&offset=0
+  router.get('/sessions', (req, res) => {
+    try {
+      const from = req.query.from || daysAgo(7);
+      const to = req.query.to || today();
+      const source = req.query.source || undefined;
+      const limit = parseInt(req.query.limit, 10) || 50;
+      const offset = parseInt(req.query.offset, 10) || 0;
+
+      const data = getSessionsByDateRange(db, from, to, source, limit, offset);
+      const total = countSessionsByDateRange(db, from, to, source);
+
+      res.json({
+        ok: true,
+        data,
+        total,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from, to },
+          pagination: { limit, offset, total },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'METRICS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/metrics/trends?period=week|month
+  router.get('/trends', (req, res) => {
+    try {
+      const period = req.query.period === 'month' ? 'month' : 'week';
+      const { current, previous } = trendPeriods(period);
+
+      const currentSummaries = getDailySummaries(db, current.from, current.to);
+      const previousSummaries = getDailySummaries(db, previous.from, previous.to);
+
+      const cur = sumSummaries(currentSummaries);
+      const prev = sumSummaries(previousSummaries);
+
+      // Compute percentage change (null if previous is zero)
+      const pct = (c, p) => (p > 0 ? Math.round(((c - p) / p) * 1000) / 10 : null);
+
+      const data = {
+        period,
+        current: cur,
+        previous: prev,
+        change: {
+          sessions: pct(cur.sessions, prev.sessions),
+          cost: pct(cur.cost, prev.cost),
+          activeMinutes: pct(cur.activeMinutes, prev.activeMinutes),
+          errors: pct(cur.errors, prev.errors),
+        },
+      };
+
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from: current.from, to: current.to },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'METRICS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  // GET /api/metrics/cross-tool
+  router.get('/cross-tool', (req, res) => {
+    try {
+      const from = req.query.from || daysAgo(30);
+      const to = req.query.to || today();
+
+      const opencodeSummaries = getDailySummaries(db, from, to, 'opencode');
+      const claudeCodeSummaries = getDailySummaries(db, from, to, 'claude-code');
+
+      const data = {
+        opencode: {
+          stats: sumSummaries(opencodeSummaries),
+        },
+        claudeCode: {
+          stats: sumSummaries(claudeCodeSummaries),
+        },
+      };
+
+      res.json({
+        ok: true,
+        data,
+        meta: {
+          generated_at: new Date().toISOString(),
+          period: { from, to },
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'METRICS_ERROR', message: err.message },
+      });
+    }
+  });
+
+  return router;
+};

package/server/api/overview.js

@@ -0,0 +1,308 @@
+/**
+ * Overview (home page) API for Agent Boss.
+ *
+ * Single endpoint `GET /api/overview?days=N` returns ETL-derived datasets
+ * — no dependency on the analysis layer, so the page renders the moment
+ * ETL sync completes:
+ *
+ *   range          — resolved window  { from, to, days, label }
+ *   trend          — daily rows broken out by source (sessions / cost)
+ *   topProjects    — top 8 projects in window, by cost
+ *   recentSessions — newest 10 sessions across all sources / dates
+ *   cacheRate      — per-day cache hit rate (%)
+ *   errorRate      — per-day error rate (%)
+ *   codeNet        — per-day additions / deletions / files
+ *   topTools       — top 10 tools by call count, with error rate
+ *   capabilityRadar — v2 5-axis radar averaged across analysed sessions in
+ *                     the window (H1/H2/H3/ENV/O1), or null if analysis
+ *                     hasn't produced any rows yet
+ *
+ * `days` may be 7 / 14 / 30 / 90 or `all`.  Unknown values fall back to 14.
+ *
+ * @author Felix
+ */
+
+const router = require('express').Router();
+
+const {
+  getOverviewTrend,
+  getOverviewTopProjects,
+  getOverviewRecentSessions,
+  getOverviewCacheRate,
+  getOverviewErrorRate,
+  getOverviewTopTools,
+  getEarliestSessionDate,
+} = require('../db/queries');
+const { getCurrentDimensionsV2 } = require('../analysis/report-builder');
+const { canonicalProject, mapTopProjects } = require('../utils/project');
+
+// ---------------------------------------------------------------------------
+// Date helpers
+// ---------------------------------------------------------------------------
+
+/** YYYY-MM-DD in local time. */
+function fmt(d) {
+  const y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, '0');
+  const dd = String(d.getDate()).padStart(2, '0');
+  return `${y}-${m}-${dd}`;
+}
+
+function daysAgo(n) {
+  const d = new Date();
+  d.setDate(d.getDate() - n);
+  return fmt(d);
+}
+
+// ---------------------------------------------------------------------------
+// Shape mappers
+// ---------------------------------------------------------------------------
+
+/**
+ * Reshape raw recent-session rows into the camelCase shape the home page
+ * table consumes.
+ *
+ * @param {Object[]} rows
+ * @returns {Object[]}
+ */
+function mapRecentSessions(rows) {
+  return rows.map((r) => ({
+    id:           r.id,
+    source:       r.source,
+    startedAt:    r.started_at,
+    project:      r.project,
+    title:        r.title,
+    model:        r.model,
+    messageCount: r.message_count || 0,
+    cost:         Math.round((r.cost_usd || 0) * 10000) / 10000,
+    errorCount:   r.error_count || 0,
+    reverted:     !!r.reverted,
+  }));
+}
+
+/**
+ * Pivot the (date, source) trend rows into one row per date with one column
+ * per source, so the recharts <TrendLine> can render overlaid lines.
+ *
+ * Output columns:
+ *   date, opencode_cost, claude-code_cost, opencode_sessions, ...
+ * The active sources list is returned alongside so the UI can build the
+ * right Line definitions without re-scanning the rows.
+ *
+ * @param {Object[]} rows  raw GROUP BY date, source rows
+ * @param {string}   fromDate
+ * @param {string}   toDate
+ * @returns {{ rows: Object[], sources: string[] }}
+ */
+function pivotTrend(rows, fromDate, toDate) {
+  const byDate = new Map();
+  const sourceSet = new Set();
+
+  for (const r of rows) {
+    sourceSet.add(r.source);
+    if (!byDate.has(r.date)) {
+      byDate.set(r.date, { date: r.date });
+    }
+    const bucket = byDate.get(r.date);
+    bucket[`${r.source}_sessions`]      = r.sessions || 0;
+    bucket[`${r.source}_cost`]          = Math.round((r.cost || 0) * 100) / 100;
+    bucket[`${r.source}_activeMinutes`] = r.active_minutes || 0;
+  }
+
+  const sources = Array.from(sourceSet);
+
+  // For very large windows (e.g. "all") we skip the dense fill — emitting
+  // one row per day for 6 months gets noisy on the x-axis.  Instead we
+  // just return the sparse rows ordered by date, with zeros injected for
+  // any source missing on a given day.
+  const start = new Date(fromDate + 'T00:00:00');
+  const end   = new Date(toDate   + 'T00:00:00');
+  const spanDays = Math.round((end - start) / 86400000) + 1;
+  const DENSE_FILL_MAX_DAYS = 120;
+
+  if (spanDays > DENSE_FILL_MAX_DAYS) {
+    const rows = Array.from(byDate.values()).sort((a, b) =>
+      a.date < b.date ? -1 : a.date > b.date ? 1 : 0
+    );
+    for (const row of rows) {
+      for (const s of sources) {
+        if (row[`${s}_sessions`]      == null) row[`${s}_sessions`]      = 0;
+        if (row[`${s}_cost`]          == null) row[`${s}_cost`]          = 0;
+        if (row[`${s}_activeMinutes`] == null) row[`${s}_activeMinutes`] = 0;
+      }
+    }
+    return { rows, sources };
+  }
+
+  // Fill the full date range so the x-axis is continuous (no gaps when a
+  // day had zero activity).
+  const filled = [];
+  for (let d = new Date(start); d <= end; d.setDate(d.getDate() + 1)) {
+    const key = fmt(d);
+    const existing = byDate.get(key) || { date: key };
+    for (const s of sources) {
+      if (existing[`${s}_sessions`]      == null) existing[`${s}_sessions`]      = 0;
+      if (existing[`${s}_cost`]          == null) existing[`${s}_cost`]          = 0;
+      if (existing[`${s}_activeMinutes`] == null) existing[`${s}_activeMinutes`] = 0;
+    }
+    filled.push(existing);
+  }
+
+  return { rows: filled, sources };
+}
+
+// ---------------------------------------------------------------------------
+// Router factory
+// ---------------------------------------------------------------------------
+
+/**
+ * @param {object} db  sql.js Database instance
+ * @returns {import('express').Router}
+ */
+/**
+ * Merge per-day rate rows into the pivoted trend rows in-place.
+ * This lets the front-end render any time-series metric (cost, sessions,
+ * tokens, hitRate, errorRate) from one flat array.
+ *
+ * Extra columns added per date row:
+ *   hitRate, cacheRead, cacheWrite
+ *   errorRate, errors, messages
+ *
+ * @param {Object[]} trendRows  output of pivotTrend (one row per date)
+ * @param {{cache: Object[], error: Object[]}} extras
+ * @returns {Object[]} same trendRows array, mutated and returned for chaining
+ */
+function mergeTimeseries(trendRows, extras) {
+  const byDate = new Map(trendRows.map((r) => [r.date, r]));
+
+  for (const c of extras.cache || []) {
+    const row = byDate.get(c.date);
+    if (!row) continue;
+    row.hitRate    = c.hitRate;
+    row.cacheRead  = c.cacheRead;
+    row.cacheWrite = c.cacheWrite;
+  }
+  for (const e of extras.error || []) {
+    const row = byDate.get(e.date);
+    if (!row) continue;
+    row.errorRate = e.rate;
+    row.errors    = e.errors;
+    row.messages  = e.messages;
+  }
+
+  // Ensure every column has a numeric default (so recharts doesn't drop
+  // points and tooltips don't render `undefined`).
+  for (const row of trendRows) {
+    if (row.hitRate    == null) row.hitRate    = 0;
+    if (row.errorRate  == null) row.errorRate  = 0;
+  }
+  return trendRows;
+}
+
+// ---------------------------------------------------------------------------
+// Date-range resolution
+// ---------------------------------------------------------------------------
+
+const PRESETS = { '7': 7, '14': 14, '30': 30, '90': 90 };
+const PRESET_LABEL = {
+  '7':   '本周',
+  '14':  '双周',
+  '30':  '本月',
+  '90':  '季度',
+  'all': '全部',
+};
+
+/**
+ * Translate the `days` query parameter into a concrete window.  Falls back
+ * to 14 days for unknown values.  For `all`, the lower bound is the
+ * earliest session date in boss.db (or today if the DB is empty).
+ *
+ * @param {string|undefined} raw   query string value
+ * @param {Object}           db    sql.js Database
+ * @returns {{ from: string, to: string, days: number|null, label: string }}
+ */
+function resolveRange(raw, db) {
+  const to = fmt(new Date());
+  if (raw === 'all') {
+    const from = getEarliestSessionDate(db) || to;
+    return { from, to, days: null, label: PRESET_LABEL.all };
+  }
+  const key = String(raw || '14');
+  const n = PRESETS[key] != null ? PRESETS[key] : 14;
+  return {
+    from:  daysAgo(n - 1),
+    to,
+    days:  n,
+    label: PRESET_LABEL[String(n)] || `${n} 天`,
+  };
+}
+
+// ---------------------------------------------------------------------------
+// Router
+// ---------------------------------------------------------------------------
+
+module.exports = function (db) {
+  // GET /api/overview?days=7|14|30|90|all
+  router.get('/', (req, res) => {
+    try {
+      const range = resolveRange(req.query.days, db);
+      const { from, to } = range;
+
+      const trendRows      = getOverviewTrend(db, from, to);
+      // Pull a larger candidate pool than the final top-N so that
+      // collapsing duplicate paths (see canonicalProject) still leaves
+      // enough rows to fill the requested limit.
+      const TOP_N          = 8;
+      const topProjectsRaw = getOverviewTopProjects(db, from, to, 40);
+      const recentSessions = getOverviewRecentSessions(db, 10);
+      const cacheRateRows  = getOverviewCacheRate(db, from, to);
+      const errorRateRows  = getOverviewErrorRate(db, from, to);
+      const topTools       = getOverviewTopTools(db, from, to, 10);
+
+      // v2 capability radar — averaged across all analysed sessions in the
+      // window (H1/H2/E1/E2/O1) plus H3 from the rolling aggregator.
+      // Returns nulls when no sessions in the window have been analysed yet;
+      // the front-end shows an empty-state in that case.
+      let capabilityRadar = null;
+      try {
+        capabilityRadar = getCurrentDimensionsV2(db, from, to);
+      } catch (e) {
+        // Don't fail the whole overview if analysis tables are missing.
+        capabilityRadar = null;
+      }
+
+      const trend = pivotTrend(trendRows, from, to);
+      const timeseries = mergeTimeseries(trend.rows, {
+        cache: cacheRateRows,
+        error: errorRateRows,
+      });
+
+      res.json({
+        ok: true,
+        data: {
+          range,
+          trend: {
+            from,
+            to,
+            sources: trend.sources,
+            rows: timeseries,
+          },
+          topProjects:    mapTopProjects(topProjectsRaw, TOP_N),
+          recentSessions: mapRecentSessions(recentSessions),
+          topTools,
+          capabilityRadar,
+        },
+        meta: {
+          generated_at: new Date().toISOString(),
+        },
+      });
+    } catch (err) {
+      res.status(500).json({
+        ok: false,
+        error: { code: 'OVERVIEW_ERROR', message: err.message },
+      });
+    }
+  });
+
+  return router;
+};