prjct-cli 0.11.5 → 0.12.0

package/core/domain/{smart-cache.js → smart-cache.ts}

@@ -1,21 +1,31 @@
 /**
  * SmartCache - Intelligent Persistent Cache for Agents
- * 
+ *
  * Cache with specific keys: {projectId}-{domain}-{techStack}
  * Persists to disk for cross-session caching
  * Invalidates only when stack changes
- * 
+ *
  * @version 1.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const os = require('os')
-const crypto = require('crypto')
-const log = require('../utils/logger')
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import crypto from 'crypto'
+import log from '../utils/logger'
+
+interface CacheStats {
+  size: number
+  keys: string[]
+}
 
 class SmartCache {
-  constructor(projectId = null) {
+  projectId: string | null
+  memoryCache: Map<string, unknown>
+  cacheDir: string
+  cacheFile: string
+
+  constructor(projectId: string | null = null) {
     this.projectId = projectId
     this.memoryCache = new Map()
     this.cacheDir = path.join(os.homedir(), '.prjct-cli', 'cache')
@@ -27,11 +37,11 @@ class SmartCache {
   /**
    * Initialize cache - load from disk
    */
-  async initialize() {
+  async initialize(): Promise<void> {
     try {
       await fs.mkdir(this.cacheDir, { recursive: true })
       await this.loadFromDisk()
-    } catch (error) {
+    } catch {
       // Cache file doesn't exist yet - that's ok
       this.memoryCache = new Map()
     }
@@ -41,7 +51,7 @@ class SmartCache {
    * Generate cache key
    * Format: {projectId}-{domain}-{techStackHash}
    */
-  generateKey(projectId, domain, techStack = {}) {
+  generateKey(projectId: string | null, domain: string, techStack: Record<string, unknown> = {}): string {
     const techString = JSON.stringify(techStack)
     const techHash = crypto.createHash('md5').update(techString).digest('hex').substring(0, 8)
     return `${projectId || 'global'}-${domain}-${techHash}`
@@ -50,26 +60,26 @@ class SmartCache {
   /**
    * Get from cache
    */
-  async get(key) {
+  async get<T = unknown>(key: string): Promise<T | null> {
     // Check memory first
     if (this.memoryCache.has(key)) {
-      return this.memoryCache.get(key)
+      return this.memoryCache.get(key) as T
     }
 
     // Load from disk if not in memory
     await this.loadFromDisk()
-    return this.memoryCache.get(key) || null
+    return (this.memoryCache.get(key) as T) || null
   }
 
   /**
    * Set in cache
    */
-  async set(key, value) {
+  async set(key: string, value: unknown): Promise<void> {
     // Set in memory
     this.memoryCache.set(key, value)
 
     // Persist to disk (async, don't wait)
-    this.persistToDisk().catch(err => {
+    this.persistToDisk().catch((err) => {
       log.error('Cache persist error:', err.message)
     })
   }
@@ -77,7 +87,7 @@ class SmartCache {
   /**
    * Check if key exists
    */
-  async has(key) {
+  async has(key: string): Promise<boolean> {
     if (this.memoryCache.has(key)) {
       return true
     }
@@ -89,7 +99,7 @@ class SmartCache {
   /**
    * Clear cache
    */
-  async clear() {
+  async clear(): Promise<void> {
     this.memoryCache.clear()
     try {
       await fs.unlink(this.cacheFile)
@@ -101,26 +111,26 @@ class SmartCache {
   /**
    * Invalidate cache for a project (when stack changes)
    */
-  async invalidateProject(projectId) {
-    const keysToDelete = []
+  async invalidateProject(projectId: string): Promise<void> {
+    const keysToDelete: string[] = []
     for (const key of this.memoryCache.keys()) {
       if (key.startsWith(`${projectId}-`)) {
         keysToDelete.push(key)
       }
     }
 
-    keysToDelete.forEach(key => this.memoryCache.delete(key))
+    keysToDelete.forEach((key) => this.memoryCache.delete(key))
     await this.persistToDisk()
   }
 
   /**
    * Load cache from disk
    */
-  async loadFromDisk() {
+  async loadFromDisk(): Promise<void> {
     try {
       const content = await fs.readFile(this.cacheFile, 'utf-8')
-      const data = JSON.parse(content)
-      
+      const data = JSON.parse(content) as Record<string, unknown>
+
       // Restore to memory cache
       for (const [key, value] of Object.entries(data)) {
         this.memoryCache.set(key, value)
@@ -134,11 +144,11 @@ class SmartCache {
   /**
    * Persist cache to disk
    */
-  async persistToDisk() {
+  async persistToDisk(): Promise<void> {
     try {
       const data = Object.fromEntries(this.memoryCache)
       await fs.writeFile(this.cacheFile, JSON.stringify(data, null, 2), 'utf-8')
-    } catch (error) {
+    } catch {
       // Fail silently - cache is best effort
     }
   }
@@ -146,13 +156,12 @@ class SmartCache {
   /**
    * Get cache statistics
    */
-  getStats() {
+  getStats(): CacheStats {
     return {
       size: this.memoryCache.size,
-      keys: Array.from(this.memoryCache.keys())
+      keys: Array.from(this.memoryCache.keys()),
     }
   }
 }
 
-module.exports = SmartCache
-
+export default SmartCache

package/core/domain/{snapshot-manager.js → snapshot-manager.ts}

@@ -9,28 +9,57 @@
  * @version 1.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const { exec } = require('child_process')
-const { promisify } = require('util')
-const pathManager = require('../infrastructure/path-manager')
-const configManager = require('../infrastructure/config-manager')
-const { emit } = require('../bus')
+import fs from 'fs/promises'
+import path from 'path'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import pathManager from '../infrastructure/path-manager'
+import configManager from '../infrastructure/config-manager'
+import { emit } from '../bus'
 
 const execAsync = promisify(exec)
 
+interface SnapshotInfo {
+  hash: string | null
+  message: string
+  timestamp: string
+  files: string[]
+}
+
+interface SnapshotListItem {
+  hash: string
+  short: string
+  message: string
+  date: string
+}
+
+interface RestoreResult {
+  hash: string
+  files: string[]
+  timestamp: string
+}
+
+interface RedoStackEntry {
+  hash: string
+  message: string
+  timestamp: string
+  files: string[]
+}
+
 class SnapshotManager {
-  constructor(projectPath) {
+  projectPath: string
+  projectId: string | null = null
+  snapshotDir: string | null = null
+  initialized: boolean = false
+
+  constructor(projectPath: string) {
     this.projectPath = projectPath
-    this.projectId = null
-    this.snapshotDir = null
-    this.initialized = false
   }
 
   /**
    * Initialize snapshot system for project
    */
-  async initialize() {
+  async initialize(): Promise<void> {
     this.projectId = await configManager.getProjectId(this.projectPath)
     if (!this.projectId) {
       throw new Error('No prjct project found. Run /p:init first.')
@@ -57,54 +86,48 @@ class SnapshotManager {
   /**
    * Initialize internal Git repository
    */
-  async initGitRepo() {
-    const gitDir = path.join(this.snapshotDir, '.git')
-
+  async initGitRepo(): Promise<void> {
     // Create bare-ish repo structure
     await execAsync(`git init "${this.snapshotDir}"`, { cwd: this.projectPath })
 
     // Configure for snapshot use
-    await execAsync(`git config user.email "prjct@local"`, { cwd: this.snapshotDir })
-    await execAsync(`git config user.name "prjct-snapshots"`, { cwd: this.snapshotDir })
+    await execAsync(`git config user.email "prjct@local"`, { cwd: this.snapshotDir! })
+    await execAsync(`git config user.name "prjct-snapshots"`, { cwd: this.snapshotDir! })
 
     // Create initial empty commit
-    await execAsync(`git commit --allow-empty -m "init: snapshot system"`, { cwd: this.snapshotDir })
+    await execAsync(`git commit --allow-empty -m "init: snapshot system"`, { cwd: this.snapshotDir! })
   }
 
   /**
    * Create a snapshot of current project state
-   *
-   * @param {string} message - Snapshot description
-   * @param {string[]} files - Specific files to track (optional, defaults to all changed)
-   * @returns {Promise<Object>} Snapshot info {hash, message, timestamp, files}
    */
-  async create(message, files = null) {
+  async create(message: string, files: string[] | null = null): Promise<SnapshotInfo> {
     if (!this.initialized) await this.initialize()
 
     const timestamp = new Date().toISOString()
 
     // Copy changed files to snapshot directory
-    const changedFiles = files || await this.getChangedFiles()
+    const changedFiles = files || (await this.getChangedFiles())
 
     if (changedFiles.length === 0) {
       return {
         hash: null,
         message: 'No changes to snapshot',
         timestamp,
-        files: []
+        files: [],
       }
     }
 
     // Copy files to snapshot dir maintaining structure
     for (const file of changedFiles) {
       const srcPath = path.join(this.projectPath, file)
-      const destPath = path.join(this.snapshotDir, file)
+      const destPath = path.join(this.snapshotDir!, file)
 
       try {
         const content = await fs.readFile(srcPath, 'utf-8')
         await fs.mkdir(path.dirname(destPath), { recursive: true })
         await fs.writeFile(destPath, content)
-      } catch (err) {
+      } catch {
         // File might be deleted, mark for removal
         try {
           await fs.unlink(destPath)
@@ -113,13 +136,13 @@ class SnapshotManager {
     }
 
     // Stage and commit in snapshot repo
-    await execAsync(`git add -A`, { cwd: this.snapshotDir })
+    await execAsync(`git add -A`, { cwd: this.snapshotDir! })
 
     const commitMsg = `${message}\n\nFiles: ${changedFiles.length}\nTimestamp: ${timestamp}`
-    await execAsync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { cwd: this.snapshotDir })
+    await execAsync(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`, { cwd: this.snapshotDir! })
 
     // Get commit hash
-    const { stdout } = await execAsync(`git rev-parse HEAD`, { cwd: this.snapshotDir })
+    const { stdout } = await execAsync(`git rev-parse HEAD`, { cwd: this.snapshotDir! })
     const hash = stdout.trim()
 
     // Log to manifest
@@ -127,7 +150,7 @@ class SnapshotManager {
       hash,
       message,
       timestamp,
-      files: changedFiles
+      files: changedFiles,
     })
 
     // Emit event for plugins
@@ -136,7 +159,7 @@ class SnapshotManager {
       message,
       timestamp,
       filesCount: changedFiles.length,
-      projectId: this.projectId
+      projectId: this.projectId,
     })
 
     return { hash, message, timestamp, files: changedFiles }
@@ -145,18 +168,15 @@ class SnapshotManager {
   /**
    * Get list of changed files in project
    */
-  async getChangedFiles() {
+  async getChangedFiles(): Promise<string[]> {
     try {
-      const { stdout } = await execAsync(
-        `git status --porcelain`,
-        { cwd: this.projectPath }
-      )
+      const { stdout } = await execAsync(`git status --porcelain`, { cwd: this.projectPath })
 
       return stdout
         .split('\n')
         .filter(Boolean)
-        .map(line => line.slice(3).trim())
-        .filter(file => !file.startsWith('.prjct/'))
+        .map((line) => line.slice(3).trim())
+        .filter((file) => !file.startsWith('.prjct/'))
     } catch {
       return []
     }
@@ -164,30 +184,27 @@ class SnapshotManager {
 
   /**
    * List all snapshots
-   *
-   * @param {number} limit - Max snapshots to return
-   * @returns {Promise<Array>} List of snapshots
    */
-  async list(limit = 10) {
+  async list(limit: number = 10): Promise<SnapshotListItem[]> {
     if (!this.initialized) await this.initialize()
 
     try {
       const { stdout } = await execAsync(
         `git log --pretty=format:'{"hash":"%H","short":"%h","message":"%s","date":"%ai"}' -n ${limit}`,
-        { cwd: this.snapshotDir }
+        { cwd: this.snapshotDir! }
       )
 
       return stdout
         .split('\n')
         .filter(Boolean)
-        .map(line => {
+        .map((line) => {
           try {
-            return JSON.parse(line)
+            return JSON.parse(line) as SnapshotListItem
           } catch {
             return null
           }
         })
-        .filter(Boolean)
+        .filter((item): item is SnapshotListItem => item !== null)
     } catch {
       return []
     }
@@ -195,34 +212,30 @@ class SnapshotManager {
 
   /**
    * Restore project to a specific snapshot
-   *
-   * @param {string} hash - Commit hash to restore
-   * @returns {Promise<Object>} Restore result
    */
-  async restore(hash) {
+  async restore(hash: string): Promise<RestoreResult> {
     if (!this.initialized) await this.initialize()
 
     // Get files changed in that commit
-    const { stdout: filesOutput } = await execAsync(
-      `git diff-tree --no-commit-id --name-only -r ${hash}`,
-      { cwd: this.snapshotDir }
-    )
+    const { stdout: filesOutput } = await execAsync(`git diff-tree --no-commit-id --name-only -r ${hash}`, {
+      cwd: this.snapshotDir!,
+    })
 
     const files = filesOutput.split('\n').filter(Boolean)
 
     // Checkout files from that snapshot
-    await execAsync(`git checkout ${hash} -- .`, { cwd: this.snapshotDir })
+    await execAsync(`git checkout ${hash} -- .`, { cwd: this.snapshotDir! })
 
     // Copy files back to project
     for (const file of files) {
-      const srcPath = path.join(this.snapshotDir, file)
+      const srcPath = path.join(this.snapshotDir!, file)
       const destPath = path.join(this.projectPath, file)
 
       try {
         const content = await fs.readFile(srcPath, 'utf-8')
         await fs.mkdir(path.dirname(destPath), { recursive: true })
         await fs.writeFile(destPath, content)
-      } catch (err) {
+      } catch {
         // File doesn't exist in snapshot, might need to delete from project
         try {
           await fs.unlink(destPath)
@@ -240,7 +253,7 @@ class SnapshotManager {
       hash,
       filesCount: files.length,
       timestamp,
-      projectId: this.projectId
+      projectId: this.projectId,
     })
 
     return { hash, files, timestamp }
@@ -248,18 +261,12 @@ class SnapshotManager {
 
   /**
    * Get diff between current state and a snapshot
-   *
-   * @param {string} hash - Snapshot hash to compare
-   * @returns {Promise<string>} Diff output
    */
-  async diff(hash) {
+  async diff(hash: string): Promise<string> {
     if (!this.initialized) await this.initialize()
 
     try {
-      const { stdout } = await execAsync(
-        `git diff ${hash} --stat`,
-        { cwd: this.snapshotDir }
-      )
+      const { stdout } = await execAsync(`git diff ${hash} --stat`, { cwd: this.snapshotDir! })
       return stdout
     } catch {
       return ''
@@ -269,14 +276,11 @@ class SnapshotManager {
   /**
    * Get the most recent snapshot hash
    */
-  async getLatestHash() {
+  async getLatestHash(): Promise<string | null> {
     if (!this.initialized) await this.initialize()
 
     try {
-      const { stdout } = await execAsync(
-        `git rev-parse HEAD`,
-        { cwd: this.snapshotDir }
-      )
+      const { stdout } = await execAsync(`git rev-parse HEAD`, { cwd: this.snapshotDir! })
       return stdout.trim()
     } catch {
       return null
@@ -286,14 +290,11 @@ class SnapshotManager {
   /**
    * Get the hash before the current one (for undo)
    */
-  async getPreviousHash() {
+  async getPreviousHash(): Promise<string | null> {
     if (!this.initialized) await this.initialize()
 
     try {
-      const { stdout } = await execAsync(
-        `git rev-parse HEAD~1`,
-        { cwd: this.snapshotDir }
-      )
+      const { stdout } = await execAsync(`git rev-parse HEAD~1`, { cwd: this.snapshotDir! })
       return stdout.trim()
     } catch {
       return null
@@ -303,12 +304,13 @@ class SnapshotManager {
   /**
    * Log snapshot to manifest
    */
-  async logSnapshot(snapshot) {
-    const manifestPath = path.join(this.snapshotDir, 'manifest.jsonl')
-    const entry = JSON.stringify({
-      type: 'snapshot',
-      ...snapshot
-    }) + '\n'
+  async logSnapshot(snapshot: SnapshotInfo): Promise<void> {
+    const manifestPath = path.join(this.snapshotDir!, 'manifest.jsonl')
+    const entry =
+      JSON.stringify({
+        type: 'snapshot',
+        ...snapshot,
+      }) + '\n'
 
     await fs.appendFile(manifestPath, entry)
   }
@@ -316,14 +318,15 @@ class SnapshotManager {
   /**
    * Log restoration to manifest
    */
-  async logRestore(hash, files) {
-    const manifestPath = path.join(this.snapshotDir, 'manifest.jsonl')
-    const entry = JSON.stringify({
-      type: 'restore',
-      hash,
-      files,
-      timestamp: new Date().toISOString()
-    }) + '\n'
+  async logRestore(hash: string, files: string[]): Promise<void> {
+    const manifestPath = path.join(this.snapshotDir!, 'manifest.jsonl')
+    const entry =
+      JSON.stringify({
+        type: 'restore',
+        hash,
+        files,
+        timestamp: new Date().toISOString(),
+      }) + '\n'
 
     await fs.appendFile(manifestPath, entry)
   }
@@ -332,8 +335,8 @@ class SnapshotManager {
    * Get redo stack (snapshots after current position)
    * This tracks undone snapshots that can be redone
    */
-  async getRedoStack() {
-    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+  async getRedoStack(): Promise<RedoStackEntry[]> {
+    const stackPath = path.join(this.snapshotDir!, 'redo-stack.json')
     try {
       const content = await fs.readFile(stackPath, 'utf-8')
       return JSON.parse(content)
@@ -345,20 +348,20 @@ class SnapshotManager {
   /**
    * Push to redo stack (when undoing)
    */
-  async pushToRedoStack(snapshot) {
+  async pushToRedoStack(snapshot: RedoStackEntry): Promise<void> {
     const stack = await this.getRedoStack()
     stack.push(snapshot)
-    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+    const stackPath = path.join(this.snapshotDir!, 'redo-stack.json')
     await fs.writeFile(stackPath, JSON.stringify(stack, null, 2))
   }
 
   /**
    * Pop from redo stack (when redoing)
    */
-  async popFromRedoStack() {
+  async popFromRedoStack(): Promise<RedoStackEntry | undefined> {
     const stack = await this.getRedoStack()
     const snapshot = stack.pop()
-    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+    const stackPath = path.join(this.snapshotDir!, 'redo-stack.json')
     await fs.writeFile(stackPath, JSON.stringify(stack, null, 2))
     return snapshot
   }
@@ -366,10 +369,10 @@ class SnapshotManager {
   /**
    * Clear redo stack (when creating new snapshot after undo)
    */
-  async clearRedoStack() {
-    const stackPath = path.join(this.snapshotDir, 'redo-stack.json')
+  async clearRedoStack(): Promise<void> {
+    const stackPath = path.join(this.snapshotDir!, 'redo-stack.json')
     await fs.writeFile(stackPath, '[]')
   }
 }
 
-module.exports = SnapshotManager
+export default SnapshotManager