@bahulam/code 0.1.5 → 0.1.7

package/pulse/app/api/stats/route.ts

@@ -1,143 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readStatsCache, getSessions, getClaudeStorageBytes } from '@/lib/claude-reader'
-import { estimateTotalCostFromModel, getPricing } from '@/lib/pricing'
-import type { DailyActivity, SessionMeta } from '@/types/claude'
-
-export const dynamic = 'force-dynamic'
-
-/** Compute daily activity from session JSONL — fresher than stats-cache */
-function computeDailyActivityFromSessions(sessions: SessionMeta[]): DailyActivity[] {
-  const byDate = new Map<string, { messages: number; sessions: number; tools: number }>()
-  for (const s of sessions) {
-    const date = s.start_time.slice(0, 10)
-    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue
-    const existing = byDate.get(date) ?? { messages: 0, sessions: 0, tools: 0 }
-    existing.messages += (s.user_message_count ?? 0) + (s.assistant_message_count ?? 0)
-    existing.sessions += 1
-    existing.tools += Object.values(s.tool_counts ?? {}).reduce((a, b) => a + b, 0)
-    byDate.set(date, existing)
-  }
-  return Array.from(byDate.entries())
-    .map(([date, { messages, sessions: count, tools }]) => ({
-      date,
-      messageCount: messages,
-      sessionCount: count,
-      toolCallCount: tools,
-    }))
-    .sort((a, b) => a.date.localeCompare(b.date))
-}
-
-/** Merge stats dailyActivity with session-derived data; session data overrides for same dates */
-function mergeDailyActivity(
-  fromStats: DailyActivity[],
-  fromSessions: DailyActivity[]
-): DailyActivity[] {
-  const map = new Map<string, DailyActivity>()
-  for (const d of fromStats) map.set(d.date, d)
-  for (const d of fromSessions) map.set(d.date, d)
-  return Array.from(map.values()).sort((a, b) => a.date.localeCompare(b.date))
-}
-
-export async function GET() {
-  const [stats, sessions, storageBytes] = await Promise.all([
-    readStatsCache(),
-    getSessions(),
-    getClaudeStorageBytes(),
-  ])
-
-  const dailyFromSessions = computeDailyActivityFromSessions(sessions)
-  const dailyActivity = stats
-    ? mergeDailyActivity(stats.dailyActivity ?? [], dailyFromSessions)
-    : dailyFromSessions
-
-  const modelUsage = stats?.modelUsage ?? {}
-
-  // Compute estimated total cost from modelUsage
-  let totalCost = 0
-  let totalCacheSavings = 0
-  for (const [model, usage] of Object.entries(modelUsage)) {
-    const cost = estimateTotalCostFromModel(model, usage)
-    totalCost += cost
-    const p = getPricing(model)
-    totalCacheSavings += (usage.cacheReadInputTokens ?? 0) * (p.input - p.cacheRead)
-  }
-
-  // Compute total tokens
-  let totalInputTokens = 0
-  let totalOutputTokens = 0
-  let totalCacheReadTokens = 0
-  let totalCacheWriteTokens = 0
-  for (const usage of Object.values(modelUsage)) {
-    totalInputTokens += usage.inputTokens ?? 0
-    totalOutputTokens += usage.outputTokens ?? 0
-    totalCacheReadTokens += usage.cacheReadInputTokens ?? 0
-    totalCacheWriteTokens += usage.cacheCreationInputTokens ?? 0
-  }
-  const totalTokens = totalInputTokens + totalOutputTokens + totalCacheReadTokens + totalCacheWriteTokens
-
-  // Aggregate tool calls total
-  let totalToolCalls = 0
-  for (const s of sessions) {
-    for (const count of Object.values(s.tool_counts ?? {})) {
-      totalToolCalls += count
-    }
-  }
-
-  // Active days (days with at least 1 session)
-  const activeDays = dailyActivity.filter(d => d.sessionCount > 0).length
-
-  // Average session length
-  const avgSessionMinutes =
-    sessions.length > 0
-      ? sessions.reduce((sum, s) => sum + (s.duration_minutes ?? 0), 0) / sessions.length
-      : 0
-
-  // Sessions this month & week
-  const now = new Date()
-  const monthStart = new Date(now.getFullYear(), now.getMonth(), 1)
-  const weekStart = new Date(now)
-  weekStart.setDate(now.getDate() - 7)
-
-  const sessionsThisMonth = sessions.filter(
-    s => new Date(s.start_time) >= monthStart
-  ).length
-  const sessionsThisWeek = sessions.filter(
-    s => new Date(s.start_time) >= weekStart
-  ).length
-
-  const statsOut = stats
-    ? { ...stats, dailyActivity }
-    : {
-        version: 0,
-        lastComputedDate: '',
-        dailyActivity,
-        tokensByDate: [],
-        modelUsage: {},
-        totalSessions: sessions.length,
-        totalMessages: sessions.reduce((s, m) => s + (m.user_message_count ?? 0) + (m.assistant_message_count ?? 0), 0),
-        longestSession: { sessionId: '', duration: 0, messageCount: 0, timestamp: '' },
-        firstSessionDate: sessions[sessions.length - 1]?.start_time ?? '',
-        hourCounts: {},
-        totalSpeculationTimeSavedMs: 0,
-      }
-
-  return NextResponse.json({
-    stats: statsOut,
-    computed: {
-      totalCost,
-      totalCacheSavings,
-      totalTokens,
-      totalInputTokens,
-      totalOutputTokens,
-      totalCacheReadTokens,
-      totalCacheWriteTokens,
-      totalToolCalls,
-      activeDays,
-      avgSessionMinutes,
-      sessionsThisMonth,
-      sessionsThisWeek,
-      storageBytes,
-      sessionCount: sessions.length,
-    },
-  })
-}

