@hasna/logs 0.3.26 → 0.3.28

package/src/lib/compare.test.ts

@@ -1,52 +0,0 @@
-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

@@ -1,85 +0,0 @@
-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,
-  }
-}

package/src/lib/count.test.ts

@@ -1,44 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { countLogs } from "./count.ts"
-
-describe("countLogs", () => {
-  it("counts all logs", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "error", message: "e" }, { level: "warn", message: "w" }, { level: "info", message: "i" }])
-    const c = countLogs(db, {})
-    expect(c.total).toBe(3)
-    expect(c.errors).toBe(1)
-    expect(c.warns).toBe(1)
-    expect(c.fatals).toBe(0)
-  })
-
-  it("filters by project", () => {
-    const db = createTestDb()
-    const p = db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
-    ingestBatch(db, [{ level: "error", message: "e", project_id: p.id }, { level: "error", message: "e2" }])
-    const c = countLogs(db, { project_id: p.id })
-    expect(c.total).toBe(1)
-  })
-
-  it("filters by service", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "error", message: "e", service: "api" }, { level: "error", message: "e2", service: "db" }])
-    expect(countLogs(db, { service: "api" }).total).toBe(1)
-  })
-
-  it("returns zero counts for empty db", () => {
-    const c = countLogs(createTestDb(), {})
-    expect(c.total).toBe(0)
-    expect(c.errors).toBe(0)
-    expect(c.by_level).toEqual({})
-  })
-
-  it("accepts relative since", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "error", message: "recent" }])
-    const c = countLogs(db, { since: "1h" })
-    expect(c.total).toBe(1)
-  })
-})

package/src/lib/count.ts

@@ -1,55 +0,0 @@
-import type { Database } from "bun:sqlite"
-import { parseTime } from "./parse-time.ts"
-
-export interface LogCount {
-  total: number
-  errors: number
-  warns: number
-  fatals: number
-  by_level: Record<string, number>
-  by_service?: Record<string, number>
-}
-
-export function countLogs(db: Database, opts: {
-  project_id?: string
-  service?: string
-  level?: string
-  since?: string
-  until?: string
-  group_by?: "level" | "service"
-}): LogCount {
-  const conditions: string[] = []
-  const params: Record<string, unknown> = {}
-
-  if (opts.project_id) { conditions.push("project_id = $p"); params.$p = opts.project_id }
-  if (opts.service) { conditions.push("service = $service"); params.$service = opts.service }
-  if (opts.level) { conditions.push("level = $level"); params.$level = opts.level }
-  const since = parseTime(opts.since)
-  const until = parseTime(opts.until)
-  if (since) { conditions.push("timestamp >= $since"); params.$since = since }
-  if (until) { conditions.push("timestamp <= $until"); params.$until = until }
-
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-
-  const byLevel = db.prepare(`SELECT level, COUNT(*) as c FROM logs ${where} GROUP BY level`)
-    .all(params) as { level: string; c: number }[]
-
-  const by_level = Object.fromEntries(byLevel.map(r => [r.level, r.c]))
-  const total = byLevel.reduce((s, r) => s + r.c, 0)
-
-  let by_service: Record<string, number> | undefined
-  if (opts.group_by === "service") {
-    const bySvc = db.prepare(`SELECT COALESCE(service, '-') as service, COUNT(*) as c FROM logs ${where} GROUP BY service ORDER BY c DESC`)
-      .all(params) as { service: string; c: number }[]
-    by_service = Object.fromEntries(bySvc.map(r => [r.service, r.c]))
-  }
-
-  return {
-    total,
-    errors: by_level["error"] ?? 0,
-    warns: by_level["warn"] ?? 0,
-    fatals: by_level["fatal"] ?? 0,
-    by_level,
-    by_service,
-  }
-}

package/src/lib/diagnose.test.ts

