prjct-cli 0.18.2 → 0.20.0

package/packages/web/app/api/projects/[id]/momentum/route.ts

@@ -1,257 +0,0 @@
-import { NextResponse } from 'next/server'
-import { promises as fs } from 'fs'
-import { join } from 'path'
-import { homedir } from 'os'
-
-export const dynamic = 'force-dynamic'
-
-interface SessionEvent {
-  ts?: string
-  timestamp?: string
-  type?: string
-  action?: string
-}
-
-type MomentumStatus = 'hot' | 'active' | 'cooling' | 'cold'
-
-interface MomentumData {
-  dailyTasks: number[]
-  totalTasks: number
-  totalShips: number
-  lastActivityDate: string | null
-  daysSinceActivity: number
-  streak: number
-  status: MomentumStatus
-  message: string
-}
-
-function getStatus(
-  daysSinceActivity: number,
-  totalTasks: number,
-  dailyTasks: number[],
-  streak: number
-): { status: MomentumStatus; message: string } {
-  // Abandoned - 7+ days without activity
-  if (daysSinceActivity >= 7) {
-    return { status: 'cold', message: 'Miss you!' }
-  }
-
-  // No activity ever
-  if (totalTasks === 0) {
-    return { status: 'active', message: 'Start building!' }
-  }
-
-  // Check if trending up (recent days > earlier days)
-  const recentDays = dailyTasks.slice(-3).reduce((a, b) => a + b, 0)
-  const earlierDays = dailyTasks.slice(0, 4).reduce((a, b) => a + b, 0)
-  const isTrendingUp = recentDays > earlierDays || streak >= 2
-
-  // Hot - trending up or on a streak
-  if (isTrendingUp && daysSinceActivity <= 1) {
-    return { status: 'hot', message: streak >= 2 ? `${streak} day streak!` : 'On fire!' }
-  }
-
-  // Normal activity - neutral
-  if (daysSinceActivity <= 3) {
-    return { status: 'active', message: `${totalTasks} this week` }
-  }
-
-  // Cooling down but not abandoned
-  return { status: 'cooling', message: `${daysSinceActivity}d ago` }
-}
-
-export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  try {
-    const { id: projectId } = await params
-    const globalStorage = join(homedir(), '.prjct-cli', 'projects')
-    const projectPath = join(globalStorage, projectId)
-
-    // Check if project exists
-    try {
-      await fs.access(projectPath)
-    } catch {
-      return NextResponse.json(
-        { success: false, error: 'Project not found' },
-        { status: 404 }
-      )
-    }
-
-    // Calculate date range (last 7 days)
-    const endDate = new Date()
-    const startDate = new Date()
-    startDate.setDate(startDate.getDate() - 6) // 7 days including today
-    startDate.setHours(0, 0, 0, 0)
-
-    const dailyMap = new Map<string, { tasks: number; ships: number }>()
-    let lastActivityDate: Date | null = null
-
-    // Read from memory/context.jsonl (legacy)
-    const contextPath = join(projectPath, 'memory', 'context.jsonl')
-    try {
-      const content = await fs.readFile(contextPath, 'utf-8')
-      const lines = content.trim().split('\n').filter(Boolean)
-
-      for (const line of lines) {
-        try {
-          const event: SessionEvent = JSON.parse(line)
-          const timestamp = event.ts || event.timestamp
-          if (!timestamp) continue
-
-          const eventDate = new Date(timestamp)
-          if (isNaN(eventDate.getTime())) continue
-
-          const eventType = event.type || event.action
-
-          // Track last activity for any relevant event
-          if (eventType === 'task_complete' || eventType === 'task_completed' ||
-              eventType === 'feature_ship' || eventType === 'feature_shipped') {
-            if (!lastActivityDate || eventDate > lastActivityDate) {
-              lastActivityDate = eventDate
-            }
-          }
-
-          // Only count last 7 days for sparkline
-          if (eventDate < startDate || eventDate > endDate) continue
-
-          const dateKey = eventDate.toISOString().split('T')[0]
-          const current = dailyMap.get(dateKey) || { tasks: 0, ships: 0 }
-
-          if (eventType === 'task_complete' || eventType === 'task_completed') {
-            current.tasks++
-          }
-          if (eventType === 'feature_ship' || eventType === 'feature_shipped') {
-            current.ships++
-          }
-
-          dailyMap.set(dateKey, current)
-        } catch {
-          // Skip malformed lines
-        }
-      }
-    } catch {
-      // No context.jsonl
-    }
-
-    // Read from progress/sessions/{YYYY-MM}/{date}.jsonl (new format)
-    const sessionsDir = join(projectPath, 'progress', 'sessions')
-    try {
-      const monthDirs = await fs.readdir(sessionsDir)
-      for (const monthDir of monthDirs) {
-        if (!monthDir.match(/^\d{4}-\d{2}$/)) continue
-
-        const monthPath = join(sessionsDir, monthDir)
-        try {
-          const dayFiles = await fs.readdir(monthPath)
-          for (const dayFile of dayFiles) {
-            if (!dayFile.endsWith('.jsonl')) continue
-
-            const dayPath = join(monthPath, dayFile)
-            try {
-              const content = await fs.readFile(dayPath, 'utf-8')
-              const lines = content.trim().split('\n').filter(Boolean)
-
-              for (const line of lines) {
-                try {
-                  const event: SessionEvent = JSON.parse(line)
-                  const timestamp = event.ts || event.timestamp
-                  if (!timestamp) continue
-
-                  const eventDate = new Date(timestamp)
-                  if (isNaN(eventDate.getTime())) continue
-
-                  const eventType = event.type || event.action
-
-                  // Track last activity
-                  if (eventType === 'task_complete' || eventType === 'task_completed' ||
-                      eventType === 'feature_ship' || eventType === 'feature_shipped') {
-                    if (!lastActivityDate || eventDate > lastActivityDate) {
-                      lastActivityDate = eventDate
-                    }
-                  }
-
-                  // Only count last 7 days for sparkline
-                  if (eventDate < startDate || eventDate > endDate) continue
-
-                  const dateKey = eventDate.toISOString().split('T')[0]
-                  const current = dailyMap.get(dateKey) || { tasks: 0, ships: 0 }
-
-                  if (eventType === 'task_complete' || eventType === 'task_completed') {
-                    current.tasks++
-                  }
-                  if (eventType === 'feature_ship' || eventType === 'feature_shipped') {
-                    current.ships++
-                  }
-
-                  dailyMap.set(dateKey, current)
-                } catch {
-                  // Skip malformed lines
-                }
-              }
-            } catch {
-              // Skip unreadable files
-            }
-          }
-        } catch {
-          // Skip unreadable month directories
-        }
-      }
-    } catch {
-      // No sessions directory
-    }
-
-    // Generate daily tasks array for sparkline (7 days)
-    const dailyTasks: number[] = []
-    let totalTasks = 0
-    let totalShips = 0
-    let streak = 0
-    let streakBroken = false
-
-    const currentDate = new Date(startDate)
-    while (currentDate <= endDate) {
-      const dateKey = currentDate.toISOString().split('T')[0]
-      const stats = dailyMap.get(dateKey) || { tasks: 0, ships: 0 }
-      dailyTasks.push(stats.tasks + stats.ships)
-      totalTasks += stats.tasks
-      totalShips += stats.ships
-      currentDate.setDate(currentDate.getDate() + 1)
-    }
-
-    // Calculate streak (consecutive days with activity from today backwards)
-    for (let i = dailyTasks.length - 1; i >= 0; i--) {
-      if (dailyTasks[i] > 0 && !streakBroken) {
-        streak++
-      } else if (dailyTasks[i] === 0 && i < dailyTasks.length - 1) {
-        streakBroken = true
-      }
-    }
-
-    // Calculate days since last activity
-    const daysSinceActivity = lastActivityDate
-      ? Math.floor((endDate.getTime() - lastActivityDate.getTime()) / (1000 * 60 * 60 * 24))
-      : 999
-
-    const { status, message } = getStatus(daysSinceActivity, totalTasks, dailyTasks, streak)
-
-    const data: MomentumData = {
-      dailyTasks,
-      totalTasks,
-      totalShips,
-      lastActivityDate: lastActivityDate?.toISOString() || null,
-      daysSinceActivity,
-      streak,
-      status,
-      message
-    }
-
-    return NextResponse.json({ success: true, data })
-  } catch (error) {
-    console.error('Momentum API error:', error)
-    return NextResponse.json(
-      { success: false, error: 'Failed to fetch momentum data' },
-      { status: 500 }
-    )
-  }
-}

