agentfit 0.1.0 → 0.1.1

package/lib/report.ts

@@ -0,0 +1,156 @@
+// ─── Report Generation ───────────────────────────────────────────────
+// Composes existing analyzers into a point-in-time snapshot report.
+
+import { getUsageData } from './queries'
+import { generateCoachInsights, type CoachInsight } from './coach'
+import { analyzePersonality } from './personality'
+import { generateCommandInsights, type CommandInsight } from './command-insights'
+import { formatCost, formatDuration } from './format'
+
+// ─── Report Content Schema ───────────────────────────────────────────
+
+export interface ReportContent {
+  atAGlance: {
+    fitnessScore: number
+    scoreLabel: string
+    totalSessions: number
+    totalProjects: number
+    totalCostUSD: number
+    totalDurationMinutes: number
+    totalMessages: number
+    totalToolCalls: number
+    totalApiErrors: number
+    totalUserInterruptions: number
+    dateRange: { from: string; to: string }
+    currentStreak: number
+    longestStreak: number
+  }
+  projectAreas: {
+    name: string
+    sessions: number
+    totalCost: number
+    totalDurationMinutes: number
+    totalMessages: number
+    topTools: [string, number][]
+  }[]
+  interactionStyle: {
+    avgMessagesPerSession: number
+    avgDurationMinutes: number
+    avgCostPerSession: number
+    readEditRatio: number
+    bashRatio: number
+    agentCallsTotal: number
+    peakHour: number
+    mostActiveDay: string
+    mbtiType: string
+    mbtiDescription: string
+  }
+  whatWorks: CoachInsight[]
+  frictionAnalysis: CoachInsight[]
+  suggestions: {
+    coachTips: CoachInsight[]
+    commandTips: CommandInsight[]
+    claudeMdRules: string[]
+  }
+}
+
+// ─── Generation ──────────────────────────────────────────────────────
+
+export async function generateReport(): Promise<{
+  title: string
+  contentJson: ReportContent
+  sessionCount: number
+}> {
+  const data = await getUsageData()
+  const coach = generateCoachInsights(data)
+  const personality = analyzePersonality(data)
+  const cmdInsights = generateCommandInsights()
+
+  const { overview, sessions, projects, toolUsage } = data
+
+  // Date range
+  const sortedSessions = [...sessions].sort((a, b) => a.startTime.localeCompare(b.startTime))
+  const from = sortedSessions[0]?.startTime?.slice(0, 10) || 'N/A'
+  const to = sortedSessions[sortedSessions.length - 1]?.startTime?.slice(0, 10) || 'N/A'
+
+  // Tool ratios
+  const readCalls = (toolUsage['Read'] || 0) + (toolUsage['Grep'] || 0) + (toolUsage['Glob'] || 0)
+  const editCalls = (toolUsage['Edit'] || 0) + (toolUsage['Write'] || 0)
+  const bashCalls = toolUsage['Bash'] || 0
+  const agentCalls = toolUsage['Agent'] || 0
+  const totalTools = overview.totalToolCalls
+
+  // MBTI descriptions
+  const mbtiDescriptions: Record<string, string> = {
+    ISTJ: 'The Inspector — Methodical, detail-oriented, follows established procedures',
+    ISFJ: 'The Protector — Supportive, reliable, focused on preserving working code',
+    INFJ: 'The Counselor — Insightful, sees patterns, anticipates architectural needs',
+    INTJ: 'The Architect — Strategic, independent, designs for long-term quality',
+    ISTP: 'The Craftsman — Practical, efficient, excels at targeted fixes',
+    ISFP: 'The Composer — Adaptable, aesthetic sense, good at UI refinement',
+    INFP: 'The Healer — Idealistic, explores creative solutions, values code clarity',
+    INTP: 'The Thinker — Analytical, explores edge cases, values logical consistency',
+    ESTP: 'The Dynamo — Action-oriented, quick iterations, bias toward execution',
+    ESFP: 'The Performer — Energetic, responsive, generates many alternatives',
+    ENFP: 'The Champion — Enthusiastic explorer, broad tool usage, creative approaches',
+    ENTP: 'The Visionary — Innovative, questions assumptions, proposes novel solutions',
+    ESTJ: 'The Supervisor — Organized, efficient, follows project conventions strictly',
+    ESFJ: 'The Provider — Cooperative, communicative, adapts to user preferences',
+    ENFJ: 'The Teacher — Explains reasoning, mentors through code, proactive guidance',
+    ENTJ: 'The Commander — Decisive, takes charge, designs comprehensive solutions',
+  }
+
+  const content: ReportContent = {
+    atAGlance: {
+      fitnessScore: coach.score,
+      scoreLabel: coach.scoreLabel,
+      totalSessions: overview.totalSessions,
+      totalProjects: overview.totalProjects,
+      totalCostUSD: overview.totalCostUSD,
+      totalDurationMinutes: overview.totalDurationMinutes,
+      totalMessages: overview.totalMessages,
+      totalToolCalls: overview.totalToolCalls,
+      totalApiErrors: overview.totalApiErrors,
+      totalUserInterruptions: overview.totalUserInterruptions,
+      dateRange: { from, to },
+      currentStreak: coach.stats.currentStreak,
+      longestStreak: coach.stats.longestStreak,
+    },
+    projectAreas: projects.slice(0, 10).map(p => ({
+      name: p.name,
+      sessions: p.sessions,
+      totalCost: p.totalCost,
+      totalDurationMinutes: p.totalDurationMinutes,
+      totalMessages: p.totalMessages,
+      topTools: Object.entries(p.toolCalls)
+        .sort((a, b) => b[1] - a[1])
+        .slice(0, 5),
+    })),
+    interactionStyle: {
+      avgMessagesPerSession: coach.stats.avgMessagesPerSession,
+      avgDurationMinutes: coach.stats.avgDurationMinutes,
+      avgCostPerSession: coach.stats.avgCostPerSession,
+      readEditRatio: editCalls > 0 ? readCalls / editCalls : 0,
+      bashRatio: totalTools > 0 ? bashCalls / totalTools : 0,
+      agentCallsTotal: agentCalls,
+      peakHour: coach.stats.peakHour,
+      mostActiveDay: coach.stats.mostActiveDay,
+      mbtiType: personality.mbtiType,
+      mbtiDescription: mbtiDescriptions[personality.mbtiType] || 'Unique profile',
+    },
+    whatWorks: coach.insights.filter(i => i.severity === 'achievement'),
+    frictionAnalysis: coach.insights.filter(i => i.severity === 'warning'),
+    suggestions: {
+      coachTips: coach.insights.filter(i => i.severity === 'tip'),
+      commandTips: cmdInsights,
+      claudeMdRules: coach.insights
+        .filter(i => i.severity === 'warning' && i.recommendation)
+        .map(i => i.recommendation!),
+    },
+  }
+
+  const now = new Date()
+  const title = `Report — ${now.toLocaleDateString('en-US', { month: 'short', day: 'numeric', year: 'numeric' })} ${now.toLocaleTimeString('en-US', { hour: 'numeric', minute: '2-digit' })}`
+
+  return { title, contentJson: content, sessionCount: overview.totalSessions }
+}

