prjct-cli 1.6.9 → 1.6.11

package/CHANGELOG.md

@@ -1,12 +1,77 @@
 # Changelog
 
+## [1.6.11] - 2026-02-07
+
+### Performance
+
+- cache provider detection to eliminate redundant shell spawns (PRJ-289) (#136)
+
+
+## [1.6.13] - 2026-02-07
+
+### Improvements
+- **Cache provider detection to eliminate redundant shell spawns (PRJ-289)**: Provider detection results (Claude, Gemini CLI availability) are now cached to `~/.prjct-cli/cache/providers.json` with a 10-minute TTL. Subsequent CLI commands skip shell spawns entirely. Added 2-second timeout on `which`/`--version` spawns to prevent hangs. Added `--refresh` flag to force re-detection.
+
+### Implementation Details
+Created `core/utils/provider-cache.ts` with `readProviderCache()`, `writeProviderCache()`, and `invalidateProviderCache()`. Wired into `detectAllProviders()` — checks cache first, falls through to shell detection on miss or expiry, writes cache after detection. `bin/prjct.ts` parses `--refresh` early (like `--quiet`), invalidates cache, and passes refresh flag to detection.
+
+### Learnings
+- `execAsync` accepts a `timeout` option (milliseconds) that kills the child process on expiry — ideal for preventing hangs on broken CLI installations.
+- Biome enforces `Array#indexOf()` over `Array#findIndex()` for simple equality checks (`useIndexOf` rule).
+- Separating cache logic into its own module keeps `ai-provider.ts` focused on detection logic.
+
+### Test Plan
+
+#### For QA
+1. Run `prjct --version` twice — second run should be near-instant (cache hit)
+2. Delete `~/.prjct-cli/cache/providers.json`, run `prjct --version` — should re-detect and recreate cache
+3. Run `prjct --version --refresh` — should take ~2s (forced re-detection)
+4. Edit cache file to set timestamp 11 minutes ago — next command should re-detect (TTL expired)
+5. Run `prjct sync` — should use cached providers, no shell spawns
+
+#### For Users
+**What changed:** Provider detection is now cached for 10 minutes. CLI startup is ~30x faster for cached commands (~66ms vs ~2100ms).
+**How to use:** Automatic. Use `--refresh` to force re-detection after installing a new CLI.
+**Breaking changes:** None.
+
+## [1.6.10] - 2026-02-07
+
+### Bug Fixes
+
+- resolve signal handler and EventBus listener accumulation leaks (PRJ-287) (#135)
+
+## [1.6.12] - 2026-02-07
+
+### Bug Fixes
+- **Fix signal handler and EventBus listener accumulation leaks (PRJ-287)**: WatchService signal handlers (`SIGINT`/`SIGTERM`) are now stored by reference and removed in `stop()`, preventing accumulation on restart cycles. `pendingChanges` Set is cleared on stop. EventBus gains `flush()` to clear history and stale once-listeners, and `removeAllListeners(event?)` for targeted cleanup.
+
+### Implementation Details
+Stored signal handler references as class properties (`sigintHandler`, `sigtermHandler`). In `start()`, old handlers are removed before new ones are added. In `stop()`, handlers are removed via `process.off()` and `pendingChanges` is cleared. EventBus `flush()` clears history array and all once-listeners. `removeAllListeners()` supports both targeted (single event) and global cleanup.
+
+### Learnings
+- Arrow functions passed to `process.on()` cannot be removed — must store named handler references for `process.off()`.
+- Cleanup code after `process.exit(0)` is unreachable — perform all cleanup before the exit call.
+
+### Test Plan
+
+#### For QA
+1. Start/stop watch mode 10 times — verify only 2 signal handlers (not 20)
+2. Trigger file changes, stop — verify `pendingChanges` cleared
+3. Emit 50 events, call `flush()` — verify history empty
+4. Register `once()` for unfired event, `flush()` — verify listener removed
+5. `removeAllListeners('event')` — verify only that event cleared
+6. `removeAllListeners()` — verify all cleared
+
+#### For Users
+**What changed:** WatchService no longer leaks signal handlers on restart. EventBus has `flush()` and `removeAllListeners()`.
+**Breaking changes:** None.
+
 ## [1.6.9] - 2026-02-07
 
 ### Bug Fixes
 
 - resolve SSE zombie connections and infinite promise leak (PRJ-286) (#134)
 
-
 ## [1.6.11] - 2026-02-07
 
 ### Bug Fixes

package/bin/prjct.ts

@@ -16,6 +16,7 @@ import configManager from '../core/infrastructure/config-manager'
 import editorsConfig from '../core/infrastructure/editors-config'
 import { DEFAULT_PORT, startServer } from '../core/server/server'
 import { fileExists } from '../core/utils/fs-helpers'
+import { invalidateProviderCache } from '../core/utils/provider-cache'
 import { VERSION } from '../core/utils/version'
 
 /**
@@ -62,6 +63,14 @@ if (isQuietMode) {
   setQuietMode(true)
 }
 
+// Parse --refresh flag (force re-detection of providers, invalidate cache)
+const refreshIndex = args.indexOf('--refresh')
+const isRefresh = refreshIndex !== -1
+if (isRefresh) {
+  args.splice(refreshIndex, 1)
+  await invalidateProviderCache()
+}
+
 // Colors for output (chalk respects NO_COLOR env)
 
 // Session tracking for commands that bypass core/index.ts
@@ -217,8 +226,8 @@ if (args[0] === 'start' || args[0] === 'setup') {
   console.log(getHelp(topic))
   process.exitCode = 0
 } else if (args[0] === 'version' || args[0] === '-v' || args[0] === '--version') {
-  // Show version with provider status
-  const detection = await detectAllProviders()
+  // Show version with provider status (uses cached detection unless --refresh)
+  const detection = await detectAllProviders(isRefresh)
   const home = os.homedir()
   const cwd = process.cwd()
   const [

package/core/bus/bus.ts

@@ -237,6 +237,30 @@ class EventBus {
     this.onceListeners.clear()
   }
 
+  /**
+   * Flush event history and clean up stale once-listeners.
+   * Call on task completion, project switch, or periodically.
+   */
+  flush(): void {
+    this.history = []
+
+    // Remove once-listeners for events that were never fired
+    this.onceListeners.clear()
+  }
+
+  /**
+   * Remove all listeners for a specific event, or all events if none specified.
+   */
+  removeAllListeners(event?: string): void {
+    if (event) {
+      this.listeners.delete(event)
+      this.onceListeners.delete(event)
+    } else {
+      this.listeners.clear()
+      this.onceListeners.clear()
+    }
+  }
+
   /**
    * Get count of listeners for an event
    */

package/core/infrastructure/ai-provider.ts

@@ -22,8 +22,10 @@ import os from 'node:os'
 import path from 'node:path'
 import { promisify } from 'node:util'
 import { fileExists } from '../utils/fs-helpers'
+import { readProviderCache, writeProviderCache } from '../utils/provider-cache'
 
 const execAsync = promisify(exec)
+const SPAWN_TIMEOUT_MS = 2000
 
 import type {
   AIProviderConfig,
@@ -179,7 +181,7 @@ export const Providers: Record<AIProviderName, AIProviderConfig> = {
  */
 async function whichCommand(command: string): Promise<string | null> {
   try {
-    const { stdout } = await execAsync(`which ${command}`)
+    const { stdout } = await execAsync(`which ${command}`, { timeout: SPAWN_TIMEOUT_MS })
     return stdout.trim()
   } catch {
     return null
@@ -191,7 +193,7 @@ async function whichCommand(command: string): Promise<string | null> {
  */
 async function getCliVersion(command: string): Promise<string | null> {
   try {
-    const { stdout } = await execAsync(`${command} --version`)
+    const { stdout } = await execAsync(`${command} --version`, { timeout: SPAWN_TIMEOUT_MS })
     // Extract version number from output (e.g., "claude 1.0.0" -> "1.0.0")
     const match = stdout.match(/\d+\.\d+\.\d+/)
     return match ? match[0] : stdout.trim()
@@ -229,14 +231,24 @@ export async function detectProvider(provider: AIProviderName): Promise<Provider
 
 /**
  * Detect all available CLI-based providers
- * Note: Cursor detection is project-level, use detectCursorProject() separately
+ * Results are cached to disk with a 10-minute TTL to avoid redundant shell spawns.
+ * Pass refresh=true to force re-detection.
  */
-export async function detectAllProviders(): Promise<{
+export async function detectAllProviders(refresh = false): Promise<{
   claude: ProviderDetectionResult
   gemini: ProviderDetectionResult
 }> {
+  if (!refresh) {
+    const cached = await readProviderCache()
+    if (cached) return cached
+  }
+
   const [claude, gemini] = await Promise.all([detectProvider('claude'), detectProvider('gemini')])
-  return { claude, gemini }
+  const detection = { claude, gemini }
+
+  await writeProviderCache(detection).catch(() => {})
+
+  return detection
 }
 
 /**

package/core/services/watch-service.ts

@@ -102,6 +102,8 @@ class WatchService {
   }
   private isRunning: boolean = false
   private syncCount: number = 0
+  private sigintHandler: (() => void) | null = null
+  private sigtermHandler: (() => void) | null = null
 
   /**
    * Start watching for file changes
@@ -151,9 +153,13 @@ class WatchService {
       .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())
+    // Handle graceful shutdown — store references for proper removal
+    if (this.sigintHandler) process.off('SIGINT', this.sigintHandler)
+    if (this.sigtermHandler) process.off('SIGTERM', this.sigtermHandler)
+    this.sigintHandler = () => this.stop()
+    this.sigtermHandler = () => this.stop()
+    process.on('SIGINT', this.sigintHandler)
+    process.on('SIGTERM', this.sigtermHandler)
 
     return { success: true }
   }
@@ -177,6 +183,17 @@ class WatchService {
       this.watcher = null
     }
 
+    // Remove signal handlers to prevent accumulation
+    if (this.sigintHandler) {
+      process.off('SIGINT', this.sigintHandler)
+      this.sigintHandler = null
+    }
+    if (this.sigtermHandler) {
+      process.off('SIGTERM', this.sigtermHandler)
+      this.sigtermHandler = null
+    }
+
+    this.pendingChanges.clear()
     this.isRunning = false
     process.exit(0)
   }

package/core/utils/provider-cache.ts

@@ -0,0 +1,49 @@
+import fs from 'node:fs/promises'
+import os from 'node:os'
+import path from 'node:path'
+import type { ProviderDetectionResult } from '../types/provider'
+
+const CACHE_DIR = path.join(os.homedir(), '.prjct-cli', 'cache')
+const CACHE_FILE = path.join(CACHE_DIR, 'providers.json')
+const TTL_MS = 10 * 60 * 1000 // 10 minutes
+
+interface ProviderCache {
+  timestamp: string
+  detection: {
+    claude: ProviderDetectionResult
+    gemini: ProviderDetectionResult
+  }
+}
+
+export async function readProviderCache(): Promise<ProviderCache['detection'] | null> {
+  try {
+    const raw = await fs.readFile(CACHE_FILE, 'utf-8')
+    const cache: ProviderCache = JSON.parse(raw)
+
+    if (!cache.timestamp || !cache.detection) return null
+
+    const age = Date.now() - new Date(cache.timestamp).getTime()
+    if (age > TTL_MS) return null
+
+    return cache.detection
+  } catch {
+    return null
+  }
+}
+
+export async function writeProviderCache(detection: ProviderCache['detection']): Promise<void> {
+  const cache: ProviderCache = {
+    timestamp: new Date().toISOString(),
+    detection,
+  }
+  await fs.mkdir(CACHE_DIR, { recursive: true })
+  await fs.writeFile(CACHE_FILE, JSON.stringify(cache, null, 2))
+}
+
+export async function invalidateProviderCache(): Promise<void> {
+  try {
+    await fs.unlink(CACHE_FILE)
+  } catch {
+    // File doesn't exist — fine
+  }
+}