package/packages/web/app/api/projects/[id]/route.ts

@@ -1,29 +0,0 @@
-import { NextResponse } from 'next/server'
-import { getProject } from '@/lib/projects'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  const { id } = await params
-
-  try {
-    const project = await getProject(id)
-
-    if (!project) {
-      return NextResponse.json(
-        { success: false, error: 'Project not found' },
-        { status: 404 }
-      )
-    }
-
-    return NextResponse.json({ success: true, data: project })
-  } catch {
-    return NextResponse.json(
-      { success: false, error: 'Failed to get project' },
-      { status: 500 }
-    )
-  }
-}

package/packages/web/app/api/projects/[id]/stats/route.ts

@@ -1,41 +0,0 @@
-import { NextRequest, NextResponse } from 'next/server'
-import { getProjectStats, getRawProjectFiles } from '@/lib/parse-prjct-files'
-
-/**
- * GET /api/projects/[id]/stats
- *
- * MD-First Architecture: Returns stats parsed from MD files.
- */
-export async function GET(
-  request: NextRequest,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  const { id: projectId } = await params
-
-  if (!projectId) {
-    return NextResponse.json(
-      { success: false, error: 'Project ID required' },
-      { status: 400 }
-    )
-  }
-
-  try {
-    const [stats, raw] = await Promise.all([
-      getProjectStats(projectId),
-      getRawProjectFiles(projectId)
-    ])
-
-    return NextResponse.json({
-      success: true,
-      version: 'md-first',
-      data: stats,
-      raw
-    })
-  } catch (error) {
-    console.error('[API] Error getting project stats:', error)
-    return NextResponse.json(
-      { success: false, error: 'Failed to get project stats' },
-      { status: 500 }
-    )
-  }
-}