@@ -1,55 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { diagnose } from "./diagnose.ts"
-
-function seedProject(db: ReturnType<typeof createTestDb>) {
-  return db.prepare("INSERT INTO projects (name) VALUES ('app') RETURNING id").get() as { id: string }
-}
-
-describe("diagnose", () => {
-  it("returns empty diagnosis for project with no logs", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    const result = diagnose(db, p.id)
-    expect(result.project_id).toBe(p.id)
-    expect(result.top_errors).toHaveLength(0)
-    expect(result.summary).toContain("No errors")
-  })
-
-  it("surfaces top errors", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    ingestBatch(db, [
-      { level: "error", message: "DB timeout", service: "api", project_id: p.id },
-      { level: "error", message: "DB timeout", service: "api", project_id: p.id },
-      { level: "error", message: "Auth failed", service: "auth", project_id: p.id },
-    ])
-    const result = diagnose(db, p.id)
-    expect(result.top_errors.length).toBeGreaterThan(0)
-    expect(result.top_errors[0]!.message).toBe("DB timeout")
-    expect(result.top_errors[0]!.count).toBe(2)
-  })
-
-  it("populates summary with error info", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    ingestBatch(db, [{ level: "error", message: "boom", service: "api", project_id: p.id }])
-    const result = diagnose(db, p.id)
-    expect(result.summary).toContain("error")
-  })
-
-  it("groups error_rate_by_service", () => {
-    const db = createTestDb()
-    const p = seedProject(db)
-    ingestBatch(db, [
-      { level: "error", message: "e1", service: "api", project_id: p.id },
-      { level: "info", message: "i1", service: "api", project_id: p.id },
-      { level: "warn", message: "w1", service: "db", project_id: p.id },
-    ])
-    const result = diagnose(db, p.id)
-    const api = result.error_rate_by_service.find(s => s.service === "api")
-    expect(api?.errors).toBe(1)
-    expect(api?.total).toBe(2)
-  })
-})

package/src/lib/diagnose.ts

