prjct-cli 0.11.5 → 0.12.1

package/packages/web/lib/services/stats.server.ts

@@ -0,0 +1,264 @@
+/**
+ * Stats Service (Server-only)
+ *
+ * Direct data access for Server Components.
+ * No API calls needed - reads directly from filesystem.
+ */
+
+import 'server-only'
+import { cache } from 'react'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import {
+  loadUnifiedJsonData,
+  hasJsonState,
+  type UnifiedJsonData,
+  type StateJson,
+  type QueueJson,
+  type MetricsJson,
+  type ProjectInsights,
+} from '@/lib/json-loader'
+import { getProjectStats as getLegacyStats, type ProjectStats } from '@/lib/parse-prjct-files'
+import { getProjects } from './projects.server'
+
+export type { UnifiedJsonData, StateJson, QueueJson, MetricsJson, ProjectInsights }
+
+// Activity type for recent activity tracking
+export interface RecentActivity {
+  timestamp: string
+  type: string
+  description?: string
+  duration?: string
+}
+
+const execAsync = promisify(exec)
+
+/**
+ * Global stats for dashboard (userName, totalProjects)
+ */
+export interface GlobalStats {
+  userName: string
+  totalProjects: number
+}
+
+async function getGitUserName(): Promise<string> {
+  try {
+    const { stdout } = await execAsync('git config user.name')
+    return stdout.trim() || 'Developer'
+  } catch {
+    return 'Developer'
+  }
+}
+
+/**
+ * Get global stats for dashboard - cached per request
+ */
+export const getGlobalStats = cache(async (): Promise<GlobalStats> => {
+  const [projects, userName] = await Promise.all([
+    getProjects(),
+    getGitUserName()
+  ])
+
+  return {
+    userName,
+    totalProjects: projects.length
+  }
+})
+
+/**
+ * Unified stats result that works with both JSON and legacy formats
+ */
+export interface StatsResult {
+  state: StateJson | null
+  queue: QueueJson | null
+  metrics: MetricsJson | null
+  insights: ProjectInsights
+  agents: UnifiedJsonData['agents']
+  ideas: UnifiedJsonData['ideas']
+  roadmap: UnifiedJsonData['roadmap']
+  shipped: UnifiedJsonData['shipped']
+  outcomes: UnifiedJsonData['outcomes']
+  hasData: boolean
+  isLegacy: boolean
+  legacyStats?: ProjectStats
+}
+
+const DEFAULT_INSIGHTS: ProjectInsights = {
+  healthScore: 0,
+  estimateAccuracy: 0,
+  topBlockers: [],
+  patternsDetected: [],
+  recommendations: ['Run /p:sync to initialize project']
+}
+
+const EMPTY_STATS_RESULT: StatsResult = {
+  state: null,
+  queue: null,
+  metrics: null,
+  insights: DEFAULT_INSIGHTS,
+  agents: [],
+  ideas: null,
+  roadmap: null,
+  shipped: null,
+  outcomes: [],
+  hasData: false,
+  isLegacy: false
+}
+
+/**
+ * Get project stats - cached per request
+ */
+export const getStats = cache(async (projectId: string): Promise<StatsResult> => {
+  const hasJson = await hasJsonState(projectId)
+
+  if (hasJson) {
+    const jsonData = await loadUnifiedJsonData(projectId)
+    return {
+      state: jsonData.state,
+      queue: jsonData.queue,
+      metrics: jsonData.metrics,
+      insights: jsonData.insights,
+      agents: jsonData.agents,
+      ideas: jsonData.ideas,
+      roadmap: jsonData.roadmap,
+      shipped: jsonData.shipped,
+      outcomes: jsonData.outcomes,
+      hasData: jsonData.hasJsonData,
+      isLegacy: false
+    }
+  }
+
+  // Fallback to legacy markdown parsing
+  try {
+    const legacyStats = await getLegacyStats(projectId)
+    return {
+      ...EMPTY_STATS_RESULT,
+      insights: {
+        ...DEFAULT_INSIGHTS,
+        healthScore: 50,
+        recommendations: ['Run /p:sync to enable JSON format']
+      },
+      hasData: true,
+      isLegacy: true,
+      legacyStats
+    }
+  } catch {
+    return EMPTY_STATS_RESULT
+  }
+})
+
+/**
+ * Calculate streak from metrics (pure function, no mutation)
+ */
+export function calculateStreak(metrics: MetricsJson | null): number {
+  if (!metrics?.recentActivity?.length) return 0
+
+  const activityDates = new Set(
+    metrics.recentActivity.map((a: { timestamp: string }) => new Date(a.timestamp).toISOString().split('T')[0])
+  )
+
+  const today = new Date()
+  today.setHours(0, 0, 0, 0)
+
+  // Generate last 30 days as array
+  const days = Array.from({ length: 30 }, (_, i) => {
+    const date = new Date(today)
+    date.setDate(date.getDate() - i)
+    return date.toISOString().split('T')[0]
+  })
+
+  // Find first gap (day without activity)
+  const firstGapIndex = days.findIndex(date => !activityDates.has(date))
+
+  // If today has no activity, check if yesterday does
+  if (firstGapIndex === 0) {
+    const yesterdayHasActivity = activityDates.has(days[1])
+    if (!yesterdayHasActivity) return 0
+    // Start counting from yesterday
+    const remainingDays = days.slice(1)
+    const gapFromYesterday = remainingDays.findIndex(date => !activityDates.has(date))
+    return gapFromYesterday === -1 ? remainingDays.length : gapFromYesterday
+  }
+
+  return firstGapIndex === -1 ? days.length : firstGapIndex
+}
+
+/**
+ * Get health emoji based on score
+ */
+export function getHealthEmoji(score: number): string {
+  if (score >= 80) return '🔥'
+  if (score >= 60) return '💪'
+  if (score >= 40) return '👍'
+  if (score >= 20) return '🌱'
+  return '💤'
+}
+
+/**
+ * Get insight message based on stats
+ */
+export function getInsightMessage(stats: StatsResult, streak: number): string {
+  if (!stats.hasData) return 'Run /p:sync to get started'
+  if (stats.state?.currentTask) return `Working on: ${stats.state.currentTask.description}`
+  if (streak >= 7) return `${streak} day streak! You're on fire! 🔥`
+  if (streak >= 3) return `${streak} day streak - keep it going!`
+
+  const queueLength = stats.queue?.tasks?.filter(t => !t.completed).length ?? 0
+  if (queueLength > 0) return `${queueLength} tasks in queue`
+  return 'Ready to start working'
+}
+
+/**
+ * Calculate velocity change percentage
+ */
+export function getVelocityChange(velocity: number): number {
+  if (velocity > 2) return 15
+  if (velocity > 1) return 5
+  if (velocity > 0) return 0
+  return -10
+}
+
+/**
+ * Get weekly velocity data from metrics (last 7 days)
+ */
+export function getWeeklyVelocityData(metrics: MetricsJson | null): number[] {
+  if (!metrics?.recentActivity?.length) return []
+
+  const today = new Date()
+
+  return Array.from({ length: 7 }, (_, i) => {
+    const date = new Date(today)
+    date.setDate(date.getDate() - (6 - i))
+    const dateStr = date.toISOString().split('T')[0]
+
+    return metrics.recentActivity.filter((e: { timestamp: string }) =>
+      e.timestamp?.startsWith(dateStr)
+    ).length
+  })
+}
+
+/**
+ * Calculate health score from stats
+ */
+export function calculateHealthScore(stats: StatsResult): number {
+  if (!stats.hasData) return 0
+  if (stats.insights.healthScore > 0) return stats.insights.healthScore
+
+  // Fallback for legacy
+  if (stats.isLegacy && stats.legacyStats) {
+    const { metrics, currentTask, queue, timeline } = stats.legacyStats
+    const velocity = metrics?.velocity?.tasksPerDay ?? 0
+    const hasCurrentTask = Boolean(currentTask)
+    const queueSize = queue?.length ?? 0
+    const recentActivity = timeline?.slice(0, 7).length ?? 0
+
+    const velocityScore = Math.min(30, velocity * 15)
+    const taskScore = hasCurrentTask ? 20 : 0
+    const queueScore = queueSize > 0 && queueSize < 15 ? 20 : queueSize === 0 ? 5 : 10
+    const activityScore = Math.min(30, recentActivity * 5)
+
+    return Math.min(100, Math.round(velocityScore + taskScore + queueScore + activityScore))
+  }
+
+  return 50
+}

