agentfit 0.1.0 → 0.1.2

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

@@ -0,0 +1,132 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import Link from 'next/link'
+import { Card, CardContent } from '@/components/ui/card'
+import { Button } from '@/components/ui/button'
+import { Badge } from '@/components/ui/badge'
+import { Tooltip, TooltipContent, TooltipTrigger } from '@/components/ui/tooltip'
+import { FileText, Plus, Loader2, ChevronRight } from 'lucide-react'
+import { toast } from 'sonner'
+import { useData } from '@/components/data-provider'
+
+interface ReportSummary {
+  id: string
+  title: string
+  generatedAt: string
+  sessionCount: number
+}
+
+export default function ReportsPage() {
+  const { data } = useData()
+  const [reports, setReports] = useState<ReportSummary[]>([])
+  const [loading, setLoading] = useState(true)
+  const [generating, setGenerating] = useState(false)
+
+  async function fetchReports() {
+    try {
+      const res = await fetch('/api/reports')
+      setReports(await res.json())
+    } catch {
+      // ignore
+    } finally {
+      setLoading(false)
+    }
+  }
+
+  useEffect(() => { fetchReports() }, [])
+
+  const currentSessionCount = data?.overview.totalSessions || 0
+  const lastReportSessionCount = reports[0]?.sessionCount || 0
+  const hasNewData = reports.length === 0 || currentSessionCount !== lastReportSessionCount
+
+  async function handleGenerate() {
+    setGenerating(true)
+    try {
+      const res = await fetch('/api/reports', { method: 'POST' })
+      const report = await res.json()
+      if (res.status === 409) {
+        toast.info('No new data', { description: report.error })
+        return
+      }
+      if (!res.ok) throw new Error(report.error || 'Failed to generate report')
+      toast.success('Report generated', { description: report.title })
+      await fetchReports()
+    } catch (e) {
+      toast.error('Failed to generate report', { description: (e as Error).message })
+    } finally {
+      setGenerating(false)
+    }
+  }
+
+  const buttonDisabled = generating || !hasNewData
+
+  return (
+    <div className="space-y-6 max-w-3xl">
+      <div className="flex items-center justify-between">
+        <div>
+          <h2 className="text-lg font-semibold">Insights Reports</h2>
+          <p className="text-sm text-muted-foreground">
+            Generate point-in-time snapshots of your coding agent fitness
+          </p>
+        </div>
+        <Tooltip>
+          <TooltipTrigger
+            render={<span />}
+          >
+            <Button onClick={handleGenerate} disabled={buttonDisabled} className="gap-2">
+              {generating ? <Loader2 className="h-4 w-4 animate-spin" /> : <Plus className="h-4 w-4" />}
+              {generating ? 'Generating...' : 'Generate Report'}
+            </Button>
+          </TooltipTrigger>
+          {!hasNewData && (
+            <TooltipContent>
+              No new sessions since last report. Sync new data first.
+            </TooltipContent>
+          )}
+        </Tooltip>
+      </div>
+
+      {loading ? (
+        <div className="flex items-center gap-2 py-8 text-muted-foreground">
+          <Loader2 className="h-4 w-4 animate-spin" /> Loading reports...
+        </div>
+      ) : reports.length === 0 ? (
+        <Card>
+          <CardContent className="py-12 text-center">
+            <FileText className="h-10 w-10 text-muted-foreground/30 mx-auto mb-3" />
+            <p className="text-sm text-muted-foreground">
+              No reports yet. Click "Generate Report" to create your first fitness snapshot.
+            </p>
+          </CardContent>
+        </Card>
+      ) : (
+        <div className="space-y-2">
+          {reports.map(report => (
+            <Link key={report.id} href={`/reports/${report.id}`}>
+              <Card className="hover:bg-muted/50 transition-colors cursor-pointer">
+                <CardContent className="flex items-center justify-between py-4">
+                  <div className="flex items-center gap-3">
+                    <FileText className="h-5 w-5 text-muted-foreground" />
+                    <div>
+                      <div className="text-sm font-medium">{report.title}</div>
+                      <div className="text-xs text-muted-foreground">
+                        {new Date(report.generatedAt).toLocaleString()}
+                      </div>
+                    </div>
+                  </div>
+                  <div className="flex items-center gap-3">
+                    <Badge variant="secondary" className="text-xs">
+                      {report.sessionCount} sessions
+                    </Badge>
+                    <ChevronRight className="h-4 w-4 text-muted-foreground" />
+                  </div>
+                </CardContent>
+              </Card>
+            </Link>
+          ))}
+        </div>
+      )}
+    </div>
+  )
+}

