prjct-cli 0.10.14 → 0.11.1

package/packages/web/lib/parse-prjct-files.ts

@@ -0,0 +1,1122 @@
+/**
+ * Comprehensive parsers for prjct-cli data files
+ * Extracts ALL rich data from the prjct storage system
+ */
+
+import { readFile, readdir, stat } from 'fs/promises'
+import { join } from 'path'
+import { homedir } from 'os'
+
+// ============================================
+// TYPES - Full data model from prjct
+// ============================================
+
+export interface Author {
+  name: string
+  email: string
+  username?: string
+}
+
+export interface CurrentTask {
+  task: string
+  started?: string
+  duration?: string
+  feature?: string
+  phase?: string
+  agent?: string
+  estimate?: string
+  priority?: string
+}
+
+export interface TaskEvent {
+  ts: string
+  type: 'task_start' | 'task_complete' | 'task_shipped'
+  task: string
+  feature?: string
+  phase?: string
+  agent?: string
+  estimate?: string
+  duration?: string
+  started?: string
+  completed?: string
+  deliverables?: string[]
+  files_modified?: number
+  impact?: string
+  progress?: string
+  author?: Author
+}
+
+export interface ShipEvent {
+  ts: string
+  type: 'ship' | 'feature_ship' | 'feature_shipped'
+  name: string
+  feature?: string
+  version?: string
+  commit?: string
+  tasks_done?: number
+  duration?: string
+  agent?: string
+  impact?: string
+  complexity?: string
+  decision?: string
+  details?: string
+  author?: Author
+}
+
+export interface BugEvent {
+  ts: string
+  type: 'bug_report' | 'bug_fix'
+  name?: string
+  description: string
+  severity: string
+  files_modified?: number
+  author?: Author
+}
+
+export interface SyncEvent {
+  ts: string
+  type: 'sync' | 'repository_analyzed' | 'agents_generated' | 'agents_removed'
+  agents?: string[]
+  stack?: string
+  patterns?: number
+  fileCount?: number
+  gitCommits?: number
+  reason?: string
+  author?: Author
+}
+
+export interface CleanupEvent {
+  ts: string
+  type: 'cleanup'
+  action?: string
+  files_changed?: number
+  lines_removed?: number
+  lines_added?: number
+  net_change?: number
+  fixes?: Record<string, number>
+  details?: string
+  author?: Author
+}
+
+export interface RoadmapEvent {
+  ts: string
+  type: 'roadmap'
+  action: string
+  phases?: number
+  features?: number
+  estimated_weeks?: string
+  author?: Author
+}
+
+export interface IdeaEvent {
+  ts: string
+  type: 'idea_captured' | 'feature_add'
+  idea?: string
+  name?: string
+  priority?: string
+  impact?: string
+  effort?: string
+  actionable?: boolean
+  tasks_created?: number
+  author?: Author
+}
+
+export interface StuckEvent {
+  ts: string
+  type: 'stuck'
+  issue: string
+  context?: string
+  author?: Author
+}
+
+export type TimelineEvent =
+  | TaskEvent
+  | ShipEvent
+  | BugEvent
+  | SyncEvent
+  | CleanupEvent
+  | RoadmapEvent
+  | IdeaEvent
+  | StuckEvent
+  | { ts: string; type: string; [key: string]: unknown }
+
+export interface Metrics {
+  tasksStarted: number
+  tasksCompleted: number
+  inProgress: number
+  totalTime: string
+  daysActive: number
+  velocity: {
+    tasksPerDay: number
+    featuresPerWeek?: number
+  }
+  testCoverage?: {
+    total: number
+    passing: number
+    categories?: Record<string, { count: number; passing: number }>
+  }
+  codeQuality?: {
+    linesAdded: number
+    linesRemoved: number
+    filesChanged: number
+  }
+}
+
+export interface ShippedFeature {
+  date: string
+  name: string
+  version?: string
+  commit?: string
+  type?: string
+  agent?: string
+  time?: string
+  impact?: string
+  filesChanged?: number
+  linesAdded?: number
+  linesRemoved?: number
+  rootCause?: string
+  solution?: string
+  details?: string[]
+}
+
+export interface QueueItem {
+  task: string
+  priority: number
+  feature?: string
+  agent?: string
+  estimate?: string
+  status: 'pending' | 'in_progress'
+}
+
+export interface Idea {
+  title: string
+  status: string
+  date?: string
+  description?: string
+  painPoints?: string[]
+  solutions?: string[]
+  impact?: string
+  effort?: string
+}
+
+export interface RoadmapPhase {
+  name: string
+  status: 'completed' | 'in_progress' | 'queued'
+  progress: number
+  features?: RoadmapFeature[]
+}
+
+export interface RoadmapFeature {
+  name: string
+  status: 'completed' | 'in_progress' | 'queued'
+  tasks: number
+  tasksCompleted: number
+  time?: string
+  shippedDate?: string
+  version?: string
+}
+
+export interface Agent {
+  name: string
+  role?: string
+  responsibilities?: string[]
+  whenToUse?: string[]
+}
+
+export interface SessionDay {
+  date: string
+  events: TimelineEvent[]
+  tasksStarted: number
+  tasksCompleted: number
+  featuresShipped: number
+  timeTracked?: string
+}
+
+export interface AnalysisData {
+  fileCount: number
+  commitCount: number
+  stack: string
+  techStack?: string[]
+  structure?: string
+  architecture?: string
+}
+
+export interface CodePatterns {
+  moduleSystem?: Record<string, string>
+  namingConventions?: Record<string, string>
+  asyncPatterns?: Record<string, string>
+  classStructure?: string
+}
+
+// Full project stats interface
+export interface ProjectStats {
+  currentTask: CurrentTask | null
+  metrics: Metrics
+  shipped: ShippedFeature[]
+  queue: QueueItem[]
+  ideas: {
+    pending: Idea[]
+    archived: number
+    implemented: number
+  }
+  roadmap: {
+    phases: RoadmapPhase[]
+    completedFeatures: number
+    totalFeatures: number
+    progress: number
+  }
+  agents: Agent[]
+  timeline: TimelineEvent[]
+  sessions: SessionDay[]
+  analysis: AnalysisData
+  patterns?: CodePatterns
+  summary: {
+    totalEvents: number
+    firstActivity?: string
+    lastActivity?: string
+    activeDays: number
+    totalTasksEver: number
+    totalShipsEver: number
+    totalBugsFixed: number
+    totalCleanups: number
+  }
+}
+
+// ============================================
+// HELPERS
+// ============================================
+
+async function safeReadFile(path: string): Promise<string> {
+  try {
+    return await readFile(path, 'utf-8')
+  } catch {
+    return ''
+  }
+}
+
+async function safeReadDir(path: string): Promise<string[]> {
+  try {
+    return await readdir(path)
+  } catch {
+    return []
+  }
+}
+
+async function fileExists(path: string): Promise<boolean> {
+  try {
+    await stat(path)
+    return true
+  } catch {
+    return false
+  }
+}
+
+export function getStoragePath(projectId: string): string {
+  return join(homedir(), '.prjct-cli', 'projects', projectId)
+}
+
+// ============================================
+// PARSERS
+// ============================================
+
+// Parse now.md - Current task with full context
+export function parseNow(content: string): CurrentTask | null {
+  if (!content || content.includes('No active task')) {
+    return null
+  }
+
+  const lines = content.split('\n').filter(l => l.trim())
+
+  // Get task line (first non-header, non-empty line)
+  const taskLine = lines.find(l => !l.startsWith('#') && !l.startsWith('_') && l.trim())
+  if (!taskLine) return null
+
+  const task: CurrentTask = {
+    task: taskLine.replace(/^[-*]\s*/, '').replace(/\*\*/g, '').trim()
+  }
+
+  // Extract metadata if present
+  const startedMatch = content.match(/Started:\s*(.+)/i)
+  const featureMatch = content.match(/Feature:\s*(.+)/i)
+  const phaseMatch = content.match(/Phase:\s*(.+)/i)
+  const agentMatch = content.match(/Agent:\s*(.+)/i)
+  const estimateMatch = content.match(/Estimate:\s*(.+)/i)
+  const priorityMatch = content.match(/Priority:\s*(.+)/i)
+
+  if (startedMatch) task.started = startedMatch[1].trim()
+  if (featureMatch) task.feature = featureMatch[1].trim()
+  if (phaseMatch) task.phase = phaseMatch[1].trim()
+  if (agentMatch) task.agent = agentMatch[1].trim()
+  if (estimateMatch) task.estimate = estimateMatch[1].trim()
+  if (priorityMatch) task.priority = priorityMatch[1].trim()
+
+  return task
+}
+
+// Parse next.md - Priority queue with context
+export function parseQueue(content: string): QueueItem[] {
+  const items: QueueItem[] = []
+  if (!content) return items
+
+  const lines = content.split('\n')
+  let priority = 1
+  let currentFeature: string | undefined
+
+  for (const line of lines) {
+    // Track feature headers
+    const featureMatch = line.match(/^##\s+(.+)$/)
+    if (featureMatch) {
+      currentFeature = featureMatch[1].trim()
+      continue
+    }
+
+    // Match items: 1. [ ] Task or - [ ] Task
+    const itemMatch = line.match(/^(?:\d+\.|[-*])\s*\[([\sx])\]\s*(.+)$/i)
+    if (itemMatch) {
+      const isCompleted = itemMatch[1].toLowerCase() === 'x'
+      if (isCompleted) continue // Skip completed
+
+      const taskText = itemMatch[2].trim()
+
+      // Extract agent if present: Task @agent
+      const agentMatch = taskText.match(/@(\w+)$/)
+      const estimateMatch = taskText.match(/\((\d+[hmd])\)/)
+
+      items.push({
+        task: taskText.replace(/@\w+$/, '').replace(/\(\d+[hmd]\)/, '').trim(),
+        priority: priority++,
+        feature: currentFeature,
+        agent: agentMatch?.[1],
+        estimate: estimateMatch?.[1],
+        status: 'pending'
+      })
+    }
+  }
+
+  return items
+}
+
+// Parse metrics.md - Full metrics extraction
+export function parseMetrics(content: string): Metrics {
+  const defaults: Metrics = {
+    tasksStarted: 0,
+    tasksCompleted: 0,
+    inProgress: 0,
+    totalTime: '0h',
+    daysActive: 0,
+    velocity: { tasksPerDay: 0 }
+  }
+
+  if (!content) return defaults
+
+  // Basic metrics
+  const started = content.match(/Tasks Started\*?\*?:\s*(\d+)/i)
+  const completed = content.match(/(?:Tasks Completed|Total Tasks Shipped)\*?\*?:\s*(\d+)/i)
+  const inProgress = content.match(/In Progress\*?\*?:\s*(\d+)/i)
+  const totalTime = content.match(/(?:Total Time|Total Time Tracked)\*?\*?:\s*([^\n]+)/i)
+  const daysActive = content.match(/Days Active\*?\*?:\s*(\d+)/i)
+  const tasksPerDay = content.match(/(?:Tasks\/Day|Tasks per Day)\*?\*?:\s*([\d.]+)/i)
+  const featuresPerWeek = content.match(/Features\/Week\*?\*?:\s*([\d.]+)/i)
+
+  const metrics: Metrics = {
+    tasksStarted: started ? parseInt(started[1]) : 0,
+    tasksCompleted: completed ? parseInt(completed[1]) : 0,
+    inProgress: inProgress ? parseInt(inProgress[1]) : 0,
+    totalTime: totalTime ? totalTime[1].trim() : '0h',
+    daysActive: daysActive ? parseInt(daysActive[1]) : 0,
+    velocity: {
+      tasksPerDay: tasksPerDay ? parseFloat(tasksPerDay[1]) : 0,
+      featuresPerWeek: featuresPerWeek ? parseFloat(featuresPerWeek[1]) : undefined
+    }
+  }
+
+  // Test coverage section
+  const testSection = content.match(/##\s*Test Coverage([\s\S]*?)(?=##|$)/i)
+  if (testSection) {
+    const totalTests = testSection[1].match(/Total:\s*(\d+)/i)
+    const passingTests = testSection[1].match(/(\d+)\s*passing/i)
+    if (totalTests || passingTests) {
+      metrics.testCoverage = {
+        total: totalTests ? parseInt(totalTests[1]) : 0,
+        passing: passingTests ? parseInt(passingTests[1]) : 0
+      }
+    }
+  }
+
+  // Code quality
+  const linesAdded = content.match(/Lines Added\*?\*?:\s*(\d+)/i)
+  const linesRemoved = content.match(/Lines Removed\*?\*?:\s*(\d+)/i)
+  const filesChanged = content.match(/Files Changed\*?\*?:\s*(\d+)/i)
+  if (linesAdded || linesRemoved || filesChanged) {
+    metrics.codeQuality = {
+      linesAdded: linesAdded ? parseInt(linesAdded[1]) : 0,
+      linesRemoved: linesRemoved ? parseInt(linesRemoved[1]) : 0,
+      filesChanged: filesChanged ? parseInt(filesChanged[1]) : 0
+    }
+  }
+
+  return metrics
+}
+
+// Parse shipped.md - Full feature details
+export function parseShipped(content: string): ShippedFeature[] {
+  const features: ShippedFeature[] = []
+  if (!content) return features
+
+  // Split by version headers: ## v1.2.3 - Name or ## 2025-01-01
+  const sections = content.split(/^##\s+/m).filter(s => s.trim())
+
+  for (const section of sections) {
+    const lines = section.split('\n')
+    const headerLine = lines[0]
+
+    // Parse header: v1.2.3 - Feature Name or date
+    const versionMatch = headerLine.match(/^(v[\d.]+)\s*[-–]\s*(.+)$/i)
+    const dateMatch = headerLine.match(/^(\d{4}-\d{2}-\d{2})/)
+
+    if (!versionMatch && !dateMatch) continue
+
+    const feature: ShippedFeature = {
+      date: dateMatch ? dateMatch[1] : new Date().toISOString().split('T')[0],
+      name: versionMatch ? versionMatch[2].trim() : '',
+      version: versionMatch ? versionMatch[1] : undefined
+    }
+
+    // Parse feature metadata
+    for (const line of lines.slice(1)) {
+      const typeMatch = line.match(/Type\*?\*?:\s*(\w+)/i)
+      const agentMatch = line.match(/Agent\*?\*?:\s*(\w+)/i)
+      const timeMatch = line.match(/Time\*?\*?:\s*([^\n]+)/i)
+      const commitMatch = line.match(/Commit\*?\*?:\s*(\w+)/i)
+      const impactMatch = line.match(/Impact\*?\*?:\s*(\w+)/i)
+      const filesMatch = line.match(/Files changed\*?\*?:\s*(\d+)/i)
+      const addedMatch = line.match(/\+(\d+)/i)
+      const removedMatch = line.match(/-(\d+)/i)
+
+      if (typeMatch) feature.type = typeMatch[1]
+      if (agentMatch) feature.agent = agentMatch[1]
+      if (timeMatch) feature.time = timeMatch[1].trim()
+      if (commitMatch) feature.commit = commitMatch[1]
+      if (impactMatch) feature.impact = impactMatch[1]
+      if (filesMatch) feature.filesChanged = parseInt(filesMatch[1])
+      if (addedMatch) feature.linesAdded = parseInt(addedMatch[1])
+      if (removedMatch) feature.linesRemoved = parseInt(removedMatch[1])
+
+      // Root cause and solution for fixes
+      if (line.includes('Root Cause')) {
+        feature.rootCause = line.replace(/.*Root Cause\*?\*?:\s*/i, '').trim()
+      }
+      if (line.includes('Solution')) {
+        feature.solution = line.replace(/.*Solution\*?\*?:\s*/i, '').trim()
+      }
+    }
+
+    // If we found name from features list
+    if (!feature.name) {
+      const featureLineMatch = section.match(/\*\*([^*]+)\*\*/m)
+      if (featureLineMatch) {
+        feature.name = featureLineMatch[1].trim()
+      }
+    }
+
+    if (feature.name) {
+      features.push(feature)
+    }
+  }
+
+  return features.slice(0, 20) // Last 20
+}
+
+// Parse ideas.md - Full idea structure
+export function parseIdeas(content: string): { pending: Idea[]; archived: number; implemented: number } {
+  const pending: Idea[] = []
+  let archived = 0
+  let implemented = 0
+
+  if (!content) return { pending, archived, implemented }
+
+  const lines = content.split('\n')
+  let inArchived = false
+  let inImplemented = false
+  let currentIdea: Partial<Idea> | null = null
+  let collectingPainPoints = false
+  let collectingSolutions = false
+
+  for (const line of lines) {
+    // Check section headers
+    if (line.match(/^##.*Archived/i)) {
+      inArchived = true
+      inImplemented = false
+      if (currentIdea?.title) pending.push(currentIdea as Idea)
+      currentIdea = null
+      continue
+    }
+    if (line.match(/^##.*Implemented/i)) {
+      inImplemented = true
+      inArchived = false
+      if (currentIdea?.title) pending.push(currentIdea as Idea)
+      currentIdea = null
+      continue
+    }
+
+    // Date header: ## 2025-01-01
+    const dateMatch = line.match(/^##\s*(\d{4}-\d{2}-\d{2})/)
+    if (dateMatch) {
+      if (currentIdea?.title && !inArchived && !inImplemented) {
+        pending.push(currentIdea as Idea)
+      }
+      currentIdea = { date: dateMatch[1], status: 'PENDING' }
+      inArchived = false
+      inImplemented = false
+      continue
+    }
+
+    // Idea title: ### Title
+    const titleMatch = line.match(/^###\s+(.+)$/)
+    if (titleMatch) {
+      if (inArchived) {
+        archived++
+        continue
+      }
+      if (inImplemented) {
+        implemented++
+        continue
+      }
+
+      if (currentIdea?.title) {
+        pending.push(currentIdea as Idea)
+      }
+      currentIdea = {
+        title: titleMatch[1].trim(),
+        status: 'PENDING',
+        date: currentIdea?.date
+      }
+      collectingPainPoints = false
+      collectingSolutions = false
+      continue
+    }
+
+    if (!currentIdea || inArchived || inImplemented) continue
+
+    // Status
+    const statusMatch = line.match(/Status\*?\*?:\s*(\w+)/i)
+    if (statusMatch) currentIdea.status = statusMatch[1]
+
+    // Description
+    const descMatch = line.match(/Description\*?\*?:\s*(.+)/i)
+    if (descMatch) currentIdea.description = descMatch[1].trim()
+
+    // Impact and effort
+    const impactMatch = line.match(/Impact\*?\*?:\s*(\w+)/i)
+    if (impactMatch) currentIdea.impact = impactMatch[1]
+
+    const effortMatch = line.match(/Effort\*?\*?:\s*([^\n|]+)/i)
+    if (effortMatch) currentIdea.effort = effortMatch[1].trim()
+
+    // Pain points section
+    if (line.match(/Pain Points/i)) {
+      collectingPainPoints = true
+      collectingSolutions = false
+      currentIdea.painPoints = []
+      continue
+    }
+    if (line.match(/Solutions/i)) {
+      collectingSolutions = true
+      collectingPainPoints = false
+      currentIdea.solutions = []
+      continue
+    }
+
+    // Collect list items
+    const listMatch = line.match(/^[-*\d.]\s+(.+)$/)
+    if (listMatch) {
+      if (collectingPainPoints && currentIdea.painPoints) {
+        currentIdea.painPoints.push(listMatch[1].trim())
+      } else if (collectingSolutions && currentIdea.solutions) {
+        currentIdea.solutions.push(listMatch[1].trim())
+      }
+    }
+  }
+
+  // Add last idea
+  if (currentIdea?.title && !inArchived && !inImplemented) {
+    pending.push(currentIdea as Idea)
+  }
+
+  return { pending, archived, implemented }
+}
+
+// Parse roadmap.md - Full roadmap structure
+export function parseRoadmap(content: string): { phases: RoadmapPhase[]; completedFeatures: number; totalFeatures: number; progress: number } {
+  const phases: RoadmapPhase[] = []
+  let completedFeatures = 0
+  let totalFeatures = 0
+
+  if (!content) return { phases, completedFeatures, totalFeatures, progress: 0 }
+
+  // Split by phase headers
+  const phaseSections = content.split(/^##\s+(?:Phase\s+)?/mi).filter(s => s.trim())
+
+  for (const section of phaseSections) {
+    const lines = section.split('\n')
+    const header = lines[0]
+
+    // Match: P1: Name or Phase 1: Name or just number
+    const phaseMatch = header.match(/^(?:P)?(\d+)[:\s-]*(.*)$/i)
+    if (!phaseMatch) continue
+
+    const phaseNum = phaseMatch[1]
+    const features: RoadmapFeature[] = []
+    let phaseStatus: 'completed' | 'in_progress' | 'queued' = 'queued'
+
+    // Check for status in section
+    if (section.match(/Status\*?\*?:\s*(?:COMPLETED|Done)/i)) {
+      phaseStatus = 'completed'
+    } else if (section.match(/Status\*?\*?:\s*(?:IN.?PROGRESS|Active)/i)) {
+      phaseStatus = 'in_progress'
+    }
+
+    // Parse features
+    for (const line of lines) {
+      // Feature line: - [x] Feature Name (tasks, time) - Shipped date
+      const featureMatch = line.match(/^[-*]\s*\[([\sx])\]\s*(.+)/i)
+      if (featureMatch) {
+        totalFeatures++
+        const isCompleted = featureMatch[1].toLowerCase() === 'x'
+        if (isCompleted) completedFeatures++
+
+        const featureText = featureMatch[2]
+        const nameMatch = featureText.match(/^([^(]+)/)
+        const tasksMatch = featureText.match(/\((\d+)\s*(?:tasks?|\/\d+)/)
+        const shippedMatch = featureText.match(/Shipped\s+(\d{4}-\d{2}-\d{2})/i)
+        const versionMatch = featureText.match(/\((v[\d.]+)\)/)
+
+        if (nameMatch) {
+          features.push({
+            name: nameMatch[1].replace(/\*\*/g, '').trim(),
+            status: isCompleted ? 'completed' : 'in_progress',
+            tasks: tasksMatch ? parseInt(tasksMatch[1]) : 0,
+            tasksCompleted: isCompleted ? (tasksMatch ? parseInt(tasksMatch[1]) : 0) : 0,
+            shippedDate: shippedMatch?.[1],
+            version: versionMatch?.[1]
+          })
+
+          // Update phase status based on features
+          if (!isCompleted) phaseStatus = phaseStatus === 'completed' ? 'in_progress' : phaseStatus
+        }
+      }
+    }
+
+    // Calculate phase progress
+    const completedInPhase = features.filter(f => f.status === 'completed').length
+    const phaseProgress = features.length > 0
+      ? Math.round((completedInPhase / features.length) * 100)
+      : (phaseStatus === 'completed' ? 100 : 0)
+
+    phases.push({
+      name: `P${phaseNum}`,
+      status: phaseStatus,
+      progress: phaseProgress,
+      features
+    })
+  }
+
+  // Also check for progress table format
+  const tableRows = content.match(/\|\s*P(\d+)[^|]*\|[^|]*\|\s*(\d+)%/gi)
+  if (tableRows && phases.length === 0) {
+    for (const row of tableRows) {
+      const match = row.match(/P(\d+)[^|]*\|[^|]*\|\s*(\d+)%/)
+      if (match) {
+        const progress = parseInt(match[2])
+        phases.push({
+          name: `P${match[1]}`,
+          status: progress === 100 ? 'completed' : progress > 0 ? 'in_progress' : 'queued',
+          progress
+        })
+      }
+    }
+  }
+
+  const overallProgress = totalFeatures > 0
+    ? Math.round((completedFeatures / totalFeatures) * 100)
+    : 0
+
+  return { phases, completedFeatures, totalFeatures, progress: overallProgress }
+}
+
+// Parse context.jsonl - Full timeline with all event types
+export function parseTimeline(content: string): TimelineEvent[] {
+  const events: TimelineEvent[] = []
+  if (!content) return events
+
+  const lines = content.split('\n').filter(l => l.trim())
+
+  for (const line of lines) {
+    try {
+      const raw = JSON.parse(line)
+      const ts = raw.ts || raw.timestamp || ''
+      const type = raw.type || raw.action || 'unknown'
+
+      // Normalize the event
+      const event: TimelineEvent = {
+        ts,
+        type,
+        ...raw
+      }
+
+      events.push(event)
+    } catch {
+      // Skip invalid JSON
+    }
+  }
+
+  // Sort by timestamp descending (most recent first)
+  return events.sort((a, b) => {
+    const dateA = new Date(a.ts).getTime()
+    const dateB = new Date(b.ts).getTime()
+    return dateB - dateA
+  })
+}
+
+// Parse session files from progress/sessions and memory/sessions
+export async function parseSessions(storagePath: string): Promise<SessionDay[]> {
+  const sessions: Map<string, SessionDay> = new Map()
+
+  const sessionDirs = [
+    join(storagePath, 'progress', 'sessions'),
+    join(storagePath, 'memory', 'sessions')
+  ]
+
+  for (const dir of sessionDirs) {
+    // Check for monthly folders
+    const months = await safeReadDir(dir)
+
+    for (const month of months) {
+      const monthPath = join(dir, month)
+      const files = await safeReadDir(monthPath)
+
+      for (const file of files) {
+        if (!file.endsWith('.jsonl')) continue
+
+        const date = file.replace('.jsonl', '')
+        const content = await safeReadFile(join(monthPath, file))
+        const events = parseTimeline(content)
+
+        if (!sessions.has(date)) {
+          sessions.set(date, {
+            date,
+            events: [],
+            tasksStarted: 0,
+            tasksCompleted: 0,
+            featuresShipped: 0
+          })
+        }
+
+        const day = sessions.get(date)!
+        day.events.push(...events)
+        day.tasksStarted += events.filter(e => e.type === 'task_start').length
+        day.tasksCompleted += events.filter(e => e.type === 'task_complete').length
+        day.featuresShipped += events.filter(e =>
+          e.type === 'ship' || e.type === 'feature_ship' || e.type === 'feature_shipped'
+        ).length
+      }
+    }
+
+    // Also check root session files
+    const rootFiles = await safeReadDir(dir)
+    for (const file of rootFiles) {
+      if (!file.endsWith('.jsonl')) continue
+
+      const date = file.replace('.jsonl', '')
+      if (date.match(/^\d{4}-\d{2}-\d{2}$/)) {
+        const content = await safeReadFile(join(dir, file))
+        const events = parseTimeline(content)
+
+        if (!sessions.has(date)) {
+          sessions.set(date, {
+            date,
+            events: [],
+            tasksStarted: 0,
+            tasksCompleted: 0,
+            featuresShipped: 0
+          })
+        }
+
+        const day = sessions.get(date)!
+        day.events.push(...events)
+        day.tasksStarted += events.filter(e => e.type === 'task_start').length
+        day.tasksCompleted += events.filter(e => e.type === 'task_complete').length
+        day.featuresShipped += events.filter(e =>
+          e.type === 'ship' || e.type === 'feature_ship' || e.type === 'feature_shipped'
+        ).length
+      }
+    }
+  }
+
+  // Sort by date descending
+  return Array.from(sessions.values()).sort((a, b) =>
+    new Date(b.date).getTime() - new Date(a.date).getTime()
+  )
+}
+
+// Parse agents - Full agent details
+export async function parseAgents(storagePath: string): Promise<Agent[]> {
+  const agents: Agent[] = []
+  const agentsDir = join(storagePath, 'agents')
+
+  const files = await safeReadDir(agentsDir)
+
+  for (const file of files) {
+    if (!file.endsWith('.md')) continue
+
+    const name = file.replace('.md', '')
+    const content = await safeReadFile(join(agentsDir, file))
+
+    const agent: Agent = { name }
+
+    // Parse role
+    const roleMatch = content.match(/(?:Role|Description)\*?\*?:\s*([^\n]+)/i)
+    if (roleMatch) agent.role = roleMatch[1].trim()
+
+    // Parse responsibilities
+    const respSection = content.match(/##\s*Responsibilities([\s\S]*?)(?=##|$)/i)
+    if (respSection) {
+      const items = respSection[1].match(/^[-*]\s+(.+)$/gm)
+      if (items) {
+        agent.responsibilities = items.map(i => i.replace(/^[-*]\s+/, '').trim())
+      }
+    }
+
+    // Parse when to use
+    const whenSection = content.match(/##\s*When to Use([\s\S]*?)(?=##|$)/i)
+    if (whenSection) {
+      const items = whenSection[1].match(/^[-*]\s+(.+)$/gm)
+      if (items) {
+        agent.whenToUse = items.map(i => i.replace(/^[-*]\s+/, '').trim())
+      }
+    }
+
+    agents.push(agent)
+  }
+
+  return agents
+}
+
+// Parse repo-summary.md - Full analysis
+export function parseAnalysis(content: string): AnalysisData {
+  const defaults: AnalysisData = { fileCount: 0, commitCount: 0, stack: 'Unknown' }
+  if (!content) return defaults
+
+  const fileMatch = content.match(/(\d+)\s*files/i)
+  const commitMatch = content.match(/(?:Total Commits|Commits)\*?\*?:\s*(\d+)/i) || content.match(/(\d+)\s*commits/i)
+  const stackMatch = content.match(/(?:Runtime|Tech Stack)[^:]*:\s*([^\n]+)/i)
+
+  // Extract tech stack array
+  const techStackSection = content.match(/##\s*(?:Tech Stack|Dependencies)([\s\S]*?)(?=##|$)/i)
+  const techStack: string[] = []
+  if (techStackSection) {
+    const items = techStackSection[1].match(/[-*]\s+([^:\n]+)/g)
+    if (items) {
+      techStack.push(...items.map(i => i.replace(/^[-*]\s+/, '').trim()))
+    }
+  }
+
+  // Extract structure
+  const structureSection = content.match(/##\s*(?:Project )?Structure([\s\S]*?)(?=##|$)/i)
+
+  // Extract architecture
+  const archSection = content.match(/##\s*Architecture([\s\S]*?)(?=##|$)/i)
+
+  return {
+    fileCount: fileMatch ? parseInt(fileMatch[1]) : 0,
+    commitCount: commitMatch ? parseInt(commitMatch[1]) : 0,
+    stack: stackMatch ? stackMatch[1].trim().replace(/^[-*]\s*/, '') : 'Unknown',
+    techStack: techStack.length > 0 ? techStack : undefined,
+    structure: structureSection?.[1]?.trim(),
+    architecture: archSection?.[1]?.trim()
+  }
+}
+
+// Parse patterns.md - Code patterns
+export function parsePatterns(content: string): CodePatterns | undefined {
+  if (!content) return undefined
+
+  const patterns: CodePatterns = {}
+
+  // Module system
+  const moduleSection = content.match(/##\s*Module System([\s\S]*?)(?=##|$)/i)
+  if (moduleSection) {
+    const items = moduleSection[1].match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/g)
+    if (items) {
+      patterns.moduleSystem = {}
+      for (const item of items) {
+        const match = item.match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/)
+        if (match && !match[1].includes('Pattern')) {
+          patterns.moduleSystem[match[1].trim()] = match[2].trim()
+        }
+      }
+    }
+  }
+
+  // Naming conventions
+  const namingSection = content.match(/##\s*Naming Conventions([\s\S]*?)(?=##|$)/i)
+  if (namingSection) {
+    const items = namingSection[1].match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/g)
+    if (items) {
+      patterns.namingConventions = {}
+      for (const item of items) {
+        const match = item.match(/\|\s*([^|]+)\s*\|\s*([^|]+)\s*\|/)
+        if (match && !match[1].includes('Element')) {
+          patterns.namingConventions[match[1].trim()] = match[2].trim()
+        }
+      }
+    }
+  }
+
+  return Object.keys(patterns).length > 0 ? patterns : undefined
+}
+
+// ============================================
+// MAIN EXPORT
+// ============================================
+
+export async function getProjectStats(projectId: string): Promise<ProjectStats> {
+  const storagePath = getStoragePath(projectId)
+
+  // Read all files in parallel
+  const [
+    nowContent,
+    nextContent,
+    metricsContent,
+    shippedContent,
+    ideasContent,
+    roadmapContent,
+    timelineContent,
+    summaryContent,
+    patternsContent,
+    agents,
+    sessions
+  ] = await Promise.all([
+    safeReadFile(join(storagePath, 'core', 'now.md')),
+    safeReadFile(join(storagePath, 'core', 'next.md')),
+    safeReadFile(join(storagePath, 'progress', 'metrics.md')),
+    safeReadFile(join(storagePath, 'progress', 'shipped.md')),
+    safeReadFile(join(storagePath, 'planning', 'ideas.md')),
+    safeReadFile(join(storagePath, 'planning', 'roadmap.md')),
+    safeReadFile(join(storagePath, 'memory', 'context.jsonl')),
+    safeReadFile(join(storagePath, 'analysis', 'repo-summary.md')),
+    safeReadFile(join(storagePath, 'analysis', 'patterns.md')),
+    parseAgents(storagePath),
+    parseSessions(storagePath)
+  ])
+
+  const timeline = parseTimeline(timelineContent)
+  const ideas = parseIdeas(ideasContent)
+  const roadmap = parseRoadmap(roadmapContent)
+
+  // Calculate summary stats from timeline
+  const taskStarts = timeline.filter(e => e.type === 'task_start')
+  const taskCompletes = timeline.filter(e => e.type === 'task_complete')
+  const ships = timeline.filter(e => ['ship', 'feature_ship', 'feature_shipped'].includes(e.type))
+  const bugFixes = timeline.filter(e => e.type === 'bug_fix')
+  const cleanups = timeline.filter(e => e.type === 'cleanup')
+
+  const firstEvent = timeline[timeline.length - 1]
+  const lastEvent = timeline[0]
+
+  // Calculate active days
+  const uniqueDays = new Set(timeline.map(e => e.ts?.split('T')[0]).filter(Boolean))
+
+  return {
+    currentTask: parseNow(nowContent),
+    metrics: parseMetrics(metricsContent),
+    shipped: parseShipped(shippedContent),
+    queue: parseQueue(nextContent),
+    ideas,
+    roadmap,
+    agents,
+    timeline: timeline.slice(0, 100), // Last 100 events
+    sessions: sessions.slice(0, 30), // Last 30 days
+    analysis: parseAnalysis(summaryContent),
+    patterns: parsePatterns(patternsContent),
+    summary: {
+      totalEvents: timeline.length,
+      firstActivity: firstEvent?.ts,
+      lastActivity: lastEvent?.ts,
+      activeDays: uniqueDays.size,
+      totalTasksEver: taskStarts.length,
+      totalShipsEver: ships.length,
+      totalBugsFixed: bugFixes.length,
+      totalCleanups: cleanups.length
+    }
+  }
+}
+
+// ============================================
+// RAW FILES - Return markdown files as-is for rendering
+// ============================================
+
+export interface RawProjectFiles {
+  shipped: string    // progress/shipped.md
+  roadmap: string    // planning/roadmap.md
+  ideas: string      // planning/ideas.md
+  queue: string      // core/next.md
+  now: string        // core/now.md
+  context: string    // core/context.md
+  timeline: string   // memory/context.jsonl (raw for custom rendering)
+  agents: { name: string; content: string }[]  // agents/*.md
+}
+
+export async function getRawProjectFiles(projectId: string): Promise<RawProjectFiles> {
+  const storagePath = join(homedir(), '.prjct-cli', 'projects', projectId)
+
+  // Read all files in parallel
+  const [
+    shipped,
+    roadmap,
+    ideas,
+    queue,
+    now,
+    context,
+    timeline,
+    agentFiles
+  ] = await Promise.all([
+    safeReadFile(join(storagePath, 'progress', 'shipped.md')),
+    safeReadFile(join(storagePath, 'planning', 'roadmap.md')),
+    safeReadFile(join(storagePath, 'planning', 'ideas.md')),
+    safeReadFile(join(storagePath, 'core', 'next.md')),
+    safeReadFile(join(storagePath, 'core', 'now.md')),
+    safeReadFile(join(storagePath, 'core', 'context.md')),
+    safeReadFile(join(storagePath, 'memory', 'context.jsonl')),
+    readAgentsRaw(join(storagePath, 'agents'))
+  ])
+
+  return {
+    shipped,
+    roadmap,
+    ideas,
+    queue,
+    now,
+    context,
+    timeline,
+    agents: agentFiles
+  }
+}
+
+async function readAgentsRaw(agentsDir: string): Promise<{ name: string; content: string }[]> {
+  try {
+    const files = await readdir(agentsDir)
+    const mdFiles = files.filter(f => f.endsWith('.md'))
+
+    const agents = await Promise.all(
+      mdFiles.map(async (file) => ({
+        name: file.replace('.md', ''),
+        content: await safeReadFile(join(agentsDir, file))
+      }))
+    )
+
+    return agents.filter(a => a.content.trim())
+  } catch {
+    return []
+  }
+}