agentfit 0.1.0 → 0.1.1

package/app/(dashboard)/settings/page.tsx

@@ -0,0 +1,180 @@
+'use client'
+
+import { useState, useEffect } from 'react'
+import { useData } from '@/components/data-provider'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Badge } from '@/components/ui/badge'
+import {
+  RefreshCw,
+  RotateCcw,
+  AlertTriangle,
+  Database,
+  HardDrive,
+  FolderSync,
+} from 'lucide-react'
+import { BackupCard } from '@/components/backup-section'
+
+export default function SettingsPage() {
+  const { syncing, resetting, lastSyncResult, lastSyncTime, handleSync, handleReset } = useData()
+  const [resetOpen, setResetOpen] = useState(false)
+  const [paths, setPaths] = useState<{ database: string; images: string; claudeLogs: string; codexLogs: string } | null>(null)
+
+  useEffect(() => {
+    fetch('/api/check')
+      .then((r) => r.json())
+      .then((d) => { if (d.paths) setPaths(d.paths) })
+      .catch(() => {})
+  }, [])
+
+  return (
+    <div className="space-y-6 max-w-2xl">
+      {/* Local Data */}
+      <Card>
+        <CardHeader>
+          <div className="flex items-center gap-2">
+            <Database className="h-5 w-5 text-muted-foreground" />
+            <div>
+              <CardTitle>Local Data</CardTitle>
+              <CardDescription>Manage your synced session data</CardDescription>
+            </div>
+          </div>
+        </CardHeader>
+        <CardContent className="space-y-4">
+          {/* Sync */}
+          <div className="flex items-center justify-between rounded-lg border p-4">
+            <div className="space-y-1">
+              <div className="flex items-center gap-2">
+                <FolderSync className="h-4 w-4 text-muted-foreground" />
+                <span className="text-sm font-medium">Sync Logs</span>
+              </div>
+              <p className="text-xs text-muted-foreground">
+                Import new sessions from ~/.claude and ~/.codex into the local database.
+              </p>
+              {lastSyncTime && (
+                <p className="text-xs text-muted-foreground">
+                  Last synced: {lastSyncTime.toLocaleString()}
+                  {lastSyncResult && (
+                    <span> — {lastSyncResult.sessionsAdded} added, {lastSyncResult.sessionsSkipped} skipped</span>
+                  )}
+                </p>
+              )}
+            </div>
+            <Button
+              variant="outline"
+              onClick={handleSync}
+              disabled={syncing || resetting}
+              className="gap-2 shrink-0"
+            >
+              <RefreshCw className={`h-4 w-4 ${syncing ? 'animate-spin' : ''}`} />
+              {syncing ? 'Syncing...' : 'Sync'}
+            </Button>
+          </div>
+
+          {/* Reset */}
+          <div className="flex items-center justify-between rounded-lg border border-destructive/20 p-4">
+            <div className="space-y-1">
+              <div className="flex items-center gap-2">
+                <RotateCcw className="h-4 w-4 text-destructive" />
+                <span className="text-sm font-medium text-destructive">Reset Database</span>
+              </div>
+              <p className="text-xs text-muted-foreground">
+                Delete all synced data and re-import from log files on disk. Use if data seems corrupted.
+              </p>
+            </div>
+            <Button
+              variant="destructive"
+              onClick={() => setResetOpen(true)}
+              disabled={syncing || resetting}
+              className="gap-2 shrink-0"
+            >
+              <RotateCcw className={`h-4 w-4 ${resetting ? 'animate-spin' : ''}`} />
+              {resetting ? 'Resetting...' : 'Reset'}
+            </Button>
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* Database Info */}
+      <Card>
+        <CardHeader>
+          <div className="flex items-center gap-2">
+            <HardDrive className="h-5 w-5 text-muted-foreground" />
+            <div>
+              <CardTitle>Storage</CardTitle>
+              <CardDescription>Where your data lives</CardDescription>
+            </div>
+          </div>
+        </CardHeader>
+        <CardContent>
+          <div className="space-y-3 text-sm">
+            <div className="flex items-center justify-between">
+              <span className="text-muted-foreground">Database</span>
+              <code className="rounded bg-muted px-2 py-0.5 text-xs">{paths?.database ?? 'agentfit.db'}</code>
+            </div>
+            <div className="flex items-center justify-between">
+              <span className="text-muted-foreground">Claude Code logs</span>
+              <code className="rounded bg-muted px-2 py-0.5 text-xs">{paths?.claudeLogs ?? '~/.claude/projects/'}</code>
+            </div>
+            <div className="flex items-center justify-between">
+              <span className="text-muted-foreground">Codex logs</span>
+              <code className="rounded bg-muted px-2 py-0.5 text-xs">{paths?.codexLogs ?? '~/.codex/sessions/'}</code>
+            </div>
+            <div className="flex items-center justify-between">
+              <span className="text-muted-foreground">Extracted images</span>
+              <code className="rounded bg-muted px-2 py-0.5 text-xs">{paths?.images ?? 'data/images/'}</code>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+
+      {/* GitHub Backup */}
+      <BackupCard />
+
+      {/* Reset confirmation dialog */}
+      <Dialog open={resetOpen} onOpenChange={setResetOpen}>
+        <DialogContent className="sm:max-w-md">
+          <DialogHeader>
+            <DialogTitle className="flex items-center gap-2 text-destructive">
+              <AlertTriangle className="h-5 w-5" />
+              Destructive Action
+            </DialogTitle>
+          </DialogHeader>
+          <div className="space-y-3 text-sm text-muted-foreground">
+            <div>
+              This will <strong className="text-foreground">permanently delete all synced data</strong> from the database and re-import from log files currently on disk.
+            </div>
+            <div className="rounded-md border border-destructive/30 bg-destructive/5 p-3 text-sm text-destructive">
+              <strong>Warning:</strong> If your coding agent (Claude Code, Codex, etc.) has purged old log files, that data will be permanently lost. The database may contain sessions that no longer exist on disk.
+            </div>
+            <div>
+              This cannot be undone. Consider backing up <code className="rounded bg-muted px-1 py-0.5 text-xs">agentfit.db</code> first.
+            </div>
+          </div>
+          <DialogFooter className="gap-3">
+            <Button variant="outline" onClick={() => setResetOpen(false)}>
+              Cancel
+            </Button>
+            <Button
+              variant="destructive"
+              disabled={resetting}
+              onClick={async () => {
+                await handleReset()
+                setResetOpen(false)
+              }}
+            >
+              I understand, reset everything
+            </Button>
+          </DialogFooter>
+        </DialogContent>
+      </Dialog>
+    </div>
+  )
+}

