prjct-cli 1.22.0 → 1.23.0

package/core/session/compaction.ts

@@ -1,248 +0,0 @@
-/**
- * Context Compaction
- *
- * Compresses conversation context while preserving semantics.
- * Useful for long sessions to prevent context overflow.
- *
- * Inspired by opencode's context management system.
- *
- * @version 1.0.0
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import type { CompactedContext, CompactionConfig, ConversationTurn } from '../types'
-import { getTimestamp } from '../utils/date-helper'
-
-export type { CompactedContext, CompactionConfig, ConversationTurn } from '../types'
-
-const DEFAULT_CONFIG: Required<CompactionConfig> = {
-  maxTurns: 50,
-  maxTokens: 160000,
-  preserveRecent: 10,
-  summaryMaxLength: 2000,
-}
-
-/**
- * Estimate token count (rough approximation)
- */
-function estimateTokens(text: string): number {
-  // Rough estimate: ~4 chars per token
-  return Math.ceil(text.length / 4)
-}
-
-/**
- * Extract key information from conversation
- */
-function extractKeyInfo(turns: ConversationTurn[]): {
-  decisions: string[]
-  filesModified: string[]
-  tasksCompleted: string[]
-} {
-  const decisions: string[] = []
-  const filesModified = new Set<string>()
-  const tasksCompleted: string[] = []
-
-  for (const turn of turns) {
-    const content = turn.content
-
-    // Extract decisions (patterns like "decided to", "will use", "choosing")
-    const decisionPatterns = [
-      /decided to ([^.]+)/gi,
-      /will use ([^.]+)/gi,
-      /choosing ([^.]+)/gi,
-      /going with ([^.]+)/gi,
-    ]
-
-    for (const pattern of decisionPatterns) {
-      const matches = content.matchAll(pattern)
-      for (const match of matches) {
-        decisions.push(match[1].trim())
-      }
-    }
-
-    // Extract file modifications
-    const filePatterns = [
-      /(?:created|modified|updated|edited|wrote to)\s+[`"]?([a-zA-Z0-9_\-./]+\.[a-zA-Z]+)[`"]?/gi,
-      /File (?:created|updated).*?:\s*([a-zA-Z0-9_\-./]+\.[a-zA-Z]+)/gi,
-    ]
-
-    for (const pattern of filePatterns) {
-      const matches = content.matchAll(pattern)
-      for (const match of matches) {
-        filesModified.add(match[1])
-      }
-    }
-
-    // Extract completed tasks
-    const taskPatterns = [/✅\s*(.+)/g, /completed[:\s]+(.+)/gi, /finished[:\s]+(.+)/gi]
-
-    for (const pattern of taskPatterns) {
-      const matches = content.matchAll(pattern)
-      for (const match of matches) {
-        const task = match[1].trim()
-        if (task.length < 100) {
-          // Avoid capturing large blocks
-          tasksCompleted.push(task)
-        }
-      }
-    }
-  }
-
-  return {
-    decisions: [...new Set(decisions)].slice(0, 10),
-    filesModified: [...filesModified].slice(0, 20),
-    tasksCompleted: [...new Set(tasksCompleted)].slice(0, 10),
-  }
-}
-
-/**
- * Generate summary from conversation turns
- */
-function generateSummary(turns: ConversationTurn[], maxLength: number): string {
-  // Get key user requests
-  const userRequests = turns
-    .filter((t) => t.role === 'user')
-    .map((t) => t.content.slice(0, 200))
-    .slice(0, 5)
-
-  // Get key assistant actions
-  const assistantActions = turns
-    .filter((t) => t.role === 'assistant')
-    .map((t) => {
-      // Extract first meaningful sentence
-      const firstLine = t.content.split('\n')[0]
-      return firstLine.slice(0, 150)
-    })
-    .filter((a) => a.length > 10)
-    .slice(0, 5)
-
-  const summary = [
-    '## Session Summary',
-    '',
-    '### User Requests:',
-    ...userRequests.map((r, i) => `${i + 1}. ${r.slice(0, 100)}...`),
-    '',
-    '### Key Actions:',
-    ...assistantActions.map((a, i) => `${i + 1}. ${a}`),
-  ].join('\n')
-
-  return summary.slice(0, maxLength)
-}
-
-/**
- * Compact conversation context
- */
-export function compactContext(
-  turns: ConversationTurn[],
-  config: CompactionConfig = {}
-): CompactedContext {
-  const cfg = { ...DEFAULT_CONFIG, ...config }
-
-  const { decisions, filesModified, tasksCompleted } = extractKeyInfo(turns)
-  const summary = generateSummary(turns, cfg.summaryMaxLength)
-
-  return {
-    summary,
-    keyPoints: decisions.slice(0, 5),
-    decisions,
-    filesModified,
-    tasksCompleted,
-    originalTurns: turns.length,
-    compactedAt: getTimestamp(),
-  }
-}
-
-/**
- * Check if compaction is needed
- */
-export function needsCompaction(turns: ConversationTurn[], config: CompactionConfig = {}): boolean {
-  const cfg = { ...DEFAULT_CONFIG, ...config }
-
-  // Check turn count
-  if (turns.length > cfg.maxTurns) {
-    return true
-  }
-
-  // Check token count
-  const totalTokens = turns.reduce((sum, t) => sum + estimateTokens(t.content), 0)
-  if (totalTokens > cfg.maxTokens) {
-    return true
-  }
-
-  return false
-}
-
-/**
- * Save compacted context to file
- */
-export async function saveCompactedContext(
-  projectId: string,
-  context: CompactedContext
-): Promise<string> {
-  const dirPath = path.join(pathManager.getGlobalProjectPath(projectId), 'memory')
-  const filePath = path.join(dirPath, 'compacted.jsonl')
-
-  await fs.mkdir(dirPath, { recursive: true })
-
-  const line = `${JSON.stringify(context)}\n`
-  await fs.appendFile(filePath, line, 'utf-8')
-
-  return filePath
-}
-
-/**
- * Load recent compacted contexts
- */
-export async function loadCompactedContexts(
-  projectId: string,
-  limit = 5
-): Promise<CompactedContext[]> {
-  const filePath = path.join(
-    pathManager.getGlobalProjectPath(projectId),
-    'memory',
-    'compacted.jsonl'
-  )
-
-  try {
-    const content = await fs.readFile(filePath, 'utf-8')
-    const lines = content.trim().split('\n').filter(Boolean)
-    const contexts = lines.map((line) => JSON.parse(line) as CompactedContext)
-
-    // Return most recent
-    return contexts.slice(-limit)
-  } catch (_error) {
-    return []
-  }
-}
-
-/**
- * Format compacted context for prompt injection
- */
-export function formatCompactedForPrompt(context: CompactedContext): string {
-  const lines = ['<compacted-context>', context.summary, '']
-
-  if (context.filesModified.length > 0) {
-    lines.push('### Files Modified:')
-    lines.push(context.filesModified.map((f) => `- ${f}`).join('\n'))
-    lines.push('')
-  }
-
-  if (context.tasksCompleted.length > 0) {
-    lines.push('### Tasks Completed:')
-    lines.push(context.tasksCompleted.map((t) => `- ${t}`).join('\n'))
-    lines.push('')
-  }
-
-  if (context.decisions.length > 0) {
-    lines.push('### Decisions Made:')
-    lines.push(context.decisions.map((d) => `- ${d}`).join('\n'))
-    lines.push('')
-  }
-
-  lines.push(`*Compacted from ${context.originalTurns} turns at ${context.compactedAt}*`)
-  lines.push('</compacted-context>')
-
-  return lines.join('\n')
-}

package/core/session/index.ts

@@ -1,35 +0,0 @@
-/**
- * Session Management - Consolidated Module
- *
- * Two managers with distinct purposes:
- * - TaskSessionManager: Task lifecycle (start, pause, complete)
- * - SessionLogManager: Log fragmentation (JSONL temporal)
- *
- * Storage: ~/.prjct-cli/projects/{projectId}/sessions/
- *
- * @version 2.0.0
- */
-
-// Task session types and utilities
-// Log session types
-export type {
-  MigrationResult,
-  Session,
-  SessionEntry,
-  SessionLogMetadata,
-  SessionMetrics,
-  SessionStats,
-  TimelineEvent,
-} from '../types'
-export { SessionLogManager } from './session-log-manager'
-
-// Main exports
-export { TaskSessionManager } from './task-session-manager'
-export { calculateDuration, formatDuration, generateId } from './utils'
-
-// Default: TaskSessionManager for backward compatibility
-import { TaskSessionManager } from './task-session-manager'
-export default TaskSessionManager
-
-// Alias for backward compatibility
-export { TaskSessionManager as SessionManager } from './task-session-manager'

package/core/session/log-migration.ts

@@ -1,88 +0,0 @@
-/**
- * Session Migration
- * Migrate legacy single-file logs to session structure
- */
-
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import type { SessionEntry, SessionLogMetadata, SessionMigrationResult } from '../types'
-import * as dateHelper from '../utils/date-helper'
-import * as fileHelper from '../utils/file-helper'
-import * as jsonlHelper from '../utils/jsonl-helper'
-
-/**
- * Migrate legacy JSONL file
- */
-export async function migrateLegacyJsonl(
-  projectId: string,
-  content: string,
-  sessionFilename: string,
-  updateMetadata: (sessionPath: string, updates: Partial<SessionLogMetadata>) => Promise<void>,
-  ensureMetadata: (sessionPath: string) => Promise<void>
-): Promise<SessionMigrationResult> {
-  const entries = jsonlHelper.parseJsonLines(content) as SessionEntry[]
-  const sessionGroups = new Map<string, SessionEntry[]>()
-
-  for (const entry of entries) {
-    const date = new Date(entry.timestamp || entry.data?.timestamp || Date.now())
-    const dateKey = dateHelper.getDateKey(date)
-
-    if (!sessionGroups.has(dateKey)) {
-      sessionGroups.set(dateKey, [])
-    }
-    sessionGroups.get(dateKey)!.push(entry)
-  }
-
-  let migratedCount = 0
-  for (const [dateKey, groupEntries] of sessionGroups) {
-    const [year, monthStr, day] = dateKey.split('-')
-    const month = parseInt(monthStr, 10)
-    const date = new Date(parseInt(year, 10), month - 1, parseInt(day, 10))
-    const sessionPath = await pathManager.ensureSessionPath(projectId, date)
-    const filePath = path.join(sessionPath, sessionFilename)
-
-    await jsonlHelper.writeJsonLines(filePath, groupEntries)
-
-    migratedCount += groupEntries.length
-
-    await ensureMetadata(sessionPath)
-    await updateMetadata(sessionPath, {
-      entryCount: groupEntries.length,
-      migrated: true,
-      migratedAt: dateHelper.getTimestamp(),
-    })
-  }
-
-  return {
-    success: true,
-    message: `Migrated ${migratedCount} entries to ${sessionGroups.size} sessions`,
-    entriesMigrated: migratedCount,
-    sessionsCreated: sessionGroups.size,
-  }
-}
-
-/**
- * Migrate legacy markdown file
- */
-export async function migrateLegacyMarkdown(
-  sessionPath: string,
-  content: string,
-  sessionFilename: string,
-  updateMetadata: (sessionPath: string, updates: Partial<SessionLogMetadata>) => Promise<void>
-): Promise<SessionMigrationResult> {
-  const filePath = path.join(sessionPath, sessionFilename)
-
-  await fileHelper.writeFile(filePath, content)
-
-  await updateMetadata(sessionPath, {
-    migrated: true,
-    migratedAt: dateHelper.getTimestamp(),
-  })
-
-  return {
-    success: true,
-    message: 'Migrated markdown content to current session',
-    entriesMigrated: 1,
-    sessionsCreated: 1,
-  }
-}

package/core/session/metrics.ts

@@ -1,323 +0,0 @@
-/**
- * SessionMetrics - Metrics Calculation and Aggregation
- *
- * Calculates productivity metrics from session data.
- *
- * @version 1.0.0
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-
-interface Session {
-  id: string
-  status: 'active' | 'paused' | 'completed'
-  startedAt: string
-  completedAt?: string
-  duration: number
-  metrics?: {
-    filesChanged?: number
-    linesAdded?: number
-    linesRemoved?: number
-    commits?: number
-  }
-}
-
-interface DayMetrics {
-  sessions: number
-  duration: number
-  commits: number
-}
-
-interface AggregatedMetrics {
-  period: string
-  totalSessions: number
-  totalDuration: number
-  totalDurationFormatted: string
-  averageDuration: number
-  averageDurationFormatted: string
-  tasksCompleted: number
-  filesChanged: number
-  linesAdded: number
-  linesRemoved: number
-  commits: number
-  productivityScore: number
-  streak: number
-  byDay: Record<string, DayMetrics>
-}
-
-class SessionMetrics {
-  private projectId: string
-
-  constructor(projectId: string) {
-    this.projectId = projectId
-  }
-
-  /**
-   * Get aggregated metrics for a time period
-   */
-  async getMetrics(period: 'day' | 'week' | 'month' | 'all' = 'week'): Promise<AggregatedMetrics> {
-    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
-   */
-  async getSessionsForPeriod(period: string): Promise<Session[]> {
-    const globalPath = pathManager.getGlobalProjectPath(this.projectId)
-    const archiveDir = path.join(globalPath, 'sessions', 'archive')
-
-    const sessions: Session[] = []
-    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: Session = JSON.parse(content)
-
-          if (session.completedAt && new Date(session.completedAt) >= cutoffDate) {
-            sessions.push(session)
-          }
-        }
-      }
-    } catch (error) {
-      // Archive might not exist - expected for new projects
-      if (!isNotFoundError(error)) {
-        console.error(`Metrics archive read error: ${getErrorMessage(error)}`)
-      }
-    }
-
-    // Also check current session
-    try {
-      const currentPath = path.join(globalPath, 'sessions', 'current.json')
-      const content = await fs.readFile(currentPath, 'utf-8')
-      const current: Session = JSON.parse(content)
-      if (new Date(current.startedAt) >= cutoffDate) {
-        sessions.push(current)
-      }
-    } catch (error) {
-      // No current session - expected
-      if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
-        console.error(`Current session read error: ${getErrorMessage(error)}`)
-      }
-    }
-
-    return sessions
-  }
-
-  /**
-   * Get cutoff date for period
-   */
-  getCutoffDate(period: string): Date {
-    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
-      }
-      default:
-        return new Date(0) // Beginning of time
-    }
-  }
-
-  /**
-   * Sum durations from sessions
-   */
-  sumDurations(sessions: Session[]): number {
-    return sessions.reduce((sum, s) => sum + (s.duration || 0), 0)
-  }
-
-  /**
-   * Calculate average duration
-   */
-  averageDuration(sessions: Session[]): number {
-    if (sessions.length === 0) return 0
-    return Math.round(this.sumDurations(sessions) / sessions.length)
-  }
-
-  /**
-   * Sum a specific metric
-   */
-  sumMetric(
-    sessions: Session[],
-    metric: 'filesChanged' | 'linesAdded' | 'linesRemoved' | 'commits'
-  ): number {
-    return sessions.reduce((sum, s) => {
-      return sum + (s.metrics?.[metric] || 0)
-    }, 0)
-  }
-
-  /**
-   * Calculate productivity score (0-100)
-   * Based on consistency, duration, and output
-   */
-  calculateProductivityScore(sessions: Session[]): number {
-    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)
-   */
-  async calculateStreak(): Promise<number> {
-    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
-   */
-  groupByDay(sessions: Session[]): Record<string, DayMetrics> {
-    const byDay: Record<string, DayMetrics> = {}
-
-    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
-   */
-  formatDuration(seconds: number): string {
-    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
-   */
-  async generateSummary(period: 'day' | 'week' | 'month' = 'week'): Promise<string> {
-    const m = await this.getMetrics(period)
-
-    const periodLabel: Record<string, string> = {
-      day: 'Today',
-      week: 'This Week',
-      month: 'This Month',
-      all: 'All Time',
-    }
-
-    return `
-## ${periodLabel[period]}
-
-| 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()
-  }
-}
-
-export default SessionMetrics
-export { SessionMetrics, type AggregatedMetrics, type DayMetrics }