@hasna/logs 0.1.0 → 0.3.0

package/src/lib/diagnose.ts

@@ -1,8 +1,13 @@
 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 }[]
@@ -10,21 +15,25 @@ export interface DiagnosisResult {
   summary: string
 }
 
-export function diagnose(db: Database, projectId: string, since?: string): DiagnosisResult {
-  const window = since ?? new Date(Date.now() - 24 * 3600 * 1000).toISOString()
+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 = db.prepare(`
+  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"]
+  `).all({ $p: projectId, $since: window }) as DiagnosisResult["top_errors"] : []
 
   // Error rate by service
-  const error_rate_by_service = db.prepare(`
+  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,
@@ -33,10 +42,10 @@ export function diagnose(db: Database, projectId: string, since?: string): Diagn
     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"]
+  `).all({ $p: projectId, $since: window }) as DiagnosisResult["error_rate_by_service"] : []
 
   // Failing pages (most errors)
-  const failing_pages = db.prepare(`
+  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
@@ -44,10 +53,10 @@ export function diagnose(db: Database, projectId: string, since?: string): Diagn
     GROUP BY l.page_id, p.url
     ORDER BY error_count DESC
     LIMIT 10
-  `).all({ $p: projectId, $since: window }) as DiagnosisResult["failing_pages"]
+  `).all({ $p: projectId, $since: window }) as DiagnosisResult["failing_pages"] : []
 
   // Perf regressions: compare latest vs previous snapshot per page
-  const perf_regressions = db.prepare(`
+  const perf_regressions = want("perf") ? db.prepare(`
     SELECT * FROM (
       SELECT
         cur.page_id,
@@ -64,13 +73,19 @@ export function diagnose(db: Database, projectId: string, since?: string): Diagn
     ) WHERE delta < -5 OR delta IS NULL
     ORDER BY delta ASC
     LIMIT 10
-  `).all({ $p: projectId }) as DiagnosisResult["perf_regressions"]
+  `).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, top_errors, error_rate_by_service, failing_pages, perf_regressions, summary }
+  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/parse-time.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, it } from "bun:test"
+import { parseTime } from "./parse-time.ts"
+
+describe("parseTime", () => {
+  it("returns undefined for undefined input", () => expect(parseTime(undefined)).toBeUndefined())
+  it("returns ISO string unchanged", () => {
+    const iso = "2026-01-01T00:00:00.000Z"
+    expect(parseTime(iso)).toBe(iso)
+  })
+  it("parses 30m", () => {
+    const result = parseTime("30m")!
+    const diff = Date.now() - new Date(result).getTime()
+    expect(diff).toBeGreaterThan(29 * 60 * 1000)
+    expect(diff).toBeLessThan(31 * 60 * 1000)
+  })
+  it("parses 1h", () => {
+    const result = parseTime("1h")!
+    const diff = Date.now() - new Date(result).getTime()
+    expect(diff).toBeGreaterThan(59 * 60 * 1000)
+    expect(diff).toBeLessThan(61 * 60 * 1000)
+  })
+  it("parses 7d", () => {
+    const result = parseTime("7d")!
+    const diff = Date.now() - new Date(result).getTime()
+    expect(diff).toBeGreaterThan(6.9 * 86400 * 1000)
+    expect(diff).toBeLessThan(7.1 * 86400 * 1000)
+  })
+  it("parses 1w", () => {
+    const result = parseTime("1w")!
+    const diff = Date.now() - new Date(result).getTime()
+    expect(diff).toBeGreaterThan(6.9 * 86400 * 1000)
+  })
+  it("returns unknown strings unchanged", () => {
+    expect(parseTime("yesterday")).toBe("yesterday")
+    expect(parseTime("now")).toBe("now")
+  })
+})

package/src/lib/parse-time.ts

@@ -0,0 +1,14 @@
+/**
+ * Parses a relative time string or ISO timestamp into an ISO timestamp.
+ * Accepts: "30m", "1h", "2h", "24h", "7d", "1w" or any ISO string.
+ * Returns the input unchanged if it doesn't match a relative format.
+ */
+export function parseTime(val: string | undefined): string | undefined {
+  if (!val) return undefined
+  const m = val.match(/^(\d+(?:\.\d+)?)(m|h|d|w)$/)
+  if (!m) return val
+  const n = parseFloat(m[1]!)
+  const unit = m[2]!
+  const ms = n * ({ m: 60, h: 3600, d: 86400, w: 604800 }[unit]!) * 1000
+  return new Date(Date.now() - ms).toISOString()
+}

package/src/lib/projects.ts

@@ -54,6 +54,16 @@ export function getPage(db: Database, id: string): Page | null {
   return db.prepare("SELECT * FROM pages WHERE id = $id").get({ $id: id }) as Page | null
 }
 
+/** Resolves a project ID or name to a project ID. Returns null if not found or input is empty. */
+export function resolveProjectId(db: Database, idOrName: string | undefined | null): string | null {
+  if (!idOrName) return null
+  // Looks like a hex ID (8+ hex chars)
+  if (/^[0-9a-f]{8,}$/i.test(idOrName)) return idOrName
+  // Try name lookup (case-insensitive)
+  const p = db.prepare("SELECT id FROM projects WHERE LOWER(name) = LOWER($n)").get({ $n: idOrName }) as { id: string } | null
+  return p?.id ?? 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.ts

@@ -1,5 +1,6 @@
 import type { Database } from "bun:sqlite"
 import type { LogQuery, LogRow } from "../types/index.ts"
+import { parseTime } from "./parse-time.ts"
 
 export function searchLogs(db: Database, q: LogQuery): LogRow[] {
   const conditions: string[] = []
@@ -9,8 +10,8 @@ export function searchLogs(db: Database, q: LogQuery): LogRow[] {
   if (q.page_id) { conditions.push("l.page_id = $page_id"); params.$page_id = q.page_id }
   if (q.service) { conditions.push("l.service = $service"); params.$service = q.service }
   if (q.trace_id) { conditions.push("l.trace_id = $trace_id"); params.$trace_id = q.trace_id }
-  if (q.since) { conditions.push("l.timestamp >= $since"); params.$since = q.since }
-  if (q.until) { conditions.push("l.timestamp <= $until"); params.$until = q.until }
+  if (q.since) { conditions.push("l.timestamp >= $since"); params.$since = parseTime(q.since) ?? q.since }
+  if (q.until) { conditions.push("l.timestamp <= $until"); params.$until = parseTime(q.until) ?? q.until }
 
   if (q.level) {
     const levels = Array.isArray(q.level) ? q.level : [q.level]
@@ -54,3 +55,10 @@ export function getLogContext(db: Database, traceId: string): LogRow[] {
   return db.prepare("SELECT * FROM logs WHERE trace_id = $t ORDER BY timestamp ASC")
     .all({ $t: traceId }) as LogRow[]
 }
+
+export function getLogContextFromId(db: Database, logId: string): LogRow[] {
+  const log = db.prepare("SELECT * FROM logs WHERE id = $id").get({ $id: logId }) as LogRow | null
+  if (!log) return []
+  if (log.trace_id) return getLogContext(db, log.trace_id)
+  return [log]
+}

package/src/lib/session-context.ts

@@ -0,0 +1,28 @@
+import type { Database } from "bun:sqlite"
+import type { LogRow } from "../types/index.ts"
+
+export interface SessionContext {
+  session_id: string
+  logs: LogRow[]
+  session?: Record<string, unknown>
+  error?: string
+}
+
+export async function getSessionContext(db: Database, sessionId: string): Promise<SessionContext> {
+  const logs = db.prepare("SELECT * FROM logs WHERE session_id = $s ORDER BY timestamp ASC")
+    .all({ $s: sessionId }) as LogRow[]
+
+  const sessionsUrl = process.env.SESSIONS_URL
+  if (!sessionsUrl) {
+    return { session_id: sessionId, logs }
+  }
+
+  try {
+    const res = await fetch(`${sessionsUrl.replace(/\/$/, "")}/api/sessions/${sessionId}`)
+    if (!res.ok) return { session_id: sessionId, logs }
+    const session = await res.json() as Record<string, unknown>
+    return { session_id: sessionId, logs, session }
+  } catch (err) {
+    return { session_id: sessionId, logs, error: String(err) }
+  }
+}

package/src/lib/summarize.ts

@@ -1,12 +1,13 @@
 import type { Database } from "bun:sqlite"
 import type { LogSummary } from "../types/index.ts"
+import { parseTime } from "./parse-time.ts"
 
 export function summarizeLogs(db: Database, projectId?: string, since?: string): LogSummary[] {
   const conditions: string[] = ["level IN ('warn','error','fatal')"]
   const params: Record<string, unknown> = {}
 
   if (projectId) { conditions.push("project_id = $project_id"); params.$project_id = projectId }
-  if (since) { conditions.push("timestamp >= $since"); params.$since = since }
+  if (since) { conditions.push("timestamp >= $since"); params.$since = parseTime(since) ?? since }
 
   const where = `WHERE ${conditions.join(" AND ")}`
   const sql = `

package/src/mcp/index.ts

@@ -3,92 +3,130 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js"
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js"
 import { z } from "zod"
 import { getDb } from "../db/index.ts"
-import { ingestLog } from "../lib/ingest.ts"
-import { getLogContext, searchLogs, tailLogs } from "../lib/query.ts"
+import { ingestBatch, ingestLog } from "../lib/ingest.ts"
+import { getLogContext, getLogContextFromId, searchLogs, tailLogs } from "../lib/query.ts"
 import { summarizeLogs } from "../lib/summarize.ts"
+import { countLogs } from "../lib/count.ts"
 import { createJob, listJobs } from "../lib/jobs.ts"
-import { createPage, createProject, listPages, listProjects } from "../lib/projects.ts"
+import { createPage, createProject, listPages, listProjects, resolveProjectId } from "../lib/projects.ts"
 import { getLatestSnapshot, getPerfTrend, scoreLabel } from "../lib/perf.ts"
 import { createAlertRule, deleteAlertRule, listAlertRules } from "../lib/alerts.ts"
 import { listIssues, updateIssueStatus } from "../lib/issues.ts"
 import { diagnose } from "../lib/diagnose.ts"
 import { compare } from "../lib/compare.ts"
 import { getHealth } from "../lib/health.ts"
+import { getSessionContext } from "../lib/session-context.ts"
+import { parseTime } from "../lib/parse-time.ts"
 import type { LogLevel, LogRow } from "../types/index.ts"
 
 const db = getDb()
-const server = new McpServer({ name: "logs", version: "0.1.0" })
+const server = new McpServer({ name: "logs", version: "0.3.0" })
 
 const BRIEF_FIELDS: (keyof LogRow)[] = ["id", "timestamp", "level", "message", "service"]
 
 function applyBrief(rows: LogRow[], brief = true): unknown[] {
   if (!brief) return rows
-  return rows.map(r => ({ id: r.id, timestamp: r.timestamp, level: r.level, message: r.message, service: r.service }))
+  return rows.map(r => ({
+    id: r.id,
+    timestamp: r.timestamp,
+    level: r.level,
+    message: r.message,
+    service: r.service,
+    age_seconds: Math.floor((Date.now() - new Date(r.timestamp).getTime()) / 1000),
+  }))
 }
 
-const TOOLS: Record<string, string> = {
-  register_project: "Register a project (name, github_repo?, base_url?, description?)",
-  register_page: "Register a page URL (project_id, url, path?, name?)",
-  create_scan_job: "Schedule page scans (project_id, schedule, page_id?)",
-  log_push: "Push a log entry (level, message, project_id?, service?, trace_id?, metadata?)",
-  log_search: "Search logs (project_id?, level?, since?, text?, brief?=true, limit?)",
-  log_tail: "Recent logs (project_id?, n?, brief?=true)",
-  log_summary: "Error/warn counts by service (project_id?, since?)",
-  log_context: "All logs for a trace_id (trace_id, brief?=true)",
-  log_diagnose: "Full diagnosis: top errors, failing pages, perf regressions (project_id, since?)",
-  log_compare: "Compare two time windows for new/resolved errors and perf delta",
-  perf_snapshot: "Latest perf snapshot (project_id, page_id?)",
-  perf_trend: "Perf over time (project_id, page_id?, since?, limit?)",
-  scan_status: "Last scan jobs (project_id?)",
-  list_projects: "List all projects",
-  list_pages: "List pages for a project (project_id)",
-  list_issues: "List grouped error issues (project_id?, status?, limit?)",
-  resolve_issue: "Update issue status (id, status: open|resolved|ignored)",
-  create_alert_rule: "Create alert rule (project_id, name, level, threshold_count, window_seconds, webhook_url?)",
-  list_alert_rules: "List alert rules (project_id?)",
-  delete_alert_rule: "Delete alert rule (id)",
-  get_health: "Server health + DB stats",
-  search_tools: "Search tools by keyword (query)",
-  describe_tools: "List all tools",
+function rp(idOrName?: string): string | undefined {
+  if (!idOrName) return undefined
+  return resolveProjectId(db, idOrName) ?? idOrName
+}
+
+// Tool registry with param signatures for discoverability
+const TOOLS: Record<string, { desc: string; params: string }> = {
+  register_project:        { desc: "Register a project", params: "(name, github_repo?, base_url?, description?)" },
+  register_page:           { desc: "Register a page URL to a project", params: "(project_id, url, path?, name?)" },
+  create_scan_job:         { desc: "Schedule headless page scans", params: "(project_id, schedule, page_id?)" },
+  resolve_project:         { desc: "Resolve project name to ID", params: "(name)" },
+  log_push:                { desc: "Push a single log entry", params: "(level, message, project_id?, service?, trace_id?, metadata?)" },
+  log_push_batch:          { desc: "Push multiple log entries in one call", params: "(entries: Array<{level, message, project_id?, service?, trace_id?}>)" },
+  log_search:              { desc: "Search logs", params: "(project_id?, level?, since?, until?, text?, service?, limit?=100, brief?=true)" },
+  log_tail:                { desc: "Get N most recent logs", params: "(project_id?, n?=50, brief?=true)" },
+  log_count:               { desc: "Count logs — zero token cost, pure signal", params: "(project_id?, service?, level?, since?, until?)" },
+  log_recent_errors:       { desc: "Shortcut: recent errors + fatals", params: "(project_id?, since?='1h', limit?=20)" },
+  log_summary:             { desc: "Error/warn counts by service", params: "(project_id?, since?)" },
+  log_context:             { desc: "All logs for a trace_id", params: "(trace_id, brief?=true)" },
+  log_context_from_id:     { desc: "Trace context from a log ID (no trace_id needed)", params: "(log_id, brief?=true)" },
+  log_diagnose:            { desc: "Full diagnosis: score, top errors, failing pages, perf regressions", params: "(project_id, since?='24h', include?=['top_errors','error_rate','failing_pages','perf'])" },
+  log_compare:             { desc: "Diff two time windows for new/resolved errors", params: "(project_id, a_since, a_until, b_since, b_until)" },
+  log_session_context:     { desc: "Logs + session metadata for a session_id", params: "(session_id, brief?=true)" },
+  perf_snapshot:           { desc: "Latest performance snapshot", params: "(project_id, page_id?)" },
+  perf_trend:              { desc: "Performance over time", params: "(project_id, page_id?, since?, limit?=50)" },
+  scan_status:             { desc: "Last scan jobs", params: "(project_id?)" },
+  list_projects:           { desc: "List all projects", params: "()" },
+  list_pages:              { desc: "List pages for a project", params: "(project_id)" },
+  list_issues:             { desc: "List grouped error issues", params: "(project_id?, status?, limit?=50)" },
+  resolve_issue:           { desc: "Update issue status", params: "(id, status: open|resolved|ignored)" },
+  create_alert_rule:       { desc: "Create alert rule", params: "(project_id, name, level?, threshold_count?, window_seconds?, webhook_url?)" },
+  list_alert_rules:        { desc: "List alert rules", params: "(project_id?)" },
+  delete_alert_rule:       { desc: "Delete alert rule", params: "(id)" },
+  get_health:              { desc: "Server health + DB stats", params: "()" },
+  search_tools:            { desc: "Search tools by keyword — returns names, descriptions, param signatures", params: "(query)" },
+  describe_tools:          { desc: "List all tools with descriptions and param signatures", params: "()" },
 }
 
 server.tool("search_tools", { query: z.string() }, ({ query }) => {
   const q = query.toLowerCase()
-  const matches = Object.entries(TOOLS).filter(([k, v]) => k.includes(q) || v.toLowerCase().includes(q))
-  return { content: [{ type: "text", text: matches.map(([k, v]) => `${k}: ${v}`).join("\n") || "No matches" }] }
+  const matches = Object.entries(TOOLS).filter(([k, v]) => k.includes(q) || v.desc.toLowerCase().includes(q))
+  const text = matches.map(([k, v]) => `${k}${v.params} — ${v.desc}`).join("\n") || "No matches"
+  return { content: [{ type: "text", text }] }
 })
 
 server.tool("describe_tools", {}, () => ({
-  content: [{ type: "text", text: Object.entries(TOOLS).map(([k, v]) => `${k}: ${v}`).join("\n") }]
+  content: [{ type: "text", text: Object.entries(TOOLS).map(([k, v]) => `${k}${v.params} — ${v.desc}`).join("\n") }]
 }))
 
+server.tool("resolve_project", { name: z.string() }, ({ name }) => {
+  const id = resolveProjectId(db, name)
+  const project = id ? db.prepare("SELECT * FROM projects WHERE id = $id").get({ $id: id }) : null
+  return { content: [{ type: "text", text: JSON.stringify(project ?? { error: `Project '${name}' not found` }) }] }
+})
+
 server.tool("register_project", {
   name: z.string(), github_repo: z.string().optional(), base_url: z.string().optional(), description: z.string().optional(),
 }, (args) => ({ content: [{ type: "text", text: JSON.stringify(createProject(db, args)) }] }))
 
 server.tool("register_page", {
   project_id: z.string(), url: z.string(), path: z.string().optional(), name: z.string().optional(),
-}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createPage(db, args)) }] }))
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createPage(db, { ...args, project_id: rp(args.project_id) ?? args.project_id })) }] }))
 
 server.tool("create_scan_job", {
   project_id: z.string(), schedule: z.string(), page_id: z.string().optional(),
-}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createJob(db, args)) }] }))
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createJob(db, { ...args, project_id: rp(args.project_id) ?? args.project_id })) }] }))
 
 server.tool("log_push", {
   level: z.enum(["debug", "info", "warn", "error", "fatal"]),
   message: z.string(),
-  project_id: z.string().optional(),
-  service: z.string().optional(),
-  trace_id: z.string().optional(),
-  session_id: z.string().optional(),
-  agent: z.string().optional(),
-  url: z.string().optional(),
+  project_id: z.string().optional(), service: z.string().optional(),
+  trace_id: z.string().optional(), session_id: z.string().optional(),
+  agent: z.string().optional(), url: z.string().optional(),
   metadata: z.record(z.unknown()).optional(),
 }, (args) => {
-  const row = ingestLog(db, args)
+  const row = ingestLog(db, { ...args, project_id: rp(args.project_id) })
   return { content: [{ type: "text", text: `Logged: ${row.id}` }] }
 })
 
