@hasna/logs 0.0.1

package/src/lib/github.ts

@@ -0,0 +1,38 @@
+import type { Database } from "bun:sqlite"
+import type { Project } from "../types/index.ts"
+import { updateProject } from "./projects.ts"
+
+interface GithubRepo {
+  description: string | null
+  default_branch: string
+  topics: string[]
+}
+
+interface GithubCommit {
+  sha: string
+}
+
+export async function syncGithubRepo(db: Database, project: Project): Promise<Project | null> {
+  if (!project.github_repo) return project
+  const repo = project.github_repo.replace(/^https?:\/\/github\.com\//, "")
+  const headers: Record<string, string> = { "Accept": "application/vnd.github.v3+json" }
+  if (process.env.GITHUB_TOKEN) headers["Authorization"] = `Bearer ${process.env.GITHUB_TOKEN}`
+
+  try {
+    const [repoRes, commitRes] = await Promise.all([
+      fetch(`https://api.github.com/repos/${repo}`, { headers }),
+      fetch(`https://api.github.com/repos/${repo}/commits?per_page=1`, { headers }),
+    ])
+    if (!repoRes.ok) return project
+    const repoData = await repoRes.json() as GithubRepo
+    const commits = commitRes.ok ? await commitRes.json() as GithubCommit[] : []
+    return updateProject(db, project.id, {
+      github_description: repoData.description,
+      github_branch: repoData.default_branch,
+      github_sha: commits[0]?.sha ?? null,
+      last_synced_at: new Date().toISOString(),
+    })
+  } catch {
+    return project
+  }
+}

package/src/lib/ingest.test.ts

@@ -0,0 +1,57 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch, ingestLog } from "./ingest.ts"
+
+describe("ingest", () => {
+  it("inserts a single log entry", () => {
+    const db = createTestDb()
+    const row = ingestLog(db, { level: "error", message: "test error", service: "api" })
+    expect(row.id).toBeTruthy()
+    expect(row.level).toBe("error")
+    expect(row.message).toBe("test error")
+    expect(row.service).toBe("api")
+    expect(row.source).toBe("sdk")
+    expect(row.timestamp).toBeTruthy()
+  })
+
+  it("inserts with all optional fields", () => {
+    const db = createTestDb()
+    const row = ingestLog(db, {
+      level: "info",
+      message: "hello",
+      source: "scanner",
+      trace_id: "trace-123",
+      session_id: "sess-456",
+      agent: "brutus",
+      url: "https://example.com",
+      stack_trace: "Error at line 1",
+      metadata: { foo: "bar" },
+    })
+    expect(row.trace_id).toBe("trace-123")
+    expect(row.agent).toBe("brutus")
+    expect(row.metadata).toBe(JSON.stringify({ foo: "bar" }))
+  })
+
+  it("inserts a batch", () => {
+    const db = createTestDb()
+    const rows = ingestBatch(db, [
+      { level: "warn", message: "warn 1" },
+      { level: "error", message: "err 1" },
+      { level: "info", message: "info 1" },
+    ])
+    expect(rows).toHaveLength(3)
+    expect(rows[0]!.level).toBe("warn")
+    expect(rows[2]!.level).toBe("info")
+  })
+
+  it("batch is transactional", () => {
+    const db = createTestDb()
+    const before = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
+    ingestBatch(db, [
+      { level: "debug", message: "a" },
+      { level: "fatal", message: "b" },
+    ])
+    const after = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
+    expect(after - before).toBe(2)
+  })
+})

package/src/lib/ingest.ts

