@hasna/logs 0.0.1 → 0.2.0

package/sdk/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@hasna/logs-sdk",
-  "version": "0.0.1",
-  "description": "Zero-dependency fetch client for @hasna/logs",
+  "version": "0.1.0",
+  "description": "Zero-dependency fetch client for @hasna/logs — push logs, query, browse issues, perf snapshots",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -16,6 +16,7 @@
   "scripts": {
     "build": "bun build src/index.ts --outdir dist --target browser"
   },
+  "keywords": ["logs", "monitoring", "sdk", "ai-agents"],
   "author": "Andrei Hasna <andrei@hasna.com>",
   "license": "MIT"
 }

package/sdk/src/index.ts

@@ -1,4 +1,4 @@
-import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "../../src/types/index.ts"
+import type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob } from "./types.ts"
 
 export type { LogEntry, LogLevel, LogQuery, LogRow, LogSummary, Page, PerformanceSnapshot, Project, ScanJob }
 

package/sdk/src/types.ts

@@ -0,0 +1,56 @@
+export type LogLevel = "debug" | "info" | "warn" | "error" | "fatal"
+export type LogSource = "sdk" | "script" | "scanner"
+
+export interface LogEntry {
+  level: LogLevel
+  message: string
+  project_id?: string
+  page_id?: string
+  source?: LogSource
+  service?: string
+  trace_id?: string
+  session_id?: string
+  agent?: string
+  url?: string
+  stack_trace?: string
+  metadata?: Record<string, unknown>
+}
+
+export interface LogRow {
+  id: string; timestamp: string; project_id: string | null; page_id: string | null
+  level: LogLevel; source: LogSource; service: string | null; message: string
+  trace_id: string | null; session_id: string | null; agent: string | null
+  url: string | null; stack_trace: string | null; metadata: string | null
+}
+
+export interface Project {
+  id: string; name: string; github_repo: string | null; base_url: string | null
+  description: string | null; created_at: string
+}
+
+export interface Page {
+  id: string; project_id: string; url: string; path: string
+  name: string | null; last_scanned_at: string | null; created_at: string
+}
+
+export interface ScanJob {
+  id: string; project_id: string; page_id: string | null
+  schedule: string; enabled: number; last_run_at: string | null; created_at: string
+}
+
+export interface PerformanceSnapshot {
+  id: string; timestamp: string; project_id: string; page_id: string | null
+  url: string; lcp: number | null; fcp: number | null; cls: number | null
+  tti: number | null; ttfb: number | null; score: number | null; raw_audit: string | null
+}
+
+export interface LogQuery {
+  project_id?: string; page_id?: string; level?: LogLevel | LogLevel[]
+  service?: string; since?: string; until?: string; text?: string
+  trace_id?: string; limit?: number; offset?: number; fields?: string[]
+}
+
+export interface LogSummary {
+  project_id: string | null; service: string | null; page_id: string | null
+  level: LogLevel; count: number; latest: string
+}

package/src/cli/index.ts

@@ -151,6 +151,102 @@ program.command("scan")
     console.log("Scan complete.")
   })
 