@@ -1,91 +0,0 @@
-import type { Database } from "bun:sqlite"
-import { parseTime } from "./parse-time.ts"
-
-export interface DiagnosisResult {
-  project_id: string
-  window: string
-  score: "green" | "yellow" | "red"
-  error_count: number
-  warn_count: number
-  has_perf_regression: boolean
-  top_errors: { message: string; count: number; service: string | null; last_seen: string }[]
-  error_rate_by_service: { service: string | null; errors: number; warns: number; total: number }[]
-  failing_pages: { page_id: string; url: string; error_count: number }[]
-  perf_regressions: { page_id: string; url: string; score_now: number | null; score_prev: number | null; delta: number | null }[]
-  summary: string
-}
-
-export type DiagnoseInclude = "top_errors" | "error_rate" | "failing_pages" | "perf"
-
-export function diagnose(db: Database, projectId: string, since?: string, include?: DiagnoseInclude[]): DiagnosisResult {
-  const window = parseTime(since) ?? since ?? new Date(Date.now() - 24 * 3600 * 1000).toISOString()
-  const all = !include || include.length === 0
-  const want = (k: DiagnoseInclude) => all || include!.includes(k)
-
-  // Top errors by message
-  const top_errors = want("top_errors") ? db.prepare(`
-    SELECT message, COUNT(*) as count, service, MAX(timestamp) as last_seen
-    FROM logs
-    WHERE project_id = $p AND level IN ('error','fatal') AND timestamp >= $since
-    GROUP BY message, service
-    ORDER BY count DESC
-    LIMIT 10
-  `).all({ $p: projectId, $since: window }) as DiagnosisResult["top_errors"] : []
-
-  // Error rate by service
-  const error_rate_by_service = want("error_rate") ? db.prepare(`
-    SELECT service,
-      SUM(CASE WHEN level IN ('error','fatal') THEN 1 ELSE 0 END) as errors,
-      SUM(CASE WHEN level = 'warn' THEN 1 ELSE 0 END) as warns,
-      COUNT(*) as total
-    FROM logs
-    WHERE project_id = $p AND timestamp >= $since
-    GROUP BY service
-    ORDER BY errors DESC
-  `).all({ $p: projectId, $since: window }) as DiagnosisResult["error_rate_by_service"] : []
-
-  // Failing pages (most errors)
-  const failing_pages = want("failing_pages") ? db.prepare(`
-    SELECT l.page_id, p.url, COUNT(*) as error_count
-    FROM logs l
-    JOIN pages p ON p.id = l.page_id
-    WHERE l.project_id = $p AND l.level IN ('error','fatal') AND l.timestamp >= $since AND l.page_id IS NOT NULL
-    GROUP BY l.page_id, p.url
-    ORDER BY error_count DESC
-    LIMIT 10
-  `).all({ $p: projectId, $since: window }) as DiagnosisResult["failing_pages"] : []
-
-  // Perf regressions: compare latest vs previous snapshot per page
-  const perf_regressions = want("perf") ? db.prepare(`
-    SELECT * FROM (
-      SELECT
-        cur.page_id,
-        p.url,
-        cur.score as score_now,
-        prev.score as score_prev,
-        (cur.score - prev.score) as delta
-      FROM performance_snapshots cur
-      JOIN pages p ON p.id = cur.page_id
-      LEFT JOIN performance_snapshots prev ON prev.page_id = cur.page_id AND prev.id != cur.id
-      WHERE cur.project_id = $p
-      AND cur.timestamp = (SELECT MAX(timestamp) FROM performance_snapshots WHERE page_id = cur.page_id)
-      AND (prev.timestamp = (SELECT MAX(timestamp) FROM performance_snapshots WHERE page_id = cur.page_id AND id != cur.id) OR prev.id IS NULL)
-    ) WHERE delta < -5 OR delta IS NULL
-    ORDER BY delta ASC
-    LIMIT 10
-  `).all({ $p: projectId }) as DiagnosisResult["perf_regressions"] : []
-
-  const totalErrors = top_errors.reduce((s, e) => s + e.count, 0)
-  const totalWarns = error_rate_by_service.reduce((s, r) => s + r.warns, 0)
-  const topService = error_rate_by_service[0]
-  const score: "green" | "yellow" | "red" = totalErrors === 0 ? "green" : totalErrors <= 10 ? "yellow" : "red"
-  const summary = totalErrors === 0
-    ? "No errors in this window. All looks good."
-    : `${totalErrors} error(s) detected. Worst service: ${topService?.service ?? "unknown"} (${topService?.errors ?? 0} errors). ${failing_pages.length} page(s) with errors. ${perf_regressions.length} perf regression(s).`
-
-  return {
-    project_id: projectId, window, score, error_count: totalErrors, warn_count: totalWarns,
-    has_perf_regression: perf_regressions.length > 0,
-    top_errors, error_rate_by_service, failing_pages, perf_regressions, summary,
-  }
-}

package/src/lib/export.test.ts

