agentfit 0.1.3 → 0.1.5

package/app/api/analyze/estimate/route.ts

@@ -0,0 +1,62 @@
+import { NextRequest, NextResponse } from 'next/server'
+import path from 'path'
+import os from 'os'
+import fs from 'fs'
+import { parseSessionDetail } from '@/lib/session-detail'
+import { extractUserMessages, estimateCost } from '@/lib/openai'
+
+export const dynamic = 'force-dynamic'
+
+function findSessionFile(sessionId: string): string | null {
+  const projectsDir = path.join(os.homedir(), '.claude', 'projects')
+  if (!fs.existsSync(projectsDir)) return null
+  for (const dir of fs.readdirSync(projectsDir)) {
+    const candidate = path.join(projectsDir, dir, `${sessionId}.jsonl`)
+    if (fs.existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+    const sessionIds: string[] = Array.isArray(body.sessionIds)
+      ? body.sessionIds
+      : body.sessionId
+        ? [body.sessionId]
+        : []
+
+    if (sessionIds.length === 0) {
+      return NextResponse.json({ error: 'Missing sessionId or sessionIds' }, { status: 400 })
+    }
+
+    let totalMessages = 0
+    let totalInputTokens = 0
+    let totalOutputTokens = 0
+    let totalCostUSD = 0
+
+    for (const sessionId of sessionIds) {
+      const filePath = findSessionFile(sessionId)
+      if (!filePath) continue
+
+      const detail = parseSessionDetail(filePath, sessionId)
+      const messages = extractUserMessages(detail.chatLog)
+      const estimate = estimateCost(messages)
+
+      totalMessages += estimate.messageCount
+      totalInputTokens += estimate.estimatedInputTokens
+      totalOutputTokens += estimate.estimatedOutputTokens
+      totalCostUSD += estimate.estimatedCostUSD
+    }
+
+    return NextResponse.json({
+      sessionCount: sessionIds.length,
+      messageCount: totalMessages,
+      estimatedInputTokens: totalInputTokens,
+      estimatedOutputTokens: totalOutputTokens,
+      estimatedCostUSD: totalCostUSD,
+    })
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}

package/app/api/analyze/route.ts

@@ -0,0 +1,142 @@
+import { NextRequest, NextResponse } from 'next/server'
+import path from 'path'
+import os from 'os'
+import fs from 'fs'
+import { prisma } from '@/lib/db'
+import { getOpenAIKey } from '@/lib/config'
+import { parseSessionDetail } from '@/lib/session-detail'
+import { extractUserMessages, classifyMessages } from '@/lib/openai'
+
+export const dynamic = 'force-dynamic'
+
+function findSessionFile(sessionId: string): string | null {
+  const projectsDir = path.join(os.homedir(), '.claude', 'projects')
+  if (!fs.existsSync(projectsDir)) return null
+  for (const dir of fs.readdirSync(projectsDir)) {
+    const candidate = path.join(projectsDir, dir, `${sessionId}.jsonl`)
+    if (fs.existsSync(candidate)) return candidate
+  }
+  return null
+}
+
+// GET — retrieve analysis results
+export async function GET(request: NextRequest) {
+  const sessionId = request.nextUrl.searchParams.get('sessionId')
+  const status = request.nextUrl.searchParams.get('status')
+
+  try {
+    if (status === 'true') {
+      // Return all analyzed session IDs
+      const analyses = await prisma.sessionAnalysis.findMany({
+        select: { sessionId: true, analyzedAt: true, totalMessages: true, costUSD: true },
+      })
+      return NextResponse.json({ analyses })
+    }
+
+    if (sessionId) {
+      const analysis = await prisma.sessionAnalysis.findUnique({
+        where: { sessionId },
+      })
+      if (!analysis) {
+        return NextResponse.json({ analysis: null })
+      }
+      return NextResponse.json({
+        analysis: {
+          ...analysis,
+          classifications: JSON.parse(analysis.classifications),
+        },
+      })
+    }
+
+    return NextResponse.json({ error: 'Missing sessionId or status param' }, { status: 400 })
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}
+
+// POST — trigger analysis for a session
+export async function POST(request: NextRequest) {
+  const apiKey = getOpenAIKey()
+  if (!apiKey) {
+    return NextResponse.json({ error: 'No OpenAI API key configured. Go to Settings to add one.' }, { status: 401 })
+  }
+
+  try {
+    const body = await request.json()
+    const sessionId = body.sessionId as string
+    if (!sessionId) {
+      return NextResponse.json({ error: 'Missing sessionId' }, { status: 400 })
+    }
+
+    // Check if already analyzed
+    const existing = await prisma.sessionAnalysis.findUnique({
+      where: { sessionId },
+    })
+    if (existing && !body.force) {
+      return NextResponse.json({
+        analysis: {
+          ...existing,
+          classifications: JSON.parse(existing.classifications),
+        },
+        cached: true,
+      })
+    }
+
+    // Find and parse the session
+    const filePath = findSessionFile(sessionId)
+    if (!filePath) {
+      return NextResponse.json({ error: 'Session JSONL not found' }, { status: 404 })
+    }
+
+    const detail = parseSessionDetail(filePath, sessionId)
+    const messages = extractUserMessages(detail.chatLog)
+
+    if (messages.length === 0) {
+      return NextResponse.json({ error: 'No user messages to analyze' }, { status: 400 })
+    }
+
+    // Classify
+    const result = await classifyMessages(apiKey, messages)
+
+    // Store results (upsert in case of re-analysis)
+    const analysis = await prisma.sessionAnalysis.upsert({
+      where: { sessionId },
+      create: {
+        sessionId,
+        model: result.model,
+        classifications: JSON.stringify(result.classifications),
+        totalMessages: result.totalMessages,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        costUSD: result.costUSD,
+      },
+      update: {
+        model: result.model,
+        classifications: JSON.stringify(result.classifications),
+        totalMessages: result.totalMessages,
+        inputTokens: result.inputTokens,
+        outputTokens: result.outputTokens,
+        costUSD: result.costUSD,
+        analyzedAt: new Date(),
+      },
+    })
+
+    return NextResponse.json({
+      analysis: {
+        ...analysis,
+        classifications: result.classifications,
+      },
+      cached: false,
+    })
+  } catch (error) {
+    const message = (error as Error).message
+    // Surface OpenAI-specific errors clearly
+    if (message.includes('401') || message.includes('Incorrect API key')) {
+      return NextResponse.json({ error: 'Invalid OpenAI API key' }, { status: 401 })
+    }
+    if (message.includes('429')) {
+      return NextResponse.json({ error: 'OpenAI rate limit exceeded. Try again later.' }, { status: 429 })
+    }
+    return NextResponse.json({ error: message }, { status: 500 })
+  }
+}

package/app/api/cc-versions/route.ts

@@ -0,0 +1,84 @@
+import { NextResponse } from 'next/server'
+import fs from 'fs'
+import path from 'path'
+
+export const dynamic = 'force-dynamic'
+
+const NPM_URL = 'https://registry.npmjs.org/@anthropic-ai/claude-code'
+const CACHE_FILE = path.resolve(process.cwd(), 'data', 'cc-versions.json')
+const CACHE_TTL = 86_400_000 // 24 hours
+
+interface VersionCache {
+  versions: Record<string, string>
+  fetchedAt: number
+}
+
+let memCache: VersionCache | null = null
+
+function readDiskCache(): VersionCache | null {
+  try {
+    if (fs.existsSync(CACHE_FILE)) {
+      return JSON.parse(fs.readFileSync(CACHE_FILE, 'utf-8'))
+    }
+  } catch {}
+  return null
+}
+
+function writeDiskCache(cache: VersionCache) {
+  try {
+    const dir = path.dirname(CACHE_FILE)
+    if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true })
+    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache))
+  } catch {}
+}
+
+function isFresh(cache: VersionCache | null): boolean {
+  return !!cache && Date.now() - cache.fetchedAt < CACHE_TTL
+}
+
+export async function GET() {
+  try {
+    // 1. Check in-memory cache
+    if (isFresh(memCache)) {
+      return NextResponse.json(memCache!.versions)
+    }
+
+    // 2. Check disk cache (survives server restarts)
+    const disk = readDiskCache()
+    if (isFresh(disk)) {
+      memCache = disk
+      return NextResponse.json(disk!.versions)
+    }
+
+    // 3. Fetch from npm registry
+    const res = await fetch(NPM_URL, {
+      headers: { Accept: 'application/json' },
+    })
+    if (!res.ok) {
+      // Fall back to stale cache if available
+      if (memCache) return NextResponse.json(memCache.versions)
+      if (disk) return NextResponse.json(disk.versions)
+      throw new Error(`npm registry returned ${res.status}`)
+    }
+
+    const pkg = await res.json()
+    const time: Record<string, string> = pkg.time || {}
+
+    // Filter to only version entries (exclude "created", "modified")
+    const versions: Record<string, string> = {}
+    for (const [key, value] of Object.entries(time)) {
+      if (/^\d+\.\d+\.\d+$/.test(key)) {
+        versions[key] = value as string
+      }
+    }
+
+    const cache: VersionCache = { versions, fetchedAt: Date.now() }
+    memCache = cache
+    writeDiskCache(cache)
+
+    return NextResponse.json(versions)
+  } catch (error) {
+    console.error('Failed to fetch CC versions:', error)
+    return NextResponse.json({}, { status: 500 })
+  }
+}

