@bahulam/code 0.1.5 → 0.1.7

package/pulse/app/activity/page.tsx

@@ -1,190 +0,0 @@
-'use client'
-
-import useSWR from 'swr'
-import { TopBar } from '@/components/layout/top-bar'
-import { ActivityHeatmap } from '@/components/overview/activity-heatmap'
-import { PeakHoursChart } from '@/components/overview/peak-hours-chart'
-import { DayOfWeekChart } from '@/components/activity/day-of-week-chart'
-import { UsageOverTimeChart } from '@/components/overview/usage-over-time-chart'
-import type { DailyActivity } from '@/types/claude'
-import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
-import { Skeleton } from '@/components/ui/skeleton'
-import { Alert, AlertDescription } from '@/components/ui/alert'
-import { AlertTriangle, Flame, CalendarDays, BarChart3, Clock, Zap, TrendingUp, Star } from 'lucide-react'
-
-const fetcher = (url: string) =>
-  fetch(url).then(r => { if (!r.ok) throw new Error(`API error ${r.status}`); return r.json() })
-
-interface ActivityData {
-  daily_activity: DailyActivity[]
-  hour_counts: Array<{ hour: number; count: number }>
-  dow_counts: Array<{ day: string; count: number }>
-  streaks: { current: number; longest: number }
-  most_active_day: string
-  most_active_day_msgs: number
-  total_active_days: number
-}
-
-function StatTile({
-  label,
-  value,
-  sub,
-  icon: Icon,
-  color,
-}: {
-  label: string
-  value: string | number
-  sub: string
-  icon: React.ElementType
-  color: string
-}) {
-  return (
-    <Card className="gap-0">
-      <CardHeader className="pb-2">
-        <CardDescription className="flex items-center gap-2 text-sm font-medium">
-          <Icon className="h-4 w-4 shrink-0 text-muted-foreground" />
-          {label}
-        </CardDescription>
-        <CardTitle className="text-3xl font-bold tabular-nums leading-none" style={{ color }}>
-          {value}
-        </CardTitle>
-      </CardHeader>
-      <CardContent className="pt-0">
-        <p className="text-xs text-muted-foreground">{sub}</p>
-      </CardContent>
-    </Card>
-  )
-}
-
-export default function ActivityPage() {
-  const { data, error, isLoading } = useSWR<ActivityData>('/api/activity', fetcher, { refreshInterval: 5_000 })
-
-  const hourCounts = data
-    ? Object.fromEntries(data.hour_counts.map(h => [String(h.hour), h.count]))
-    : {}
-
-  return (
-    <div className="flex flex-col min-h-screen">
-      <TopBar title="Activity" subtitle="Patterns, streaks, and peak hours" />
-      <div className="w-full space-y-4 p-4 md:p-6">
-
-        {error && (
-          <Alert variant="destructive">
-            <AlertTriangle className="h-4 w-4" />
-            <AlertDescription>Error loading data: {String(error)}</AlertDescription>
-          </Alert>
-        )}
-
-        {isLoading && (
-          <>
-            <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
-              {Array.from({ length: 4 }).map((_, i) => <Skeleton key={i} className="h-28 rounded-xl" />)}
-            </div>
-            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
-              <Skeleton className="h-72 min-h-72 rounded-xl md:min-h-80" />
-              <Skeleton className="h-56 min-h-56 rounded-xl md:min-h-80" />
-            </div>
-            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
-              <Skeleton className="h-64 rounded-xl md:min-h-72" />
-              <Skeleton className="h-56 rounded-xl md:min-h-72" />
-            </div>
-          </>
-        )}
-
-        {data && (
-          <>
-            {/* Stat tiles */}
-            <div className="grid grid-cols-2 md:grid-cols-4 gap-4">
-              <StatTile
-                label="Current Streak"
-                value={data.streaks.current}
-                sub="consecutive days"
-                icon={Flame}
-                color="#f97316"
-              />
-              <StatTile
-                label="Longest Streak"
-                value={data.streaks.longest}
-                sub="personal best"
-                icon={Zap}
-                color="var(--viz-sky)"
-              />
-              <StatTile
-                label="Active Days"
-                value={data.total_active_days}
-                sub="total days with activity"
-                icon={TrendingUp}
-                color="#a78bfa"
-              />
-              <StatTile
-                label="Most Active Day"
-                value={data.most_active_day ? data.most_active_day.slice(5) : '—'}
-                sub={data.most_active_day_msgs ? `${data.most_active_day_msgs.toLocaleString()} messages` : 'no data'}
-                icon={Star}
-                color="#34d399"
-              />
-            </div>
-
-            {/* Row 1: Activity calendar | Peak hours */}
-            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
-              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
-                <CardHeader className="space-y-1 pb-0">
-                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
-                    <CalendarDays className="h-4 w-4 shrink-0 text-muted-foreground" />
-                    Activity Calendar
-                  </CardTitle>
-                  <CardDescription>GitHub-style contribution heatmap</CardDescription>
-                </CardHeader>
-                <CardContent className="flex flex-1 flex-col pt-3 pb-0">
-                  <ActivityHeatmap data={data.daily_activity} />
-                </CardContent>
-              </Card>
-
-              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
-                <CardHeader className="space-y-1 pb-0">
-                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
-                    <Clock className="h-4 w-4 shrink-0 text-muted-foreground" />
-                    Peak Hours
-                  </CardTitle>
-                  <CardDescription>Activity by hour of day</CardDescription>
-                </CardHeader>
-                <CardContent className="flex flex-1 flex-col justify-between pt-3 pb-0">
-                  <PeakHoursChart hourCounts={hourCounts} />
-                </CardContent>
-              </Card>
-            </div>
-
-            {/* Row 2: Usage over time | Day of week */}
-            <div className="grid grid-cols-1 gap-4 md:grid-cols-2 md:items-stretch">
-              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
-                <CardHeader className="space-y-1 pb-0">
-                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
-                    <BarChart3 className="h-4 w-4 shrink-0 text-muted-foreground" />
-                    Usage Over Time
-                  </CardTitle>
-                  <CardDescription>Messages and sessions over the last 90 days</CardDescription>
-                </CardHeader>
-                <CardContent className="flex flex-1 flex-col pt-3 pb-0">
-                  <UsageOverTimeChart data={data.daily_activity} days={90} />
-                </CardContent>
-              </Card>
-
-              <Card className="flex h-full min-h-0 min-w-0 flex-col gap-2 py-4">
-                <CardHeader className="space-y-1 pb-0">
-                  <CardTitle className="flex items-center gap-2 text-base font-semibold">
-                    <CalendarDays className="h-4 w-4 shrink-0 text-muted-foreground" />
-                    Day of Week
-                  </CardTitle>
-                  <CardDescription>Which days you use Bahulam Code most</CardDescription>
-                </CardHeader>
-                <CardContent className="flex flex-1 flex-col justify-between pt-3 pb-0">
-                  <DayOfWeekChart data={data.dow_counts} />
-                </CardContent>
-              </Card>
-            </div>
-          </>
-        )}
-      </div>
-    </div>
-  )
-}

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

