prjct-cli 1.21.0 → 1.23.0

package/core/services/project-service.ts

@@ -1,155 +0,0 @@
-/**
- * ProjectService - Project detection, validation, and path resolution
- *
- * Handles project initialization detection, author management, and directory analysis.
- */
-
-import { ProjectError } from '../errors'
-import * as authorDetector from '../infrastructure/author-detector'
-import configManager from '../infrastructure/config-manager'
-import pathManager from '../infrastructure/path-manager'
-import type { Author, CommandResult } from '../types'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-import * as fileHelper from '../utils/file-helper'
-import out from '../utils/output'
-
-export class ProjectService {
-  private currentAuthor: Author | null = null
-
-  /**
-   * Ensure project is initialized
-   */
-  async ensureInit(projectPath: string): Promise<CommandResult> {
-    if (await configManager.isConfigured(projectPath)) {
-      return { success: true }
-    }
-
-    out.spin('initializing project...')
-    // Lazy import to avoid circular dependency
-    const { PlanningCommands } = await import('../commands/planning')
-    const planning = new PlanningCommands()
-    const initResult = await planning.init(null, projectPath)
-
-    if (!initResult.success) {
-      return initResult
-    }
-    return { success: true }
-  }
-
-  /**
-   * Get project ID for a path
-   */
-  async getProjectId(projectPath: string): Promise<string> {
-    const projectId = await configManager.getProjectId(projectPath)
-    if (!projectId) {
-      throw ProjectError.notInitialized()
-    }
-    return projectId
-  }
-
-  /**
-   * Get global storage path for a project
-   */
-  async getGlobalPath(projectPath: string): Promise<string> {
-    const projectId = await this.getProjectId(projectPath)
-    await pathManager.ensureProjectStructure(projectId)
-    return pathManager.getGlobalProjectPath(projectId)
-  }
-
-  /**
-   * Ensure author information is loaded
-   */
-  async ensureAuthor(): Promise<Author> {
-    if (this.currentAuthor) return this.currentAuthor
-
-    const authorObj = await authorDetector.detect()
-    this.currentAuthor = {
-      name: authorObj.name ?? undefined,
-      email: authorObj.email ?? undefined,
-      github: authorObj.github ?? undefined,
-    }
-    return this.currentAuthor
-  }
-
-  /**
-   * Get current author
-   */
-  getCurrentAuthor(): Author | null {
-    return this.currentAuthor
-  }
-
-  /**
-   * Clear cached author (useful for tests)
-   */
-  clearAuthorCache(): void {
-    this.currentAuthor = null
-  }
-
-  /**
-   * Check if directory is empty (excluding common files)
-   */
-  async isEmptyDirectory(projectPath: string): Promise<boolean> {
-    try {
-      const entries = await fileHelper.listFiles(projectPath)
-      const meaningfulFiles = entries.filter(
-        (name) =>
-          !name.startsWith('.') &&
-          name !== 'node_modules' &&
-          name !== 'package.json' &&
-          name !== 'package-lock.json' &&
-          name !== 'README.md'
-      )
-      return meaningfulFiles.length === 0
-    } catch (error) {
-      // Directory read error - treat as empty (expected for new dirs)
-      if (!isNotFoundError(error)) {
-        console.error(`Directory check error: ${getErrorMessage(error)}`)
-      }
-      return true
-    }
-  }
-
-  /**
-   * Check if directory has existing code
-   */
-  async hasExistingCode(projectPath: string): Promise<boolean> {
-    try {
-      const codePatterns = [
-        'src',
-        'lib',
-        'app',
-        'components',
-        'pages',
-        'api',
-        'main.go',
-        'main.rs',
-        'main.py',
-      ]
-      const entries = await fileHelper.listFiles(projectPath)
-      return entries.some((name) => codePatterns.includes(name))
-    } catch (error) {
-      // Directory read error - treat as no code (expected for new dirs)
-      if (!isNotFoundError(error)) {
-        console.error(`Code check error: ${getErrorMessage(error)}`)
-      }
-      return false
-    }
-  }
-
-  /**
-   * Check if project is configured
-   */
-  async isConfigured(projectPath: string): Promise<boolean> {
-    return await configManager.isConfigured(projectPath)
-  }
-
-  /**
-   * Check if project needs migration
-   */
-  async needsMigration(projectPath: string): Promise<boolean> {
-    return await configManager.needsMigration(projectPath)
-  }
-}
-
-export const projectService = new ProjectService()
-export default projectService