package/lib/session-detail.ts

@@ -0,0 +1,382 @@
+// ─── Session Detail Parser ───────────────────────────────────────────
+// Parses a single Claude Code JSONL session file into a workflow DAG
+// and chat log for visualization (inspired by CommuGraph).
+
+import fs from 'fs'
+
+// ─── Types ───────────────────────────────────────────────────────────
+
+export type WorkflowNodeType =
+  | 'user_input'
+  | 'thinking'
+  | 'text_response'
+  | 'tool_call'
+  | 'tool_result'
+  | 'system'
+
+export interface WorkflowNode {
+  id: string
+  stepIndex: number
+  timestamp: string
+  nodeType: WorkflowNodeType
+  label: string
+  content: string
+  contentPreview: string
+  toolName?: string
+  toolInput?: string
+  parentId: string | null
+  durationMs?: number
+  isError?: boolean
+  isSidechain?: boolean
+  agentId?: string
+}
+
+export interface WorkflowEdge {
+  id: string
+  source: string
+  target: string
+  durationMs?: number
+}
+
+export interface ChatMessage {
+  id: string
+  stepIndex: number
+  timestamp: string
+  role: 'user' | 'assistant' | 'system' | 'tool_result'
+  content: string
+  toolName?: string
+  isThinking?: boolean
+  isSidechain?: boolean
+  agentId?: string
+  images?: number
+}
+
+export interface SessionDetail {
+  sessionId: string
+  workflowNodes: WorkflowNode[]
+  workflowEdges: WorkflowEdge[]
+  chatLog: ChatMessage[]
+  stats: {
+    totalMessages: number
+    userTurns: number
+    assistantTurns: number
+    toolCalls: number
+    successCount: number
+    failureCount: number
+    duration: string
+    tokens: number
+  }
+}
+
+// ─── Parser ──────────────────────────────────────────────────────────
+
+interface RawEntry {
+  uuid?: string
+  parentUuid?: string
+  type?: string
+  timestamp?: string
+  isSidechain?: boolean
+  message?: {
+    role?: string
+    content?: unknown[]
+    model?: string
+    usage?: {
+      input_tokens?: number
+      output_tokens?: number
+    }
+  }
+}
+
+export function parseSessionDetail(filePath: string, sessionId: string): SessionDetail {
+  const content = fs.readFileSync(filePath, 'utf-8')
+  const lines = content.trim().split('\n')
+
+  const nodes: WorkflowNode[] = []
+  const edges: WorkflowEdge[] = []
+  const chatLog: ChatMessage[] = []
+
+  let stepIndex = 0
+  let lastNodeId: string | null = null
+  let totalTokens = 0
+  let toolCallCount = 0
+  let successCount = 0
+  let failureCount = 0
+  let userTurns = 0
+  let assistantTurns = 0
+  let firstTimestamp = ''
+  let lastTimestamp = ''
+
+  for (const line of lines) {
+    if (!line.trim()) continue
+    let entry: RawEntry
+    try {
+      entry = JSON.parse(line)
+    } catch {
+      continue
+    }
+
+    const ts = entry.timestamp || ''
+    if (ts && !firstTimestamp) firstTimestamp = ts
+    if (ts) lastTimestamp = ts
+
+    const uuid = entry.uuid || `step-${stepIndex}`
+    const parentUuid = entry.parentUuid || null
+    const isSidechain = entry.isSidechain || false
+
+    if (entry.type === 'user') {
+      stepIndex++
+      userTurns++
+
+      // Extract user text
+      let text = ''
+      let imageCount = 0
+      const msg = entry.message
+      if (msg?.content && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (typeof block === 'object' && block !== null) {
+            const b = block as Record<string, unknown>
+            if (b.type === 'text') text += (b.text as string) || ''
+            else if (b.type === 'tool_result') {
+              const resultContent = b.content
+              if (typeof resultContent === 'string') text += resultContent
+              else if (Array.isArray(resultContent)) {
+                for (const rc of resultContent) {
+                  if (typeof rc === 'object' && rc !== null) {
+                    const r = rc as Record<string, unknown>
+                    if (r.type === 'text') text += (r.text as string) || ''
+                  }
+                }
+              }
+              // This is actually a tool result
+              const isError = b.is_error === true
+              const toolUseId = b.tool_use_id as string | undefined
+
+              if (isError) failureCount++
+              else successCount++
+
+              const resultNode: WorkflowNode = {
+                id: `${uuid}-result`,
+                stepIndex,
+                timestamp: ts,
+                nodeType: 'tool_result',
+                label: isError ? 'Error' : 'Result',
+                content: text.slice(0, 500),
+                contentPreview: text.slice(0, 100),
+                parentId: toolUseId ? `tool-${toolUseId}` : lastNodeId,
+                isError,
+                isSidechain,
+              }
+              nodes.push(resultNode)
+
+              if (resultNode.parentId) {
+                edges.push({
+                  id: `e-${resultNode.parentId}-${resultNode.id}`,
+                  source: resultNode.parentId,
+                  target: resultNode.id,
+                })
+              }
+
+              chatLog.push({
+                id: `${uuid}-result`,
+                stepIndex,
+                timestamp: ts,
+                role: 'tool_result',
+                content: text.slice(0, 300),
+                isSidechain,
+              })
+
+              lastNodeId = resultNode.id
+              text = ''
+              continue
+            } else if (b.type === 'image') {
+              imageCount++
+            }
+          } else if (typeof block === 'string') {
+            text += block
+          }
+        }
+      } else if (typeof msg?.content === 'string') {
+        text = msg.content
+      }
+
+      if (!text && imageCount === 0) continue
+
+      const nodeId = uuid
+      const node: WorkflowNode = {
+        id: nodeId,
+        stepIndex,
+        timestamp: ts,
+        nodeType: 'user_input',
+        label: 'User Input',
+        content: text,
+        contentPreview: text.slice(0, 100) || `[${imageCount} image(s)]`,
+        parentId: lastNodeId,
+        isSidechain,
+      }
+      nodes.push(node)
+
+      if (lastNodeId) {
+        edges.push({ id: `e-${lastNodeId}-${nodeId}`, source: lastNodeId, target: nodeId })
+      }
+
+      chatLog.push({
+        id: nodeId,
+        stepIndex,
+        timestamp: ts,
+        role: 'user',
+        content: text || `[${imageCount} image(s)]`,
+        isSidechain,
+        images: imageCount,
+      })
+
+      lastNodeId = nodeId
+
+    } else if (entry.type === 'assistant' && entry.message) {
+      const msg = entry.message
+      assistantTurns++
+
+      if (msg.usage) {
+        totalTokens += (msg.usage.input_tokens || 0) + (msg.usage.output_tokens || 0)
+      }
+
+      if (!Array.isArray(msg.content)) continue
+
+      for (const block of msg.content) {
+        if (typeof block !== 'object' || block === null) continue
+        const b = block as Record<string, unknown>
+
+        if (b.type === 'thinking') {
+          stepIndex++
+          const text = (b.thinking as string) || ''
+          const nodeId = `${uuid}-thinking-${stepIndex}`
+
+          nodes.push({
+            id: nodeId,
+            stepIndex,
+            timestamp: ts,
+            nodeType: 'thinking',
+            label: 'Thinking',
+            content: text,
+            contentPreview: text.slice(0, 100),
+            parentId: lastNodeId,
+            isSidechain,
+          })
+
+          if (lastNodeId) {
+            edges.push({ id: `e-${lastNodeId}-${nodeId}`, source: lastNodeId, target: nodeId })
+          }
+
+          chatLog.push({
+            id: nodeId,
+            stepIndex,
+            timestamp: ts,
+            role: 'assistant',
+            content: text.slice(0, 300),
+            isThinking: true,
+            isSidechain,
+          })
+
+          lastNodeId = nodeId
+
+        } else if (b.type === 'text') {
+          stepIndex++
+          const text = (b.text as string) || ''
+          if (!text.trim()) continue
+          const nodeId = `${uuid}-text-${stepIndex}`
+
+          nodes.push({
+            id: nodeId,
+            stepIndex,
+            timestamp: ts,
+            nodeType: 'text_response',
+            label: 'Response',
+            content: text,
+            contentPreview: text.slice(0, 100),
+            parentId: lastNodeId,
+            isSidechain,
+          })
+
+          if (lastNodeId) {
+            edges.push({ id: `e-${lastNodeId}-${nodeId}`, source: lastNodeId, target: nodeId })
+          }
+
+          chatLog.push({
+            id: nodeId,
+            stepIndex,
+            timestamp: ts,
+            role: 'assistant',
+            content: text.slice(0, 500),
+            isSidechain,
+          })
+
+          lastNodeId = nodeId
+
+        } else if (b.type === 'tool_use') {
+          stepIndex++
+          toolCallCount++
+          const toolName = (b.name as string) || 'unknown'
+          const toolInput = b.input ? JSON.stringify(b.input).slice(0, 200) : ''
+          const toolUseId = (b.id as string) || `tool-${stepIndex}`
+          const nodeId = `tool-${toolUseId}`
+
+          nodes.push({
+            id: nodeId,
+            stepIndex,
+            timestamp: ts,
+            nodeType: 'tool_call',
+            label: toolName,
+            content: toolInput,
+            contentPreview: toolInput.slice(0, 80),
+            toolName,
+            toolInput,
+            parentId: lastNodeId,
+            isSidechain,
+          })
+
+          if (lastNodeId) {
+            edges.push({ id: `e-${lastNodeId}-${nodeId}`, source: lastNodeId, target: nodeId })
+          }
+
+          chatLog.push({
+            id: nodeId,
+            stepIndex,
+            timestamp: ts,
+            role: 'assistant',
+            content: `${toolName}: ${toolInput.slice(0, 200)}`,
+            toolName,
+            isSidechain,
+          })
+
+          lastNodeId = nodeId
+        }
+      }
+    }
+  }
+
+  // Compute duration
+  let durationStr = '0s'
+  if (firstTimestamp && lastTimestamp) {
+    const ms = new Date(lastTimestamp).getTime() - new Date(firstTimestamp).getTime()
+    const mins = ms / 60000
+    if (mins < 1) durationStr = `${Math.round(ms / 1000)}s`
+    else if (mins < 60) durationStr = `${Math.round(mins)}m`
+    else durationStr = `${Math.floor(mins / 60)}h ${Math.round(mins % 60)}m`
+  }
+
+  return {
+    sessionId,
+    workflowNodes: nodes,
+    workflowEdges: edges,
+    chatLog,
+    stats: {
+      totalMessages: userTurns + assistantTurns,
+      userTurns,
+      assistantTurns,
+      toolCalls: toolCallCount,
+      successCount,
+      failureCount,
+      duration: durationStr,
+      tokens: totalTokens,
+    },
+  }
+}

