prjct-cli 0.13.3 → 0.15.0

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

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

@@ -16,6 +16,7 @@ interface DailyStats {
   date: string
   tasks: number
   ships: number
+  partial: number
 }
 
 export async function GET() {
@@ -37,16 +38,19 @@ export async function GET() {
     }
 
     // Aggregate by date
-    const dailyMap = new Map<string, { tasks: number; ships: number }>()
+    const dailyMap = new Map<string, { tasks: number; ships: number; partial: number }>()
 
-    // Calculate date range (last 90 days)
+    // Calculate date range (last 30 days)
     const endDate = new Date()
     const startDate = new Date()
-    startDate.setDate(startDate.getDate() - 90)
+    startDate.setDate(startDate.getDate() - 30)
 
     for (const projectId of projects) {
-      const contextPath = join(globalStorage, projectId, 'memory', 'context.jsonl')
+      // 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)
@@ -62,12 +66,12 @@ export async function GET() {
             if (eventDate < startDate || eventDate > endDate) continue
 
             const dateKey = eventDate.toISOString().split('T')[0]
-            const current = dailyMap.get(dateKey) || { tasks: 0, ships: 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') {
+            if (eventType === 'task_complete' || eventType === 'task_completed' || eventType === 'session_completed') {
               current.tasks++
             }
 
@@ -76,6 +80,11 @@ export async function GET() {
               current.ships++
             }
 
+            // Count partial/abandoned sessions
+            if (eventType === 'session_partial' || eventType === 'session_abandoned') {
+              current.partial++
+            }
+
             dailyMap.set(dateKey, current)
           } catch {
             // Skip malformed lines
@@ -84,21 +93,94 @@ export async function GET() {
       } 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
+      }
     }
 
-    // Convert to sorted array
-    const data: DailyStats[] = Array.from(dailyMap.entries())
-      .map(([date, stats]) => ({
-        date,
+    // 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
-      }))
-      .sort((a, b) => a.date.localeCompare(b.date))
+        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)
+      ships: data.reduce((sum, d) => sum + d.ships, 0),
+      partial: data.reduce((sum, d) => sum + d.partial, 0)
     }
 
     return NextResponse.json({

package/packages/web/app/globals.css

@@ -117,6 +117,11 @@
   * {
     @apply border-border outline-ring/50;
   }
+  html,
+  body {
+    overflow-x: hidden;
+    max-width: 100vw;
+  }
   body {
     @apply bg-background text-foreground;
     /* Prevent pull-to-refresh on mobile */

package/packages/web/app/layout.tsx

@@ -3,6 +3,7 @@ import { Geist, Geist_Mono } from 'next/font/google'
 import './globals.css'
 import { Providers } from '@/components/Providers'
 import { AppSidebar } from '@/components/AppSidebar'
+import { TerminalDock } from '@/components/TerminalDock'
 
 const geistSans = Geist({
   variable: '--font-geist-sans',
@@ -44,6 +45,7 @@ export default function RootLayout({
               {children}
             </main>
           </div>
+          <TerminalDock />
         </Providers>
       </body>
     </html>

package/packages/web/app/project/[id]/code/layout.tsx

@@ -0,0 +1,18 @@
+import type { Metadata } from 'next'
+import { getProject } from '@/lib/services/projects.server'
+import { getProjectEmoji } from '@/lib/project-colors'
+
+export async function generateMetadata({ params }: { params: Promise<{ id: string }> }): Promise<Metadata> {
+  const { id: projectId } = await params
+  const project = await getProject(projectId)
+  const projectName = project?.name ?? projectId
+  const emoji = getProjectEmoji(projectId)
+
+  return {
+    title: `${emoji} ${projectName} / Code / p.`,
+  }
+}
+
+export default function CodeLayout({ children }: { children: React.ReactNode }) {
+  return children
+}