@bahulam/code 0.1.5 → 0.1.7

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

@@ -1,88 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readStatsCache, getSessions } from '@/lib/claude-reader'
-import { estimateTotalCostFromModel, cacheEfficiency, getPricing, PRICING } from '@/lib/pricing'
-import { projectDisplayName } from '@/lib/decode'
-import type { CostAnalytics, ModelCostBreakdown, DailyCost, ProjectCost } from '@/types/claude'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET() {
-  const [stats, sessions] = await Promise.all([readStatsCache(), getSessions()])
-
-  if (!stats) {
-    return NextResponse.json({ error: 'stats-cache.json not found' }, { status: 404 })
-  }
-
-  // ── Per-model breakdown ────────────────────────────────────────────────────
-  let totalCost = 0
-  let totalSavings = 0
-  const models: ModelCostBreakdown[] = Object.entries(stats.modelUsage ?? {}).map(([model, usage]) => {
-    const cost = estimateTotalCostFromModel(model, usage)
-    const eff = cacheEfficiency(model, usage)
-    totalCost += cost
-    totalSavings += eff.savedUSD
-    return {
-      model,
-      input_tokens: usage.inputTokens ?? 0,
-      output_tokens: usage.outputTokens ?? 0,
-      cache_write_tokens: usage.cacheCreationInputTokens ?? 0,
-      cache_read_tokens: usage.cacheReadInputTokens ?? 0,
-      estimated_cost: cost,
-      cache_savings: eff.savedUSD ?? 0,
-      cache_hit_rate: eff.hitRate ?? 0,
-    }
-  }).sort((a, b) => b.estimated_cost - a.estimated_cost)
-
-  // ── Daily cost by model ────────────────────────────────────────────────────
-  // stats-cache.json uses "dailyModelTokens" in newer CC versions; "tokensByDate" in older ones
-  const daily: DailyCost[] = (stats.dailyModelTokens ?? stats.tokensByDate ?? []).map(d => {
-    const costs: Record<string, number> = {}
-    let dayTotal = 0
-    for (const [model, tokens] of Object.entries(d.tokensByModel ?? {})) {
-      const p = getPricing(model)
-      // tokensByDate only has total tokens, approximate as input+output split 50/50
-      const cost = tokens * p.input * 0.5 + tokens * p.output * 0.5
-      costs[model] = cost
-      dayTotal += cost
-    }
-    return { date: d.date, costs, total: dayTotal }
-  })
-
-  // ── Cost by project ────────────────────────────────────────────────────────
-  const projectMap = new Map<string, { cost: number; input: number; output: number }>()
-  for (const s of sessions) {
-    const pp = s.project_path ?? ''
-    const slug = pp
-    const existing = projectMap.get(slug) ?? { cost: 0, input: 0, output: 0 }
-    const cost = estimateTotalCostFromModel('claude-opus-4-6', {
-      inputTokens: s.input_tokens ?? 0,
-      outputTokens: s.output_tokens ?? 0,
-      cacheCreationInputTokens: s.cache_creation_input_tokens ?? 0,
-      cacheReadInputTokens: s.cache_read_input_tokens ?? 0,
-      costUSD: 0,
-      webSearchRequests: 0,
-    })
-    projectMap.set(slug, {
-      cost: existing.cost + cost,
-      input: existing.input + (s.input_tokens ?? 0),
-      output: existing.output + (s.output_tokens ?? 0),
-    })
-  }
-
-  const by_project: ProjectCost[] = [...projectMap.entries()]
-    .map(([slug, data]) => {
-      const projectPath = slug
-      return {
-        slug,
-        display_name: projectDisplayName(projectPath),
-        estimated_cost: data.cost,
-        input_tokens: data.input,
-        output_tokens: data.output,
-      }
-    })
-    .sort((a, b) => b.estimated_cost - a.estimated_cost)
-    .slice(0, 20)
-
-  const result: CostAnalytics = { total_cost: totalCost, total_savings: totalSavings, models, daily, by_project }
-  return NextResponse.json(result)
-}

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