package/lib/sync.ts

@@ -38,7 +38,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
 }
 
@@ -62,6 +78,12 @@ function parseSessionFile(
   let endTime = ''
   const toolCalls: Record<string, number> = {}
   const images: ImageInfo[] = []
+  const messageTimestamps: string[] = []
+  let apiErrors = 0
+  let rateLimitErrors = 0
+  let userInterruptions = 0
+  const skillCalls: Record<string, number> = {}
+  const permissionModes: Record<string, number> = {}
 
   for (const line of lines) {
     if (!line.trim()) continue
@@ -75,6 +97,7 @@ function parseSessionFile(
     if (entry.timestamp) {
       if (!startTime) startTime = entry.timestamp
       endTime = entry.timestamp
+      messageTimestamps.push(entry.timestamp)
     }
 
     const entryType = entry.type
@@ -82,9 +105,44 @@ function parseSessionFile(
 
     if (entryType === 'user') {
       userMessages++
+      // Track permission mode
+      const pm = (entry as Record<string, unknown>).permissionMode as string | undefined
+      if (pm) {
+        permissionModes[pm] = (permissionModes[pm] || 0) + 1
+      }
+      // Detect user interruptions from tool_result content
+      if (msg && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block && typeof block === 'object' && 'type' in block) {
+            const b = block as Record<string, unknown>
+            if (b.type === 'tool_result') {
+              const c = String(b.content || '')
+              if (c.includes("doesn't want to proceed") || c.includes('was rejected')) {
+                userInterruptions++
+              }
+            }
+          }
+        }
+      }
     } else if (entryType === 'assistant' && msg) {
       assistantMessages++
 
+      // Detect API errors from synthetic messages
+      if (msg.model === '<synthetic>' && Array.isArray(msg.content)) {
+        for (const block of msg.content) {
+          if (block && typeof block === 'object' && 'type' in block) {
+            const b = block as Record<string, unknown>
+            if (b.type === 'text' && String(b.text || '').startsWith('API Error')) {
+              apiErrors++
+              const errText = String(b.text || '').toLowerCase()
+              if (errText.includes('rate limit') || errText.includes('rate_limit') || errText.includes('429') || errText.includes('529') || errText.includes('overloaded')) {
+                rateLimitErrors++
+              }
+            }
+          }
+        }
+      }
+
       if (msg.model && msg.model !== '<synthetic>') {
         model = msg.model
       }
@@ -112,6 +170,13 @@ function parseSessionFile(
           const toolName = b.name as string
           if (toolName) {
             toolCalls[toolName] = (toolCalls[toolName] || 0) + 1
+            // Track individual skill names
+            if (toolName === 'Skill' && b.input && typeof b.input === 'object') {
+              const skillName = (b.input as Record<string, unknown>).skill as string
+              if (skillName) {
+                skillCalls[skillName] = (skillCalls[skillName] || 0) + 1
+              }
+            }
           }
         }
 
@@ -172,6 +237,12 @@ function parseSessionFile(
     model: model || 'unknown',
     toolCalls,
     toolCallsTotal: Object.values(toolCalls).reduce((a, b) => a + b, 0),
+    messageTimestamps,
+    apiErrors,
+    rateLimitErrors,
+    userInterruptions,
+    skillCalls,
+    permissionModes,
     images,
   }
 }
@@ -263,6 +334,12 @@ export async function syncLogs(): Promise<SyncResult> {
             model: parsed.model,
             toolCallsTotal: parsed.toolCallsTotal,
             toolCallsJson: JSON.stringify(parsed.toolCalls),
+            skillCallsJson: JSON.stringify(parsed.skillCalls),
+            messageTimestamps: JSON.stringify(parsed.messageTimestamps),
+            apiErrors: parsed.apiErrors,
+            rateLimitErrors: parsed.rateLimitErrors,
+            userInterruptions: parsed.userInterruptions,
+            permissionModesJson: JSON.stringify(parsed.permissionModes),
           },
         })