+// ── logs watch ────────────────────────────────────────────
+program.command("watch")
+  .description("Stream new logs in real time with color coding")
+  .option("--project <id>")
+  .option("--level <levels>", "Comma-separated levels")
+  .option("--service <name>")
+  .action(async (opts) => {
+    const db = getDb()
+    const { searchLogs } = await import("../lib/query.ts")
+
+    const COLORS: Record<string, string> = {
+      debug: "\x1b[90m", info: "\x1b[36m", warn: "\x1b[33m", error: "\x1b[31m", fatal: "\x1b[35m",
+    }
+    const RESET = "\x1b[0m"
+    const BOLD = "\x1b[1m"
+
+    let lastTimestamp = new Date().toISOString()
+    let errorCount = 0
+    let warnCount = 0
+
+    process.stdout.write(`\x1b[2J\x1b[H`) // clear screen
+    console.log(`${BOLD}@hasna/logs watch${RESET} — Ctrl+C to exit\n`)
+
+    const poll = () => {
+      const rows = searchLogs(db, {
+        project_id: opts.project,
+        level: opts.level ? (opts.level.split(",") as LogLevel[]) : undefined,
+        service: opts.service,
+        since: lastTimestamp,
+        limit: 100,
+      }).reverse()
+
+      for (const row of rows) {
+        if (row.timestamp <= lastTimestamp) continue
+        lastTimestamp = row.timestamp
+        if (row.level === "error" || row.level === "fatal") errorCount++
+        if (row.level === "warn") warnCount++
+        const color = COLORS[row.level] ?? ""
+        const ts = row.timestamp.slice(11, 19)
+        const svc = (row.service ?? "-").padEnd(12)
+        const lvl = row.level.toUpperCase().padEnd(5)
+        console.log(`${color}${ts}  ${BOLD}${lvl}${RESET}${color}  ${svc}  ${row.message}${RESET}`)
+      }
+
+      // Update terminal title with counts
+      process.stdout.write(`\x1b]2;logs: ${errorCount}E ${warnCount}W\x07`)
+    }
+
+    const interval = setInterval(poll, 500)
+    process.on("SIGINT", () => { clearInterval(interval); console.log(`\n\nErrors: ${errorCount}  Warnings: ${warnCount}`); process.exit(0) })
+  })
+
+// ── logs export ───────────────────────────────────────────
+program.command("export")
+  .description("Export logs to JSON or CSV")
+  .option("--project <id>")
+  .option("--since <time>", "Relative time or ISO")
+  .option("--level <level>")
+  .option("--service <name>")
+  .option("--format <fmt>", "json or csv", "json")
+  .option("--output <file>", "Output file (default: stdout)")
+  .option("--limit <n>", "Max rows", "100000")
+  .action(async (opts) => {
+    const { exportToCsv, exportToJson } = await import("../lib/export.ts")
+    const { createWriteStream } = await import("node:fs")
+    const db = getDb()
+    const options = {
+      project_id: opts.project,
+      since: parseRelativeTime(opts.since),
+      level: opts.level,
+      service: opts.service,
+      limit: Number(opts.limit),
+    }
+    let count = 0
+    if (opts.output) {
+      const stream = createWriteStream(opts.output)
+      const write = (s: string) => stream.write(s)
+      count = opts.format === "csv" ? exportToCsv(db, options, write) : exportToJson(db, options, write)
+      stream.end()
+      console.error(`Exported ${count} log(s) to ${opts.output}`)
+    } else {
+      const write = (s: string) => process.stdout.write(s)
+      count = opts.format === "csv" ? exportToCsv(db, options, write) : exportToJson(db, options, write)
+      process.stderr.write(`\nExported ${count} log(s)\n`)
+    }
+  })
+
+// ── logs health ───────────────────────────────────────────
+program.command("health")
+  .description("Show server health and DB stats")
+  .action(async () => {
+    const { getHealth } = await import("../lib/health.ts")
+    const h = getHealth(getDb())
+    console.log(JSON.stringify(h, null, 2))
+  })
+
 // ── logs mcp / logs serve ─────────────────────────────────
 program.command("mcp")
   .description("Start the MCP server")