package/pulse/app/api/todos/route.ts

@@ -1,9 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readTodos } from '@/lib/claude-reader'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET() {
-  const todos = await readTodos()
-  return NextResponse.json({ todos })
-}

package/pulse/app/api/tools/route.ts

@@ -1,160 +0,0 @@
-import path from 'path'
-import { NextResponse } from 'next/server'
-import { getSessions, listProjectSlugs, listProjectJSONLFiles, readJSONLLines } from '@/lib/claude-reader'
-import { categorizeTool, isMcpTool, parseMcpTool } from '@/lib/tool-categories'
-import type { ToolsAnalytics, ToolSummary, McpServerSummary, VersionRecord } from '@/types/claude'
-
-export const dynamic = 'force-dynamic'
-
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type AnyLine = Record<string, any>
-
-export async function GET() {
-  const sessions = await getSessions()
-  const totalSessions = sessions.length
-
-  // ── Aggregate tool counts across all sessions ──────────────────────────────
-  const toolTotals = new Map<string, number>()
-  const toolSessionCount = new Map<string, Set<string>>()
-  const mcpServerCalls = new Map<string, Map<string, number>>()
-  const mcpServerSessions = new Map<string, Set<string>>()
-  const errorCategories: Record<string, number> = {}
-  let totalErrors = 0
-
-  for (const s of sessions) {
-    const sid = s.session_id
-    for (const [tool, count] of Object.entries(s.tool_counts ?? {})) {
-      toolTotals.set(tool, (toolTotals.get(tool) ?? 0) + count)
-      if (!toolSessionCount.has(tool)) toolSessionCount.set(tool, new Set())
-      toolSessionCount.get(tool)!.add(sid)
-
-      if (isMcpTool(tool)) {
-        const parsed = parseMcpTool(tool)
-        if (parsed) {
-          if (!mcpServerCalls.has(parsed.server)) mcpServerCalls.set(parsed.server, new Map())
-          if (!mcpServerSessions.has(parsed.server)) mcpServerSessions.set(parsed.server, new Set())
-          const srv = mcpServerCalls.get(parsed.server)!
-          srv.set(parsed.tool, (srv.get(parsed.tool) ?? 0) + count)
-          mcpServerSessions.get(parsed.server)!.add(sid)
-        }
-      }
-    }
-
-    // Error categories
-    for (const [cat, count] of Object.entries(s.tool_error_categories ?? {})) {
-      errorCategories[cat] = (errorCategories[cat] ?? 0) + count
-      totalErrors += count
-    }
-  }
-
-  // ── Build ToolSummary list ─────────────────────────────────────────────────
-  const tools: ToolSummary[] = [...toolTotals.entries()]
-    .map(([name, total_calls]) => ({
-      name,
-      category: categorizeTool(name),
-      total_calls,
-      session_count: toolSessionCount.get(name)?.size ?? 0,
-      error_count: 0,
-    }))
-    .sort((a, b) => b.total_calls - a.total_calls)
-
-  const totalToolCalls = tools.reduce((s, t) => s + t.total_calls, 0)
-
-  // ── MCP server summaries ───────────────────────────────────────────────────
-  const mcp_servers: McpServerSummary[] = [...mcpServerCalls.entries()]
-    .map(([server_name, toolMap]) => {
-      const toolArr = [...toolMap.entries()]
-        .map(([name, calls]) => ({ name, calls }))
-        .sort((a, b) => b.calls - a.calls)
-      const total_calls = toolArr.reduce((s, t) => s + t.calls, 0)
-      return {
-        server_name,
-        tools: toolArr,
-        total_calls,
-        session_count: mcpServerSessions.get(server_name)?.size ?? 0,
-      }
-    })
-    .sort((a, b) => b.total_calls - a.total_calls)
-
-  // ── Feature adoption ──────────────────────────────────────────────────────
-  const featureSessions = {
-    task_agents: sessions.filter(s => s.uses_task_agent || (s.tool_counts?.Task ?? 0) > 0).length,
-    mcp: sessions.filter(s => s.uses_mcp || Object.keys(s.tool_counts ?? {}).some(isMcpTool)).length,
-    web_search: sessions.filter(s => s.uses_web_search || (s.tool_counts?.WebSearch ?? 0) > 0).length,
-    web_fetch: sessions.filter(s => s.uses_web_fetch || (s.tool_counts?.WebFetch ?? 0) > 0).length,
-    plan_mode: sessions.filter(s => (s.tool_counts?.EnterPlanMode ?? 0) > 0).length,
-    git_commits: sessions.filter(s => (s.git_commits ?? 0) > 0).length,
-  }
-
-  const feature_adoption: Record<string, { sessions: number; pct: number }> = {}
-  for (const [key, count] of Object.entries(featureSessions)) {
-    feature_adoption[key] = { sessions: count, pct: totalSessions > 0 ? count / totalSessions : 0 }
-  }
-
-  // ── Version + branch info from JSONL ─────────────────────────────────────
-  const versionData = new Map<string, { sessions: Set<string>; dates: string[] }>()
-  const branchTurns = new Map<string, number>()
-
-  const slugs = await listProjectSlugs()
-  await Promise.all(
-    slugs.map(async (slug) => {
-      const files = await listProjectJSONLFiles(slug)
-      await Promise.all(
-        files.map(async (f) => {
-          const sessionId = path.basename(f, '.jsonl')
-          let fileVersion: string | undefined
-          let fileDate: string | undefined
-
-          await readJSONLLines(f, (line: AnyLine) => {
-            if (!fileVersion && line.version) {
-              fileVersion = line.version
-              fileDate = line.timestamp
-            }
-            if (line.gitBranch && line.gitBranch !== 'HEAD') {
-              branchTurns.set(line.gitBranch, (branchTurns.get(line.gitBranch) ?? 0) + 1)
-            }
-          })
-
-          if (fileVersion) {
-            if (!versionData.has(fileVersion)) {
-              versionData.set(fileVersion, { sessions: new Set(), dates: [] })
-            }
-            const vd = versionData.get(fileVersion)!
-            vd.sessions.add(sessionId)
-            if (fileDate) vd.dates.push(fileDate)
-          }
-        })
-      )
-    })
-  )
-
-  const versions: VersionRecord[] = [...versionData.entries()]
-    .map(([version, data]) => {
-      const sortedDates = data.dates.sort()
-      return {
-        version,
-        session_count: data.sessions.size,
-        first_seen: sortedDates[0] ?? '',
-        last_seen: sortedDates[sortedDates.length - 1] ?? '',
-      }
-    })
-    .sort((a, b) => b.last_seen.localeCompare(a.last_seen))
-
-  const branches = [...branchTurns.entries()]
-    .map(([branch, turns]) => ({ branch, turns }))
-    .sort((a, b) => b.turns - a.turns)
-    .slice(0, 15)
-
-  const result: ToolsAnalytics = {
-    tools,
-    mcp_servers,
-    feature_adoption,
-    versions,
-    branches,
-    error_categories: errorCategories,
-    total_tool_calls: totalToolCalls,
-    total_errors: totalErrors,
-  }
-
-  return NextResponse.json(result)
-}

