prjct-cli 0.10.13 → 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.13",
+  "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/agentic/agent-routing.md

@@ -57,17 +57,49 @@ Consider these agent specializations:
 3. Consider secondary areas
 4. Choose agent with best expertise match
 
-## Output
+## How to Invoke (EFFICIENT)
 
-Return the recommended agent with reasoning:
+After deciding the best agent, **delegate via Task tool with REFERENCE, not content**:
 
-```json
-{
-  "agent": "recommended-agent-type",
-  "reasoning": "why this agent is best for the task",
-  "confidence": "high|medium|low",
-  "alternatives": ["other agents that could help"]
-}
+```
+Task(
+  subagent_type: 'general-purpose',
+  prompt: '
+    ## Agent Assignment
+    Read and apply: ~/.prjct-cli/projects/{projectId}/agents/{agent-name}.md
+
+    ## Task
+    {task description}
+
+    ## Context
+    - Project: {projectPath}
+    - Files affected: {file list if known}
+
+    ## Flow
+    1. Read agent file FIRST
+    2. Apply agent expertise and patterns
+    3. Execute task following agent guidelines
+    4. Return results
+  '
+)
+```
+
+### Why References, Not Content
+
+| Approach | Prompt Size | Issue |
+|----------|-------------|-------|
+| ❌ Inject content | 3-5KB | Bloats context, increases hallucinations |
+| ✅ Pass reference | ~200 bytes | Subagent reads what it needs |
+
+**CRITICAL:** The subagent reads the agent file itself. You do NOT need to read and inject the content.
+
+## Output (After Delegation)
+
+After Task tool returns, summarize:
+
+```
+✅ Delegated to: {agent-name}
+Result: {brief summary from subagent}
 ```
 
 ## Rules
@@ -75,4 +107,5 @@ Return the recommended agent with reasoning:
 - **Task-driven, not tech-driven** - Focus on what needs to be done
 - **Context matters** - Same tech can mean different things in different projects
 - **Be flexible** - One project's "backend" might be another's "full-stack"
+- **Pass PATH, not CONTENT** - Let subagent read the agent file
 - **Explain your reasoning** - Don't just pick, justify

package/templates/agentic/checklist-routing.md

@@ -0,0 +1,98 @@
+---
+allowed-tools: [Read, Glob]
+description: 'Determine which quality checklists to apply - Claude decides'
+---
+
+# Checklist Routing Instructions
+
+## Objective
+
+Determine which quality checklists are relevant for a task by analyzing the ACTUAL task and its scope.
+
+## Step 1: Understand the Task
+
+Read the task description and identify:
+
+- What type of work is being done? (new feature, bug fix, refactor, infra, docs)
+- What domains are affected? (code, UI, API, database, deployment)
+- What is the scope? (small fix, major feature, architectural change)
+
+## Step 2: Consider Task Domains
+
+Each task can touch multiple domains. Consider:
+
+| Domain | Signals |
+|--------|---------|
+| Code Quality | Writing/modifying any code |
+| Architecture | New components, services, or major refactors |
+| UX/UI | User-facing changes, CLI output, visual elements |
+| Infrastructure | Deployment, containers, CI/CD, cloud resources |
+| Security | Auth, user data, external inputs, secrets |
+| Testing | New functionality, bug fixes, critical paths |
+| Documentation | Public APIs, complex features, breaking changes |
+| Performance | Data processing, loops, network calls, rendering |
+| Accessibility | User interfaces (web, mobile, CLI) |
+| Data | Database operations, caching, data transformations |
+
+## Step 3: Match Task to Checklists
+
+Based on your analysis, select relevant checklists:
+
+**DO NOT assume:**
+- Every task needs all checklists
+- "Frontend" = only UX checklist
+- "Backend" = only Code Quality checklist
+
+**DO analyze:**
+- What the task actually touches
+- What quality dimensions matter for this specific work
+- What could go wrong if not checked
+
+## Available Checklists
+
+Located in `templates/checklists/`:
+
+| Checklist | When to Apply |
+|-----------|---------------|
+| `code-quality.md` | Any code changes (any language) |
+| `architecture.md` | New modules, services, significant structural changes |
+| `ux-ui.md` | User-facing interfaces (web, mobile, CLI, API DX) |
+| `infrastructure.md` | Deployment, containers, CI/CD, cloud resources |
+| `security.md` | ALWAYS for: auth, user input, external APIs, secrets |
+| `testing.md` | New features, bug fixes, refactors |
+| `documentation.md` | Public APIs, complex features, configuration changes |
+| `performance.md` | Data-intensive operations, critical paths |
+| `accessibility.md` | Any user interface work |
+| `data.md` | Database, caching, data transformations |
+
+## Decision Process
+
+1. Read task description
+2. Identify primary work domain
+3. List secondary domains affected
+4. Select 2-4 most relevant checklists
+5. Consider Security (almost always relevant)
+
+## Output
+
+Return selected checklists with reasoning:
+
+```json
+{
+  "checklists": ["code-quality", "security", "testing"],
+  "reasoning": "Task involves new API endpoint (code), handles user input (security), and adds business logic (testing)",
+  "priority_items": ["Input validation", "Error handling", "Happy path tests"],
+  "skipped": {
+    "accessibility": "No user interface changes",
+    "infrastructure": "No deployment changes"
+  }
+}
+```
+
+## Rules
+
+- **Task-driven** - Focus on what the specific task needs
+- **Less is more** - 2-4 focused checklists beat 10 unfocused
+- **Security is special** - Default to including unless clearly irrelevant
+- **Explain your reasoning** - Don't just pick, justify selections AND skips
+- **Context matters** - Small typo fix ≠ major refactor in checklist needs

package/templates/checklists/accessibility.md

@@ -0,0 +1,33 @@
+# Accessibility Checklist
+
+> Applies to: Web (WCAG), Mobile, CLI, Desktop
+
+## Perceivable
+- [ ] Text alternatives for non-text content
+- [ ] Sufficient color contrast (4.5:1 minimum)
+- [ ] Content readable without color alone
+- [ ] Resizable text supported (up to 200%)
+
+## Operable
+- [ ] Keyboard accessible (all functionality)
+- [ ] No keyboard traps
+- [ ] Sufficient time for interactions
+- [ ] Seizure-safe (no flashing > 3Hz)
+
+## Understandable
+- [ ] Clear and simple language
+- [ ] Consistent navigation
+- [ ] Input assistance provided
+- [ ] Error identification and suggestions
+
+## Robust
+- [ ] Compatible with assistive technologies
+- [ ] Valid markup/structure
+- [ ] ARIA used correctly (web)
+- [ ] Semantic HTML elements used
+
+## CLI Accessibility
+- [ ] Screen reader compatible output
+- [ ] No color-only information
+- [ ] Clear text formatting
+- [ ] Configurable output verbosity

package/templates/checklists/architecture.md

@@ -0,0 +1,28 @@
+# Architecture Checklist
+
+> Applies to ANY system architecture
+
+## Design Principles
+- [ ] Clear separation of concerns
+- [ ] Loose coupling between components
+- [ ] High cohesion within modules
+- [ ] Single source of truth for data
+- [ ] Explicit dependencies (no hidden coupling)
+
+## Scalability
+- [ ] Stateless where possible
+- [ ] Horizontal scaling considered
+- [ ] Bottlenecks identified
+- [ ] Caching strategy defined
+
+## Resilience
+- [ ] Failure modes documented
+- [ ] Graceful degradation planned
+- [ ] Recovery procedures defined
+- [ ] Circuit breakers where needed
+
+## Maintainability
+- [ ] Clear boundaries between layers
+- [ ] Easy to test in isolation
+- [ ] Configuration externalized
+- [ ] Logging and observability built-in

package/templates/checklists/code-quality.md

@@ -0,0 +1,28 @@
+# Code Quality Checklist
+
+> Universal principles for ANY programming language
+
+## Universal Principles
+- [ ] Single Responsibility: Each unit does ONE thing well
+- [ ] DRY: No duplicated logic (extract shared code)
+- [ ] KISS: Simplest solution that works
+- [ ] Clear naming: Self-documenting identifiers
+- [ ] Consistent patterns: Match existing codebase style
+
+## Error Handling
+- [ ] All error paths handled gracefully
+- [ ] Meaningful error messages
+- [ ] No silent failures
+- [ ] Proper resource cleanup (files, connections, memory)
+
+## Edge Cases
+- [ ] Null/nil/None handling
+- [ ] Empty collections handled
+- [ ] Boundary conditions tested
+- [ ] Invalid input rejected early
+
+## Code Organization
+- [ ] Functions/methods are small and focused
+- [ ] Related code grouped together
+- [ ] Clear module/package boundaries
+- [ ] No circular dependencies

package/templates/checklists/data.md

@@ -0,0 +1,33 @@
+# Data Checklist
+
+> Applies to: SQL, NoSQL, GraphQL, File storage, Caching
+
+## Data Integrity
+- [ ] Schema/structure defined
+- [ ] Constraints enforced
+- [ ] Transactions used appropriately
+- [ ] Referential integrity maintained
+
+## Query Performance
+- [ ] Indexes on frequent queries
+- [ ] N+1 queries eliminated
+- [ ] Query complexity analyzed
+- [ ] Pagination for large datasets
+
+## Data Operations
+- [ ] Migrations versioned and reversible
+- [ ] Backup and restore tested
+- [ ] Data validation at boundary
+- [ ] Soft deletes considered (if applicable)
+
+## Caching
+- [ ] Cache invalidation strategy defined
+- [ ] TTL values appropriate
+- [ ] Cache warming considered
+- [ ] Cache hit/miss monitored
+
+## Data Privacy
+- [ ] PII identified and protected
+- [ ] Data anonymization where needed
+- [ ] Audit trail for sensitive data
+- [ ] Data deletion procedures defined

package/templates/checklists/documentation.md

@@ -0,0 +1,33 @@
+# Documentation Checklist
+
+> Applies to ALL projects
+
+## Essential Docs
+- [ ] README with quick start
+- [ ] Installation instructions
+- [ ] Configuration options documented
+- [ ] Common use cases shown
+
+## Code Documentation
+- [ ] Public APIs documented
+- [ ] Complex logic explained
+- [ ] Architecture decisions recorded (ADRs)
+- [ ] Diagrams for complex flows
+
+## Operational Docs
+- [ ] Deployment process documented
+- [ ] Troubleshooting guide
+- [ ] Runbooks for common issues
+- [ ] Changelog maintained
+
+## API Documentation
+- [ ] All endpoints documented
+- [ ] Request/response examples
+- [ ] Error codes explained
+- [ ] Authentication documented
+
+## Maintenance
+- [ ] Docs updated with code changes
+- [ ] Version-specific documentation
+- [ ] Broken links checked
+- [ ] Examples tested and working