agentfit 0.1.0

package/lib/commands.ts

@@ -0,0 +1,239 @@
+// ─── Slash Command Usage Analysis ────────────────────────────────────
+// Parses ~/.claude/history.jsonl to extract slash command usage patterns
+// and compares against the full set of built-in Claude Code commands.
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+
+// ─── Types ───────────────────────────────────────────────────────────
+
+export interface CommandInfo {
+  command: string
+  description: string
+  category: string
+  aliases?: string[]
+}
+
+export interface CommandUsage {
+  command: string
+  description: string
+  category: string
+  count: number
+  used: boolean
+  aliases?: string[]
+}
+
+export interface CommandAnalysis {
+  totalCommands: number
+  usedCommands: number
+  unusedCommands: number
+  usagePercentage: number
+  totalInvocations: number
+  commands: CommandUsage[]
+  categories: Record<string, { total: number; used: number; invocations: number }>
+  customCommands: { command: string; count: number }[]
+}
+
+// ─── Built-in Commands Registry ──────────────────────────────────────
+
+// Source: https://code.claude.com/docs/en/commands (official documentation)
+const BUILTIN_COMMANDS: CommandInfo[] = [
+  // Core — conversation lifecycle
+  { command: '/help', description: 'Show help and available commands', category: 'Core' },
+  { command: '/clear', description: 'Clear conversation history and free up context', category: 'Core', aliases: ['/reset', '/new'] },
+  { command: '/compact', description: 'Compact conversation with optional focus instructions', category: 'Core' },
+  { command: '/rewind', description: 'Rewind conversation and/or code to a previous point', category: 'Core', aliases: ['/checkpoint'] },
+  { command: '/rename', description: 'Rename the current session', category: 'Core' },
+  { command: '/exit', description: 'Exit the CLI', category: 'Core', aliases: ['/quit'] },
+
+  // Session & History
+  { command: '/branch', description: 'Create a branch of the current conversation at this point', category: 'Session', aliases: ['/fork'] },
+  { command: '/resume', description: 'Resume a conversation by ID or name, or open session picker', category: 'Session', aliases: ['/continue'] },
+  { command: '/export', description: 'Export the current conversation as plain text', category: 'Session' },
+
+  // Configuration & Preferences
+  { command: '/config', description: 'Open Settings interface for theme, model, output style, and preferences', category: 'Configuration', aliases: ['/settings'] },
+  { command: '/status', description: 'Show version, model, account, and connectivity info', category: 'Configuration' },
+  { command: '/theme', description: 'Change color theme (light, dark, colorblind-accessible, ANSI)', category: 'Configuration' },
+  { command: '/color', description: 'Set prompt bar color for the current session', category: 'Configuration' },
+  { command: '/model', description: 'Select or change the AI model', category: 'Configuration' },
+  { command: '/effort', description: 'Set model effort level (low/medium/high/max/auto)', category: 'Configuration' },
+  { command: '/fast', description: 'Toggle fast mode on or off', category: 'Configuration' },
+  { command: '/vim', description: 'Toggle between Vim and Normal editing modes', category: 'Configuration' },
+  { command: '/voice', description: 'Toggle push-to-talk voice dictation', category: 'Configuration' },
+  { command: '/statusline', description: 'Configure Claude Code status line display', category: 'Configuration' },
+  { command: '/terminal-setup', description: 'Configure terminal keybindings (Shift+Enter, etc.)', category: 'Configuration' },
+
+  // Account & Billing
+  { command: '/login', description: 'Sign in to your Anthropic account', category: 'Account' },
+  { command: '/logout', description: 'Sign out from your Anthropic account', category: 'Account' },
+  { command: '/usage', description: 'Show plan usage limits and rate limit status', category: 'Account' },
+  { command: '/cost', description: 'Show token usage statistics for current session', category: 'Account' },
+  { command: '/upgrade', description: 'Open upgrade page to switch to a higher plan tier', category: 'Account' },
+  { command: '/passes', description: 'Share a free week of Claude Code with friends', category: 'Account' },
+  { command: '/privacy-settings', description: 'View and update privacy settings (Pro/Max only)', category: 'Account' },
+  { command: '/extra-usage', description: 'Configure extra usage when rate limits are hit', category: 'Account' },
+
+  // Development Tools
+  { command: '/init', description: 'Initialize project with a CLAUDE.md guide', category: 'Dev Tools' },
+  { command: '/doctor', description: 'Diagnose and verify your Claude Code installation', category: 'Dev Tools' },
+  { command: '/diff', description: 'Interactive diff viewer for uncommitted changes and per-turn diffs', category: 'Dev Tools' },
+  { command: '/context', description: 'Visualize current context usage as a colored grid', category: 'Dev Tools' },
+  { command: '/copy', description: 'Copy last assistant response to clipboard (interactive picker for code blocks)', category: 'Dev Tools' },
+  { command: '/plan', description: 'Enter plan mode directly from the prompt', category: 'Dev Tools' },
+  { command: '/btw', description: 'Ask a quick side question without adding to conversation', category: 'Dev Tools' },
+  { command: '/sandbox', description: 'Toggle sandbox mode on supported platforms', category: 'Dev Tools' },
+
+  // Code Review & Security
+  { command: '/security-review', description: 'Analyze pending changes for security vulnerabilities', category: 'Code Review' },
+  { command: '/review', description: 'Deprecated — install code-review plugin instead', category: 'Code Review' },
+  { command: '/pr-comments', description: 'Fetch and display comments from a GitHub pull request', category: 'Code Review' },
+
+  // Skills & Extensions
+  { command: '/skills', description: 'List available skills', category: 'Extensions' },
+  { command: '/agents', description: 'Manage agent configurations', category: 'Extensions' },
+  { command: '/plugin', description: 'Manage Claude Code plugins', category: 'Extensions' },
+  { command: '/reload-plugins', description: 'Reload all active plugins to apply pending changes', category: 'Extensions' },
+
+  // Memory, Permissions & Config
+  { command: '/memory', description: 'Edit CLAUDE.md memory files, enable/disable auto-memory', category: 'Memory' },
+  { command: '/add-dir', description: 'Add a new working directory to the current session', category: 'Memory' },
+  { command: '/keybindings', description: 'Open or create your keybindings configuration file', category: 'Memory' },
+  { command: '/permissions', description: 'View or update tool permissions', category: 'Memory', aliases: ['/allowed-tools'] },
+  { command: '/hooks', description: 'View hook configurations for tool events', category: 'Memory' },
+
+  // Integrations
+  { command: '/mcp', description: 'Manage MCP server connections and OAuth authentication', category: 'Integrations' },
+  { command: '/ide', description: 'Manage IDE integrations and show status', category: 'Integrations' },
+  { command: '/install-slack-app', description: 'Install the Claude Slack app via OAuth flow', category: 'Integrations' },
+  { command: '/install-github-app', description: 'Set up Claude GitHub Actions app for a repository', category: 'Integrations' },
+  { command: '/chrome', description: 'Configure Claude in Chrome settings', category: 'Integrations' },
+  { command: '/remote-control', description: 'Make this session available for remote control from claude.ai', category: 'Integrations', aliases: ['/rc'] },
+
+  // Utilities & Info
+  { command: '/feedback', description: 'Submit feedback about Claude Code', category: 'Utilities', aliases: ['/bug'] },
+  { command: '/tasks', description: 'List and manage background tasks', category: 'Utilities' },
+  { command: '/stats', description: 'Visualize daily usage, session history, streaks, and model preferences', category: 'Utilities' },
+  { command: '/insights', description: 'Generate a report analyzing your Claude Code sessions', category: 'Utilities' },
+  { command: '/release-notes', description: 'View the full changelog', category: 'Utilities' },
+  { command: '/mobile', description: 'Show QR code to download the Claude mobile app', category: 'Utilities', aliases: ['/ios', '/android'] },
+  { command: '/desktop', description: 'Continue the current session in Claude Code Desktop app', category: 'Utilities', aliases: ['/app'] },
+  { command: '/stickers', description: 'Order Claude Code stickers', category: 'Utilities' },
+
+  // Cloud & Remote
+  { command: '/schedule', description: 'Create, update, list, or run Cloud scheduled tasks', category: 'Cloud' },
+  { command: '/remote-env', description: 'Configure default remote environment for web sessions', category: 'Cloud' },
+]
+
+// ─── History Parsing ─────────────────────────────────────────────────
+
+interface HistoryEntry {
+  display: string
+  timestamp: number
+  project?: string
+  sessionId?: string
+}
+
+function parseHistory(): Map<string, number> {
+  const historyPath = path.join(os.homedir(), '.claude', 'history.jsonl')
+  const counts = new Map<string, number>()
+
+  if (!fs.existsSync(historyPath)) return counts
+
+  const content = fs.readFileSync(historyPath, 'utf-8')
+  const lines = content.trim().split('\n')
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+    try {
+      const entry: HistoryEntry = JSON.parse(line)
+      const text = entry.display?.trim() || ''
+      const match = text.match(/^\/([a-zA-Z_-]+)/)
+      if (match) {
+        const cmd = '/' + match[1]
+        counts.set(cmd, (counts.get(cmd) || 0) + 1)
+      }
+    } catch {
+      continue
+    }
+  }
+
+  return counts
+}
+
+// ─── Main Analysis ───────────────────────────────────────────────────
+
+export function analyzeCommands(): CommandAnalysis {
+  const usageCounts = parseHistory()
+
+  // Build alias-to-primary map
+  const aliasMap = new Map<string, string>()
+  for (const cmd of BUILTIN_COMMANDS) {
+    if (cmd.aliases) {
+      for (const alias of cmd.aliases) {
+        aliasMap.set(alias, cmd.command)
+      }
+    }
+  }
+
+  // Merge alias counts into primary commands
+  const mergedCounts = new Map<string, number>()
+  for (const [cmd, count] of usageCounts) {
+    const primary = aliasMap.get(cmd) || cmd
+    mergedCounts.set(primary, (mergedCounts.get(primary) || 0) + count)
+  }
+
+  // Build command usage list
+  const builtinSet = new Set(BUILTIN_COMMANDS.map(c => c.command))
+  const commands: CommandUsage[] = BUILTIN_COMMANDS.map(cmd => ({
+    command: cmd.command,
+    description: cmd.description,
+    category: cmd.category,
+    count: mergedCounts.get(cmd.command) || 0,
+    used: (mergedCounts.get(cmd.command) || 0) > 0,
+    aliases: cmd.aliases,
+  }))
+
+  // Sort: used commands first (by count desc), then unused (alphabetical)
+  commands.sort((a, b) => {
+    if (a.used && !b.used) return -1
+    if (!a.used && b.used) return 1
+    if (a.used && b.used) return b.count - a.count
+    return a.command.localeCompare(b.command)
+  })
+
+  // Identify custom (non-built-in) commands
+  const customCommands: { command: string; count: number }[] = []
+  for (const [cmd, count] of mergedCounts) {
+    if (!builtinSet.has(cmd) && !aliasMap.has(cmd)) {
+      customCommands.push({ command: cmd, count })
+    }
+  }
+  customCommands.sort((a, b) => b.count - a.count)
+
+  // Category stats
+  const categories: Record<string, { total: number; used: number; invocations: number }> = {}
+  for (const cmd of commands) {
+    if (!categories[cmd.category]) {
+      categories[cmd.category] = { total: 0, used: 0, invocations: 0 }
+    }
+    categories[cmd.category].total++
+    if (cmd.used) categories[cmd.category].used++
+    categories[cmd.category].invocations += cmd.count
+  }
+
+  const usedCommands = commands.filter(c => c.used).length
+  const totalInvocations = commands.reduce((sum, c) => sum + c.count, 0)
+
+  return {
+    totalCommands: BUILTIN_COMMANDS.length,
+    usedCommands,
+    unusedCommands: BUILTIN_COMMANDS.length - usedCommands,
+    usagePercentage: Math.round((usedCommands / BUILTIN_COMMANDS.length) * 100),
+    totalInvocations,
+    commands,
+    categories,
+    customCommands,
+  }
+}