@@ -0,0 +1,51 @@
+import type { Database } from "bun:sqlite"
+import type { LogEntry, LogRow } from "../types/index.ts"
+
+export function ingestLog(db: Database, entry: LogEntry): LogRow {
+  const stmt = db.prepare(`
+    INSERT INTO logs (project_id, page_id, level, source, service, message, trace_id, session_id, agent, url, stack_trace, metadata)
+    VALUES ($project_id, $page_id, $level, $source, $service, $message, $trace_id, $session_id, $agent, $url, $stack_trace, $metadata)
+    RETURNING *
+  `)
+  return stmt.get({
+    $project_id: entry.project_id ?? null,
+    $page_id: entry.page_id ?? null,
+    $level: entry.level,
+    $source: entry.source ?? "sdk",
+    $service: entry.service ?? null,
+    $message: entry.message,
+    $trace_id: entry.trace_id ?? null,
+    $session_id: entry.session_id ?? null,
+    $agent: entry.agent ?? null,
+    $url: entry.url ?? null,
+    $stack_trace: entry.stack_trace ?? null,
+    $metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
+  }) as LogRow
+}
+
+export function ingestBatch(db: Database, entries: LogEntry[]): LogRow[] {
+  const insert = db.prepare(`
+    INSERT INTO logs (project_id, page_id, level, source, service, message, trace_id, session_id, agent, url, stack_trace, metadata)
+    VALUES ($project_id, $page_id, $level, $source, $service, $message, $trace_id, $session_id, $agent, $url, $stack_trace, $metadata)
+    RETURNING *
+  `)
+  const tx = db.transaction((items: LogEntry[]) =>
+    items.map(entry =>
+      insert.get({
+        $project_id: entry.project_id ?? null,
+        $page_id: entry.page_id ?? null,
+        $level: entry.level,
+        $source: entry.source ?? "sdk",
+        $service: entry.service ?? null,
+        $message: entry.message,
+        $trace_id: entry.trace_id ?? null,
+        $session_id: entry.session_id ?? null,
+        $agent: entry.agent ?? null,
+        $url: entry.url ?? null,
+        $stack_trace: entry.stack_trace ?? null,
+        $metadata: entry.metadata ? JSON.stringify(entry.metadata) : null,
+      }) as LogRow
+    )
+  )
+  return tx(entries)
+}

package/src/lib/jobs.test.ts

@@ -0,0 +1,69 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { createJob, createScanRun, deleteJob, finishScanRun, listJobs, listScanRuns, updateJob } from "./jobs.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('test') RETURNING id").get() as { id: string }
+}
+
+describe("jobs", () => {
+  it("creates a job", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
+    expect(job.id).toBeTruthy()
+    expect(job.schedule).toBe("*/5 * * * *")
+    expect(job.enabled).toBe(1)
+  })
+
+  it("lists jobs for a project", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
+    createJob(db, { project_id: p.id, schedule: "*/10 * * * *" })
+    expect(listJobs(db, p.id)).toHaveLength(2)
+  })
+
+  it("updates a job", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
+    const updated = updateJob(db, job.id, { enabled: 0 })
+    expect(updated?.enabled).toBe(0)
+  })
+
+  it("deletes a job", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
+    deleteJob(db, job.id)
+    expect(listJobs(db, p.id)).toHaveLength(0)
+  })
+})
+
+describe("scan runs", () => {
+  it("creates and finishes a scan run", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
+    const run = createScanRun(db, { job_id: job.id })
+    expect(run.status).toBe("running")
+    expect(run.logs_collected).toBe(0)
+
+    const finished = finishScanRun(db, run.id, { status: "completed", logs_collected: 12, errors_found: 3, perf_score: 87.5 })
+    expect(finished?.status).toBe("completed")
+    expect(finished?.logs_collected).toBe(12)
+    expect(finished?.errors_found).toBe(3)
+    expect(finished?.perf_score).toBe(87.5)
+    expect(finished?.finished_at).toBeTruthy()
+  })
+
+  it("lists scan runs for a job", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const job = createJob(db, { project_id: p.id, schedule: "*/5 * * * *" })
+    createScanRun(db, { job_id: job.id })
+    createScanRun(db, { job_id: job.id })
+    expect(listScanRuns(db, job.id)).toHaveLength(2)
+  })
+})

package/src/lib/jobs.ts

