prjct-cli 0.11.5 → 0.12.0

package/core/infrastructure/migrator/version-migration.ts

@@ -0,0 +1,117 @@
+/**
+ * Version Migration
+ * Handles migration between prjct versions.
+ */
+
+import configManager from '../config-manager'
+import type { Author, VersionMigrationResult } from './types'
+
+/**
+ * Check if a project needs migration
+ */
+export async function needsMigration(projectPath: string): Promise<boolean> {
+  const structureMigration = await configManager.needsMigration(projectPath)
+  if (structureMigration) return true
+
+  const config = await configManager.readConfig(projectPath)
+  if (config && config.version && config.version.startsWith('0.2.')) {
+    return true
+  }
+
+  return false
+}
+
+/**
+ * Migrate config from 0.2.x to 0.3.0 (move authors to global config)
+ */
+export async function migrateConfigTo030(projectPath: string): Promise<VersionMigrationResult> {
+  const result: VersionMigrationResult = {
+    success: false,
+    message: '',
+    oldVersion: null,
+    newVersion: '0.3.0',
+  }
+
+  try {
+    const localConfig = await configManager.readConfig(projectPath)
+    if (!localConfig) {
+      result.message = 'No config found'
+      return result
+    }
+
+    result.oldVersion = localConfig.version || null
+    const projectId = localConfig.projectId
+
+    const globalConfig = await configManager.readGlobalConfig(projectId)
+    if (globalConfig && globalConfig.authors && globalConfig.authors.length > 0) {
+      const needsCleanup =
+        localConfig.authors ||
+        localConfig.author ||
+        localConfig.version ||
+        localConfig.created ||
+        localConfig.lastSync
+
+      if (needsCleanup) {
+        delete localConfig.authors
+        delete localConfig.author
+        delete localConfig.version
+        delete localConfig.created
+        delete localConfig.lastSync
+        await configManager.writeConfig(projectPath, localConfig)
+      }
+      result.success = true
+      result.message = 'Authors already in global config, cleaned up local config'
+      return result
+    }
+
+    let authors: Author[] = []
+    const now = new Date().toISOString()
+
+    if (localConfig.authors && Array.isArray(localConfig.authors)) {
+      authors = localConfig.authors
+    } else if (localConfig.author) {
+      authors = [
+        {
+          name: localConfig.author.name || 'Unknown',
+          email: localConfig.author.email || '',
+          github: localConfig.author.github || '',
+          firstContribution: localConfig.created || now,
+          lastActivity: localConfig.lastSync || now,
+        },
+      ]
+    } else {
+      authors = [
+        {
+          name: 'Unknown',
+          email: '',
+          github: '',
+          firstContribution: now,
+          lastActivity: now,
+        },
+      ]
+    }
+
+    const newGlobalConfig = {
+      projectId,
+      authors,
+      version: '0.3.0',
+      created: localConfig.created || now,
+      lastSync: now,
+    }
+    await configManager.writeGlobalConfig(projectId, newGlobalConfig)
+
+    delete localConfig.authors
+    delete localConfig.author
+    delete localConfig.version
+    delete localConfig.created
+    delete localConfig.lastSync
+    await configManager.writeConfig(projectPath, localConfig)
+
+    result.success = true
+    result.message = `Migrated ${authors.length} author(s) to global config`
+    return result
+  } catch (error) {
+    result.message = `Migration failed: ${(error as Error).message}`
+    return result
+  }
+}

package/core/infrastructure/migrator.ts

@@ -0,0 +1,10 @@
+/**
+ * Migrator
+ * Re-exports from migrator/index.ts for backwards compatibility.
+ *
+ * @module infrastructure/migrator
+ */
+
+import migrator from './migrator/index'
+export default migrator
+export * from './migrator/types'

package/core/infrastructure/{path-manager.js → path-manager.ts}

