prjct-cli 0.20.0 → 0.21.0

package/core/commands/base.ts

@@ -1,281 +1,105 @@
 /**
  * Base class and helpers for PrjctCommands
+ *
+ * Delegates to service modules for business logic.
+ * This class maintains backward compatibility while services handle implementation.
  */
 
 import commandExecutor from '../agentic/command-executor'
 import contextBuilder from '../agentic/context-builder'
 import toolRegistry from '../agentic/tool-registry'
-import AgentRouter from '../agentic/agent-router'
 import pathManager from '../infrastructure/path-manager'
 import configManager from '../infrastructure/config-manager'
-import authorDetector from '../infrastructure/author-detector'
-import agentDetector from '../infrastructure/agent-detector'
 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 type {
   CommandResult,
   AgentInfo,
   Author,
   AgentAssignmentResult,
-  Context
-} from './types'
-import { ProjectError, AgentError } from '../errors'
-
-// Valid agent types - whitelist for security (prevents path traversal)
-const VALID_AGENT_TYPES = ['claude'] as const
-type ValidAgentType = typeof VALID_AGENT_TYPES[number]
-
-// Lazy-loaded to avoid circular dependencies
-let _planningCommands: import('./planning').PlanningCommands | null = null
-async function getPlanningCommands(): Promise<import('./planning').PlanningCommands> {
-  if (!_planningCommands) {
-    const { PlanningCommands } = await import('./planning')
-    _planningCommands = new PlanningCommands()
-  }
-  return _planningCommands
-}
+  ProjectContext
+} from '../types'
 
 /**
  * Base class with shared state and utilities
+ * Delegates to service modules for implementation
  */
 export class PrjctCommandsBase {
-  agent: unknown
-  agentInfo: AgentInfo | null
-  currentAuthor: Author | null
   prjctDir: string
   updateChecker: UpdateChecker
   updateNotificationShown: boolean
   commandExecutor: typeof commandExecutor
-  agentRouter: AgentRouter
 
   constructor() {
-    this.agent = null
-    this.agentInfo = null
-    this.currentAuthor = null
     this.prjctDir = '.prjct'
     this.updateChecker = new UpdateChecker()
     this.updateNotificationShown = false
     this.commandExecutor = commandExecutor
-    this.agentRouter = new AgentRouter()
   }
 
-  /**
-   * Initialize agent (Claude Code, Desktop, or Terminal)
-   */
-  async initializeAgent(): Promise<unknown> {
-    if (this.agent) return this.agent
-
-    this.agentInfo = await agentDetector.detect()
-
-    if (!this.agentInfo.isSupported) {
-      throw AgentError.notSupported(this.agentInfo.type)
-    }
+  // Agent accessors (delegate to agentService)
+  get agent(): unknown {
+    return agentService.getAgent()
+  }
 
-    // Security: validate agent type against whitelist to prevent path traversal
-    const agentType = this.agentInfo.type as ValidAgentType
-    if (!VALID_AGENT_TYPES.includes(agentType)) {
-      throw AgentError.notSupported(this.agentInfo.type)
-    }
+  get agentInfo(): AgentInfo | null {
+    return agentService.getInfo()
+  }
 
-    const { default: Agent } = await import(`../infrastructure/agents/${agentType}-agent`)
-    this.agent = new Agent()
+  get currentAuthor(): Author | null {
+    return projectService.getCurrentAuthor()
+  }
 
-    return this.agent
+  async initializeAgent(): Promise<unknown> {
+    return agentService.initialize()
   }
 
-  /**
-   * Ensure project is initialized
-   */
   async ensureProjectInit(projectPath: string): Promise<CommandResult> {
-    if (await configManager.isConfigured(projectPath)) {
-      return { success: true }
-    }
-
-    out.spin('initializing project...')
-    const planning = await getPlanningCommands()
-    const initResult = await planning.init(null, projectPath)
-    if (!initResult.success) {
-      return initResult
-    }
-    return { success: true }
+    return projectService.ensureInit(projectPath)
   }
 
-  /**
-   * Ensure author information is loaded
-   */
   async ensureAuthor(): Promise<Author> {
-    if (this.currentAuthor) return this.currentAuthor
-    // detectAuthorForLogs returns a string (username), detect() returns full Author
-    const authorObj = await authorDetector.detect()
-    this.currentAuthor = {
-      name: authorObj.name,
-      email: authorObj.email,
-      github: authorObj.github
-    }
-    return this.currentAuthor
+    return projectService.ensureAuthor()
   }
 
-  /**
-   * Get global project path
-   */
   async getGlobalProjectPath(projectPath: string): Promise<string> {
-    const projectId = await configManager.getProjectId(projectPath)
-    if (!projectId) {
-      throw ProjectError.notInitialized()
-    }
-    await pathManager.ensureProjectStructure(projectId)
-    return pathManager.getGlobalProjectPath(projectId)
+    return projectService.getGlobalPath(projectPath)
   }
 
-  /**
-   * Log to memory
-   */
   async logToMemory(projectPath: string, action: string, data: Record<string, unknown>): Promise<void> {
-    try {
-      const author = await this.ensureAuthor()
-      const projectId = await configManager.getProjectId(projectPath)
-      const memoryPath = pathManager.getFilePath(projectId!, 'memory', 'context.jsonl')
-
-      const entry = {
-        timestamp: dateHelper.getTimestamp(),
-        action,
-        data,
-        author: author.name,
-      }
-
-      await jsonlHelper.appendJsonLine(memoryPath, entry)
-    } catch {
-      // Non-critical - don't fail the command
-    }
+    const author = await this.ensureAuthor()
+    return memoryService.log(projectPath, action, data, author.name)
   }
 
-  /**
-   * Detect if directory is empty (excluding common files)
-   */
   async _detectEmptyDirectory(projectPath: string): Promise<boolean> {
-    try {
-      const entries = await fileHelper.listFiles(projectPath)
-      const meaningfulFiles = entries.filter(
-        (name) =>
-          !name.startsWith('.') &&
-          name !== 'node_modules' &&
-          name !== 'package.json' &&
-          name !== 'package-lock.json' &&
-          name !== 'README.md'
-      )
-      return meaningfulFiles.length === 0
-    } catch {
-      return true
-    }
+    return projectService.isEmptyDirectory(projectPath)
   }
 
-  /**
-   * Detect if directory has existing code
-   */
   async _detectExistingCode(projectPath: string): Promise<boolean> {
-    try {
-      const codePatterns = [
-        'src', 'lib', 'app', 'components', 'pages', 'api',
-        'main.go', 'main.rs', 'main.py',
-      ]
-      const entries = await fileHelper.listFiles(projectPath)
-      return entries.some((name) => codePatterns.includes(name))
-    } catch {
-      return false
-    }
+    return projectService.hasExistingCode(projectPath)
   }
 
-  /**
-   * Breakdown feature into tasks
-   */
   _breakdownFeatureTasks(description: string): string[] {
-    return [
-      `Analyze and plan: ${description}`,
-      'Implement core functionality',
-      'Test and validate',
-      'Document changes',
-    ]
+    return breakdownService.breakdownFeature(description)
   }
 
-  /**
-   * Detect bug severity from description
-   */
-  _detectBugSeverity(_description: string): string {
-    return 'medium'
+  _detectBugSeverity(description: string): string {
+    return breakdownService.detectBugSeverity(description)
   }
 
-  /**
-   * Assign agent for a task using AgentRouter
-   * Returns agent info for Claude to delegate work
-   */
   async _assignAgentForTask(
     task: string,
     projectPath: string,
-    _context: Context
+    context: ProjectContext
   ): Promise<AgentAssignmentResult> {
-    try {
-      await this.agentRouter.initialize(projectPath)
-      const agents = await this.agentRouter.getAgentNames()
-
-      if (agents.length === 0) {
-        return {
-          agent: { name: 'generalist' },
-          routing: {
-            confidence: 1.0,
-            reason: 'No specialized agents available',
-            availableAgents: [],
-          },
-        }
-      }
-
-      // Simple keyword matching for agent assignment
-      // Claude will make the final decision via templates
-      const taskLower = task.toLowerCase()
-      let bestMatch = 'generalist'
-
-      for (const agentName of agents) {
-        const nameLower = agentName.toLowerCase()
-        if (taskLower.includes(nameLower) || nameLower.includes('general')) {
-          bestMatch = agentName
-          break
-        }
-        // Common domain keywords
-        if ((nameLower.includes('fe') || nameLower.includes('frontend')) &&
-            (taskLower.includes('ui') || taskLower.includes('component') || taskLower.includes('react'))) {
-          bestMatch = agentName
-          break
-        }
-        if ((nameLower.includes('be') || nameLower.includes('backend')) &&
-            (taskLower.includes('api') || taskLower.includes('server') || taskLower.includes('database'))) {
-          bestMatch = agentName
-          break
-        }
-      }
-
-      await this.agentRouter.logUsage(task, bestMatch, projectPath)
-
-      return {
-        agent: { name: bestMatch },
-        routing: {
-          confidence: 0.7,
-          reason: 'Keyword-based agent matching',
-          availableAgents: agents,
-        },
-        _agenticNote: 'Claude should verify this assignment using agent context',
-      }
-    } catch {
-      return {
-        agent: { name: 'generalist' },
-        routing: {
-          confidence: 1.0,
-          reason: 'Agent routing unavailable',
-        },
-      }
-    }
+    return agentService.assignForTask(task, projectPath, context)
   }
 }
 

package/core/commands/cleanup.ts

@@ -0,0 +1,148 @@
+/**
+ * Cleanup Commands
+ *
+ * Memory and project file cleanup operations.
+ */
+
+import path from 'path'
+
+import type { CommandResult, CleanupOptions } from '../types'
+import {
+  pathManager,
+  configManager,
+  jsonlHelper,
+  dateHelper,
+  out
+} from './base'
+import { ideasStorage, queueStorage } from '../storage'
+import { memoryService } from '../services'
+
+/**
+ * Memory cleanup helper
+ */
+export async function cleanupMemory(projectPath: string): Promise<{
+  success: boolean
+  results: { rotated: string[]; totalSize: number; freedSpace: number }
+}> {
+  const projectId = await configManager.getProjectId(projectPath)
+
+  const results = { rotated: [] as string[], totalSize: 0, freedSpace: 0 }
+  const jsonlFiles = [
+    pathManager.getFilePath(projectId!, 'memory', 'context.jsonl'),
+    pathManager.getFilePath(projectId!, 'progress', 'shipped.md'),
+    pathManager.getFilePath(projectId!, 'planning', 'ideas.md'),
+  ]
+
+  for (const filePath of jsonlFiles) {
+    try {
+      const sizeMB = await jsonlHelper.getFileSizeMB(filePath)
+      if (sizeMB > 0) {
+        results.totalSize += sizeMB
+        const rotated = await jsonlHelper.rotateJsonLinesIfNeeded(filePath, 10)
+        if (rotated) {
+          results.rotated.push(path.basename(filePath))
+          results.freedSpace += sizeMB
+        }
+      }
+    } catch {
+      // skip
+    }
+  }
+
+  return { success: true, results }
+}
+
+/**
+ * Internal cleanup helper for memory during normal cleanup
+ */
+export async function cleanupMemoryInternal(projectPath: string): Promise<void> {
+  const projectId = await configManager.getProjectId(projectPath)
+  const memoryPath = pathManager.getFilePath(projectId!, 'memory', 'context.jsonl')
+  await jsonlHelper.rotateJsonLinesIfNeeded(memoryPath, 10)
+}
+
+/**
+ * /p:cleanup - Clean temp files and old entries
+ */
+export async function cleanup(
+  options: CleanupOptions = {},
+  projectPath: string = process.cwd()
+): Promise<CommandResult> {
+  try {
+    const isMemoryMode = options.memory === true || options.type === 'memory'
+
+    if (isMemoryMode) {
+      out.spin('cleaning memory...')
+      const result = await cleanupMemory(projectPath)
+      out.done('memory cleaned')
+      return result
+    }
+
+    out.spin('cleaning up...')
+
+    const projectId = await configManager.getProjectId(projectPath)
+    if (!projectId) {
+      out.fail('no project ID')
+      return { success: false, error: 'No project ID found' }
+    }
+
+    const cleaned: string[] = []
+
+    // Clean memory (keep last 100 entries)
+    const memoryPath = pathManager.getFilePath(projectId, 'memory', 'context.jsonl')
+    try {
+      const entries = await jsonlHelper.readJsonLines(memoryPath)
+
+      if (entries.length > 100) {
+        const kept = entries.slice(-100)
+        await jsonlHelper.writeJsonLines(memoryPath, kept)
+        cleaned.push(`Memory: ${entries.length - 100} old entries removed`)
+      } else {
+        cleaned.push('Memory: No cleanup needed')
+      }
+    } catch {
+      cleaned.push('Memory: No file found')
+    }
+
+    // Clean ideas using ideasStorage
+    try {
+      const result = await ideasStorage.cleanup(projectId)
+      if (result.removed > 0) {
+        cleaned.push(`Ideas: ${result.removed} old archived ideas removed`)
+      } else {
+        cleaned.push('Ideas: No cleanup needed')
+      }
+    } catch {
+      cleaned.push('Ideas: No file found')
+    }
+
+    // Check queue for completed tasks using queueStorage
+    try {
+      const tasks = await queueStorage.getActiveTasks(projectId)
+      const completedTasks = tasks.filter(t => t.completed).length
+
+      if (completedTasks > 0) {
+        cleaned.push(
+          `Queue: ${completedTasks} completed tasks found (not removed - use /p:done to clear)`
+        )
+      } else {
+        cleaned.push('Queue: No completed tasks')
+      }
+    } catch {
+      cleaned.push('Queue: No file found')
+    }
+
+    await cleanupMemoryInternal(projectPath)
+
+    await memoryService.log(projectPath, 'cleanup_performed', {
+      items: cleaned.length,
+      timestamp: dateHelper.getTimestamp(),
+    })
+
+    out.done(`${cleaned.length} items cleaned`)
+    return { success: true, cleaned }
+  } catch (error) {
+    out.fail((error as Error).message)
+    return { success: false, error: (error as Error).message }
+  }
+}