@@ -159,11 +255,25 @@ program.command("mcp")
   .option("--gemini", "Install into Gemini")
   .action(async (opts) => {
     if (opts.claude || opts.codex || opts.gemini) {
-      const bin = process.execPath
-      const script = new URL(import.meta.url).pathname
+      const { execSync } = await import("node:child_process")
+      // Resolve the MCP binary path — works from both source and dist
+      const selfPath = process.argv[1] ?? new URL(import.meta.url).pathname
+      const mcpBin = selfPath.replace(/cli\/index\.(ts|js)$/, "mcp/index.$1")
+      const runtime = process.execPath  // bun or node
+
       if (opts.claude) {
-        const { execSync } = await import("node:child_process")
-        execSync(`claude mcp add --transport stdio --scope user logs -- ${bin} ${script} mcp`, { stdio: "inherit" })
+        const cmd = `claude mcp add --transport stdio --scope user logs -- ${runtime} ${mcpBin}`
+        console.log(`Running: ${cmd}`)
+        execSync(cmd, { stdio: "inherit" })
+        console.log("✓ Installed logs-mcp into Claude Code")
+      }
+      if (opts.codex) {
+        const config = `[mcp_servers.logs]\ncommand = "${runtime}"\nargs = ["${mcpBin}"]`
+        console.log("Add to ~/.codex/config.toml:\n\n" + config)
+      }
+      if (opts.gemini) {
+        const config = JSON.stringify({ mcpServers: { logs: { command: runtime, args: [mcpBin] } } }, null, 2)
+        console.log("Add to ~/.gemini/settings.json mcpServers:\n\n" + config)
       }
       return
     }

package/src/db/index.ts

@@ -1,6 +1,10 @@
 import { Database } from "bun:sqlite"
 import { join } from "node:path"
 import { existsSync, mkdirSync } from "node:fs"
+import { migrateAlertRules } from "./migrations/001_alert_rules.ts"
+import { migrateIssues } from "./migrations/002_issues.ts"
+import { migrateRetention } from "./migrations/003_retention.ts"
+import { migratePageAuth } from "./migrations/004_page_auth.ts"
 
 const DATA_DIR = process.env.LOGS_DATA_DIR ?? join(process.env.HOME ?? "~", ".logs")
 const DB_PATH = process.env.LOGS_DB_PATH ?? join(DATA_DIR, "logs.db")
@@ -150,4 +154,10 @@ function migrate(db: Database): void {
 
   db.run(`CREATE INDEX IF NOT EXISTS idx_perf_project_ts ON performance_snapshots(project_id, timestamp DESC)`)
   db.run(`CREATE INDEX IF NOT EXISTS idx_perf_page ON performance_snapshots(page_id)`)
+
+  // QoL migrations
+  migrateAlertRules(db)
+  migrateIssues(db)
+  migrateRetention(db)
+  migratePageAuth(db)
 }

package/src/db/migrations/001_alert_rules.ts

@@ -0,0 +1,21 @@
+import type { Database } from "bun:sqlite"
+
+export function migrateAlertRules(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS alert_rules (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      project_id TEXT NOT NULL REFERENCES projects(id) ON DELETE CASCADE,
+      name TEXT NOT NULL,
+      service TEXT,
+      level TEXT NOT NULL DEFAULT 'error' CHECK(level IN ('debug','info','warn','error','fatal')),
+      threshold_count INTEGER NOT NULL DEFAULT 10,
+      window_seconds INTEGER NOT NULL DEFAULT 60,
+      action TEXT NOT NULL DEFAULT 'webhook' CHECK(action IN ('webhook','log')),
+      webhook_url TEXT,
+      enabled INTEGER NOT NULL DEFAULT 1,
+      last_fired_at TEXT,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    )
+  `)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_alert_rules_project ON alert_rules(project_id)`)
+}

package/src/db/migrations/002_issues.ts

@@ -0,0 +1,21 @@
+import type { Database } from "bun:sqlite"
+
+export function migrateIssues(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS issues (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      project_id TEXT REFERENCES projects(id) ON DELETE CASCADE,
+      fingerprint TEXT NOT NULL,
+      level TEXT NOT NULL,
+      service TEXT,
+      message_template TEXT NOT NULL,
+      first_seen TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      last_seen TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now')),
+      count INTEGER NOT NULL DEFAULT 1,
+      status TEXT NOT NULL DEFAULT 'open' CHECK(status IN ('open','resolved','ignored')),
+      UNIQUE(project_id, fingerprint)
+    )
+  `)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_issues_project ON issues(project_id, status)`)
+  db.run(`CREATE INDEX IF NOT EXISTS idx_issues_fingerprint ON issues(fingerprint)`)
+}

