prjct-cli 0.6.0 → 0.7.0

package/core/{update-checker.js → infrastructure/update-checker.js}

@@ -1,14 +1,14 @@
-const https = require('https');
-const fs = require('fs');
-const path = require('path');
-const os = require('os');
+const https = require('https')
+const fs = require('fs')
+const path = require('path')
+const os = require('os')
 
 class UpdateChecker {
   constructor() {
-    this.packageName = 'prjct-cli';
-    this.cacheDir = path.join(os.homedir(), '.prjct-cli', 'config');
-    this.cacheFile = path.join(this.cacheDir, 'update-cache.json');
-    this.checkInterval = 24 * 60 * 60 * 1000; // 24 hours in milliseconds
+    this.packageName = 'prjct-cli'
+    this.cacheDir = path.join(os.homedir(), '.prjct-cli', 'config')
+    this.cacheFile = path.join(this.cacheDir, 'update-cache.json')
+    this.checkInterval = 24 * 60 * 60 * 1000 // 24 hours in milliseconds
   }
 
   /**
@@ -16,12 +16,12 @@ class UpdateChecker {
    */
   getCurrentVersion() {
     try {
-      const packageJsonPath = path.join(__dirname, '..', 'package.json');
-      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-      return packageJson.version;
+      const packageJsonPath = path.join(__dirname, '..', '..', 'package.json')
+      const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'))
+      return packageJson.version
     } catch (error) {
-      console.error('Error reading package version:', error.message);
-      return null;
+      console.error('Error reading package version:', error.message)
+      return null
     }
   }
 
@@ -36,42 +36,42 @@ class UpdateChecker {
         method: 'GET',
         headers: {
           'User-Agent': 'prjct-cli-update-checker',
-          Accept: 'application/json'
-        }
-      };
+          Accept: 'application/json',
+        },
+      }
 
-      const req = https.request(options, res => {
-        let data = '';
+      const req = https.request(options, (res) => {
+        let data = ''
 
-        res.on('data', chunk => {
-          data += chunk;
-        });
+        res.on('data', (chunk) => {
+          data += chunk
+        })
 
         res.on('end', () => {
           try {
             if (res.statusCode === 200) {
-              const packageData = JSON.parse(data);
-              resolve(packageData.version);
+              const packageData = JSON.parse(data)
+              resolve(packageData.version)
             } else {
-              reject(new Error(`npm registry returned status ${res.statusCode}`));
+              reject(new Error(`npm registry returned status ${res.statusCode}`))
             }
           } catch (error) {
-            reject(error);
+            reject(error)
           }
-        });
-      });
+        })
+      })
 
-      req.on('error', error => {
-        reject(error);
-      });
+      req.on('error', (error) => {
+        reject(error)
+      })
 
       req.setTimeout(5000, () => {
-        req.destroy();
-        reject(new Error('Request timeout'));
-      });
+        req.destroy()
+        reject(new Error('Request timeout'))
+      })
 
-      req.end();
-    });
+      req.end()
+    })
   }
 
   /**
@@ -79,18 +79,18 @@ class UpdateChecker {
    * Returns: 1 if v1 > v2, -1 if v1 < v2, 0 if equal
    */
   compareVersions(v1, v2) {
-    const parts1 = v1.split('.').map(Number);
-    const parts2 = v2.split('.').map(Number);
+    const parts1 = v1.split('.').map(Number)
+    const parts2 = v2.split('.').map(Number)
 
     for (let i = 0; i < 3; i++) {
-      const part1 = parts1[i] || 0;
-      const part2 = parts2[i] || 0;
+      const part1 = parts1[i] || 0
+      const part2 = parts2[i] || 0
 
-      if (part1 > part2) return 1;
-      if (part1 < part2) return -1;
+      if (part1 > part2) return 1
+      if (part1 < part2) return -1
     }
 
-    return 0;
+    return 0
   }
 
   /**
@@ -99,13 +99,13 @@ class UpdateChecker {
   readCache() {
     try {
       if (fs.existsSync(this.cacheFile)) {
-        const cache = JSON.parse(fs.readFileSync(this.cacheFile, 'utf8'));
-        return cache;
+        const cache = JSON.parse(fs.readFileSync(this.cacheFile, 'utf8'))
+        return cache
       }
     } catch (error) {
       // Cache file doesn't exist or is corrupted, ignore
     }
-    return null;
+    return null
   }
 
   /**
@@ -115,10 +115,10 @@ class UpdateChecker {
     try {
       // Ensure cache directory exists
       if (!fs.existsSync(this.cacheDir)) {
-        fs.mkdirSync(this.cacheDir, { recursive: true });
+        fs.mkdirSync(this.cacheDir, { recursive: true })
       }
 
-      fs.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), 'utf8');
+      fs.writeFileSync(this.cacheFile, JSON.stringify(data, null, 2), 'utf8')
     } catch (error) {
       // Fail silently - cache is not critical
     }
@@ -130,14 +130,14 @@ class UpdateChecker {
    */
   async checkForUpdates() {
     try {
-      const currentVersion = this.getCurrentVersion();
+      const currentVersion = this.getCurrentVersion()
       if (!currentVersion) {
-        return null;
+        return null
       }
 
       // Check cache first
-      const cache = this.readCache();
-      const now = Date.now();
+      const cache = this.readCache()
+      const now = Date.now()
 
       if (cache && cache.lastCheck && now - cache.lastCheck < this.checkInterval) {
         // Cache is still valid
@@ -145,37 +145,37 @@ class UpdateChecker {
           return {
             updateAvailable: true,
             currentVersion,
-            latestVersion: cache.latestVersion
-          };
+            latestVersion: cache.latestVersion,
+          }
         }
         return {
           updateAvailable: false,
           currentVersion,
-          latestVersion: currentVersion
-        };
+          latestVersion: currentVersion,
+        }
       }
 
       // Cache expired or doesn't exist, fetch from npm
