@bahulam/code 2.6.0

package/pulse/app/api/sessions/[id]/replay/route.ts

@@ -0,0 +1,20 @@
+import { NextResponse } from 'next/server'
+import { findSessionJSONL } from '@/lib/claude-reader'
+import { parseSessionReplay } from '@/lib/replay-parser'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params
+  const jsonlPath = await findSessionJSONL(id)
+
+  if (!jsonlPath) {
+    return NextResponse.json({ error: 'Session JSONL not found' }, { status: 404 })
+  }
+
+  const replay = await parseSessionReplay(jsonlPath, id)
+  return NextResponse.json(replay)
+}

package/pulse/app/api/sessions/[id]/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from 'next/server'
+import { readSessionMeta, readFacet, getSessions } from '@/lib/claude-reader'
+import { estimateCostFromUsage } from '@/lib/pricing'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET(
+  _req: Request,
+  { params }: { params: Promise<{ id: string }> }
+) {
+  const { id } = await params
+  const [meta, facet] = await Promise.all([readSessionMeta(id), readFacet(id)])
+
+  // readSessionMeta only finds session-meta/*.json files (legacy path).
+  // Fall back to JSONL-derived sessions for machines without that directory.
+  const resolved = meta ?? (await getSessions()).find(s => s.session_id === id) ?? null
+
+  if (!resolved) {
+    return NextResponse.json({ error: 'Session not found' }, { status: 404 })
+  }
+
+  const estimated_cost = estimateCostFromUsage('claude-opus-4-6', {
+    input_tokens: resolved.input_tokens ?? 0,
+    output_tokens: resolved.output_tokens ?? 0,
+    cache_creation_input_tokens: resolved.cache_creation_input_tokens ?? 0,
+    cache_read_input_tokens: resolved.cache_read_input_tokens ?? 0,
+  })
+
+  return NextResponse.json({ session: { ...resolved, facet, estimated_cost } })
+}
+

package/pulse/app/api/sessions/route.ts

@@ -0,0 +1,112 @@
+import path from 'path'
+import { NextResponse } from 'next/server'
+import {
+  getSessions,
+  readAllSessionMeta,
+  readAllFacets,
+  listProjectSlugs,
+  listProjectJSONLFiles,
+  readJSONLLines,
+} from '@/lib/claude-reader'
+import { estimateCostFromUsage } from '@/lib/pricing'
+import type { SessionWithFacet } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyLine = Record<string, any>
+
+async function enrichSessions(sessions: { session_id: string }[]) {
+  // Build a map of sessionId -> { slug, version, gitBranch, has_compaction, has_thinking }
+  const enrichment: Record<string, {
+    slug?: string
+    version?: string
+    git_branch?: string
+    has_compaction?: boolean
+    has_thinking?: boolean
+  }> = {}
+
+  const slugs = await listProjectSlugs()
+  await Promise.all(
+    slugs.map(async (slug) => {
+      const files = await listProjectJSONLFiles(slug)
+      await Promise.all(
+        files.map(async (f) => {
+          const sessionId = path.basename(f, '.jsonl')
+          const data: {
+            slug?: string; version?: string; gitBranch?: string
+            has_compaction?: boolean; has_thinking?: boolean
+          } = {}
+
+          await readJSONLLines(f, (line: AnyLine) => {
+            if (!data.slug && line.slug)         data.slug = line.slug
+            if (!data.version && line.version)   data.version = line.version
+            if (!data.gitBranch && line.gitBranch && line.gitBranch !== 'HEAD') {
+              data.gitBranch = line.gitBranch
+            }
+            if (line.type === 'system' && line.subtype === 'compact_boundary') {
+              data.has_compaction = true
+            }
+            if (line.type === 'assistant' && Array.isArray(line.message?.content)) {
+              if (line.message.content.some((c: AnyLine) => c.type === 'thinking')) {
+                data.has_thinking = true
+              }
+            }
+          })
+
+          enrichment[sessionId] = {
+            slug: data.slug,
+            version: data.version,
+            git_branch: data.gitBranch,
+            has_compaction: data.has_compaction,
+            has_thinking: data.has_thinking,
+          }
+        })
+      )
+    })
+  )
+  return enrichment
+}
+
+export async function GET() {
+  const [sessions, metaSessions, facets] = await Promise.all([
+    getSessions(),
+    readAllSessionMeta(),
+    readAllFacets(),
+  ])
+  const metaMap = new Map(metaSessions.map((s) => [s.session_id, s]))
+  const merged = sessions.map((s) => {
+    const meta = metaMap.get(s.session_id)
+    if (meta) return { ...meta, ...s } as typeof s
+    return s
+  })
+  const enrichment = await enrichSessions(merged)
+
+  const facetMap = new Map(facets.map(f => [f.session_id, f]))
+
+  const result: SessionWithFacet[] = merged.map(s => {
+    const facet = facetMap.get(s.session_id)
+    const enrich = enrichment[s.session_id] ?? {}
+
+    // Estimate cost from session tokens (rough: treat all as opus)
+    const estimated_cost = estimateCostFromUsage('claude-opus-4-6', {
+      input_tokens: s.input_tokens ?? 0,
+      output_tokens: s.output_tokens ?? 0,
+      cache_creation_input_tokens: s.cache_creation_input_tokens ?? 0,
+      cache_read_input_tokens: s.cache_read_input_tokens ?? 0,
+    })
+
+    return {
+      ...s,
+      facet,
+      estimated_cost,
+      slug: enrich.slug,
+      version: enrich.version,
+      git_branch: enrich.git_branch,
+      has_compaction: enrich.has_compaction ?? false,
+      has_thinking: enrich.has_thinking ?? false,
+    }
+  })
+
+  return NextResponse.json({ sessions: result, total: result.length })
+}

