agentfit 0.1.0

package/generated/prisma/models.ts

@@ -0,0 +1,14 @@
+
+/* !!! This is code generated by Prisma. Do not edit directly. !!! */
+/* eslint-disable */
+// biome-ignore-all lint: generated file
+// @ts-nocheck 
+/*
+ * This is a barrel export file for all models and their related types.
+ *
+ * 🟢 You can import this file directly.
+ */
+export type * from './models/Session'
+export type * from './models/Image'
+export type * from './models/SyncLog'
+export type * from './commonInputTypes'

package/hooks/use-mobile.ts

@@ -0,0 +1,19 @@
+import * as React from "react"
+
+const MOBILE_BREAKPOINT = 768
+
+export function useIsMobile() {
+  const [isMobile, setIsMobile] = React.useState<boolean | undefined>(undefined)
+
+  React.useEffect(() => {
+    const mql = window.matchMedia(`(max-width: ${MOBILE_BREAKPOINT - 1}px)`)
+    const onChange = () => {
+      setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    }
+    mql.addEventListener("change", onChange)
+    setIsMobile(window.innerWidth < MOBILE_BREAKPOINT)
+    return () => mql.removeEventListener("change", onChange)
+  }, [])
+
+  return !!isMobile
+}

package/hooks/use-pagination.ts

@@ -0,0 +1,60 @@
+import { useState, useMemo } from 'react'
+
+export interface PaginationState<T> {
+  page: number
+  pageSize: number
+  totalPages: number
+  totalItems: number
+  pageItems: T[]
+  setPage: (page: number) => void
+  setPageSize: (size: number) => void
+  canPrevious: boolean
+  canNext: boolean
+  previous: () => void
+  next: () => void
+  startIndex: number
+  endIndex: number
+}
+
+export function usePagination<T>(
+  items: T[],
+  defaultPageSize = 20
+): PaginationState<T> {
+  const [page, setPage] = useState(1)
+  const [pageSize, setPageSizeState] = useState(defaultPageSize)
+
+  const totalItems = items.length
+  const totalPages = Math.max(1, Math.ceil(totalItems / pageSize))
+
+  // Reset to page 1 if current page is out of bounds
+  const safePage = Math.min(page, totalPages)
+
+  const startIndex = (safePage - 1) * pageSize
+  const endIndex = Math.min(startIndex + pageSize, totalItems)
+
+  const pageItems = useMemo(
+    () => items.slice(startIndex, endIndex),
+    [items, startIndex, endIndex]
+  )
+
+  const setPageSize = (size: number) => {
+    setPageSizeState(size)
+    setPage(1)
+  }
+
+  return {
+    page: safePage,
+    pageSize,
+    totalPages,
+    totalItems,
+    pageItems,
+    setPage,
+    setPageSize,
+    canPrevious: safePage > 1,
+    canNext: safePage < totalPages,
+    previous: () => setPage(Math.max(1, safePage - 1)),
+    next: () => setPage(Math.min(totalPages, safePage + 1)),
+    startIndex: startIndex + 1,
+    endIndex,
+  }
+}

package/lib/coach.ts

