prjct-cli 1.22.0 → 1.24.0

package/core/utils/collection-filters.ts

@@ -1,209 +0,0 @@
-/**
- * Collection Filter Utilities
- *
- * Reusable filtering and sorting functions for storage collections.
- * Eliminates duplicated filter logic across storage classes.
- */
-
-import type { Priority, TaskSection } from '../schemas/state'
-
-/**
- * Priority order mapping for sorting (highest priority first)
- */
-export const PRIORITY_ORDER: Record<Priority, number> = {
-  critical: 0,
-  high: 1,
-  medium: 2,
-  low: 3,
-}
-
-/**
- * Section order mapping for sorting
- */
-export const SECTION_ORDER: Record<TaskSection, number> = {
-  active: 0,
-  previously_active: 1,
-  backlog: 2,
-}
-
-/**
- * Filter items by a specific field value
- */
-export function filterByField<T, K extends keyof T>(items: T[], field: K, value: T[K]): T[] {
-  return items.filter((item) => item[field] === value)
-}
-
-/**
- * Filter items by multiple field values (OR logic)
- */
-export function filterByFieldIn<T, K extends keyof T>(items: T[], field: K, values: T[K][]): T[] {
-  return items.filter((item) => values.includes(item[field]))
-}
-
-/**
- * Filter items excluding a specific field value
- */
-export function filterByFieldNot<T, K extends keyof T>(items: T[], field: K, value: T[K]): T[] {
-  return items.filter((item) => item[field] !== value)
-}
-
-/**
- * Combined filter: field equals value AND another field is falsy
- * Useful for filtering active items that aren't completed
- */
-export function filterActiveByField<T, K extends keyof T>(
-  items: T[],
-  field: K,
-  value: T[K],
-  activeField: keyof T
-): T[] {
-  return items.filter((item) => item[field] === value && !item[activeField])
-}
-
-/**
- * Filter items where a field is truthy
- */
-export function filterByTruthy<T, K extends keyof T>(items: T[], field: K): T[] {
-  return items.filter((item) => Boolean(item[field]))
-}
-
-/**
- * Filter items where a field is falsy
- */
-export function filterByFalsy<T, K extends keyof T>(items: T[], field: K): T[] {
-  return items.filter((item) => !item[field])
-}
-
-/**
- * Sort items by priority (highest first)
- */
-export function sortByPriority<T extends { priority: Priority }>(items: T[]): T[] {
-  return [...items].sort((a, b) => PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority])
-}
-
-/**
- * Sort items by section, then priority
- */
-export function sortBySectionAndPriority<T extends { section: TaskSection; priority: Priority }>(
-  items: T[]
-): T[] {
-  return [...items].sort((a, b) => {
-    const sectionDiff = SECTION_ORDER[a.section] - SECTION_ORDER[b.section]
-    if (sectionDiff !== 0) return sectionDiff
-    return PRIORITY_ORDER[a.priority] - PRIORITY_ORDER[b.priority]
-  })
-}
-
-/**
- * Sort items by date field
- */
-export function sortByDate<T>(
-  items: T[],
-  dateField: keyof T,
-  direction: 'asc' | 'desc' = 'desc'
-): T[] {
-  return [...items].sort((a, b) => {
-    const dateA = new Date(a[dateField] as string).getTime()
-    const dateB = new Date(b[dateField] as string).getTime()
-    return direction === 'desc' ? dateB - dateA : dateA - dateB
-  })
-}
-
-/**
- * Filter items by date range
- */
-export function filterByDateRange<T>(
-  items: T[],
-  dateField: keyof T,
-  startDate: Date,
-  endDate: Date
-): T[] {
-  return items.filter((item) => {
-    const date = new Date(item[dateField] as string)
-    return date >= startDate && date <= endDate
-  })
-}
-
-/**
- * Filter items from the last N days
- */
-export function filterByLastDays<T>(items: T[], dateField: keyof T, days: number): T[] {
-  const startDate = new Date()
-  startDate.setDate(startDate.getDate() - days)
-  return filterByDateRange(items, dateField, startDate, new Date())
-}
-
-/**
- * Group items by a field value
- */
-export function groupByField<T, K extends keyof T>(items: T[], field: K): Map<T[K], T[]> {
-  const groups = new Map<T[K], T[]>()
-
-  for (const item of items) {
-    const key = item[field]
-    if (!groups.has(key)) {
-      groups.set(key, [])
-    }
-    groups.get(key)!.push(item)
-  }
-
-  return groups
-}
-
-/**
- * Count items by field value
- */
-export function countByField<T, K extends keyof T>(items: T[], field: K): Map<T[K], number> {
-  const counts = new Map<T[K], number>()
-
-  for (const item of items) {
-    const key = item[field]
-    counts.set(key, (counts.get(key) || 0) + 1)
-  }
-
-  return counts
-}
-
-/**
- * Get the first N items
- */
-export function take<T>(items: T[], count: number): T[] {
-  return items.slice(0, count)
-}
-
-/**
- * Get the last N items
- */
-export function takeLast<T>(items: T[], count: number): T[] {
-  return items.slice(-count)
-}
-
-/**
- * Find item by field value
- */
-export function findByField<T, K extends keyof T>(
-  items: T[],
-  field: K,
-  value: T[K]
-): T | undefined {
-  return items.find((item) => item[field] === value)
-}
-
-/**
- * Check if any item matches field value
- */
-export function anyByField<T, K extends keyof T>(items: T[], field: K, value: T[K]): boolean {
-  return items.some((item) => item[field] === value)
-}
-
-/**
- * Remove duplicates by field
- */
-export function uniqueByField<T, K extends keyof T>(items: T[], field: K): T[] {
-  const seen = new Set<T[K]>()
-  return items.filter((item) => {
-    if (seen.has(item[field])) return false
-    seen.add(item[field])
-    return true
-  })
-}