-      const latestVersion = await this.getLatestVersion();
+      const latestVersion = await this.getLatestVersion()
 
       // Update cache
       this.writeCache({
         lastCheck: now,
-        latestVersion
-      });
+        latestVersion,
+      })
 
       // Compare versions
-      const updateAvailable = this.compareVersions(latestVersion, currentVersion) > 0;
+      const updateAvailable = this.compareVersions(latestVersion, currentVersion) > 0
 
       return {
         updateAvailable,
         currentVersion,
-        latestVersion
-      };
+        latestVersion,
+      }
     } catch (error) {
       // Network error or other issue - fail silently
       // Return null to indicate check couldn't be performed
-      return null;
+      return null
     }
   }
 
@@ -183,13 +183,13 @@ class UpdateChecker {
    * Get formatted update notification message
    */
   async getUpdateNotification() {
-    const result = await this.checkForUpdates();
+    const result = await this.checkForUpdates()
 
     if (!result || !result.updateAvailable) {
-      return null;
+      return null
     }
 
-    const chalk = require('chalk');
+    const chalk = require('chalk')
 
     return (
       '\n' +
@@ -215,8 +215,8 @@ class UpdateChecker {
       '\n' +
       chalk.yellow('└───────────────────────────────────────────────────────────┘') +
       '\n'
-    );
+    )
   }
 }
 
-module.exports = UpdateChecker;
+module.exports = UpdateChecker

package/core/{animations-simple.js → utils/animations.js}

@@ -38,18 +38,7 @@ const frames = {
     '｡ﾟ☆: *.☽ .* :☆ﾟ. ✨ ･ ｡ﾟ',
     '☆: *.☽ .* :☆ﾟ. ✨ ･ ｡ﾟ☆:',
   ],
-  loading: [
-    '⠋',
-    '⠙',
-    '⠹',
-    '⠸',
-    '⠼',
-    '⠴',
-    '⠦',
-    '⠧',
-    '⠇',
-    '⠏',
-  ],
+  loading: ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'],
   progress: [
     '[          ]',
     '[▓         ]',
@@ -63,16 +52,7 @@ const frames = {
     '[▓▓▓▓▓▓▓▓▓ ]',
     '[▓▓▓▓▓▓▓▓▓▓]',
   ],
-  celebration: [
-    '🎉',
-    '🎊',
-    '✨',
-    '🌟',
-    '⭐',
-    '💫',
-    '🎆',
-    '🎇',
-  ],
+  celebration: ['🎉', '🎊', '✨', '🌟', '⭐', '💫', '🎆', '🎇'],
 }
 
 const banners = {
@@ -150,7 +130,7 @@ async function sparkle(message) {
 }
 
 function sleep(ms) {
-  return new Promise(resolve => setTimeout(resolve, ms))
+  return new Promise((resolve) => setTimeout(resolve, ms))
 }
 
 function formatShip(feature, count) {

package/core/utils/date-helper.js

@@ -0,0 +1,238 @@
+/**
+ * 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
+ */
+
+/**
+ * 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) {
+  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
+ *
+ * @param {Date} date - Date to format
+ * @returns {string} - Formatted month string (e.g., "2025-10")
+ */
+function formatMonth(date) {
+  const year = date.getFullYear()
+  const month = (date.getMonth() + 1).toString().padStart(2, '0')
+  return `${year}-${month}`
+}
+
+/**
+ * Get date key for today (YYYY-MM-DD)
+ *
+ * @returns {string} - Today's date key
+ */
+function getTodayKey() {
+  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) {
+  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) {
+  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
+ *
+ * @param {string} dateString - Date string to parse
+ * @returns {Date} - Parsed date
+ */
+function parseDate(dateString) {
+  return new Date(dateString)
+}
+
+/**
+ * Get current timestamp in ISO format
+ *
+ * @returns {string} - ISO timestamp (e.g., "2025-10-04T14:30:00.000Z")
+ */
+function getTimestamp() {
+  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) {
+  const date = new Date()
+  date.setDate(date.getDate() - days)
+  return date
+}
+
+/**
+ * Get date N days from today
+ *
+ * @param {number} days - Number of days to add
+ * @returns {Date} - Date in the future
+ */
+function getDaysFromNow(days) {
+  const date = new Date()
+  date.setDate(date.getDate() + days)
+  return date
+}
+
+/**
+ * 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 = []
+  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
+ *
+ * @param {Date} date - Date to check
+ * @returns {boolean} - True if date is today
+ */
+function isToday(date) {
+  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) {
+  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) {
+  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
+ *
+ * @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
+  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) {
+  const result = new Date(date)
+  result.setHours(0, 0, 0, 0)
+  return result
+}
+
+/**
+ * Get end of day (23:59:59.999)
+ *
+ * @param {Date} date - Date to process
+ * @returns {Date} - End of day
+ */
+function getEndOfDay(date) {
+  const result = new Date(date)
+  result.setHours(23, 59, 59, 999)
+  return result
+}
+
+module.exports = {
+  formatDate,
+  formatMonth,
+  getTodayKey,
+  getDateKey,
+  getYearMonthDay,
+  parseDate,
+  getTimestamp,
+  getDaysAgo,
+  getDaysFromNow,
+  getDateRange,
+  isToday,
+  isWithinLastDays,
+  formatDuration,
+  calculateDuration,
+  getStartOfDay,
+  getEndOfDay,
+}