@@ -0,0 +1,425 @@
+// ─── Agent Coach ─────────────────────────────────────────────────────
+// Analyzes usage data and generates actionable coaching insights,
+// like a Garmin coach for your AI coding agent.
+
+import type { UsageData, SessionSummary } from './parse-logs'
+
+export type InsightSeverity = 'tip' | 'warning' | 'achievement'
+export type InsightCategory =
+  | 'cost'
+  | 'efficiency'
+  | 'tools'
+  | 'context'
+  | 'model'
+  | 'habits'
+  | 'discovery'
+  | 'streak'
+
+export interface CoachInsight {
+  id: string
+  title: string
+  description: string
+  category: InsightCategory
+  severity: InsightSeverity
+  metric?: string        // e.g., "$142.30" or "26.8%"
+  recommendation?: string
+}
+
+export interface CoachSummary {
+  score: number          // 0-100 overall "fitness score"
+  scoreLabel: string
+  insights: CoachInsight[]
+  stats: {
+    avgCostPerSession: number
+    avgDurationMinutes: number
+    avgMessagesPerSession: number
+    avgToolCallsPerSession: number
+    mostUsedModel: string
+    mostActiveDay: string
+    longestStreak: number
+    currentStreak: number
+    totalDays: number
+    peakHour: number
+  }
+}
+
+// ─── Streak Calculation ──────────────────────────────────────────────
+
+function calculateStreaks(sessions: SessionSummary[]): { longest: number; current: number } {
+  const dates = new Set(sessions.map(s => s.startTime.slice(0, 10)))
+  const sorted = Array.from(dates).sort()
+  if (sorted.length === 0) return { longest: 0, current: 0 }
+
+  let longest = 1
+  let current = 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 diffDays = (curr.getTime() - prev.getTime()) / (1000 * 60 * 60 * 24)
+
+    if (diffDays === 1) {
+      streak++
+      longest = Math.max(longest, streak)
+    } else {
+      streak = 1
+    }
+  }
+
+  // Check if current streak is still active (last active day is today or yesterday)
+  const lastDate = new Date(sorted[sorted.length - 1])
+  const today = new Date()
+  today.setHours(0, 0, 0, 0)
+  const diffFromToday = (today.getTime() - lastDate.getTime()) / (1000 * 60 * 60 * 24)
+  current = diffFromToday <= 1 ? streak : 0
+
+  return { longest, current }
+}
+
+// ─── Peak Hour ───────────────────────────────────────────────────────
+
+function findPeakHour(sessions: SessionSummary[]): number {
+  const hourCounts = new Array(24).fill(0)
+  for (const s of sessions) {
+    if (s.startTime) {
+      const hour = new Date(s.startTime).getHours()
+      hourCounts[hour]++
+    }
+  }
+  return hourCounts.indexOf(Math.max(...hourCounts))
+}
+
+// ─── Most Active Day ─────────────────────────────────────────────────
+
+function findMostActiveDay(sessions: SessionSummary[]): string {
+  const days = ['Sunday', 'Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday', 'Saturday']
+  const dayCounts = new Array(7).fill(0)
+  for (const s of sessions) {
+    if (s.startTime) {
+      dayCounts[new Date(s.startTime).getDay()]++
+    }
+  }
+  return days[dayCounts.indexOf(Math.max(...dayCounts))]
+}
+
+// ─── Insight Generation ──────────────────────────────────────────────
+
+export function generateCoachInsights(data: UsageData): CoachSummary {
+  const { sessions, overview, toolUsage } = data
+  const insights: CoachInsight[] = []
+
+  if (sessions.length === 0) {
+    return {
+      score: 0,
+      scoreLabel: 'No data',
+      insights: [{ id: 'no-data', title: 'No sessions found', description: 'Start using your coding agent to get coaching insights.', category: 'habits', severity: 'tip' }],
+      stats: { avgCostPerSession: 0, avgDurationMinutes: 0, avgMessagesPerSession: 0, avgToolCallsPerSession: 0, mostUsedModel: 'N/A', mostActiveDay: 'N/A', longestStreak: 0, currentStreak: 0, totalDays: 0, peakHour: 0 },
+    }
+  }
+
+  // Basic stats
+  const avgCost = overview.totalCostUSD / sessions.length
+  const avgDuration = overview.totalDurationMinutes / sessions.length
+  const avgMessages = overview.totalMessages / sessions.length
+  const avgToolCalls = overview.totalToolCalls / sessions.length
+  const modelEntries = Object.entries(overview.models).sort((a, b) => b[1] - a[1])
+  const mostUsedModel = modelEntries[0]?.[0] || 'unknown'
+  const streaks = calculateStreaks(sessions)
+  const peakHour = findPeakHour(sessions)
+  const mostActiveDay = findMostActiveDay(sessions)
+  const uniqueDates = new Set(sessions.map(s => s.startTime.slice(0, 10)))
+
+  // ── Cost insights ──
+
+  // Model cost optimization
+  const opusSessions = sessions.filter(s => s.model.includes('opus'))
+  const opusRatio = opusSessions.length / sessions.length
+  if (opusRatio > 0.8 && sessions.length > 10) {
+    const opusCost = opusSessions.reduce((sum, s) => sum + s.costUSD, 0)
+    insights.push({
+      id: 'model-diversity',
+      title: 'Heavy Opus usage detected',
+      description: `${Math.round(opusRatio * 100)}% of your sessions use Opus, costing $${opusCost.toFixed(0)} total. Many routine tasks (git operations, simple edits, file reading) can be handled by Haiku or Sonnet at a fraction of the cost.`,
+      category: 'cost',
+      severity: 'warning',
+      metric: `${Math.round(opusRatio * 100)}% Opus`,
+      recommendation: 'Use /model to switch to Sonnet or Haiku for routine tasks. Reserve Opus for complex architecture decisions and debugging.',
+    })
+  }
+
+  // High cost sessions
+  const expensiveSessions = sessions.filter(s => s.costUSD > avgCost * 3)
+  if (expensiveSessions.length > 3) {
+    insights.push({
+      id: 'expensive-sessions',
+      title: 'Cost spikes detected',
+      description: `${expensiveSessions.length} sessions cost 3x+ your average ($${avgCost.toFixed(2)}). These outliers often indicate context overflow or runaway tool loops.`,
+      category: 'cost',
+      severity: 'warning',
+      metric: `${expensiveSessions.length} expensive sessions`,
+      recommendation: 'Use /compact proactively during long sessions. Watch for repeated tool call patterns that indicate the agent is stuck.',
+    })
+  }
+
+  // Cost trend (last 7 days vs previous 7 days)
+  const sortedByDate = [...sessions].sort((a, b) => b.startTime.localeCompare(a.startTime))
+  const recentSessions = sortedByDate.filter(s => {
+    const d = new Date(s.startTime)
+    const now = new Date()
+    return (now.getTime() - d.getTime()) / (1000 * 60 * 60 * 24) <= 7
+  })
+  const olderSessions = sortedByDate.filter(s => {
+    const d = new Date(s.startTime)
+    const now = new Date()
+    const daysAgo = (now.getTime() - d.getTime()) / (1000 * 60 * 60 * 24)
+    return daysAgo > 7 && daysAgo <= 14
+  })
+  if (recentSessions.length > 3 && olderSessions.length > 3) {
+    const recentCost = recentSessions.reduce((sum, s) => sum + s.costUSD, 0)
+    const olderCost = olderSessions.reduce((sum, s) => sum + s.costUSD, 0)
+    if (recentCost < olderCost * 0.7) {
+      insights.push({
+        id: 'cost-down',
+        title: 'Costs trending down',
+        description: `Your spending dropped ${Math.round((1 - recentCost / olderCost) * 100)}% this week vs last week. You're becoming more efficient with your agent.`,
+        category: 'cost',
+        severity: 'achievement',
+        metric: `-${Math.round((1 - recentCost / olderCost) * 100)}%`,
+      })
+    } else if (recentCost > olderCost * 1.5) {
+      insights.push({
+        id: 'cost-up',
+        title: 'Cost spike this week',
+        description: `Spending is up ${Math.round((recentCost / olderCost - 1) * 100)}% vs last week ($${recentCost.toFixed(0)} vs $${olderCost.toFixed(0)}).`,
+        category: 'cost',
+        severity: 'warning',
+        metric: `+${Math.round((recentCost / olderCost - 1) * 100)}%`,
+        recommendation: 'Check if long-running sessions or model upgrades are driving the increase.',
+      })
+    }
+  }
+
+  // ── Efficiency insights ──
+
+  // Long sessions
+  const longSessions = sessions.filter(s => s.durationMinutes > 120)
+  if (longSessions.length > 5) {
+    const longAvgCost = longSessions.reduce((sum, s) => sum + s.costUSD, 0) / longSessions.length
+    insights.push({
+      id: 'long-sessions',
+      title: 'Many long sessions (2h+)',
+      description: `${longSessions.length} sessions exceeded 2 hours. Long sessions often hit context limits and lose coherence. Average cost per long session: $${longAvgCost.toFixed(2)}.`,
+      category: 'efficiency',
+      severity: 'tip',
+      metric: `${longSessions.length} sessions > 2h`,
+      recommendation: 'Break complex tasks into focused 30-60 min sessions. Use /clear between distinct tasks. Use /compact if you need to continue.',
+    })
+  }
+
+  // Read-before-Edit ratio
+  const readCalls = (toolUsage['Read'] || 0) + (toolUsage['Grep'] || 0) + (toolUsage['Glob'] || 0)
+  const editCalls = (toolUsage['Edit'] || 0) + (toolUsage['Write'] || 0)
+  if (editCalls > 0) {
+    const ratio = readCalls / editCalls
+    if (ratio < 0.5 && editCalls > 50) {
+      insights.push({
+        id: 'read-before-edit',
+        title: 'Low read-before-edit ratio',
+        description: `Your agent reads ${ratio.toFixed(1)}x for every edit. A ratio below 1.0 suggests the agent may be editing without fully understanding the code first, leading to more iterations.`,
+        category: 'efficiency',
+        severity: 'warning',
+        metric: `${ratio.toFixed(1)}x ratio`,
+        recommendation: 'Encourage the agent to read files before modifying them. Add "always read the file first" to your CLAUDE.md.',
+      })
+    } else if (ratio > 2.0) {
+      insights.push({
+        id: 'good-read-ratio',
+        title: 'Strong read-before-edit habit',
+        description: `Your agent reads ${ratio.toFixed(1)}x for every edit — a sign of careful, well-informed modifications. This typically leads to fewer iterations and less rework.`,
+        category: 'efficiency',
+        severity: 'achievement',
+        metric: `${ratio.toFixed(1)}x ratio`,
+      })
+    }
+  }
+
+  // ── Context insights ──
+
+  // High-token sessions (proxy for context overflow)
+  const highTokenSessions = sessions.filter(s => s.totalTokens > 200000)
+  const overflowRate = highTokenSessions.length / sessions.length
+  if (overflowRate > 0.2) {
+    insights.push({
+      id: 'context-overflow',
+      title: 'Frequent high-token sessions',
+      description: `${Math.round(overflowRate * 100)}% of sessions exceed 200K tokens, suggesting frequent context pressure. This increases cost and can reduce response quality.`,
+      category: 'context',
+      severity: 'warning',
+      metric: `${Math.round(overflowRate * 100)}% overflow rate`,
+      recommendation: 'Use /compact with focus instructions to preserve important context. Use /context to monitor usage. Start fresh sessions for new tasks.',
+    })
+  }
+
+  // ── Tool insights ──
+
+  // Bash overuse
+  const bashCalls = toolUsage['Bash'] || 0
+  const totalToolCalls = overview.totalToolCalls
+  const bashRatio = totalToolCalls > 0 ? bashCalls / totalToolCalls : 0
+  if (bashRatio > 0.4 && totalToolCalls > 100) {
+    insights.push({
+      id: 'bash-heavy',
+      title: 'Heavy Bash usage',
+      description: `${Math.round(bashRatio * 100)}% of tool calls are Bash commands. Some of these may be better handled by dedicated tools (Read instead of cat, Edit instead of sed, Grep instead of grep).`,
+      category: 'tools',
+      severity: 'tip',
+      metric: `${Math.round(bashRatio * 100)}% Bash`,
+      recommendation: 'Dedicated tools are faster, safer, and easier to review. Add guidance to CLAUDE.md to prefer Read/Edit/Grep over Bash equivalents.',
+    })
+  }
+
+  // Agent/subagent usage
+  const agentCalls = toolUsage['Agent'] || 0
+  if (agentCalls === 0 && totalToolCalls > 500) {
+    insights.push({
+      id: 'no-agents',
+      title: 'Not using subagents',
+      description: 'You haven\'t used the Agent tool for parallel research or exploration. Subagents can significantly speed up tasks that require searching across multiple files or investigating multiple approaches.',
+      category: 'tools',
+      severity: 'tip',
+      recommendation: 'Try asking Claude to "use an agent to research X while you work on Y". This parallelizes work and keeps the main context clean.',
+    })
+  } else if (agentCalls > 50) {
+    insights.push({
+      id: 'good-agents',
+      title: 'Effective subagent usage',
+      description: `${agentCalls} subagent calls show you're effectively parallelizing work. This keeps the main context lean while delegating research tasks.`,
+      category: 'tools',
+      severity: 'achievement',
+      metric: `${agentCalls} agent calls`,
+    })
+  }
+
+  // ── Habit insights ──
+
+  // Streaks
+  if (streaks.current >= 7) {
+    insights.push({
+      id: 'streak-hot',
+      title: `${streaks.current}-day coding streak!`,
+      description: `You've been coding with your agent every day for ${streaks.current} days straight. Consistency is the key to mastering human-AI collaboration.`,
+      category: 'streak',
+      severity: 'achievement',
+      metric: `${streaks.current} days`,
+    })
+  } else if (streaks.current >= 3) {
+    insights.push({
+      id: 'streak-building',
+      title: `${streaks.current}-day streak building`,
+      description: `You're on a ${streaks.current}-day streak. Your longest was ${streaks.longest} days — keep going!`,
+      category: 'streak',
+      severity: 'achievement',
+      metric: `${streaks.current} / ${streaks.longest} days`,
+    })
+  } else if (streaks.current === 0 && streaks.longest > 3) {
+    insights.push({
+      id: 'streak-broken',
+      title: 'Streak broken',
+      description: `Your ${streaks.longest}-day streak ended. Start a new one today!`,
+      category: 'streak',
+      severity: 'tip',
+      metric: `Best: ${streaks.longest} days`,
+    })
+  }
+
+  // Peak productivity time
+  insights.push({
+    id: 'peak-hour',
+    title: `Peak hour: ${peakHour}:00`,
+    description: `You start the most sessions around ${peakHour}:00. Your most active day is ${mostActiveDay}. Schedule your most complex tasks during these peak windows.`,
+    category: 'habits',
+    severity: 'tip',
+    metric: `${peakHour}:00 ${mostActiveDay}s`,
+  })
+
+  // Session volume trend
+  if (recentSessions.length > 0 && olderSessions.length > 0) {
+    const recentPerDay = recentSessions.length / 7
+    const olderPerDay = olderSessions.length / 7
+    if (recentPerDay > olderPerDay * 1.5) {
+      insights.push({
+        id: 'usage-up',
+        title: 'Usage ramping up',
+        description: `You're averaging ${recentPerDay.toFixed(1)} sessions/day this week, up from ${olderPerDay.toFixed(1)} last week. You're leaning more into AI-assisted development.`,
+        category: 'habits',
+        severity: 'achievement',
+        metric: `${recentPerDay.toFixed(1)}/day`,
+      })
+    }
+  }
+
+  // ── Discovery insights ──
+
+  // Skill/command usage from tool calls
+  const skillCalls = toolUsage['Skill'] || 0
+  if (skillCalls === 0 && totalToolCalls > 200) {
+    insights.push({
+      id: 'no-skills',
+      title: 'Unused: Custom Skills',
+      description: 'You haven\'t used any custom skills yet. Skills are reusable prompt templates that automate repetitive workflows — like /simplify for code review or custom deploy scripts.',
+      category: 'discovery',
+      severity: 'tip',
+      recommendation: 'Try /skills to see available skills. Create your own in .claude/skills/ for tasks you repeat often.',
+    })
+  }
+
+  // ── Compute fitness score ──
+
+  let score = 50 // baseline
+  const achievements = insights.filter(i => i.severity === 'achievement').length
+  const warnings = insights.filter(i => i.severity === 'warning').length
+
+  score += achievements * 8
+  score -= warnings * 6
+
+  // Bonus for streaks
+  score += Math.min(streaks.current, 10) * 2
+
+  // Bonus for good read ratio
+  if (readCalls > 0 && editCalls > 0 && readCalls / editCalls > 1.5) score += 5
+
+  // Penalty for high overflow rate
+  if (overflowRate > 0.3) score -= 10
+
+  // Bonus for tool diversity
+  const uniqueTools = Object.keys(toolUsage).length
+  if (uniqueTools > 10) score += 5
+
+  score = Math.max(0, Math.min(100, score))
+
+  const scoreLabel =
+    score >= 85 ? 'Elite' :
+    score >= 70 ? 'Strong' :
+    score >= 55 ? 'Building' :
+    score >= 40 ? 'Getting Started' :
+    'Needs Attention'
+
+  return {
+    score,
+    scoreLabel,
+    insights,
+    stats: {
+      avgCostPerSession: avgCost,
+      avgDurationMinutes: avgDuration,
+      avgMessagesPerSession: avgMessages,
+      avgToolCallsPerSession: avgToolCalls,
+      mostUsedModel,
+      mostActiveDay,
+      longestStreak: streaks.longest,
+      currentStreak: streaks.current,
+      totalDays: uniqueDates.size,
+      peakHour,
+    },
+  }
+}