@klars/agentobs 0.1.0 → 0.1.2

package/dist/core/queries.js

@@ -15,20 +15,45 @@ export function rangeStart(range) {
             return null;
     }
 }
+/**
+ * Totals for an explicit window. Used for the previous-period comparison;
+ * `getSummary` handles the current window itself.
+ */
+function periodTotals(db, from, to) {
+    const calls = db
+        .prepare(`SELECT COUNT(*) AS tool_calls,
+              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+              SUM(cost_usd) AS total_cost_usd
+         FROM tool_calls
+        WHERE started_at >= ? AND started_at < ?`)
+        .get(from, to);
+    const sessions = db
+        .prepare('SELECT COUNT(*) AS n FROM sessions WHERE started_at >= ? AND started_at < ?')
+        .get(from, to);
+    const toolCalls = Number(calls.tool_calls ?? 0);
+    const errors = Number(calls.errors ?? 0);
+    return {
+        total_cost_usd: calls.total_cost_usd === null ? null : Number(calls.total_cost_usd),
+        tool_calls: toolCalls,
+        sessions: Number(sessions.n ?? 0),
+        errors,
+        error_rate: toolCalls === 0 ? 0 : errors / toolCalls,
+    };
+}
 export function getSummary(db, range) {
     const since = rangeStart(range);
     const where = since ? 'WHERE started_at >= ?' : '';
     const args = since ? [since] : [];
     const calls = db
-        .prepare(`SELECT
-         COUNT(*) AS tool_calls,
-         COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
-         COALESCE(SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END), 0) AS blocked,
-         COALESCE(SUM(tokens_in), 0) AS tokens_in,
-         COALESCE(SUM(tokens_out), 0) AS tokens_out,
-         SUM(cost_usd) AS total_cost_usd,
-         COALESCE(SUM(CASE WHEN cost_usd IS NULL AND status <> 'pending' THEN 1 ELSE 0 END), 0) AS uncosted_calls,
-         AVG(duration_ms) AS avg_duration_ms
+        .prepare(`SELECT
+         COUNT(*) AS tool_calls,
+         COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+         COALESCE(SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END), 0) AS blocked,
+         COALESCE(SUM(tokens_in), 0) AS tokens_in,
+         COALESCE(SUM(tokens_out), 0) AS tokens_out,
+         SUM(cost_usd) AS total_cost_usd,
+         COALESCE(SUM(CASE WHEN cost_usd IS NULL AND status <> 'pending' THEN 1 ELSE 0 END), 0) AS uncosted_calls,
+         AVG(duration_ms) AS avg_duration_ms
        FROM tool_calls ${where}`)
         .get(...args);
     const sessions = db.prepare(`SELECT COUNT(*) AS n FROM sessions ${where}`).get(...args);
@@ -47,8 +72,20 @@ export function getSummary(db, range) {
         tokens_in: Number(calls.tokens_in ?? 0),
         tokens_out: Number(calls.tokens_out ?? 0),
         avg_duration_ms: calls.avg_duration_ms === null ? null : Number(calls.avg_duration_ms),
+        previous: previousPeriod(db, range, since),
     };
 }
+/**
+ * Totals for the window immediately before the current one, of equal length.
+ * Returns null for 'all', where there is no previous period to compare to.
+ */
+function previousPeriod(db, range, since) {
+    if (!since)
+        return null;
+    const start = Date.parse(since);
+    const spanMs = range === 'today' ? 864e5 : range === '7d' ? 7 * 864e5 : 30 * 864e5;
+    return periodTotals(db, new Date(start - spanMs).toISOString(), since);
+}
 /**
  * Activity/cost over time. Buckets hourly for `today` and daily otherwise so
  * the chart keeps a readable number of points at every range.
@@ -59,29 +96,67 @@ export function getTimeline(db, range) {
     const where = since ? 'WHERE started_at >= ?' : '';
     const args = since ? [since] : [];
     return db
-        .prepare(`SELECT strftime(?, started_at) AS bucket,
-              COUNT(*) AS calls,
-              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
-              SUM(cost_usd) AS cost_usd,
-              COALESCE(SUM(COALESCE(tokens_in, 0) + COALESCE(tokens_out, 0)), 0) AS tokens
-         FROM tool_calls ${where}
-        GROUP BY bucket
+        .prepare(`SELECT strftime(?, started_at) AS bucket,
+              COUNT(*) AS calls,
+              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+              SUM(cost_usd) AS cost_usd,
+              COALESCE(SUM(COALESCE(tokens_in, 0) + COALESCE(tokens_out, 0)), 0) AS tokens
+         FROM tool_calls ${where}
+        GROUP BY bucket
         ORDER BY bucket ASC`)
         .all(fmt, ...args);
 }