+server.tool("log_push_batch", {
+  entries: z.array(z.object({
+    level: z.enum(["debug", "info", "warn", "error", "fatal"]),
+    message: z.string(),
+    project_id: z.string().optional(), service: z.string().optional(),
+    trace_id: z.string().optional(), metadata: z.record(z.unknown()).optional(),
+  })),
+}, ({ entries }) => {
+  const rows = ingestBatch(db, entries.map(e => ({ ...e, project_id: rp(e.project_id) })))
+  return { content: [{ type: "text", text: `Logged ${rows.length} entries` }] }
+})
+
 server.tool("log_search", {
   project_id: z.string().optional(), page_id: z.string().optional(),
   level: z.string().optional(), service: z.string().optional(),
@@ -96,34 +134,66 @@ server.tool("log_search", {
   text: z.string().optional(), trace_id: z.string().optional(),
   limit: z.number().optional(), brief: z.boolean().optional(),
 }, (args) => {
-  const rows = searchLogs(db, { ...args, level: args.level ? (args.level.split(",") as LogLevel[]) : undefined })
+  const rows = searchLogs(db, {
+    ...args,
+    project_id: rp(args.project_id),
+    level: args.level ? (args.level.split(",") as LogLevel[]) : undefined,
+    since: parseTime(args.since) ?? args.since,
+    until: parseTime(args.until) ?? args.until,
+  })
   return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, args.brief !== false)) }] }
 })
 
 server.tool("log_tail", {
   project_id: z.string().optional(), n: z.number().optional(), brief: z.boolean().optional(),
 }, ({ project_id, n, brief }) => {
-  const rows = tailLogs(db, project_id, n ?? 50)
+  const rows = tailLogs(db, rp(project_id), n ?? 50)
   return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, brief !== false)) }] }
 })
 