@@ -1,138 +0,0 @@
-import { NextResponse } from 'next/server'
-import { getSessions, readStatsCache } from '@/lib/claude-reader'
-import type { DailyActivity, SessionMeta } from '@/types/claude'
-
-export const dynamic = 'force-dynamic'
-
-function computeStreaks(dates: Set<string>): { current: number; longest: number } {
-  const sorted = [...dates].sort()
-  if (sorted.length === 0) return { current: 0, longest: 0 }
-
-  let longest = 1
-  let streak = 1
-  for (let i = 1; i < sorted.length; i++) {
-    const prev = new Date(sorted[i - 1])
-    const curr = new Date(sorted[i])
-    const diff = (curr.getTime() - prev.getTime()) / 86_400_000
-    if (diff === 1) {
-      streak++
-      if (streak > longest) longest = streak
-    } else {
-      streak = 1
-    }
-  }
-
-  // Current streak (from today backwards)
-  const today = new Date().toISOString().slice(0, 10)
-  let current = 0
-  const d = new Date(today)
-  while (dates.has(d.toISOString().slice(0, 10))) {
-    current++
-    d.setDate(d.getDate() - 1)
-  }
-
-  return { current, longest }
-}
-
-function computeDailyActivityFromSessions(sessions: SessionMeta[]): DailyActivity[] {
-  const byDate = new Map<string, { messages: number; sessions: number; tools: number }>()
-
-  for (const s of sessions) {
-    if (!s.start_time) continue
-    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((sum, count) => sum + count, 0)
-    byDate.set(date, existing)
-  }
-
-  return Array.from(byDate.entries())
-    .map(([date, { messages, sessions: sessionCount, tools }]) => ({
-      date,
-      messageCount: messages,
-      sessionCount,
-      toolCallCount: tools,
-    }))
-    .sort((a, b) => a.date.localeCompare(b.date))
-}
-
-function mergeDailyActivity(fromStats: DailyActivity[], fromSessions: DailyActivity[]): DailyActivity[] {
-  const byDate = new Map<string, DailyActivity>()
-  for (const d of fromStats) byDate.set(d.date, d)
-  for (const d of fromSessions) byDate.set(d.date, d)
-  return Array.from(byDate.values()).sort((a, b) => a.date.localeCompare(b.date))
-}
-
-function computeHourCounts(sessions: SessionMeta[]): Array<{ hour: number; count: number }> {
-  const hourCounts = Array.from({ length: 24 }, () => 0)
-
-  for (const s of sessions) {
-    if (s.user_message_timestamps?.length) {
-      for (const ts of s.user_message_timestamps) {
-        const d = new Date(ts)
-        if (!isNaN(d.getTime())) hourCounts[d.getHours()]++
-      }
-      continue
-    }
-
-    if (s.message_hours?.length) {
-      for (const hour of s.message_hours) {
-        if (Number.isInteger(hour) && hour >= 0 && hour < 24) hourCounts[hour]++
-      }
-      continue
-    }
-
-    const d = new Date(s.start_time)
-    if (!isNaN(d.getTime())) hourCounts[d.getHours()]++
-  }
-
-  return hourCounts.map((count, hour) => ({ hour, count }))
-}
-
-export async function GET() {
-  const [stats, sessions] = await Promise.all([readStatsCache(), getSessions()])
-  const dailyFromSessions = computeDailyActivityFromSessions(sessions)
-  const dailyActivity = stats
-    ? mergeDailyActivity(stats.dailyActivity ?? [], dailyFromSessions)
-    : dailyFromSessions
-
-  // Day-of-week counts from session timestamps
-  const dowCounts: number[] = [0, 0, 0, 0, 0, 0, 0] // Sun=0..Sat=6
-  const activeDates = new Set<string>()
-
-  for (const s of sessions) {
-    if (!s.start_time) continue
-    const d = new Date(s.start_time)
-    if (isNaN(d.getTime())) continue
-    dowCounts[d.getDay()]++
-    activeDates.add(s.start_time.slice(0, 10))
-  }
-
-  const streaks = computeStreaks(activeDates)
-
-  // Most active day
-  let mostActiveDay = ''
-  let mostActiveMsgs = 0
-  for (const da of dailyActivity) {
-    if (da.messageCount > mostActiveMsgs) {
-      mostActiveMsgs = da.messageCount
-      mostActiveDay = da.date
-    }
-  }
-
-  return NextResponse.json({
-    daily_activity: dailyActivity,
-    hour_counts: computeHourCounts(sessions),
-    dow_counts: dowCounts.map((count, i) => ({
-      day: ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][i],
-      count,
-    })),
-    streaks,
-    most_active_day: mostActiveDay,
-    most_active_day_msgs: mostActiveMsgs,
-    total_active_days: activeDates.size,
-  })
-}

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