package/src/db/migrations/003_retention.ts

@@ -0,0 +1,15 @@
+import type { Database } from "bun:sqlite"
+
+const RETENTION_COLUMNS = [
+  "max_rows INTEGER NOT NULL DEFAULT 100000",
+  "debug_ttl_hours INTEGER NOT NULL DEFAULT 24",
+  "info_ttl_hours INTEGER NOT NULL DEFAULT 168",
+  "warn_ttl_hours INTEGER NOT NULL DEFAULT 720",
+  "error_ttl_hours INTEGER NOT NULL DEFAULT 2160",
+]
+
+export function migrateRetention(db: Database): void {
+  for (const col of RETENTION_COLUMNS) {
+    try { db.run(`ALTER TABLE projects ADD COLUMN ${col}`) } catch { /* already exists */ }
+  }
+}

package/src/db/migrations/004_page_auth.ts

@@ -0,0 +1,13 @@
+import type { Database } from "bun:sqlite"
+
+export function migratePageAuth(db: Database): void {
+  db.run(`
+    CREATE TABLE IF NOT EXISTS page_auth (
+      id TEXT PRIMARY KEY DEFAULT (lower(hex(randomblob(8)))),
+      page_id TEXT NOT NULL UNIQUE REFERENCES pages(id) ON DELETE CASCADE,
+      type TEXT NOT NULL CHECK(type IN ('cookie','bearer','basic')),
+      credentials TEXT NOT NULL,
+      created_at TEXT NOT NULL DEFAULT (strftime('%Y-%m-%dT%H:%M:%fZ','now'))
+    )
+  `)
+}

package/src/lib/alerts.test.ts

@@ -0,0 +1,67 @@
+import { describe, expect, it, mock } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { createAlertRule, deleteAlertRule, evaluateAlerts, listAlertRules, updateAlertRule } from "./alerts.ts"
+import { ingestBatch } from "./ingest.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+}
+
+describe("alert rules CRUD", () => {
+  it("creates an alert rule", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const rule = createAlertRule(db, { project_id: p.id, name: "High errors", level: "error", threshold_count: 5, window_seconds: 60 })
+    expect(rule.id).toBeTruthy()
+    expect(rule.name).toBe("High errors")
+    expect(rule.threshold_count).toBe(5)
+    expect(rule.enabled).toBe(1)
+  })
+
+  it("lists rules for a project", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createAlertRule(db, { project_id: p.id, name: "r1" })
+    createAlertRule(db, { project_id: p.id, name: "r2" })
+    expect(listAlertRules(db, p.id)).toHaveLength(2)
+  })
+
+  it("updates a rule", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const rule = createAlertRule(db, { project_id: p.id, name: "r1" })
+    const updated = updateAlertRule(db, rule.id, { enabled: 0, threshold_count: 99 })
+    expect(updated?.enabled).toBe(0)
+    expect(updated?.threshold_count).toBe(99)
+  })
+
+  it("deletes a rule", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const rule = createAlertRule(db, { project_id: p.id, name: "r1" })
+    deleteAlertRule(db, rule.id)
+    expect(listAlertRules(db, p.id)).toHaveLength(0)
+  })
+})
+
+describe("alert evaluation", () => {
+  it("does not fire when under threshold", async () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createAlertRule(db, { project_id: p.id, name: "r", level: "error", threshold_count: 10, window_seconds: 60, action: "log" })
+    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "error" as const, message: "e", project_id: p.id })))
+    // No throw = passes
+    await expect(evaluateAlerts(db, p.id, null, "error")).resolves.toBeUndefined()
+  })
+
+  it("fires when threshold exceeded (log action)", async () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createAlertRule(db, { project_id: p.id, name: "r", level: "error", threshold_count: 3, window_seconds: 3600, action: "log" })
+    ingestBatch(db, Array.from({ length: 5 }, () => ({ level: "error" as const, message: "e", project_id: p.id })))
+    await expect(evaluateAlerts(db, p.id, null, "error")).resolves.toBeUndefined()
+    // Verify last_fired_at was set
+    const rule = db.prepare("SELECT last_fired_at FROM alert_rules WHERE project_id = ?").get(p.id) as { last_fired_at: string | null }
+    expect(rule.last_fired_at).toBeTruthy()
+  })
+})