@@ -1,77 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readStatsCache, getSessions, readAllFacets, readHistory } from '@/lib/claude-reader'
-import type { ExportPayload, Facet, SessionMeta } from '@/types/claude'
-
-export const dynamic = 'force-dynamic'
-
-function filterSessionsByDateRange(
-  sessions: SessionMeta[],
-  dateRange?: { from?: string; to?: string }
-) {
-  const fromMs = dateRange?.from ? new Date(dateRange.from).getTime() : null
-  const toMs = dateRange?.to ? new Date(dateRange.to + 'T23:59:59.999Z').getTime() : null
-  return sessions.filter(s => {
-    if (!s.start_time) return true
-    const t = new Date(s.start_time).getTime()
-    if (fromMs !== null && t < fromMs) return false
-    if (toMs !== null && t > toMs) return false
-    return true
-  })
-}
-
-function facetsForSessions(facets: Facet[], sessions: SessionMeta[]) {
-  const sessionIds = new Set(sessions.map(s => s.session_id))
-  return facets.filter(f => sessionIds.has(f.session_id))
-}
-
-/** Preview counts for the export UI (optional date filter via query params). */
-export async function GET(req: Request) {
-  const url = new URL(req.url)
-  const from = url.searchParams.get('from') || undefined
-  const to = url.searchParams.get('to') || undefined
-  const dateRange = from || to ? { from, to } : undefined
-
-  const [stats, sessions, facets, history] = await Promise.all([
-    readStatsCache(),
-    getSessions(),
-    readAllFacets(),
-    readHistory(10_000),
-  ])
-
-  const filteredSessions = filterSessionsByDateRange(sessions, dateRange)
-  const filteredFacets = facetsForSessions(facets, filteredSessions)
-
-  return NextResponse.json({
-    sessionCount: filteredSessions.length,
-    facetCount: filteredFacets.length,
-    historyEntries: history.length,
-    hasStatsCache: stats !== null,
-    totalSessionsIndexed: sessions.length,
-  })
-}
-
-export async function POST(req: Request) {
-  const body = await req.json().catch(() => ({}))
-  const { dateRange } = body as { dateRange?: { from?: string; to?: string } }
-
-  const [stats, sessions, facets, history] = await Promise.all([
-    readStatsCache(),
-    getSessions(),
-    readAllFacets(),
-    readHistory(10_000),
-  ])
-
-  const filteredSessions = filterSessionsByDateRange(sessions, dateRange)
-  const filteredFacets = facetsForSessions(facets, filteredSessions)
-
-  const payload: ExportPayload = {
-    exportedAt: new Date().toISOString(),
-    version: '1.0.0',
-    stats,
-    sessions: filteredSessions,
-    facets: filteredFacets,
-    history,
-  }
-
-  return NextResponse.json(payload)
-}

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

@@ -1,11 +0,0 @@
-import { NextResponse } from 'next/server'
-import { readHistory } from '@/lib/claude-reader'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET(req: Request) {
-  const { searchParams } = new URL(req.url)
-  const limit = Math.min(parseInt(searchParams.get('limit') ?? '200', 10), 10_000)
-  const history = await readHistory(limit)
-  return NextResponse.json({ history })
-}

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

@@ -1,31 +0,0 @@
-import { NextResponse } from 'next/server'
-import { getSessions } from '@/lib/claude-reader'
-import type { ExportPayload, ImportDiff } from '@/types/claude'
-
-export const dynamic = 'force-dynamic'
-
-export async function POST(req: Request) {
-  const payload = await req.json().catch(() => null) as ExportPayload | null
-
-  if (!payload || !payload.sessions) {
-    return NextResponse.json({ error: 'Invalid import payload' }, { status: 400 })
-  }
-
-  const existing = await getSessions()
-  const existingIds = new Set(existing.map(s => s.session_id))
-
-  const sessions_to_add = payload.sessions.filter(s => !existingIds.has(s.session_id))
-
-  const diff: ImportDiff = {
-    total_in_export: payload.sessions.length,
-    already_present: payload.sessions.length - sessions_to_add.length,
-    new_sessions: sessions_to_add.length,
-    sessions_to_add,
-  }
-
-  // Note: actual file writing is intentionally not implemented here
-  // to prevent accidental corruption of ~/.bahulam/ live data.
-  // The import feature shows a diff preview only.
-
-  return NextResponse.json(diff)
-}

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