@@ -0,0 +1,63 @@
+import type { Database } from "bun:sqlite"
+import type { ScanJob, ScanRun } from "../types/index.ts"
+
+export function createJob(db: Database, data: { project_id: string; schedule: string; page_id?: string }): ScanJob {
+  return db.prepare(`
+    INSERT INTO scan_jobs (project_id, page_id, schedule)
+    VALUES ($project_id, $page_id, $schedule)
+    RETURNING *
+  `).get({
+    $project_id: data.project_id,
+    $page_id: data.page_id ?? null,
+    $schedule: data.schedule,
+  }) as ScanJob
+}
+
+export function listJobs(db: Database, projectId?: string): ScanJob[] {
+  if (projectId) {
+    return db.prepare("SELECT * FROM scan_jobs WHERE project_id = $p ORDER BY created_at DESC").all({ $p: projectId }) as ScanJob[]
+  }
+  return db.prepare("SELECT * FROM scan_jobs ORDER BY created_at DESC").all() as ScanJob[]
+}
+
+export function getJob(db: Database, id: string): ScanJob | null {
+  return db.prepare("SELECT * FROM scan_jobs WHERE id = $id").get({ $id: id }) as ScanJob | null
+}
+
+export function updateJob(db: Database, id: string, data: { enabled?: number; schedule?: string; last_run_at?: string }): ScanJob | null {
+  const fields = Object.keys(data).map(k => `${k} = $${k}`).join(", ")
+  if (!fields) return getJob(db, id)
+  const params = Object.fromEntries(Object.entries(data).map(([k, v]) => [`$${k}`, v]))
+  params.$id = id
+  return db.prepare(`UPDATE scan_jobs SET ${fields} WHERE id = $id RETURNING *`).get(params) as ScanJob | null
+}
+
+export function deleteJob(db: Database, id: string): void {
+  db.run("DELETE FROM scan_jobs WHERE id = $id", { $id: id })
+}
+
+export function createScanRun(db: Database, data: { job_id: string; page_id?: string }): ScanRun {
+  return db.prepare(`
+    INSERT INTO scan_runs (job_id, page_id) VALUES ($job_id, $page_id) RETURNING *
+  `).get({ $job_id: data.job_id, $page_id: data.page_id ?? null }) as ScanRun
+}
+
+export function finishScanRun(db: Database, id: string, data: { status: "completed" | "failed"; logs_collected: number; errors_found: number; perf_score?: number }): ScanRun | null {
+  return db.prepare(`
+    UPDATE scan_runs SET finished_at = strftime('%Y-%m-%dT%H:%M:%fZ','now'),
+      status = $status, logs_collected = $logs_collected,
+      errors_found = $errors_found, perf_score = $perf_score
+    WHERE id = $id RETURNING *
+  `).get({
+    $id: id,
+    $status: data.status,
+    $logs_collected: data.logs_collected,
+    $errors_found: data.errors_found,
+    $perf_score: data.perf_score ?? null,
+  }) as ScanRun | null
+}
+
+export function listScanRuns(db: Database, jobId: string, limit = 20): ScanRun[] {
+  return db.prepare("SELECT * FROM scan_runs WHERE job_id = $j ORDER BY started_at DESC LIMIT $l")
+    .all({ $j: jobId, $l: limit }) as ScanRun[]
+}

package/src/lib/lighthouse.ts

@@ -0,0 +1,65 @@
+import type { Database } from "bun:sqlite"
+import { saveSnapshot } from "./perf.ts"
+import type { PerformanceSnapshot } from "../types/index.ts"
+
+export interface LighthouseResult {
+  lcp: number | null
+  fcp: number | null
+  cls: number | null
+  tti: number | null
+  ttfb: number | null
+  score: number | null
+  raw_audit: string
+}
+
+export async function runLighthouse(url: string): Promise<LighthouseResult | null> {
+  try {
+    // Dynamic import — lighthouse is an optional peer dep
+    const { default: lighthouse } = await import("lighthouse" as string)
+    const { chromium } = await import("playwright")
+
+    const browser = await chromium.launch({ headless: true, args: ["--remote-debugging-port=9222"] })
+    try {
+      const result = await lighthouse(url, {
+        port: 9222,
+        output: "json",
+        logLevel: "silent",
+        onlyCategories: ["performance"],
+      } as Parameters<typeof lighthouse>[1])
+
+      if (!result) return null
+      const audits = result.lhr.audits
+      const score = result.lhr.categories["performance"]?.score
+
+      return {
+        lcp: (audits["largest-contentful-paint"]?.numericValue ?? null) as number | null,
+        fcp: (audits["first-contentful-paint"]?.numericValue ?? null) as number | null,
+        cls: (audits["cumulative-layout-shift"]?.numericValue ?? null) as number | null,
+        tti: (audits["interactive"]?.numericValue ?? null) as number | null,
+        ttfb: (audits["server-response-time"]?.numericValue ?? null) as number | null,
+        score: score !== undefined ? score * 100 : null,
+        raw_audit: JSON.stringify(result.lhr.audits),
+      }
+    } finally {
+      await browser.close()
+    }
+  } catch {
+    return null
+  }
+}
+
+export async function runAndSaveLighthouse(
+  db: Database,
+  url: string,
+  projectId: string,
+  pageId?: string,
+): Promise<PerformanceSnapshot | null> {
+  const result = await runLighthouse(url)
+  if (!result) return null
+  return saveSnapshot(db, {
+    project_id: projectId,
+    page_id: pageId ?? null,
+    url,
+    ...result,
+  })
+}