package/pulse/app/benchmarks/page.tsx

@@ -1,224 +0,0 @@
-'use client'
-
-import { useEffect, useState } from 'react'
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
-import { Badge } from '@/components/ui/badge'
-
-interface BenchmarkStats {
-  total_runs: number
-  passed: number
-  failed: number
-  error: number
-  success_rate: number
-  avg_duration: number
-  total_cost: number
-  total_tokens: number
-  avg_tokens_per_run: number
-  by_status: Record<string, number>
-  by_repo: Record<string, { count: number; passed: number; success_rate: number }>
-  by_model: Record<string, { count: number; passed: number; success_rate: number }>
-}
-
-interface BenchmarkResponse {
-  stats: BenchmarkStats
-  filters: {
-    repo: string | null
-    model: string | null
-    status: string | null
-  }
-}
-
-export default function BenchmarksPage() {
-  const [data, setData] = useState<BenchmarkResponse | null>(null)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-
-  useEffect(() => {
-    const fetchBenchmarks = async () => {
-      try {
-        const response = await fetch('/api/benchmarks')
-        if (!response.ok) {
-          throw new Error('Failed to fetch benchmarks')
-        }
-        const json = await response.json()
-        setData(json)
-      } catch (err) {
-        setError(err instanceof Error ? err.message : 'Unknown error')
-      } finally {
-        setLoading(false)
-      }
-    }
-
-    fetchBenchmarks()
-  }, [])
-
-  if (loading) {
-    return (
-      <div className="flex items-center justify-center min-h-screen">
-        <p className="text-muted-foreground">Loading benchmarks...</p>
-      </div>
-    )
-  }
-
-  if (error) {
-    return (
-      <div className="flex items-center justify-center min-h-screen">
-        <p className="text-destructive">Error: {error}</p>
-      </div>
-    )
-  }
-
-  if (!data) {
-    return (
-      <div className="flex items-center justify-center min-h-screen">
-        <p className="text-muted-foreground">No benchmark data available</p>
-      </div>
-    )
-  }
-
-  const stats = data.stats
-
-  return (
-    <div className="space-y-6 p-6">
-      <div>
-        <h1 className="text-3xl font-bold tracking-tight">Benchmarks</h1>
-        <p className="text-muted-foreground mt-2">SWE-Bench v4 Flash 300 Results</p>
-      </div>
-
-      {/* Key Metrics */}
-      <div className="grid gap-4 md:grid-cols-2 lg:grid-cols-4">
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm font-medium">Total Runs</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <div className="text-2xl font-bold">{stats.total_runs}</div>
-          </CardContent>
-        </Card>
-
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm font-medium">Success Rate</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <div className="text-2xl font-bold">{stats.success_rate.toFixed(1)}%</div>
-            <p className="text-xs text-muted-foreground mt-1">
-              {stats.passed} passed, {stats.failed} failed
-            </p>
-          </CardContent>
-        </Card>
-
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm font-medium">Total Cost</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <div className="text-2xl font-bold">${stats.total_cost.toFixed(2)}</div>
-            <p className="text-xs text-muted-foreground mt-1">
-              {stats.avg_tokens_per_run.toFixed(0)} tokens/run
-            </p>
-          </CardContent>
-        </Card>
-
-        <Card>
-          <CardHeader className="pb-2">
-            <CardTitle className="text-sm font-medium">Avg Duration</CardTitle>
-          </CardHeader>
-          <CardContent>
-            <div className="text-2xl font-bold">{stats.avg_duration.toFixed(1)}s</div>
-            <p className="text-xs text-muted-foreground mt-1">
-              {(stats.total_tokens / 1000).toFixed(1)}K tokens total
-            </p>
-          </CardContent>
-        </Card>
-      </div>
-
-      {/* Status Breakdown */}
-      <Card>
-        <CardHeader>
-          <CardTitle>Status Breakdown</CardTitle>
-          <CardDescription>Distribution of run statuses</CardDescription>
-        </CardHeader>
-        <CardContent>
-          <div className="space-y-3">
-            {Object.entries(stats.by_status).map(([status, count]) => (
-              <div key={status} className="flex items-center justify-between">
-                <div className="flex items-center gap-2">
-                  <Badge
-                    variant={
-                      status === 'success'
-                        ? 'default'
-                        : status === 'failed'
-                          ? 'destructive'
-                          : 'secondary'
-                    }
-                  >
-                    {status}
-                  </Badge>
-                  <span className="text-sm text-muted-foreground">{count} runs</span>
-                </div>
-                <span className="text-sm font-medium">
-                  {((count / stats.total_runs) * 100).toFixed(1)}%
-                </span>
-              </div>
-            ))}
-          </div>
-        </CardContent>
-      </Card>
-
-      {/* By Repository */}
-      <Card>
-        <CardHeader>
-          <CardTitle>Performance by Repository</CardTitle>
-          <CardDescription>Success rate and run count per repository</CardDescription>
-        </CardHeader>
-        <CardContent>
-          <div className="space-y-4">
-            {Object.entries(stats.by_repo)
-              .sort((a, b) => b[1].count - a[1].count)
-              .map(([repo, data]) => (
-                <div key={repo} className="flex items-center justify-between border-b pb-3 last:border-0">
-                  <div>
-                    <p className="font-medium text-sm">{repo}</p>
-                    <p className="text-xs text-muted-foreground">
-                      {data.count} runs, {data.passed} passed
-                    </p>
-                  </div>
-                  <div className="text-right">
-                    <p className="font-bold text-sm">{data.success_rate.toFixed(1)}%</p>
-                  </div>
-                </div>
-              ))}
-          </div>
-        </CardContent>
-      </Card>
-
-      {/* By Model */}
-      <Card>
-        <CardHeader>
-          <CardTitle>Performance by Model</CardTitle>
-          <CardDescription>Success rate and run count per model</CardDescription>
-        </CardHeader>
-        <CardContent>
-          <div className="space-y-4">
-            {Object.entries(stats.by_model)
-              .sort((a, b) => b[1].count - a[1].count)
-              .map(([model, data]) => (
-                <div key={model} className="flex items-center justify-between border-b pb-3 last:border-0">
-                  <div>
-                    <p className="font-medium text-sm">{model}</p>
-                    <p className="text-xs text-muted-foreground">
-                      {data.count} runs, {data.passed} passed
-                    </p>
-                  </div>
-                  <div className="text-right">
-                    <p className="font-bold text-sm">{data.success_rate.toFixed(1)}%</p>
-                  </div>
-                </div>
-              ))}
-          </div>
-        </CardContent>
-      </Card>
-    </div>
-  )
-}