@bahulam/code 0.1.6 → 0.1.8

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

@@ -1,20 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,112 +0,0 @@
-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

@@ -1,14 +0,0 @@
-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

@@ -1,143 +0,0 @@
-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

@@ -1,9 +0,0 @@
-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

@@ -1,160 +0,0 @@
-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)
-}