package/packages/web/app/api/projects/[id]/status/route.ts

@@ -1,21 +0,0 @@
-import { NextResponse } from 'next/server'
-import { getProjectStatus } from '@/lib/projects'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET(
-  request: Request,
-  { params }: { params: Promise<{ id: string }> }
-) {
-  const { id } = await params
-
-  try {
-    const status = await getProjectStatus(id)
-    return NextResponse.json({ success: true, data: status })
-  } catch {
-    return NextResponse.json(
-      { success: false, error: 'Failed to get status' },
-      { status: 500 }
-    )
-  }
-}

package/packages/web/app/api/projects/route.ts

@@ -1,16 +0,0 @@
-import { NextResponse } from 'next/server'
-import { getProjects } from '@/lib/projects'
-
-export const dynamic = 'force-dynamic'
-
-export async function GET() {
-  try {
-    const projects = await getProjects()
-    return NextResponse.json({ success: true, data: projects })
-  } catch {
-    return NextResponse.json(
-      { success: false, error: 'Failed to list projects' },
-      { status: 500 }
-    )
-  }
-}

package/packages/web/app/api/sessions/current/route.ts

@@ -1,132 +0,0 @@
-import { NextResponse } from 'next/server'
-import { promises as fs } from 'fs'
-import { join } from 'path'
-import { homedir } from 'os'
-
-export const dynamic = 'force-dynamic'
-
-interface Session {
-  id: string
-  projectId?: string
-  task: string
-  status: string
-  startedAt: string
-  timeline?: Array<{ type: string; at: string }>
-  context?: {
-    prompt?: string
-    promptLength?: number
-    files?: string[]
-  }
-}
-
-interface AbandonedSession {
-  id: string
-  task: string
-  projectId: string
-  projectName?: string
-  startedAt: string
-  lastActivity?: string
-  hoursAgo: number
-  prompt?: string
-}
-
-export async function GET(request: Request) {
-  try {
-    const { searchParams } = new URL(request.url)
-    const targetProjectId = searchParams.get('projectId')
-
-    const globalStorage = join(homedir(), '.prjct-cli', 'projects')
-
-    let projects: string[]
-    try {
-      projects = await fs.readdir(globalStorage)
-    } catch {
-      return NextResponse.json({
-        success: true,
-        data: {
-          currentSession: null,
-          abandonedSessions: []
-        }
-      })
-    }
-
-    const abandonedSessions: AbandonedSession[] = []
-    let currentSession: Session | null = null
-
-    const now = Date.now()
-    const ABANDON_THRESHOLD_HOURS = 8
-
-    for (const projectId of projects) {
-      // Skip hidden directories
-      if (projectId.startsWith('.')) continue
-
-      const sessionPath = join(globalStorage, projectId, 'sessions', 'current.json')
-
-      try {
-        const content = await fs.readFile(sessionPath, 'utf-8')
-        if (!content.trim()) continue
-
-        const session: Session = JSON.parse(content)
-
-        // Skip if not active
-        if (session.status !== 'active') continue
-
-        // Get last activity timestamp
-        const lastActivity = session.timeline?.[session.timeline.length - 1]?.at || session.startedAt
-        const lastActivityDate = new Date(lastActivity)
-        if (isNaN(lastActivityDate.getTime())) continue
-
-        const hoursAgo = (now - lastActivityDate.getTime()) / (1000 * 60 * 60)
-
-        // If this is the target project and session is recent, it's the current session
-        if (projectId === targetProjectId && hoursAgo < ABANDON_THRESHOLD_HOURS) {
-          currentSession = session
-        }
-        // If session is old (>8 hours), it's considered abandoned
-        // Only show abandoned sessions for the target project
-        else if (hoursAgo >= ABANDON_THRESHOLD_HOURS && projectId === targetProjectId) {
-          // Try to get project name from project.json
-          let projectName: string | undefined
-          try {
-            const projectJsonPath = join(globalStorage, projectId, 'project.json')
-            const projectJson = await fs.readFile(projectJsonPath, 'utf-8')
-            const projectData = JSON.parse(projectJson)
-            projectName = projectData.name
-          } catch {
-            // Ignore - project name is optional
-          }
-
-          abandonedSessions.push({
-            id: session.id,
-            task: session.task,
-            projectId,
-            projectName,
-            startedAt: session.startedAt,
-            lastActivity,
-            hoursAgo: Math.round(hoursAgo),
-            prompt: session.context?.prompt
-          })
-        }
-      } catch {
-        // Skip projects without valid session files
-      }
-    }
-
-    // Sort abandoned sessions by most recent first
-    abandonedSessions.sort((a, b) => a.hoursAgo - b.hoursAgo)
-
-    return NextResponse.json({
-      success: true,
-      data: {
-        currentSession,
-        abandonedSessions
-      }
-    })
-  } catch (error) {
-    console.error('Sessions current error:', error)
-    return NextResponse.json(
-      { success: false, error: 'Failed to fetch sessions' },
-      { status: 500 }
-    )
-  }
-}

