agentfit 0.1.0 → 0.1.2

package/lib/command-insights.ts

@@ -0,0 +1,231 @@
+// ─── Command Discovery Insights ──────────────────────────────────────
+// Analyzes ~/.claude/history.jsonl command patterns to generate
+// actionable coaching insights about command adoption.
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+export interface CommandInsight {
+  id: string
+  title: string
+  description: string
+  severity: 'tip' | 'achievement'
+  metric?: string
+  recommendation?: string
+}
+
+interface CommandTimeline {
+  command: string
+  firstUsed: string  // ISO date
+  totalUses: number
+  recentUses: number // last 7 days
+  isBuiltIn: boolean
+}
+
+// High-value built-in commands that many users don't know about
+const POWER_COMMANDS: Record<string, { description: string; benefit: string }> = {
+  '/compact': {
+    description: 'Compress conversation context with optional focus instructions',
+    benefit: 'Reduces context overflow by ~50%. Use when context exceeds 80% but you\'re still working on the same task.',
+  },
+  '/rewind': {
+    description: 'Rewind conversation and/or code to a previous point',
+    benefit: 'Undo mistakes without restarting. Saves 5-10 minutes per recovery vs starting fresh.',
+  },
+  '/simplify': {
+    description: 'Review changed code for reuse, quality, and efficiency',
+    benefit: 'Catches code quality issues automatically. Run after completing a feature to clean up.',
+  },
+  '/diff': {
+    description: 'Interactive diff viewer for uncommitted changes',
+    benefit: 'Review all changes at a glance before committing. Catches unintended modifications.',
+  },
+  '/btw': {
+    description: 'Ask a side question without polluting the main conversation',
+    benefit: 'Keeps your main context clean. Quick lookups without losing your place.',
+  },
+  '/branch': {
+    description: 'Create a branch of the current conversation',
+    benefit: 'Try risky approaches without losing your current progress. Fork, experiment, come back.',
+  },
+  '/plan': {
+    description: 'Enter plan mode for complex tasks',
+    benefit: 'Forces the agent to think before acting. Reduces wasted iterations on complex problems.',
+  },
+  '/context': {
+    description: 'Visualize current context usage as a colored grid',
+    benefit: 'See exactly what\'s consuming your context window. Know when to /compact.',
+  },
+  '/security-review': {
+    description: 'Analyze pending changes for security vulnerabilities',
+    benefit: 'Catches injection, auth, and data exposure issues before they ship.',
+  },
+  '/insights': {
+    description: 'Generate a report analyzing your Claude Code sessions',
+    benefit: 'Built-in analytics about your interaction patterns and friction points.',
+  },
+  '/frontend-design': {
+    description: 'Create distinctive, production-grade frontend interfaces',
+    benefit: 'Generates polished UI components with creative design choices, not generic AI slop.',
+  },
+  '/rename': {
+    description: 'Name your session for easy recall later',
+    benefit: 'Find important sessions quickly with /resume instead of scrolling through UUIDs.',
+  },
+  '/export': {
+    description: 'Export the current conversation as plain text',
+    benefit: 'Save important conversations for documentation, sharing, or review.',
+  },
+}
+
+function parseCommandHistory(): CommandTimeline[] {
+  const historyPath = path.join(os.homedir(), '.claude', 'history.jsonl')
+  if (!fs.existsSync(historyPath)) return []
+
+  const content = fs.readFileSync(historyPath, 'utf-8')
+  const lines = content.trim().split('\n')
+
+  const commandData = new Map<string, { firstUsed: number; uses: number; recentUses: number }>()
+  const now = Date.now()
+  const sevenDaysAgo = now - 7 * 24 * 60 * 60 * 1000
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+    try {
+      const entry = JSON.parse(line)
+      const text = (entry.display || '').trim()
+      const ts = entry.timestamp || 0
+      const match = text.match(/^\/([a-zA-Z_-]+)/)
+      if (!match) continue
+      const cmd = '/' + match[1]
+
+      if (!commandData.has(cmd)) {
+        commandData.set(cmd, { firstUsed: ts, uses: 0, recentUses: 0 })
+      }
+      const d = commandData.get(cmd)!
+      d.uses++
+      if (d.firstUsed > ts) d.firstUsed = ts
+      if (ts > sevenDaysAgo) d.recentUses++
+    } catch {
+      continue
+    }
+  }
+
+  return Array.from(commandData.entries()).map(([cmd, data]) => ({
+    command: cmd,
+    firstUsed: new Date(data.firstUsed).toISOString().slice(0, 10),
+    totalUses: data.uses,
+    recentUses: data.recentUses,
+    isBuiltIn: cmd in POWER_COMMANDS,
+  }))
+}
+
+export function generateCommandInsights(): CommandInsight[] {
+  const timeline = parseCommandHistory()
+  const insights: CommandInsight[] = []
+  const usedCommands = new Set(timeline.map(t => t.command))
+
+  // 1. Power commands you discovered and now use frequently
+  const powerHits = timeline
+    .filter(t => POWER_COMMANDS[t.command] && t.totalUses >= 5)
+    .sort((a, b) => b.totalUses - a.totalUses)
+
+  if (powerHits.length > 0) {
+    const top = powerHits.slice(0, 3)
+    insights.push({
+      id: 'power-commands-adopted',
+      title: `Power commands mastered: ${top.map(t => t.command).join(', ')}`,
+      description: `You've adopted ${powerHits.length} power commands. ${top[0].command} is your most-used (${top[0].totalUses}x). These commands significantly improve your workflow efficiency.`,
+      severity: 'achievement',
+      metric: `${powerHits.length} mastered`,
+    })
+  }
+
+  // 2. Recently discovered commands gaining traction
+  const recentDiscoveries = timeline
+    .filter(t => {
+      const daysSinceFirst = (Date.now() - new Date(t.firstUsed).getTime()) / (1000 * 60 * 60 * 24)
+      return daysSinceFirst < 14 && t.totalUses >= 3
+    })
+    .sort((a, b) => b.totalUses - a.totalUses)
+
+  for (const disc of recentDiscoveries.slice(0, 2)) {
+    const info = POWER_COMMANDS[disc.command]
+    insights.push({
+      id: `recent-discovery-${disc.command}`,
+      title: `New favorite: ${disc.command} (${disc.totalUses}x in ${Math.ceil((Date.now() - new Date(disc.firstUsed).getTime()) / (1000 * 60 * 60 * 24))} days)`,
+      description: info
+        ? `${info.description}. ${info.benefit}`
+        : `You discovered ${disc.command} recently and it's becoming a regular part of your workflow.`,
+      severity: 'achievement',
+      metric: `${disc.totalUses}x`,
+    })
+  }
+
+  // 3. High-value commands you haven't tried yet
+  const untried = Object.entries(POWER_COMMANDS)
+    .filter(([cmd]) => !usedCommands.has(cmd))
+    .sort(() => Math.random() - 0.5) // randomize so different tips each time
+
+  for (const [cmd, info] of untried.slice(0, 3)) {
+    insights.push({
+      id: `try-${cmd}`,
+      title: `Try ${cmd}`,
+      description: info.description,
+      severity: 'tip',
+      recommendation: info.benefit,
+    })
+  }
+
+  // 4. Commands you used to use but stopped
+  const abandoned = timeline
+    .filter(t => t.totalUses >= 3 && t.recentUses === 0 && POWER_COMMANDS[t.command])
+    .sort((a, b) => b.totalUses - a.totalUses)
+
+  for (const cmd of abandoned.slice(0, 2)) {
+    const info = POWER_COMMANDS[cmd.command]!
+    insights.push({
+      id: `revive-${cmd.command}`,
+      title: `Revisit ${cmd.command}?`,
+      description: `You used ${cmd.command} ${cmd.totalUses} times but haven't used it recently.`,
+      severity: 'tip',
+      recommendation: info.benefit,
+    })
+  }
+
+  // 5. Command diversity insight
+  const weeklyDiversity = timeline.filter(t => t.recentUses > 0).length
+  if (weeklyDiversity >= 8) {
+    insights.push({
+      id: 'diverse-commands',
+      title: `${weeklyDiversity} commands used this week`,
+      description: 'You have a diverse command vocabulary. This means you\'re leveraging the full power of your coding agent instead of just chatting.',
+      severity: 'achievement',
+      metric: `${weeklyDiversity} active`,
+    })
+  } else if (weeklyDiversity <= 3 && timeline.length > 5) {
+    insights.push({
+      id: 'low-diversity',
+      title: 'Low command diversity this week',
+      description: `Only ${weeklyDiversity} commands used in the last 7 days. Slash commands save time by encoding common workflows into single keystrokes.`,
+      severity: 'tip',
+      recommendation: 'Type / in Claude Code to see all available commands. Try using at least one new command today.',
+    })
+  }
+
+  // 6. Custom skills/plugins adoption
+  const customCommands = timeline.filter(t => !Object.keys(POWER_COMMANDS).includes(t.command) && t.totalUses >= 3)
+  if (customCommands.length >= 3) {
+    const topCustom = customCommands.sort((a, b) => b.totalUses - a.totalUses).slice(0, 3)
+    insights.push({
+      id: 'custom-skills',
+      title: `${customCommands.length} custom skills in your toolkit`,
+      description: `Your most-used custom commands: ${topCustom.map(c => `${c.command} (${c.totalUses}x)`).join(', ')}. Custom skills automate your specific workflows.`,
+      severity: 'achievement',
+      metric: `${customCommands.length} skills`,
+    })
+  }
+
+  return insights
+}

