prjct-cli 0.45.0 → 0.45.3

package/core/services/watch-service.ts

@@ -0,0 +1,294 @@
+/**
+ * WatchService - Smart file watcher for auto-sync
+ *
+ * Monitors project files and triggers sync on meaningful changes.
+ * Features:
+ * - Debouncing to batch rapid changes
+ * - Smart filtering of meaningful files
+ * - Graceful shutdown
+ * - Low CPU/memory footprint
+ */
+
+import path from 'node:path'
+import chalk from 'chalk'
+import chokidar, { type FSWatcher } from 'chokidar'
+import configManager from '../infrastructure/config-manager'
+import dateHelper from '../utils/date-helper'
+import { syncService } from './sync-service'
+
+// ============================================================================
+// TYPES
+// ============================================================================
+
+interface WatchOptions {
+  debounceMs?: number // Debounce window (default: 2000ms)
+  minIntervalMs?: number // Minimum sync interval (default: 30000ms)
+  verbose?: boolean // Show detailed output
+  quiet?: boolean // Suppress all output except errors
+}
+
+interface WatchResult {
+  success: boolean
+  error?: string
+}
+
+// ============================================================================
+// DEFAULT CONFIGURATION
+// ============================================================================
+
+// Files that trigger a sync when changed
+const TRIGGER_PATTERNS = [
+  'package.json',
+  'package-lock.json',
+  'bun.lockb',
+  'pnpm-lock.yaml',
+  'yarn.lock',
+  'tsconfig.json',
+  'tsconfig.*.json',
+  '.env',
+  '.env.*',
+  'Cargo.toml',
+  'go.mod',
+  'pyproject.toml',
+  'requirements.txt',
+  // Source files (new files trigger sync)
+  'src/**/*.ts',
+  'src/**/*.tsx',
+  'src/**/*.js',
+  'src/**/*.jsx',
+  'lib/**/*.ts',
+  'core/**/*.ts',
+  'app/**/*.ts',
+  'app/**/*.tsx',
+  'pages/**/*.ts',
+  'pages/**/*.tsx',
+]
+
+// Patterns to always ignore
+const IGNORE_PATTERNS = [
+  '**/node_modules/**',
+  '**/.git/**',
+  '**/dist/**',
+  '**/build/**',
+  '**/.next/**',
+  '**/.nuxt/**',
+  '**/coverage/**',
+  '**/*.log',
+  '**/*.tmp',
+  '**/CLAUDE.md', // Don't trigger on our own output
+  '**/.cursorrules',
+  '**/.windsurfrules',
+  '**/.prjct/**',
+  '**/.prjct-cli/**',
+]
+
+// ============================================================================
+// WATCH SERVICE
+// ============================================================================
+
+class WatchService {
+  private watcher: FSWatcher | null = null
+  private projectPath: string = ''
+  private projectId: string | null = null
+  private debounceTimer: ReturnType<typeof setTimeout> | null = null
+  private lastSyncTime: number = 0
+  private pendingChanges: Set<string> = new Set()
+  private options: Required<WatchOptions> = {
+    debounceMs: 2000,
+    minIntervalMs: 30000,
+    verbose: false,
+    quiet: false,
+  }
+  private isRunning: boolean = false
+  private syncCount: number = 0
+
+  /**
+   * Start watching for file changes
+   */
+  async start(
+    projectPath: string = process.cwd(),
+    options: WatchOptions = {}
+  ): Promise<WatchResult> {
+    this.projectPath = projectPath
+    this.options = { ...this.options, ...options }
+
+    // Get project ID
+    this.projectId = await configManager.getProjectId(projectPath)
+    if (!this.projectId) {
+      return { success: false, error: 'No prjct project. Run "prjct init" first.' }
+    }
+
+    // Check if already running
+    if (this.isRunning) {
+      return { success: false, error: 'Watch mode is already running' }
+    }
+
+    this.isRunning = true
+
+    // Print startup message
+    if (!this.options.quiet) {
+      this.printStartup()
+    }
+
+    // Initialize watcher
+    this.watcher = chokidar.watch(TRIGGER_PATTERNS, {
+      cwd: this.projectPath,
+      ignored: IGNORE_PATTERNS,
+      persistent: true,
+      ignoreInitial: true, // Don't trigger on initial scan
+      awaitWriteFinish: {
+        // Wait for writes to complete
+        stabilityThreshold: 500,
+        pollInterval: 100,
+      },
+    })
+
+    // Set up event handlers
+    this.watcher
+      .on('add', (filePath: string) => this.handleChange('add', filePath))
+      .on('change', (filePath: string) => this.handleChange('change', filePath))
+      .on('unlink', (filePath: string) => this.handleChange('unlink', filePath))
+      .on('error', (error: unknown) => this.handleError(error as Error))
+
+    // Handle graceful shutdown
+    process.on('SIGINT', () => this.stop())
+    process.on('SIGTERM', () => this.stop())
+
+    return { success: true }
+  }
+
+  /**
+   * Stop watching
+   */
+  async stop(): Promise<void> {
+    if (!this.options.quiet) {
+      console.log('')
+      console.log(chalk.dim(`\n👋 Stopped watching (${this.syncCount} syncs performed)`))
+    }
+
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+      this.debounceTimer = null
+    }
+
+    if (this.watcher) {
+      await this.watcher.close()
+      this.watcher = null
+    }
+
+    this.isRunning = false
+    process.exit(0)
+  }
+
+  /**
+   * Handle file change event
+   */
+  private handleChange(event: 'add' | 'change' | 'unlink', filePath: string): void {
+    // Add to pending changes
+    this.pendingChanges.add(filePath)
+
+    if (this.options.verbose && !this.options.quiet) {
+      const eventIcon = event === 'add' ? '➕' : event === 'unlink' ? '➖' : '📝'
+      console.log(chalk.dim(`  ${eventIcon} ${filePath}`))
+    }
+
+    // Debounce the sync
+    this.scheduleSyncIfNeeded()
+  }
+
+  /**
+   * Schedule a sync with debouncing and rate limiting
+   */
+  private scheduleSyncIfNeeded(): void {
+    // Clear existing timer
+    if (this.debounceTimer) {
+      clearTimeout(this.debounceTimer)
+    }
+
+    // Schedule new sync
+    this.debounceTimer = setTimeout(async () => {
+      // Check rate limit
+      const now = Date.now()
+      const timeSinceLastSync = now - this.lastSyncTime
+
+      if (timeSinceLastSync < this.options.minIntervalMs && this.lastSyncTime > 0) {
+        // Too soon, reschedule
+        const waitTime = this.options.minIntervalMs - timeSinceLastSync
+        if (this.options.verbose && !this.options.quiet) {
+          console.log(chalk.dim(`  ⏳ Rate limited, waiting ${Math.round(waitTime / 1000)}s...`))
+        }
+        this.debounceTimer = setTimeout(() => this.performSync(), waitTime)
+        return
+      }
+
+      await this.performSync()
+    }, this.options.debounceMs)
+  }
+
+  /**
+   * Perform the actual sync
+   */
+  private async performSync(): Promise<void> {
+    const changedFiles = Array.from(this.pendingChanges)
+    this.pendingChanges.clear()
+
+    if (changedFiles.length === 0) return
+
+    const timestamp = dateHelper.getTimestamp().split('T')[1].split('.')[0]
+
+    if (!this.options.quiet) {
+      const filesSummary =
+        changedFiles.length === 1 ? changedFiles[0] : `${changedFiles.length} files`
+      console.log(
+        `\n${chalk.dim(`[${timestamp}]`)} ${chalk.cyan('⟳')} ${filesSummary} changed → syncing...`
+      )
+    }
+
+    try {
+      const result = await syncService.sync(this.projectPath)
+
+      this.lastSyncTime = Date.now()
+      this.syncCount++
+
+      if (result.success) {
+        if (!this.options.quiet) {
+          const agents = result.agents.filter((a) => a.type === 'domain').map((a) => a.name)
+          const agentStr = agents.length > 0 ? ` [${agents.join(', ')}]` : ''
+          console.log(`${chalk.dim(`[${timestamp}]`)} ${chalk.green('✓')} Synced${agentStr}`)
+        }
+      } else {
+        console.error(
+          `${chalk.dim(`[${timestamp}]`)} ${chalk.red('✗')} Sync failed: ${result.error}`
+        )
+      }
+    } catch (error) {
+      console.error(
+        `${chalk.dim(`[${timestamp}]`)} ${chalk.red('✗')} Error: ${(error as Error).message}`
+      )
+    }
+  }
+
+  /**
+   * Handle watcher errors
+   */
+  private handleError(error: Error): void {
+    console.error(chalk.red(`Watch error: ${error.message}`))
+  }
+
+  /**
+   * Print startup message
+   */
+  private printStartup(): void {
+    console.log('')
+    console.log(chalk.cyan('👁️  Watching for changes...'))
+    console.log(chalk.dim(`   Project: ${path.basename(this.projectPath)}`))
+    console.log(chalk.dim(`   Debounce: ${this.options.debounceMs}ms`))
+    console.log(chalk.dim(`   Min interval: ${this.options.minIntervalMs / 1000}s`))
+    console.log('')
+    console.log(chalk.dim('   Press Ctrl+C to stop'))
+    console.log('')
+  }
+}
+
+export const watchService = new WatchService()
+export { WatchService, type WatchOptions, type WatchResult }