@@ -1,113 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readFileSync } from 'fs'
-import { join } from 'path'
-
-export const dynamic = 'force-dynamic'
-
-interface BenchmarkResult {
-  instance_id: string
-  repo: string
-  base_commit: string
-  test_patch: string
-  resolved: boolean
-  test_result: {
-    result: string[]
-    exit_code: number
-  }
-  metadata: {
-    agent_class: string
-    model_name: string
-    max_iterations: number
-    eval_history: Array<{
-      timestamp: string
-      action: string
-      observation: string
-    }>
-    submission: string
-    instance_id: string
-    predict_output: string
-    model_patch: string
-    test_result: {
-      result: string[]
-      exit_code: number
-    }
-  }
-}
-
-interface BenchmarkData {
-  results: BenchmarkResult[]
-}
-
-export async function GET(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url)
-    const run = searchParams.get('run') || 'swebench-v4-flash-300'
-    const limit = parseInt(searchParams.get('limit') || '50', 10)
-    const offset = parseInt(searchParams.get('offset') || '0', 10)
-
-    // Load benchmark results from file
-    const resultsPath = join(
-      process.cwd(),
-      '..',
-      'benchmark',
-      'results',
-      'runs',
-      run,
-      'harness-results.json'
-    )
-
-    let data: BenchmarkData
-    try {
-      const fileContent = readFileSync(resultsPath, 'utf-8')
-      data = JSON.parse(fileContent)
-    } catch (error) {
-      return NextResponse.json(
-        { error: `Benchmark run "${run}" not found` },
-        { status: 404 }
-      )
-    }
-
-    // Calculate statistics
-    const results = data.results || []
-    const totalTests = results.length
-    const resolvedTests = results.filter((r) => r.resolved).length
-    const passRate = totalTests > 0 ? (resolvedTests / totalTests) * 100 : 0
-
-    // Group by repo
-    const byRepo = new Map<string, number>()
-    const byRepoResolved = new Map<string, number>()
-    for (const result of results) {
-      const repo = result.repo || 'unknown'
-      byRepo.set(repo, (byRepo.get(repo) || 0) + 1)
-      if (result.resolved) {
-        byRepoResolved.set(repo, (byRepoResolved.get(repo) || 0) + 1)
-      }
-    }
-
-    // Paginate results
-    const paginatedResults = results.slice(offset, offset + limit)
-
-    return NextResponse.json({
-      run,
-      stats: {
-        totalTests,
-        resolvedTests,
-        passRate: parseFloat(passRate.toFixed(2)),
-        byRepo: Object.fromEntries(byRepo),
-        byRepoResolved: Object.fromEntries(byRepoResolved),
-      },
-      pagination: {
-        limit,
-        offset,
-        total: totalTests,
-      },
-      results: paginatedResults,
-    })
-  } catch (error) {
-    console.error('Benchmark API error:', error)
-    return NextResponse.json(
-      { error: 'Failed to load benchmark data' },
-      { status: 500 }
-    )
-  }
-}

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