@@ -1,50 +0,0 @@
-import { NextResponse } from 'next/server'
-import fs from 'fs/promises'
-import path from 'path'
-import { readMemories } from '@/lib/claude-reader'
-import { bahulamPath } from '@/lib/bahulam-paths'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET() {
-  const memories = await readMemories()
-  return NextResponse.json({ memories })
-}
-
-export async function PATCH(req: Request) {
-  try {
-    const { projectSlug, file, content } = await req.json() as {
-      projectSlug?: string
-      file?: string
-      content?: string
-    }
-
-    if (!projectSlug || !file || typeof content !== 'string') {
-      return NextResponse.json({ error: 'Missing required fields' }, { status: 400 })
-    }
-
-    // Only allow .md files
-    if (!file.endsWith('.md')) {
-      return NextResponse.json({ error: 'Only .md files allowed' }, { status: 400 })
-    }
-
-    // Prevent path traversal — slug and file must be plain names (no slashes or dots)
-    if (/[/\\]/.test(projectSlug) || /[/\\]/.test(file)) {
-      return NextResponse.json({ error: 'Invalid path' }, { status: 400 })
-    }
-
-    const filePath = bahulamPath('projects', projectSlug, 'memory', file)
-
-    // Ensure the resolved path stays within ~/.bahulam/projects/ (or the configured legacy dir).
-    const allowedRoot = bahulamPath('projects')
-    if (!filePath.startsWith(allowedRoot + path.sep)) {
-      return NextResponse.json({ error: 'Path outside allowed directory' }, { status: 403 })
-    }
-
-    await fs.mkdir(path.dirname(filePath), { recursive: true })
-    await fs.writeFile(filePath, content, 'utf-8')
-    return NextResponse.json({ ok: true })
-  } catch (err) {
-    return NextResponse.json({ error: String(err) }, { status: 500 })
-  }
-}

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

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

package/pulse/app/api/projects/[slug]/route.ts

@@ -1,96 +0,0 @@
-import path from 'path'
-import { NextResponse } from 'next/server'
-import { getSessions, listProjectJSONLFiles, readJSONLLines, resolveProjectPath } from '@/lib/claude-reader'
-import { estimateCostFromUsage } from '@/lib/pricing'
-import { projectDisplayName } from '@/lib/decode'
-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>
-
-export async function GET(
-  _req: Request,
-  { params }: { params: Promise<{ slug: string }> }
-) {
-  const { slug } = await params
-  const projectPath = await resolveProjectPath(slug)
-  const allSessions = await getSessions()
-  let sessions = allSessions.filter(s => s.project_path === projectPath)
-
-  if (sessions.length === 0) {
-    const lastSegment = projectPath.split('/').filter(Boolean).pop() ?? ''
-    sessions = allSessions.filter(s =>
-      s.project_path?.endsWith('/' + lastSegment)
-    )
-  }
-
-  // Gather per-session branch data from JSONL
-  const files = await listProjectJSONLFiles(slug)
-  const branchTurns = new Map<string, number>()
-  const sessionMeta = new Map<string, { slug?: string; version?: string; has_compaction?: boolean }>()
-
-  await Promise.all(
-    files.map(async (f) => {
-      const sessionId = path.basename(f, '.jsonl')
-      const meta: { slug?: string; version?: string; has_compaction?: boolean } = {}
-
-      await readJSONLLines(f, (line: AnyLine) => {
-        if (!meta.slug && line.slug) meta.slug = line.slug
-        if (!meta.version && line.version) meta.version = line.version
-        if (line.type === 'system' && line.subtype === 'compact_boundary') meta.has_compaction = true
-        if (line.gitBranch && line.gitBranch !== 'HEAD') {
-          branchTurns.set(line.gitBranch, (branchTurns.get(line.gitBranch) ?? 0) + 1)
-        }
-      })
-
-      sessionMeta.set(sessionId, meta)
-    })
-  )
-
-  const enrichedSessions: SessionWithFacet[] = sessions.map(s => {
-    const enrich = sessionMeta.get(s.session_id) ?? {}
-    return {
-      ...s,
-      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,
-      }),
-      slug: enrich.slug,
-      version: enrich.version,
-      has_compaction: enrich.has_compaction,
-    }
-  })
-
-  // Aggregate tools
-  const toolCounts: Record<string, number> = {}
-  for (const s of sessions) {
-    for (const [t, c] of Object.entries(s.tool_counts ?? {})) {
-      toolCounts[t] = (toolCounts[t] ?? 0) + c
-    }
-  }
-
-  // Cost per session (for chart)
-  const costBySession = enrichedSessions.map(s => ({
-    session_id: s.session_id,
-    start_time: s.start_time,
-    cost: s.estimated_cost,
-    messages: (s.user_message_count ?? 0) + (s.assistant_message_count ?? 0),
-  }))
-
-  const branches = [...branchTurns.entries()]
-    .map(([branch, turns]) => ({ branch, turns }))
-    .sort((a, b) => b.turns - a.turns)
-
-  return NextResponse.json({
-    project_path: projectPath,
-    display_name: projectDisplayName(projectPath),
-    sessions: enrichedSessions.sort((a, b) => b.start_time.localeCompare(a.start_time)),
-    tool_counts: toolCounts,
-    cost_by_session: costBySession,
-    branches,
-  })
-}

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

