prjct-cli 0.10.14 → 0.11.0

package/core/session/metrics.js

@@ -0,0 +1,293 @@
+/**
+ * SessionMetrics - Metrics Calculation and Aggregation
+ *
+ * Calculates productivity metrics from session data.
+ *
+ * @version 1.0.0
+ */
+
+const fs = require('fs').promises
+const path = require('path')
+const pathManager = require('../infrastructure/path-manager')
+
+class SessionMetrics {
+  constructor(projectId) {
+    this.projectId = projectId
+  }
+
+  /**
+   * Get aggregated metrics for a time period
+   * @param {'day'|'week'|'month'|'all'} period
+   * @returns {Promise<Object>}
+   */
+  async getMetrics(period = 'week') {
+    const sessions = await this.getSessionsForPeriod(period)
+
+    return {
+      period,
+      totalSessions: sessions.length,
+      totalDuration: this.sumDurations(sessions),
+      totalDurationFormatted: this.formatDuration(this.sumDurations(sessions)),
+      averageDuration: this.averageDuration(sessions),
+      averageDurationFormatted: this.formatDuration(this.averageDuration(sessions)),
+      tasksCompleted: sessions.filter(s => s.status === 'completed').length,
+      filesChanged: this.sumMetric(sessions, 'filesChanged'),
+      linesAdded: this.sumMetric(sessions, 'linesAdded'),
+      linesRemoved: this.sumMetric(sessions, 'linesRemoved'),
+      commits: this.sumMetric(sessions, 'commits'),
+      productivityScore: this.calculateProductivityScore(sessions),
+      streak: await this.calculateStreak(),
+      byDay: this.groupByDay(sessions)
+    }
+  }
+
+  /**
+   * Get sessions for a given period
+   * @param {string} period
+   * @returns {Promise<Array>}
+   */
+  async getSessionsForPeriod(period) {
+    const globalPath = pathManager.getGlobalProjectPath(this.projectId)
+    const archiveDir = path.join(globalPath, 'sessions', 'archive')
+
+    const sessions = []
+    const cutoffDate = this.getCutoffDate(period)
+
+    try {
+      const months = await fs.readdir(archiveDir)
+
+      for (const month of months) {
+        const monthDir = path.join(archiveDir, month)
+        const files = await fs.readdir(monthDir)
+
+        for (const file of files) {
+          if (!file.endsWith('.json')) continue
+
+          const content = await fs.readFile(path.join(monthDir, file), 'utf-8')
+          const session = JSON.parse(content)
+
+          if (new Date(session.completedAt) >= cutoffDate) {
+            sessions.push(session)
+          }
+        }
+      }
+    } catch {
+      // Archive might not exist
+    }
+
+    // Also check current session
+    try {
+      const currentPath = path.join(globalPath, 'sessions', 'current.json')
+      const content = await fs.readFile(currentPath, 'utf-8')
+      const current = JSON.parse(content)
+      if (new Date(current.startedAt) >= cutoffDate) {
+        sessions.push(current)
+      }
+    } catch {
+      // No current session
+    }
+
+    return sessions
+  }
+
+  /**
+   * Get cutoff date for period
+   * @param {string} period
+   * @returns {Date}
+   */
+  getCutoffDate(period) {
+    const now = new Date()
+
+    switch (period) {
+      case 'day':
+        return new Date(now.setHours(0, 0, 0, 0))
+      case 'week':
+        const weekAgo = new Date(now)
+        weekAgo.setDate(weekAgo.getDate() - 7)
+        return weekAgo
+      case 'month':
+        const monthAgo = new Date(now)
+        monthAgo.setMonth(monthAgo.getMonth() - 1)
+        return monthAgo
+      case 'all':
+      default:
+        return new Date(0) // Beginning of time
+    }
+  }
+
+  /**
+   * Sum durations from sessions
+   * @param {Array} sessions
+   * @returns {number} Total seconds
+   */
+  sumDurations(sessions) {
+    return sessions.reduce((sum, s) => sum + (s.duration || 0), 0)
+  }
+
+  /**
+   * Calculate average duration
+   * @param {Array} sessions
+   * @returns {number} Average seconds
+   */
+  averageDuration(sessions) {
+    if (sessions.length === 0) return 0
+    return Math.round(this.sumDurations(sessions) / sessions.length)
+  }
+
+  /**
+   * Sum a specific metric
+   * @param {Array} sessions
+   * @param {string} metric
+   * @returns {number}
+   */
+  sumMetric(sessions, metric) {
+    return sessions.reduce((sum, s) => {
+      return sum + (s.metrics?.[metric] || 0)
+    }, 0)
+  }
+
+  /**
+   * Calculate productivity score (0-100)
+   * Based on consistency, duration, and output
+   * @param {Array} sessions
+   * @returns {number}
+   */
+  calculateProductivityScore(sessions) {
+    if (sessions.length === 0) return 0
+
+    // Factors:
+    // 1. Session count (more = better, up to a point)
+    const sessionScore = Math.min(sessions.length / 10, 1) * 30
+
+    // 2. Average duration (25-90 min is optimal)
+    const avgMins = this.averageDuration(sessions) / 60
+    let durationScore = 0
+    if (avgMins >= 25 && avgMins <= 90) {
+      durationScore = 30
+    } else if (avgMins > 0) {
+      durationScore = Math.max(0, 30 - Math.abs(avgMins - 57.5) / 2)
+    }
+
+    // 3. Completion rate
+    const completedCount = sessions.filter(s => s.status === 'completed').length
+    const completionScore = (completedCount / sessions.length) * 20
+
+    // 4. Output (commits + files changed)
+    const totalOutput = this.sumMetric(sessions, 'commits') + this.sumMetric(sessions, 'filesChanged')
+    const outputScore = Math.min(totalOutput / 50, 1) * 20
+
+    return Math.round(sessionScore + durationScore + completionScore + outputScore)
+  }
+
+  /**
+   * Calculate current streak (consecutive days with sessions)
+   * @returns {Promise<number>}
+   */
+  async calculateStreak() {
+    const sessions = await this.getSessionsForPeriod('month')
+
+    // Get unique dates with sessions
+    const dates = new Set(
+      sessions.map(s => {
+        const d = new Date(s.completedAt || s.startedAt)
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`
+      })
+    )
+
+    // Count consecutive days from today
+    let streak = 0
+    const today = new Date()
+
+    for (let i = 0; i < 30; i++) {
+      const checkDate = new Date(today)
+      checkDate.setDate(checkDate.getDate() - i)
+      const key = `${checkDate.getFullYear()}-${checkDate.getMonth()}-${checkDate.getDate()}`
+
+      if (dates.has(key)) {
+        streak++
+      } else if (i > 0) {
+        break // Streak broken
+      }
+    }
+
+    return streak
+  }
+
+  /**
+   * Group sessions by day
+   * @param {Array} sessions
+   * @returns {Object}
+   */
+  groupByDay(sessions) {
+    const byDay = {}
+
+    for (const session of sessions) {
+      const date = new Date(session.completedAt || session.startedAt)
+      const key = date.toISOString().split('T')[0]
+
+      if (!byDay[key]) {
+        byDay[key] = {
+          sessions: 0,
+          duration: 0,
+          commits: 0
+        }
+      }
+
+      byDay[key].sessions++
+      byDay[key].duration += session.duration || 0
+      byDay[key].commits += session.metrics?.commits || 0
+    }
+
+    return byDay
+  }
+
+  /**
+   * Format duration as human readable
+   * @param {number} seconds
+   * @returns {string}
+   */
+  formatDuration(seconds) {
+    if (seconds < 60) return `${seconds}s`
+    if (seconds < 3600) return `${Math.round(seconds / 60)}m`
+
+    const hours = Math.floor(seconds / 3600)
+    const minutes = Math.round((seconds % 3600) / 60)
+
+    if (minutes === 0) return `${hours}h`
+    return `${hours}h ${minutes}m`
+  }
+
+  /**
+   * Generate metrics summary for display
+   * @param {'day'|'week'|'month'} period
+   * @returns {Promise<string>}
+   */
+  async generateSummary(period = 'week') {
+    const m = await this.getMetrics(period)
+
+    const periodLabel = {
+      day: 'Today',
+      week: 'This Week',
+      month: 'This Month',
+      all: 'All Time'
+    }[period]
+
+    return `
+## ${periodLabel}
+
+| Metric | Value |
+|--------|-------|
+| Sessions | ${m.totalSessions} |
+| Total Time | ${m.totalDurationFormatted} |
+| Avg Session | ${m.averageDurationFormatted} |
+| Tasks Done | ${m.tasksCompleted} |
+| Files Changed | ${m.filesChanged} |
+| Lines +/- | +${m.linesAdded} / -${m.linesRemoved} |
+| Commits | ${m.commits} |
+| Streak | ${m.streak} days |
+| Score | ${m.productivityScore}/100 |
+`.trim()
+  }
+}
+
+module.exports = SessionMetrics

package/package.json

@@ -1,16 +1,24 @@
 {
   "name": "prjct-cli",
-  "version": "0.10.14",
+  "version": "0.11.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.js",
   "bin": {
-    "prjct": "bin/prjct"
+    "prjct": "bin/prjct",
+    "prjct-dev": "bin/dev.js",
+    "prjct-serve": "bin/serve.js"
   },
+  "workspaces": [
+    "packages/*"
+  ],
   "publishConfig": {
     "access": "public",
     "registry": "https://registry.npmjs.org"
   },
   "scripts": {
+    "dev": "turbo run dev",
+    "build": "turbo run build",
+    "serve": "turbo run dev --filter=@prjct/server --filter=@prjct/web",
     "postinstall": "node scripts/postinstall.js",
     "update-commands": "node -e \"const installer = require('./core/infrastructure/command-installer'); installer.syncCommands().then(r => console.log('Commands updated:', r)).catch(e => console.error('Error:', e.message))\"",
     "install-global": "./scripts/install.sh",
@@ -41,6 +49,7 @@
   "dependencies": {
     "chalk": "^4.1.2",
     "glob": "^10.3.10",
+    "lightningcss": "^1.30.2",
     "prompts": "^2.4.2"
   },
   "devDependencies": {
@@ -52,6 +61,7 @@
     "eslint-plugin-n": "^16.6.2",
     "eslint-plugin-promise": "^6.6.0",
     "prettier": "^3.6.2",
+    "turbo": "^2.3.0",
     "vitest": "^3.2.4"
   },
   "repository": {
@@ -62,6 +72,7 @@
     "url": "https://github.com/jlopezlira/prjct-cli/issues"
   },
   "homepage": "https://prjct.app",
+  "packageManager": "npm@10.2.4",
   "engines": {
     "node": ">=18.0.0"
   },
@@ -79,5 +90,8 @@
   "trustedDependencies": [
     "chalk",
     "prompts"
-  ]
-}
+  ],
+  "overrides": {
+    "esbuild": "^0.25.0"
+  }
+}

package/templates/commands/done.md

@@ -1,15 +1,17 @@
 ---
-allowed-tools: [Read, Write]
-description: 'Complete current task'
+allowed-tools: [Read, Write, Bash]
+description: 'Complete current task with session metrics'
 timestamp-rule: 'GetTimestamp() for all timestamps'
 ---
 
-# /p:done - Complete Current Task
+# /p:done - Complete Current Task with Session Metrics
 
 ## Context Variables
 - `{projectId}`: From `.prjct/prjct.config.json`
 - `{globalPath}`: `~/.prjct-cli/projects/{projectId}`
 - `{nowPath}`: `{globalPath}/core/now.md`
+- `{sessionPath}`: `{globalPath}/sessions/current.json`
+- `{archiveDir}`: `{globalPath}/sessions/archive`
 - `{memoryPath}`: `{globalPath}/memory/context.jsonl`
 - `{metricsPath}`: `{globalPath}/progress/metrics.md`
 
@@ -22,116 +24,236 @@ IF file not found:
   OUTPUT: "No prjct project. Run /p:init first."
   STOP
 
-## Step 2: Validate Active Task
+## Step 2: Check Session State
 
+### Try structured session first
+READ: `{sessionPath}`
+
+IF file exists:
+  PARSE as JSON
+  EXTRACT: {session} object
+  GOTO Step 3 (Session Completion)
+
+### Fallback to legacy now.md
 READ: `{nowPath}`
 
 IF empty OR contains "No current task":
   OUTPUT: "⚠️ No active task to complete. Use /p:now to start one."
   STOP
 
-## Step 3: Extract Task Data
+## Step 3: Session Completion
 
-From NOW file content, extract:
+### Calculate Final Duration
+SET: {now} = GetTimestamp()
 
-1. **Task name**: Text between `**` markers
-   - Pattern: `**(.+?)**`
-   - Example: `**implement auth**` → "implement auth"
+For each event in {session.timeline}:
+  Track start/resume/pause/complete times
+  Calculate total active time
 
-2. **Start time**: Text after "Started:"
-   - Pattern: `Started: (.+)`
-   - Example: `Started: 11/28/2025, 2:30:00 PM`
+SET: {duration} = total active seconds
+SET: {durationFormatted} = format as "Xh Ym" or "Xm"
 
-3. **Calculate duration**:
-   - Current: GetTimestamp()
-   - Duration: current - started
-   - Format: "Xh Ym" (e.g., "2h 15m")
-   - If < 1 hour: "Xm"
-   - If < 1 minute: "< 1m"
+### Calculate Git Metrics
+BASH: `git rev-list --count --since="{session.startedAt}" HEAD 2>/dev/null || echo "0"`
+CAPTURE as {commits}
 
-## Step 4: Clear Task File
+BASH: `git diff --stat HEAD~{commits} 2>/dev/null || git diff --stat`
+PARSE output for:
+  - {filesChanged}: number of files
+  - {linesAdded}: insertions
+  - {linesRemoved}: deletions
 
-WRITE: `{nowPath}`
+### Update Session Object
+```json
+{
+  "id": "{session.id}",
+  "projectId": "{projectId}",
+  "task": "{session.task}",
+  "status": "completed",
+  "startedAt": "{session.startedAt}",
+  "pausedAt": null,
+  "completedAt": "{now}",
+  "duration": {duration},
+  "metrics": {
+    "filesChanged": {filesChanged},
+    "linesAdded": {linesAdded},
+    "linesRemoved": {linesRemoved},
+    "commits": {commits},
+    "snapshots": {session.metrics.snapshots}
+  },
+  "timeline": [
+    ...{session.timeline},
+    {"type": "complete", "at": "{now}"}
+  ]
+}
+```
+
+## Step 4: Archive Session
+
+### Create Archive Directory
+GET: {yearMonth} = YYYY-MM from {now}
+ENSURE: `{archiveDir}/{yearMonth}` exists
+
+BASH: `mkdir -p {archiveDir}/{yearMonth}`
+
+### Write Archived Session
+WRITE: `{archiveDir}/{yearMonth}/{session.id}.json`
+Content: Updated session object from Step 3
+
+## Step 5: Clear Current Session
+
+DELETE: `{sessionPath}`
 
-Content (exact):
+OR WRITE empty state:
+WRITE: `{sessionPath}`
+Content:
+```json
+{}
+```
+
+## Step 6: Update Legacy now.md
+
+WRITE: `{nowPath}`
+Content:
 ```markdown
 # NOW
 
 No current task. Use `/p:now` to set focus.
 ```
 
-## Step 5: Log to Memory
+## Step 7: Log to Memory
 
 APPEND to: `{memoryPath}`
 
 Single line (JSONL format):
 ```json
-{"timestamp":"{GetTimestamp()}","action":"task_completed","task":"{task}","duration":"{duration}"}
+{"timestamp":"{now}","action":"session_completed","sessionId":"{session.id}","task":"{session.task}","duration":{duration},"metrics":{"files":{filesChanged},"added":{linesAdded},"removed":{linesRemoved},"commits":{commits}}}
 ```
 
-## Step 6: Update Metrics (Optional)
+## Step 8: Update Metrics Summary
+
+READ: `{metricsPath}` (create if not exists)
 
-IF `{metricsPath}` exists:
-  READ current content
-  APPEND new entry with task and duration
+### Append Daily Entry
+GET: {date} = YYYY-MM-DD from {now}
+
+INSERT or UPDATE entry for {date}:
+```markdown
+### {date}
+- **{session.task}** ({durationFormatted})
+  - Files: {filesChanged} | +{linesAdded}/-{linesRemoved} | Commits: {commits}
+```
 
 ## Output
 
 SUCCESS:
 ```
-✅ {task} ({duration})
+✅ {session.task} ({durationFormatted})
+
+Session: {session.id}
+Files: {filesChanged} | +{linesAdded}/-{linesRemoved}
+Commits: {commits}
 
 Next:
 • /p:now - Start next task
 • /p:ship - Ship completed work
-• /p:next - See priority queue
+• /p:progress - View metrics
 ```
 
 ## Error Handling
 
-| Error | Response |
-|-------|----------|
-| Config not found | "No prjct project. Run /p:init first." |
-| Now.md empty | "⚠️ No active task. Use /p:now to start." |
-| Parse fails | Use task = "task", duration = "unknown", continue |
-| Write fails | Log warning, continue (non-critical) |
+| Error | Response | Action |
+|-------|----------|--------|
+| Config not found | "No prjct project" | STOP |
+| No session/task | "No active task" | STOP |
+| Git fails | Use zeros for metrics | CONTINUE |
+| Archive fails | Log warning | CONTINUE |
+| Write fails | Log warning | CONTINUE |
 
 ## Examples
 
-### Example 1: Success
-**now.md content:**
+### Example 1: Full Session Completion
+**Session:**
+```json
+{
+  "id": "sess_abc12345",
+  "task": "implement authentication",
+  "status": "active",
+  "startedAt": "2025-12-07T10:00:00.000Z",
+  "timeline": [
+    {"type": "start", "at": "2025-12-07T10:00:00.000Z"}
+  ]
+}
 ```
-# NOW
 
-**implement authentication**
+**Git activity:**
+- 3 commits
+- 5 files changed
+- +120/-30 lines
 
-Started: 11/28/2025, 12:15:00 PM
+**Output:**
 ```
+✅ implement authentication (2h 15m)
 
-**Current time:** 11/28/2025, 2:30:00 PM
-**Duration:** 2h 15m
-**Output:** `✅ implement authentication (2h 15m)`
+Session: sess_abc12345
+Files: 5 | +120/-30
+Commits: 3
 
-### Example 2: No Task
-**now.md content:**
+Next:
+• /p:now - Start next task
+• /p:ship - Ship completed work
+• /p:progress - View metrics
 ```
-# NOW
 
-No current task.
+### Example 2: Session with Pauses
+**Session with multiple pause/resume:**
+```json
+{
+  "id": "sess_xyz98765",
+  "task": "fix login bug",
+  "timeline": [
+    {"type": "start", "at": "2025-12-07T09:00:00.000Z"},
+    {"type": "pause", "at": "2025-12-07T10:00:00.000Z"},
+    {"type": "resume", "at": "2025-12-07T14:00:00.000Z"},
+    {"type": "pause", "at": "2025-12-07T15:30:00.000Z"},
+    {"type": "resume", "at": "2025-12-07T16:00:00.000Z"}
+  ]
+}
+```
+
+**Completion at 17:00:**
+- Active time: 1h + 1.5h + 1h = 3.5h
+- Duration: 3h 30m
+
+**Output:**
 ```
+✅ fix login bug (3h 30m)
 
-**Output:** `⚠️ No active task to complete. Use /p:now to start one.`
+Session: sess_xyz98765
+Files: 2 | +45/-12
+Commits: 1
 
-### Example 3: Quick Task
+Next:
+• /p:now - Start next task
+• /p:ship - Ship completed work
+• /p:progress - View metrics
+```
+
+### Example 3: Legacy Fallback (No Session)
 **now.md content:**
 ```
 # NOW
 
-**fix typo in readme**
+**quick fix**
 
-Started: 11/28/2025, 2:25:00 PM
+Started: 2025-12-07T16:45:00.000Z
 ```
 
-**Current time:** 11/28/2025, 2:30:00 PM
-**Duration:** 5m
-**Output:** `✅ fix typo in readme (5m)`
+**Output:**
+```
+✅ quick fix (15m)
+
+Next:
+• /p:now - Start next task
+• /p:ship - Ship completed work
+```