prjct-cli 0.11.4 → 0.12.0

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

@@ -0,0 +1,307 @@
+/**
+ * SessionManager Class
+ * Manages temporal fragmentation of logs and progress data.
+ */
+
+import path from 'path'
+import pathManager from '../path-manager'
+import { VERSION } from '../../utils/version'
+import * as dateHelper from '../../utils/date-helper'
+import * as jsonlHelper from '../../utils/jsonl-helper'
+import * as fileHelper from '../../utils/file-helper'
+import { migrateLegacyJsonl, migrateLegacyMarkdown } from './migration'
+import type { SessionEntry, SessionMetadata, SessionStats, MigrationResult } from './types'
+
+export class SessionManager {
+  private currentSessionCache: Map<string, string>
+  private sessionMetadataCache: Map<string, SessionMetadata>
+
+  constructor() {
+    this.currentSessionCache = new Map()
+    this.sessionMetadataCache = new Map()
+  }
+
+  /**
+   * Get or create current session directory for a project
+   */
+  async getCurrentSession(projectId: string): Promise<string> {
+    const cacheKey = `${projectId}-${this._getTodayKey()}`
+
+    if (this.currentSessionCache.has(cacheKey)) {
+      return this.currentSessionCache.get(cacheKey)!
+    }
+
+    const sessionPath = await pathManager.ensureSessionPath(projectId)
+    this.currentSessionCache.set(cacheKey, sessionPath)
+
+    await this._ensureSessionMetadata(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._updateSessionMetadata(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._updateSessionMetadata(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._getSessionMetadata(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<MigrationResult> {
+    try {
+      const content = await fileHelper.readFile(legacyFilePath)
+
+      if (sessionFilename.endsWith('.jsonl')) {
+        return await migrateLegacyJsonl(
+          projectId,
+          content,
+          sessionFilename,
+          (sp, u) => this._updateSessionMetadata(sp, u),
+          (sp) => this._ensureSessionMetadata(sp)
+        )
+      } else {
+        const sessionPath = await this.getCurrentSession(projectId)
+        return await migrateLegacyMarkdown(
+          sessionPath,
+          content,
+          sessionFilename,
+          (sp, u) => this._updateSessionMetadata(sp, u)
+        )
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: `Migration failed: ${(error as Error).message}`,
+        entriesMigrated: 0,
+      }
+    }
+  }
+
+  /**
+   * Get session metadata
+   */
+  private async _getSessionMetadata(sessionPath: string): Promise<SessionMetadata | null> {
+    const metadataPath = path.join(sessionPath, 'session-meta.json')
+
+    if (this.sessionMetadataCache.has(sessionPath)) {
+      return this.sessionMetadataCache.get(sessionPath)!
+    }
+
+    const metadata = await fileHelper.readJson<SessionMetadata>(metadataPath, null)
+    if (metadata) {
+      this.sessionMetadataCache.set(sessionPath, metadata)
+    }
+    return metadata
+  }
+
+  /**
+   * Ensure session metadata exists
+   */
+  private async _ensureSessionMetadata(sessionPath: string): Promise<void> {
+    const metadataPath = path.join(sessionPath, 'session-meta.json')
+
+    const exists = await fileHelper.fileExists(metadataPath)
+    if (!exists) {
+      const metadata: SessionMetadata = {
+        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 _updateSessionMetadata(
+    sessionPath: string,
+    updates: Partial<SessionMetadata>
+  ): Promise<void> {
+    const metadata = (await this._getSessionMetadata(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()
+  }
+
+  /**
+   * Get date key for any date (YYYY-MM-DD)
+   */
+  private _getDateKey(date: Date): string {
+    return dateHelper.getDateKey(date)
+  }
+
+  clearCache(): void {
+    this.currentSessionCache.clear()
+    this.sessionMetadataCache.clear()
+  }
+}

package/core/infrastructure/session-manager/types.ts

@@ -0,0 +1,45 @@
+/**
+ * Session Manager Types
+ */
+
+export interface SessionEntry {
+  timestamp?: string
+  data?: {
+    timestamp?: string
+  }
+  _sessionDate?: Date
+  [key: string]: unknown
+}
+
+export interface SessionMetadata {
+  created?: string
+  lastActivity?: string
+  entryCount?: number
+  shipCount?: number
+  version?: string
+  migrated?: boolean
+  migratedAt?: string
+}
+
+export interface SessionStats {
+  totalSessions: number
+  activeDays: number
+  totalEntries: number
+  totalShips: number
+  averageEntriesPerDay: number
+}
+
+export interface MigrationResult {
+  success: boolean
+  message: string
+  entriesMigrated: number
+  sessionsCreated?: number
+}
+
+export interface SessionInfo {
+  path: string
+  date: Date
+  year: string
+  month: string
+  day: string
+}

package/core/infrastructure/session-manager.ts

@@ -0,0 +1,8 @@
+/**
+ * Session Manager
+ * Re-exports from session-manager/index.ts for backwards compatibility.
+ */
+
+import sessionManager from './session-manager/index'
+export * from './session-manager/index'
+export default sessionManager

package/core/infrastructure/{setup.js → setup.ts}

@@ -1,10 +1,3 @@
-const { execSync } = require('child_process')
-const installer = require('./command-installer')
-const migrator = require('./migrator')
-const legacyDetector = require('./legacy-installer-detector')
-const editorsConfig = require('./editors-config')
-const { VERSION } = require('../utils/version')
-
 /**
  * Setup Module - Core installation logic
  *
@@ -23,18 +16,33 @@ const { VERSION } = require('../utils/version')
  * @version 0.8.8
  */
 
+import { execSync } from 'child_process'
+import installer from './command-installer'
+import migrator from './migrator'
+import legacyDetector from './legacy-installer-detector'
+import editorsConfig from './editors-config'
+import { VERSION } from '../utils/version'
+
 // Colors
 const GREEN = '\x1b[32m'
 const YELLOW = '\x1b[33m'
-const MAGENTA = '\x1b[35m'
-const BOLD = '\x1b[1m'
 const DIM = '\x1b[2m'
 const NC = '\x1b[0m'
 
+interface SetupResults {
+  legacyCleaned: boolean
+  legacyProjectsMigrated: number
+  claudeInstalled: boolean
+  commandsAdded: number
+  commandsUpdated: number
+  configAction: string | null
+  projectsMigrated: number
+}
+
 /**
  * Check if Claude Code CLI is installed
  */
-async function hasClaudeCodeCLI() {
+async function hasClaudeCodeCLI(): Promise<boolean> {
   try {
     execSync('which claude', { stdio: 'ignore' })
     return true
@@ -46,7 +54,7 @@ async function hasClaudeCodeCLI() {
 /**
  * Install Claude Code CLI
  */
-async function installClaudeCode() {
+async function installClaudeCode(): Promise<boolean> {
   try {
     console.log(`${YELLOW}📦 Claude Code not found. Installing...${NC}`)
     console.log('')
@@ -56,7 +64,7 @@ async function installClaudeCode() {
     console.log('')
     return true
   } catch (error) {
-    console.log(`${YELLOW}⚠️  Failed to install Claude Code: ${error.message}${NC}`)
+    console.log(`${YELLOW}⚠️  Failed to install Claude Code: ${(error as Error).message}${NC}`)
     console.log(`${DIM}Please install manually: npm install -g @anthropic-ai/claude-code${NC}`)
     console.log('')
     return false
@@ -66,15 +74,15 @@ async function installClaudeCode() {
 /**
  * Main setup function
  */
-async function run() {
-  const results = {
+export async function run(): Promise<SetupResults> {
+  const results: SetupResults = {
     legacyCleaned: false,
     legacyProjectsMigrated: 0,
     claudeInstalled: false,
     commandsAdded: 0,
     commandsUpdated: 0,
     configAction: null,
-    projectsMigrated: 0
+    projectsMigrated: 0,
   }
 
   // Step 0: Detect and clean legacy curl installation
@@ -120,7 +128,7 @@ async function run() {
     const migrationResult = await migrator.migrateAll({
       deepScan: false,
       cleanupLegacy: true,
-      dryRun: false
+      dryRun: false,
     })
 
     if (migrationResult.successfullyMigrated > 0) {
@@ -140,14 +148,16 @@ async function run() {
 /**
  * Show setup results
  */
-function showResults(results) {
+function showResults(results: SetupResults): void {
   console.log('')
 
   // Show what was done
   if (results.legacyCleaned) {
     console.log(`   ${GREEN}✓${NC} Legacy curl installation cleaned up`)
     if (results.legacyProjectsMigrated > 0) {
-      console.log(`   ${GREEN}✓${NC} ${results.legacyProjectsMigrated} project(s) migrated from legacy`)
+      console.log(
+        `   ${GREEN}✓${NC} ${results.legacyProjectsMigrated} project(s) migrated from legacy`
+      )
     }
   }
 
@@ -159,7 +169,7 @@ function showResults(results) {
 
   const totalCommands = results.commandsAdded + results.commandsUpdated
   if (totalCommands > 0) {
-    const parts = []
+    const parts: string[] = []
     if (results.commandsAdded > 0) parts.push(`${results.commandsAdded} new`)
     if (results.commandsUpdated > 0) parts.push(`${results.commandsUpdated} updated`)
     console.log(`   ${GREEN}✓${NC} Commands synced (${parts.join(', ')})`)
@@ -181,5 +191,3 @@ function showResults(results) {
 
   console.log('')
 }
-
-module.exports = { run }

package/core/infrastructure/{update-checker.js → update-checker.ts}

@@ -1,9 +1,32 @@
-const https = require('https')
-const fs = require('fs')
-const path = require('path')
-const os = require('os')
+/**
+ * UpdateChecker - Checks for package updates from npm registry
+ *
+ * @version 0.5.0
+ */
+
+import https from 'https'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import chalk from 'chalk'
+
+interface UpdateCache {
+  lastCheck: number
+  latestVersion: string
+}
+
+interface UpdateResult {
+  updateAvailable: boolean
+  currentVersion: string
+  latestVersion: string
+}
 
 class UpdateChecker {
+  packageName: string
+  cacheDir: string
+  cacheFile: string
+  checkInterval: number
+
   constructor() {
     this.packageName = 'prjct-cli'
     this.cacheDir = path.join(os.homedir(), '.prjct-cli', 'config')
@@ -14,13 +37,13 @@ class UpdateChecker {
   /**
    * Get current installed version from package.json
    */
-  getCurrentVersion() {
+  getCurrentVersion(): string | null {
     try {
       const packageJsonPath = path.join(__dirname, '..', '..', 'package.json')
       const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
       return packageJson.version
     } catch (error) {
-      console.error('Error reading package version:', error.message)
+      console.error('Error reading package version:', (error as Error).message)
       return null
     }
   }
@@ -28,7 +51,7 @@ class UpdateChecker {
   /**
    * Fetch latest version from npm registry
    */
-  async getLatestVersion() {
+  async getLatestVersion(): Promise<string> {
     return new Promise((resolve, reject) => {
       const options = {
         hostname: 'registry.npmjs.org',
@@ -78,7 +101,7 @@ class UpdateChecker {
    * Compare two semantic versions
    * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
    */
-  compareVersions(v1, v2) {
+  compareVersions(v1: string, v2: string): number {
     const parts1 = v1.split('.').map(Number)
     const parts2 = v2.split('.').map(Number)
 
@@ -96,13 +119,13 @@ class UpdateChecker {
   /**
    * Read cache file
    */
-  readCache() {
+  readCache(): UpdateCache | null {
     try {
       if (fs.existsSync(this.cacheFile)) {
         const cache = JSON.parse(fs.readFileSync(this.cacheFile, 'utf8'))
         return cache
       }
-    } catch (error) {
+    } catch {
       // Cache file doesn't exist or is corrupted, ignore
     }
     return null
@@ -111,7 +134,7 @@ class UpdateChecker {
   /**
    * Write cache file
    */
-  writeCache(data) {
+  writeCache(data: UpdateCache): void {
     try {
       // Ensure cache directory exists
       if (!fs.existsSync(this.cacheDir)) {
@@ -119,7 +142,7 @@ class UpdateChecker {
       }
 
       fs.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), 'utf8')
-    } catch (error) {
+    } catch {
       // Fail silently - cache is not critical
     }
   }
@@ -128,7 +151,7 @@ class UpdateChecker {
    * Check if update is available (respects 24-hour cache)
    * Returns: { updateAvailable: boolean, currentVersion: string, latestVersion: string } or null
    */
-  async checkForUpdates() {
+  async checkForUpdates(): Promise<UpdateResult | null> {
     try {
       const currentVersion = this.getCurrentVersion()
       if (!currentVersion) {
@@ -172,7 +195,7 @@ class UpdateChecker {
         currentVersion,
         latestVersion,
       }
-    } catch (error) {
+    } catch {
       // Network error or other issue - fail silently
       // Return null to indicate check couldn't be performed
       return null
@@ -182,15 +205,13 @@ class UpdateChecker {
   /**
    * Get formatted update notification message
    */
-  async getUpdateNotification() {
+  async getUpdateNotification(): Promise<string | null> {
     const result = await this.checkForUpdates()
 
     if (!result || !result.updateAvailable) {
       return null
     }
 
-    const chalk = require('chalk')
-
     return (
       '\n' +
       chalk.yellow('┌───────────────────────────────────────────────────────────┐') +
@@ -219,4 +240,5 @@ class UpdateChecker {
   }
 }
 
-module.exports = UpdateChecker
+export default UpdateChecker
+export { UpdateChecker }