package/app/api/backup/route.ts

@@ -0,0 +1,215 @@
+import { NextResponse } from 'next/server'
+import { execSync } from 'child_process'
+import { existsSync } from 'fs'
+import { homedir } from 'os'
+import path from 'path'
+
+interface FolderStatus {
+  exists: boolean
+  hasGit: boolean
+  hasRemote: boolean
+  remoteUrl: string | null
+  isDirty: boolean
+  lastCommit: string | null
+}
+
+interface BackupStatus {
+  ghInstalled: boolean
+  ghAuthenticated: boolean
+  ghUser: string | null
+  claude: FolderStatus
+  codex: FolderStatus
+}
+
+function run(cmd: string, cwd: string): string {
+  try {
+    return execSync(cmd, { cwd, encoding: 'utf-8', timeout: 30000 }).trim()
+  } catch {
+    return ''
+  }
+}
+
+function getFolderStatus(folderPath: string): FolderStatus {
+  if (!existsSync(folderPath)) {
+    return { exists: false, hasGit: false, hasRemote: false, remoteUrl: null, isDirty: false, lastCommit: null }
+  }
+
+  const hasGit = existsSync(path.join(folderPath, '.git'))
+  let hasRemote = false
+  let remoteUrl: string | null = null
+  let isDirty = false
+  let lastCommit: string | null = null
+
+  if (hasGit) {
+    remoteUrl = run('git remote get-url origin', folderPath) || null
+    hasRemote = !!remoteUrl
+    const status = run('git status --porcelain', folderPath)
+    isDirty = status.length > 0
+    lastCommit = run('git log -1 --format=%ci', folderPath) || null
+  }
+
+  return { exists: true, hasGit, hasRemote, remoteUrl, isDirty, lastCommit }
+}
+
+export async function GET() {
+  const home = homedir()
+  const ghInstalled = !!run('which gh', home)
+  let ghAuthenticated = false
+  let ghUser: string | null = null
+
+  if (ghInstalled) {
+    ghUser = run('gh api user -q .login', home) || null
+    ghAuthenticated = !!ghUser
+  }
+
+  const status: BackupStatus = {
+    ghInstalled,
+    ghAuthenticated,
+    ghUser,
+    claude: getFolderStatus(path.join(home, '.claude')),
+    codex: getFolderStatus(path.join(home, '.codex')),
+  }
+
+  return NextResponse.json(status)
+}
+
+const CLAUDE_GITIGNORE = `# Sensitive / ephemeral files
+*.lock
+*.lock.lock
+cache/
+chrome/
+debug/
+downloads/
+ide/
+image-cache/
+paste-cache/
+session-env/
+telemetry/
+mcp-needs-auth-cache.json
+.DS_Store
+`
+
+const CODEX_GITIGNORE = `# Sensitive files
+auth.json
+*.lock
+tmp/
+.DS_Store
+`
+
+function initGit(folderPath: string, gitignoreContent: string) {
+  const gitignorePath = path.join(folderPath, '.gitignore')
+  if (!existsSync(gitignorePath)) {
+    require('fs').writeFileSync(gitignorePath, gitignoreContent)
+  }
+  if (!existsSync(path.join(folderPath, '.git'))) {
+    run('git init -b main', folderPath)
+  }
+}
+
+function commitAll(folderPath: string, message: string): boolean {
+  run('git add -A', folderPath)
+  const status = run('git status --porcelain', folderPath)
+  if (!status) return false
+  execSync(`git commit -m "${message}"`, { cwd: folderPath, encoding: 'utf-8', timeout: 30000 })
+  return true
+}
+
+export async function POST(request: Request) {
+  const home = homedir()
+  const body = await request.json()
+  const { action, folder } = body as { action: string; folder?: 'claude' | 'codex' }
+
+  if (action === 'init') {
+    // Initialize and push to GitHub for the first time
+    if (!folder) return NextResponse.json({ error: 'folder required' }, { status: 400 })
+
+    const ghUser = run('gh api user -q .login', home)
+    if (!ghUser) {
+      return NextResponse.json({ error: 'Not authenticated with GitHub. Run: gh auth login' }, { status: 401 })
+    }
+
+    const folderPath = path.join(home, `.${folder}`)
+    if (!existsSync(folderPath)) {
+      return NextResponse.json({ error: `~/.${folder} does not exist` }, { status: 404 })
+    }
+
+    const repoName = `my-${folder}-backup`
+    const gitignore = folder === 'claude' ? CLAUDE_GITIGNORE : CODEX_GITIGNORE
+
+    // Init git and .gitignore
+    initGit(folderPath, gitignore)
+
+    // Create private repo if it doesn't exist
+    const existing = run(`gh repo view ${ghUser}/${repoName} --json name -q .name`, home)
+    if (!existing) {
+      try {
+        execSync(`gh repo create ${repoName} --private --description "Backup of ~/.${folder}"`, {
+          cwd: home, encoding: 'utf-8', timeout: 30000,
+        })
+      } catch (e) {
+        return NextResponse.json({ error: `Failed to create repo: ${(e as Error).message}` }, { status: 500 })
+      }
+    }
+
+    // Set remote
+    const currentRemote = run('git remote get-url origin', folderPath)
+    const repoUrl = `https://github.com/${ghUser}/${repoName}.git`
+    if (!currentRemote) {
+      run(`git remote add origin ${repoUrl}`, folderPath)
+    } else if (currentRemote !== repoUrl) {
+      run(`git remote set-url origin ${repoUrl}`, folderPath)
+    }
+
+    // Commit and push
+    const timestamp = new Date().toISOString().slice(0, 19).replace('T', ' ')
+    commitAll(folderPath, `backup: ${timestamp}`)
+
+    try {
+      execSync('git push -u origin main', { cwd: folderPath, encoding: 'utf-8', timeout: 60000 })
+    } catch {
+      // Try force push on first init (empty remote)
+      try {
+        execSync('git push -u origin main --force-with-lease', { cwd: folderPath, encoding: 'utf-8', timeout: 60000 })
+      } catch (e) {
+        return NextResponse.json({ error: `Push failed: ${(e as Error).message}` }, { status: 500 })
+      }
+    }
+
+    return NextResponse.json({
+      success: true,
+      repoUrl: `https://github.com/${ghUser}/${repoName}`,
+    })
+  }
+
+  if (action === 'sync') {
+    // Sync changes to existing remote
+    if (!folder) return NextResponse.json({ error: 'folder required' }, { status: 400 })
+
+    const folderPath = path.join(home, `.${folder}`)
+    if (!existsSync(path.join(folderPath, '.git'))) {
+      return NextResponse.json({ error: 'Not initialized. Set up backup first.' }, { status: 400 })
+    }
+
+    const remote = run('git remote get-url origin', folderPath)
+    if (!remote) {
+      return NextResponse.json({ error: 'No remote configured. Set up backup first.' }, { status: 400 })
+    }
+
+    const timestamp = new Date().toISOString().slice(0, 19).replace('T', ' ')
+    const hadChanges = commitAll(folderPath, `backup: ${timestamp}`)
+
+    if (!hadChanges) {
+      return NextResponse.json({ success: true, message: 'Already up to date' })
+    }
+
+    try {
+      execSync('git push origin main', { cwd: folderPath, encoding: 'utf-8', timeout: 60000 })
+    } catch (e) {
+      return NextResponse.json({ error: `Push failed: ${(e as Error).message}` }, { status: 500 })
+    }
+
+    return NextResponse.json({ success: true, message: 'Synced to GitHub' })
+  }
+
+  return NextResponse.json({ error: 'Unknown action' }, { status: 400 })
+}

