prjct-cli 1.22.0 → 1.23.0

package/core/commands/commands.ts

@@ -1,306 +0,0 @@
-/**
- * prjct CLI Commands Handler
- *
- * MD-First Architecture - All state in Markdown files.
- *
- * COMMANDS:
- * - Workflow: done, next, pause, resume
- * - Planning: init, bug, idea, spec
- * - Shipping: ship
- * - Analytics: dash, help
- * - Maintenance: cleanup, design, recover, undo, redo, history
- * - Analysis: analyze, sync
- * - Setup: start, setup
- * - Context: context
- */
-
-import type {
-  AgentInfo,
-  AnalyzeOptions,
-  Author,
-  CleanupOptions,
-  CommandResult,
-  DesignOptions,
-  SetupOptions,
-} from '../types'
-import { AnalysisCommands } from './analysis'
-import { AnalyticsCommands } from './analytics'
-import { ContextCommands } from './context'
-import { MaintenanceCommands } from './maintenance'
-import { PerformanceCommands } from './performance'
-import { PlanningCommands } from './planning'
-import { SetupCommands } from './setup'
-import { ShippingCommands } from './shipping'
-import { VelocityCommands } from './velocity'
-import { WorkflowCommands } from './workflow'
-
-/**
- * PrjctCommands - Combined class with all commands
- * Uses mixins pattern to combine all command groups
- */
-class PrjctCommands {
-  // Instances of each command group
-  private workflow: WorkflowCommands
-  private planning: PlanningCommands
-  private shipping: ShippingCommands
-  private analytics: AnalyticsCommands
-  private performanceCmds: PerformanceCommands
-  private maintenance: MaintenanceCommands
-  private analysis: AnalysisCommands
-  private setupCmds: SetupCommands
-  private velocityCmds: VelocityCommands
-  private contextCmds: ContextCommands
-
-  // Shared state
-  agent: unknown
-  agentInfo: AgentInfo | null
-  currentAuthor: Author | null
-  prjctDir: string
-
-  constructor() {
-    this.workflow = new WorkflowCommands()
-    this.planning = new PlanningCommands()
-    this.shipping = new ShippingCommands()
-    this.analytics = new AnalyticsCommands()
-    this.performanceCmds = new PerformanceCommands()
-    this.maintenance = new MaintenanceCommands()
-    this.analysis = new AnalysisCommands()
-    this.setupCmds = new SetupCommands()
-    this.velocityCmds = new VelocityCommands()
-    this.contextCmds = new ContextCommands()
-
-    this.agent = null
-    this.agentInfo = null
-    this.currentAuthor = null
-    this.prjctDir = '.prjct'
-  }
-
-  // ========== Workflow Commands ==========
-
-  async done(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.workflow.done(projectPath)
-  }
-
-  async next(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.workflow.next(projectPath)
-  }
-
-  async pause(reason: string = '', projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.workflow.pause(reason, projectPath)
-  }
-
-  async resume(
-    taskId: string | null = null,
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.workflow.resume(taskId, projectPath)
-  }
-
-  async workflowPrefs(
-    input: string | null = null,
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.workflow.workflow(input, projectPath)
-  }
-
-  // ========== Planning Commands ==========
-
-  async init(
-    idea: string | null = null,
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.planning.init(idea, projectPath)
-  }
-
-  async bug(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.planning.bug(description, projectPath)
-  }
-
-  async idea(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.planning.idea(description, projectPath)
-  }
-
-  async spec(
-    featureName: string | null = null,
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.planning.spec(featureName, projectPath)
-  }
-
-  // ========== Shipping Commands ==========
-
-  async ship(feature: string | null, projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.shipping.ship(feature, projectPath)
-  }
-
-  // ========== Analytics Commands ==========
-
-  async dash(
-    view: string = 'default',
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.analytics.dash(view, projectPath)
-  }
-
-  async help(topic: string = '', projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.analytics.help(topic, projectPath)
-  }
-
-  // ========== Performance Commands ==========
-
-  async perf(period: string = '7', projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.performanceCmds.perf(period, projectPath)
-  }
-
-  // ========== Velocity Commands ==========
-
-  async velocity(
-    backlogPoints: string = '0',
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.velocityCmds.velocity(backlogPoints, projectPath)
-  }
-
-  // ========== Maintenance Commands ==========
-
-  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> {
-    return this.maintenance.design(target, options, projectPath)
-  }
-
-  async recover(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.maintenance.recover(projectPath)
-  }
-
-  async undo(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.maintenance.undo(projectPath)
-  }
-
-  async redo(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.maintenance.redo(projectPath)
-  }
-
-  async history(projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.maintenance.history(projectPath)
-  }
-
-  // ========== Analysis Commands ==========
-
-  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[]
-      preview?: boolean
-      yes?: boolean
-      json?: boolean
-      package?: string
-      full?: boolean
-    } = {}
-  ): Promise<CommandResult> {
-    return this.analysis.sync(projectPath, options)
-  }
-
-  async stats(
-    projectPath: string = process.cwd(),
-    options: { json?: boolean; export?: boolean } = {}
-  ): Promise<CommandResult> {
-    return this.analysis.stats(projectPath, options)
-  }
-
-  async status(
-    projectPath: string = process.cwd(),
-    options: { json?: boolean } = {}
-  ): Promise<CommandResult> {
-    return this.analysis.status(projectPath, options)
-  }
-
-  async seal(
-    projectPath: string = process.cwd(),
-    options: { json?: boolean } = {}
-  ): Promise<CommandResult> {
-    return this.analysis.seal(projectPath, options)
-  }
-
-  async verify(
-    projectPath: string = process.cwd(),
-    options: { json?: boolean; semantic?: boolean } = {}
-  ): Promise<CommandResult> {
-    return this.analysis.verify(projectPath, options)
-  }
-
-  // ========== Context Commands ==========
-
-  async context(
-    input: string | null = null,
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    return this.contextCmds.context(input, projectPath)
-  }
-
-  // ========== Setup Commands ==========
-
-  async start(): Promise<CommandResult> {
-    return this.setupCmds.start()
-  }
-
-  async setup(options: SetupOptions = {}): Promise<CommandResult> {
-    return this.setupCmds.setup(options)
-  }
-
-  async installStatusLine(): Promise<{ success: boolean; error?: string }> {
-    return this.setupCmds.installStatusLine()
-  }
-
-  showAsciiArt(): void {
-    this.setupCmds.showAsciiArt()
-  }
-
-  // ========== Delegated Base Methods ==========
-
-  async initializeAgent(): Promise<unknown> {
-    return this.workflow.initializeAgent()
-  }
-
-  async ensureProjectInit(projectPath: string): Promise<CommandResult> {
-    return this.workflow.ensureProjectInit(projectPath)
-  }
-
-  async ensureAuthor(): Promise<Author> {
-    return this.workflow.ensureAuthor()
-  }
-
-  async getGlobalProjectPath(projectPath: string): Promise<string> {
-    return this.workflow.getGlobalProjectPath(projectPath)
-  }
-
-  async logToMemory(
-    projectPath: string,
-    action: string,
-    data: Record<string, unknown>
-  ): Promise<void> {
-    return this.workflow.logToMemory(projectPath, action, data)
-  }
-}
-
-// Export both class and singleton instance
-const instance = new PrjctCommands()
-
-export default instance
-export { PrjctCommands }