package/core/session/compaction.ts

@@ -9,13 +9,13 @@
  * @version 1.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
-import { getTimestamp } from '../utils/date-helper'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import pathManager from '../infrastructure/path-manager'
-import type { ConversationTurn, CompactedContext, CompactionConfig } from '../types'
+import type { CompactedContext, CompactionConfig, ConversationTurn } from '../types'
+import { getTimestamp } from '../utils/date-helper'
 
-export type { ConversationTurn, CompactedContext, CompactionConfig } from '../types'
+export type { CompactedContext, CompactionConfig, ConversationTurn } from '../types'
 
 const DEFAULT_CONFIG: Required<CompactionConfig> = {
   maxTurns: 50,
@@ -76,17 +76,14 @@ function extractKeyInfo(turns: ConversationTurn[]): {
     }
 
     // Extract completed tasks
-    const taskPatterns = [
-      /✅\s*(.+)/g,
-      /completed[:\s]+(.+)/gi,
-      /finished[:\s]+(.+)/gi,
-    ]
+    const taskPatterns = [/✅\s*(.+)/g, /completed[:\s]+(.+)/gi, /finished[:\s]+(.+)/gi]
 
     for (const pattern of taskPatterns) {
       const matches = content.matchAll(pattern)
       for (const match of matches) {
         const task = match[1].trim()
-        if (task.length < 100) { // Avoid capturing large blocks
+        if (task.length < 100) {
+          // Avoid capturing large blocks
           tasksCompleted.push(task)
         }
       }
@@ -106,19 +103,19 @@ function extractKeyInfo(turns: ConversationTurn[]): {
 function generateSummary(turns: ConversationTurn[], maxLength: number): string {
   // Get key user requests
   const userRequests = turns
-    .filter(t => t.role === 'user')
-    .map(t => t.content.slice(0, 200))
+    .filter((t) => t.role === 'user')
+    .map((t) => t.content.slice(0, 200))
     .slice(0, 5)
 
   // Get key assistant actions
   const assistantActions = turns
-    .filter(t => t.role === 'assistant')
-    .map(t => {
+    .filter((t) => t.role === 'assistant')
+    .map((t) => {
       // Extract first meaningful sentence
       const firstLine = t.content.split('\n')[0]
       return firstLine.slice(0, 150)
     })
-    .filter(a => a.length > 10)
+    .filter((a) => a.length > 10)
     .slice(0, 5)
 
   const summary = [
@@ -160,10 +157,7 @@ export function compactContext(
 /**
  * Check if compaction is needed
  */
-export function needsCompaction(
-  turns: ConversationTurn[],
-  config: CompactionConfig = {}
-): boolean {
+export function needsCompaction(turns: ConversationTurn[], config: CompactionConfig = {}): boolean {
   const cfg = { ...DEFAULT_CONFIG, ...config }
 
   // Check turn count
@@ -192,7 +186,7 @@ export async function saveCompactedContext(
 
   await fs.mkdir(dirPath, { recursive: true })
 
-  const line = JSON.stringify(context) + '\n'
+  const line = `${JSON.stringify(context)}\n`
   await fs.appendFile(filePath, line, 'utf-8')
 
   return filePath
@@ -206,13 +200,15 @@ export async function loadCompactedContexts(
   limit = 5
 ): Promise<CompactedContext[]> {
   const filePath = path.join(
-    pathManager.getGlobalProjectPath(projectId), 'memory', 'compacted.jsonl'
+    pathManager.getGlobalProjectPath(projectId),
+    'memory',
+    'compacted.jsonl'
   )
 
   try {
     const content = await fs.readFile(filePath, 'utf-8')
     const lines = content.trim().split('\n').filter(Boolean)
-    const contexts = lines.map(line => JSON.parse(line) as CompactedContext)
+    const contexts = lines.map((line) => JSON.parse(line) as CompactedContext)
 
     // Return most recent
     return contexts.slice(-limit)
@@ -225,27 +221,23 @@ export async function loadCompactedContexts(
  * Format compacted context for prompt injection
  */
 export function formatCompactedForPrompt(context: CompactedContext): string {
-  const lines = [
-    '<compacted-context>',
-    context.summary,
-    '',
-  ]
+  const lines = ['<compacted-context>', context.summary, '']
 
   if (context.filesModified.length > 0) {
     lines.push('### Files Modified:')
-    lines.push(context.filesModified.map(f => `- ${f}`).join('\n'))
+    lines.push(context.filesModified.map((f) => `- ${f}`).join('\n'))
     lines.push('')
   }
 
   if (context.tasksCompleted.length > 0) {
     lines.push('### Tasks Completed:')
-    lines.push(context.tasksCompleted.map(t => `- ${t}`).join('\n'))
+    lines.push(context.tasksCompleted.map((t) => `- ${t}`).join('\n'))
     lines.push('')
   }
 
   if (context.decisions.length > 0) {
     lines.push('### Decisions Made:')
-    lines.push(context.decisions.map(d => `- ${d}`).join('\n'))
+    lines.push(context.decisions.map((d) => `- ${d}`).join('\n'))
     lines.push('')
   }
 

package/core/session/index.ts

@@ -11,15 +11,21 @@
  */
 
 // Task session types and utilities
-export type { Session, SessionMetrics, TimelineEvent } from '../types'
-export { generateId, calculateDuration, formatDuration } from './utils'
-
 // Log session types
-export type { SessionEntry, SessionLogMetadata, SessionStats, MigrationResult } from '../types'
+export type {
+  MigrationResult,
+  Session,
+  SessionEntry,
+  SessionLogMetadata,
+  SessionMetrics,
+  SessionStats,
+  TimelineEvent,
+} from '../types'
+export { SessionLogManager } from './session-log-manager'
 
 // Main exports
 export { TaskSessionManager } from './task-session-manager'
-export { SessionLogManager } from './session-log-manager'
+export { calculateDuration, formatDuration, generateId } from './utils'
 
 // Default: TaskSessionManager for backward compatibility
 import { TaskSessionManager } from './task-session-manager'

package/core/session/log-migration.ts

@@ -3,12 +3,12 @@
  * Migrate legacy single-file logs to session structure
  */
 
-import path from 'path'
+import path from 'node:path'
 import pathManager from '../infrastructure/path-manager'
+import type { SessionEntry, SessionLogMetadata, SessionMigrationResult } from '../types'
 import * as dateHelper from '../utils/date-helper'
-import * as jsonlHelper from '../utils/jsonl-helper'
 import * as fileHelper from '../utils/file-helper'
-import type { SessionEntry, SessionMigrationResult, SessionLogMetadata } from '../types'
+import * as jsonlHelper from '../utils/jsonl-helper'
 
 /**
  * Migrate legacy JSONL file

package/core/session/metrics.ts

@@ -6,8 +6,8 @@
  * @version 1.0.0
  */
 
-import fs from 'fs/promises'
-import path from 'path'
+import fs from 'node:fs/promises'
+import path from 'node:path'
 import pathManager from '../infrastructure/path-manager'
 import { isNotFoundError } from '../types/fs'
 
@@ -68,14 +68,14 @@ class SessionMetrics {
       totalDurationFormatted: this.formatDuration(this.sumDurations(sessions)),
       averageDuration: this.averageDuration(sessions),
       averageDurationFormatted: this.formatDuration(this.averageDuration(sessions)),
-      tasksCompleted: sessions.filter(s => s.status === 'completed').length,
+      tasksCompleted: sessions.filter((s) => s.status === 'completed').length,
       filesChanged: this.sumMetric(sessions, 'filesChanged'),
       linesAdded: this.sumMetric(sessions, 'linesAdded'),
       linesRemoved: this.sumMetric(sessions, 'linesRemoved'),
       commits: this.sumMetric(sessions, 'commits'),
       productivityScore: this.calculateProductivityScore(sessions),
       streak: await this.calculateStreak(),
-      byDay: this.groupByDay(sessions)
+      byDay: this.groupByDay(sessions),
     }
   }
 
@@ -141,15 +141,16 @@ class SessionMetrics {
     switch (period) {
       case 'day':
         return new Date(now.setHours(0, 0, 0, 0))
-      case 'week':
+      case 'week': {
         const weekAgo = new Date(now)
         weekAgo.setDate(weekAgo.getDate() - 7)
         return weekAgo
-      case 'month':
+      }
+      case 'month': {
         const monthAgo = new Date(now)
         monthAgo.setMonth(monthAgo.getMonth() - 1)
         return monthAgo
-      case 'all':
+      }
       default:
         return new Date(0) // Beginning of time
     }
@@ -173,7 +174,10 @@ class SessionMetrics {
   /**
    * Sum a specific metric
    */
-  sumMetric(sessions: Session[], metric: 'filesChanged' | 'linesAdded' | 'linesRemoved' | 'commits'): number {
+  sumMetric(
+    sessions: Session[],
+    metric: 'filesChanged' | 'linesAdded' | 'linesRemoved' | 'commits'
+  ): number {
     return sessions.reduce((sum, s) => {
       return sum + (s.metrics?.[metric] || 0)
     }, 0)
@@ -200,11 +204,12 @@ class SessionMetrics {
     }
 
     // 3. Completion rate
-    const completedCount = sessions.filter(s => s.status === 'completed').length
+    const completedCount = sessions.filter((s) => s.status === 'completed').length
     const completionScore = (completedCount / sessions.length) * 20
 
     // 4. Output (commits + files changed)
-    const totalOutput = this.sumMetric(sessions, 'commits') + this.sumMetric(sessions, 'filesChanged')
+    const totalOutput =
+      this.sumMetric(sessions, 'commits') + this.sumMetric(sessions, 'filesChanged')
     const outputScore = Math.min(totalOutput / 50, 1) * 20
 
     return Math.round(sessionScore + durationScore + completionScore + outputScore)
@@ -218,7 +223,7 @@ class SessionMetrics {
 
     // Get unique dates with sessions
     const dates = new Set(
-      sessions.map(s => {
+      sessions.map((s) => {
         const d = new Date(s.completedAt || s.startedAt)
         return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`
       })
@@ -257,7 +262,7 @@ class SessionMetrics {
         byDay[key] = {
           sessions: 0,
           duration: 0,
-          commits: 0
+          commits: 0,
         }
       }
 
@@ -293,7 +298,7 @@ class SessionMetrics {
       day: 'Today',
       week: 'This Week',
       month: 'This Month',
-      all: 'All Time'
+      all: 'All Time',
     }
 
     return `
@@ -315,4 +320,4 @@ class SessionMetrics {
 }
 
 export default SessionMetrics
-export { SessionMetrics, AggregatedMetrics, DayMetrics }
+export { SessionMetrics, type AggregatedMetrics, type DayMetrics }

package/core/session/session-log-manager.ts

@@ -4,14 +4,19 @@
  * Writes to sessions/YYYY-MM/DD/ structure with auto-rotation.
  */
 
-import path from 'path'
+import path from 'node:path'
 import pathManager from '../infrastructure/path-manager'
-import { VERSION } from '../utils/version'
+import type {
+  SessionEntry,
+  SessionLogMetadata,
+  SessionMigrationResult,
+  SessionStats,
+} from '../types'
 import * as dateHelper from '../utils/date-helper'
-import * as jsonlHelper from '../utils/jsonl-helper'
 import * as fileHelper from '../utils/file-helper'
+import * as jsonlHelper from '../utils/jsonl-helper'
+import { VERSION } from '../utils/version'
 import { migrateLegacyJsonl, migrateLegacyMarkdown } from './log-migration'
-import type { SessionEntry, SessionLogMetadata, SessionStats, SessionMigrationResult } from '../types'
 
 export class SessionLogManager {
   private currentSessionCache: Map<string, string>
@@ -69,7 +74,7 @@ export class SessionLogManager {
 
     const exists = await fileHelper.fileExists(filePath)
     if (!exists && filename === 'shipped.md') {
-      await fileHelper.writeFile(filePath, '# SHIPPED 🚀\n\n' + content)
+      await fileHelper.writeFile(filePath, `# SHIPPED 🚀\n\n${content}`)
     } else {
       await fileHelper.appendToFile(filePath, content)
     }
@@ -218,11 +223,8 @@ export class SessionLogManager {
         )
       } else {
         const sessionPath = await this.getCurrentSession(projectId)
-        return await migrateLegacyMarkdown(
-          sessionPath,
-          content,
-          sessionFilename,
-          (sp, u) => this._updateSessionLogMetadata(sp, u)
+        return await migrateLegacyMarkdown(sessionPath, content, sessionFilename, (sp, u) =>
+          this._updateSessionLogMetadata(sp, u)
         )
       }
     } catch (error) {
@@ -294,13 +296,6 @@ export class SessionLogManager {
     return dateHelper.getTodayKey()
   }
 
-  /**
-   * Get date key for any date (YYYY-MM-DD)
-   */
-  private _getDateKey(date: Date): string {
-    return dateHelper.getDateKey(date)
-  }
-
   clearCache(): void {
     this.currentSessionCache.clear()
     this.sessionMetadataCache.clear()