package/pulse/app/api/settings/route.ts

@@ -0,0 +1,14 @@
+import { NextResponse } from 'next/server'
+import { readSettings, getClaudeStorageBytes, readSkills, readInstalledPlugins } from '@/lib/claude-reader'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const [settings, storageBytes, skills, plugins] = await Promise.all([
+    readSettings(),
+    getClaudeStorageBytes(),
+    readSkills(),
+    readInstalledPlugins(),
+  ])
+  return NextResponse.json({ settings, storageBytes, skills, plugins })
+}

package/pulse/app/api/stats/route.ts

@@ -0,0 +1,143 @@
+import { NextResponse } from 'next/server'
+import { readStatsCache, getSessions, getClaudeStorageBytes } from '@/lib/claude-reader'
+import { estimateTotalCostFromModel, getPricing } from '@/lib/pricing'
+import type { DailyActivity, SessionMeta } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+/** Compute daily activity from session JSONL — fresher than stats-cache */
+function computeDailyActivityFromSessions(sessions: SessionMeta[]): DailyActivity[] {
+  const byDate = new Map<string, { messages: number; sessions: number; tools: number }>()
+  for (const s of sessions) {
+    const date = s.start_time.slice(0, 10)
+    if (!/^\d{4}-\d{2}-\d{2}$/.test(date)) continue
+    const existing = byDate.get(date) ?? { messages: 0, sessions: 0, tools: 0 }
+    existing.messages += (s.user_message_count ?? 0) + (s.assistant_message_count ?? 0)
+    existing.sessions += 1
+    existing.tools += Object.values(s.tool_counts ?? {}).reduce((a, b) => a + b, 0)
+    byDate.set(date, existing)
+  }
+  return Array.from(byDate.entries())
+    .map(([date, { messages, sessions: count, tools }]) => ({
+      date,
+      messageCount: messages,
+      sessionCount: count,
+      toolCallCount: tools,
+    }))
+    .sort((a, b) => a.date.localeCompare(b.date))
+}
+
+/** Merge stats dailyActivity with session-derived data; session data overrides for same dates */
+function mergeDailyActivity(
+  fromStats: DailyActivity[],
+  fromSessions: DailyActivity[]
+): DailyActivity[] {
+  const map = new Map<string, DailyActivity>()
+  for (const d of fromStats) map.set(d.date, d)
+  for (const d of fromSessions) map.set(d.date, d)
+  return Array.from(map.values()).sort((a, b) => a.date.localeCompare(b.date))
+}
+
+export async function GET() {
+  const [stats, sessions, storageBytes] = await Promise.all([
+    readStatsCache(),
+    getSessions(),
+    getClaudeStorageBytes(),
+  ])
+
+  const dailyFromSessions = computeDailyActivityFromSessions(sessions)
+  const dailyActivity = stats
+    ? mergeDailyActivity(stats.dailyActivity ?? [], dailyFromSessions)
+    : dailyFromSessions
+
+  const modelUsage = stats?.modelUsage ?? {}
+
+  // Compute estimated total cost from modelUsage
+  let totalCost = 0
+  let totalCacheSavings = 0
+  for (const [model, usage] of Object.entries(modelUsage)) {
+    const cost = estimateTotalCostFromModel(model, usage)
+    totalCost += cost
+    const p = getPricing(model)
+    totalCacheSavings += (usage.cacheReadInputTokens ?? 0) * (p.input - p.cacheRead)
+  }
+
+  // Compute total tokens
+  let totalInputTokens = 0
+  let totalOutputTokens = 0
+  let totalCacheReadTokens = 0
+  let totalCacheWriteTokens = 0
+  for (const usage of Object.values(modelUsage)) {
+    totalInputTokens += usage.inputTokens ?? 0
+    totalOutputTokens += usage.outputTokens ?? 0
+    totalCacheReadTokens += usage.cacheReadInputTokens ?? 0
+    totalCacheWriteTokens += usage.cacheCreationInputTokens ?? 0
+  }
+  const totalTokens = totalInputTokens + totalOutputTokens + totalCacheReadTokens + totalCacheWriteTokens
+
+  // Aggregate tool calls total
+  let totalToolCalls = 0
+  for (const s of sessions) {
+    for (const count of Object.values(s.tool_counts ?? {})) {
+      totalToolCalls += count
+    }
+  }
+
+  // Active days (days with at least 1 session)
+  const activeDays = dailyActivity.filter(d => d.sessionCount > 0).length
+
+  // Average session length
+  const avgSessionMinutes =
+    sessions.length > 0
+      ? sessions.reduce((sum, s) => sum + (s.duration_minutes ?? 0), 0) / sessions.length
+      : 0
+
+  // Sessions this month & week
+  const now = new Date()
+  const monthStart = new Date(now.getFullYear(), now.getMonth(), 1)
+  const weekStart = new Date(now)
+  weekStart.setDate(now.getDate() - 7)
+
+  const sessionsThisMonth = sessions.filter(
+    s => new Date(s.start_time) >= monthStart
+  ).length
+  const sessionsThisWeek = sessions.filter(
+    s => new Date(s.start_time) >= weekStart
+  ).length
+
+  const statsOut = stats
+    ? { ...stats, dailyActivity }
+    : {
+        version: 0,
+        lastComputedDate: '',
+        dailyActivity,
+        tokensByDate: [],
+        modelUsage: {},
+        totalSessions: sessions.length,
+        totalMessages: sessions.reduce((s, m) => s + (m.user_message_count ?? 0) + (m.assistant_message_count ?? 0), 0),
+        longestSession: { sessionId: '', duration: 0, messageCount: 0, timestamp: '' },
+        firstSessionDate: sessions[sessions.length - 1]?.start_time ?? '',
+        hourCounts: {},
+        totalSpeculationTimeSavedMs: 0,
+      }
+
+  return NextResponse.json({
+    stats: statsOut,
+    computed: {
+      totalCost,
+      totalCacheSavings,
+      totalTokens,
+      totalInputTokens,
+      totalOutputTokens,
+      totalCacheReadTokens,
+      totalCacheWriteTokens,
+      totalToolCalls,
+      activeDays,
+      avgSessionMinutes,
+      sessionsThisMonth,
+      sessionsThisWeek,
+      storageBytes,
+      sessionCount: sessions.length,
+    },
+  })
+}