package/app/api/config/route.ts

@@ -0,0 +1,35 @@
+import { NextRequest, NextResponse } from 'next/server'
+import { getOpenAIKey, setOpenAIKey, clearOpenAIKey } from '@/lib/config'
+
+export const dynamic = 'force-dynamic'
+
+// GET — check if API key is configured (returns masked key, not the actual key)
+export async function GET() {
+  const key = getOpenAIKey()
+  return NextResponse.json({
+    hasOpenAIKey: !!key,
+    maskedKey: key ? `${key.slice(0, 7)}...${key.slice(-4)}` : null,
+  })
+}
+
+// POST — save or clear the API key
+export async function POST(request: NextRequest) {
+  try {
+    const body = await request.json()
+
+    if (body.action === 'clear') {
+      clearOpenAIKey()
+      return NextResponse.json({ success: true })
+    }
+
+    const apiKey = body.apiKey as string
+    if (!apiKey?.trim()) {
+      return NextResponse.json({ error: 'Missing apiKey' }, { status: 400 })
+    }
+
+    setOpenAIKey(apiKey.trim())
+    return NextResponse.json({ success: true })
+  } catch (error) {
+    return NextResponse.json({ error: (error as Error).message }, { status: 500 })
+  }
+}

package/bin/agentfit.mjs