package/core/commands/context.ts

@@ -1,238 +0,0 @@
-/**
- * Context Commands - Exposes orchestrator context to Claude
- *
- * The `context` command runs the orchestrator and returns JSON with everything
- * Claude needs to execute workflows:
- * - projectId and globalPath for file operations
- * - detected domains from task description
- * - loaded agents with file paths and previews
- * - current task state (if any)
- * - repo analysis data
- *
- * This bridges the gap between TypeScript orchestration and Claude Code templates.
- *
- * @module commands/context
- * @version 1.0.0
- */
-
-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 type { CommandResult } from '../types'
-import { getErrorMessage, isNotFoundError } from '../types/fs'
-
-// =============================================================================
-// Types
-// =============================================================================
-
-export interface ContextOutput {
-  projectId: string
-  globalPath: string
-  currentTask: {
-    id: string
-    description: string
-    startedAt: string
-    subtasks?: Array<{
-      id: string
-      description: string
-      status: string
-      domain: string
-    }>
-    currentSubtaskIndex?: number
-  } | null
-  domains: string[]
-  primaryDomain: string | null
-  agents: Array<{
-    name: string
-    domain: string
-    filePath: string
-    skills: string[]
-    preview: string
-  }>
-  subtasks: Array<{
-    id: string
-    description: string
-    domain: string
-    agent: string
-    status: string
-    order: number
-  }> | null
-  repoAnalysis: {
-    ecosystem: string
-    frameworks: string[]
-    hasTests: boolean
-    technologies: string[]
-  }
-}
-
-// =============================================================================
-// Context Commands Class
-// =============================================================================
-
-export class ContextCommands {
-  /**
-   * Get full project context for Claude
-   *
-   * Usage:
-   *   prjct context task "add user auth"
-   *   prjct context done
-   *   prjct context ship
-   *
-   * Returns JSON with all orchestrator data.
-   */
-  async context(
-    input: string | null = null,
-    projectPath: string = process.cwd()
-  ): Promise<CommandResult> {
-    try {
-      // Parse input: first word is command, rest is arguments
-      const parts = (input || '').trim().split(/\s+/)
-      const command = parts[0] || 'task'
-      const taskDescription = parts.slice(1).join(' ')
-
-      // Get project info
-      const config = await configManager.readConfig(projectPath)
-      if (!config || !config.projectId) {
-        const output: Partial<ContextOutput> = {
-          projectId: '',
-          globalPath: '',
-          currentTask: null,
-          domains: [],
-          primaryDomain: null,
-          agents: [],
-          subtasks: null,
-          repoAnalysis: {
-            ecosystem: 'unknown',
-            frameworks: [],
-            hasTests: false,
-            technologies: [],
-          },
-        }
-        console.log(JSON.stringify(output, null, 2))
-        return {
-          success: false,
-          message: 'No prjct project. Run `p. init` first.',
-        }
-      }
-
-      const projectId = config.projectId
-      const globalPath = pathManager.getGlobalProjectPath(projectId)
-
-      // Get current task state
-      const state = await stateStorage.read(projectId)
-      const currentTask = state?.currentTask
-        ? {
-            id: state.currentTask.id,
-            description: state.currentTask.description,
-            startedAt: state.currentTask.startedAt,
-            subtasks: state.currentTask.subtasks?.map((st) => ({
-              id: st.id,
-              description: st.description,
-              status: st.status,
-              domain: st.domain,
-            })),
-            currentSubtaskIndex: state.currentTask.currentSubtaskIndex,
-          }
-        : null
-
-      // Run orchestrator if we have a task description
-      let orchestratorContext = null
-      if (taskDescription) {
-        try {
-          orchestratorContext = await orchestratorExecutor.execute(
-            command,
-            taskDescription,
-            projectPath
-          )
-        } catch (error) {
-          // Orchestration failed - continue without it
-          console.error(`Warning: Orchestrator failed: ${getErrorMessage(error)}`)
-        }
-      }
-
-      // Load repo analysis
-      const repoAnalysis = await this.loadRepoAnalysis(globalPath)
-
-      // Build output
-      const output: ContextOutput = {
-        projectId,
-        globalPath,
-        currentTask,
-        domains: orchestratorContext?.detectedDomains || [],
-        primaryDomain: orchestratorContext?.primaryDomain || null,
-        agents:
-          orchestratorContext?.agents.map((a) => ({
-            name: a.name,
-            domain: a.domain,
-            filePath: a.filePath,
-            skills: a.skills,
-            preview: a.content.substring(0, 500),
-          })) || [],
-        subtasks:
-          orchestratorContext?.subtasks?.map((st) => ({
-            id: st.id,
-            description: st.description,
-            domain: st.domain,
-            agent: st.agent,
-            status: st.status,
-            order: st.order,
-          })) || null,
-        repoAnalysis: {
-          ecosystem: repoAnalysis?.ecosystem || 'unknown',
-          frameworks: repoAnalysis?.frameworks || [],
-          hasTests: repoAnalysis?.hasTests || false,
-          technologies: repoAnalysis?.technologies || [],
-        },
-      }
-
-      // Output JSON to stdout
-      console.log(JSON.stringify(output, null, 2))
-
-      return {
-        success: true,
-        message: '', // Empty message - JSON output is the result
-      }
-    } catch (error) {
-      return {
-        success: false,
-        message: `Context error: ${getErrorMessage(error)}`,
-      }
-    }
-  }
-
-  /**
-   * Load repo analysis from analysis/repo-analysis.json
-   */
-  private async loadRepoAnalysis(globalPath: string): Promise<{
-    ecosystem: string
-    frameworks: string[]
-    hasTests: boolean
-    technologies: string[]
-  } | null> {
-    try {
-      const analysisPath = path.join(globalPath, 'analysis', 'repo-analysis.json')
-      const content = await fs.readFile(analysisPath, 'utf-8')
-      const data = JSON.parse(content)
-      return {
-        ecosystem: data.ecosystem || 'unknown',
-        frameworks: data.frameworks || [],
-        hasTests: data.hasTests ?? false,
-        technologies: data.technologies || [],
-      }
-    } catch (error) {
-      if (isNotFoundError(error)) return null
-      return null
-    }
-  }
-}
-
-// =============================================================================
-// Exports
-// =============================================================================
-
-const contextCommands = new ContextCommands()
-export default contextCommands
-export { contextCommands }

