prjct-cli 0.44.1 → 0.45.3

package/core/commands/analysis.ts

@@ -2,28 +2,32 @@
  * Analysis Commands: analyze, sync, and related helpers
  */
 
-import path from 'path'
-
-import type { CommandResult, AnalyzeOptions, ProjectContext } from '../types'
-import {
-  PrjctCommandsBase,
-  contextBuilder,
-  toolRegistry,
-  pathManager,
-  configManager,
-  dateHelper
-} from './base'
-import analyzer from '../domain/analyzer'
+import path from 'node:path'
 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 { metricsStorage } from '../storage/metrics-storage'
+import type { AnalyzeOptions, CommandResult, ProjectContext } from '../types'
 import { showNextSteps } from '../utils/next-steps'
+import {
+  configManager,
+  contextBuilder,
+  dateHelper,
+  PrjctCommandsBase,
+  pathManager,
+  toolRegistry,
+} from './base'
 
 export class AnalysisCommands extends PrjctCommandsBase {
   /**
    * /p:analyze - Analyze repository and generate summary
    */
-  async analyze(options: AnalyzeOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async analyze(
+    options: AnalyzeOptions = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     try {
       await this.initializeAgent()
 
@@ -31,7 +35,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       analyzer.init(projectPath)
 
-      const context = await contextBuilder.build(projectPath, options) as ProjectContext
+      const context = (await contextBuilder.build(projectPath, options)) as ProjectContext
 
       const analysisData = {
         packageJson: await analyzer.readPackageJson(),
@@ -58,12 +62,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       const projectId = await configManager.getProjectId(projectPath)
       const summaryPath =
-        context.paths.analysis ||
-        pathManager.getFilePath(
-          projectId!,
-          'analysis',
-          'repo-summary.md'
-        )
+        context.paths.analysis || pathManager.getFilePath(projectId!, 'analysis', 'repo-summary.md')
 
       await toolRegistry.get('Write')!(summaryPath, summary)
 
@@ -163,7 +162,9 @@ export class AnalysisCommands extends PrjctCommandsBase {
     if (data.hasReadme) lines.push('- **Documentation**: README.md found')
     lines.push('')
 
-    const gitStats = data.gitStats as { totalCommits?: number; contributors?: number; age?: string } | undefined
+    const gitStats = data.gitStats as
+      | { totalCommits?: number; contributors?: number; age?: string }
+      | undefined
     lines.push('## Git Statistics\n')
     lines.push(`- **Total Commits**: ${gitStats?.totalCommits || 0}`)
     lines.push(`- **Contributors**: ${gitStats?.contributors || 0}`)
@@ -206,7 +207,10 @@ export class AnalysisCommands extends PrjctCommandsBase {
    *
    * This eliminates the need for Claude to make 50+ individual tool calls.
    */
-  async sync(projectPath: string = process.cwd(), options: { aiTools?: string[] } = {}): Promise<CommandResult> {
+  async sync(
+    projectPath: string = process.cwd(),
+    options: { aiTools?: string[] } = {}
+  ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
@@ -250,7 +254,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       // Show AI Tools generated (multi-agent output)
       if (result.aiTools && result.aiTools.length > 0) {
-        const successTools = result.aiTools.filter(t => t.success)
+        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 ? '✓' : '✗'
@@ -259,8 +263,8 @@ export class AnalysisCommands extends PrjctCommandsBase {
         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)
+      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(', ')}`)
@@ -284,14 +288,21 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       // Summary metrics
       const elapsed = Date.now() - startTime
-      const contextFilesCount = result.contextFiles.length + (result.aiTools?.filter(t => t.success).length || 0)
+      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(
+        `   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('')
 
@@ -311,4 +322,251 @@ export class AnalysisCommands extends PrjctCommandsBase {
     }
   }
 
+  /**
+   * /p:stats - Value dashboard showing accumulated savings and impact
+   *
+   * Displays:
+   * - Token savings (total, compression rate, estimated cost)
+   * - Performance metrics (sync count, avg duration)
+   * - Agent usage breakdown
+   * - 30-day trend visualization
+   */
+  async stats(
+    projectPath: string = process.cwd(),
+    options: { json?: boolean; export?: boolean } = {}
+  ): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        return { success: false, error: 'No project ID found' }
+      }
+
+      // Get metrics summary
+      const summary = await metricsStorage.getSummary(projectId)
+      const dailyStats = await metricsStorage.getDailyStats(projectId, 30)
+
+      // JSON output mode
+      if (options.json) {
+        const jsonOutput = {
+          totalTokensSaved: summary.totalTokensSaved,
+          estimatedCostSaved: summary.estimatedCostSaved,
+          compressionRate: summary.compressionRate,
+          syncCount: summary.syncCount,
+          avgSyncDuration: summary.avgSyncDuration,
+          topAgents: summary.topAgents,
+          last30DaysTokens: summary.last30DaysTokens,
+          trend: summary.trend,
+          dailyStats,
+        }
+        console.log(JSON.stringify(jsonOutput, null, 2))
+        return { success: true, data: jsonOutput }
+      }
+
+      // Get project info for header
+      const globalPath = pathManager.getGlobalProjectPath(projectId)
+      let projectName = 'Unknown'
+      try {
+        const fs = require('node:fs/promises')
+        const path = require('node:path')
+        const projectJson = JSON.parse(
+          await fs.readFile(path.join(globalPath, 'project.json'), 'utf-8')
+        )
+        projectName = projectJson.name || 'Unknown'
+      } catch {
+        // Use fallback
+      }
+
+      // Determine first sync date
+      const metricsData = await metricsStorage.read(projectId)
+      const firstSyncDate = metricsData.firstSync
+        ? new Date(metricsData.firstSync).toLocaleDateString('en-US', {
+            month: 'short',
+            day: 'numeric',
+            year: 'numeric',
+          })
+        : 'N/A'
+
+      // ASCII Dashboard
+      console.log('')
+      console.log('╭─────────────────────────────────────────────────╮')
+      console.log('│  📊 prjct-cli Value Dashboard                   │')
+      console.log(
+        `│  Project: ${projectName.padEnd(20).slice(0, 20)} | Since: ${firstSyncDate.padEnd(12).slice(0, 12)} │`
+      )
+      console.log('╰─────────────────────────────────────────────────╯')
+      console.log('')
+
+      // Token Savings Section
+      console.log('💰 TOKEN SAVINGS')
+      console.log(`   Total saved:     ${this._formatTokens(summary.totalTokensSaved)} tokens`)
+      console.log(
+        `   Compression:     ${(summary.compressionRate * 100).toFixed(0)}% average reduction`
+      )
+      console.log(`   Estimated cost:  ${formatCost(summary.estimatedCostSaved)} saved`)
+      console.log('')
+
+      // Performance Section
+      console.log('⚡ PERFORMANCE')
+      console.log(`   Syncs completed: ${summary.syncCount.toLocaleString()}`)
+      console.log(`   Avg sync time:   ${this._formatDuration(summary.avgSyncDuration)}`)
+      console.log('')
+
+      // Agent Usage Section
+      if (summary.topAgents.length > 0) {
+        console.log('🤖 AGENT USAGE')
+        const totalUsage = summary.topAgents.reduce((sum, a) => sum + a.usageCount, 0)
+        for (const agent of summary.topAgents) {
+          const pct = totalUsage > 0 ? ((agent.usageCount / totalUsage) * 100).toFixed(0) : 0
+          console.log(`   ${agent.agentName.padEnd(12)}: ${pct}% (${agent.usageCount} uses)`)
+        }
+        console.log('')
+      }
+
+      // 30-Day Trend Section
+      if (dailyStats.length > 0) {
+        console.log('📈 TREND (last 30 days)')
+        const sparkline = this._generateSparkline(dailyStats)
+        console.log(`   ${sparkline} ${this._formatTokens(summary.last30DaysTokens)} tokens saved`)
+
+        if (summary.trend !== 0) {
+          const trendIcon = summary.trend > 0 ? '↑' : '↓'
+          const trendSign = summary.trend > 0 ? '+' : ''
+          console.log(
+            `   ${trendIcon} ${trendSign}${summary.trend.toFixed(0)}% vs previous 30 days`
+          )
+        }
+        console.log('')
+      }
+
+      // Footer
+      console.log('───────────────────────────────────────────────────')
+      console.log(`Export: prjct stats --export > stats.md`)
+      console.log('')
+
+      // Export mode - return markdown
+      if (options.export) {
+        const markdown = this._generateStatsMarkdown(
+          summary,
+          dailyStats,
+          projectName,
+          firstSyncDate
+        )
+        console.log(markdown)
+        return { success: true, data: { markdown } }
+      }
+
+      return {
+        success: true,
+        data: summary,
+      }
+    } catch (error) {
+      console.error('❌ Error:', (error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  // =========== Stats Helper Methods ===========
+
+  private _formatTokens(tokens: number): string {
+    if (tokens >= 1_000_000) {
+      return `${(tokens / 1_000_000).toFixed(1)}M`
+    }
+    if (tokens >= 1_000) {
+      return `${(tokens / 1_000).toFixed(1)}K`
+    }
+    return tokens.toLocaleString()
+  }
+
+  private _formatDuration(ms: number): string {
+    if (ms < 1000) {
+      return `${Math.round(ms)}ms`
+    }
+    return `${(ms / 1000).toFixed(1)}s`
+  }
+
+  private _generateSparkline(dailyStats: { tokensSaved: number }[]): string {
+    if (dailyStats.length === 0) return ''
+
+    const chars = '▁▂▃▄▅▆▇█'
+    const values = dailyStats.map((d) => d.tokensSaved)
+    const max = Math.max(...values, 1)
+
+    return values
+      .map((v) => {
+        const idx = Math.min(Math.floor((v / max) * (chars.length - 1)), chars.length - 1)
+        return chars[idx]
+      })
+      .join('')
+  }
+
+  private _generateStatsMarkdown(
+    summary: {
+      totalTokensSaved: number
+      estimatedCostSaved: number
+      compressionRate: number
+      syncCount: number
+      avgSyncDuration: number
+      topAgents: { agentName: string; usageCount: number }[]
+      last30DaysTokens: number
+      trend: number
+    },
+    _dailyStats: { date: string; tokensSaved: number; syncs: number }[],
+    projectName: string,
+    firstSyncDate: string
+  ): string {
+    const lines: string[] = []
+
+    lines.push(`# ${projectName} - Value Dashboard`)
+    lines.push('')
+    lines.push(`_Generated: ${new Date().toLocaleString()} | Tracking since: ${firstSyncDate}_`)
+    lines.push('')
+
+    lines.push('## 💰 Token Savings')
+    lines.push('')
+    lines.push(`| Metric | Value |`)
+    lines.push(`|--------|-------|`)
+    lines.push(`| Total saved | ${this._formatTokens(summary.totalTokensSaved)} tokens |`)
+    lines.push(`| Compression | ${(summary.compressionRate * 100).toFixed(0)}% |`)
+    lines.push(`| Cost saved | ${formatCost(summary.estimatedCostSaved)} |`)
+    lines.push('')
+
+    lines.push('## ⚡ Performance')
+    lines.push('')
+    lines.push(`| Metric | Value |`)
+    lines.push(`|--------|-------|`)
+    lines.push(`| Syncs | ${summary.syncCount} |`)
+    lines.push(`| Avg time | ${this._formatDuration(summary.avgSyncDuration)} |`)
+    lines.push('')
+
+    if (summary.topAgents.length > 0) {
+      lines.push('## 🤖 Agent Usage')
+      lines.push('')
+      lines.push(`| Agent | Usage |`)
+      lines.push(`|-------|-------|`)
+      const totalUsage = summary.topAgents.reduce((sum, a) => sum + a.usageCount, 0)
+      for (const agent of summary.topAgents) {
+        const pct = totalUsage > 0 ? ((agent.usageCount / totalUsage) * 100).toFixed(0) : 0
+        lines.push(`| ${agent.agentName} | ${pct}% (${agent.usageCount}) |`)
+      }
+      lines.push('')
+    }
+
+    lines.push('## 📈 30-Day Trend')
+    lines.push('')
+    lines.push(`- Tokens saved: ${this._formatTokens(summary.last30DaysTokens)}`)
+    if (summary.trend !== 0) {
+      const trendSign = summary.trend > 0 ? '+' : ''
+      lines.push(`- Trend: ${trendSign}${summary.trend.toFixed(0)}% vs previous period`)
+    }
+    lines.push('')
+
+    lines.push('---')
+    lines.push('')
+    lines.push('_Generated with [prjct-cli](https://prjct.app)_')
+
+    return lines.join('\n')
+  }
 }

package/core/commands/analytics.ts

@@ -3,21 +3,20 @@
  * Unified dashboard and contextual help - MD-First Architecture
  */
 
-import path from 'path'
-
-import { commandRegistry } from './registry'
+import path from 'node:path'
+import { ideasStorage, queueStorage, shippedStorage, stateStorage } from '../storage'
 import type { CommandResult, ProjectContext } from '../types'
 import {
-  PrjctCommandsBase,
-  contextBuilder,
-  toolRegistry,
-  pathManager,
   configManager,
-  jsonlHelper,
+  contextBuilder,
   dateHelper,
-  out
+  jsonlHelper,
+  out,
+  PrjctCommandsBase,
+  pathManager,
+  toolRegistry,
 } from './base'
-import { stateStorage, queueStorage, shippedStorage, ideasStorage } from '../storage'
+import { commandRegistry } from './registry'
 
 interface MemoryEntry {
   timestamp: string
@@ -30,7 +29,10 @@ export class AnalyticsCommands extends PrjctCommandsBase {
    * /p:dash - Unified dashboard
    * Views: default, week, month, roadmap, compact
    */
-  async dash(view: string = 'default', projectPath: string = process.cwd()): Promise<CommandResult> {
+  async dash(
+    view: string = 'default',
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
@@ -72,9 +74,11 @@ export class AnalyticsCommands extends PrjctCommandsBase {
         const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
         let entries: MemoryEntry[] = []
         try {
-          const allEntries = await jsonlHelper.readJsonLines(memoryPath) as MemoryEntry[]
+          const allEntries = (await jsonlHelper.readJsonLines(memoryPath)) as MemoryEntry[]
           entries = allEntries.filter((e) => new Date(e.timestamp) >= startDate)
-        } catch { entries = [] }
+        } catch {
+          entries = []
+        }
 
         const metrics = {
           tasksCompleted: entries.filter((e) => e.action === 'task_completed').length,
@@ -98,8 +102,10 @@ export class AnalyticsCommands extends PrjctCommandsBase {
 
       if (view === 'roadmap') {
         // Roadmap view
-        const context = await contextBuilder.build(projectPath) as ProjectContext
-        const roadmapContent = (await toolRegistry.get('Read')!(context.paths.roadmap)) as string | null
+        const context = (await contextBuilder.build(projectPath)) as ProjectContext
+        const roadmapContent = (await toolRegistry.get('Read')!(context.paths.roadmap)) as
+          | string
+          | null
 
         console.log(`\n🗺️  ROADMAP - ${projectName}\n`)
         console.log('═'.repeat(50))
@@ -109,7 +115,9 @@ export class AnalyticsCommands extends PrjctCommandsBase {
           console.log('  Use /p:feature to add features.\n')
         } else {
           // Parse and display roadmap
-          const features = roadmapContent.split('##').filter(s => s.trim() && !s.includes('ROADMAP'))
+          const features = roadmapContent
+            .split('##')
+            .filter((s) => s.trim() && !s.includes('ROADMAP'))
           features.slice(0, 5).forEach((f, i) => {
             const name = f.split('\n')[0].trim()
             console.log(`  ${i + 1}. ${name}`)
@@ -118,7 +126,7 @@ export class AnalyticsCommands extends PrjctCommandsBase {
             console.log(`  ... and ${features.length - 5} more`)
           }
         }
-        console.log('═'.repeat(50) + '\n')
+        console.log(`${'═'.repeat(50)}\n`)
 
         return { success: true, view: 'roadmap' }
       }
@@ -168,7 +176,7 @@ export class AnalyticsCommands extends PrjctCommandsBase {
       console.log('\n💡 IDEAS')
       console.log(`   ${ideas.length} pending ideas`)
 
-      console.log('\n' + '═'.repeat(50))
+      console.log(`\n${'═'.repeat(50)}`)
       console.log('💡 /p:work to start | /p:done to complete | /p:ship to ship\n')
 
       await this.logToMemory(projectPath, 'dash_viewed', {
@@ -183,8 +191,8 @@ export class AnalyticsCommands extends PrjctCommandsBase {
           currentTask: currentTask?.description || null,
           queueCount: queueTasks.length,
           shippedCount: shipped.length,
-          ideasCount: ideas.length
-        }
+          ideasCount: ideas.length,
+        },
       }
     } catch (error) {
       out.fail((error as Error).message)
@@ -195,7 +203,7 @@ export class AnalyticsCommands extends PrjctCommandsBase {
   /**
    * /p:help - Contextual help and guidance
    */
-  async help(topic: string = '', projectPath: string = process.cwd()): Promise<CommandResult> {
+  async help(topic: string = '', _projectPath: string = process.cwd()): Promise<CommandResult> {
     try {
       if (!topic) {
         // Show command overview
@@ -207,7 +215,7 @@ export class AnalyticsCommands extends PrjctCommandsBase {
 
         // Group by category
         const byCategory: Record<string, typeof commands> = {}
-        commands.forEach(cmd => {
+        commands.forEach((cmd) => {
           if (cmd.deprecated) return
           if (!byCategory[cmd.group]) byCategory[cmd.group] = []
           byCategory[cmd.group].push(cmd)
@@ -216,14 +224,14 @@ export class AnalyticsCommands extends PrjctCommandsBase {
         Object.entries(byCategory).forEach(([cat, cmds]) => {
           const catInfo = categories.get(cat)
           console.log(`\n${catInfo?.title || cat}:`)
-          cmds.forEach(cmd => {
+          cmds.forEach((cmd) => {
             const params = cmd.params ? ` ${cmd.params}` : ''
             console.log(`  ${cmd.name}${params}`)
             console.log(`    ${cmd.description}`)
           })
         })
 
-        console.log('\n' + '═'.repeat(50))
+        console.log(`\n${'═'.repeat(50)}`)
         console.log('💡 Use /p:help <command> for detailed help\n')
 
         return { success: true, topic: 'overview' }
@@ -248,31 +256,31 @@ export class AnalyticsCommands extends PrjctCommandsBase {
 
         if (command.features) {
           console.log('\nFeatures:')
-          command.features.forEach(f => console.log(`  • ${f}`))
+          command.features.forEach((f) => console.log(`  • ${f}`))
         }
 
-        console.log('\n' + '═'.repeat(50) + '\n')
+        console.log(`\n${'═'.repeat(50)}\n`)
         return { success: true, topic, command }
       }
 
       // Intent translation (like old /p:ask)
       const intents: Record<string, { command: string; hint: string }> = {
-        'start': { command: 'work', hint: 'Start working on a task' },
-        'begin': { command: 'work', hint: 'Start working on a task' },
-        'finish': { command: 'done', hint: 'Mark current task complete' },
-        'complete': { command: 'done', hint: 'Mark current task complete' },
-        'deploy': { command: 'ship', hint: 'Ship a feature' },
-        'release': { command: 'ship', hint: 'Ship a feature' },
-        'status': { command: 'dash', hint: 'View project dashboard' },
-        'overview': { command: 'dash', hint: 'View project dashboard' },
-        'queue': { command: 'next', hint: 'View task queue' },
-        'tasks': { command: 'next', hint: 'View task queue' },
-        'add': { command: 'feature', hint: 'Add a new feature' },
-        'new': { command: 'feature', hint: 'Add a new feature' },
-        'break': { command: 'pause', hint: 'Pause current task' },
-        'stop': { command: 'pause', hint: 'Pause current task' },
-        'continue': { command: 'resume', hint: 'Resume paused task' },
-        'back': { command: 'resume', hint: 'Resume paused task' },
+        start: { command: 'work', hint: 'Start working on a task' },
+        begin: { command: 'work', hint: 'Start working on a task' },
+        finish: { command: 'done', hint: 'Mark current task complete' },
+        complete: { command: 'done', hint: 'Mark current task complete' },
+        deploy: { command: 'ship', hint: 'Ship a feature' },
+        release: { command: 'ship', hint: 'Ship a feature' },
+        status: { command: 'dash', hint: 'View project dashboard' },
+        overview: { command: 'dash', hint: 'View project dashboard' },
+        queue: { command: 'next', hint: 'View task queue' },
+        tasks: { command: 'next', hint: 'View task queue' },
+        add: { command: 'feature', hint: 'Add a new feature' },
+        new: { command: 'feature', hint: 'Add a new feature' },
+        break: { command: 'pause', hint: 'Pause current task' },
+        stop: { command: 'pause', hint: 'Pause current task' },
+        continue: { command: 'resume', hint: 'Resume paused task' },
+        back: { command: 'resume', hint: 'Resume paused task' },
       }
 
       const lowerTopic = topic.toLowerCase()
@@ -308,7 +316,7 @@ export class AnalyticsCommands extends PrjctCommandsBase {
       const dayStart = new Date(date.setHours(0, 0, 0, 0))
       const dayEnd = new Date(date.setHours(23, 59, 59, 999))
 
-      const count = entries.filter(e => {
+      const count = entries.filter((e) => {
         const ts = new Date(e.timestamp)
         return ts >= dayStart && ts <= dayEnd
       }).length
@@ -317,6 +325,6 @@ export class AnalyticsCommands extends PrjctCommandsBase {
     }
 
     const max = Math.max(...counts, 1)
-    return counts.map(c => bars[Math.floor((c / max) * (bars.length - 1))]).join('')
+    return counts.map((c) => bars[Math.floor((c / max) * (bars.length - 1))]).join('')
   }
 }

package/core/commands/base.ts

@@ -8,24 +8,22 @@
 import commandExecutor from '../agentic/command-executor'
 import contextBuilder from '../agentic/context-builder'
 import toolRegistry from '../agentic/tool-registry'
-import pathManager from '../infrastructure/path-manager'
 import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
 import UpdateChecker from '../infrastructure/update-checker'
-import dateHelper from '../utils/date-helper'
-import jsonlHelper from '../utils/jsonl-helper'
-import * as fileHelper from '../utils/file-helper'
-import out from '../utils/output'
-
 // Services
-import { agentService, projectService, memoryService, breakdownService } from '../services'
-
+import { agentService, breakdownService, memoryService, projectService } from '../services'
 import type {
-  CommandResult,
+  AgentAssignmentResult,
   AgentInfo,
   Author,
-  AgentAssignmentResult,
-  ProjectContext
+  CommandResult,
+  ProjectContext,
 } from '../types'
+import dateHelper from '../utils/date-helper'
+import * as fileHelper from '../utils/file-helper'
+import jsonlHelper from '../utils/jsonl-helper'
+import out from '../utils/output'
 
 /**
  * Base class with shared state and utilities
@@ -73,7 +71,11 @@ export class PrjctCommandsBase {
     return projectService.getGlobalPath(projectPath)
   }
 
-  async logToMemory(projectPath: string, action: string, data: Record<string, unknown>): Promise<void> {
+  async logToMemory(
+    projectPath: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
     const author = await this.ensureAuthor()
     return memoryService.log(projectPath, action, data, author.name)
   }
@@ -112,5 +114,5 @@ export {
   fileHelper,
   jsonlHelper,
   dateHelper,
-  out
+  out,
 }

package/core/commands/cleanup.ts

@@ -4,19 +4,12 @@
  * Memory and project file cleanup operations.
  */
 
-import path from 'path'
-
-import { isNotFoundError } from '../types/fs'
-import type { CommandResult, CleanupOptions } from '../types'
-import {
-  pathManager,
-  configManager,
-  jsonlHelper,
-  dateHelper,
-  out
-} from './base'
-import { ideasStorage, queueStorage } from '../storage'
+import path from 'node:path'
 import { memoryService } from '../services'
+import { ideasStorage, queueStorage } from '../storage'
+import type { CleanupOptions, CommandResult } from '../types'
+import { isNotFoundError } from '../types/fs'
+import { configManager, dateHelper, jsonlHelper, out, pathManager } from './base'
 
 /**
  * Memory cleanup helper
@@ -131,7 +124,7 @@ export async function cleanup(
     // Check queue for completed tasks using queueStorage
     try {
       const tasks = await queueStorage.getActiveTasks(projectId)
-      const completedTasks = tasks.filter(t => t.completed).length
+      const completedTasks = tasks.filter((t) => t.completed).length
 
       if (completedTasks > 0) {
         cleaned.push(