package/core/services/session-tracker.ts

@@ -1,287 +0,0 @@
-/**
- * SessionTracker - Lightweight session state tracking for multi-command workflows
- *
- * Tracks command sequences and file access across CLI invocations.
- * Sessions auto-create on first command and expire after 30 min idle.
- *
- * Storage: ~/.prjct-cli/projects/{projectId}/storage/session.json
- *
- * @see PRJ-109
- */
-
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import pathManager from '../infrastructure/path-manager'
-import { isNotFoundError } from '../types/fs'
-import { formatDuration, getTimestamp } from '../utils/date-helper'
-
-// =============================================================================
-// TYPES
-// =============================================================================
-
-export interface CommandRecord {
-  command: string
-  timestamp: string
-  durationMs: number
-}
-
-export interface FileRecord {
-  path: string
-  operation: 'read' | 'write'
-  timestamp: string
-}
-
-export interface SessionData {
-  id: string
-  projectId: string
-  status: 'active' | 'expired'
-  createdAt: string
-  lastActivity: string
-  commands: CommandRecord[]
-  files: FileRecord[]
-}
-
-export interface SessionFile {
-  current: SessionData | null
-  config: {
-    idleTimeoutMs: number
-  }
-}
-
-export interface SessionInfo {
-  active: boolean
-  id: string | null
-  duration: string | null
-  idleSince: string | null
-  idleMs: number
-  expiresIn: string | null
-  commandCount: number
-  commands: string[]
-  filesRead: number
-  filesWritten: number
-}
-
-// =============================================================================
-// CONSTANTS
-// =============================================================================
-
-const SESSION_FILENAME = 'session.json'
-const DEFAULT_IDLE_TIMEOUT_MS = 30 * 60 * 1000 // 30 minutes
-const MAX_COMMAND_HISTORY = 50
-const MAX_FILE_HISTORY = 200
-
-// =============================================================================
-// SESSION TRACKER
-// =============================================================================
-
-class SessionTracker {
-  private getPath(projectId: string): string {
-    return pathManager.getStoragePath(projectId, SESSION_FILENAME)
-  }
-
-  /**
-   * Read session file from disk
-   */
-  private async read(projectId: string): Promise<SessionFile> {
-    const filePath = this.getPath(projectId)
-    try {
-      const content = await fs.readFile(filePath, 'utf-8')
-      return JSON.parse(content) as SessionFile
-    } catch (error) {
-      if (isNotFoundError(error) || error instanceof SyntaxError) {
-        return this.getDefault()
-      }
-      throw error
-    }
-  }
-
-  /**
-   * Write session file to disk
-   */
-  private async write(projectId: string, data: SessionFile): Promise<void> {
-    const filePath = this.getPath(projectId)
-    await fs.mkdir(path.dirname(filePath), { recursive: true })
-    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
-  }
-
-  private getDefault(): SessionFile {
-    return {
-      current: null,
-      config: {
-        idleTimeoutMs: DEFAULT_IDLE_TIMEOUT_MS,
-      },
-    }
-  }
-
-  /**
-   * Check if a session has expired based on idle timeout
-   */
-  private isExpired(session: SessionData, timeoutMs: number): boolean {
-    const lastActivity = new Date(session.lastActivity).getTime()
-    const now = Date.now()
-    return now - lastActivity > timeoutMs
-  }
-
-  /**
-   * Touch session — create new or resume existing.
-   * Called at the start of every CLI command.
-   * Returns the active session.
-   */
-  async touch(projectId: string): Promise<SessionData> {
-    const file = await this.read(projectId)
-    const now = getTimestamp()
-
-    // If active session exists and not expired, resume it
-    if (file.current && !this.isExpired(file.current, file.config.idleTimeoutMs)) {
-      file.current.lastActivity = now
-      await this.write(projectId, file)
-      return file.current
-    }
-
-    // Create new session (old one expired or doesn't exist)
-    const session: SessionData = {
-      id: crypto.randomUUID(),
-      projectId,
-      status: 'active',
-      createdAt: now,
-      lastActivity: now,
-      commands: [],
-      files: [],
-    }
-
-    file.current = session
-    await this.write(projectId, file)
-    return session
-  }
-
-  /**
-   * Record a command execution in the current session
-   */
-  async trackCommand(projectId: string, command: string, durationMs: number): Promise<void> {
-    const file = await this.read(projectId)
-    if (!file.current) return
-
-    const now = getTimestamp()
-    file.current.lastActivity = now
-    file.current.commands.push({
-      command,
-      timestamp: now,
-      durationMs,
-    })
-
-    // Trim old commands if over limit
-    if (file.current.commands.length > MAX_COMMAND_HISTORY) {
-      file.current.commands = file.current.commands.slice(-MAX_COMMAND_HISTORY)
-    }
-
-    await this.write(projectId, file)
-  }
-
-  /**
-   * Record a file access in the current session
-   */
-  async trackFile(projectId: string, filePath: string, operation: 'read' | 'write'): Promise<void> {
-    const file = await this.read(projectId)
-    if (!file.current) return
-
-    const now = getTimestamp()
-    file.current.lastActivity = now
-    file.current.files.push({
-      path: filePath,
-      operation,
-      timestamp: now,
-    })
-
-    // Trim old file records if over limit
-    if (file.current.files.length > MAX_FILE_HISTORY) {
-      file.current.files = file.current.files.slice(-MAX_FILE_HISTORY)
-    }
-
-    await this.write(projectId, file)
-  }
-
-  /**
-   * Get session info for display (used by `prjct status`)
-   */
-  async getInfo(projectId: string): Promise<SessionInfo> {
-    const file = await this.read(projectId)
-
-    if (!file.current || this.isExpired(file.current, file.config.idleTimeoutMs)) {
-      return {
-        active: false,
-        id: null,
-        duration: null,
-        idleSince: null,
-        idleMs: 0,
-        expiresIn: null,
-        commandCount: 0,
-        commands: [],
-        filesRead: 0,
-        filesWritten: 0,
-      }
-    }
-
-    const session = file.current
-    const now = Date.now()
-    const createdAt = new Date(session.createdAt).getTime()
-    const lastActivity = new Date(session.lastActivity).getTime()
-    const idleMs = now - lastActivity
-    const timeoutMs = file.config.idleTimeoutMs
-    const expiresInMs = Math.max(0, timeoutMs - idleMs)
-
-    const uniqueCommands = session.commands.map((c) => c.command)
-    const filesRead = new Set(
-      session.files.filter((f) => f.operation === 'read').map((f) => f.path)
-    ).size
-    const filesWritten = new Set(
-      session.files.filter((f) => f.operation === 'write').map((f) => f.path)
-    ).size
-
-    return {
-      active: true,
-      id: session.id,
-      duration: formatDuration(now - createdAt),
-      idleSince: session.lastActivity,
-      idleMs,
-      expiresIn: formatDuration(expiresInMs),
-      commandCount: session.commands.length,
-      commands: uniqueCommands,
-      filesRead,
-      filesWritten,
-    }
-  }
-
-  /**
-   * Expire the current session (cleanup)
-   */
-  async expire(projectId: string): Promise<void> {
-    const file = await this.read(projectId)
-    if (file.current) {
-      file.current.status = 'expired'
-      file.current = null
-      await this.write(projectId, file)
-    }
-  }
-
-  /**
-   * Check and expire stale session if needed.
-   * Called on startup to clean up leftover sessions.
-   * Returns true if a session was expired.
-   */
-  async expireIfStale(projectId: string): Promise<boolean> {
-    const file = await this.read(projectId)
-    if (file.current && this.isExpired(file.current, file.config.idleTimeoutMs)) {
-      file.current = null
-      await this.write(projectId, file)
-      return true
-    }
-    return false
-  }
-}
-
-// =============================================================================
-// EXPORTS
-// =============================================================================
-
-export const sessionTracker = new SessionTracker()
-export default sessionTracker