+/**
+ * Compact per-bucket series for the stat-tile sparklines.
+ *
+ * Returns a fixed 12 buckets (the stat-tile contract's trend length),
+ * zero-filled so a quiet day renders as a gap in the line rather than
+ * silently shortening the series and misstating the shape.
+ */
+export function getSparklines(db, range) {
+    const POINTS = 12;
+    const spanMs = range === 'today' ? 864e5 : range === '7d' ? 7 * 864e5 : 30 * 864e5;
+    const end = Date.now();
+    const start = range === 'all' ? null : end - spanMs;
+    const bucketMs = (start ? spanMs : 30 * 864e5) / POINTS;
+    const origin = start ?? end - 30 * 864e5;
+    const rows = db
+        .prepare(`SELECT started_at, status, cost_usd, session_id
+         FROM tool_calls
+        WHERE started_at >= ?`)
+        .all(new Date(origin).toISOString());
+    const calls = new Array(POINTS).fill(0);
+    const cost = new Array(POINTS).fill(0);
+    const errors = new Array(POINTS).fill(0);
+    const blocked = new Array(POINTS).fill(0);
+    const sessionSets = Array.from({ length: POINTS }, () => new Set());
+    for (const row of rows) {
+        const i = Math.min(POINTS - 1, Math.floor((Date.parse(row.started_at) - origin) / bucketMs));
+        if (i < 0)
+            continue;
+        calls[i] += 1;
+        cost[i] += row.cost_usd ?? 0;
+        if (row.status === 'error')
+            errors[i] += 1;
+        if (row.status === 'blocked')
+            blocked[i] += 1;
+        sessionSets[i].add(row.session_id);
+    }
+    return { calls, cost, errors, blocked, sessions: sessionSets.map((s) => s.size) };
+}
 export function getToolsBreakdown(db, range) {
     const since = rangeStart(range);
     const where = since ? 'WHERE started_at >= ?' : '';
     const args = since ? [since] : [];
     return db
-        .prepare(`SELECT tool_name,
-              COUNT(*) AS calls,
-              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
-              COALESCE(SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END), 0) AS blocked,
-              SUM(cost_usd) AS cost_usd,
-              AVG(duration_ms) AS avg_duration_ms
-         FROM tool_calls ${where}
-        GROUP BY tool_name
+        .prepare(`SELECT tool_name,
+              COUNT(*) AS calls,
+              COALESCE(SUM(CASE WHEN status = 'error' THEN 1 ELSE 0 END), 0) AS errors,
+              COALESCE(SUM(CASE WHEN status = 'blocked' THEN 1 ELSE 0 END), 0) AS blocked,
+              SUM(cost_usd) AS cost_usd,
+              AVG(duration_ms) AS avg_duration_ms
+         FROM tool_calls ${where}
+        GROUP BY tool_name
         ORDER BY calls DESC`)
         .all(...args);
 }
@@ -104,16 +179,16 @@ export function getRecentToolCalls(db, opts = {}) {
     }
     const where = clauses.length ? `WHERE ${clauses.join(' AND ')}` : '';
     return db
-        .prepare(`SELECT tc.id, tc.session_id, s.agent_name, tc.tool_name, tc.started_at,
-              tc.duration_ms, tc.status, tc.input_summary, tc.output_summary,
-              tc.cost_usd, tc.error_message,
-              (SELECT pd.rule_matched FROM policy_decisions pd
-                WHERE pd.tool_call_id = tc.id
-                ORDER BY pd.decided_at DESC LIMIT 1) AS rule_matched
-         FROM tool_calls tc
-         LEFT JOIN sessions s ON s.id = tc.session_id
-         ${where}
-        ORDER BY tc.started_at DESC
+        .prepare(`SELECT tc.id, tc.session_id, s.agent_name, tc.tool_name, tc.started_at,
+              tc.duration_ms, tc.status, tc.input_summary, tc.output_summary,
+              tc.cost_usd, tc.error_message,
+              (SELECT pd.rule_matched FROM policy_decisions pd
+                WHERE pd.tool_call_id = tc.id
+                ORDER BY pd.decided_at DESC LIMIT 1) AS rule_matched
+         FROM tool_calls tc
+         LEFT JOIN sessions s ON s.id = tc.session_id
+         ${where}
+        ORDER BY tc.started_at DESC
         LIMIT ?`)
         .all(...args, limit);
 }
@@ -123,20 +198,20 @@ export function getSessions(db, opts = {}) {
     const where = since ? 'WHERE started_at >= ?' : '';
     const args = since ? [since] : [];
     return db
-        .prepare(`SELECT id, agent_name, started_at, ended_at, cwd, fidelity, tool_call_count,
-              error_count, blocked_count, total_cost_usd, total_tokens_in,
-              total_tokens_out, exit_code
-         FROM sessions ${where}
-        ORDER BY started_at DESC
+        .prepare(`SELECT id, agent_name, started_at, ended_at, cwd, fidelity, tool_call_count,
+              error_count, blocked_count, total_cost_usd, total_tokens_in,
+              total_tokens_out, exit_code
+         FROM sessions ${where}
+        ORDER BY started_at DESC
         LIMIT ?`)
         .all(...args, limit);
 }
 export function getPolicyDecisions(db, opts = {}) {
     const limit = Math.min(Math.max(opts.limit ?? 100, 1), 500);
     return db
-        .prepare(`SELECT id, tool_call_id, session_id, tool_name, rule_matched, decision, reason, decided_at
-         FROM policy_decisions
-        ORDER BY decided_at DESC
+        .prepare(`SELECT id, tool_call_id, session_id, tool_name, rule_matched, decision, reason, decided_at
+         FROM policy_decisions
+        ORDER BY decided_at DESC
         LIMIT ?`)
         .all(limit);
 }

package/dist/server/index.js

@@ -18,7 +18,7 @@ import { dirname, extname, join, normalize } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { timingSafeEqual } from 'node:crypto';
 import { openDb } from '../core/db.js';
-import { getPolicyDecisions, getRecentToolCalls, getSessions, getSummary, getTimeline, getToolsBreakdown, } from '../core/queries.js';
+import { getPolicyDecisions, getRecentToolCalls, getSessions, getSparklines, getSummary, getTimeline, getToolsBreakdown, } from '../core/queries.js';
 import { loadPolicy } from '../core/policy-engine.js';
 const PUBLIC_DIR = join(dirname(fileURLToPath(import.meta.url)), 'public');
 const MIME = {
@@ -86,7 +86,9 @@ export function createDashboardServer(opts) {
             const range = parseRange(url.searchParams.get('range'));
             switch (url.pathname) {
                 case '/api/summary':
-                    json(res, getSummary(db, range));
+                    // Sparklines ride along with the summary: the tiles need both, and
+                    // one request keeps the 5s poll to a single round trip.
+                    json(res, { ...getSummary(db, range), sparklines: getSparklines(db, range) });
                     return;
                 case '/api/timeline':
                     json(res, getTimeline(db, range));