prjct-cli 0.13.3 → 0.15.1

package/core/storage/state-storage.ts

@@ -0,0 +1,235 @@
+/**
+ * State Storage
+ *
+ * Manages current task state via storage/state.json
+ * Generates context/now.md for Claude
+ */
+
+import { StorageManager } from './storage-manager'
+import { generateUUID } from '../schemas'
+import type { StateJson, CurrentTask, PreviousTask } from '../schemas/state'
+
+class StateStorage extends StorageManager<StateJson> {
+  constructor() {
+    super('state.json')
+  }
+
+  protected getDefault(): StateJson {
+    return {
+      currentTask: null,
+      previousTask: null,
+      lastUpdated: ''
+    }
+  }
+
+  protected getMdFilename(): string {
+    return 'now.md'
+  }
+
+  protected getEventType(action: 'update' | 'create' | 'delete'): string {
+    return `state.${action}d`
+  }
+
+  protected toMarkdown(data: StateJson): string {
+    const lines = ['# NOW', '']
+
+    // Show current task if exists
+    if (data.currentTask) {
+      const task = data.currentTask
+      lines.push(`**${task.description}**`)
+      lines.push('')
+      lines.push(`Started: ${task.startedAt}`)
+      lines.push(`Session: ${task.sessionId}`)
+      if (task.featureId) {
+        lines.push(`Feature: ${task.featureId}`)
+      }
+    } else {
+      lines.push('*No active task. Use /p:work to start.*')
+    }
+
+    // Show paused task section if exists
+    if (data.previousTask) {
+      lines.push('')
+      lines.push('---')
+      lines.push('')
+      lines.push('## Paused')
+      lines.push('')
+      lines.push(`**${data.previousTask.description}**`)
+      lines.push(`Paused: ${data.previousTask.pausedAt}`)
+      if (data.previousTask.pauseReason) {
+        lines.push(`Reason: ${data.previousTask.pauseReason}`)
+      }
+      lines.push('')
+      lines.push('*Use /p:resume to continue*')
+    }
+
+    lines.push('')
+    return lines.join('\n')
+  }
+
+  // =========== Domain Methods ===========
+
+  /**
+   * Get current active task
+   */
+  async getCurrentTask(projectId: string): Promise<CurrentTask | null> {
+    const state = await this.read(projectId)
+    return state.currentTask
+  }
+
+  /**
+   * Start a new task
+   */
+  async startTask(
+    projectId: string,
+    task: Omit<CurrentTask, 'startedAt'>
+  ): Promise<CurrentTask> {
+    const currentTask: CurrentTask = {
+      ...task,
+      startedAt: new Date().toISOString()
+    }
+
+    await this.update(projectId, (state) => ({
+      ...state,
+      currentTask,
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish incremental event
+    await this.publishEvent(projectId, 'task.started', {
+      taskId: currentTask.id,
+      description: currentTask.description,
+      startedAt: currentTask.startedAt,
+      sessionId: currentTask.sessionId
+    })
+
+    return currentTask
+  }
+
+  /**
+   * Complete current task
+   */
+  async completeTask(projectId: string): Promise<CurrentTask | null> {
+    const state = await this.read(projectId)
+    const completedTask = state.currentTask
+
+    if (!completedTask) {
+      return null
+    }
+
+    await this.update(projectId, () => ({
+      currentTask: null,
+      previousTask: null,
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish incremental event
+    await this.publishEvent(projectId, 'task.completed', {
+      taskId: completedTask.id,
+      description: completedTask.description,
+      startedAt: completedTask.startedAt,
+      completedAt: new Date().toISOString()
+    })
+
+    return completedTask
+  }
+
+  /**
+   * Pause current task
+   */
+  async pauseTask(projectId: string, reason?: string): Promise<PreviousTask | null> {
+    const state = await this.read(projectId)
+
+    if (!state.currentTask) {
+      return null
+    }
+
+    const previousTask: PreviousTask = {
+      id: state.currentTask.id,
+      description: state.currentTask.description,
+      status: 'paused',
+      startedAt: state.currentTask.startedAt,
+      pausedAt: new Date().toISOString(),
+      pauseReason: reason
+    }
+
+    await this.update(projectId, () => ({
+      currentTask: null,
+      previousTask,
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish incremental event
+    await this.publishEvent(projectId, 'task.paused', {
+      taskId: previousTask.id,
+      description: previousTask.description,
+      pausedAt: previousTask.pausedAt,
+      reason
+    })
+
+    return previousTask
+  }
+
+  /**
+   * Resume paused task
+   */
+  async resumeTask(projectId: string): Promise<CurrentTask | null> {
+    const state = await this.read(projectId)
+
+    if (!state.previousTask) {
+      return null
+    }
+
+    const currentTask: CurrentTask = {
+      id: state.previousTask.id,
+      description: state.previousTask.description,
+      startedAt: new Date().toISOString(),
+      sessionId: generateUUID()
+    }
+
+    await this.update(projectId, () => ({
+      currentTask,
+      previousTask: null,
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish incremental event
+    await this.publishEvent(projectId, 'task.resumed', {
+      taskId: currentTask.id,
+      description: currentTask.description,
+      resumedAt: currentTask.startedAt
+    })
+
+    return currentTask
+  }
+
+  /**
+   * Clear all task state
+   */
+  async clearTask(projectId: string): Promise<void> {
+    await this.update(projectId, () => ({
+      currentTask: null,
+      previousTask: null,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Check if there's an active or paused task
+   */
+  async hasTask(projectId: string): Promise<boolean> {
+    const state = await this.read(projectId)
+    return state.currentTask !== null || state.previousTask !== null
+  }
+
+  /**
+   * Get paused task
+   */
+  async getPausedTask(projectId: string): Promise<PreviousTask | null> {
+    const state = await this.read(projectId)
+    return state.previousTask || null
+  }
+}
+
+export const stateStorage = new StateStorage()
+export default stateStorage

package/core/storage/storage-manager.ts

@@ -0,0 +1,175 @@
+/**
+ * Storage Manager Base Class
+ *
+ * Write-through pattern:
+ * 1. Write JSON to storage/
+ * 2. Regenerate MD in context/
+ * 3. Publish event for backend sync
+ *
+ * Subclasses implement specific data types (state, queue, ideas, shipped).
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { eventBus, type SyncEvent } from '../events'
+
+export abstract class StorageManager<T> {
+  protected filename: string
+  protected cache: Map<string, T> = new Map()
+  protected cacheTimeout = 5000 // 5 seconds
+
+  constructor(filename: string) {
+    this.filename = filename
+  }
+
+  /**
+   * Get file path for storage JSON
+   */
+  protected getStoragePath(projectId: string): string {
+    return path.join(
+      os.homedir(),
+      '.prjct-cli/projects',
+      projectId,
+      'storage',
+      this.filename
+    )
+  }
+
+  /**
+   * Get file path for context MD
+   */
+  protected getContextPath(projectId: string, mdFilename: string): string {
+    return path.join(
+      os.homedir(),
+      '.prjct-cli/projects',
+      projectId,
+      'context',
+      mdFilename
+    )
+  }
+
+  /**
+   * Get default data structure
+   */
+  protected abstract getDefault(): T
+
+  /**
+   * Convert data to markdown for Claude
+   */
+  protected abstract toMarkdown(data: T): string
+
+  /**
+   * Get MD filename for context generation
+   */
+  protected abstract getMdFilename(): string
+
+  /**
+   * Get event type for sync
+   */
+  protected abstract getEventType(action: 'update' | 'create' | 'delete'): string
+
+  /**
+   * Read data from storage
+   */
+  async read(projectId: string): Promise<T> {
+    // Check cache first
+    const cached = this.cache.get(projectId)
+    if (cached) {
+      return cached
+    }
+
+    const filePath = this.getStoragePath(projectId)
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8')
+      const data = JSON.parse(content) as T
+      this.cache.set(projectId, data)
+      return data
+    } catch {
+      // Return default if file doesn't exist
+      return this.getDefault()
+    }
+  }
+
+  /**
+   * Write data to storage + regenerate context + publish event
+   */
+  async write(projectId: string, data: T): Promise<void> {
+    const storagePath = this.getStoragePath(projectId)
+    const contextPath = this.getContextPath(projectId, this.getMdFilename())
+
+    // Ensure directories exist
+    await fs.mkdir(path.dirname(storagePath), { recursive: true })
+    await fs.mkdir(path.dirname(contextPath), { recursive: true })
+
+    // 1. Write JSON (atomic via temp file)
+    const tempPath = `${storagePath}.${Date.now()}.tmp`
+    await fs.writeFile(tempPath, JSON.stringify(data, null, 2), 'utf-8')
+    await fs.rename(tempPath, storagePath)
+
+    // 2. Regenerate MD for Claude
+    const md = this.toMarkdown(data)
+    await fs.writeFile(contextPath, md, 'utf-8')
+
+    // 3. Update cache
+    this.cache.set(projectId, data)
+
+    // 4. Publish event for backend sync (NOT included in this call - subclass handles)
+  }
+
+  /**
+   * Update data with a transform function
+   */
+  async update(projectId: string, updater: (current: T) => T): Promise<T> {
+    const current = await this.read(projectId)
+    const updated = updater(current)
+    await this.write(projectId, updated)
+    return updated
+  }
+
+  /**
+   * Publish sync event to eventBus
+   */
+  protected async publishEvent(
+    projectId: string,
+    eventType: string,
+    eventData: unknown
+  ): Promise<void> {
+    const event: SyncEvent = {
+      type: eventType,
+      path: [this.filename.replace('.json', '')],
+      data: eventData,
+      timestamp: new Date().toISOString(),
+      projectId
+    }
+
+    await eventBus.publish(event)
+  }
+
+  /**
+   * Check if storage file exists
+   */
+  async exists(projectId: string): Promise<boolean> {
+    const filePath = this.getStoragePath(projectId)
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Clear cache for a project
+   */
+  clearCache(projectId?: string): void {
+    if (projectId) {
+      this.cache.delete(projectId)
+    } else {
+      this.cache.clear()
+    }
+  }
+}
+
+export default StorageManager

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.13.3",
+  "version": "0.15.1",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {

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

@@ -0,0 +1,257 @@
+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 }
+    )
+  }
+}