prjct-cli 0.45.0 → 0.45.3

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(

package/core/commands/command-data.ts

@@ -5,7 +5,7 @@
  * Used by registry for introspection and help display.
  */
 
-import type { CommandMeta, CategoryInfo } from '../types'
+import type { CategoryInfo, CommandMeta } from '../types'
 
 // Category definitions
 export const CATEGORIES: Record<string, CategoryInfo> = {
@@ -38,7 +38,11 @@ export const COMMANDS: CommandMeta[] = [
     implemented: true,
     hasTemplate: true,
     requiresProject: false,
-    features: ['Architect mode for blank projects', 'Auto tech stack recommendation', 'Analyzes existing codebases'],
+    features: [
+      'Architect mode for blank projects',
+      'Auto tech stack recommendation',
+      'Analyzes existing codebases',
+    ],
   },
   {
     name: 'idea',
@@ -60,7 +64,12 @@ export const COMMANDS: CommandMeta[] = [
     implemented: true,
     hasTemplate: true,
     requiresProject: true,
-    features: ['Agentic type classification', '7-phase workflow', 'Git branch management', 'Task breakdown'],
+    features: [
+      'Agentic type classification',
+      '7-phase workflow',
+      'Git branch management',
+      'Task breakdown',
+    ],
   },
   {
     name: 'spec',
@@ -333,5 +342,20 @@ export const COMMANDS: CommandMeta[] = [
       'summary - Intelligent file summarization',
     ],
   },
+  {
+    name: 'uninstall',
+    group: 'setup',
+    description: 'Complete system removal of prjct',
+    usage: { claude: null, terminal: 'prjct uninstall' },
+    params: '[--force] [--backup] [--dry-run]',
+    implemented: true,
+    hasTemplate: false,
+    requiresProject: false,
+    features: [
+      'Removes ~/.prjct-cli/ data',
+      'Cleans CLAUDE.md prjct section',
+      'Uninstalls Homebrew/npm packages',
+      'Backup option before deletion',
+    ],
+  },
 ]
-

package/core/commands/commands.ts

@@ -14,24 +14,23 @@
  * - Context: context
  */
 
-import { WorkflowCommands } from './workflow'
-import { PlanningCommands } from './planning'
-import { ShippingCommands } from './shipping'
-import { AnalyticsCommands } from './analytics'
-import { MaintenanceCommands } from './maintenance'
-import { AnalysisCommands } from './analysis'
-import { SetupCommands } from './setup'
-import { ContextCommands } from './context'
-
 import type {
-  CommandResult,
   AgentInfo,
+  AnalyzeOptions,
   Author,
-  DesignOptions,
   CleanupOptions,
+  CommandResult,
+  DesignOptions,
   SetupOptions,
-  AnalyzeOptions
 } from '../types'
+import { AnalysisCommands } from './analysis'
+import { AnalyticsCommands } from './analytics'
+import { ContextCommands } from './context'
+import { MaintenanceCommands } from './maintenance'
+import { PlanningCommands } from './planning'
+import { SetupCommands } from './setup'
+import { ShippingCommands } from './shipping'
+import { WorkflowCommands } from './workflow'
 
 /**
  * PrjctCommands - Combined class with all commands
@@ -84,13 +83,19 @@ class PrjctCommands {
     return this.workflow.pause(reason, projectPath)
   }
 
-  async resume(taskId: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async resume(
+    taskId: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.workflow.resume(taskId, projectPath)
   }
 
   // ========== Planning Commands ==========
 
-  async init(idea: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async init(
+    idea: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.planning.init(idea, projectPath)
   }
 
@@ -102,7 +107,10 @@ class PrjctCommands {
     return this.planning.idea(description, projectPath)
   }
 
-  async spec(featureName: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async spec(
+    featureName: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.planning.spec(featureName, projectPath)
   }
 
@@ -114,7 +122,10 @@ class PrjctCommands {
 
   // ========== Analytics Commands ==========
 
-  async dash(view: string = 'default', projectPath: string = process.cwd()): Promise<CommandResult> {
+  async dash(
+    view: string = 'default',
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.analytics.dash(view, projectPath)
   }
 
@@ -124,11 +135,18 @@ class PrjctCommands {
 
   // ========== Maintenance Commands ==========
 
-  async cleanup(options: CleanupOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async cleanup(
+    options: CleanupOptions = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.maintenance.cleanup(options, projectPath)
   }
 
-  async design(target: string | null = null, options: DesignOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async design(
+    target: string | null = null,
+    options: DesignOptions = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.maintenance.design(target, options, projectPath)
   }
 
@@ -150,21 +168,33 @@ class PrjctCommands {
 
   // ========== Analysis Commands ==========
 
-  async analyze(options: AnalyzeOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async analyze(
+    options: AnalyzeOptions = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.analysis.analyze(options, projectPath)
   }
 
-  async sync(projectPath: string = process.cwd(), options: { aiTools?: string[] } = {}): Promise<CommandResult> {
+  async sync(
+    projectPath: string = process.cwd(),
+    options: { aiTools?: string[] } = {}
+  ): Promise<CommandResult> {
     return this.analysis.sync(projectPath, options)
   }
 
-  async stats(projectPath: string = process.cwd(), options: { json?: boolean; export?: boolean } = {}): Promise<CommandResult> {
+  async stats(
+    projectPath: string = process.cwd(),
+    options: { json?: boolean; export?: boolean } = {}
+  ): Promise<CommandResult> {
     return this.analysis.stats(projectPath, options)
   }
 
   // ========== Context Commands ==========
 
-  async context(input: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async context(
+    input: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     return this.contextCmds.context(input, projectPath)
   }
 
@@ -204,7 +234,11 @@ class PrjctCommands {
     return this.workflow.getGlobalProjectPath(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> {
     return this.workflow.logToMemory(projectPath, action, data)
   }
 }
@@ -214,4 +248,3 @@ const instance = new PrjctCommands()
 
 export default instance
 export { PrjctCommands }
-

package/core/commands/context.ts

@@ -15,14 +15,14 @@
  * @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 orchestratorExecutor from '../agentic/orchestrator-executor'
 import configManager from '../infrastructure/config-manager'
 import pathManager from '../infrastructure/path-manager'
 import { stateStorage } from '../storage'
-import orchestratorExecutor from '../agentic/orchestrator-executor'
-import { isNotFoundError } from '../types/fs'
 import type { CommandResult } from '../types'
+import { isNotFoundError } from '../types/fs'
 
 // =============================================================================
 // Types

package/core/commands/design.ts

@@ -4,17 +4,10 @@
  * System architecture, API, and component design operations.
  */
 
-import path from 'path'
-
-import type { CommandResult, DesignOptions } from '../types'
-import {
-  pathManager,
-  configManager,
-  fileHelper,
-  dateHelper,
-  out
-} from './base'
+import path from 'node:path'
 import { memoryService } from '../services'
+import type { CommandResult, DesignOptions } from '../types'
+import { configManager, dateHelper, fileHelper, out, pathManager } from './base'
 
 /**
  * /p:design - Design system architecture, APIs, and components

package/core/commands/index.ts

@@ -8,15 +8,12 @@
  * - New: import { commandRegistry } from './commands' → registry.execute('work')
  */
 
+// Types
+export * from '../types'
 // Legacy exports (backwards compat)
 export { default, PrjctCommands } from './commands'
-
-// New registry-based exports
-export { commandRegistry, CommandRegistry } from './registry'
-export type { ExecutionContext, CommandHandler, HandlerFn, CommandMeta } from './registry'
-
 // Command registration (auto-runs on import)
 export { registerAllCommands } from './register'
-
-// Types
-export * from '../types'
+export type { CommandHandler, CommandMeta, ExecutionContext, HandlerFn } from './registry'
+// New registry-based exports
+export { CommandRegistry, commandRegistry } from './registry'

package/core/commands/maintenance.ts

@@ -7,13 +7,13 @@
  * - snapshots: Git-based undo/redo and session recovery
  */
 
-import type { CommandResult, CleanupOptions, DesignOptions } from '../types'
+import type { CleanupOptions, CommandResult, DesignOptions } from '../types'
 import { PrjctCommandsBase } from './base'
 
 // Import individual command functions
 import { cleanup, cleanupMemory, cleanupMemoryInternal } from './cleanup'
 import { design } from './design'
-import { recover, undo, redo, history } from './snapshots'
+import { history, recover, redo, undo } from './snapshots'
 
 /**
  * MaintenanceCommands - Facade class for maintenance operations
@@ -25,7 +25,10 @@ export class MaintenanceCommands extends PrjctCommandsBase {
   _cleanupMemory = cleanupMemory
   _cleanupMemoryInternal = cleanupMemoryInternal
 
-  async cleanup(options: CleanupOptions = {}, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async cleanup(
+    options: CleanupOptions = {},
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
     const initResult = await this.ensureProjectInit(projectPath)
     if (!initResult.success) return initResult
     return cleanup(options, projectPath)
@@ -71,4 +74,4 @@ export class MaintenanceCommands extends PrjctCommandsBase {
 // Re-export individual functions for direct use
 export { cleanup, cleanupMemory, cleanupMemoryInternal } from './cleanup'
 export { design } from './design'
-export { recover, undo, redo, history } from './snapshots'
+export { history, recover, redo, undo } from './snapshots'