package/packages/web/lib/unified-loader.ts

@@ -0,0 +1,396 @@
+/**
+ * Unified Loader
+ *
+ * Loads project data from the new unified state modules.
+ * Provides faster access than parsing markdown files.
+ */
+
+import { promises as fs } from 'fs'
+import { join } from 'path'
+import { homedir } from 'os'
+
+const GLOBAL_STORAGE = join(homedir(), '.prjct-cli', 'projects')
+
+/**
+ * Project state from state.json
+ */
+export interface ProjectState {
+  projectId: string
+  currentTask: CurrentTask | null
+  queue: QueuedTask[]
+  activeFeature: ActiveFeature | null
+  stats: PerformanceStats
+  recentActivity: RecentActivity[]
+  lastSync: string
+  version: number
+}
+
+export interface CurrentTask {
+  id: string
+  description: string
+  startedAt: string
+  agent?: string
+  agentConfidence?: number
+  estimatedDuration?: string
+  featureId?: string
+  pausedAt?: string
+  pauseReason?: string
+}
+
+export interface QueuedTask {
+  id: string
+  description: string
+  priority: 'low' | 'medium' | 'high' | 'critical'
+  featureId?: string
+  estimatedDuration?: string
+  tags?: string[]
+  createdAt: string
+  blockedReason?: string
+}
+
+export interface ActiveFeature {
+  id: string
+  name: string
+  status: 'planned' | 'in_progress' | 'completed' | 'shipped'
+  tasksCompleted: number
+  tasksRemaining: number
+  estimatedEffort?: string
+  actualEffort?: string
+  startedAt: string
+}
+
+export interface PerformanceStats {
+  tasksToday: number
+  tasksThisWeek: number
+  avgDuration: string
+  velocity: string
+  estimateAccuracy: number
+  streak: number
+}
+
+export interface RecentActivity {
+  type: 'task_completed' | 'feature_shipped' | 'idea_captured' | 'session_started'
+  description: string
+  timestamp: string
+  duration?: string
+}
+
+/**
+ * Outcome summary from analyzer
+ */
+export interface OutcomeSummary {
+  totalOutcomes: number
+  avgQualityScore: number
+  estimateAccuracy: number
+  topBlockers: string[]
+  topAgents: string[]
+  patternsDetected: string[]
+}
+
+/**
+ * Agent performance data
+ */
+export interface AgentPerformance {
+  agentName: string
+  taskType: string
+  tasksCompleted: number
+  successRate: number
+  avgDuration: string
+  estimateAccuracy: number
+  improving: boolean
+  lastUpdated: string
+  bestFor: string[]
+  avoidFor: string[]
+}
+
+/**
+ * Insights computed from all data
+ */
+export interface ProjectInsights {
+  healthScore: number
+  estimateAccuracy: number
+  topBlockers: string[]
+  patternsDetected: string[]
+  recommendations: string[]
+}
+
+/**
+ * Unified response combining all data
+ */
+export interface UnifiedProjectData {
+  state: ProjectState | null
+  outcomes: OutcomeSummary | null
+  agentPerformance: AgentPerformance[]
+  insights: ProjectInsights
+  // Legacy fallback data
+  legacyFallback: boolean
+}
+
+const DEFAULT_STATE: ProjectState = {
+  projectId: '',
+  currentTask: null,
+  queue: [],
+  activeFeature: null,
+  stats: {
+    tasksToday: 0,
+    tasksThisWeek: 0,
+    avgDuration: '0h',
+    velocity: '0',
+    estimateAccuracy: 0,
+    streak: 0,
+  },
+  recentActivity: [],
+  lastSync: new Date().toISOString(),
+  version: 1,
+}
+
+/**
+ * Read state.json for a project
+ */
+async function readState(projectId: string): Promise<ProjectState | null> {
+  const statePath = join(GLOBAL_STORAGE, projectId, 'core', 'state.json')
+  try {
+    const content = await fs.readFile(statePath, 'utf-8')
+    return JSON.parse(content) as ProjectState
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Read outcomes summary
+ */
+async function readOutcomes(projectId: string): Promise<OutcomeSummary | null> {
+  const outcomesPath = join(GLOBAL_STORAGE, projectId, 'outcomes', 'outcomes.jsonl')
+  try {
+    const content = await fs.readFile(outcomesPath, 'utf-8')
+    const outcomes = content
+      .trim()
+      .split('\n')
+      .filter(line => line.trim())
+      .map(line => JSON.parse(line))
+
+    if (outcomes.length === 0) return null
+
+    // Calculate summary
+    const avgQuality = outcomes.reduce((sum: number, o: { qualityScore: number }) =>
+      sum + o.qualityScore, 0) / outcomes.length
+
+    // Count accurate estimates (within 20%)
+    const accurateCount = outcomes.filter((o: { variance: string; estimatedDuration: string }) => {
+      if (!o.variance) return false
+      const variance = parseVariance(o.variance)
+      const estimated = parseDuration(o.estimatedDuration)
+      if (estimated === 0) return false
+      return Math.abs(variance) / estimated <= 0.2
+    }).length
+
+    // Count blockers
+    const blockerCounts = new Map<string, number>()
+    for (const outcome of outcomes) {
+      for (const blocker of outcome.blockers || []) {
+        blockerCounts.set(blocker, (blockerCounts.get(blocker) || 0) + 1)
+      }
+    }
+    const topBlockers = [...blockerCounts.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 5)
+      .map(([blocker]) => blocker)
+
+    // Count agents
+    const agentCounts = new Map<string, number>()
+    for (const outcome of outcomes) {
+      if (outcome.agentUsed) {
+        agentCounts.set(outcome.agentUsed, (agentCounts.get(outcome.agentUsed) || 0) + 1)
+      }
+    }
+    const topAgents = [...agentCounts.entries()]
+      .sort((a, b) => b[1] - a[1])
+      .slice(0, 3)
+      .map(([agent]) => agent)
+
+    // Detect patterns
+    const patterns: string[] = []
+    const underestimated = outcomes.filter((o: { variance: string }) => {
+      const variance = parseVariance(o.variance)
+      return variance > 0
+    })
+    if (underestimated.length / outcomes.length > 0.6) {
+      patterns.push('Tasks consistently take longer than estimated')
+    }
+
+    return {
+      totalOutcomes: outcomes.length,
+      avgQualityScore: Math.round(avgQuality * 10) / 10,
+      estimateAccuracy: Math.round((accurateCount / outcomes.length) * 100),
+      topBlockers,
+      topAgents,
+      patternsDetected: patterns,
+    }
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Read agent performance data
+ */
+async function readAgentPerformance(projectId: string): Promise<AgentPerformance[]> {
+  const perfPath = join(GLOBAL_STORAGE, projectId, 'analysis', 'agent-performance.json')
+  try {
+    const content = await fs.readFile(perfPath, 'utf-8')
+    const data = JSON.parse(content)
+    return data.agents || []
+  } catch {
+    return []
+  }
+}
+
+/**
+ * Compute insights from all data
+ */
+function computeInsights(
+  state: ProjectState | null,
+  outcomes: OutcomeSummary | null,
+  agentPerformance: AgentPerformance[]
+): ProjectInsights {
+  let healthScore = 50 // Base score
+
+  // Adjust for state
+  if (state) {
+    // Has current task = +10
+    if (state.currentTask) healthScore += 10
+
+    // Velocity bonus (max +20)
+    const velocity = parseFloat(state.stats.velocity) || 0
+    healthScore += Math.min(20, velocity * 5)
+
+    // Streak bonus (max +15)
+    healthScore += Math.min(15, state.stats.streak * 3)
+
+    // Queue size penalty (too many = -5)
+    if (state.queue.length > 15) healthScore -= 5
+  }
+
+  // Adjust for outcomes
+  if (outcomes) {
+    // Estimate accuracy bonus (max +15)
+    healthScore += Math.round(outcomes.estimateAccuracy * 0.15)
+
+    // Quality score bonus (max +10)
+    healthScore += Math.round(outcomes.avgQualityScore * 2)
+
+    // Blockers penalty
+    healthScore -= outcomes.topBlockers.length * 2
+  }
+
+  // Adjust for agent performance
+  if (agentPerformance.length > 0) {
+    const avgSuccess = agentPerformance.reduce((sum, a) => sum + a.successRate, 0) / agentPerformance.length
+    healthScore += Math.round(avgSuccess * 0.1)
+  }
+
+  // Clamp to 0-100
+  healthScore = Math.max(0, Math.min(100, healthScore))
+
+  // Build recommendations
+  const recommendations: string[] = []
+
+  if (!state?.currentTask) {
+    recommendations.push('Start a task with /p:now to maintain momentum')
+  }
+
+  if (state && state.queue.length > 10) {
+    recommendations.push('Queue is large - consider prioritizing or archiving tasks')
+  }
+
+  if (outcomes && outcomes.estimateAccuracy < 50) {
+    recommendations.push('Estimate accuracy is low - try adding 30% buffer to estimates')
+  }
+
+  if (agentPerformance.length === 0) {
+    recommendations.push('No agent performance data yet - track outcomes with /p:done')
+  }
+
+  const improving = agentPerformance.filter(a => a.improving)
+  if (improving.length > 0) {
+    recommendations.push(`${improving.map(a => a.agentName).join(', ')} improving - great progress!`)
+  }
+
+  return {
+    healthScore,
+    estimateAccuracy: outcomes?.estimateAccuracy || 0,
+    topBlockers: outcomes?.topBlockers || [],
+    patternsDetected: outcomes?.patternsDetected || [],
+    recommendations: recommendations.slice(0, 4),
+  }
+}
+
+/**
+ * Parse variance string to minutes
+ */
+function parseVariance(variance: string): number {
+  const match = variance.match(/^([+-])(\d+)([mh])$/)
+  if (!match) return 0
+
+  const sign = match[1] === '-' ? -1 : 1
+  const value = parseInt(match[2], 10)
+  const unit = match[3]
+
+  return sign * (unit === 'h' ? value * 60 : value)
+}
+
+/**
+ * Parse duration string to minutes
+ */
+function parseDuration(duration: string): number {
+  let minutes = 0
+
+  const hourMatch = duration.match(/(\d+)h/)
+  if (hourMatch) {
+    minutes += parseInt(hourMatch[1], 10) * 60
+  }
+
+  const minMatch = duration.match(/(\d+)m/)
+  if (minMatch) {
+    minutes += parseInt(minMatch[1], 10)
+  }
+
+  return minutes
+}
+
+/**
+ * Load unified project data
+ */
+export async function loadUnifiedProjectData(projectId: string): Promise<UnifiedProjectData> {
+  // Try to read from new unified state
+  const [state, outcomes, agentPerformance] = await Promise.all([
+    readState(projectId),
+    readOutcomes(projectId),
+    readAgentPerformance(projectId),
+  ])
+
+  // Compute insights
+  const insights = computeInsights(state, outcomes, agentPerformance)
+
+  return {
+    state,
+    outcomes,
+    agentPerformance,
+    insights,
+    legacyFallback: state === null,
+  }
+}
+
+/**
+ * Check if unified state exists for a project
+ */
+export async function hasUnifiedState(projectId: string): Promise<boolean> {
+  const statePath = join(GLOBAL_STORAGE, projectId, 'core', 'state.json')
+  try {
+    await fs.access(statePath)
+    return true
+  } catch {
+    return false
+  }
+}

package/packages/web/package.json

@@ -3,14 +3,15 @@
   "version": "0.1.0",
   "private": true,
   "scripts": {
-    "dev": "tsx server.ts",
-    "dev:next": "next dev",
-    "build": "next build",
-    "start": "NODE_ENV=production node server.js",
-    "start:prod": "NODE_ENV=production tsx server.ts",
+    "dev": "NODE_ENV=development PORT=9471 bun server.ts",
+    "dev:next": "bun next dev",
+    "build": "bun next build",
+    "start": "NODE_ENV=production PORT=9472 bun server.ts",
+    "start:prod": "NODE_ENV=production PORT=9472 bun server.ts",
     "lint": "eslint"
   },
   "dependencies": {
+    "@ai-sdk/openai": "^2.0.80",
     "@radix-ui/react-alert-dialog": "^1.1.15",
     "@radix-ui/react-dialog": "^1.1.15",
     "@radix-ui/react-dropdown-menu": "^2.1.16",
@@ -23,6 +24,7 @@
     "@xterm/addon-fit": "^0.10.0",
     "@xterm/addon-web-links": "^0.11.0",
     "@xterm/xterm": "^5.5.0",
+    "ai": "^5.0.108",
     "class-variance-authority": "^0.7.1",
     "clsx": "^2.1.1",
     "lucide-react": "^0.556.0",
@@ -36,10 +38,12 @@
     "recharts": "^3.5.1",
     "remark-gfm": "^4.0.1",
     "tailwind-merge": "^3.4.0",
-    "ws": "^8.18.3"
+    "ws": "^8.18.3",
+    "zod": "^4.1.13"
   },
   "devDependencies": {
     "@tailwindcss/postcss": "^4",
+    "@types/bun": "latest",
     "@types/node": "^20",
     "@types/react": "^19",
     "@types/react-dom": "^19",
@@ -47,7 +51,6 @@
     "eslint": "^9",
     "eslint-config-next": "16.0.7",
     "tailwindcss": "^4",
-    "tsx": "^4.19.2",
     "tw-animate-css": "^1.4.0",
     "typescript": "^5"
   }