har-mcp 0.1.0

package/src/tools/read-har/formatters/stats.ts

@@ -0,0 +1,129 @@
+/**
+ * Stats Formatter for Read HAR Tool
+ */
+
+import type { HarFile } from "../../../types/har.ts"
+import { formatDuration } from "../helpers.ts"
+
+/**
+ * Formats stats mode output - aggregate statistics by endpoint
+ */
+export function formatStats(harFile: HarFile, filename: string): string {
+  const entries = harFile.log.entries
+  const lines: string[] = []
+
+  // Group by endpoint pattern
+  const endpointStats = new Map<
+    string,
+    {
+      count: number
+      methods: Set<string>
+      durations: number[]
+      sizes: number[]
+      errors: number
+      statuses: Map<number, number>
+    }
+  >()
+
+  for (const entry of entries) {
+    try {
+      const url = new URL(entry.request.url)
+      // Create pattern by replacing IDs with *
+      const pathParts = url.pathname.split("/").filter(Boolean)
+      const patternParts = pathParts.map(part => {
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(part)) return "*"
+        if (/^\d+$/.test(part)) return "*"
+        if (/^[0-9a-f]{24,}$/i.test(part)) return "*"
+        return part
+      })
+      const pattern = `${url.host}/${patternParts.join("/")}`
+
+      const existing = endpointStats.get(pattern) || {
+        count: 0,
+        methods: new Set<string>(),
+        durations: [],
+        sizes: [],
+        errors: 0,
+        statuses: new Map<number, number>(),
+      }
+
+      existing.count++
+      existing.methods.add(entry.request.method)
+      existing.durations.push(entry.time)
+      existing.sizes.push(entry.response.content.size)
+      if (entry.response.status >= 400) existing.errors++
+      existing.statuses.set(entry.response.status, (existing.statuses.get(entry.response.status) || 0) + 1)
+
+      endpointStats.set(pattern, existing)
+    } catch {
+      // Skip invalid URLs
+    }
+  }
+
+  lines.push(`# HAR Statistics: ${filename}`)
+  lines.push("")
+  lines.push(`**Total Entries:** ${entries.length}`)
+  lines.push(`**Unique Endpoints:** ${endpointStats.size}`)
+  lines.push("")
+
+  // Sort by count descending
+  const sorted = Array.from(endpointStats.entries()).sort((a, b) => b[1].count - a[1].count)
+
+  lines.push("## Endpoint Statistics")
+  lines.push("")
+  lines.push("| Endpoint | Count | Methods | Avg Time | P95 Time | Error Rate |")
+  lines.push("|----------|-------|---------|----------|----------|------------|")
+
+  for (const [pattern, stats] of sorted) {
+    const avgTime = stats.durations.reduce((a, b) => a + b, 0) / stats.durations.length
+    const sortedDurations = [...stats.durations].sort((a, b) => a - b)
+    const p95Idx = Math.floor(sortedDurations.length * 0.95)
+    const p95Time = sortedDurations[p95Idx] || sortedDurations[sortedDurations.length - 1] || 0
+    const errorRate = ((stats.errors / stats.count) * 100).toFixed(1)
+    const methods = Array.from(stats.methods).join(",")
+
+    const truncatedPattern = pattern.length > 40 ? `${pattern.slice(0, 37)}...` : pattern
+    lines.push(
+      `| ${truncatedPattern} | ${stats.count} | ${methods} | ${formatDuration(avgTime)} | ${formatDuration(p95Time)} | ${errorRate}% |`,
+    )
+  }
+
+  lines.push("")
+
+  // Top slowest endpoints
+  const slowest = sorted
+    .map(([pattern, stats]) => ({
+      pattern,
+      avg: stats.durations.reduce((a, b) => a + b, 0) / stats.durations.length,
+    }))
+    .sort((a, b) => b.avg - a.avg)
+    .slice(0, 5)
+
+  if (slowest.length > 0) {
+    lines.push("## Slowest Endpoints (by avg)")
+    for (const { pattern, avg } of slowest) {
+      lines.push(`- ${pattern.slice(0, 50)}: ${formatDuration(avg)}`)
+    }
+    lines.push("")
+  }
+
+  // Highest error rate endpoints
+  const highestErrors = sorted
+    .filter(([, stats]) => stats.errors > 0)
+    .map(([pattern, stats]) => ({
+      pattern,
+      rate: (stats.errors / stats.count) * 100,
+      count: stats.errors,
+    }))
+    .sort((a, b) => b.rate - a.rate)
+    .slice(0, 5)
+
+  if (highestErrors.length > 0) {
+    lines.push("## Highest Error Rates")
+    for (const { pattern, rate, count } of highestErrors) {
+      lines.push(`- ${pattern.slice(0, 50)}: ${rate.toFixed(1)}% (${count} errors)`)
+    }
+  }
+
+  return lines.join("\n")
+}