package/src/lib/alerts.ts

@@ -0,0 +1,117 @@
+import type { Database } from "bun:sqlite"
+
+export interface AlertRule {
+  id: string
+  project_id: string
+  name: string
+  service: string | null
+  level: string
+  threshold_count: number
+  window_seconds: number
+  action: "webhook" | "log"
+  webhook_url: string | null
+  enabled: number
+  last_fired_at: string | null
+  created_at: string
+}
+
+export function createAlertRule(db: Database, data: {
+  project_id: string
+  name: string
+  service?: string
+  level?: string
+  threshold_count?: number
+  window_seconds?: number
+  action?: "webhook" | "log"
+  webhook_url?: string
+}): AlertRule {
+  return db.prepare(`
+    INSERT INTO alert_rules (project_id, name, service, level, threshold_count, window_seconds, action, webhook_url)
+    VALUES ($project_id, $name, $service, $level, $threshold_count, $window_seconds, $action, $webhook_url)
+    RETURNING *
+  `).get({
+    $project_id: data.project_id,
+    $name: data.name,
+    $service: data.service ?? null,
+    $level: data.level ?? "error",
+    $threshold_count: data.threshold_count ?? 10,
+    $window_seconds: data.window_seconds ?? 60,
+    $action: data.action ?? "webhook",
+    $webhook_url: data.webhook_url ?? null,
+  }) as AlertRule
+}
+
+export function listAlertRules(db: Database, projectId?: string): AlertRule[] {
+  if (projectId) {
+    return db.prepare("SELECT * FROM alert_rules WHERE project_id = $p ORDER BY created_at DESC").all({ $p: projectId }) as AlertRule[]
+  }
+  return db.prepare("SELECT * FROM alert_rules ORDER BY created_at DESC").all() as AlertRule[]
+}
+
+export function updateAlertRule(db: Database, id: string, data: Partial<Pick<AlertRule, "enabled" | "threshold_count" | "window_seconds" | "webhook_url">>): AlertRule | null {
+  const fields = Object.keys(data).map(k => `${k} = $${k}`).join(", ")
+  if (!fields) return db.prepare("SELECT * FROM alert_rules WHERE id = $id").get({ $id: id }) as AlertRule | null
+  const params = Object.fromEntries(Object.entries(data).map(([k, v]) => [`$${k}`, v]))
+  params.$id = id
+  return db.prepare(`UPDATE alert_rules SET ${fields} WHERE id = $id RETURNING *`).get(params) as AlertRule | null
+}
+
+export function deleteAlertRule(db: Database, id: string): void {
+  db.run("DELETE FROM alert_rules WHERE id = $id", { $id: id })
+}
+
+export async function evaluateAlerts(db: Database, projectId: string, service: string | null, level: string): Promise<void> {
+  const rules = db.prepare(`
+    SELECT * FROM alert_rules
+    WHERE project_id = $p AND level = $level AND enabled = 1
+    AND ($service IS NULL OR service IS NULL OR service = $service)
+  `).all({ $p: projectId, $level: level, $service: service }) as AlertRule[]
+
+  for (const rule of rules) {
+    const since = new Date(Date.now() - rule.window_seconds * 1000).toISOString()
+    const conditions = ["project_id = $p", "level = $level", "timestamp >= $since"]
+    const params: Record<string, unknown> = { $p: projectId, $level: rule.level, $since: since }
+    if (rule.service) { conditions.push("service = $service"); params.$service = rule.service }
+
+    const { count } = db.prepare(`SELECT COUNT(*) as count FROM logs WHERE ${conditions.join(" AND ")}`).get(params) as { count: number }
+
+    if (count >= rule.threshold_count) {
+      await fireAlert(db, rule, count)
+    }
+  }
+}
+
+async function fireAlert(db: Database, rule: AlertRule, count: number): Promise<void> {
+  // Debounce: don't fire more than once per window
+  if (rule.last_fired_at) {
+    const lastFired = new Date(rule.last_fired_at).getTime()
+    if (Date.now() - lastFired < rule.window_seconds * 1000) return
+  }
+
+  db.run("UPDATE alert_rules SET last_fired_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') WHERE id = $id", { $id: rule.id })
+
+  const payload = {
+    alert: rule.name,
+    project_id: rule.project_id,
+    level: rule.level,
+    service: rule.service,
+    count,
+    threshold: rule.threshold_count,
+    window_seconds: rule.window_seconds,
+    fired_at: new Date().toISOString(),
+  }
+
+  if (rule.action === "webhook" && rule.webhook_url) {
+    try {
+      await fetch(rule.webhook_url, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify(payload),
+      })
+    } catch (err) {
+      console.error(`Alert webhook failed for rule ${rule.id}:`, err)
+    }
+  } else {
+    console.warn(`[ALERT] ${rule.name}:`, JSON.stringify(payload))
+  }
+}