package/app/api/check/route.ts

@@ -1,4 +1,6 @@
 import { NextResponse } from 'next/server'
+import path from 'path'
+import os from 'os'
 import { checkForNewSessions } from '@/lib/sync'
 
 export const dynamic = 'force-dynamic'
@@ -6,7 +8,15 @@ export const dynamic = 'force-dynamic'
 export async function GET() {
   try {
     const newSessions = await checkForNewSessions()
-    return NextResponse.json({ newSessions })
+    return NextResponse.json({
+      newSessions,
+      paths: {
+        database: path.resolve(process.cwd(), 'agentfit.db'),
+        images: path.resolve(process.cwd(), 'data', 'images'),
+        claudeLogs: path.join(os.homedir(), '.claude', 'projects'),
+        codexLogs: path.join(os.homedir(), '.codex', 'sessions'),
+      },
+    })
   } catch (error) {
     return NextResponse.json({ newSessions: 0, error: (error as Error).message }, { status: 500 })
   }

package/app/api/command-insights/route.ts

@@ -0,0 +1,13 @@
+import { NextResponse } from 'next/server'
+import { generateCommandInsights } from '@/lib/command-insights'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  try {
+    const insights = generateCommandInsights()
+    return NextResponse.json(insights)
+  } catch (error) {
+    return NextResponse.json([], { status: 500 })
+  }
+}