package/src/tools/read-har/formatters/summary.ts

@@ -0,0 +1,174 @@
+/**
+ * Summary Formatter for Read HAR Tool
+ */
+
+import type { HarFile } from "../../../types/har.ts"
+import {
+  formatDuration,
+  getContentTypeCategory,
+  getUrlPath,
+  identifyUrlPatterns,
+  isError,
+  truncateUrl,
+} from "../helpers.ts"
+
+/**
+ * Formats summary mode output
+ */
+export function formatSummary(harFile: HarFile, filename: string): string {
+  const log = harFile.log
+  const entries = log.entries
+
+  // Collect statistics
+  const methodCounts = new Map<string, number>()
+  const statusCounts = new Map<string, number>()
+  const typeCounts = new Map<string, number>()
+  const errorEntries: { status: number; url: string }[] = []
+  let totalDuration = 0
+  const durations: number[] = []
+  let slowestEntry: { index: number; url: string; duration: number } | null = null
+
+  for (let index = 0; index < entries.length; index++) {
+    const entry = entries[index]!
+
+    // Method counts
+    const method = entry.request.method
+    methodCounts.set(method, (methodCounts.get(method) || 0) + 1)
+
+    // Status counts (group by class)
+    const statusClass = `${Math.floor(entry.response.status / 100)}xx`
+    statusCounts.set(statusClass, (statusCounts.get(statusClass) || 0) + 1)
+
+    // Content type counts
+    const contentType = getContentTypeCategory(entry.response.content.mimeType)
+    typeCounts.set(contentType, (typeCounts.get(contentType) || 0) + 1)
+
+    // Errors
+    if (isError(entry)) {
+      errorEntries.push({ status: entry.response.status, url: getUrlPath(entry.request.url) })
+    }
+
+    // Duration stats
+    const duration = entry.time
+    totalDuration += duration
+    durations.push(duration)
+
+    if (!slowestEntry || duration > slowestEntry.duration) {
+      slowestEntry = { index, url: getUrlPath(entry.request.url), duration }
+    }
+  }
+
+  // Calculate percentiles
+  durations.sort((a, b) => a - b)
+  const avgDuration = entries.length > 0 ? totalDuration / entries.length : 0
+  const p95Index = Math.floor(durations.length * 0.95)
+  const p95Duration = durations[p95Index] || 0
+
+  // Group errors by status
+  const errorsByStatus = new Map<number, string[]>()
+  for (const error of errorEntries) {
+    const urls = errorsByStatus.get(error.status) || []
+    urls.push(error.url)
+    errorsByStatus.set(error.status, urls)
+  }
+
+  // Get URL patterns
+  const urlPatterns = identifyUrlPatterns(entries)
+  const topPatterns = Array.from(urlPatterns.entries())
+    .sort((a, b) => b[1].count - a[1].count)
+    .slice(0, 10)
+
+  // Build output
+  const lines: string[] = []
+
+  lines.push(`# HAR Summary: ${filename}`)
+  lines.push("")
+
+  // File Info
+  lines.push("## File Info")
+  lines.push(`- **Version:** ${log.version}`)
+  lines.push(`- **Creator:** ${log.creator.name} ${log.creator.version}`)
+  const firstEntry = entries[0]
+  if (firstEntry) {
+    lines.push(`- **Captured:** ${firstEntry.startedDateTime}`)
+  }
+  lines.push(`- **Total Entries:** ${entries.length}`)
+  lines.push("")
+
+  // Pages
+  if (log.pages && log.pages.length > 0) {
+    lines.push("## Pages")
+    lines.push("| # | Title | Load Time |")
+    lines.push("|---|-------|-----------|")
+    log.pages.forEach((page, i) => {
+      const loadTime = page.pageTimings.onLoad ? formatDuration(page.pageTimings.onLoad) : "-"
+      lines.push(`| ${i + 1} | ${page.title} | ${loadTime} |`)
+    })
+    lines.push("")
+  }
+
+  // Request Statistics
+  lines.push("## Request Statistics")
+
+  // Methods
+  const methodStr = Array.from(methodCounts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .map(([m, c]) => `${m} (${c})`)
+    .join(", ")
+  lines.push(`- **By Method:** ${methodStr}`)
+
+  // Status
+  const statusStr = Array.from(statusCounts.entries())
+    .sort((a, b) => a[0].localeCompare(b[0]))
+    .map(([s, c]) => `${s} (${c})`)
+    .join(", ")
+  lines.push(`- **By Status:** ${statusStr}`)
+
+  // Types
+  const typeStr = Array.from(typeCounts.entries())
+    .sort((a, b) => b[1] - a[1])
+    .map(([t, c]) => `${t} (${c})`)
+    .join(", ")
+  lines.push(`- **By Type:** ${typeStr}`)
+  lines.push("")
+
+  // Errors
+  if (errorsByStatus.size > 0) {
+    lines.push(`## Errors (${errorEntries.length} total)`)
+    lines.push("| Status | Count | Example URLs |")
+    lines.push("|--------|-------|--------------|")
+    for (const [status, urls] of Array.from(errorsByStatus.entries()).sort((a, b) => a[0] - b[0])) {
+      const exampleUrls = urls
+        .slice(0, 3)
+        .map(u => truncateUrl(u, 30))
+        .join(", ")
+      lines.push(`| ${status} | ${urls.length} | ${exampleUrls} |`)
+    }
+    lines.push("")
+  }
+
+  // Performance
+  lines.push("## Performance")
+  if (slowestEntry) {
+    lines.push(
+      `- **Slowest:** #${slowestEntry.index} ${truncateUrl(slowestEntry.url, 40)} (${formatDuration(slowestEntry.duration)})`,
+    )
+  }
+  lines.push(`- **Average:** ${formatDuration(avgDuration)}`)
+  lines.push(`- **P95:** ${formatDuration(p95Duration)}`)
+  lines.push("")
+
+  // Top URL Patterns
+  if (topPatterns.length > 0) {
+    lines.push("## Top URL Patterns")
+    lines.push("| Pattern | Count | Methods |")
+    lines.push("|---------|-------|---------|")
+    for (const [pattern, data] of topPatterns) {
+      const methods = Array.from(data.methods).join(", ")
+      lines.push(`| ${truncateUrl(pattern, 40)} | ${data.count} | ${methods} |`)
+    }
+    lines.push("")
+  }
+
+  return lines.join("\n")
+}

package/src/tools/read-har/formatters/timeline.ts

@@ -0,0 +1,95 @@
+/**
+ * Timeline Formatter for Read HAR Tool
+ */
+
+import type { HarFile } from "../../../types/har.ts"
+import { formatDuration } from "../helpers.ts"
+
+/**
+ * Gets the bar character based on status code
+ */
+function getStatusBar(status: number, length: number): string {
+  let char: string
+  if (status < 300) char = "█"
+  else if (status < 400) char = "▓"
+  else if (status < 500) char = "░"
+  else char = "▒"
+  return char.repeat(length)
+}
+
+/**
+ * Formats timeline mode output - text-based waterfall visualization
+ */
+export function formatTimeline(harFile: HarFile, filename: string, pageSize = 20, page = 1): string {
+  const entries = harFile.log.entries
+  const lines: string[] = []
+
+  if (entries.length === 0) {
+    return "# Timeline\n\nNo entries to display."
+  }
+
+  // Get time range
+  const startTimes = entries.map(e => new Date(e.startedDateTime).getTime())
+  const minTime = Math.min(...startTimes)
+  const endTimes = entries.map((e, i) => startTimes[i]! + e.time)
+  const maxTime = Math.max(...endTimes)
+  const totalDuration = maxTime - minTime
+
+  // Pagination
+  const start = (page - 1) * pageSize
+  const pageEntries = entries.slice(start, start + pageSize)
+  const totalPages = Math.ceil(entries.length / pageSize)
+
+  lines.push(`# HAR Timeline: ${filename}`)
+  lines.push("")
+  lines.push(
+    `**Duration:** ${formatDuration(totalDuration)} | **Entries:** ${entries.length} | **Page:** ${page}/${totalPages}`,
+  )
+  lines.push("")
+
+  // Width for the bar visualization
+  const barWidth = 40
+
+  lines.push("```")
+  lines.push(`${"Time".padEnd(8)} ${"Method".padEnd(7)} ${"Bar".padEnd(barWidth + 2)} ${"Duration".padEnd(10)} URL`)
+  lines.push(`${"-".repeat(8)} ${"-".repeat(7)} ${"-".repeat(barWidth + 2)} ${"-".repeat(10)} ${"-".repeat(30)}`)
+
+  for (let i = 0; i < pageEntries.length; i++) {
+    const entry = pageEntries[i]!
+    const entryStart = new Date(entry.startedDateTime).getTime()
+    const relativeStart = entryStart - minTime
+    const duration = entry.time
+
+    // Calculate bar position and width
+    const barStart = Math.floor((relativeStart / totalDuration) * barWidth)
+    const barLength = Math.max(1, Math.ceil((duration / totalDuration) * barWidth))
+
+    // Create the bar
+    const bar = " ".repeat(barStart) + getStatusBar(entry.response.status, barLength)
+    const paddedBar = `[${bar.padEnd(barWidth)}]`
+
+    // Format time offset
+    const timeOffset = formatDuration(relativeStart).padEnd(8)
+
+    // Method and URL
+    const method = entry.request.method.padEnd(7)
+    const durationStr = formatDuration(duration).padEnd(10)
+
+    // Truncate URL
+    let url: string
+    try {
+      const parsed = new URL(entry.request.url)
+      url = parsed.pathname.slice(0, 30)
+    } catch {
+      url = entry.request.url.slice(0, 30)
+    }
+
+    lines.push(`${timeOffset} ${method} ${paddedBar} ${durationStr} ${url}`)
+  }
+
+  lines.push("```")
+  lines.push("")
+  lines.push("**Legend:** █ = 2xx, ▓ = 3xx, ░ = 4xx, ▒ = 5xx")
+
+  return lines.join("\n")
+}

package/src/tools/read-har/helpers.ts

@@ -0,0 +1,237 @@
+/**
+ * Helper Functions for Read HAR Tool
+ */
+
+import type { HarEntry, HarTimings } from "../../types/har.ts"
+
+/**
+ * Formats bytes into human-readable string
+ */
+export function formatBytes(bytes: number): string {
+  if (bytes < 0) return "-"
+  if (bytes === 0) return "0B"
+  if (bytes < 1024) return `${bytes}B`
+  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)}KB`
+  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)}MB`
+  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)}GB`
+}
+
+/**
+ * Formats duration in milliseconds to human-readable string
+ */
+export function formatDuration(ms: number): string {
+  if (ms < 0) return "-"
+  if (ms < 1) return "<1ms"
+  if (ms < 1000) return `${Math.round(ms)}ms`
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`
+  return `${(ms / 60000).toFixed(1)}min`
+}
+
+/**
+ * Matches URL against a pattern (substring, glob, or regex)
+ */
+export function matchUrl(url: string, pattern: string): boolean {
+  // Regex pattern (starts with ~)
+  if (pattern.startsWith("~")) {
+    try {
+      const regex = new RegExp(pattern.slice(1), "i")
+      return regex.test(url)
+    } catch {
+      return false
+    }
+  }
+
+  // Glob pattern (contains *)
+  if (pattern.includes("*")) {
+    const regexPattern = pattern
+      .replace(/[.+^${}()|[\]\\]/g, "\\$&") // Escape special chars except *
+      .replace(/\*/g, ".*") // Convert * to .*
+    try {
+      const regex = new RegExp(`^${regexPattern}$`, "i")
+      return regex.test(url)
+    } catch {
+      return false
+    }
+  }
+
+  // Substring match (case-insensitive)
+  return url.toLowerCase().includes(pattern.toLowerCase())
+}
+
+/**
+ * Matches status code against filter
+ */
+export function matchStatus(status: number, filter: number | string | { min?: number; max?: number }): boolean {
+  if (typeof filter === "number") {
+    return status === filter
+  }
+
+  if (typeof filter === "string") {
+    // Pattern like "2xx", "4xx", "5xx"
+    const match = filter.match(/^(\d)xx$/i)
+    if (match?.[1]) {
+      const firstDigit = Number.parseInt(match[1], 10)
+      return Math.floor(status / 100) === firstDigit
+    }
+    return false
+  }
+
+  // Range filter
+  const { min, max } = filter
+  if (min !== undefined && status < min) return false
+  if (max !== undefined && status > max) return false
+  return true
+}
+
+/**
+ * Gets content type category from MIME type
+ */
+export function getContentTypeCategory(mimeType: string): string {
+  const type = mimeType.toLowerCase()
+  if (type.includes("json")) return "JSON"
+  if (type.includes("html")) return "HTML"
+  if (type.includes("javascript") || type.includes("ecmascript")) return "JS"
+  if (type.includes("css")) return "CSS"
+  if (type.includes("xml")) return "XML"
+  if (type.includes("image")) return "Image"
+  if (type.includes("font")) return "Font"
+  if (type.includes("text/plain")) return "Text"
+  if (type.includes("form")) return "Form"
+  if (type.includes("video")) return "Video"
+  if (type.includes("audio")) return "Audio"
+  return "Other"
+}
+
+/**
+ * Truncates URL for display - shows domain + last path segment
+ */
+export function truncateUrl(url: string, maxLength = 60): string {
+  if (url.length <= maxLength) return url
+  try {
+    const parsed = new URL(url)
+    const pathParts = parsed.pathname.split("/").filter(Boolean)
+    const lastPart = pathParts[pathParts.length - 1] || ""
+    const domain = parsed.hostname
+
+    // Try: domain + /.../ + lastPart
+    const shortened = `${domain}/.../${lastPart}`
+    if (shortened.length <= maxLength) return shortened
+
+    // If still too long, truncate the last part
+    const availableForPath = maxLength - domain.length - 5 // 5 for "/.../"
+    if (availableForPath > 10) {
+      return `${domain}/.../${lastPart.slice(0, availableForPath)}`
+    }
+
+    // Fallback: just truncate
+    return `${url.slice(0, maxLength - 3)}...`
+  } catch {
+    return `${url.slice(0, maxLength - 3)}...`
+  }
+}
+
+/**
+ * Gets the path portion of a URL for display
+ */
+export function getUrlPath(url: string): string {
+  try {
+    const parsed = new URL(url)
+    return parsed.pathname + parsed.search
+  } catch {
+    return url
+  }
+}
+
+/**
+ * Checks if an entry is an error (4xx or 5xx status)
+ */
+export function isError(entry: HarEntry): boolean {
+  return entry.response.status >= 400
+}
+
+/**
+ * Gets response size from entry
+ */
+export function getResponseSize(entry: HarEntry): number {
+  const bodySize = entry.response.bodySize
+  if (bodySize >= 0) return bodySize
+  return entry.response.content.size
+}
+
+/**
+ * Calculates total timing from timings object
+ */
+export function getTotalTiming(timings: HarTimings): number {
+  let total = 0
+  if (timings.blocked && timings.blocked > 0) total += timings.blocked
+  if (timings.dns && timings.dns > 0) total += timings.dns
+  if (timings.connect && timings.connect > 0) total += timings.connect
+  if (timings.ssl && timings.ssl > 0) total += timings.ssl
+  total += timings.send > 0 ? timings.send : 0
+  total += timings.wait > 0 ? timings.wait : 0
+  total += timings.receive > 0 ? timings.receive : 0
+  return total
+}
+
+/**
+ * Identifies URL patterns in entries
+ */
+export function identifyUrlPatterns(entries: HarEntry[]): Map<string, { count: number; methods: Set<string> }> {
+  const patterns = new Map<string, { count: number; methods: Set<string> }>()
+
+  for (const entry of entries) {
+    try {
+      const url = new URL(entry.request.url)
+      // Create pattern by generalizing path segments
+      const pathParts = url.pathname.split("/").filter(Boolean)
+      const patternParts = pathParts.map(part => {
+        // Replace UUIDs, numbers, and hex strings with wildcards
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(part)) return "*"
+        if (/^\d+$/.test(part)) return "*"
+        if (/^[0-9a-f]{24,}$/i.test(part)) return "*"
+        return part
+      })
+      const pattern = `/${patternParts.join("/")}${url.pathname.endsWith("/") ? "/" : ""}`
+
+      const existing = patterns.get(pattern)
+      if (existing) {
+        existing.count++
+        existing.methods.add(entry.request.method)
+      } else {
+        patterns.set(pattern, { count: 1, methods: new Set([entry.request.method]) })
+      }
+    } catch {
+      // Skip invalid URLs
+    }
+  }
+
+  return patterns
+}
+
+/**
+ * Gets appropriate code fence language for MIME type
+ */
+export function getCodeFenceLanguage(mimeType: string): string {
+  const type = mimeType.toLowerCase()
+  if (type.includes("json")) return "json"
+  if (type.includes("html")) return "html"
+  if (type.includes("xml")) return "xml"
+  if (type.includes("javascript")) return "javascript"
+  if (type.includes("css")) return "css"
+  return ""
+}
+
+/**
+ * Formats content for display (pretty-print JSON if applicable)
+ */
+export function formatContentForDisplay(content: string, mimeType: string): string {
+  if (mimeType.toLowerCase().includes("json")) {
+    try {
+      const parsed = JSON.parse(content)
+      return JSON.stringify(parsed, null, 2)
+    } catch {
+      return content
+    }
+  }
+  return content
+}