prjct-cli 0.11.5 → 0.12.1

package/core/session/{index.js → session-manager.ts}

@@ -1,37 +1,27 @@
 /**
- * SessionManager - Structured Session Tracking
- *
- * Tracks work sessions with metrics, timeline, and duration.
- * Inspired by OpenCode's session system but simplified.
- *
- * Storage: ~/.prjct-cli/projects/{projectId}/sessions/
- *
- * @version 1.0.0
+ * SessionManager Class
+ * Core session management functionality
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const pathManager = require('../infrastructure/path-manager')
-const configManager = require('../infrastructure/config-manager')
-const { eventBus, emit } = require('../bus')
-
-/**
- * Session Schema
- * @typedef {Object} Session
- * @property {string} id - Unique session ID (sess_xxxx)
- * @property {string} projectId - Project identifier
- * @property {string} task - Task description
- * @property {'active'|'paused'|'completed'} status - Current status
- * @property {string} startedAt - ISO timestamp when started
- * @property {string} [pausedAt] - ISO timestamp when paused
- * @property {string} [completedAt] - ISO timestamp when completed
- * @property {number} duration - Total duration in seconds
- * @property {Object} metrics - Automatic metrics
- * @property {Array} timeline - Event history
- */
-
-class SessionManager {
-  constructor(projectPath) {
+import fs from 'fs/promises'
+import path from 'path'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import pathManager from '../infrastructure/path-manager'
+import configManager from '../infrastructure/config-manager'
+import { emit } from '../bus'
+import type { Session, SessionMetrics } from './types'
+import { generateId, calculateDuration, formatDuration } from './utils'
+
+const execAsync = promisify(exec)
+
+export class SessionManager {
+  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
@@ -41,7 +31,7 @@ class SessionManager {
   /**
    * Initialize session manager for project
    */
-  async initialize() {
+  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.')
@@ -57,23 +47,17 @@ class SessionManager {
   /**
    * Generate unique session ID
    */
-  generateId() {
-    const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
-    let id = 'sess_'
-    for (let i = 0; i < 8; i++) {
-      id += chars.charAt(Math.floor(Math.random() * chars.length))
-    }
-    return id
+  generateId(): string {
+    return generateId()
   }
 
   /**
    * Get current active session
-   * @returns {Promise<Session|null>}
    */
-  async getCurrent() {
+  async getCurrent(): Promise<Session | null> {
     if (!this.initialized) await this.initialize()
 
-    const currentPath = path.join(this.sessionDir, 'current.json')
+    const currentPath = path.join(this.sessionDir!, 'current.json')
     try {
       const content = await fs.readFile(currentPath, 'utf-8')
       return JSON.parse(content)
@@ -84,10 +68,8 @@ class SessionManager {
 
   /**
    * Create a new session
-   * @param {string} task - Task description
-   * @returns {Promise<Session>}
    */
-  async create(task) {
+  async create(task: string): Promise<Session> {
     if (!this.initialized) await this.initialize()
 
     // Check if there's already an active session
@@ -97,9 +79,9 @@ class SessionManager {
     }
 
     const now = new Date().toISOString()
-    const session = {
+    const session: Session = {
       id: this.generateId(),
-      projectId: this.projectId,
+      projectId: this.projectId!,
       task,
       status: 'active',
       startedAt: now,
@@ -136,10 +118,8 @@ class SessionManager {
 
   /**
    * Resume a paused session or continue active session
-   * @param {string} [task] - Optional new task (creates new session if provided)
-   * @returns {Promise<Session>}
    */
-  async resume(task = null) {
+  async resume(task: string | null = null): Promise<Session> {
     if (!this.initialized) await this.initialize()
 
     const current = await this.getCurrent()
@@ -182,9 +162,8 @@ class SessionManager {
 
   /**
    * Pause current session
-   * @returns {Promise<Session>}
    */
-  async pause() {
+  async pause(): Promise<Session> {
     if (!this.initialized) await this.initialize()
 
     const current = await this.getCurrent()
@@ -199,7 +178,7 @@ class SessionManager {
     const now = new Date().toISOString()
     current.status = 'paused'
     current.pausedAt = now
-    current.duration = this.calculateDuration(current)
+    current.duration = calculateDuration(current)
     current.timeline.push({ type: 'pause', at: now })
 
     await this.saveCurrent(current)
@@ -218,9 +197,8 @@ class SessionManager {
 
   /**
    * Complete current session
-   * @returns {Promise<Session>}
    */
-  async complete() {
+  async complete(): Promise<Session> {
     if (!this.initialized) await this.initialize()
 
     const current = await this.getCurrent()
@@ -231,7 +209,7 @@ class SessionManager {
     const now = new Date().toISOString()
     current.status = 'completed'
     current.completedAt = now
-    current.duration = this.calculateDuration(current)
+    current.duration = calculateDuration(current)
     current.metrics = await this.calculateMetrics(current)
     current.timeline.push({ type: 'complete', at: now })
 
@@ -263,45 +241,18 @@ class SessionManager {
 
   /**
    * Calculate total duration in seconds
-   * @param {Session} session
-   * @returns {number}
    */
-  calculateDuration(session) {
-    let totalMs = 0
-    let lastStart = null
-
-    for (const event of session.timeline) {
-      if (event.type === 'start' || event.type === 'resume') {
-        lastStart = new Date(event.at)
-      } else if (event.type === 'pause' || event.type === 'complete') {
-        if (lastStart) {
-          totalMs += new Date(event.at) - lastStart
-          lastStart = null
-        }
-      }
-    }
-
-    // If still active, count from last start to now
-    if (lastStart && session.status === 'active') {
-      totalMs += Date.now() - lastStart
-    }
-
-    return Math.round(totalMs / 1000)
+  calculateDuration(session: Session): number {
+    return calculateDuration(session)
   }
 
   /**
    * Calculate metrics for session
-   * @param {Session} session
-   * @returns {Promise<Object>}
    */
-  async calculateMetrics(session) {
+  async calculateMetrics(session: Session): Promise<SessionMetrics> {
     const metrics = { ...session.metrics }
 
     try {
-      const { exec } = require('child_process')
-      const { promisify } = require('util')
-      const execAsync = promisify(exec)
-
       // Get git stats since session start
       const since = session.startedAt.split('T')[0]
 
@@ -337,18 +288,17 @@ class SessionManager {
 
   /**
    * Save current session
-   * @param {Session} session
    */
-  async saveCurrent(session) {
-    const currentPath = path.join(this.sessionDir, 'current.json')
+  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() {
-    const currentPath = path.join(this.sessionDir, 'current.json')
+  async clearCurrent(): Promise<void> {
+    const currentPath = path.join(this.sessionDir!, 'current.json')
     try {
       await fs.unlink(currentPath)
     } catch {
@@ -358,12 +308,11 @@ class SessionManager {
 
   /**
    * Archive completed session
-   * @param {Session} session
    */
-  async archive(session) {
-    const date = new Date(session.completedAt)
+  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)
+    const archiveDir = path.join(this.sessionDir!, 'archive', yearMonth)
 
     await fs.mkdir(archiveDir, { recursive: true })
 
@@ -373,14 +322,12 @@ class SessionManager {
 
   /**
    * Get session history
-   * @param {number} limit - Max sessions to return
-   * @returns {Promise<Session[]>}
    */
-  async getHistory(limit = 10) {
+  async getHistory(limit: number = 10): Promise<Session[]> {
     if (!this.initialized) await this.initialize()
 
-    const sessions = []
-    const archiveDir = path.join(this.sessionDir, 'archive')
+    const sessions: Session[] = []
+    const archiveDir = path.join(this.sessionDir!, 'archive')
 
     try {
       const months = await fs.readdir(archiveDir)
@@ -409,11 +356,9 @@ class SessionManager {
 
   /**
    * Log event to memory
-   * @param {string} action
-   * @param {Object} data
    */
-  async logEvent(action, data) {
-    const globalPath = pathManager.getGlobalProjectPath(this.projectId)
+  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({
@@ -431,19 +376,8 @@ class SessionManager {
 
   /**
    * Format duration as human readable
-   * @param {number} seconds
-   * @returns {string}
    */
-  static 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`
+  static formatDuration(seconds: number): string {
+    return formatDuration(seconds)
   }
 }
-
-module.exports = SessionManager

package/core/session/types.ts

@@ -0,0 +1,29 @@
+/**
+ * Session Types
+ */
+
+export interface SessionMetrics {
+  filesChanged: number
+  linesAdded: number
+  linesRemoved: number
+  commits: number
+  snapshots: string[]
+}
+
+export interface TimelineEvent {
+  type: 'start' | 'pause' | 'resume' | 'complete'
+  at: string
+}
+
+export interface Session {
+  id: string
+  projectId: string
+  task: string
+  status: 'active' | 'paused' | 'completed'
+  startedAt: string
+  pausedAt: string | null
+  completedAt: string | null
+  duration: number
+  metrics: SessionMetrics
+  timeline: TimelineEvent[]
+}

package/core/session/utils.ts

@@ -0,0 +1,57 @@
+/**
+ * Session Utilities
+ */
+
+import type { Session, TimelineEvent } from './types'
+
+/**
+ * Generate unique session ID
+ */
+export function generateId(): string {
+  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
+  let id = 'sess_'
+  for (let i = 0; i < 8; i++) {
+    id += chars.charAt(Math.floor(Math.random() * chars.length))
+  }
+  return id
+}
+
+/**
+ * Calculate total duration in seconds
+ */
+export function calculateDuration(session: Session): number {
+  let totalMs = 0
+  let lastStart: Date | null = null
+
+  for (const event of session.timeline) {
+    if (event.type === 'start' || event.type === 'resume') {
+      lastStart = new Date(event.at)
+    } else if (event.type === 'pause' || event.type === 'complete') {
+      if (lastStart) {
+        totalMs += new Date(event.at).getTime() - lastStart.getTime()
+        lastStart = null
+      }
+    }
+  }
+
+  // If still active, count from last start to now
+  if (lastStart && session.status === 'active') {
+    totalMs += Date.now() - lastStart.getTime()
+  }
+
+  return Math.round(totalMs / 1000)
+}
+
+/**
+ * Format duration as human readable
+ */
+export function 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`
+}

package/core/state/index.ts

@@ -0,0 +1,25 @@
+/**
+ * State Module
+ *
+ * Unified project state management.
+ * Single source of truth replacing scattered file reads.
+ *
+ * @example
+ * ```typescript
+ * import stateManager from './state'
+ *
+ * // Read state
+ * const state = await stateManager.read(projectId)
+ *
+ * // Update state
+ * await stateManager.startTask(projectId, { id: 'task_1', description: 'auth' })
+ * await stateManager.completeTask(projectId, '2h 15m')
+ * ```
+ */
+
+import stateManager from './manager'
+
+export { StateManager } from './manager'
+export { stateManager }
+export default stateManager
+export * from './types'