package/pulse/app/api/todos/route.ts

@@ -0,0 +1,9 @@
+import { NextResponse } from 'next/server'
+import { readTodos } from '@/lib/claude-reader'
+
+export const dynamic = 'force-dynamic'
+
+export async function GET() {
+  const todos = await readTodos()
+  return NextResponse.json({ todos })
+}

package/pulse/app/api/tools/route.ts

@@ -0,0 +1,160 @@
+import path from 'path'
+import { NextResponse } from 'next/server'
+import { getSessions, listProjectSlugs, listProjectJSONLFiles, readJSONLLines } from '@/lib/claude-reader'
+import { categorizeTool, isMcpTool, parseMcpTool } from '@/lib/tool-categories'
+import type { ToolsAnalytics, ToolSummary, McpServerSummary, VersionRecord } from '@/types/claude'
+
+export const dynamic = 'force-dynamic'
+
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+type AnyLine = Record<string, any>
+
+export async function GET() {
+  const sessions = await getSessions()
+  const totalSessions = sessions.length
+
+  // ── Aggregate tool counts across all sessions ──────────────────────────────
+  const toolTotals = new Map<string, number>()
+  const toolSessionCount = new Map<string, Set<string>>()
+  const mcpServerCalls = new Map<string, Map<string, number>>()
+  const mcpServerSessions = new Map<string, Set<string>>()
+  const errorCategories: Record<string, number> = {}
+  let totalErrors = 0
+
+  for (const s of sessions) {
+    const sid = s.session_id
+    for (const [tool, count] of Object.entries(s.tool_counts ?? {})) {
+      toolTotals.set(tool, (toolTotals.get(tool) ?? 0) + count)
+      if (!toolSessionCount.has(tool)) toolSessionCount.set(tool, new Set())
+      toolSessionCount.get(tool)!.add(sid)
+
+      if (isMcpTool(tool)) {
+        const parsed = parseMcpTool(tool)
+        if (parsed) {
+          if (!mcpServerCalls.has(parsed.server)) mcpServerCalls.set(parsed.server, new Map())
+          if (!mcpServerSessions.has(parsed.server)) mcpServerSessions.set(parsed.server, new Set())
+          const srv = mcpServerCalls.get(parsed.server)!
+          srv.set(parsed.tool, (srv.get(parsed.tool) ?? 0) + count)
+          mcpServerSessions.get(parsed.server)!.add(sid)
+        }
+      }
+    }
+
+    // Error categories
+    for (const [cat, count] of Object.entries(s.tool_error_categories ?? {})) {
+      errorCategories[cat] = (errorCategories[cat] ?? 0) + count
+      totalErrors += count
+    }
+  }
+
+  // ── Build ToolSummary list ─────────────────────────────────────────────────
+  const tools: ToolSummary[] = [...toolTotals.entries()]
+    .map(([name, total_calls]) => ({
+      name,
+      category: categorizeTool(name),
+      total_calls,
+      session_count: toolSessionCount.get(name)?.size ?? 0,
+      error_count: 0,
+    }))
+    .sort((a, b) => b.total_calls - a.total_calls)
+
+  const totalToolCalls = tools.reduce((s, t) => s + t.total_calls, 0)
+
+  // ── MCP server summaries ───────────────────────────────────────────────────
+  const mcp_servers: McpServerSummary[] = [...mcpServerCalls.entries()]
+    .map(([server_name, toolMap]) => {
+      const toolArr = [...toolMap.entries()]
+        .map(([name, calls]) => ({ name, calls }))
+        .sort((a, b) => b.calls - a.calls)
+      const total_calls = toolArr.reduce((s, t) => s + t.calls, 0)
+      return {
+        server_name,
+        tools: toolArr,
+        total_calls,
+        session_count: mcpServerSessions.get(server_name)?.size ?? 0,
+      }
+    })
+    .sort((a, b) => b.total_calls - a.total_calls)
+
+  // ── Feature adoption ──────────────────────────────────────────────────────
+  const featureSessions = {
+    task_agents: sessions.filter(s => s.uses_task_agent || (s.tool_counts?.Task ?? 0) > 0).length,
+    mcp: sessions.filter(s => s.uses_mcp || Object.keys(s.tool_counts ?? {}).some(isMcpTool)).length,
+    web_search: sessions.filter(s => s.uses_web_search || (s.tool_counts?.WebSearch ?? 0) > 0).length,
+    web_fetch: sessions.filter(s => s.uses_web_fetch || (s.tool_counts?.WebFetch ?? 0) > 0).length,
+    plan_mode: sessions.filter(s => (s.tool_counts?.EnterPlanMode ?? 0) > 0).length,
+    git_commits: sessions.filter(s => (s.git_commits ?? 0) > 0).length,
+  }
+
+  const feature_adoption: Record<string, { sessions: number; pct: number }> = {}
+  for (const [key, count] of Object.entries(featureSessions)) {
+    feature_adoption[key] = { sessions: count, pct: totalSessions > 0 ? count / totalSessions : 0 }
+  }
+
+  // ── Version + branch info from JSONL ─────────────────────────────────────
+  const versionData = new Map<string, { sessions: Set<string>; dates: string[] }>()
+  const branchTurns = new Map<string, number>()
+
+  const slugs = await listProjectSlugs()
+  await Promise.all(
+    slugs.map(async (slug) => {
+      const files = await listProjectJSONLFiles(slug)
+      await Promise.all(
+        files.map(async (f) => {
+          const sessionId = path.basename(f, '.jsonl')
+          let fileVersion: string | undefined
+          let fileDate: string | undefined
+
+          await readJSONLLines(f, (line: AnyLine) => {
+            if (!fileVersion && line.version) {
+              fileVersion = line.version
+              fileDate = line.timestamp
+            }
+            if (line.gitBranch && line.gitBranch !== 'HEAD') {
+              branchTurns.set(line.gitBranch, (branchTurns.get(line.gitBranch) ?? 0) + 1)
+            }
+          })
+
+          if (fileVersion) {
+            if (!versionData.has(fileVersion)) {
+              versionData.set(fileVersion, { sessions: new Set(), dates: [] })
+            }
+            const vd = versionData.get(fileVersion)!
+            vd.sessions.add(sessionId)
+            if (fileDate) vd.dates.push(fileDate)
+          }
+        })
+      )
+    })
+  )
+
+  const versions: VersionRecord[] = [...versionData.entries()]
+    .map(([version, data]) => {
+      const sortedDates = data.dates.sort()
+      return {
+        version,
+        session_count: data.sessions.size,
+        first_seen: sortedDates[0] ?? '',
+        last_seen: sortedDates[sortedDates.length - 1] ?? '',
+      }
+    })
+    .sort((a, b) => b.last_seen.localeCompare(a.last_seen))
+
+  const branches = [...branchTurns.entries()]
+    .map(([branch, turns]) => ({ branch, turns }))
+    .sort((a, b) => b.turns - a.turns)
+    .slice(0, 15)
+
+  const result: ToolsAnalytics = {
+    tools,
+    mcp_servers,
+    feature_adoption,
+    versions,
+    branches,
+    error_categories: errorCategories,
+    total_tool_calls: totalToolCalls,
+    total_errors: totalErrors,
+  }
+
+  return NextResponse.json(result)
+}