@@ -1,13 +1,26 @@
 #!/usr/bin/env node
 
 import { execSync, spawn } from 'child_process'
-import { existsSync, writeFileSync } from 'fs'
+import { createServer } from 'net'
+import { existsSync } from 'fs'
 import path from 'path'
 import { fileURLToPath } from 'url'
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url))
 const ROOT = path.resolve(__dirname, '..')
-const PORT = process.env.AGENTFIT_PORT || process.env.PORT || '3000'
+
+function findAvailablePort(startPort) {
+  return new Promise((resolve) => {
+    const server = createServer()
+    server.listen(startPort, () => {
+      server.close(() => resolve(startPort))
+    })
+    server.on('error', () => resolve(findAvailablePort(startPort + 1)))
+  })
+}
+
+const preferredPort = parseInt(process.env.AGENTFIT_PORT || process.env.PORT || '3000', 10)
+const PORT = await findAvailablePort(preferredPort)
 
 function info(msg) {
   console.log(`\x1b[1;34m==>\x1b[0m ${msg}`)
@@ -23,12 +36,6 @@ function run(cmd, opts = {}) {
   execSync(cmd, { cwd: ROOT, stdio: 'inherit', ...opts })
 }
 
-// ─── Ensure .env exists ─────────────────────────────────────────────
-const envPath = path.join(ROOT, '.env')
-if (!existsSync(envPath)) {
-  writeFileSync(envPath, 'DATABASE_URL="file:./agentfit.db"\n')
-}
-
 // ─── First-run setup: prisma generate + migrate ─────────────────────
 const generatedClient = path.join(ROOT, 'generated', 'prisma')
 if (!existsSync(generatedClient)) {
@@ -49,6 +56,9 @@ if (!existsSync(nextDir)) {
 }
 
 // ─── Start server ───────────────────────────────────────────────────
+if (PORT !== preferredPort) {
+  info(`Port ${preferredPort} is in use, using ${PORT} instead`)
+}
 ok(`Starting AgentFit on http://localhost:${PORT}`)
 console.log('  Press Ctrl+C to stop.\n')
 

package/components/analyze-confirm-dialog.tsx

@@ -0,0 +1,81 @@
+'use client'
+
+import {
+  Dialog,
+  DialogContent,
+  DialogFooter,
+  DialogHeader,
+  DialogTitle,
+} from '@/components/ui/dialog'
+import { Button } from '@/components/ui/button'
+import { Loader2 } from 'lucide-react'
+import { formatCost } from '@/lib/format'
+
+interface AnalyzeConfirmDialogProps {
+  open: boolean
+  onOpenChange: (open: boolean) => void
+  onConfirm: () => void
+  loading: boolean
+  estimate: {
+    sessionCount: number
+    messageCount: number
+    estimatedCostUSD: number
+  } | null
+}
+
+export function AnalyzeConfirmDialog({
+  open,
+  onOpenChange,
+  onConfirm,
+  loading,
+  estimate,
+}: AnalyzeConfirmDialogProps) {
+  return (
+    <Dialog open={open} onOpenChange={onOpenChange}>
+      <DialogContent>
+        <DialogHeader>
+          <DialogTitle>Run AI Analysis</DialogTitle>
+        </DialogHeader>
+        {estimate ? (
+          <div className="space-y-3">
+            <div className="rounded-lg border p-4 space-y-2">
+              <div className="flex justify-between text-sm">
+                <span className="text-muted-foreground">Sessions</span>
+                <span className="font-medium">{estimate.sessionCount}</span>
+              </div>
+              <div className="flex justify-between text-sm">
+                <span className="text-muted-foreground">User messages</span>
+                <span className="font-medium">{estimate.messageCount}</span>
+              </div>
+              <div className="flex justify-between text-sm">
+                <span className="text-muted-foreground">Model</span>
+                <span className="font-medium">gpt-4.1-mini</span>
+              </div>
+              <div className="flex justify-between text-sm border-t pt-2">
+                <span className="text-muted-foreground">Estimated cost</span>
+                <span className="font-bold">{formatCost(estimate.estimatedCostUSD)}</span>
+              </div>
+            </div>
+            <p className="text-xs text-muted-foreground">
+              Each user message will be classified by type, role, skill level, and sentiment.
+              Results are cached — you won&apos;t be charged again for the same session.
+            </p>
+          </div>
+        ) : (
+          <div className="flex items-center justify-center py-8">
+            <Loader2 className="h-5 w-5 animate-spin text-muted-foreground" />
+          </div>
+        )}
+        <DialogFooter>
+          <Button variant="outline" onClick={() => onOpenChange(false)}>
+            Cancel
+          </Button>
+          <Button onClick={onConfirm} disabled={!estimate || loading}>
+            {loading && <Loader2 className="mr-1 h-3 w-3 animate-spin" />}
+            Analyze
+          </Button>
+        </DialogFooter>
+      </DialogContent>
+    </Dialog>
+  )
+}

package/components/app-sidebar.tsx

@@ -9,14 +9,17 @@ import {
   Camera,
   ChevronRight,
   Coins,
+  Cpu,
   FileText,
   FolderOpen,
   GitBranch,
   HeartPulse,
+  Key,
   LayoutDashboard,
   ListTree,
   Puzzle,
   Settings,
+  Sparkles,
   Terminal,
   Wrench,
 } from 'lucide-react'
@@ -74,6 +77,7 @@ const navGroups: NavGroup[] = [
       { title: 'Token Breakdown', icon: Coins, href: '/tokens' },
       { title: 'Tool Usage', icon: Wrench, href: '/tools' },
       { title: 'Command Usage', icon: Terminal, href: '/commands' },
+      { title: 'Model Usage', icon: Cpu, href: '/models' },
     ],
   },
   {
@@ -82,6 +86,7 @@ const navGroups: NavGroup[] = [
     items: [
       { title: 'Personality Fit', icon: Brain, href: '/personality' },
       { title: 'Session Flow', icon: GitBranch, href: '/flow' },
+      { title: 'AI Insights', icon: Sparkles, href: '/ai-insights' },
       { title: 'Image Analysis', icon: Camera, href: '/images' },
       { title: 'Reports', icon: FileText, href: '/reports' },
     ],
@@ -170,6 +175,15 @@ export function AppSidebar() {
                   <span>Data Management</span>
                 </SidebarMenuButton>
               </SidebarMenuItem>
+              <SidebarMenuItem>
+                <SidebarMenuButton
+                  render={<Link href="/settings" />}
+                  isActive={pathname === '/settings'}
+                >
+                  <Key className="h-4 w-4" />
+                  <span>Settings</span>
+                </SidebarMenuButton>
+              </SidebarMenuItem>
             </SidebarMenu>
           </SidebarGroupContent>
         </SidebarGroup>

package/components/data-provider.tsx

@@ -131,8 +131,10 @@ function filterData(raw: UsageData | null, range: TimeRange, project: string): U
       toolUsage[tool] = (toolUsage[tool] || 0) + count
     }
 
-    // Models
-    models[s.model] = (models[s.model] || 0) + 1
+    // Models — aggregate at message level
+    for (const [m, count] of Object.entries(s.modelCounts || {})) {
+      models[m] = (models[m] || 0) + count
+    }
   }
 
   const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)