@@ -1,121 +0,0 @@
-import { NextResponse } from 'next/server'
-import { getSessions, listProjectSlugs, listProjectJSONLFiles, readJSONLLines, resolveProjectPath } from '@/lib/claude-reader'
-import { estimateCostFromUsage } from '@/lib/pricing'
-import { projectDisplayName } from '@/lib/decode'
-import type { ProjectSummary } 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, slugDirs] = await Promise.all([getSessions(), listProjectSlugs()])
-
-  // Build path→slug lookup from actual project directories
-  const pathToSlugMap = new Map<string, string>()
-  await Promise.all(
-    slugDirs.map(async (slug) => {
-      const resolved = await resolveProjectPath(slug)
-      pathToSlugMap.set(resolved, slug)
-    })
-  )
-
-  // Group sessions by project_path
-  const byPath = new Map<string, typeof sessions>()
-  for (const s of sessions) {
-    const pp = s.project_path ?? ''
-    if (!byPath.has(pp)) byPath.set(pp, [])
-    byPath.get(pp)!.push(s)
-  }
-
-  // Gather branches per slug from JSONL
-  const slugBranches = new Map<string, Set<string>>()
-  await Promise.all(
-    slugDirs.map(async (slug) => {
-      const files = await listProjectJSONLFiles(slug)
-      const branches = new Set<string>()
-      await Promise.all(
-        files.map(async (f) => {
-          await readJSONLLines(f, (line: AnyLine) => {
-            if (line.gitBranch && line.gitBranch !== 'HEAD') {
-              branches.add(line.gitBranch)
-            }
-          })
-        })
-      )
-      slugBranches.set(slug, branches)
-    })
-  )
-
-  const projects: ProjectSummary[] = []
-
-  for (const [projectPath, sessionList] of byPath.entries()) {
-    const slug = pathToSlugMap.get(projectPath) ?? projectPath.replace(/\//g, '-')
-
-    const totalMessages = sessionList.reduce(
-      (s, m) => s + (m.user_message_count ?? 0) + (m.assistant_message_count ?? 0), 0
-    )
-    const totalDuration = sessionList.reduce((s, m) => s + (m.duration_minutes ?? 0), 0)
-    const totalLinesAdded = sessionList.reduce((s, m) => s + (m.lines_added ?? 0), 0)
-    const totalLinesRemoved = sessionList.reduce((s, m) => s + (m.lines_removed ?? 0), 0)
-    const totalFilesModified = sessionList.reduce((s, m) => s + (m.files_modified ?? 0), 0)
-    const gitCommits = sessionList.reduce((s, m) => s + (m.git_commits ?? 0), 0)
-    const gitPushes = sessionList.reduce((s, m) => s + (m.git_pushes ?? 0), 0)
-    const inputTokens = sessionList.reduce((s, m) => s + (m.input_tokens ?? 0), 0)
-    const outputTokens = sessionList.reduce((s, m) => s + (m.output_tokens ?? 0), 0)
-
-    const estimatedCost = sessionList.reduce((sum, s) => {
-      return sum + 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,
-      })
-    }, 0)
-
-    const languages: Record<string, number> = {}
-    for (const s of sessionList) {
-      for (const [lang, count] of Object.entries(s.languages ?? {})) {
-        languages[lang] = (languages[lang] ?? 0) + count
-      }
-    }
-
-    const toolCounts: Record<string, number> = {}
-    for (const s of sessionList) {
-      for (const [tool, count] of Object.entries(s.tool_counts ?? {})) {
-        toolCounts[tool] = (toolCounts[tool] ?? 0) + count
-      }
-    }
-
-    const sortedDates = sessionList.map(s => s.start_time).sort()
-
-    projects.push({
-      slug,
-      project_path: projectPath,
-      display_name: projectDisplayName(projectPath),
-      session_count: sessionList.length,
-      total_messages: totalMessages,
-      total_duration_minutes: totalDuration,
-      total_lines_added: totalLinesAdded,
-      total_lines_removed: totalLinesRemoved,
-      total_files_modified: totalFilesModified,
-      git_commits: gitCommits,
-      git_pushes: gitPushes,
-      estimated_cost: estimatedCost,
-      input_tokens: inputTokens,
-      output_tokens: outputTokens,
-      languages,
-      tool_counts: toolCounts,
-      last_active: sortedDates[sortedDates.length - 1] ?? '',
-      first_active: sortedDates[0] ?? '',
-      uses_mcp: sessionList.some(s => s.uses_mcp),
-      uses_task_agent: sessionList.some(s => s.uses_task_agent),
-      branches: [...(slugBranches.get(slug) ?? new Set())].slice(0, 10),
-    })
-  }
-
-  return NextResponse.json({
-    projects: projects.sort((a, b) => b.last_active.localeCompare(a.last_active)),
-  })
-}

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 })
-}