@@ -1,66 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { exportToCsv, exportToJson } from "./export.ts"
-
-function seed(db: ReturnType<typeof createTestDb>) {
-  ingestBatch(db, [
-    { level: "error", message: "boom", service: "api" },
-    { level: "info", message: "ok", service: "web" },
-    { level: "warn", message: 'has "quotes"', service: "db" },
-  ])
-}
-
-describe("exportToJson", () => {
-  it("exports all logs as JSON array", () => {
-    const db = createTestDb()
-    seed(db)
-    const chunks: string[] = []
-    const count = exportToJson(db, {}, s => chunks.push(s))
-    expect(count).toBe(3)
-    const parsed = JSON.parse(chunks.join(""))
-    expect(Array.isArray(parsed)).toBe(true)
-    expect(parsed).toHaveLength(3)
-  })
-
-  it("filters by level", () => {
-    const db = createTestDb()
-    seed(db)
-    const chunks: string[] = []
-    const count = exportToJson(db, { level: "error" }, s => chunks.push(s))
-    expect(count).toBe(1)
-    const parsed = JSON.parse(chunks.join(""))
-    expect(parsed[0].level).toBe("error")
-  })
-})
-
-describe("exportToCsv", () => {
-  it("exports CSV with header", () => {
-    const db = createTestDb()
-    seed(db)
-    const chunks: string[] = []
-    const count = exportToCsv(db, {}, s => chunks.push(s))
-    expect(count).toBe(3)
-    const csv = chunks.join("")
-    expect(csv).toContain("id,timestamp,level")
-    expect(csv).toContain("error")
-    expect(csv).toContain("boom")
-  })
-
-  it("escapes CSV quotes", () => {
-    const db = createTestDb()
-    seed(db)
-    const chunks: string[] = []
-    exportToCsv(db, { level: "warn" }, s => chunks.push(s))
-    const csv = chunks.join("")
-    expect(csv).toContain('"has ""quotes"""')
-  })
-
-  it("filters by service", () => {
-    const db = createTestDb()
-    seed(db)
-    const chunks: string[] = []
-    const count = exportToCsv(db, { service: "api" }, s => chunks.push(s))
-    expect(count).toBe(1)
-  })
-})

package/src/lib/export.ts

@@ -1,65 +0,0 @@
-import type { Database } from "bun:sqlite"
-import type { LogRow } from "../types/index.ts"
-
-export interface ExportOptions {
-  project_id?: string
-  since?: string
-  until?: string
-  level?: string
-  service?: string
-  limit?: number
-}
-
-function* iterLogs(db: Database, opts: ExportOptions): Generator<LogRow> {
-  const conditions: string[] = []
-  const params: Record<string, unknown> = {}
-  if (opts.project_id) { conditions.push("project_id = $p"); params.$p = opts.project_id }
-  if (opts.since) { conditions.push("timestamp >= $since"); params.$since = opts.since }
-  if (opts.until) { conditions.push("timestamp <= $until"); params.$until = opts.until }
-  if (opts.level) { conditions.push("level = $level"); params.$level = opts.level }
-  if (opts.service) { conditions.push("service = $service"); params.$service = opts.service }
-  const where = conditions.length ? `WHERE ${conditions.join(" AND ")}` : ""
-  const limit = opts.limit ?? 100_000
-
-  // Batch in pages of 1000 to avoid memory issues
-  let offset = 0
-  while (offset < limit) {
-    const batch = db.prepare(`SELECT * FROM logs ${where} ORDER BY timestamp ASC LIMIT 1000 OFFSET $offset`)
-      .all({ ...params, $offset: offset }) as LogRow[]
-    if (!batch.length) break
-    yield* batch
-    offset += batch.length
-    if (batch.length < 1000) break
-  }
-}
-
-export function exportToJson(db: Database, opts: ExportOptions, writeLine: (s: string) => void): number {
-  writeLine("[")
-  let count = 0
-  for (const row of iterLogs(db, opts)) {
-    writeLine((count > 0 ? "," : "") + JSON.stringify(row))
-    count++
-  }
-  writeLine("]")
-  return count
-}
-
-const CSV_HEADER = "id,timestamp,level,service,message,trace_id,url\n"
-
-export function exportToCsv(db: Database, opts: ExportOptions, writeLine: (s: string) => void): number {
-  writeLine(CSV_HEADER)
-  let count = 0
-  for (const row of iterLogs(db, opts)) {
-    const fields = [row.id, row.timestamp, row.level, row.service ?? "", escapeCSV(row.message), row.trace_id ?? "", row.url ?? ""]
-    writeLine(fields.join(",") + "\n")
-    count++
-  }
-  return count
-}
-
-function escapeCSV(s: string): string {
-  if (s.includes(",") || s.includes('"') || s.includes("\n")) {
-    return `"${s.replace(/"/g, '""')}"`
-  }
-  return s
-}

package/src/lib/github.ts

@@ -1,38 +0,0 @@
-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/health.test.ts