package/lib/db.ts

@@ -3,8 +3,8 @@ import { PrismaLibSql } from '@prisma/adapter-libsql'
 import path from 'path'
 
 function createPrisma() {
-  const dbPath = path.resolve(process.cwd(), 'dev.db')
-  const adapter = new PrismaLibSql({ url: `file:${dbPath}` })
+  const dbUrl = process.env.DATABASE_URL || `file:${path.resolve(process.cwd(), 'agentfit.db')}`
+  const adapter = new PrismaLibSql({ url: dbUrl })
   return new PrismaClient({ adapter })
 }
 

package/lib/parse-codex.ts

@@ -158,6 +158,12 @@ export function parseCodexSession(filePath: string): SessionSummary | null {
       model: model || 'gpt-5',
       toolCalls,
       toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
+      skillCalls: {},
+      apiErrors: 0,
+      rateLimitErrors: 0,
+      userInterruptions: 0,
+      systemPromptEdits: 0,
+      permissionModes: {},
     }
   } catch {
     return null

package/lib/parse-logs.ts

@@ -27,6 +27,13 @@ export interface SessionSummary {
   model: string
   toolCalls: Record<string, number>
   toolCallsTotal: number
+  skillCalls: Record<string, number>
+  messageTimestamps?: string[] // ISO timestamps of each message
+  apiErrors: number
+  rateLimitErrors: number
+  userInterruptions: number
+  permissionModes: Record<string, number> // default, acceptEdits, bypassPermissions, plan
+  systemPromptEdits: number // edits/writes to CLAUDE.md, AGENTS.md, agent.md
 }
 
 export interface ProjectSummary {
@@ -44,6 +51,8 @@ export interface DailyUsage {
   date: string
   sessions: number
   messages: number
+  userMessages: number
+  assistantMessages: number
   inputTokens: number
   outputTokens: number
   cacheCreationTokens: number
@@ -51,6 +60,9 @@ export interface DailyUsage {
   totalTokens: number
   costUSD: number
   toolCalls: number
+  toolCallsDetail: Record<string, number>
+  interruptions: number
+  rateLimitErrors: number
 }
 
 export interface OverviewStats {
@@ -67,7 +79,13 @@ export interface OverviewStats {
   totalCostUSD: number
   totalDurationMinutes: number
   totalToolCalls: number
+  totalApiErrors: number
+  totalRateLimitDays: number
+  totalUserInterruptions: number
+  totalSystemPromptEdits: number
   models: Record<string, number>
+  skillUsage: Record<string, number>
+  permissionModes: Record<string, number>
 }
 
 export interface UsageData {
@@ -85,7 +103,23 @@ function decodeProjectPath(dirName: string): string {
 }
 
 function getProjectName(projectPath: string): string {
+  // The decoded path may be wrong if the actual folder name contains dashes,
+  // since decodeProjectPath replaces ALL dashes with slashes.
+  // Try merging trailing segments to find the real directory on disk.
+  if (fs.existsSync(projectPath)) {
+    return path.basename(projectPath)
+  }
   const parts = projectPath.split('/')
+  for (let merge = 2; merge <= Math.min(parts.length, 6); merge++) {
+    const parentParts = parts.slice(0, -merge)
+    const nameParts = parts.slice(-merge)
+    const candidateName = nameParts.join('-')
+    const candidatePath = [...parentParts, candidateName].join('/')
+    if (fs.existsSync(candidatePath)) {
+      return candidateName
+    }
+  }
+  // Fallback: last segment
   return parts[parts.length - 1] || parts[parts.length - 2] || projectPath
 }
 
@@ -125,6 +159,8 @@ function parseSessionFile(
     let startTime = ''
     let endTime = ''
     const toolCalls: Record<string, number> = {}
+    const permissionModes: Record<string, number> = {}
+    let systemPromptEdits = 0
 
     for (const line of lines) {
       if (!line.trim()) continue
@@ -143,6 +179,11 @@ function parseSessionFile(
 
       if (entry.type === 'user') {
         userMessages++
+        // Track permission mode
+        const pm = (entry as Record<string, unknown>).permissionMode as string | undefined
+        if (pm) {
+          permissionModes[pm] = (permissionModes[pm] || 0) + 1
+        }
       } else if (entry.type === 'assistant' && entry.message) {
         assistantMessages++
         const msg = entry.message
@@ -174,9 +215,17 @@ function parseSessionFile(
               'type' in block &&
               (block as Record<string, unknown>).type === 'tool_use'
             ) {
-              const toolName = (block as Record<string, unknown>).name as string
+              const b = block as Record<string, unknown>
+              const toolName = b.name as string
               if (toolName) {
                 toolCalls[toolName] = (toolCalls[toolName] || 0) + 1
+                // Detect system prompt file edits (CLAUDE.md, AGENTS.md, agent.md)
+                if ((toolName === 'Edit' || toolName === 'Write') && b.input && typeof b.input === 'object') {
+                  const filePath = (b.input as Record<string, unknown>).file_path as string
+                  if (filePath && /\/(CLAUDE|AGENTS|agent)\.md$/i.test(filePath)) {
+                    systemPromptEdits++
+                  }
+                }
               }
             }
           }
@@ -212,6 +261,12 @@ function parseSessionFile(
       model: model || 'unknown',
       toolCalls,
       toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
+      skillCalls: {},
+      apiErrors: 0,
+      rateLimitErrors: 0,
+      userInterruptions: 0,
+      permissionModes,
+      systemPromptEdits,
     }
   } catch {
     return null
@@ -280,6 +335,8 @@ export async function parseAllLogs(): Promise<UsageData> {
             date,
             sessions: 0,
             messages: 0,
+            userMessages: 0,
+            assistantMessages: 0,
             inputTokens: 0,
             outputTokens: 0,
             cacheCreationTokens: 0,
@@ -287,11 +344,16 @@ export async function parseAllLogs(): Promise<UsageData> {
             totalTokens: 0,
             costUSD: 0,
             toolCalls: 0,
+            toolCallsDetail: {},
+            interruptions: 0,
+            rateLimitErrors: 0,
           })
         }
         const daily = dailyMap.get(date)!
         daily.sessions++
         daily.messages += session.totalMessages
+        daily.userMessages += session.userMessages
+        daily.assistantMessages += session.assistantMessages
         daily.inputTokens += session.inputTokens
         daily.outputTokens += session.outputTokens
         daily.cacheCreationTokens += session.cacheCreationTokens
@@ -299,6 +361,11 @@ export async function parseAllLogs(): Promise<UsageData> {
         daily.totalTokens += session.totalTokens
         daily.costUSD += session.costUSD
         daily.toolCalls += session.toolCallsTotal
+        daily.interruptions += session.userInterruptions
+        daily.rateLimitErrors += session.rateLimitErrors
+        for (const [tool, count] of Object.entries(session.toolCalls)) {
+          daily.toolCallsDetail[tool] = (daily.toolCallsDetail[tool] || 0) + count
+        }
       }
 
       // Aggregate tool usage
@@ -337,7 +404,13 @@ export async function parseAllLogs(): Promise<UsageData> {
     totalCostUSD: sessions.reduce((a, s) => a + s.costUSD, 0),
     totalDurationMinutes: sessions.reduce((a, s) => a + s.durationMinutes, 0),
     totalToolCalls: sessions.reduce((a, s) => a + s.toolCallsTotal, 0),
+    totalApiErrors: 0,
+    totalRateLimitDays: 0,
+    totalUserInterruptions: 0,
+    totalSystemPromptEdits: sessions.reduce((a, s) => a + s.systemPromptEdits, 0),
     models,
+    skillUsage: {},
+    permissionModes: {},
   }
 
   return { overview, sessions, projects, daily, toolUsage }
@@ -359,7 +432,13 @@ function emptyUsageData(): UsageData {
       totalCostUSD: 0,
       totalDurationMinutes: 0,
       totalToolCalls: 0,
+      totalApiErrors: 0,
+      totalRateLimitDays: 0,
+      totalUserInterruptions: 0,
+      totalSystemPromptEdits: 0,
       models: {},
+      skillUsage: {},
+      permissionModes: {},
     },
     sessions: [],
     projects: [],

package/lib/queries-codex.ts

@@ -52,6 +52,8 @@ export function getCodexUsageData(): UsageData {
         date,
         sessions: 0,
         messages: 0,
+        userMessages: 0,
+        assistantMessages: 0,
         inputTokens: 0,
         outputTokens: 0,
         cacheCreationTokens: 0,
@@ -59,16 +61,26 @@ export function getCodexUsageData(): UsageData {
         totalTokens: 0,
         costUSD: 0,
         toolCalls: 0,
+        toolCallsDetail: {},
+        interruptions: 0,
+        rateLimitErrors: 0,
       })
     }
     const daily = dailyMap.get(date)!
     daily.sessions++
     daily.messages += s.totalMessages
+    daily.userMessages += s.userMessages
+    daily.assistantMessages += s.assistantMessages
     daily.inputTokens += s.inputTokens
     daily.outputTokens += s.outputTokens
     daily.totalTokens += s.totalTokens
     daily.costUSD += s.costUSD
     daily.toolCalls += s.toolCallsTotal
+    daily.interruptions += s.userInterruptions
+    daily.rateLimitErrors += s.rateLimitErrors
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      daily.toolCallsDetail[tool] = (daily.toolCallsDetail[tool] || 0) + count
+    }
 
     // Tool usage
     for (const [tool, count] of Object.entries(s.toolCalls)) {
@@ -98,7 +110,13 @@ export function getCodexUsageData(): UsageData {
     totalCostUSD: sessions.reduce((a, s) => a + s.costUSD, 0),
     totalDurationMinutes: sessions.reduce((a, s) => a + s.durationMinutes, 0),
     totalToolCalls: sessions.reduce((a, s) => a + s.toolCallsTotal, 0),
+    totalApiErrors: 0,
+    totalRateLimitDays: 0,
+    totalUserInterruptions: 0,
+    totalSystemPromptEdits: 0,
     models,
+    skillUsage: {},
+    permissionModes: {},
   }
 
   return { overview, sessions, projects, daily, toolUsage }
@@ -120,7 +138,13 @@ function emptyUsageData(): UsageData {
       totalCostUSD: 0,
       totalDurationMinutes: 0,
       totalToolCalls: 0,
+      totalApiErrors: 0,
+      totalRateLimitDays: 0,
+      totalUserInterruptions: 0,
+      totalSystemPromptEdits: 0,
       models: {},
+      skillUsage: {},
+    permissionModes: {},
     },
     sessions: [],
     projects: [],

package/lib/queries.ts

@@ -36,6 +36,13 @@ export async function getUsageData(): Promise<UsageData> {
     model: s.model,
     toolCalls: JSON.parse(s.toolCallsJson) as Record<string, number>,
     toolCallsTotal: s.toolCallsTotal,
+    messageTimestamps: JSON.parse(s.messageTimestamps) as string[],
+    skillCalls: JSON.parse(s.skillCallsJson) as Record<string, number>,
+    apiErrors: s.apiErrors,
+    rateLimitErrors: s.rateLimitErrors,
+    userInterruptions: s.userInterruptions,
+    permissionModes: JSON.parse(s.permissionModesJson || '{}') as Record<string, number>,
+    systemPromptEdits: s.systemPromptEdits,
   }))
 
   // Aggregate projects
@@ -74,6 +81,8 @@ export async function getUsageData(): Promise<UsageData> {
         date,
         sessions: 0,
         messages: 0,
+        userMessages: 0,
+        assistantMessages: 0,
         inputTokens: 0,
         outputTokens: 0,
         cacheCreationTokens: 0,
@@ -81,11 +90,16 @@ export async function getUsageData(): Promise<UsageData> {
         totalTokens: 0,
         costUSD: 0,
         toolCalls: 0,
+        toolCallsDetail: {},
+        interruptions: 0,
+        rateLimitErrors: 0,
       })
     }
     const daily = dailyMap.get(date)!
     daily.sessions++
     daily.messages += s.totalMessages
+    daily.userMessages += s.userMessages
+    daily.assistantMessages += s.assistantMessages
     daily.inputTokens += s.inputTokens
     daily.outputTokens += s.outputTokens
     daily.cacheCreationTokens += s.cacheCreationTokens
@@ -93,6 +107,11 @@ export async function getUsageData(): Promise<UsageData> {
     daily.totalTokens += s.totalTokens
     daily.costUSD += s.costUSD
     daily.toolCalls += s.toolCallsTotal
+    daily.interruptions += s.userInterruptions
+    daily.rateLimitErrors += s.rateLimitErrors
+    for (const [tool, count] of Object.entries(s.toolCalls)) {
+      daily.toolCallsDetail[tool] = (daily.toolCallsDetail[tool] || 0) + count
+    }
 
     // Tool usage
     for (const [tool, count] of Object.entries(s.toolCalls)) {
@@ -104,8 +123,16 @@ export async function getUsageData(): Promise<UsageData> {
   const projects = Array.from(projectMap.values()).sort((a, b) => b.totalCost - a.totalCost)
 
   const models: Record<string, number> = {}
+  const skillUsage: Record<string, number> = {}
+  const permissionModes: Record<string, number> = {}
   for (const s of sessions) {
     models[s.model] = (models[s.model] || 0) + 1
+    for (const [skill, count] of Object.entries(s.skillCalls)) {
+      skillUsage[skill] = (skillUsage[skill] || 0) + count
+    }
+    for (const [mode, count] of Object.entries(s.permissionModes)) {
+      permissionModes[mode] = (permissionModes[mode] || 0) + count
+    }
   }
 
   const overview: OverviewStats = {
@@ -122,7 +149,19 @@ export async function getUsageData(): Promise<UsageData> {
     totalCostUSD: sessions.reduce((a, s) => a + s.costUSD, 0),
     totalDurationMinutes: sessions.reduce((a, s) => a + s.durationMinutes, 0),
     totalToolCalls: sessions.reduce((a, s) => a + s.toolCallsTotal, 0),
+    totalApiErrors: sessions.reduce((a, s) => a + s.apiErrors, 0),
+    totalRateLimitDays: (() => {
+      const days = new Set<string>()
+      for (const s of sessions) {
+        if (s.rateLimitErrors > 0) days.add(s.startTime.slice(0, 10))
+      }
+      return days.size
+    })(),
+    totalUserInterruptions: sessions.reduce((a, s) => a + s.userInterruptions, 0),
+    totalSystemPromptEdits: sessions.reduce((a, s) => a + s.systemPromptEdits, 0),
     models,
+    skillUsage,
+    permissionModes,
   }
 
   return { overview, sessions, projects, daily: dailyArr, toolUsage }
@@ -144,7 +183,13 @@ function emptyUsageData(): UsageData {
       totalCostUSD: 0,
       totalDurationMinutes: 0,
       totalToolCalls: 0,
+      totalApiErrors: 0,
+      totalRateLimitDays: 0,
+      totalUserInterruptions: 0,
+      totalSystemPromptEdits: 0,
       models: {},
+      skillUsage: {},
+      permissionModes: {},
     },
     sessions: [],
     projects: [],