@@ -1,10 +1,3 @@
-const fs = require('fs').promises
-const path = require('path')
-const crypto = require('crypto')
-const os = require('os')
-const dateHelper = require('../utils/date-helper')
-const fileHelper = require('../utils/file-helper')
-
 /**
  * PathManager - Manages project paths between local and global storage
  *
@@ -15,7 +8,27 @@ const fileHelper = require('../utils/file-helper')
  *
  * @version 0.2.1
  */
+
+import fs from 'fs/promises'
+import path from 'path'
+import crypto from 'crypto'
+import os from 'os'
+import * as dateHelper from '../utils/date-helper'
+import * as fileHelper from '../utils/file-helper'
+
+interface SessionInfo {
+  year: string
+  month: string
+  day: string
+  path: string
+  date: Date
+}
+
 class PathManager {
+  globalBaseDir: string
+  globalProjectsDir: string
+  globalConfigDir: string
+
   constructor() {
     this.globalBaseDir = path.join(os.homedir(), '.prjct-cli')
     this.globalProjectsDir = path.join(this.globalBaseDir, 'projects')
@@ -25,11 +38,8 @@ class PathManager {
   /**
    * Generate a unique project ID from the absolute project path
    * Uses SHA-256 hash of the absolute path for consistency
-   *
-   * @param {string} projectPath - Absolute path to the project
-   * @returns {string} - 12-character hash ID
    */
-  generateProjectId(projectPath) {
+  generateProjectId(projectPath: string): string {
     const absolutePath = path.resolve(projectPath)
     const hash = crypto.createHash('sha256').update(absolutePath).digest('hex')
     return hash.substring(0, 12) // Use first 12 chars for readability
@@ -37,72 +47,52 @@ class PathManager {
 
   /**
    * Get the base global storage path
-   *
-   * @returns {string} - Path to global base directory (~/.prjct-cli)
    */
-  getGlobalBasePath() {
+  getGlobalBasePath(): string {
     return this.globalBaseDir
   }
 
   /**
    * Get the global storage path for a project
-   *
-   * @param {string} projectId - The project identifier
-   * @returns {string} - Path to global project storage
    */
-  getGlobalProjectPath(projectId) {
+  getGlobalProjectPath(projectId: string): string {
     return path.join(this.globalProjectsDir, projectId)
   }
 
   /**
    * Get the local config file path for a project
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {string} - Path to .prjct/prjct.config.json
    */
-  getLocalConfigPath(projectPath) {
+  getLocalConfigPath(projectPath: string): string {
     return path.join(projectPath, '.prjct', 'prjct.config.json')
   }
 
   /**
    * Get the global config file path for a project
    * This file stores authors and other system data that shouldn't be versioned
-   *
-   * @param {string} projectId - The project identifier
-   * @returns {string} - Path to ~/.prjct-cli/projects/{id}/project.json
    */
-  getGlobalProjectConfigPath(projectId) {
+  getGlobalProjectConfigPath(projectId: string): string {
     return path.join(this.getGlobalProjectPath(projectId), 'project.json')
   }
 
   /**
    * Get the legacy .prjct directory path
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {string} - Path to legacy .prjct directory
    */
-  getLegacyPrjctPath(projectPath) {
+  getLegacyPrjctPath(projectPath: string): string {
     return path.join(projectPath, '.prjct')
   }
 
   /**
    * Check if a project has legacy .prjct directory
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<boolean>} - True if legacy directory exists
    */
-  async hasLegacyStructure(projectPath) {
+  async hasLegacyStructure(projectPath: string): Promise<boolean> {
     const legacyPath = this.getLegacyPrjctPath(projectPath)
     return await fileHelper.dirExists(legacyPath)
   }
 
   /**
    * Check if a project has the new config file
-   *
-   * @param {string} projectPath - Path to the project
-   * @returns {Promise<boolean>} - True if config exists
    */
-  async hasConfig(projectPath) {
+  async hasConfig(projectPath: string): Promise<boolean> {
     const configPath = this.getLocalConfigPath(projectPath)
     return await fileHelper.fileExists(configPath)
   }
@@ -110,10 +100,8 @@ class PathManager {
   /**
    * Ensure the global directory structure exists
    * Creates all necessary directories in ~/.prjct-cli/
-   *
-   * @returns {Promise<void>}
    */
-  async ensureGlobalStructure() {
+  async ensureGlobalStructure(): Promise<void> {
     await fileHelper.ensureDir(this.globalBaseDir)
     await fileHelper.ensureDir(this.globalProjectsDir)
     await fileHelper.ensureDir(this.globalConfigDir)
@@ -122,11 +110,8 @@ class PathManager {
   /**
    * Ensure the project-specific global structure exists
    * Creates the layered directory structure for a project
-   *
-   * @param {string} projectId - The project identifier
-   * @returns {Promise<string>} - Path to the project's global storage
    */
-  async ensureProjectStructure(projectId) {
+  async ensureProjectStructure(projectId: string): Promise<string> {
     await this.ensureGlobalStructure()
 
     const projectPath = this.getGlobalProjectPath(projectId)
@@ -146,12 +131,8 @@ class PathManager {
   /**
    * Get session directory path for a specific date
    * Creates hierarchical structure: sessions/YYYY/MM/DD/
-   *
-   * @param {string} projectId - The project identifier
-   * @param {Date} date - Date for the session (defaults to today)
-   * @returns {string} - Path to session directory
    */
-  getSessionPath(projectId, date = new Date()) {
+  getSessionPath(projectId: string, date: Date = new Date()): string {
     const { year, month, day } = dateHelper.getYearMonthDay(date)
 
     return path.join(this.getGlobalProjectPath(projectId), 'sessions', year, month, day)
@@ -159,22 +140,15 @@ class PathManager {
 
   /**
    * Get current session directory path (today)
-   *
-   * @param {string} projectId - The project identifier
-   * @returns {string} - Path to today's session directory
    */
-  getCurrentSessionPath(projectId) {
+  getCurrentSessionPath(projectId: string): string {
     return this.getSessionPath(projectId, new Date())
   }
 
   /**
    * Ensure session directory exists for a specific date
-   *
-   * @param {string} projectId - The project identifier
-   * @param {Date} date - Date for the session (defaults to today)
-   * @returns {Promise<string>} - Path to session directory
    */
-  async ensureSessionPath(projectId, date = new Date()) {
+  async ensureSessionPath(projectId: string, date: Date = new Date()): Promise<string> {
     const sessionPath = this.getSessionPath(projectId, date)
     await fileHelper.ensureDir(sessionPath)
     return sessionPath
@@ -182,15 +156,14 @@ class PathManager {
 
   /**
    * List all session dates for a project
-   *
-   * @param {string} projectId - The project identifier
-   * @param {number} year - Optional year filter
-   * @param {number} month - Optional month filter (1-12)
-   * @returns {Promise<Array<{year: string, month: string, day: string, path: string}>>} - Array of session info
    */
-  async listSessions(projectId, year = null, month = null) {
+  async listSessions(
+    projectId: string,
+    year: number | null = null,
+    month: number | null = null
+  ): Promise<SessionInfo[]> {
     const sessionsDir = path.join(this.getGlobalProjectPath(projectId), 'sessions')
-    const sessions = []
+    const sessions: SessionInfo[] = []
 
     try {
       const years = await fs.readdir(sessionsDir, { withFileTypes: true })
@@ -223,7 +196,7 @@ class PathManager {
         }
       }
 
-      sessions.sort((a, b) => b.date - a.date)
+      sessions.sort((a, b) => b.date.getTime() - a.date.getTime())
       return sessions
     } catch {
       return []
@@ -232,13 +205,12 @@ class PathManager {
 
   /**
    * Get sessions within a date range
-   *
-   * @param {string} projectId - The project identifier
-   * @param {Date} fromDate - Start date (inclusive)
-   * @param {Date} toDate - End date (inclusive, defaults to today)
-   * @returns {Promise<Array>} - Array of session info within range
    */
-  async getSessionsInRange(projectId, fromDate, toDate = new Date()) {
+  async getSessionsInRange(
+    projectId: string,
+    fromDate: Date,
+    toDate: Date = new Date()
+  ): Promise<SessionInfo[]> {
     const allSessions = await this.listSessions(projectId)
 
     return allSessions.filter((session) => session.date >= fromDate && session.date <= toDate)
@@ -246,22 +218,15 @@ class PathManager {
 
   /**
    * Get the path for a specific file in the global structure
-   *
-   * @param {string} projectId - The project identifier
-   * @param {string} layer - The layer (core, progress, planning, analysis, memory)
-   * @param {string} filename - The filename
-   * @returns {string} - Full path to the file
    */
-  getFilePath(projectId, layer, filename) {
+  getFilePath(projectId: string, layer: string, filename: string): string {
     return path.join(this.getGlobalProjectPath(projectId), layer, filename)
   }
 
   /**
    * Get all project IDs in global storage
-   *
-   * @returns {Promise<string[]>} - Array of project IDs
    */
-  async listProjects() {
+  async listProjects(): Promise<string[]> {
     try {
       await this.ensureGlobalStructure()
       const entries = await fs.readdir(this.globalProjectsDir, { withFileTypes: true })
@@ -273,22 +238,16 @@ class PathManager {
 
   /**
    * Check if a project exists in global storage
-   *
-   * @param {string} projectId - The project identifier
-   * @returns {Promise<boolean>} - True if project exists
    */
-  async projectExists(projectId) {
+  async projectExists(projectId: string): Promise<boolean> {
     const projectPath = this.getGlobalProjectPath(projectId)
     return await fileHelper.dirExists(projectPath)
   }
 
   /**
    * Get the relative path from home directory for display
-   *
-   * @param {string} absolutePath - Absolute path
-   * @returns {string} - Path with ~ notation
    */
-  getDisplayPath(absolutePath) {
+  getDisplayPath(absolutePath: string): string {
     const homeDir = os.homedir()
     if (absolutePath.startsWith(homeDir)) {
       return absolutePath.replace(homeDir, '~')
@@ -297,4 +256,5 @@ class PathManager {
   }
 }
 
-module.exports = new PathManager()
+const pathManager = new PathManager()
+export default pathManager

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

@@ -0,0 +1,23 @@
+/**
+ * Session Manager
+ * Manages temporal fragmentation of logs and progress data.
+ *
+ * @module infrastructure/session-manager
+ * @version 0.2.1
+ */
+
+export type {
+  SessionEntry,
+  SessionMetadata,
+  SessionStats,
+  MigrationResult,
+  SessionInfo,
+} from './types'
+
+export { migrateLegacyJsonl, migrateLegacyMarkdown } from './migration'
+export { SessionManager } from './session-manager'
+
+import { SessionManager } from './session-manager'
+
+const sessionManager = new SessionManager()
+export default sessionManager

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

@@ -0,0 +1,88 @@
+/**
+ * Session Migration
+ * Migrate legacy single-file logs to session structure
+ */
+
+import path from 'path'
+import pathManager from '../path-manager'
+import * as dateHelper from '../../utils/date-helper'
+import * as jsonlHelper from '../../utils/jsonl-helper'
+import * as fileHelper from '../../utils/file-helper'
+import type { SessionEntry, MigrationResult, SessionMetadata } from './types'
+
+/**
+ * Migrate legacy JSONL file
+ */
+export async function migrateLegacyJsonl(
+  projectId: string,
+  content: string,
+  sessionFilename: string,
+  updateMetadata: (sessionPath: string, updates: Partial<SessionMetadata>) => Promise<void>,
+  ensureMetadata: (sessionPath: string) => Promise<void>
+): Promise<MigrationResult> {
+  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<SessionMetadata>) => Promise<void>
+): Promise<MigrationResult> {
+  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,
+  }
+}