@@ -1,48 +0,0 @@
-import { describe, expect, it } from "bun:test"
-import { createTestDb } from "../db/index.ts"
-import { ingestBatch } from "./ingest.ts"
-import { getHealth } from "./health.ts"
-
-describe("getHealth", () => {
-  it("returns status ok", () => {
-    const db = createTestDb()
-    const h = getHealth(db)
-    expect(h.status).toBe("ok")
-  })
-
-  it("counts total logs", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "info", message: "a" }, { level: "error", message: "b" }])
-    const h = getHealth(db)
-    expect(h.total_logs).toBe(2)
-  })
-
-  it("returns logs_by_level breakdown", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "info", message: "a" }, { level: "error", message: "b" }, { level: "error", message: "c" }])
-    const h = getHealth(db)
-    expect(h.logs_by_level["error"]).toBe(2)
-    expect(h.logs_by_level["info"]).toBe(1)
-  })
-
-  it("counts projects", () => {
-    const db = createTestDb()
-    db.prepare("INSERT INTO projects (name) VALUES ('p1')").run()
-    db.prepare("INSERT INTO projects (name) VALUES ('p2')").run()
-    const h = getHealth(db)
-    expect(h.projects).toBe(2)
-  })
-
-  it("returns uptime_seconds >= 0", () => {
-    const h = getHealth(createTestDb())
-    expect(h.uptime_seconds).toBeGreaterThanOrEqual(0)
-  })
-
-  it("returns newest and oldest log timestamps", () => {
-    const db = createTestDb()
-    ingestBatch(db, [{ level: "info", message: "first" }, { level: "warn", message: "last" }])
-    const h = getHealth(db)
-    expect(h.oldest_log).toBeTruthy()
-    expect(h.newest_log).toBeTruthy()
-  })
-})

package/src/lib/health.ts

@@ -1,51 +0,0 @@
-import type { Database } from "bun:sqlite"
-
-const startTime = Date.now()
-
-export interface HealthResult {
-  status: "ok"
-  uptime_seconds: number
-  db_size_bytes: number | null
-  projects: number
-  total_logs: number
-  logs_by_level: Record<string, number>
-  oldest_log: string | null
-  newest_log: string | null
-  scheduler_jobs: number
-  open_issues: number
-}
-
-export function getHealth(db: Database): HealthResult {
-  const projects = (db.prepare("SELECT COUNT(*) as c FROM projects").get() as { c: number }).c
-  const total_logs = (db.prepare("SELECT COUNT(*) as c FROM logs").get() as { c: number }).c
-  const scheduler_jobs = (db.prepare("SELECT COUNT(*) as c FROM scan_jobs WHERE enabled = 1").get() as { c: number }).c
-  const open_issues = (db.prepare("SELECT COUNT(*) as c FROM issues WHERE status = 'open'").get() as { c: number }).c
-
-  const levelRows = db.prepare("SELECT level, COUNT(*) as c FROM logs GROUP BY level").all() as { level: string; c: number }[]
-  const logs_by_level = Object.fromEntries(levelRows.map(r => [r.level, r.c]))
-
-  const oldest = db.prepare("SELECT MIN(timestamp) as t FROM logs").get() as { t: string | null }
-  const newest = db.prepare("SELECT MAX(timestamp) as t FROM logs").get() as { t: string | null }
-
-  let db_size_bytes: number | null = null
-  try {
-    const dbPath = process.env.HASNA_LOGS_DB_PATH ?? process.env.LOGS_DB_PATH
-    if (dbPath) {
-      const { statSync } = require("node:fs")
-      db_size_bytes = statSync(dbPath).size
-    }
-  } catch { /* in-memory or not accessible */ }
-
-  return {
-    status: "ok",
-    uptime_seconds: Math.floor((Date.now() - startTime) / 1000),
-    db_size_bytes,
-    projects,
-    total_logs,
-    logs_by_level,
-    oldest_log: oldest.t,
-    newest_log: newest.t,
-    scheduler_jobs,
-    open_issues,
-  }
-}