package/src/lib/perf.test.ts

@@ -0,0 +1,45 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { getLatestSnapshot, getPerfTrend, saveSnapshot, scoreLabel } from "./perf.ts"
+
+function seedProject(db: ReturnType<typeof createTestDb>) {
+  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
+}
+
+describe("perf", () => {
+  it("saves and retrieves a snapshot", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    const snap = saveSnapshot(db, { project_id: p.id, url: "https://app.com", lcp: 1200, fcp: 800, cls: 0.05, tti: 2000, ttfb: 100, score: 91, raw_audit: null, page_id: null })
+    expect(snap.id).toBeTruthy()
+    expect(snap.score).toBe(91)
+    const latest = getLatestSnapshot(db, p.id)
+    expect(latest?.id).toBe(snap.id)
+  })
+
+  it("returns null when no snapshot exists", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    expect(getLatestSnapshot(db, p.id)).toBeNull()
+  })
+
+  it("returns trend in desc order", () => {
+    const db = createTestDb()
+    const p = seedProject(db)
+    saveSnapshot(db, { project_id: p.id, url: "https://app.com", lcp: 1000, fcp: 700, cls: 0.03, tti: 1800, ttfb: 90, score: 95, raw_audit: null, page_id: null })
+    saveSnapshot(db, { project_id: p.id, url: "https://app.com", lcp: 2000, fcp: 1200, cls: 0.1, tti: 3000, ttfb: 200, score: 70, raw_audit: null, page_id: null })
+    const trend = getPerfTrend(db, p.id)
+    expect(trend).toHaveLength(2)
+    expect(trend[0]!.timestamp >= trend[1]!.timestamp).toBe(true)
+  })
+})
+
+describe("scoreLabel", () => {
+  it("returns green for >= 90", () => expect(scoreLabel(90)).toBe("green"))
+  it("returns green for 100", () => expect(scoreLabel(100)).toBe("green"))
+  it("returns yellow for 50-89", () => expect(scoreLabel(75)).toBe("yellow"))
+  it("returns yellow for 50", () => expect(scoreLabel(50)).toBe("yellow"))
+  it("returns red for < 50", () => expect(scoreLabel(49)).toBe("red"))
+  it("returns red for 0", () => expect(scoreLabel(0)).toBe("red"))
+  it("returns unknown for null", () => expect(scoreLabel(null)).toBe("unknown"))
+})

package/src/lib/perf.ts

@@ -0,0 +1,46 @@
+import type { Database } from "bun:sqlite"
+import type { PerformanceSnapshot } from "../types/index.ts"
+
+export function saveSnapshot(db: Database, data: Omit<PerformanceSnapshot, "id" | "timestamp">): PerformanceSnapshot {
+  return db.prepare(`
+    INSERT INTO performance_snapshots (project_id, page_id, url, lcp, fcp, cls, tti, ttfb, score, raw_audit)
+    VALUES ($project_id, $page_id, $url, $lcp, $fcp, $cls, $tti, $ttfb, $score, $raw_audit)
+    RETURNING *
+  `).get({
+    $project_id: data.project_id,
+    $page_id: data.page_id ?? null,
+    $url: data.url,
+    $lcp: data.lcp ?? null,
+    $fcp: data.fcp ?? null,
+    $cls: data.cls ?? null,
+    $tti: data.tti ?? null,
+    $ttfb: data.ttfb ?? null,
+    $score: data.score ?? null,
+    $raw_audit: data.raw_audit ?? null,
+  }) as PerformanceSnapshot
+}
+
+export function getLatestSnapshot(db: Database, projectId: string, pageId?: string): PerformanceSnapshot | null {
+  if (pageId) {
+    return db.prepare("SELECT * FROM performance_snapshots WHERE project_id = $p AND page_id = $pg ORDER BY timestamp DESC LIMIT 1")
+      .get({ $p: projectId, $pg: pageId }) as PerformanceSnapshot | null
+  }
+  return db.prepare("SELECT * FROM performance_snapshots WHERE project_id = $p ORDER BY timestamp DESC LIMIT 1")
+    .get({ $p: projectId }) as PerformanceSnapshot | null
+}
+
+export function getPerfTrend(db: Database, projectId: string, pageId?: string, since?: string, limit = 50): PerformanceSnapshot[] {
+  const conditions = ["project_id = $p"]
+  const params: Record<string, unknown> = { $p: projectId, $limit: limit }
+  if (pageId) { conditions.push("page_id = $pg"); params.$pg = pageId }
+  if (since) { conditions.push("timestamp >= $since"); params.$since = since }
+  return db.prepare(`SELECT * FROM performance_snapshots WHERE ${conditions.join(" AND ")} ORDER BY timestamp DESC LIMIT $limit`)
+    .all(params) as PerformanceSnapshot[]
+}
+
+export function scoreLabel(score: number | null): "green" | "yellow" | "red" | "unknown" {
+  if (score === null) return "unknown"
+  if (score >= 90) return "green"
+  if (score >= 50) return "yellow"
+  return "red"
+}

