prjct-cli 0.11.5 → 0.12.1

package/core/commands/shipping.ts

@@ -0,0 +1,188 @@
+/**
+ * Shipping Commands: ship and related helpers
+ */
+
+import path from 'path'
+
+import memorySystem from '../agentic/memory-system'
+import type { CommandResult, Context } from './types'
+import {
+  PrjctCommandsBase,
+  contextBuilder,
+  toolRegistry,
+  configManager,
+  fileHelper,
+  dateHelper,
+  out
+} from './base'
+
+export class ShippingCommands extends PrjctCommandsBase {
+  /**
+   * /p:ship - Ship feature with complete automated workflow
+   */
+  async ship(feature: string | null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      let featureName = feature
+      if (!featureName) {
+        const context = await contextBuilder.build(projectPath) as Context
+        const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
+        if (nowContent && nowContent.includes('**')) {
+          const match = nowContent.match(/\*\*(.+?)\*\*/)
+          featureName = match ? match[1] : 'current work'
+        } else {
+          featureName = 'current work'
+        }
+      }
+
+      out.spin(`shipping ${featureName}...`)
+
+      const lintResult = await this._runLint(projectPath)
+
+      out.spin('running tests...')
+      const testResult = await this._runTests(projectPath)
+
+      out.spin('updating version...')
+      const newVersion = await this._bumpVersion(projectPath)
+      await this._updateChangelog(featureName, newVersion, projectPath)
+
+      out.spin('committing...')
+      const commitResult = await this._createShipCommit(featureName, projectPath)
+
+      if (commitResult.success) {
+        out.spin('pushing...')
+        await this._gitPush(projectPath)
+      }
+
+      const context = await contextBuilder.build(projectPath) as Context
+      const shippedContent =
+        (await toolRegistry.get('Read')!(context.paths.shipped) as string) || '# SHIPPED 🚀\n\n'
+      const shippedEntry = `\n## ${featureName}\n\nShipped: ${new Date().toLocaleString()}\nVersion: ${newVersion}\n`
+      await toolRegistry.get('Write')!(context.paths.shipped, shippedContent + shippedEntry)
+
+      await this.logToMemory(projectPath, 'feature_shipped', {
+        feature: featureName,
+        version: newVersion,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      const config = await configManager.readConfig(projectPath)
+      const projectId = config!.projectId
+
+      await memorySystem.learnDecision(projectId, 'commit_footer', 'prjct', 'ship')
+
+      if (testResult.success) {
+        await memorySystem.recordDecision(projectId, 'test_before_ship', 'true', 'ship')
+      }
+
+      const isQuickShip = !lintResult.success || !testResult.success
+      if (isQuickShip) {
+        await memorySystem.recordWorkflow(projectId, 'quick_ship', {
+          description: 'Ship without full checks',
+          feature_type: featureName.toLowerCase().includes('doc') ? 'docs' : 'other'
+        })
+      }
+
+      out.done(`v${newVersion} shipped`)
+
+      return { success: true, feature: featureName, version: newVersion }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * Run lint checks
+   */
+  async _runLint(_projectPath: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const result = await toolRegistry.get('Bash')!('npm run lint 2>&1 || true') as { stdout: string; stderr: string }
+      return { success: !result.stderr.includes('error'), message: 'passed' }
+    } catch {
+      return { success: false, message: 'no lint script (skipped)' }
+    }
+  }
+
+  /**
+   * Run tests
+   */
+  async _runTests(_projectPath: string): Promise<{ success: boolean; message: string }> {
+    try {
+      const result = await toolRegistry.get('Bash')!(
+        'npm test -- --passWithNoTests 2>&1 || true'
+      ) as { stdout: string; stderr: string }
+      return { success: !result.stderr.includes('FAIL'), message: 'passed' }
+    } catch {
+      return { success: false, message: 'no test script (skipped)' }
+    }
+  }
+
+  /**
+   * Bump version
+   */
+  async _bumpVersion(projectPath: string): Promise<string> {
+    try {
+      const pkgPath = path.join(projectPath, 'package.json')
+      const pkg = await fileHelper.readJson<{ version?: string }>(pkgPath, { version: '0.0.0' })
+      const oldVersion = pkg?.version || '0.0.0'
+      const [major, minor, patch] = oldVersion.split('.').map(Number)
+      const newVersion = `${major}.${minor}.${patch + 1}`
+      if (pkg) {
+        pkg.version = newVersion
+        await fileHelper.writeJson(pkgPath, pkg)
+      }
+      return newVersion
+    } catch {
+      return '0.0.1'
+    }
+  }
+
+  /**
+   * Update CHANGELOG
+   */
+  async _updateChangelog(feature: string, version: string, projectPath: string): Promise<void> {
+    try {
+      const changelogPath = path.join(projectPath, 'CHANGELOG.md')
+      const changelog = await fileHelper.readFile(changelogPath, '# Changelog\n\n')
+
+      const entry = `## [${version}] - ${dateHelper.formatDate(new Date())}\n\n### Added\n- ${feature}\n\n`
+      const updated = changelog.replace('# Changelog\n\n', `# Changelog\n\n${entry}`)
+
+      await fileHelper.writeFile(changelogPath, updated)
+    } catch {
+      console.error('   Warning: Could not update CHANGELOG')
+    }
+  }
+
+  /**
+   * Create git commit for ship
+   */
+  async _createShipCommit(feature: string, _projectPath: string): Promise<{ success: boolean; message: string }> {
+    try {
+      await toolRegistry.get('Bash')!('git add .')
+
+      const commitMsg = `feat: ${feature}\n\n🤖 Generated with [p/](https://www.prjct.app/)\nDesigned for [Claude](https://www.anthropic.com/claude)`
+
+      await toolRegistry.get('Bash')!(`git commit -m "${commitMsg.replace(/"/g, '\\"')}"`)
+
+      return { success: true, message: 'Committed' }
+    } catch {
+      return { success: false, message: 'No changes to commit' }
+    }
+  }
+
+  /**
+   * Push to remote
+   */
+  async _gitPush(_projectPath: string): Promise<{ success: boolean; message: string }> {
+    try {
+      await toolRegistry.get('Bash')!('git push')
+      return { success: true, message: 'Pushed to remote' }
+    } catch {
+      return { success: false, message: 'Push failed (no remote or auth issue)' }
+    }
+  }
+}

package/core/commands/types.ts

@@ -0,0 +1,183 @@
+/**
+ * Type definitions for Commands module
+ *
+ * Re-exports common types from core/types and defines command-specific types.
+ */
+
+// Re-export commonly used types from core/types
+export type {
+  ContextPaths as Paths,
+  ProjectContext as Context,
+  CommandParams,
+  CommandResult as BaseCommandResult,
+} from '../types'
+
+/**
+ * Command execution result with optional extra data.
+ * Extends BaseCommandResult with command-specific fields.
+ */
+export interface CommandResult {
+  success: boolean
+  message?: string
+  error?: string
+  /** Duration of command execution */
+  duration?: string
+  /** Task that was affected */
+  task?: string
+  /** Feature that was affected */
+  feature?: string
+  /** Files that were modified */
+  filesModified?: string[]
+}
+
+// Agent types
+export interface AgentInfo {
+  isSupported: boolean
+  type: string
+}
+
+export interface Author {
+  name: string | null
+  email: string | null
+  github?: string | null
+}
+
+export interface AgentAssignmentResult {
+  agent: { name: string; domain?: string } | null
+  routing: {
+    confidence: number
+    reason: string
+    availableAgents?: string[]
+  }
+  _agenticNote?: string
+}
+
+// Analysis types
+export interface ComplexityResult {
+  level: 'low' | 'medium' | 'high'
+  hours: number
+  type: string
+}
+
+export interface HealthResult {
+  score: number
+  message: string
+}
+
+/**
+ * Options for the design command.
+ */
+export interface DesignOptions {
+  /** Type of design (e.g., 'system', 'component', 'api') */
+  type?: 'system' | 'component' | 'api' | 'database'
+  /** Output format */
+  format?: 'markdown' | 'mermaid'
+}
+
+/**
+ * Options for the cleanup command.
+ */
+export interface CleanupOptions {
+  /** Clean up memory/history */
+  memory?: boolean
+  /** Type of cleanup */
+  type?: 'all' | 'memory' | 'sessions' | 'cache'
+  /** Dry run without making changes */
+  dryRun?: boolean
+}
+
+/**
+ * Options for the setup command.
+ */
+export interface SetupOptions {
+  /** Force re-setup even if already configured */
+  force?: boolean
+  /** Skip interactive prompts */
+  nonInteractive?: boolean
+}
+
+/**
+ * Options for the migrate-all command.
+ */
+export interface MigrateOptions {
+  /** Perform deep scan for legacy installations */
+  deepScan?: boolean
+  /** Remove legacy installations after migration */
+  removeLegacy?: boolean
+  /** Dry run without making changes */
+  dryRun?: boolean
+}
+
+/**
+ * Options for the analyze command.
+ */
+export interface AnalyzeOptions {
+  /** Force re-analysis even if cached */
+  force?: boolean
+  /** Analysis depth */
+  depth?: 'quick' | 'normal' | 'deep'
+}
+
+/**
+ * Result from project migration.
+ */
+export interface MigrationResult {
+  success: boolean
+  projectId: string | null
+  filesCopied?: number
+  layerCounts: LayerCounts
+  config: MigrationConfig | null
+  author: Author | null
+  issues: string[]
+  dryRun: boolean
+  legacyRemoved?: boolean
+  legacyCleaned?: boolean
+}
+
+export interface LayerCounts {
+  core: number
+  progress: number
+  planning: number
+  analysis: number
+  memory: number
+  other: number
+}
+
+export interface MigrationConfig {
+  projectId: string
+  version: string
+  migratedAt: string
+}
+
+// Type-safe command method names (for dynamic invocation)
+export type CommandMethodName =
+  | 'now' | 'done' | 'next' | 'build'
+  | 'init' | 'feature' | 'bug' | 'architect'
+  | 'ship'
+  | 'context' | 'recap' | 'stuck' | 'progress' | 'roadmap' | 'status'
+  | 'cleanup' | 'design'
+  | 'analyze' | 'sync'
+  | 'start' | 'setup' | 'migrateAll'
+
+// Function signature for standard command methods
+export type StandardCommandFn = (param: string | null, projectPath?: string) => Promise<CommandResult>
+
+/**
+ * Global configuration for prjct.
+ */
+export interface GlobalConfig {
+  projectId: string
+  projectPath?: string
+  authors: AuthorEntry[]
+  version: string
+  created?: string
+  lastSync: string
+}
+
+export interface AuthorEntry {
+  name: string
+  email: string
+  github: string
+  firstContribution?: string
+  lastActivity?: string
+}

package/core/commands/workflow.ts

@@ -0,0 +1,226 @@
+/**
+ * Workflow Commands: now, done, next, build
+ * Core task management
+ */
+
+import type { CommandResult, Context } from './types'
+import {
+  PrjctCommandsBase,
+  contextBuilder,
+  toolRegistry,
+  dateHelper,
+  out
+} from './base'
+
+export class WorkflowCommands extends PrjctCommandsBase {
+  /**
+   * /p:now - Set or show current task
+   */
+  async now(task: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const context = await contextBuilder.build(projectPath, { task }) as Context
+
+      if (task) {
+        const agentResult = await this._assignAgentForTask(task, projectPath, context)
+        const agent = agentResult.agent?.name || 'generalist'
+        const confidence = agentResult.routing?.confidence || 0.5
+
+        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\nAgent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`
+        await toolRegistry.get('Write')!(context.paths.now, nowContent)
+
+        out.done(`${task} [${agent}]`)
+
+        await this.logToMemory(projectPath, 'task_started', {
+          task,
+          agent,
+          confidence,
+          timestamp: dateHelper.getTimestamp(),
+        })
+        return { success: true, task, agent }
+      } else {
+        const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
+
+        if (!nowContent || nowContent.includes('No current task')) {
+          out.warn('no active task')
+          return { success: true, message: 'No active task' }
+        }
+
+        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const agentMatch = nowContent.match(/Agent: ([^\s(]+)/)
+        const currentTask = taskMatch ? taskMatch[1] : 'unknown'
+        const currentAgent = agentMatch ? agentMatch[1] : ''
+        out.done(`working on: ${currentTask}${currentAgent ? ` [${currentAgent}]` : ''}`)
+        return { success: true, content: nowContent }
+      }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:done - Complete current task
+   */
+  async done(projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const context = await contextBuilder.build(projectPath) as Context
+      const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
+
+      if (!nowContent || nowContent.includes('No current task') || nowContent.trim() === '# NOW') {
+        out.warn('no active task')
+        return { success: true, message: 'No active task to complete' }
+      }
+
+      const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+      const task = taskMatch ? taskMatch[1] : 'task'
+
+      const startedMatch = nowContent.match(/Started: (.+)/)
+      let duration = ''
+      if (startedMatch) {
+        const started = new Date(startedMatch[1])
+        duration = dateHelper.calculateDuration(started)
+      }
+
+      const emptyNow = '# NOW\n\nNo current task. Use `/p:now` to set focus.\n'
+      await toolRegistry.get('Write')!(context.paths.now, emptyNow)
+
+      out.done(`${task}${duration ? ` (${duration})` : ''}`)
+
+      await this.logToMemory(projectPath, 'task_completed', {
+        task,
+        duration,
+        timestamp: dateHelper.getTimestamp(),
+      })
+      return { success: true, task, duration }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:next - Show priority queue
+   */
+  async next(projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const context = await contextBuilder.build(projectPath) as Context
+      const nextContent = await toolRegistry.get('Read')!(context.paths.next) as string
+
+      if (!nextContent || nextContent.trim() === '# NEXT\n\n## Priority Queue') {
+        out.warn('queue empty')
+        return { success: true, message: 'Queue is empty' }
+      }
+
+      const taskCount = (nextContent.match(/^- \[/gm) || []).length
+      out.done(`${taskCount} task${taskCount !== 1 ? 's' : ''} queued`)
+
+      return { success: true, content: nextContent }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:build - Start task with agent assignment
+   */
+  async build(taskOrNumber: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
+
+      const context = await contextBuilder.build(projectPath, { task: taskOrNumber }) as Context
+
+      const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
+      if (nowContent && !nowContent.includes('No current task')) {
+        console.log('⚠️  Already working on a task!')
+        console.log('   Complete it with /p:done first\n')
+        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
+        const currentTask = taskMatch ? taskMatch[1] : 'current task'
+        console.log(`   Current: ${currentTask}`)
+        return { success: false, message: 'Task already active' }
+      }
+
+      let task = taskOrNumber
+
+      if (!isNaN(Number(taskOrNumber))) {
+        const nextContent = await toolRegistry.get('Read')!(context.paths.next) as string
+        const tasks = nextContent
+          .split('\n')
+          .filter((line) => line.trim().match(/^\d+\./) || line.includes('[ ]'))
+
+        const index = parseInt(taskOrNumber) - 1
+        if (index >= 0 && index < tasks.length) {
+          task = tasks[index].replace(/^\d+\.\s*\[.\]\s*/, '').trim()
+          console.log(`📋 Selected from queue: ${task}\n`)
+        } else {
+          console.log(`❌ Invalid task number. Queue has ${tasks.length} tasks.`)
+          console.log('   Use /p:next to see queue')
+          return { success: false, error: 'Invalid task number' }
+        }
+      }
+
+      if (!task) {
+        console.log('❌ Task description required')
+        console.log('Usage: /p:build "task description"')
+        console.log('   or: /p:build 1 (select from queue)')
+        return { success: false, error: 'Task required' }
+      }
+
+      console.log(`🏗️  Building: ${task}\n`)
+
+      const complexity = this._detectComplexity(task)
+      const estimate = complexity.hours
+
+      console.log('📊 Analysis:')
+      console.log(`   Complexity: ${complexity.level}`)
+      console.log(`   Estimated: ${estimate}h`)
+      console.log(`   Type: ${complexity.type}\n`)
+
+      const agentResult = await this._assignAgentForTask(task, projectPath, context)
+      const agent = agentResult.agent?.name || 'generalist'
+      const confidence = agentResult.routing?.confidence || 0.5
+      console.log(`🤖 Agent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`)
+
+      const nowContentNew = `# NOW
+
+**${task}**
+
+Started: ${new Date().toLocaleString()}
+Estimated: ${estimate}h
+Complexity: ${complexity.level}
+Agent: ${agent} (${Math.round(confidence * 100)}% confidence)
+`
+      await toolRegistry.get('Write')!(context.paths.now, nowContentNew)
+
+      console.log('✅ Task started!\n')
+      console.log('💡 Next steps:')
+      console.log('• Start coding')
+      console.log('• /p:done → Mark complete')
+      console.log('• /p:stuck → Get help if needed')
+
+      await this.logToMemory(projectPath, 'task_built', {
+        task,
+        complexity: complexity.level,
+        estimate,
+        agent,
+        confidence,
+        timestamp: dateHelper.getTimestamp(),
+      })
+
+      return { success: true, task, complexity, estimate, agent }
+    } catch (error) {
+      console.error('❌ Error:', (error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+}

package/core/commands.ts

@@ -0,0 +1,11 @@
+/**
+ * Agentic Commands Handler for prjct CLI
+ *
+ * Re-exports from modular commands/ directory.
+ * See commands/index.ts for implementation.
+ */
+
+import instance, { PrjctCommands } from './commands/index'
+
+export default instance
+export { PrjctCommands }