package/app/(dashboard)/sessions/[id]/page.tsx

@@ -0,0 +1,167 @@
+'use client'
+
+import { useEffect, useState } from 'react'
+import { useParams } from 'next/navigation'
+import Link from 'next/link'
+import { Card, CardContent, CardDescription, CardHeader, CardTitle } from '@/components/ui/card'
+import { ArrowLeft, Clock, Coins, MessageSquare, Wrench, CheckCircle, XCircle } from 'lucide-react'
+import { SessionWorkflow } from '@/components/session-workflow'
+import { SessionChatLog } from '@/components/session-chatlog'
+import type { SessionDetail } from '@/lib/session-detail'
+
+export default function SessionDetailPage() {
+  const params = useParams()
+  const sessionId = params.id as string
+  const [detail, setDetail] = useState<SessionDetail | null>(null)
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [activeTab, setActiveTab] = useState<'workflow' | 'dialog'>('dialog')
+
+  useEffect(() => {
+    async function load() {
+      try {
+        const res = await fetch(`/api/session?id=${sessionId}`)
+        if (!res.ok) throw new Error('Session not found')
+        const data = await res.json()
+        setDetail(data)
+      } catch (e) {
+        setError((e as Error).message)
+      } finally {
+        setLoading(false)
+      }
+    }
+    load()
+  }, [sessionId])
+
+  if (loading) {
+    return <div className="text-muted-foreground">Loading session...</div>
+  }
+
+  if (error || !detail) {
+    return (
+      <div className="space-y-4">
+        <Link href="/sessions" className="flex items-center gap-1 text-sm text-primary hover:underline">
+          <ArrowLeft className="h-4 w-4" /> Back to sessions
+        </Link>
+        <div className="text-destructive">{error || 'Session not found'}</div>
+      </div>
+    )
+  }
+
+  const s = detail.stats
+
+  return (
+    <div className="space-y-4">
+      <Link href="/sessions" className="flex items-center gap-1 text-sm text-muted-foreground hover:text-foreground">
+        <ArrowLeft className="h-4 w-4" /> Back to sessions
+      </Link>
+
+      <div className="grid gap-4 sm:grid-cols-2 lg:grid-cols-6">
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-muted-foreground">Duration</CardTitle>
+            <Clock className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold tracking-tight">{s.duration}</div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-muted-foreground">Tokens</CardTitle>
+            <Coins className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold tracking-tight">{s.tokens.toLocaleString()}</div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-muted-foreground">Messages</CardTitle>
+            <MessageSquare className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold tracking-tight">{s.totalMessages}</div>
+            <p className="text-xs text-muted-foreground">{s.userTurns} user / {s.assistantTurns} assistant</p>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-muted-foreground">Tool Calls</CardTitle>
+            <Wrench className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold tracking-tight">{s.toolCalls}</div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-muted-foreground">Success</CardTitle>
+            <CheckCircle className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className="text-2xl font-bold tracking-tight">{s.successCount}</div>
+          </CardContent>
+        </Card>
+        <Card>
+          <CardHeader className="flex flex-row items-center justify-between pb-2">
+            <CardTitle className="text-sm font-medium text-muted-foreground">Failures</CardTitle>
+            <XCircle className="h-4 w-4 text-muted-foreground" />
+          </CardHeader>
+          <CardContent>
+            <div className={`text-2xl font-bold tracking-tight ${s.failureCount > 0 ? 'text-destructive' : ''}`}>{s.failureCount}</div>
+          </CardContent>
+        </Card>
+      </div>
+
+      <div className="flex gap-1.5 border-b pb-1">
+        <button
+          onClick={() => setActiveTab('dialog')}
+          className={`rounded-md px-3 py-1.5 text-sm font-medium transition-colors ${
+            activeTab === 'dialog'
+              ? 'bg-primary text-primary-foreground'
+              : 'text-muted-foreground hover:text-foreground'
+          }`}
+        >
+          Dialog
+        </button>
+        <button
+          onClick={() => setActiveTab('workflow')}
+          className={`rounded-md px-3 py-1.5 text-sm font-medium transition-colors ${
+            activeTab === 'workflow'
+              ? 'bg-primary text-primary-foreground'
+              : 'text-muted-foreground hover:text-foreground'
+          }`}
+        >
+          Workflow
+        </button>
+      </div>
+
+      {activeTab === 'dialog' && (
+        <Card>
+          <CardHeader>
+            <CardTitle>Chat Log</CardTitle>
+            <CardDescription>{detail.chatLog.length} records</CardDescription>
+          </CardHeader>
+          <CardContent>
+            <SessionChatLog messages={detail.chatLog} />
+          </CardContent>
+        </Card>
+      )}
+
+      {activeTab === 'workflow' && (
+        <Card>
+          <CardHeader>
+            <CardTitle>Workflow</CardTitle>
+            <CardDescription>
+              Tool calls, reasoning, and execution flow — {detail.workflowNodes.length} nodes
+            </CardDescription>
+          </CardHeader>
+          <CardContent>
+            <SessionWorkflow nodes={detail.workflowNodes} edges={detail.workflowEdges} />
+          </CardContent>
+        </Card>
+      )}
+    </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/commands/route.ts

@@ -1,12 +1,66 @@
 import { NextResponse } from 'next/server'
 import { analyzeCommands } from '@/lib/commands'
+import { prisma } from '@/lib/db'
 
 export const dynamic = 'force-dynamic'
 
 export async function GET() {
   try {
     const analysis = analyzeCommands()
-    return NextResponse.json(analysis)
+
+    // Merge skill invocations from session data (Skill tool calls tracked in DB)
+    // These capture cases where the user asked Claude to invoke a skill
+    // (e.g. "use /doc-writer to...") rather than typing the slash command directly
+    const dbSessions = await prisma.session.findMany({
+      select: { skillCallsJson: true },
+    })
+
+    const dbSkillCounts = new Map<string, number>()
+    for (const s of dbSessions) {
+      const skills = JSON.parse(s.skillCallsJson) as Record<string, number>
+      for (const [skill, count] of Object.entries(skills)) {
+        const cmd = skill.startsWith('/') ? skill : `/${skill}`
+        dbSkillCounts.set(cmd, (dbSkillCounts.get(cmd) || 0) + count)
+      }
+    }
+
+    // Build a map of history.jsonl counts for custom commands
+    const historyMap = new Map<string, number>()
+    for (const c of analysis.customCommands) {
+      historyMap.set(c.command, c.count)
+    }
+
+    // Merge DB skill counts into customCommands with breakdown
+    const customMap = new Map<string, { command: string; count: number; historyCount: number; sessionCount: number }>()
+    for (const c of analysis.customCommands) {
+      customMap.set(c.command, { command: c.command, count: c.count, historyCount: c.count, sessionCount: 0 })
+    }
+    for (const [cmd, count] of dbSkillCounts) {
+      const existing = analysis.commands.find(c => c.command === cmd)
+      if (existing) {
+        existing.count += count
+        existing.used = existing.count > 0
+      } else {
+        const prev = customMap.get(cmd)
+        if (prev) {
+          prev.sessionCount += count
+          prev.count += count
+        } else {
+          customMap.set(cmd, { command: cmd, count, historyCount: 0, sessionCount: count })
+        }
+      }
+    }
+
+    analysis.customCommands = Array.from(customMap.values())
+      .sort((a, b) => b.count - a.count)
+
+    // Expose session skill counts so the chart can show breakdown
+    const responseData = {
+      ...analysis,
+      dbSkillCounts: Object.fromEntries(dbSkillCounts),
+    }
+
+    return NextResponse.json(responseData)
   } catch (error) {
     return NextResponse.json(
       { error: (error as Error).message },

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 })
+  }
+}