package/src/lib/projects.test.ts

@@ -0,0 +1,73 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { createPage, createProject, getPage, getProject, listPages, listProjects, touchPage, updateProject } from "./projects.ts"
+
+describe("projects", () => {
+  it("creates a project", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "my-app", github_repo: "https://github.com/foo/bar", base_url: "https://myapp.com" })
+    expect(p.id).toBeTruthy()
+    expect(p.name).toBe("my-app")
+    expect(p.github_repo).toBe("https://github.com/foo/bar")
+  })
+
+  it("lists projects", () => {
+    const db = createTestDb()
+    createProject(db, { name: "app1" })
+    createProject(db, { name: "app2" })
+    expect(listProjects(db)).toHaveLength(2)
+  })
+
+  it("gets a project by id", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "test" })
+    expect(getProject(db, p.id)?.name).toBe("test")
+  })
+
+  it("returns null for unknown id", () => {
+    expect(getProject(createTestDb(), "nope")).toBeNull()
+  })
+
+  it("updates project fields", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "x" })
+    const updated = updateProject(db, p.id, { github_sha: "abc123" })
+    expect(updated?.github_sha).toBe("abc123")
+  })
+})
+
+describe("pages", () => {
+  it("creates a page", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "app" })
+    const page = createPage(db, { project_id: p.id, url: "https://app.com/dashboard", name: "Dashboard" })
+    expect(page.id).toBeTruthy()
+    expect(page.url).toBe("https://app.com/dashboard")
+    expect(page.name).toBe("Dashboard")
+  })
+
+  it("upserts on duplicate url", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "app" })
+    createPage(db, { project_id: p.id, url: "https://app.com/", name: "Home" })
+    createPage(db, { project_id: p.id, url: "https://app.com/", name: "Home v2" })
+    expect(listPages(db, p.id)).toHaveLength(1)
+  })
+
+  it("lists pages for a project", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "app" })
+    createPage(db, { project_id: p.id, url: "https://app.com/a" })
+    createPage(db, { project_id: p.id, url: "https://app.com/b" })
+    expect(listPages(db, p.id)).toHaveLength(2)
+  })
+
+  it("touches last_scanned_at", () => {
+    const db = createTestDb()
+    const p = createProject(db, { name: "app" })
+    const page = createPage(db, { project_id: p.id, url: "https://app.com/" })
+    expect(page.last_scanned_at).toBeNull()
+    touchPage(db, page.id)
+    expect(getPage(db, page.id)?.last_scanned_at).toBeTruthy()
+  })
+})

package/src/lib/projects.ts

