prjct-cli 0.50.0 → 0.52.0

package/CHANGELOG.md

@@ -1,5 +1,44 @@
 # Changelog
 
+## [0.52.0] - 2026-01-30
+
+### Features
+
+- Add confidence scores to all stored preferences - PRJ-104 (#78)
+
+
+## [0.52.0] - 2026-01-30
+
+### Added
+
+- **Confidence scores for stored preferences** (PRJ-104)
+  - All preferences, decisions, and workflows now track confidence level
+  - Confidence: `low` (1-2 obs), `medium` (3-5 obs), `high` (6+ or confirmed)
+  - Added `confirmPreference()`, `confirmDecision()`, `confirmWorkflow()` methods
+  - User confirmation immediately sets confidence to `high`
+  - Added `calculateConfidence()` utility function
+
+
+## [0.51.0] - 2026-01-30
+
+### Features
+
+- Context diff preview before sync applies - PRJ-125 (#77)
+
+
+## [0.51.0] - 2026-01-30
+
+### Added
+
+- **Context Diff Preview** (PRJ-125)
+  - See what changes sync will make before they're applied
+  - Interactive confirmation: apply, cancel, or show full diff
+  - Preserved sections clearly marked in preview
+  - Token count delta displayed
+  - `--preview` flag for dry-run only
+  - `--yes` flag to skip confirmation
+
+
 ## [0.50.0] - 2026-01-30
 
 ### Features

package/core/agentic/memory-system.ts

@@ -22,6 +22,7 @@ import { appendJsonLine, getLastJsonLines } from '../utils/jsonl-helper'
 
 // Re-export types from canonical location
 export type {
+  ConfidenceLevel,
   Decision,
   HistoryEntry,
   HistoryEventType,
@@ -35,7 +36,7 @@ export type {
   Workflow,
 } from '../types/memory'
 
-export { MEMORY_TAGS } from '../types/memory'
+export { calculateConfidence, MEMORY_TAGS } from '../types/memory'
 
 import type {
   HistoryEntry,
@@ -49,7 +50,7 @@ import type {
   Workflow,
 } from '../types/memory'
 
-import { MEMORY_TAGS } from '../types/memory'
+import { calculateConfidence, MEMORY_TAGS } from '../types/memory'
 
 // =============================================================================
 // Base Store
@@ -306,7 +307,8 @@ export class PatternStore extends CachedStore<Patterns> {
     projectId: string,
     key: string,
     value: string,
-    context: string = ''
+    context: string = '',
+    options: { userConfirmed?: boolean } = {}
   ): Promise<void> {
     const patterns = await this.load(projectId)
     const now = getTimestamp()
@@ -317,11 +319,14 @@ export class PatternStore extends CachedStore<Patterns> {
         count: 1,
         firstSeen: now,
         lastSeen: now,
-        confidence: 'low',
+        confidence: options.userConfirmed ? 'high' : 'low',
         contexts: [context].filter(Boolean),
-      }
+        userConfirmed: options.userConfirmed || false,
+      } as Patterns['decisions'][string]
     } else {
-      const decision = patterns.decisions[key]
+      const decision = patterns.decisions[key] as Patterns['decisions'][string] & {
+        userConfirmed?: boolean
+      }
 
       if (decision.value === value) {
         decision.count++
@@ -329,23 +334,36 @@ export class PatternStore extends CachedStore<Patterns> {
         if (context && !decision.contexts.includes(context)) {
           decision.contexts.push(context)
         }
-
-        if (decision.count >= 5) {
-          decision.confidence = 'high'
-        } else if (decision.count >= 3) {
-          decision.confidence = 'medium'
+        if (options.userConfirmed) {
+          decision.userConfirmed = true
         }
+        decision.confidence = calculateConfidence(decision.count, decision.userConfirmed)
       } else {
         decision.value = value
         decision.count = 1
         decision.lastSeen = now
-        decision.confidence = 'low'
+        decision.userConfirmed = options.userConfirmed || false
+        decision.confidence = options.userConfirmed ? 'high' : 'low'
       }
     }
 
     await this.save(projectId)
   }
 
+  async confirmDecision(projectId: string, key: string): Promise<boolean> {
+    const patterns = await this.load(projectId)
+    const decision = patterns.decisions[key] as
+      | (Patterns['decisions'][string] & { userConfirmed?: boolean })
+      | undefined
+    if (!decision) return false
+
+    decision.userConfirmed = true
+    decision.confidence = 'high'
+    decision.lastSeen = getTimestamp()
+    await this.save(projectId)
+    return true
+  }
+
   async getDecision(
     projectId: string,
     key: string
@@ -378,15 +396,31 @@ export class PatternStore extends CachedStore<Patterns> {
         count: 1,
         firstSeen: now,
         lastSeen: now,
+        confidence: 'low',
+        userConfirmed: false,
       }
     } else {
-      patterns.workflows[workflowName].count++
-      patterns.workflows[workflowName].lastSeen = now
+      const workflow = patterns.workflows[workflowName]
+      workflow.count++
+      workflow.lastSeen = now
+      workflow.confidence = calculateConfidence(workflow.count, workflow.userConfirmed)
     }
 
     await this.save(projectId)
   }
 
+  async confirmWorkflow(projectId: string, workflowName: string): Promise<boolean> {
+    const patterns = await this.load(projectId)
+    const workflow = patterns.workflows[workflowName]
+    if (!workflow) return false
+
+    workflow.userConfirmed = true
+    workflow.confidence = 'high'
+    workflow.lastSeen = getTimestamp()
+    await this.save(projectId)
+    return true
+  }
+
   async getWorkflow(projectId: string, workflowName: string): Promise<Workflow | null> {
     const patterns = await this.load(projectId)
     const workflow = patterns.workflows[workflowName]
@@ -395,12 +429,39 @@ export class PatternStore extends CachedStore<Patterns> {
     return workflow
   }
 
-  async setPreference(projectId: string, key: string, value: Preference['value']): Promise<void> {
+  async setPreference(
+    projectId: string,
+    key: string,
+    value: Preference['value'],
+    options: { userConfirmed?: boolean } = {}
+  ): Promise<void> {
     const patterns = await this.load(projectId)
-    patterns.preferences[key] = { value, updatedAt: getTimestamp() }
+    const existing = patterns.preferences[key]
+    const observationCount = existing ? existing.observationCount + 1 : 1
+    const userConfirmed = options.userConfirmed || existing?.userConfirmed || false
+
+    patterns.preferences[key] = {
+      value,
+      updatedAt: getTimestamp(),
+      confidence: calculateConfidence(observationCount, userConfirmed),
+      observationCount,
+      userConfirmed,
+    }
     await this.save(projectId)
   }
 
+  async confirmPreference(projectId: string, key: string): Promise<boolean> {
+    const patterns = await this.load(projectId)
+    const pref = patterns.preferences[key]
+    if (!pref) return false
+
+    pref.userConfirmed = true
+    pref.confidence = 'high'
+    pref.updatedAt = getTimestamp()
+    await this.save(projectId)
+    return true
+  }
+
   async getPreference(
     projectId: string,
     key: string,
@@ -857,14 +918,31 @@ export class MemorySystem {
     return this._patternStore.getWorkflow(projectId, workflowName)
   }
 
-  setPreference(projectId: string, key: string, value: Preference['value']): Promise<void> {
-    return this._patternStore.setPreference(projectId, key, value)
+  setPreference(
+    projectId: string,
+    key: string,
+    value: Preference['value'],
+    options?: { userConfirmed?: boolean }
+  ): Promise<void> {
+    return this._patternStore.setPreference(projectId, key, value, options)
   }
 
   getPreference(projectId: string, key: string, defaultValue?: unknown): Promise<unknown> {
     return this._patternStore.getPreference(projectId, key, defaultValue)
   }
 
+  confirmPreference(projectId: string, key: string): Promise<boolean> {
+    return this._patternStore.confirmPreference(projectId, key)
+  }
+
+  confirmDecision(projectId: string, key: string): Promise<boolean> {
+    return this._patternStore.confirmDecision(projectId, key)
+  }
+
+  confirmWorkflow(projectId: string, workflowName: string): Promise<boolean> {
+    return this._patternStore.confirmWorkflow(projectId, workflowName)
+  }
+
   getPatternsSummary(projectId: string) {
     return this._patternStore.getPatternsSummary(projectId)
   }

package/core/commands/analysis.ts

@@ -2,15 +2,19 @@
  * Analysis Commands: analyze, sync, and related helpers
  */
 
+import fs from 'node:fs/promises'
 import path from 'node:path'
+import prompts from 'prompts'
 import { generateContext } from '../context/generator'
 import analyzer from '../domain/analyzer'
 import commandInstaller from '../infrastructure/command-installer'
 import { formatCost } from '../schemas/metrics'
 import { syncService } from '../services'
+import { formatDiffPreview, formatFullDiff, generateSyncDiff } from '../services/diff-generator'
 import { metricsStorage } from '../storage/metrics-storage'
 import type { AnalyzeOptions, CommandResult, ProjectContext } from '../types'
 import { showNextSteps } from '../utils/next-steps'
+import out from '../utils/output'
 import {
   configManager,
   contextBuilder,
@@ -195,7 +199,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
   }
 
   /**
-   * /p:sync - Comprehensive project sync
+   * /p:sync - Comprehensive project sync with diff preview
    *
    * Uses syncService to do ALL operations in one TypeScript execution:
    * - Git analysis
@@ -205,120 +209,232 @@ export class AnalysisCommands extends PrjctCommandsBase {
    * - Skill configuration
    * - State updates
    *
+   * Options:
+   * - --preview: Show what would change without applying
+   * - --yes: Skip confirmation prompt
+   *
    * This eliminates the need for Claude to make 50+ individual tool calls.
+   *
+   * @see PRJ-125
    */
   async sync(
     projectPath: string = process.cwd(),
-    options: { aiTools?: string[] } = {}
+    options: { aiTools?: string[]; preview?: boolean; yes?: boolean } = {}
   ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
-      const startTime = Date.now()
-      console.log('🔄 Syncing project...\n')
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        out.failWithHint('NO_PROJECT_ID')
+        return { success: false, error: 'No project ID found' }
+      }
 
-      // Use syncService to do EVERYTHING in one call
-      const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
+      const globalPath = pathManager.getGlobalProjectPath(projectId)
+      const startTime = Date.now()
 
-      if (!result.success) {
-        console.error('❌ Sync failed:', result.error)
-        return { success: false, error: result.error }
+      // Generate diff preview if we have existing context
+      const claudeMdPath = path.join(globalPath, 'context', 'CLAUDE.md')
+      let existingContent: string | null = null
+      try {
+        existingContent = await fs.readFile(claudeMdPath, 'utf-8')
+      } catch {
+        // No existing file - first sync
       }
 
-      // Update global config
-      const globalConfigResult = await commandInstaller.installGlobalConfig()
-      if (globalConfigResult.success) {
-        console.log(`📝 Updated ${pathManager.getDisplayPath(globalConfigResult.path!)}`)
-      }
+      // For preview mode or when we have existing content, show diff first
+      if (existingContent && !options.yes) {
+        out.spin('Analyzing changes...')
 
-      // Format output
-      console.log(`🔄 Project synced to prjct v${result.cliVersion}\n`)
+        // Do a dry-run sync to see what would change
+        const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
 
-      console.log('📊 Project Stats')
-      console.log(`├── Files: ~${result.stats.fileCount}`)
-      console.log(`├── Commits: ${result.git.commits}`)
-      console.log(`├── Version: ${result.stats.version}`)
-      console.log(`└── Stack: ${result.stats.ecosystem}\n`)
+        if (!result.success) {
+          out.fail(result.error || 'Sync failed')
+          return { success: false, error: result.error }
+        }
 
-      console.log('🌿 Git Status')
-      console.log(`├── Branch: ${result.git.branch}`)
-      console.log(`├── Uncommitted: ${result.git.hasChanges ? 'Yes' : 'Clean'}`)
-      console.log(`└── Recent: ${result.git.weeklyCommits} commits this week\n`)
+        // Read the newly generated CLAUDE.md
+        let newContent: string
+        try {
+          newContent = await fs.readFile(claudeMdPath, 'utf-8')
+        } catch {
+          newContent = ''
+        }
 
-      console.log('📁 Context Updated')
-      for (const file of result.contextFiles) {
-        console.log(`├── ${file}`)
-      }
-      console.log('')
+        // Generate diff
+        const diff = generateSyncDiff(existingContent, newContent)
+
+        out.stop()
 
-      // Show AI Tools generated (multi-agent output)
-      if (result.aiTools && result.aiTools.length > 0) {
-        const successTools = result.aiTools.filter((t) => t.success)
-        console.log(`🤖 AI Tools Context (${successTools.length})`)
-        for (const tool of result.aiTools) {
-          const status = tool.success ? '✓' : '✗'
-          console.log(`├── ${status} ${tool.outputFile} (${tool.toolId})`)
+        if (!diff.hasChanges) {
+          out.done('No changes detected (context is up to date)')
+          return { success: true, message: 'No changes' }
         }
-        console.log('')
-      }
 
-      const workflowAgents = result.agents.filter((a) => a.type === 'workflow').map((a) => a.name)
-      const domainAgents = result.agents.filter((a) => a.type === 'domain').map((a) => a.name)
+        // Show diff preview
+        console.log(formatDiffPreview(diff))
+
+        // Preview-only mode - don't apply
+        if (options.preview) {
+          return {
+            success: true,
+            isPreview: true,
+            diff,
+            message: 'Preview complete (no changes applied)',
+          }
+        }
 
-      console.log(`🤖 Agents Regenerated (${result.agents.length})`)
-      console.log(`├── Workflow: ${workflowAgents.join(', ')}`)
-      console.log(`└── Domain: ${domainAgents.join(', ') || 'none'}\n`)
+        // Interactive confirmation
+        const response = await prompts({
+          type: 'select',
+          name: 'action',
+          message: 'Apply these changes?',
+          choices: [
+            { title: 'Yes, apply changes', value: 'apply' },
+            { title: 'No, cancel', value: 'cancel' },
+            { title: 'Show full diff', value: 'diff' },
+          ],
+        })
+
+        if (response.action === 'cancel' || !response.action) {
+          out.warn('Sync cancelled')
+          return { success: false, message: 'Cancelled by user' }
+        }
 
-      if (result.skills.length > 0) {
-        console.log('📦 Skills Configured')
-        for (const skill of result.skills) {
-          console.log(`├── ${skill.agent}.md → ${skill.skill}`)
+        if (response.action === 'diff') {
+          console.log(`\n${formatFullDiff(diff)}`)
+          const confirm = await prompts({
+            type: 'confirm',
+            name: 'apply',
+            message: 'Apply these changes?',
+            initial: true,
+          })
+          if (!confirm.apply) {
+            out.warn('Sync cancelled')
+            return { success: false, message: 'Cancelled by user' }
+          }
         }
-        console.log('')
+
+        // Changes already applied from dry-run, just show success
+        out.done('Changes applied')
+        return this.showSyncResult(result, startTime)
       }
 
-      if (result.git.hasChanges) {
-        console.log('⚠️  You have uncommitted changes\n')
-      } else {
-        console.log('✨ Repository is clean!\n')
+      // First sync or --yes flag - proceed directly
+      out.spin('Syncing project...')
+
+      // Use syncService to do EVERYTHING in one call
+      const result = await syncService.sync(projectPath, { aiTools: options.aiTools })
+
+      if (!result.success) {
+        out.fail(result.error || 'Sync failed')
+        return { success: false, error: result.error }
       }
 
-      showNextSteps('sync')
+      out.stop()
+      return this.showSyncResult(result, startTime)
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
 
-      // Summary metrics
-      const elapsed = Date.now() - startTime
-      const contextFilesCount =
-        result.contextFiles.length + (result.aiTools?.filter((t) => t.success).length || 0)
-      const agentCount = result.agents.length
+  /**
+   * Display sync results (extracted to avoid duplication)
+   */
+  private async showSyncResult(
+    result: Awaited<ReturnType<typeof syncService.sync>>,
+    startTime: number
+  ): Promise<CommandResult> {
+    // Update global config
+    const globalConfigResult = await commandInstaller.installGlobalConfig()
+    if (globalConfigResult.success) {
+      console.log(`📝 Updated ${pathManager.getDisplayPath(globalConfigResult.path!)}`)
+    }
 
-      console.log('─'.repeat(45))
-      console.log(`📊 Sync Summary`)
-      console.log(
-        `   Stack: ${result.stats.ecosystem} (${result.stats.frameworks.join(', ') || 'no frameworks'})`
-      )
-      console.log(
-        `   Files: ${result.stats.fileCount} analyzed → ${contextFilesCount} context files`
-      )
-      console.log(
-        `   Agents: ${agentCount} (${result.agents.filter((a) => a.type === 'domain').length} domain)`
-      )
-      console.log(`   Time: ${(elapsed / 1000).toFixed(1)}s`)
+    // Format output
+    console.log(`🔄 Project synced to prjct v${result.cliVersion}\n`)
+
+    console.log('📊 Project Stats')
+    console.log(`├── Files: ~${result.stats.fileCount}`)
+    console.log(`├── Commits: ${result.git.commits}`)
+    console.log(`├── Version: ${result.stats.version}`)
+    console.log(`└── Stack: ${result.stats.ecosystem}\n`)
+
+    console.log('🌿 Git Status')
+    console.log(`├── Branch: ${result.git.branch}`)
+    console.log(`├── Uncommitted: ${result.git.hasChanges ? 'Yes' : 'Clean'}`)
+    console.log(`└── Recent: ${result.git.weeklyCommits} commits this week\n`)
+
+    console.log('📁 Context Updated')
+    for (const file of result.contextFiles) {
+      console.log(`├── ${file}`)
+    }
+    console.log('')
+
+    // Show AI Tools generated (multi-agent output)
+    if (result.aiTools && result.aiTools.length > 0) {
+      const successTools = result.aiTools.filter((t) => t.success)
+      console.log(`🤖 AI Tools Context (${successTools.length})`)
+      for (const tool of result.aiTools) {
+        const status = tool.success ? '✓' : '✗'
+        console.log(`├── ${status} ${tool.outputFile} (${tool.toolId})`)
+      }
       console.log('')
+    }
 
-      return {
-        success: true,
-        data: result,
-        metrics: {
-          elapsed,
-          contextFilesCount,
-          agentCount,
-          fileCount: result.stats.fileCount,
-        },
+    const workflowAgents = result.agents.filter((a) => a.type === 'workflow').map((a) => a.name)
+    const domainAgents = result.agents.filter((a) => a.type === 'domain').map((a) => a.name)
+
+    console.log(`🤖 Agents Regenerated (${result.agents.length})`)
+    console.log(`├── Workflow: ${workflowAgents.join(', ')}`)
+    console.log(`└── Domain: ${domainAgents.join(', ') || 'none'}\n`)
+
+    if (result.skills.length > 0) {
+      console.log('📦 Skills Configured')
+      for (const skill of result.skills) {
+        console.log(`├── ${skill.agent}.md → ${skill.skill}`)
       }
-    } catch (error) {
-      console.error('❌ Error:', (error as Error).message)
-      return { success: false, error: (error as Error).message }
+      console.log('')
+    }
+
+    if (result.git.hasChanges) {
+      console.log('⚠️  You have uncommitted changes\n')
+    } else {
+      console.log('✨ Repository is clean!\n')
+    }
+
+    showNextSteps('sync')
+
+    // Summary metrics
+    const elapsed = Date.now() - startTime
+    const contextFilesCount =
+      result.contextFiles.length + (result.aiTools?.filter((t) => t.success).length || 0)
+    const agentCount = result.agents.length
+
+    console.log('─'.repeat(45))
+    console.log('📊 Sync Summary')
+    console.log(
+      `   Stack: ${result.stats.ecosystem} (${result.stats.frameworks.join(', ') || 'no frameworks'})`
+    )
+    console.log(`   Files: ${result.stats.fileCount} analyzed → ${contextFilesCount} context files`)
+    console.log(
+      `   Agents: ${agentCount} (${result.agents.filter((a) => a.type === 'domain').length} domain)`
+    )
+    console.log(`   Time: ${(elapsed / 1000).toFixed(1)}s`)
+    console.log('')
+
+    return {
+      success: true,
+      data: result,
+      metrics: {
+        elapsed,
+        contextFilesCount,
+        agentCount,
+        fileCount: result.stats.fileCount,
+      },
     }
   }