package/core/commands/design.ts

@@ -1,77 +0,0 @@
-/**
- * Design Commands
- *
- * System architecture, API, and component design operations.
- */
-
-import path from 'node:path'
-import { memoryService } from '../services'
-import type { CommandResult, DesignOptions } from '../types'
-import { getErrorMessage } from '../types/fs'
-import { configManager, dateHelper, fileHelper, out, pathManager } from './base'
-
-/**
- * /p:design - Design system architecture, APIs, and components
- */
-export async function design(
-  target: string | null = null,
-  options: DesignOptions = {},
-  projectPath: string = process.cwd()
-): Promise<CommandResult> {
-  try {
-    const designType = options.type || 'architecture'
-    const validTypes = ['architecture', 'api', 'component', 'database', 'flow']
-
-    if (!validTypes.includes(designType)) {
-      out.fail(`invalid type: ${designType}`)
-      return { success: false, error: 'Invalid design type' }
-    }
-
-    const designTarget = target || 'system'
-    out.spin(`designing ${designType}...`)
-
-    const projectId = await configManager.getProjectId(projectPath)
-    const designsPath = path.join(
-      pathManager.getGlobalProjectPath(projectId!),
-      'planning',
-      'designs'
-    )
-    await fileHelper.ensureDir(designsPath)
-
-    let designContent = ''
-
-    switch (designType) {
-      case 'architecture':
-        designContent = `# Architecture Design: ${designTarget}\n\n*Use templates/design/architecture.md for full design*\n`
-        break
-      case 'api':
-        designContent = `# API Design: ${designTarget}\n\n*Use templates/design/api.md for full design*\n`
-        break
-      case 'component':
-        designContent = `# Component Design: ${designTarget}\n\n*Use templates/design/component.md for full design*\n`
-        break
-      case 'database':
-        designContent = `# Database Design: ${designTarget}\n\n*Use templates/design/database.md for full design*\n`
-        break
-      case 'flow':
-        designContent = `# Flow Design: ${designTarget}\n\n*Use templates/design/flow.md for full design*\n`
-        break
-    }
-
-    const designFileName = `${designType}-${designTarget.toLowerCase().replace(/\s+/g, '-')}.md`
-    const designFilePath = path.join(designsPath, designFileName)
-    await fileHelper.writeFile(designFilePath, designContent)
-
-    await memoryService.log(projectPath, 'design_created', {
-      type: designType,
-      target: designTarget,
-      timestamp: dateHelper.getTimestamp(),
-    })
-
-    out.done(`${designType} design created`)
-    return { success: true, designPath: designFilePath, type: designType, target: designTarget }
-  } catch (error) {
-    out.fail(getErrorMessage(error))
-    return { success: false, error: getErrorMessage(error) }
-  }
-}

package/core/commands/index.ts

@@ -1,19 +0,0 @@
-/**
- * prjct CLI Commands Handler
- *
- * Barrel export for commands module.
- *
- * Migration path:
- * - Legacy: import commands from './commands' → commands.work()
- * - New: import { commandRegistry } from './commands' → registry.execute('work')
- */
-
-// Types
-export * from '../types'
-// Legacy exports (backwards compat)
-export { default, PrjctCommands } from './commands'
-// Command registration (auto-runs on import)
-export { registerAllCommands } from './register'
-export type { CommandHandler, CommandMeta, ExecutionContext, HandlerFn } from './registry'
-// New registry-based exports
-export { CommandRegistry, commandRegistry } from './registry'