@@ -0,0 +1,59 @@
+import type { Database } from "bun:sqlite"
+import type { Page, Project } from "../types/index.ts"
+
+// Projects
+export function createProject(db: Database, data: { name: string; github_repo?: string; base_url?: string; description?: string }): Project {
+  return db.prepare(`
+    INSERT INTO projects (name, github_repo, base_url, description)
+    VALUES ($name, $github_repo, $base_url, $description)
+    RETURNING *
+  `).get({
+    $name: data.name,
+    $github_repo: data.github_repo ?? null,
+    $base_url: data.base_url ?? null,
+    $description: data.description ?? null,
+  }) as Project
+}
+
+export function listProjects(db: Database): Project[] {
+  return db.prepare("SELECT * FROM projects ORDER BY created_at DESC").all() as Project[]
+}
+
+export function getProject(db: Database, id: string): Project | null {
+  return db.prepare("SELECT * FROM projects WHERE id = $id").get({ $id: id }) as Project | null
+}
+
+export function updateProject(db: Database, id: string, data: Partial<Pick<Project, "name" | "github_repo" | "base_url" | "description" | "github_description" | "github_branch" | "github_sha" | "last_synced_at">>): Project | null {
+  const fields = Object.keys(data).map(k => `${k} = $${k}`).join(", ")
+  if (!fields) return getProject(db, id)
+  const params = Object.fromEntries(Object.entries(data).map(([k, v]) => [`$${k}`, v]))
+  params.$id = id
+  return db.prepare(`UPDATE projects SET ${fields} WHERE id = $id RETURNING *`).get(params) as Project | null
+}
+
+// Pages
+export function createPage(db: Database, data: { project_id: string; url: string; path?: string; name?: string }): Page {
+  return db.prepare(`
+    INSERT INTO pages (project_id, url, path, name)
+    VALUES ($project_id, $url, $path, $name)
+    ON CONFLICT(project_id, url) DO UPDATE SET name = excluded.name
+    RETURNING *
+  `).get({
+    $project_id: data.project_id,
+    $url: data.url,
+    $path: data.path ?? new URL(data.url).pathname,
+    $name: data.name ?? null,
+  }) as Page
+}
+
+export function listPages(db: Database, projectId: string): Page[] {
+  return db.prepare("SELECT * FROM pages WHERE project_id = $p ORDER BY created_at ASC").all({ $p: projectId }) as Page[]
+}
+
+export function getPage(db: Database, id: string): Page | null {
+  return db.prepare("SELECT * FROM pages WHERE id = $id").get({ $id: id }) as Page | null
+}
+
+export function touchPage(db: Database, id: string): void {
+  db.run("UPDATE pages SET last_scanned_at = strftime('%Y-%m-%dT%H:%M:%fZ','now') WHERE id = $id", { $id: id })
+}

package/src/lib/query.test.ts

@@ -0,0 +1,104 @@
+import { describe, expect, it } from "bun:test"
+import { createTestDb } from "../db/index.ts"
+import { ingestBatch } from "./ingest.ts"
+import { getLogContext, searchLogs, tailLogs } from "./query.ts"
+
+function seed(db: ReturnType<typeof createTestDb>) {
+  ingestBatch(db, [
+    { level: "error", message: "DB connection failed", service: "api", trace_id: "t1" },
+    { level: "warn", message: "Slow query detected", service: "api", trace_id: "t1" },
+    { level: "info", message: "User login", service: "auth" },
+    { level: "debug", message: "Cache miss", service: "cache" },
+    { level: "fatal", message: "Out of memory", service: "worker" },
+  ])
+}
+
+describe("searchLogs", () => {
+  it("returns all logs without filters", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, {})
+    expect(rows.length).toBe(5)
+  })
+
+  it("filters by level", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, { level: "error" })
+    expect(rows.every(r => r.level === "error")).toBe(true)
+  })
+
+  it("filters by multiple levels", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, { level: ["error", "fatal"] })
+    expect(rows).toHaveLength(2)
+  })
+
+  it("filters by service", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, { service: "api" })
+    expect(rows).toHaveLength(2)
+  })
+
+  it("full-text search on message", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, { text: "connection" })
+    expect(rows).toHaveLength(1)
+    expect(rows[0]!.message).toContain("connection")
+  })
+
+  it("filters by trace_id", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, { trace_id: "t1" })
+    expect(rows).toHaveLength(2)
+  })
+
+  it("respects limit", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, { limit: 2 })
+    expect(rows).toHaveLength(2)
+  })
+
+  it("returns results ordered by timestamp desc", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = searchLogs(db, {})
+    expect(rows[0]!.timestamp >= rows[rows.length - 1]!.timestamp).toBe(true)
+  })
+})
+
+describe("tailLogs", () => {
+  it("returns n most recent logs", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = tailLogs(db, undefined, 3)
+    expect(rows).toHaveLength(3)
+  })
+
+  it("filters by project_id", () => {
+    const db = createTestDb()
+    const rows = tailLogs(db, "nonexistent")
+    expect(rows).toHaveLength(0)
+  })
+})
+
+describe("getLogContext", () => {
+  it("returns all logs for a trace_id in asc order", () => {
+    const db = createTestDb()
+    seed(db)
+    const rows = getLogContext(db, "t1")
+    expect(rows).toHaveLength(2)
+    expect(rows[0]!.timestamp <= rows[1]!.timestamp).toBe(true)
+  })
+
+  it("returns empty for unknown trace_id", () => {
+    const db = createTestDb()
+    const rows = getLogContext(db, "unknown")
+    expect(rows).toHaveLength(0)
+  })
+})