@@ -1,195 +0,0 @@
-import { NextResponse } from 'next/server'
-import fs from 'fs'
-import path from 'path'
-
-export const dynamic = 'force-dynamic'
-
-interface BenchmarkResult {
-  instance_id: string
-  repo: string
-  model: string
-  timestamp: string
-  kepler: {
-    status: string
-    exit_code: number
-    duration_seconds: number
-    tokens_used: number
-    cost: number
-    tool_calls: number
-    sub_agents: string[]
-  }
-  patch_lines: number
-  model_patch: string
-  status: string
-}
-
-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 }>
-}
-
-async function loadBenchmarkResults(): Promise<BenchmarkResult[]> {
-  try {
-    const resultsPath = path.join(
-      process.cwd(),
-      'benchmark/results/runs/swebench-v4-flash-300/harness-results.json'
-    )
-
-    if (!fs.existsSync(resultsPath)) {
-      return []
-    }
-
-    const data = JSON.parse(fs.readFileSync(resultsPath, 'utf-8'))
-    return data.results || []
-  } catch (error) {
-    console.error('Error loading benchmark results:', error)
-    return []
-  }
-}
-
-function calculateStats(results: BenchmarkResult[]): BenchmarkStats {
-  if (results.length === 0) {
-    return {
-      total_runs: 0,
-      passed: 0,
-      failed: 0,
-      error: 0,
-      success_rate: 0,
-      avg_duration: 0,
-      total_cost: 0,
-      total_tokens: 0,
-      avg_tokens_per_run: 0,
-      by_status: {},
-      by_repo: {},
-      by_model: {},
-    }
-  }
-
-  const by_status: Record<string, number> = {}
-  const by_repo: Record<string, { count: number; passed: number }> = {}
-  const by_model: Record<string, { count: number; passed: number }> = {}
-
-  let total_cost = 0
-  let total_tokens = 0
-  let total_duration = 0
-  let passed = 0
-
-  results.forEach((result) => {
-    // Count by status
-    by_status[result.status] = (by_status[result.status] || 0) + 1
-
-    // Count by repo
-    if (!by_repo[result.repo]) {
-      by_repo[result.repo] = { count: 0, passed: 0 }
-    }
-    by_repo[result.repo].count++
-
-    // Count by model
-    if (!by_model[result.model]) {
-      by_model[result.model] = { count: 0, passed: 0 }
-    }
-    by_model[result.model].count++
-
-    // Aggregate metrics
-    if (result.kepler) {
-      total_cost += result.kepler.cost || 0
-      total_tokens += result.kepler.tokens_used || 0
-      total_duration += result.kepler.duration_seconds || 0
-
-      if (result.kepler.status === 'success') {
-        passed++
-        by_repo[result.repo].passed++
-        by_model[result.model].passed++
-      }
-    }
-  })
-
-  // Calculate success rates
-  const by_repo_with_rates = Object.entries(by_repo).reduce(
-    (acc, [repo, data]) => {
-      acc[repo] = {
-        ...data,
-        success_rate: data.count > 0 ? (data.passed / data.count) * 100 : 0,
-      }
-      return acc
-    },
-    {} as Record<string, { count: number; passed: number; success_rate: number }>
-  )
-
-  const by_model_with_rates = Object.entries(by_model).reduce(
-    (acc, [model, data]) => {
-      acc[model] = {
-        ...data,
-        success_rate: data.count > 0 ? (data.passed / data.count) * 100 : 0,
-      }
-      return acc
-    },
-    {} as Record<string, { count: number; passed: number; success_rate: number }>
-  )
-
-  return {
-    total_runs: results.length,
-    passed,
-    failed: by_status['failed'] || 0,
-    error: by_status['error'] || 0,
-    success_rate: (passed / results.length) * 100,
-    avg_duration: total_duration / results.length,
-    total_cost,
-    total_tokens,
-    avg_tokens_per_run: total_tokens / results.length,
-    by_status,
-    by_repo: by_repo_with_rates,
-    by_model: by_model_with_rates,
-  }
-}
-
-export async function GET(request: Request) {
-  const { searchParams } = new URL(request.url)
-  const format = searchParams.get('format') || 'summary'
-  const repo = searchParams.get('repo')
-  const model = searchParams.get('model')
-  const status = searchParams.get('status')
-
-  const results = await loadBenchmarkResults()
-
-  // Filter results
-  let filtered = results
-  if (repo) {
-    filtered = filtered.filter((r) => r.repo === repo)
-  }
-  if (model) {
-    filtered = filtered.filter((r) => r.model === model)
-  }
-  if (status) {
-    filtered = filtered.filter((r) => r.status === status)
-  }
-
-  if (format === 'detailed') {
-    return NextResponse.json({
-      results: filtered,
-      count: filtered.length,
-    })
-  }
-
-  // Default: summary format
-  const stats = calculateStats(filtered)
-
-  return NextResponse.json({
-    stats,
-    filters: {
-      repo: repo || null,
-      model: model || null,
-      status: status || null,
-    },
-  })
-}