prjct-cli 1.22.0 → 1.24.0

package/core/session/session-log-manager.ts

@@ -1,307 +0,0 @@
-/**
- * SessionLogManager Class
- * Manages temporal fragmentation of logs and progress data.
- * Writes to sessions/YYYY-MM/DD/ structure with auto-rotation.
- */
-
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import type {
-  SessionEntry,
-  SessionLogMetadata,
-  SessionMigrationResult,
-  SessionStats,
-} from '../types'
-import { getErrorMessage } from '../types/fs'
-import { TTLCache } from '../utils/cache'
-import * as dateHelper from '../utils/date-helper'
-import * as fileHelper from '../utils/file-helper'
-import * as jsonlHelper from '../utils/jsonl-helper'
-import { VERSION } from '../utils/version'
-import { migrateLegacyJsonl, migrateLegacyMarkdown } from './log-migration'
-
-export class SessionLogManager {
-  private currentSessionCache: TTLCache<string>
-  private sessionMetadataCache: TTLCache<SessionLogMetadata>
-
-  constructor() {
-    this.currentSessionCache = new TTLCache<string>({ maxSize: 50, ttl: 3_600_000 })
-    this.sessionMetadataCache = new TTLCache<SessionLogMetadata>({ maxSize: 50, ttl: 3_600_000 })
-  }
-
-  /**
-   * Get or create current session directory for a project
-   */
-  async getCurrentSession(projectId: string): Promise<string> {
-    const cacheKey = `${projectId}-${this._getTodayKey()}`
-
-    const cached = this.currentSessionCache.get(cacheKey)
-    if (cached !== null) {
-      return cached
-    }
-
-    const sessionPath = await pathManager.ensureSessionPath(projectId)
-    this.currentSessionCache.set(cacheKey, sessionPath)
-
-    await this._ensureSessionLogMetadata(sessionPath)
-
-    return sessionPath
-  }
-
-  /**
-   * Write log entry to current session
-   */
-  async writeToSession(
-    projectId: string,
-    entry: SessionEntry,
-    filename: string = 'context.jsonl'
-  ): Promise<void> {
-    const sessionPath = await this.getCurrentSession(projectId)
-    const filePath = path.join(sessionPath, filename)
-
-    // Use automatic rotation to prevent large files (>10MB)
-    await jsonlHelper.appendJsonLineWithRotation(filePath, entry, 10)
-
-    await this._updateSessionLogMetadata(sessionPath, {
-      lastActivity: dateHelper.getTimestamp(),
-      entryCount: await jsonlHelper.countJsonLines(filePath),
-    })
-  }
-
-  /**
-   * Append content to a session file (for markdown files like shipped.md)
-   */
-  async appendToSession(projectId: string, content: string, filename: string): Promise<void> {
-    const sessionPath = await this.getCurrentSession(projectId)
-    const filePath = path.join(sessionPath, filename)
-
-    const exists = await fileHelper.fileExists(filePath)
-    if (!exists && filename === 'shipped.md') {
-      await fileHelper.writeFile(filePath, `# SHIPPED 🚀\n\n${content}`)
-    } else {
-      await fileHelper.appendToFile(filePath, content)
-    }
-
-    await this._updateSessionLogMetadata(sessionPath, {
-      lastActivity: dateHelper.getTimestamp(),
-    })
-  }
-
-  /**
-   * Read logs from current session
-   * Uses streaming for large files (>50MB)
-   */
-  async readCurrentSession<T = SessionEntry>(
-    projectId: string,
-    filename: string = 'context.jsonl',
-    maxLines: number = 1000
-  ): Promise<T[]> {
-    const sessionPath = await this.getCurrentSession(projectId)
-    const filePath = path.join(sessionPath, filename)
-
-    // Check file size and warn if large
-    const { isLarge } = await jsonlHelper.checkFileSizeWarning(filePath, 50)
-
-    if (isLarge) {
-      // Use streaming for large files
-      return (await jsonlHelper.readJsonLinesStreaming(filePath, maxLines)) as T[]
-    }
-
-    // Use normal read for small files
-    return (await jsonlHelper.readJsonLines(filePath)) as T[]
-  }
-
-  /**
-   * Read logs from a specific date range
-   */
-  async readSessionRange<T = SessionEntry>(
-    projectId: string,
-    fromDate: Date,
-    toDate: Date = new Date(),
-    filename: string = 'context.jsonl'
-  ): Promise<T[]> {
-    const sessions = await pathManager.getSessionsInRange(projectId, fromDate, toDate)
-    const allEntries: T[] = []
-
-    for (const session of sessions) {
-      const filePath = path.join(session.path, filename)
-      const entries = (await jsonlHelper.readJsonLines(filePath)) as (T & { _sessionDate?: Date })[]
-
-      entries.forEach((entry) => {
-        entry._sessionDate = session.date
-      })
-
-      allEntries.push(...entries)
-    }
-
-    return allEntries
-  }
-
-  /**
-   * Read markdown content from sessions in date range
-   */
-  async readMarkdownRange(
-    projectId: string,
-    fromDate: Date,
-    toDate: Date,
-    filename: string
-  ): Promise<string> {
-    const sessions = await pathManager.getSessionsInRange(projectId, fromDate, toDate)
-    const allContent: string[] = []
-
-    for (const session of sessions) {
-      const filePath = path.join(session.path, filename)
-      const content = await fileHelper.readFile(filePath, '')
-
-      if (content.trim()) {
-        allContent.push(`## Session: ${session.year}-${session.month}-${session.day}\n\n${content}`)
-      }
-    }
-
-    return allContent.join('\n---\n\n')
-  }
-
-  /**
-   * Get recent logs (last N days)
-   */
-  async getRecentLogs<T = SessionEntry>(
-    projectId: string,
-    days: number = 7,
-    filename: string = 'context.jsonl'
-  ): Promise<T[]> {
-    const toDate = new Date()
-    const fromDate = dateHelper.getDaysAgo(days)
-
-    return await this.readSessionRange<T>(projectId, fromDate, toDate, filename)
-  }
-
-  /**
-   * Get session statistics
-   */
-  async getSessionStats(projectId: string, fromDate: Date, toDate: Date): Promise<SessionStats> {
-    const sessions = await pathManager.getSessionsInRange(projectId, fromDate, toDate)
-
-    let totalEntries = 0
-    let totalShips = 0
-    let activeDays = 0
-
-    for (const session of sessions) {
-      const metadata = await this._getSessionLogMetadata(session.path)
-      if (metadata) {
-        totalEntries += metadata.entryCount || 0
-        totalShips += metadata.shipCount || 0
-        if (metadata.entryCount && metadata.entryCount > 0) {
-          activeDays++
-        }
-      }
-    }
-
-    return {
-      totalSessions: sessions.length,
-      activeDays,
-      totalEntries,
-      totalShips,
-      averageEntriesPerDay: activeDays > 0 ? Math.round(totalEntries / activeDays) : 0,
-    }
-  }
-
-  /**
-   * Migrate legacy single-file logs to session structure
-   */
-  async migrateLegacyLogs(
-    projectId: string,
-    legacyFilePath: string,
-    sessionFilename: string
-  ): Promise<SessionMigrationResult> {
-    try {
-      const content = await fileHelper.readFile(legacyFilePath)
-
-      if (sessionFilename.endsWith('.jsonl')) {
-        return await migrateLegacyJsonl(
-          projectId,
-          content,
-          sessionFilename,
-          (sp, u) => this._updateSessionLogMetadata(sp, u),
-          (sp) => this._ensureSessionLogMetadata(sp)
-        )
-      } else {
-        const sessionPath = await this.getCurrentSession(projectId)
-        return await migrateLegacyMarkdown(sessionPath, content, sessionFilename, (sp, u) =>
-          this._updateSessionLogMetadata(sp, u)
-        )
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: `Migration failed: ${getErrorMessage(error)}`,
-        entriesMigrated: 0,
-      }
-    }
-  }
-
-  /**
-   * Get session metadata
-   */
-  private async _getSessionLogMetadata(sessionPath: string): Promise<SessionLogMetadata | null> {
-    const metadataPath = path.join(sessionPath, 'session-meta.json')
-
-    const cached = this.sessionMetadataCache.get(sessionPath)
-    if (cached !== null) {
-      return cached
-    }
-
-    const metadata = await fileHelper.readJson<SessionLogMetadata>(metadataPath, null)
-    if (metadata) {
-      this.sessionMetadataCache.set(sessionPath, metadata)
-    }
-    return metadata
-  }
-
-  /**
-   * Ensure session metadata exists
-   */
-  private async _ensureSessionLogMetadata(sessionPath: string): Promise<void> {
-    const metadataPath = path.join(sessionPath, 'session-meta.json')
-
-    const exists = await fileHelper.fileExists(metadataPath)
-    if (!exists) {
-      const metadata: SessionLogMetadata = {
-        created: dateHelper.getTimestamp(),
-        lastActivity: dateHelper.getTimestamp(),
-        entryCount: 0,
-        shipCount: 0,
-        version: VERSION,
-      }
-      await fileHelper.writeJson(metadataPath, metadata)
-      this.sessionMetadataCache.set(sessionPath, metadata)
-    }
-  }
-
-  /**
-   * Update session metadata
-   */
-  private async _updateSessionLogMetadata(
-    sessionPath: string,
-    updates: Partial<SessionLogMetadata>
-  ): Promise<void> {
-    const metadata = (await this._getSessionLogMetadata(sessionPath)) || {}
-    Object.assign(metadata, updates)
-
-    const metadataPath = path.join(sessionPath, 'session-meta.json')
-    await fileHelper.writeJson(metadataPath, metadata)
-
-    this.sessionMetadataCache.set(sessionPath, metadata)
-  }
-
-  /**
-   * Get today's date key (YYYY-MM-DD)
-   */
-  private _getTodayKey(): string {
-    return dateHelper.getTodayKey()
-  }
-
-  clearCache(): void {
-    this.currentSessionCache.clear()
-    this.sessionMetadataCache.clear()
-  }
-}