+server.tool("log_count", {
+  project_id: z.string().optional(), service: z.string().optional(),
+  level: z.string().optional(), since: z.string().optional(), until: z.string().optional(),
+}, (args) => ({
+  content: [{ type: "text", text: JSON.stringify(countLogs(db, { ...args, project_id: rp(args.project_id) })) }]
+}))
+
+server.tool("log_recent_errors", {
+  project_id: z.string().optional(), since: z.string().optional(), limit: z.number().optional(),
+}, ({ project_id, since, limit }) => {
+  const rows = searchLogs(db, {
+    project_id: rp(project_id),
+    level: ["error", "fatal"],
+    since: parseTime(since ?? "1h"),
+    limit: limit ?? 20,
+  })
+  return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, true)) }] }
+})
+
 server.tool("log_summary", {
   project_id: z.string().optional(), since: z.string().optional(),
 }, ({ project_id, since }) => ({
-  content: [{ type: "text", text: JSON.stringify(summarizeLogs(db, project_id, since)) }]
+  content: [{ type: "text", text: JSON.stringify(summarizeLogs(db, rp(project_id), parseTime(since) ?? since)) }]
 }))
 
 server.tool("log_context", {
   trace_id: z.string(), brief: z.boolean().optional(),
-}, ({ trace_id, brief }) => {
-  const rows = getLogContext(db, trace_id)
-  return { content: [{ type: "text", text: JSON.stringify(applyBrief(rows, brief !== false)) }] }
-})
+}, ({ trace_id, brief }) => ({
+  content: [{ type: "text", text: JSON.stringify(applyBrief(getLogContext(db, trace_id), brief !== false)) }]
+}))
+
+server.tool("log_context_from_id", {
+  log_id: z.string(), brief: z.boolean().optional(),
+}, ({ log_id, brief }) => ({
+  content: [{ type: "text", text: JSON.stringify(applyBrief(getLogContextFromId(db, log_id), brief !== false)) }]
+}))
 
 server.tool("log_diagnose", {
-  project_id: z.string(), since: z.string().optional(),
-}, ({ project_id, since }) => ({
-  content: [{ type: "text", text: JSON.stringify(diagnose(db, project_id, since)) }]
+  project_id: z.string(),
+  since: z.string().optional(),
+  include: z.array(z.enum(["top_errors", "error_rate", "failing_pages", "perf"])).optional(),
+}, ({ project_id, since, include }) => ({
+  content: [{ type: "text", text: JSON.stringify(diagnose(db, rp(project_id) ?? project_id, since, include)) }]
 }))
 
 server.tool("log_compare", {
@@ -131,26 +201,35 @@ server.tool("log_compare", {
   a_since: z.string(), a_until: z.string(),
   b_since: z.string(), b_until: z.string(),
 }, ({ project_id, a_since, a_until, b_since, b_until }) => ({
-  content: [{ type: "text", text: JSON.stringify(compare(db, project_id, a_since, a_until, b_since, b_until)) }]
+  content: [{ type: "text", text: JSON.stringify(compare(db, rp(project_id) ?? project_id,
+    parseTime(a_since) ?? a_since, parseTime(a_until) ?? a_until,
+    parseTime(b_since) ?? b_since, parseTime(b_until) ?? b_until)) }]
 }))
 
+server.tool("log_session_context", {
+  session_id: z.string(), brief: z.boolean().optional(),
+}, async ({ session_id, brief }) => {
+  const ctx = await getSessionContext(db, session_id)
+  return { content: [{ type: "text", text: JSON.stringify({ ...ctx, logs: applyBrief(ctx.logs, brief !== false) }) }] }
+})
+
 server.tool("perf_snapshot", {
   project_id: z.string(), page_id: z.string().optional(),
 }, ({ project_id, page_id }) => {
-  const snap = getLatestSnapshot(db, project_id, page_id)
+  const snap = getLatestSnapshot(db, rp(project_id) ?? project_id, page_id)
   return { content: [{ type: "text", text: JSON.stringify(snap ? { ...snap, label: scoreLabel(snap.score) } : null) }] }
 })
 
 server.tool("perf_trend", {
   project_id: z.string(), page_id: z.string().optional(), since: z.string().optional(), limit: z.number().optional(),
 }, ({ project_id, page_id, since, limit }) => ({
-  content: [{ type: "text", text: JSON.stringify(getPerfTrend(db, project_id, page_id, since, limit ?? 50)) }]
+  content: [{ type: "text", text: JSON.stringify(getPerfTrend(db, rp(project_id) ?? project_id, page_id, parseTime(since) ?? since, limit ?? 50)) }]
 }))
 
 server.tool("scan_status", {
   project_id: z.string().optional(),
 }, ({ project_id }) => ({
-  content: [{ type: "text", text: JSON.stringify(listJobs(db, project_id)) }]
+  content: [{ type: "text", text: JSON.stringify(listJobs(db, rp(project_id))) }]
 }))
 
 server.tool("list_projects", {}, () => ({
@@ -158,13 +237,13 @@ server.tool("list_projects", {}, () => ({
 }))
 
 server.tool("list_pages", { project_id: z.string() }, ({ project_id }) => ({
-  content: [{ type: "text", text: JSON.stringify(listPages(db, project_id)) }]
+  content: [{ type: "text", text: JSON.stringify(listPages(db, rp(project_id) ?? project_id)) }]
 }))
 
 server.tool("list_issues", {
   project_id: z.string().optional(), status: z.string().optional(), limit: z.number().optional(),
 }, ({ project_id, status, limit }) => ({
-  content: [{ type: "text", text: JSON.stringify(listIssues(db, project_id, status, limit ?? 50)) }]
+  content: [{ type: "text", text: JSON.stringify(listIssues(db, rp(project_id), status, limit ?? 50)) }]
 }))
 
 server.tool("resolve_issue", {
@@ -178,12 +257,12 @@ server.tool("create_alert_rule", {
   level: z.string().optional(), service: z.string().optional(),
   threshold_count: z.number().optional(), window_seconds: z.number().optional(),
   action: z.enum(["webhook", "log"]).optional(), webhook_url: z.string().optional(),
-}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createAlertRule(db, args)) }] }))
+}, (args) => ({ content: [{ type: "text", text: JSON.stringify(createAlertRule(db, { ...args, project_id: rp(args.project_id) ?? args.project_id })) }] }))
 
 server.tool("list_alert_rules", {
   project_id: z.string().optional(),
 }, ({ project_id }) => ({
-  content: [{ type: "text", text: JSON.stringify(listAlertRules(db, project_id)) }]
+  content: [{ type: "text", text: JSON.stringify(listAlertRules(db, rp(project_id))) }]
 }))
 
 server.tool("delete_alert_rule", { id: z.string() }, ({ id }) => {

package/src/server/index.ts

@@ -1,6 +1,7 @@
 #!/usr/bin/env bun
 import { Hono } from "hono"
 import { cors } from "hono/cors"
+import { serveStatic } from "hono/bun"
 import { getDb } from "../db/index.ts"
 import { getBrowserScript } from "../lib/browser-script.ts"
 import { getHealth } from "../lib/health.ts"
@@ -37,7 +38,9 @@ app.route("/api/issues", issuesRoutes(db))
 app.route("/api/perf", perfRoutes(db))
 
 app.get("/health", (c) => c.json(getHealth(db)))
-app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok" }))
+app.get("/dashboard", (c) => c.redirect("/dashboard/"))
+app.use("/dashboard/*", serveStatic({ root: "./dashboard/dist", rewriteRequestPath: (p) => p.replace(/^\/dashboard/, "") }))
+app.get("/", (c) => c.json({ service: "@hasna/logs", port: PORT, status: "ok", dashboard: `http://localhost:${PORT}/dashboard/` }))
 
 // Start scheduler
 startScheduler(db)

package/src/server/routes/logs.ts

@@ -4,6 +4,9 @@ import { ingestBatch, ingestLog } from "../../lib/ingest.ts"
 import { getLogContext, searchLogs, tailLogs } from "../../lib/query.ts"
 import { summarizeLogs } from "../../lib/summarize.ts"
 import { exportToCsv, exportToJson } from "../../lib/export.ts"
+import { countLogs } from "../../lib/count.ts"
+import { parseTime } from "../../lib/parse-time.ts"
+import { resolveProjectId } from "../../lib/projects.ts"
 import type { LogEntry, LogLevel } from "../../types/index.ts"
 
 export function logsRoutes(db: Database) {
@@ -52,10 +55,34 @@ export function logsRoutes(db: Database) {
   // GET /api/logs/summary
   app.get("/summary", (c) => {
     const { project_id, since } = c.req.query()
-    const summary = summarizeLogs(db, project_id || undefined, since || undefined)
+    const summary = summarizeLogs(db, resolveProjectId(db, project_id) || undefined, parseTime(since) || since || undefined)
     return c.json(summary)
   })
 
+  // GET /api/logs/count
+  app.get("/count", (c) => {
+    const { project_id, service, level, since, until } = c.req.query()
+    return c.json(countLogs(db, {
+      project_id: resolveProjectId(db, project_id) || undefined,
+      service: service || undefined,
+      level: level || undefined,
+      since: since || undefined,
+      until: until || undefined,
+    }))
+  })
+
+  // GET /api/logs/recent-errors
+  app.get("/recent-errors", (c) => {
+    const { project_id, since, limit } = c.req.query()
+    const rows = searchLogs(db, {
+      project_id: resolveProjectId(db, project_id) || undefined,
+      level: ["error", "fatal"],
+      since: parseTime(since || "1h"),
+      limit: limit ? Number(limit) : 20,
+    })
+    return c.json(rows.map(r => ({ id: r.id, timestamp: r.timestamp, level: r.level, message: r.message, service: r.service, age_seconds: Math.floor((Date.now() - new Date(r.timestamp).getTime()) / 1000) })))
+  })
+
   // GET /api/logs/:trace_id/context
   app.get("/:trace_id/context", (c) => {
     const rows = getLogContext(db, c.req.param("trace_id"))