package/app/api/images-analysis/route.ts

@@ -113,9 +113,8 @@ export async function GET() {
         }
       })
 
-    // --- Recent images (for gallery) ---
-    const recentImages = images
-      .slice(-20)
+    // --- All images (newest first, for gallery with pagination) ---
+    const allImages = [...images]
       .reverse()
       .map((img) => ({
         filename: img.filename,
@@ -168,7 +167,7 @@ export async function GET() {
         under5Percent: gaps.length ? Math.round((under5 / gaps.length) * 100) : 0,
       },
       topSessions,
-      recentImages,
+      allImages,
     })
   } catch (error) {
     console.error('Failed to analyze images:', error)

package/app/api/reports/[id]/route.ts

@@ -0,0 +1,23 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(
+  request: NextRequest,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  try {
+    const { id } = await params
+    const report = await prisma.report.findUnique({ where: { id } })
+    if (!report) {
+      return NextResponse.json({ error: 'Report not found' }, { status: 404 })
+    }
+    return NextResponse.json({
+      ...report,
+      contentJson: JSON.parse(report.contentJson),
+    })
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}

package/app/api/reports/route.ts

@@ -0,0 +1,50 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { generateReport } from '@/lib/report'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  try {
+    const reports = await prisma.report.findMany({
+      orderBy: { generatedAt: 'desc' },
+      select: { id: true, title: true, generatedAt: true, sessionCount: true },
+    })
+    return NextResponse.json(reports)
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}
+
+export async function POST() {
+  try {
+    const { title, contentJson, sessionCount } = await generateReport()
+
+    // Check if data has changed since last report
+    const lastReport = await prisma.report.findFirst({
+      orderBy: { generatedAt: 'desc' },
+      select: { sessionCount: true },
+    })
+
+    if (lastReport && lastReport.sessionCount === sessionCount) {
+      return NextResponse.json(
+        { error: 'No new data since the last report. Sync new sessions first.' },
+        { status: 409 }
+      )
+    }
+
+    const report = await prisma.report.create({
+      data: {
+        title,
+        contentJson: JSON.stringify(contentJson),
+        sessionCount,
+      },
+    })
+    return NextResponse.json({
+      ...report,
+      contentJson: JSON.parse(report.contentJson),
+    })
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}

package/app/api/reset/route.ts

@@ -0,0 +1,21 @@
+import { NextResponse } from 'next/server'
+import { prisma } from '@/lib/db'
+import { syncLogs } from '@/lib/sync'
+
+export const dynamic = 'force-dynamic'
+
+export async function POST() {
+  try {
+    // Delete all records in order (images reference sessions)
+    await prisma.image.deleteMany()
+    await prisma.session.deleteMany()
+    await prisma.syncLog.deleteMany()
+
+    // Re-sync from disk
+    const result = await syncLogs()
+    return NextResponse.json(result)
+  } catch (error) {
+    console.error('Reset failed:', error)
+    return NextResponse.json({ error: 'Reset failed' }, { status: 500 })
+  }
+}

package/app/api/session/route.ts

@@ -0,0 +1,40 @@
+import { NextRequest, NextResponse } from 'next/server'
+import path from 'path'
+import os from 'os'
+import fs from 'fs'
+import { parseSessionDetail } from '@/lib/session-detail'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(request: NextRequest) {
+  const sessionId = request.nextUrl.searchParams.get('id')
+  if (!sessionId) {
+    return NextResponse.json({ error: 'Missing session id' }, { status: 400 })
+  }
+
+  try {
+    // Search for the JSONL file across all project directories
+    const projectsDir = path.join(os.homedir(), '.claude', 'projects')
+    let filePath: string | null = null
+
+    if (fs.existsSync(projectsDir)) {
+      const dirs = fs.readdirSync(projectsDir)
+      for (const dir of dirs) {
+        const candidate = path.join(projectsDir, dir, `${sessionId}.jsonl`)
+        if (fs.existsSync(candidate)) {
+          filePath = candidate
+          break
+        }
+      }
+    }
+
+    if (!filePath) {
+      return NextResponse.json({ error: 'Session not found' }, { status: 404 })
+    }
+
+    const detail = parseSessionDetail(filePath, sessionId)
+    return NextResponse.json(detail)
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}

package/app/api/usage/route.ts

@@ -65,6 +65,8 @@ function mergeUsageData(a: UsageData, b: UsageData): UsageData {
     if (existing) {
       existing.sessions += day.sessions
       existing.messages += day.messages
+      existing.userMessages += day.userMessages
+      existing.assistantMessages += day.assistantMessages
       existing.inputTokens += day.inputTokens
       existing.outputTokens += day.outputTokens
       existing.cacheCreationTokens += day.cacheCreationTokens
@@ -72,8 +74,13 @@ function mergeUsageData(a: UsageData, b: UsageData): UsageData {
       existing.totalTokens += day.totalTokens
       existing.costUSD += day.costUSD
       existing.toolCalls += day.toolCalls
+      existing.interruptions += day.interruptions
+      existing.rateLimitErrors += day.rateLimitErrors
+      for (const [tool, count] of Object.entries(day.toolCallsDetail)) {
+        existing.toolCallsDetail[tool] = (existing.toolCallsDetail[tool] || 0) + count
+      }
     } else {
-      dailyMap.set(day.date, { ...day })
+      dailyMap.set(day.date, { ...day, toolCallsDetail: { ...day.toolCallsDetail } })
     }
   }
 
@@ -107,7 +114,24 @@ function mergeUsageData(a: UsageData, b: UsageData): UsageData {
       totalCostUSD: a.overview.totalCostUSD + b.overview.totalCostUSD,
       totalDurationMinutes: a.overview.totalDurationMinutes + b.overview.totalDurationMinutes,
       totalToolCalls: a.overview.totalToolCalls + b.overview.totalToolCalls,
+      totalApiErrors: a.overview.totalApiErrors + b.overview.totalApiErrors,
+      totalRateLimitDays: a.overview.totalRateLimitDays + b.overview.totalRateLimitDays,
+      totalUserInterruptions: a.overview.totalUserInterruptions + b.overview.totalUserInterruptions,
       models,
+      skillUsage: (() => {
+        const skills: Record<string, number> = { ...a.overview.skillUsage }
+        for (const [s, c] of Object.entries(b.overview.skillUsage)) {
+          skills[s] = (skills[s] || 0) + c
+        }
+        return skills
+      })(),
+      permissionModes: (() => {
+        const modes: Record<string, number> = { ...(a.overview.permissionModes || {}) }
+        for (const [m, c] of Object.entries(b.overview.permissionModes || {})) {
+          modes[m] = (modes[m] || 0) + c
+        }
+        return modes
+      })(),
     },
     sessions,
     projects,

package/app/layout.tsx

@@ -12,7 +12,7 @@ const fontMono = Geist_Mono({
 })
 
 export const metadata = {
-  title: 'AgentFit — Coding Agent Fitness Tracker',
+  title: 'AgentFit — Your AI Coding Fitness Tracker',
   description: 'Track your AI coding agent\'s fitness — usage, costs, personality, and behavioral patterns across Claude Code, Codex, and more.',
 }
 

package/bin/agentfit.mjs

@@ -26,7 +26,7 @@ function run(cmd, opts = {}) {
 // ─── Ensure .env exists ─────────────────────────────────────────────
 const envPath = path.join(ROOT, '.env')
 if (!existsSync(envPath)) {
-  writeFileSync(envPath, 'DATABASE_URL="file:./dev.db"\n')
+  writeFileSync(envPath, 'DATABASE_URL="file:./agentfit.db"\n')
 }
 
 // ─── First-run setup: prisma generate + migrate ─────────────────────
@@ -36,7 +36,7 @@ if (!existsSync(generatedClient)) {
   run('npx prisma generate')
 }
 
-const dbPath = path.join(ROOT, 'dev.db')
+const dbPath = path.join(ROOT, 'agentfit.db')
 if (!existsSync(dbPath)) {
   info('Creating database...')
   run('npx prisma migrate deploy')