package/core/session/task-session-manager.ts

@@ -1,404 +0,0 @@
-/**
- * TaskSessionManager Class
- * Manages task lifecycle: create, pause, resume, complete
- * Tracks metrics, timeline, and archives completed sessions.
- */
-
-import { exec } from 'node:child_process'
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { promisify } from 'node:util'
-import { emit } from '../bus'
-import configManager from '../infrastructure/config-manager'
-import pathManager from '../infrastructure/path-manager'
-import type { Session, SessionMetrics } from '../types'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-import { calculateDuration, formatDuration, generateId } from './utils'
-
-const execAsync = promisify(exec)
-
-export class TaskSessionManager {
-  private projectPath: string
-  private projectId: string | null
-  private sessionDir: string | null
-  private initialized: boolean
-
-  constructor(projectPath: string) {
-    this.projectPath = projectPath
-    this.projectId = null
-    this.sessionDir = null
-    this.initialized = false
-  }
-
-  /**
-   * Initialize session manager for project
-   */
-  async initialize(): Promise<void> {
-    this.projectId = await configManager.getProjectId(this.projectPath)
-    if (!this.projectId) {
-      throw new Error('No prjct project found. Run /p:init first.')
-    }
-
-    const globalPath = pathManager.getGlobalProjectPath(this.projectId)
-    this.sessionDir = path.join(globalPath, 'sessions')
-
-    await fs.mkdir(this.sessionDir, { recursive: true })
-    this.initialized = true
-  }
-
-  /**
-   * Generate unique session ID
-   */
-  generateId(): string {
-    return generateId()
-  }
-
-  /**
-   * Get current active session
-   */
-  async getCurrent(): Promise<Session | null> {
-    if (!this.initialized) await this.initialize()
-
-    const currentPath = path.join(this.sessionDir!, 'current.json')
-    try {
-      const content = await fs.readFile(currentPath, 'utf-8')
-      return JSON.parse(content)
-    } catch (error) {
-      if (isNotFoundError(error) || error instanceof SyntaxError) {
-        return null
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Create a new session
-   */
-  async create(task: string): Promise<Session> {
-    if (!this.initialized) await this.initialize()
-
-    // Check if there's already an active session
-    const current = await this.getCurrent()
-    if (current && current.status === 'active') {
-      throw new Error(`Session already active: "${current.task}". Use /p:done or /p:pause first.`)
-    }
-
-    const now = new Date().toISOString()
-    const session: Session = {
-      id: this.generateId(),
-      projectId: this.projectId!,
-      task,
-      status: 'active',
-      startedAt: now,
-      pausedAt: null,
-      completedAt: null,
-      duration: 0,
-      metrics: {
-        filesCreated: 0,
-        filesChanged: 0,
-        filesModified: 0,
-        linesAdded: 0,
-        linesRemoved: 0,
-        commits: 0,
-        snapshots: [],
-      },
-      timeline: [{ type: 'start', at: now }],
-    }
-
-    // Save as current session
-    await this.saveCurrent(session)
-
-    // Log to session history
-    await this.logEvent('session_started', { sessionId: session.id, task })
-
-    // Emit event for plugins
-    await emit.sessionStarted({
-      sessionId: session.id,
-      task,
-      projectId: this.projectId,
-    })
-
-    return session
-  }
-
-  /**
-   * Resume a paused session or continue active session
-   */
-  async resume(task: string | null = null): Promise<Session> {
-    if (!this.initialized) await this.initialize()
-
-    const current = await this.getCurrent()
-
-    // If task provided and different from current, create new session
-    if (task && (!current || current.task !== task)) {
-      return this.create(task)
-    }
-
-    // If no current session, need a task
-    if (!current) {
-      if (!task) {
-        throw new Error('No active session. Provide a task to start one.')
-      }
-      return this.create(task)
-    }
-
-    // If already active, just return it
-    if (current.status === 'active') {
-      return current
-    }
-
-    // Resume paused session
-    const now = new Date().toISOString()
-    current.status = 'active'
-    current.timeline.push({ type: 'resume', at: now })
-
-    await this.saveCurrent(current)
-    await this.logEvent('session_resumed', { sessionId: current.id })
-
-    // Emit event for plugins
-    await emit.sessionResumed({
-      sessionId: current.id,
-      task: current.task,
-      projectId: this.projectId,
-    })
-
-    return current
-  }
-
-  /**
-   * Pause current session
-   */
-  async pause(): Promise<Session> {
-    if (!this.initialized) await this.initialize()
-
-    const current = await this.getCurrent()
-    if (!current) {
-      throw new Error('No active session to pause.')
-    }
-
-    if (current.status === 'paused') {
-      return current // Already paused
-    }
-
-    const now = new Date().toISOString()
-    current.status = 'paused'
-    current.pausedAt = now
-    current.duration = calculateDuration(current)
-    current.timeline.push({ type: 'pause', at: now })
-
-    await this.saveCurrent(current)
-    await this.logEvent('session_paused', { sessionId: current.id, duration: current.duration })
-
-    // Emit event for plugins
-    await emit.sessionPaused({
-      sessionId: current.id,
-      task: current.task,
-      duration: current.duration,
-      projectId: this.projectId,
-    })
-
-    return current
-  }
-
-  /**
-   * Complete current session
-   */
-  async complete(): Promise<Session> {
-    if (!this.initialized) await this.initialize()
-
-    const current = await this.getCurrent()
-    if (!current) {
-      throw new Error('No active session to complete.')
-    }
-
-    const now = new Date().toISOString()
-    current.status = 'completed'
-    current.completedAt = now
-    current.duration = calculateDuration(current)
-    current.metrics = await this.calculateMetrics(current)
-    current.timeline.push({ type: 'complete', at: now })
-
-    // Archive session
-    await this.archive(current)
-
-    // Clear current
-    await this.clearCurrent()
-
-    // Log completion
-    await this.logEvent('session_completed', {
-      sessionId: current.id,
-      task: current.task,
-      duration: current.duration,
-      metrics: current.metrics,
-    })
-
-    // Emit event for plugins
-    await emit.sessionCompleted({
-      sessionId: current.id,
-      task: current.task,
-      duration: current.duration,
-      metrics: current.metrics,
-      projectId: this.projectId,
-    })
-
-    return current
-  }
-
-  /**
-   * Calculate total duration in seconds
-   */
-  calculateDuration(session: Session): number {
-    return calculateDuration(session)
-  }
-
-  /**
-   * Calculate metrics for session
-   */
-  async calculateMetrics(session: Session): Promise<SessionMetrics> {
-    const metrics = { ...session.metrics }
-
-    try {
-      // Get git stats since session start
-      const since = session.startedAt.split('T')[0]
-
-      // Count commits
-      const { stdout: commitCount } = await execAsync(
-        `git rev-list --count --since="${since}" HEAD 2>/dev/null || echo "0"`,
-        { cwd: this.projectPath }
-      )
-      metrics.commits = parseInt(commitCount.trim(), 10) || 0
-
-      // Get diff stats
-      const { stdout: diffStat } = await execAsync(
-        `git diff --stat HEAD~${Math.max(metrics.commits, 1)} 2>/dev/null || echo ""`,
-        { cwd: this.projectPath }
-      )
-
-      // Parse diff stats
-      const lines = diffStat.split('\n')
-      const summaryLine = lines[lines.length - 2] || ''
-      const match = summaryLine.match(
-        /(\d+) files? changed(?:, (\d+) insertions?)?(?:, (\d+) deletions?)?/
-      )
-
-      if (match) {
-        metrics.filesChanged = parseInt(match[1], 10) || 0
-        metrics.linesAdded = parseInt(match[2], 10) || 0
-        metrics.linesRemoved = parseInt(match[3], 10) || 0
-      }
-    } catch (error) {
-      // Keep existing metrics if git fails (not a repo, git not installed, etc.)
-      // This is expected in non-git projects
-      if (!isNotFoundError(error)) {
-        // Log unexpected errors but don't fail
-        console.error(`Metrics calculation warning: ${getErrorMessage(error)}`)
-      }
-    }
-
-    return metrics
-  }
-
-  /**
-   * Save current session
-   */
-  async saveCurrent(session: Session): Promise<void> {
-    const currentPath = path.join(this.sessionDir!, 'current.json')
-    await fs.writeFile(currentPath, JSON.stringify(session, null, 2))
-  }
-
-  /**
-   * Clear current session file
-   */
-  async clearCurrent(): Promise<void> {
-    const currentPath = path.join(this.sessionDir!, 'current.json')
-    try {
-      await fs.unlink(currentPath)
-    } catch (error) {
-      // File might not exist - that's ok
-      if (!isNotFoundError(error)) {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Archive completed session
-   */
-  async archive(session: Session): Promise<void> {
-    const date = new Date(session.completedAt!)
-    const yearMonth = `${date.getFullYear()}-${String(date.getMonth() + 1).padStart(2, '0')}`
-    const archiveDir = path.join(this.sessionDir!, 'archive', yearMonth)
-
-    await fs.mkdir(archiveDir, { recursive: true })
-
-    const archivePath = path.join(archiveDir, `${session.id}.json`)
-    await fs.writeFile(archivePath, JSON.stringify(session, null, 2))
-  }
-
-  /**
-   * Get session history
-   */
-  async getHistory(limit: number = 10): Promise<Session[]> {
-    if (!this.initialized) await this.initialize()
-
-    const sessions: Session[] = []
-    const archiveDir = path.join(this.sessionDir!, 'archive')
-
-    try {
-      const months = await fs.readdir(archiveDir)
-      const sortedMonths = months.sort().reverse()
-
-      for (const month of sortedMonths) {
-        if (sessions.length >= limit) break
-
-        const monthDir = path.join(archiveDir, month)
-        const files = await fs.readdir(monthDir)
-
-        for (const file of files.sort().reverse()) {
-          if (sessions.length >= limit) break
-          if (!file.endsWith('.json')) continue
-
-          const content = await fs.readFile(path.join(monthDir, file), 'utf-8')
-          sessions.push(JSON.parse(content))
-        }
-      }
-    } catch (error) {
-      // Archive might not exist yet
-      if (!isNotFoundError(error) && !(error instanceof SyntaxError)) {
-        throw error
-      }
-    }
-
-    return sessions
-  }
-
-  /**
-   * Log event to memory
-   */
-  async logEvent(action: string, data: Record<string, unknown>): Promise<void> {
-    const globalPath = pathManager.getGlobalProjectPath(this.projectId!)
-    const memoryPath = path.join(globalPath, 'memory', 'context.jsonl')
-
-    const entry = `${JSON.stringify({
-      timestamp: new Date().toISOString(),
-      action,
-      ...data,
-    })}\n`
-
-    try {
-      await fs.appendFile(memoryPath, entry)
-    } catch (error) {
-      // Memory file might not exist - that's ok
-      if (!isNotFoundError(error)) {
-        throw error
-      }
-    }
-  }
-
-  /**
-   * Format duration as human readable
-   */
-  static formatDuration(seconds: number): string {
-    return formatDuration(seconds)
-  }
-}