package/src/lib/compare.test.ts

@@ -0,0 +1,52 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { compare } from "./compare.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+}
+
+describe("compare", () => {
+  it("detects new errors in window B", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const dayAgo = new Date(Date.now() - 48 * 3600 * 1000).toISOString()
+    const halfDayAgo = new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+    const now = new Date().toISOString()
+
+    // Window A: old error
+    db.prepare("INSERT INTO logs (project_id, level, message, service, timestamp) VALUES (?, 'error', 'old bug', 'api', ?)").run(p.id, dayAgo)
+    // Window B: new error
+    db.prepare("INSERT INTO logs (project_id, level, message, service, timestamp) VALUES (?, 'error', 'new bug', 'api', ?)").run(p.id, now)
+
+    const result = compare(db, p.id, dayAgo, halfDayAgo, halfDayAgo, now)
+    expect(result.new_errors.some(e => e.message === "new bug")).toBe(true)
+    expect(result.resolved_errors.some(e => e.message === "old bug")).toBe(true)
+  })
+
+  it("returns empty diff when no changes", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const since = new Date(Date.now() - 48 * 3600 * 1000).toISOString()
+    const mid = new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+    const now = new Date().toISOString()
+    const result = compare(db, p.id, since, mid, mid, now)
+    expect(result.new_errors).toHaveLength(0)
+    expect(result.resolved_errors).toHaveLength(0)
+  })
+
+  it("has correct structure", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const since = new Date(Date.now() - 48 * 3600 * 1000).toISOString()
+    const mid = new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+    const now = new Date().toISOString()
+    const result = compare(db, p.id, since, mid, mid, now)
+    expect(result).toHaveProperty("project_id")
+    expect(result).toHaveProperty("new_errors")
+    expect(result).toHaveProperty("resolved_errors")
+    expect(result).toHaveProperty("error_delta_by_service")
+    expect(result).toHaveProperty("summary")
+  })
+})

package/src/lib/compare.ts

