@axplusb/kepler 0.0.1 → 1.0.0

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

@@ -0,0 +1,52 @@
+import { NextResponse } from 'next/server'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { readMemories } from '@/lib/claude-reader'
+
+export const dynamic = 'force-dynamic'
+
+const CLAUDE_DIR = path.join(os.homedir(), '.orca')
+
+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 = path.join(CLAUDE_DIR, 'projects', projectSlug, 'memory', file)
+
+    // Ensure the resolved path stays within ~/.orca/projects/
+    const allowedRoot = path.join(CLAUDE_DIR, '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

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

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

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

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