package/core/utils/date-helper.ts

@@ -1,176 +0,0 @@
-/**
- * Date Helper - Centralized date operations and formatting
- *
- * Eliminates duplicated date logic across:
- * - session-manager.ts (_getDateKey, _getTodayKey)
- * - path-manager.ts (getSessionPath date formatting)
- * - commands.ts (38+ inline date operations)
- */
-
-import { formatDistanceToNowStrict } from 'date-fns'
-import type { DateComponents } from '../types'
-
-/**
- * Format a date to YYYY-MM-DD format
- */
-export function formatDate(date: Date): string {
-  const year = date.getFullYear()
-  const month = (date.getMonth() + 1).toString().padStart(2, '0')
-  const day = date.getDate().toString().padStart(2, '0')
-  return `${year}-${month}-${day}`
-}
-
-/**
- * Format a date to YYYY-MM format
- */
-export function formatMonth(date: Date): string {
-  const year = date.getFullYear()
-  const month = (date.getMonth() + 1).toString().padStart(2, '0')
-  return `${year}-${month}`
-}
-
-/**
- * Get date key for today (YYYY-MM-DD)
- */
-export function getTodayKey(): string {
-  return formatDate(new Date())
-}
-
-/**
- * Get date key for any date (YYYY-MM-DD)
- * Alias for formatDate for consistency with session-manager
- */
-export function getDateKey(date: Date): string {
-  return formatDate(date)
-}
-
-/**
- * Get year, month, day components from a date
- * Useful for path construction
- */
-export function getYearMonthDay(date: Date): DateComponents {
-  return {
-    year: date.getFullYear().toString(),
-    month: (date.getMonth() + 1).toString().padStart(2, '0'),
-    day: date.getDate().toString().padStart(2, '0'),
-  }
-}
-
-/**
- * Parse a date string to Date object
- * Supports: YYYY-MM-DD, YYYY-MM, ISO strings
- */
-export function parseDate(dateString: string): Date {
-  return new Date(dateString)
-}
-
-/**
- * Get current timestamp in ISO format
- */
-export function getTimestamp(): string {
-  return new Date().toISOString()
-}
-
-/**
- * Get date N days ago from today
- */
-export function getDaysAgo(days: number): Date {
-  const date = new Date()
-  date.setDate(date.getDate() - days)
-  return date
-}
-
-/**
- * Get date N days from today
- */
-export function getDaysFromNow(days: number): Date {
-  const date = new Date()
-  date.setDate(date.getDate() + days)
-  return date
-}
-
-/**
- * Get date range between two dates
- */
-export function getDateRange(fromDate: Date, toDate: Date): Date[] {
-  const dates: Date[] = []
-  let current = new Date(fromDate)
-
-  while (current <= toDate) {
-    dates.push(new Date(current))
-    current = new Date(current.getFullYear(), current.getMonth(), current.getDate() + 1)
-  }
-
-  return dates
-}
-
-/**
- * Check if a date is today
- */
-export function isToday(date: Date): boolean {
-  return formatDate(date) === getTodayKey()
-}
-
-/**
- * Check if a date is within the last N days
- */
-export function isWithinLastDays(date: Date, days: number): boolean {
-  const threshold = getDaysAgo(days)
-  return date >= threshold
-}
-
-/**
- * Format duration in human-readable format
- */
-export function formatDuration(milliseconds: number): string {
-  const seconds = Math.floor(milliseconds / 1000)
-  const minutes = Math.floor(seconds / 60)
-  const hours = Math.floor(minutes / 60)
-  const days = Math.floor(hours / 24)
-
-  if (days > 0) {
-    return `${days}d ${hours % 24}h`
-  }
-  if (hours > 0) {
-    return `${hours}h ${minutes % 60}m`
-  }
-  if (minutes > 0) {
-    return `${minutes}m`
-  }
-  return `${seconds}s`
-}
-
-/**
- * Calculate duration between two dates
- */
-export function calculateDuration(startDate: Date, endDate: Date = new Date()): string {
-  const milliseconds = endDate.getTime() - startDate.getTime()
-  return formatDuration(milliseconds)
-}
-
-/**
- * Get start of day (00:00:00.000)
- */
-export function getStartOfDay(date: Date): Date {
-  const result = new Date(date)
-  result.setHours(0, 0, 0, 0)
-  return result
-}
-
-/**
- * Get end of day (23:59:59.999)
- */
-export function getEndOfDay(date: Date): Date {
-  const result = new Date(date)
-  result.setHours(23, 59, 59, 999)
-  return result
-}
-
-/**
- * Convert a date/timestamp to a relative string (e.g. "5 minutes ago").
- * Uses date-fns formatDistanceToNowStrict for accurate, token-friendly output.
- */
-export function toRelative(date: string | Date): string {
-  const d = typeof date === 'string' ? new Date(date) : date
-  return formatDistanceToNowStrict(d, { addSuffix: true })
-}