@@ -0,0 +1,85 @@
+import type { Database } from "bun:sqlite"
+
+export interface CompareResult {
+  project_id: string
+  window_a: { since: string; until: string }
+  window_b: { since: string; until: string }
+  new_errors: { message: string; service: string | null; count: number }[]
+  resolved_errors: { message: string; service: string | null; count: number }[]
+  error_delta_by_service: { service: string | null; errors_a: number; errors_b: number; delta: number }[]
+  perf_delta_by_page: { page_id: string; url: string; score_a: number | null; score_b: number | null; delta: number | null }[]
+  summary: string
+}
+
+function getErrorsByMessage(db: Database, projectId: string, since: string, until: string) {
+  return db.prepare(`
+    SELECT message, service, COUNT(*) as count
+    FROM logs
+    WHERE project_id = $p AND level IN ('error','fatal') AND timestamp >= $since AND timestamp <= $until
+    GROUP BY message, service
+  `).all({ $p: projectId, $since: since, $until: until }) as { message: string; service: string | null; count: number }[]
+}
+
+function getErrorsByService(db: Database, projectId: string, since: string, until: string) {
+  return db.prepare(`
+    SELECT service, COUNT(*) as errors
+    FROM logs
+    WHERE project_id = $p AND level IN ('error','fatal') AND timestamp >= $since AND timestamp <= $until
+    GROUP BY service
+  `).all({ $p: projectId, $since: since, $until: until }) as { service: string | null; errors: number }[]
+}
+
+export function compare(
+  db: Database,
+  projectId: string,
+  aSince: string, aUntil: string,
+  bSince: string, bUntil: string,
+): CompareResult {
+  const errorsA = getErrorsByMessage(db, projectId, aSince, aUntil)
+  const errorsB = getErrorsByMessage(db, projectId, bSince, bUntil)
+
+  const keyA = new Set(errorsA.map(e => `${e.service}|${e.message}`))
+  const keyB = new Set(errorsB.map(e => `${e.service}|${e.message}`))
+
+  const new_errors = errorsB.filter(e => !keyA.has(`${e.service}|${e.message}`))
+  const resolved_errors = errorsA.filter(e => !keyB.has(`${e.service}|${e.message}`))
+
+  // Service-level delta
+  const svcA = getErrorsByService(db, projectId, aSince, aUntil)
+  const svcB = getErrorsByService(db, projectId, bSince, bUntil)
+  const svcMapA = new Map(svcA.map(s => [s.service, s.errors]))
+  const svcMapB = new Map(svcB.map(s => [s.service, s.errors]))
+  const allSvcs = new Set([...svcMapA.keys(), ...svcMapB.keys()])
+  const error_delta_by_service = [...allSvcs].map(svc => ({
+    service: svc,
+    errors_a: svcMapA.get(svc) ?? 0,
+    errors_b: svcMapB.get(svc) ?? 0,
+    delta: (svcMapB.get(svc) ?? 0) - (svcMapA.get(svc) ?? 0),
+  })).sort((a, b) => Math.abs(b.delta) - Math.abs(a.delta))
+
+  // Perf delta per page
+  const perf_delta_by_page = db.prepare(`
+    SELECT
+      pa.page_id, pg.url,
+      pa.score as score_a,
+      pb.score as score_b,
+      (pb.score - pa.score) as delta
+    FROM
+      (SELECT page_id, AVG(score) as score FROM performance_snapshots WHERE project_id = $p AND timestamp >= $as AND timestamp <= $au GROUP BY page_id) pa
+      JOIN pages pg ON pg.id = pa.page_id
+      LEFT JOIN (SELECT page_id, AVG(score) as score FROM performance_snapshots WHERE project_id = $p AND timestamp >= $bs AND timestamp <= $bu GROUP BY page_id) pb ON pb.page_id = pa.page_id
+    ORDER BY delta ASC
+  `).all({ $p: projectId, $as: aSince, $au: aUntil, $bs: bSince, $bu: bUntil }) as CompareResult["perf_delta_by_page"]
+
+  const summary = [
+    `${new_errors.length} new error type(s), ${resolved_errors.length} resolved.`,
+    error_delta_by_service.filter(s => s.delta > 0).map(s => `${s.service ?? "unknown"}: +${s.delta}`).join(", ") || "No error increases.",
+  ].join(" ")
+
+  return {
+    project_id: projectId,
+    window_a: { since: aSince, until: aUntil },
+    window_b: { since: bSince, until: bUntil },
+    new_errors, resolved_errors, error_delta_by_service, perf_delta_by_page, summary,
+  }
+}