package/lib/db.ts

@@ -0,0 +1,15 @@
+import { PrismaClient } from '@/generated/prisma/client'
+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}` })
+  return new PrismaClient({ adapter })
+}
+
+const globalForPrisma = globalThis as unknown as { prisma: PrismaClient }
+
+export const prisma = globalForPrisma.prisma || createPrisma()
+
+if (process.env.NODE_ENV !== 'production') globalForPrisma.prisma = prisma

package/lib/format.ts

@@ -0,0 +1,26 @@
+export function formatCost(usd: number): string {
+  if (usd < 0.01) return `$${usd.toFixed(4)}`
+  if (usd < 1) return `$${usd.toFixed(3)}`
+  return `$${usd.toFixed(2)}`
+}
+
+export function formatTokens(n: number): string {
+  if (n >= 1_000_000_000) return `${(n / 1_000_000_000).toFixed(1)}B`
+  if (n >= 1_000_000) return `${(n / 1_000_000).toFixed(1)}M`
+  if (n >= 1_000) return `${(n / 1_000).toFixed(1)}K`
+  return n.toString()
+}
+
+export function formatDuration(minutes: number): string {
+  if (minutes < 60) return `${Math.round(minutes)}m`
+  const hours = Math.floor(minutes / 60)
+  const mins = Math.round(minutes % 60)
+  if (hours < 24) return `${hours}h ${mins}m`
+  const days = Math.floor(hours / 24)
+  const remainingHours = hours % 24
+  return `${days}d ${remainingHours}h`
+}
+
+export function formatNumber(n: number): string {
+  return n.toLocaleString()
+}

package/lib/parse-codex.ts

@@ -0,0 +1,201 @@
+// ─── Codex CLI Log Parser ────────────────────────────────────────────
+// Parses OpenAI Codex session logs from ~/.codex/sessions/
+// Rollout format: ~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import type { SessionSummary } from './parse-logs'
+
+const CODEX_HOME = process.env.CODEX_HOME || path.join(os.homedir(), '.codex')
+const SESSIONS_DIR = path.join(CODEX_HOME, 'sessions')
+
+// ─── Codex Log Entry Types ──────────────────────────────────────────
+
+interface CodexEntry {
+  timestamp: string
+  type: 'session_meta' | 'event_msg' | 'response_item' | 'turn_context'
+  payload: Record<string, unknown>
+}
+
+// ─── Session Parsing ─────────────────────────────────────────────────
+
+function getProjectName(cwd: string): string {
+  const parts = cwd.split('/')
+  return parts[parts.length - 1] || parts[parts.length - 2] || cwd
+}
+
+export function parseCodexSession(filePath: string): SessionSummary | null {
+  try {
+    const content = fs.readFileSync(filePath, 'utf-8')
+    const lines = content.trim().split('\n')
+
+    let sessionId = ''
+    let project = ''
+    let projectPath = ''
+    let model = 'unknown'
+    let startTime = ''
+    let endTime = ''
+    let userMessages = 0
+    let assistantMessages = 0
+    const toolCalls: Record<string, number> = {}
+
+    // Codex doesn't expose per-message token counts in rollout files,
+    // so we estimate from message counts. Codex uses GPT-5 models which
+    // don't break down cache tokens the same way.
+    let inputTokens = 0
+    let outputTokens = 0
+
+    for (const line of lines) {
+      if (!line.trim()) continue
+      let entry: CodexEntry
+      try {
+        entry = JSON.parse(line)
+      } catch {
+        continue
+      }
+
+      // Track timestamps
+      if (entry.timestamp) {
+        if (!startTime) startTime = entry.timestamp
+        endTime = entry.timestamp
+      }
+
+      const payload = entry.payload || {}
+
+      switch (entry.type) {
+        case 'session_meta':
+          sessionId = (payload.id as string) || ''
+          projectPath = (payload.cwd as string) || ''
+          project = getProjectName(projectPath)
+          break
+
+        case 'turn_context':
+          model = (payload.model as string) || model
+          break
+
+        case 'response_item': {
+          const role = payload.role as string | undefined
+          const ptype = payload.type as string
+
+          if (role === 'user') {
+            userMessages++
+            // Estimate input tokens from user message content
+            const content = payload.content as Array<{ text?: string }> | undefined
+            if (content) {
+              for (const block of content) {
+                if (block.text) {
+                  inputTokens += Math.round(block.text.length / 4) // rough estimate
+                }
+              }
+            }
+          } else if (role === 'assistant') {
+            assistantMessages++
+            // Estimate output tokens from assistant message content
+            const content = payload.content as Array<{ text?: string }> | undefined
+            if (content) {
+              for (const block of content) {
+                if (block.text) {
+                  outputTokens += Math.round(block.text.length / 4)
+                }
+              }
+            }
+          }
+
+          if (ptype === 'function_call') {
+            const toolName = (payload.name as string) || 'unknown'
+            toolCalls[toolName] = (toolCalls[toolName] || 0) + 1
+          }
+          break
+        }
+
+        case 'event_msg': {
+          const eventType = payload.type as string
+          if (eventType === 'user_message') {
+            userMessages++
+            const text = (payload as Record<string, unknown>).text as string | undefined
+            if (text) {
+              inputTokens += Math.round(text.length / 4)
+            }
+          }
+          break
+        }
+      }
+    }
+
+    if (userMessages === 0 && assistantMessages === 0) return null
+
+    // Use filename-based session ID if not found in meta
+    if (!sessionId) {
+      const basename = path.basename(filePath, '.jsonl')
+      const match = basename.match(/rollout-[\dT-]+-(.+)/)
+      sessionId = match ? match[1] : basename
+    }
+
+    const durationMinutes =
+      startTime && endTime
+        ? (new Date(endTime).getTime() - new Date(startTime).getTime()) / 60000
+        : 0
+
+    const totalTokens = inputTokens + outputTokens
+
+    return {
+      sessionId: `codex-${sessionId}`,
+      project,
+      projectPath,
+      startTime,
+      endTime,
+      durationMinutes: Math.max(0, durationMinutes),
+      userMessages,
+      assistantMessages,
+      totalMessages: userMessages + assistantMessages,
+      inputTokens,
+      outputTokens,
+      cacheCreationTokens: 0,
+      cacheReadTokens: 0,
+      totalTokens,
+      costUSD: 0, // Codex doesn't expose per-session costs in logs
+      model: model || 'gpt-5',
+      toolCalls,
+      toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
+    }
+  } catch {
+    return null
+  }
+}
+
+// ─── Discover and Parse All Sessions ─────────────────────────────────
+
+export function parseAllCodexSessions(): SessionSummary[] {
+  if (!fs.existsSync(SESSIONS_DIR)) return []
+
+  const sessions: SessionSummary[] = []
+  const files = findJsonlFiles(SESSIONS_DIR)
+
+  for (const file of files) {
+    const session = parseCodexSession(file)
+    if (session) sessions.push(session)
+  }
+
+  return sessions.sort((a, b) => (b.startTime || '').localeCompare(a.startTime || ''))
+}
+
+function findJsonlFiles(dir: string): string[] {
+  const results: string[] = []
+
+  try {
+    const entries = fs.readdirSync(dir, { withFileTypes: true })
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name)
+      if (entry.isDirectory()) {
+        results.push(...findJsonlFiles(fullPath))
+      } else if (entry.name.endsWith('.jsonl') && entry.name.startsWith('rollout-')) {
+        results.push(fullPath)
+      }
+    }
+  } catch {
+    // Permission errors, etc.
+  }
+
+  return results
+}