package/core/utils/error-messages.ts

@@ -1,38 +0,0 @@
-/**
- * Error Messages Catalog
- *
- * Centralized error messages with context and recovery hints.
- * Types and catalog live in core/types/errors.ts.
- *
- * @see PRJ-131
- * @module utils/error-messages
- */
-
-import type { ErrorCode, ErrorWithHint } from '../types/errors'
-import { ERRORS } from '../types/errors'
-
-export type { ErrorCode, ErrorWithHint } from '../types/errors'
-export { ERRORS } from '../types/errors'
-
-/**
- * Get error with optional overrides
- */
-export function getError(code: ErrorCode, overrides?: Partial<ErrorWithHint>): ErrorWithHint {
-  const base = ERRORS[code]
-  return { ...base, ...overrides }
-}
-
-/**
- * Create a custom error with hint
- */
-export function createError(
-  message: string,
-  hint?: string,
-  options?: { file?: string; docs?: string }
-): ErrorWithHint {
-  return {
-    message,
-    hint,
-    ...options,
-  }
-}

package/core/utils/file-helper.ts

@@ -1,277 +0,0 @@
-import fs from 'node:fs/promises'
-import path from 'node:path'
-import { safeRead, type ValidationSchema } from '../storage/safe-reader'
-import { isNotFoundError } from '../types/fs'
-
-/**
- * File Helper - Centralized file operations with error handling
- *
- * Eliminates duplicated fs operations across:
- * - 101 fs.readFile/writeFile calls in 18 files
- * - Consistent error handling
- * - JSON read/write patterns
- */
-
-interface ListFilesOptions {
-  filesOnly?: boolean
-  dirsOnly?: boolean
-  extension?: string
-}
-
-/**
- * Read JSON file and parse.
- * When a Zod schema is provided, validates the data and creates a .backup on corruption.
- */
-export async function readJson<T = unknown>(
-  filePath: string,
-  defaultValue: T | null = null,
-  schema?: ValidationSchema
-): Promise<T | null> {
-  if (schema) {
-    const data = await safeRead<T>(filePath, schema)
-    return data ?? defaultValue
-  }
-
-  try {
-    const content = await fs.readFile(filePath, 'utf-8')
-    return JSON.parse(content) as T
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return defaultValue
-    }
-    throw error
-  }
-}
-
-/**
- * Write object to JSON file (pretty-printed)
- */
-export async function writeJson(filePath: string, data: unknown, indent = 2): Promise<void> {
-  const content = JSON.stringify(data, null, indent)
-  await fs.writeFile(filePath, content, 'utf-8')
-}
-
-/**
- * Read text file
- */
-export async function readFile(filePath: string, defaultValue = ''): Promise<string> {
-  try {
-    return await fs.readFile(filePath, 'utf-8')
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return defaultValue
-    }
-    throw error
-  }
-}
-
-/**
- * Write text file
- */
-export async function writeFile(filePath: string, content: string): Promise<void> {
-  const dir = path.dirname(filePath)
-  await fs.mkdir(dir, { recursive: true })
-  await fs.writeFile(filePath, content, 'utf-8')
-}
-
-/**
- * Atomic write - writes to temp file then renames (prevents partial writes)
- */
-export async function atomicWrite(filePath: string, content: string): Promise<void> {
-  const dir = path.dirname(filePath)
-  await fs.mkdir(dir, { recursive: true })
-  const tempPath = `${filePath}.${Date.now()}.tmp`
-  await fs.writeFile(tempPath, content, 'utf-8')
-  await fs.rename(tempPath, filePath)
-}
-
-/**
- * Append to text file
- */
-export async function appendToFile(filePath: string, content: string): Promise<void> {
-  await fs.appendFile(filePath, content, 'utf-8')
-}
-
-/**
- * Append a single line to file (with newline and directory creation)
- */
-export async function appendLine(filePath: string, line: string): Promise<void> {
-  const dir = path.dirname(filePath)
-  await fs.mkdir(dir, { recursive: true })
-  await fs.appendFile(filePath, `${line}\n`, 'utf-8')
-}
-
-/**
- * Prepend to text file (adds content at beginning)
- */
-export async function prependToFile(filePath: string, content: string): Promise<void> {
-  try {
-    const existing = await fs.readFile(filePath, 'utf-8')
-    await fs.writeFile(filePath, content + existing, 'utf-8')
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      await fs.writeFile(filePath, content, 'utf-8')
-    } else {
-      throw error
-    }
-  }
-}
-
-/**
- * Check if file exists
- */
-export async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return false
-    }
-    throw error
-  }
-}
-
-/**
- * Check if directory exists
- */
-export async function dirExists(dirPath: string): Promise<boolean> {
-  try {
-    const stats = await fs.stat(dirPath)
-    return stats.isDirectory()
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return false
-    }
-    throw error
-  }
-}
-
-/**
- * Ensure directory exists (create if not)
- */
-export async function ensureDir(dirPath: string): Promise<void> {
-  await fs.mkdir(dirPath, { recursive: true })
-}
-
-/**
- * Delete file if it exists
- */
-export async function deleteFile(filePath: string): Promise<boolean> {
-  try {
-    await fs.unlink(filePath)
-    return true
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return false // File didn't exist
-    }
-    throw error
-  }
-}
-
-/**
- * Delete directory and all contents
- */
-export async function deleteDir(dirPath: string): Promise<boolean> {
-  try {
-    await fs.rm(dirPath, { recursive: true, force: true })
-    return true
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return false
-    }
-    throw error
-  }
-}
-
-/**
- * List files in directory
- */
-export async function listFiles(
-  dirPath: string,
-  options: ListFilesOptions = {}
-): Promise<string[]> {
-  try {
-    const entries = await fs.readdir(dirPath, { withFileTypes: true })
-    let files = entries
-
-    if (options.filesOnly) {
-      files = files.filter((entry) => entry.isFile())
-    }
-
-    if (options.dirsOnly) {
-      files = files.filter((entry) => entry.isDirectory())
-    }
-
-    if (options.extension) {
-      files = files.filter((entry) => entry.name.endsWith(options.extension!))
-    }
-
-    return files.map((entry) => entry.name)
-  } catch (error) {
-    if (isNotFoundError(error)) {
-      return []
-    }
-    throw error
-  }
-}
-
-/**
- * Get file size in bytes
- */
-export async function getFileSize(filePath: string): Promise<number> {
-  const stats = await fs.stat(filePath)
-  return stats.size
-}
-
-/**
- * Get file modification time
- */
-export async function getFileModifiedTime(filePath: string): Promise<Date> {
-  const stats = await fs.stat(filePath)
-  return stats.mtime
-}
-
-/**
- * Copy file
- */
-export async function copyFile(sourcePath: string, destPath: string): Promise<void> {
-  await fs.copyFile(sourcePath, destPath)
-}
-
-/**
- * Move/rename file
- */
-export async function moveFile(oldPath: string, newPath: string): Promise<void> {
-  await fs.rename(oldPath, newPath)
-}
-
-/**
- * Read file and split into lines
- */
-export async function readLines(filePath: string): Promise<string[]> {
-  const content = await readFile(filePath, '')
-  return content.split('\n')
-}
-
-/**
- * Write lines to file
- */
-export async function writeLines(filePath: string, lines: string[]): Promise<void> {
-  const content = lines.join('\n')
-  await writeFile(filePath, content)
-}
-
-/**
- * Get file extension
- */
-export function getFileExtension(filePath: string): string {
-  return path.extname(filePath)
-}
-
-/**
- * Get filename without extension
- */
-export function getFileNameWithoutExtension(filePath: string): string {
-  return path.basename(filePath, path.extname(filePath))
-}

package/core/utils/fs-helpers.ts

@@ -1,14 +0,0 @@
-import fs from 'node:fs/promises'
-
-/**
- * Async check if a file/directory exists
- * Replacement for fs.existsSync
- */
-export async function fileExists(filePath: string): Promise<boolean> {
-  try {
-    await fs.access(filePath)
-    return true
-  } catch {
-    return false
-  }
-}