package/packages/web/app/api/sessions/history/route.ts

@@ -1,204 +0,0 @@
-import { NextResponse } from 'next/server'
-import { promises as fs } from 'fs'
-import { join } from 'path'
-import { homedir } from 'os'
-
-export const dynamic = 'force-dynamic'
-
-interface SessionEvent {
-  ts?: string
-  timestamp?: string
-  type?: string
-  action?: string
-}
-
-interface DailyStats {
-  date: string
-  tasks: number
-  ships: number
-  partial: number
-}
-
-export async function GET() {
-  try {
-    const globalStorage = join(homedir(), '.prjct-cli', 'projects')
-
-    let projects: string[]
-    try {
-      projects = await fs.readdir(globalStorage)
-    } catch {
-      return NextResponse.json({
-        success: true,
-        data: {
-          chartData: [],
-          totals: { tasks: 0, ships: 0 },
-          dateRange: { start: '', end: '' }
-        }
-      })
-    }
-
-    // Aggregate by date
-    const dailyMap = new Map<string, { tasks: number; ships: number; partial: number }>()
-
-    // Calculate date range (last 30 days)
-    const endDate = new Date()
-    const startDate = new Date()
-    startDate.setDate(startDate.getDate() - 30)
-
-    for (const projectId of projects) {
-      // Skip hidden directories
-      if (projectId.startsWith('.')) continue
-
-      // Read from memory/context.jsonl (legacy)
-      const contextPath = join(globalStorage, projectId, 'memory', 'context.jsonl')
-      try {
-        const content = await fs.readFile(contextPath, 'utf-8')
-        const lines = content.trim().split('\n').filter(Boolean)
-
-        for (const line of lines) {
-          try {
-            const event: SessionEvent = JSON.parse(line)
-            const timestamp = event.ts || event.timestamp
-            if (!timestamp) continue
-
-            const eventDate = new Date(timestamp)
-            if (isNaN(eventDate.getTime())) continue
-            if (eventDate < startDate || eventDate > endDate) continue
-
-            const dateKey = eventDate.toISOString().split('T')[0]
-            const current = dailyMap.get(dateKey) || { tasks: 0, ships: 0, partial: 0 }
-
-            const eventType = event.type || event.action
-
-            // Count tasks completed
-            if (eventType === 'task_complete' || eventType === 'task_completed' || eventType === 'session_completed') {
-              current.tasks++
-            }
-
-            // Count features shipped
-            if (eventType === 'feature_ship' || eventType === 'feature_shipped') {
-              current.ships++
-            }
-
-            // Count partial/abandoned sessions
-            if (eventType === 'session_partial' || eventType === 'session_abandoned') {
-              current.partial++
-            }
-
-            dailyMap.set(dateKey, current)
-          } catch {
-            // Skip malformed lines
-          }
-        }
-      } catch {
-        // Skip projects without context.jsonl
-      }
-
-      // Read from progress/sessions/{YYYY-MM}/{date}.jsonl (new format)
-      const sessionsDir = join(globalStorage, projectId, 'progress', 'sessions')
-      try {
-        const monthDirs = await fs.readdir(sessionsDir)
-        for (const monthDir of monthDirs) {
-          // Skip non-directory entries
-          if (!monthDir.match(/^\d{4}-\d{2}$/)) continue
-
-          const monthPath = join(sessionsDir, monthDir)
-          try {
-            const dayFiles = await fs.readdir(monthPath)
-            for (const dayFile of dayFiles) {
-              if (!dayFile.endsWith('.jsonl')) continue
-
-              const dayPath = join(monthPath, dayFile)
-              try {
-                const content = await fs.readFile(dayPath, 'utf-8')
-                const lines = content.trim().split('\n').filter(Boolean)
-
-                for (const line of lines) {
-                  try {
-                    const event: SessionEvent = JSON.parse(line)
-                    const timestamp = event.ts || event.timestamp
-                    if (!timestamp) continue
-
-                    const eventDate = new Date(timestamp)
-                    if (isNaN(eventDate.getTime())) continue
-                    if (eventDate < startDate || eventDate > endDate) continue
-
-                    const dateKey = eventDate.toISOString().split('T')[0]
-                    const current = dailyMap.get(dateKey) || { tasks: 0, ships: 0, partial: 0 }
-
-                    const eventType = event.type || event.action
-
-                    // Count tasks completed
-                    if (eventType === 'task_complete' || eventType === 'task_completed') {
-                      current.tasks++
-                    }
-
-                    // Count features shipped
-                    if (eventType === 'feature_ship' || eventType === 'feature_shipped') {
-                      current.ships++
-                    }
-
-                    // Count partial/abandoned sessions
-                    if (eventType === 'session_partial' || eventType === 'session_abandoned') {
-                      current.partial++
-                    }
-
-                    dailyMap.set(dateKey, current)
-                  } catch {
-                    // Skip malformed lines
-                  }
-                }
-              } catch {
-                // Skip unreadable files
-              }
-            }
-          } catch {
-            // Skip unreadable month directories
-          }
-        }
-      } catch {
-        // Skip projects without sessions directory
-      }
-    }
-
-    // Generate all dates in range (90 days), filling gaps with zeros
-    const data: DailyStats[] = []
-    const currentDate = new Date(startDate)
-    while (currentDate <= endDate) {
-      const dateKey = currentDate.toISOString().split('T')[0]
-      const stats = dailyMap.get(dateKey) || { tasks: 0, ships: 0, partial: 0 }
-      data.push({
-        date: dateKey,
-        tasks: stats.tasks,
-        ships: stats.ships,
-        partial: stats.partial
-      })
-      currentDate.setDate(currentDate.getDate() + 1)
-    }
-
-    // Calculate totals for summary
-    const totals = {
-      tasks: data.reduce((sum, d) => sum + d.tasks, 0),
-      ships: data.reduce((sum, d) => sum + d.ships, 0),
-      partial: data.reduce((sum, d) => sum + d.partial, 0)
-    }
-
-    return NextResponse.json({
-      success: true,
-      data: {
-        chartData: data,
-        totals,
-        dateRange: {
-          start: startDate.toISOString().split('T')[0],
-          end: endDate.toISOString().split('T')[0]
-        }
-      }
-    })
-  } catch (error) {
-    console.error('Sessions history error:', error)
-    return NextResponse.json(
-      { success: false, error: 'Failed to fetch session history' },
-      { status: 500 }
-    )
-  }
-}