prjct-cli 0.11.5 → 0.12.1

package/core/utils/{branding.js → branding.ts}

@@ -3,12 +3,36 @@
  * Single source of truth for all branding across CLI and Claude Code
  */
 
-const chalk = require('chalk')
+import chalk from 'chalk'
 
 const SPINNER_FRAMES = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
 const SPINNER_SPEED = 80
 
-const branding = {
+interface Branding {
+  name: string
+  icon: string
+  signature: string
+  spinner: {
+    frames: string[]
+    speed: number
+  }
+  cli: {
+    header: () => string
+    footer: () => string
+    spin: (frame: number, msg?: string) => string
+  }
+  template: {
+    header: string
+    footer: string
+  }
+  commitFooter: string
+  urls: {
+    website: string
+    docs: string
+  }
+}
+
+const branding: Branding = {
   // Core identity
   name: 'prjct',
   icon: '⚡',
@@ -24,7 +48,8 @@ const branding = {
   cli: {
     header: () => chalk.cyan.bold('⚡') + ' ' + chalk.cyan('prjct'),
     footer: () => chalk.dim('⚡ prjct'),
-    spin: (frame, msg) => chalk.cyan('⚡') + ' ' + chalk.cyan('prjct') + ' ' + chalk.cyan(SPINNER_FRAMES[frame % 10]) + ' ' + chalk.dim(msg || '')
+    spin: (frame: number, msg?: string) =>
+      chalk.cyan('⚡') + ' ' + chalk.cyan('prjct') + ' ' + chalk.cyan(SPINNER_FRAMES[frame % 10]) + ' ' + chalk.dim(msg || '')
   },
 
   // Template/Claude (plain text)
@@ -44,4 +69,4 @@ Designed for [Claude](https://www.anthropic.com/claude)`,
   }
 }
 
-module.exports = branding
+export default branding

package/core/utils/{date-helper.js → date-helper.ts}

@@ -2,20 +2,21 @@
  * Date Helper - Centralized date operations and formatting
  *
  * Eliminates duplicated date logic across:
- * - session-manager.js (_getDateKey, _getTodayKey)
- * - path-manager.js (getSessionPath date formatting)
- * - commands.js (38+ inline date operations)
- *
- * @module date-helper
+ * - session-manager.ts (_getDateKey, _getTodayKey)
+ * - path-manager.ts (getSessionPath date formatting)
+ * - commands.ts (38+ inline date operations)
  */
 
+export interface DateComponents {
+  year: string
+  month: string
+  day: string
+}
+
 /**
  * Format a date to YYYY-MM-DD format
- *
- * @param {Date} date - Date to format
- * @returns {string} - Formatted date string (e.g., "2025-10-04")
  */
-function formatDate(date) {
+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')
@@ -24,11 +25,8 @@ function formatDate(date) {
 
 /**
  * Format a date to YYYY-MM format
- *
- * @param {Date} date - Date to format
- * @returns {string} - Formatted month string (e.g., "2025-10")
  */
-function formatMonth(date) {
+export function formatMonth(date: Date): string {
   const year = date.getFullYear()
   const month = (date.getMonth() + 1).toString().padStart(2, '0')
   return `${year}-${month}`
@@ -36,32 +34,24 @@ function formatMonth(date) {
 
 /**
  * Get date key for today (YYYY-MM-DD)
- *
- * @returns {string} - Today's date key
  */
-function getTodayKey() {
+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
- *
- * @param {Date} date - Date to format
- * @returns {string} - Date key (e.g., "2025-10-04")
  */
-function getDateKey(date) {
+export function getDateKey(date: Date): string {
   return formatDate(date)
 }
 
 /**
  * Get year, month, day components from a date
  * Useful for path construction
- *
- * @param {Date} date - Date to parse
- * @returns {{year: string, month: string, day: string}} - Date components
  */
-function getYearMonthDay(date) {
+export function getYearMonthDay(date: Date): DateComponents {
   return {
     year: date.getFullYear().toString(),
     month: (date.getMonth() + 1).toString().padStart(2, '0'),
@@ -72,30 +62,22 @@ function getYearMonthDay(date) {
 /**
  * Parse a date string to Date object
  * Supports: YYYY-MM-DD, YYYY-MM, ISO strings
- *
- * @param {string} dateString - Date string to parse
- * @returns {Date} - Parsed date
  */
-function parseDate(dateString) {
+export function parseDate(dateString: string): Date {
   return new Date(dateString)
 }
 
 /**
  * Get current timestamp in ISO format
- *
- * @returns {string} - ISO timestamp (e.g., "2025-10-04T14:30:00.000Z")
  */
-function getTimestamp() {
+export function getTimestamp(): string {
   return new Date().toISOString()
 }
 
 /**
  * Get date N days ago from today
- *
- * @param {number} days - Number of days to subtract
- * @returns {Date} - Date in the past
  */
-function getDaysAgo(days) {
+export function getDaysAgo(days: number): Date {
   const date = new Date()
   date.setDate(date.getDate() - days)
   return date
@@ -103,11 +85,8 @@ function getDaysAgo(days) {
 
 /**
  * Get date N days from today
- *
- * @param {number} days - Number of days to add
- * @returns {Date} - Date in the future
  */
-function getDaysFromNow(days) {
+export function getDaysFromNow(days: number): Date {
   const date = new Date()
   date.setDate(date.getDate() + days)
   return date
@@ -115,13 +94,9 @@ function getDaysFromNow(days) {
 
 /**
  * Get date range between two dates
- *
- * @param {Date} fromDate - Start date
- * @param {Date} toDate - End date
- * @returns {Array<Date>} - Array of dates in range
  */
-function getDateRange(fromDate, toDate) {
-  const dates = []
+export function getDateRange(fromDate: Date, toDate: Date): Date[] {
+  const dates: Date[] = []
   let current = new Date(fromDate)
 
   while (current <= toDate) {
@@ -138,33 +113,23 @@ function getDateRange(fromDate, toDate) {
 
 /**
  * Check if a date is today
- *
- * @param {Date} date - Date to check
- * @returns {boolean} - True if date is today
  */
-function isToday(date) {
+export function isToday(date: Date): boolean {
   return formatDate(date) === getTodayKey()
 }
 
 /**
  * Check if a date is within the last N days
- *
- * @param {Date} date - Date to check
- * @param {number} days - Number of days
- * @returns {boolean} - True if within range
  */
-function isWithinLastDays(date, days) {
+export function isWithinLastDays(date: Date, days: number): boolean {
   const threshold = getDaysAgo(days)
   return date >= threshold
 }
 
 /**
  * Format duration in human-readable format
- *
- * @param {number} milliseconds - Duration in ms
- * @returns {string} - Formatted duration (e.g., "2h 15m")
  */
-function formatDuration(milliseconds) {
+export function formatDuration(milliseconds: number): string {
   const seconds = Math.floor(milliseconds / 1000)
   const minutes = Math.floor(seconds / 60)
   const hours = Math.floor(minutes / 60)
@@ -184,23 +149,16 @@ function formatDuration(milliseconds) {
 
 /**
  * Calculate duration between two dates
- *
- * @param {Date} startDate - Start date
- * @param {Date} endDate - End date (defaults to now)
- * @returns {string} - Formatted duration
  */
-function calculateDuration(startDate, endDate = new Date()) {
-  const milliseconds = endDate - startDate
+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)
- *
- * @param {Date} date - Date to process
- * @returns {Date} - Start of day
  */
-function getStartOfDay(date) {
+export function getStartOfDay(date: Date): Date {
   const result = new Date(date)
   result.setHours(0, 0, 0, 0)
   return result
@@ -208,17 +166,15 @@ function getStartOfDay(date) {
 
 /**
  * Get end of day (23:59:59.999)
- *
- * @param {Date} date - Date to process
- * @returns {Date} - End of day
  */
-function getEndOfDay(date) {
+export function getEndOfDay(date: Date): Date {
   const result = new Date(date)
   result.setHours(23, 59, 59, 999)
   return result
 }
 
-module.exports = {
+// Default export for CommonJS compatibility
+export default {
   formatDate,
   formatMonth,
   getTodayKey,
@@ -234,5 +190,6 @@ module.exports = {
   formatDuration,
   calculateDuration,
   getStartOfDay,
-  getEndOfDay,
+  getEndOfDay
 }
+

package/core/utils/file-helper.ts

@@ -0,0 +1,262 @@
+import fs from 'fs/promises'
+import path from 'path'
+
+/**
+ * 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
+}
+
+interface NodeError extends Error {
+  code?: string
+}
+
+/**
+ * Read JSON file and parse
+ */
+export async function readJson<T = unknown>(filePath: string, defaultValue: T | null = null): Promise<T | null> {
+  try {
+    const content = await fs.readFile(filePath, 'utf-8')
+    return JSON.parse(content) as T
+  } catch (error) {
+    if ((error as NodeError).code === 'ENOENT') {
+      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 ((error as NodeError).code === 'ENOENT') {
+      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')
+}
+
+/**
+ * Append to text file
+ */
+export async function appendToFile(filePath: string, content: string): Promise<void> {
+  await fs.appendFile(filePath, content, '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 ((error as NodeError).code === 'ENOENT') {
+      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 {
+    return false
+  }
+}
+
+/**
+ * Check if directory exists
+ */
+export async function dirExists(dirPath: string): Promise<boolean> {
+  try {
+    const stats = await fs.stat(dirPath)
+    return stats.isDirectory()
+  } catch {
+    return false
+  }
+}
+
+/**
+ * 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 ((error as NodeError).code === 'ENOENT') {
+      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 ((error as NodeError).code === 'ENOENT') {
+      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 ((error as NodeError).code === 'ENOENT') {
+      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))
+}
+
+// Default export for CommonJS compatibility
+export default {
+  readJson,
+  writeJson,
+  readFile,
+  writeFile,
+  fileExists,
+  ensureDir,
+  deleteFile,
+  deleteDir,
+  listFiles,
+  getFileSize,
+  getFileModifiedTime,
+  copyFile,
+  moveFile,
+  readLines,
+  writeLines,
+  getFileExtension,
+  getFileNameWithoutExtension
+}
+