prjct-cli 0.11.5 → 0.12.1

package/core/bus/{index.js → index.ts}

@@ -7,9 +7,9 @@
  * @version 1.0.0
  */
 
-const fs = require('fs').promises
-const path = require('path')
-const pathManager = require('../infrastructure/path-manager')
+import fs from 'fs/promises'
+import path from 'path'
+import pathManager from '../infrastructure/path-manager'
 
 /**
  * Event Types - All events that can be emitted
@@ -50,9 +50,26 @@ const EventTypes = {
 
   // Wildcard
   ALL: '*'
+} as const
+
+type EventType = typeof EventTypes[keyof typeof EventTypes]
+
+interface EventData {
+  type: string
+  timestamp: string
+  projectId: string | null
+  [key: string]: unknown
 }
 
+type EventCallback = (data: EventData) => void | Promise<void>
+
 class EventBus {
+  private listeners: Map<string, Set<EventCallback>>
+  private onceListeners: Map<string, Set<EventCallback>>
+  private history: EventData[]
+  private historyLimit: number
+  projectId: string | null
+
   constructor() {
     this.listeners = new Map()
     this.onceListeners = new Map()
@@ -63,23 +80,19 @@ class EventBus {
 
   /**
    * Initialize event bus for a project
-   * @param {string} projectId
    */
-  async initialize(projectId) {
+  async initialize(projectId: string): Promise<void> {
     this.projectId = projectId
   }
 
   /**
    * Subscribe to an event
-   * @param {string} event - Event type or wildcard pattern
-   * @param {Function} callback - Handler function
-   * @returns {Function} Unsubscribe function
    */
-  on(event, callback) {
+  on(event: string, callback: EventCallback): () => void {
     if (!this.listeners.has(event)) {
       this.listeners.set(event, new Set())
     }
-    this.listeners.get(event).add(callback)
+    this.listeners.get(event)!.add(callback)
 
     // Return unsubscribe function
     return () => this.off(event, callback)
@@ -87,15 +100,12 @@ class EventBus {
 
   /**
    * Subscribe to an event once
-   * @param {string} event
-   * @param {Function} callback
-   * @returns {Function} Unsubscribe function
    */
-  once(event, callback) {
+  once(event: string, callback: EventCallback): () => void {
     if (!this.onceListeners.has(event)) {
       this.onceListeners.set(event, new Set())
     }
-    this.onceListeners.get(event).add(callback)
+    this.onceListeners.get(event)!.add(callback)
 
     return () => {
       const listeners = this.onceListeners.get(event)
@@ -107,10 +117,8 @@ class EventBus {
 
   /**
    * Unsubscribe from an event
-   * @param {string} event
-   * @param {Function} callback
    */
-  off(event, callback) {
+  off(event: string, callback: EventCallback): void {
     const listeners = this.listeners.get(event)
     if (listeners) {
       listeners.delete(callback)
@@ -119,13 +127,10 @@ class EventBus {
 
   /**
    * Emit an event
-   * @param {string} event - Event type
-   * @param {Object} data - Event payload
-   * @returns {Promise<void>}
    */
-  async emit(event, data = {}) {
+  async emit(event: string, data: Record<string, unknown> = {}): Promise<void> {
     const timestamp = new Date().toISOString()
-    const eventData = {
+    const eventData: EventData = {
       type: event,
       timestamp,
       projectId: this.projectId,
@@ -152,7 +157,7 @@ class EventBus {
     )
 
     // Log any errors
-    results.forEach((result, index) => {
+    results.forEach((result) => {
       if (result.status === 'rejected') {
         console.error(`Event listener error for ${event}:`, result.reason)
       }
@@ -179,11 +184,9 @@ class EventBus {
 
   /**
    * Get all listeners that match an event (including wildcards)
-   * @param {string} event
-   * @returns {Function[]}
    */
-  getMatchingListeners(event) {
-    const callbacks = []
+  getMatchingListeners(event: string): EventCallback[] {
+    const callbacks: EventCallback[] = []
 
     // Exact match
     const exact = this.listeners.get(event)
@@ -209,10 +212,8 @@ class EventBus {
 
   /**
    * Execute a callback safely (handles sync and async)
-   * @param {Function} callback
-   * @param {Object} data
    */
-  async executeCallback(callback, data) {
+  async executeCallback(callback: EventCallback, data: EventData): Promise<void> {
     try {
       const result = callback(data)
       if (result instanceof Promise) {
@@ -226,11 +227,10 @@ class EventBus {
 
   /**
    * Log event to persistent storage
-   * @param {Object} eventData
    */
-  async logEvent(eventData) {
+  async logEvent(eventData: EventData): Promise<void> {
     try {
-      const globalPath = pathManager.getGlobalProjectPath(this.projectId)
+      const globalPath = pathManager.getGlobalProjectPath(this.projectId!)
       const eventsPath = path.join(globalPath, 'memory', 'events.jsonl')
 
       // Ensure directory exists
@@ -246,11 +246,8 @@ class EventBus {
 
   /**
    * Get recent events from history
-   * @param {number} limit
-   * @param {string} [type] - Optional filter by event type
-   * @returns {Object[]}
    */
-  getHistory(limit = 10, type = null) {
+  getHistory(limit: number = 10, type: string | null = null): EventData[] {
     let events = this.history
     if (type) {
       events = events.filter(e => e.type === type || e.type.startsWith(type))
@@ -261,26 +258,23 @@ class EventBus {
   /**
    * Clear all listeners
    */
-  clear() {
+  clear(): void {
     this.listeners.clear()
     this.onceListeners.clear()
   }
 
   /**
    * Get count of listeners for an event
-   * @param {string} event
-   * @returns {number}
    */
-  listenerCount(event) {
+  listenerCount(event: string): number {
     const listeners = this.listeners.get(event)
     return listeners ? listeners.size : 0
   }
 
   /**
    * Get all registered event types
-   * @returns {string[]}
    */
-  getRegisteredEvents() {
+  getRegisteredEvents(): string[] {
     return Array.from(this.listeners.keys())
   }
 }
@@ -290,33 +284,35 @@ const eventBus = new EventBus()
 
 // Convenience methods for common events
 const emit = {
-  sessionStarted: (data) => eventBus.emit(EventTypes.SESSION_STARTED, data),
-  sessionPaused: (data) => eventBus.emit(EventTypes.SESSION_PAUSED, data),
-  sessionResumed: (data) => eventBus.emit(EventTypes.SESSION_RESUMED, data),
-  sessionCompleted: (data) => eventBus.emit(EventTypes.SESSION_COMPLETED, data),
+  sessionStarted: (data: Record<string, unknown>) => eventBus.emit(EventTypes.SESSION_STARTED, data),
+  sessionPaused: (data: Record<string, unknown>) => eventBus.emit(EventTypes.SESSION_PAUSED, data),
+  sessionResumed: (data: Record<string, unknown>) => eventBus.emit(EventTypes.SESSION_RESUMED, data),
+  sessionCompleted: (data: Record<string, unknown>) => eventBus.emit(EventTypes.SESSION_COMPLETED, data),
 
-  taskCreated: (data) => eventBus.emit(EventTypes.TASK_CREATED, data),
-  taskCompleted: (data) => eventBus.emit(EventTypes.TASK_COMPLETED, data),
+  taskCreated: (data: Record<string, unknown>) => eventBus.emit(EventTypes.TASK_CREATED, data),
+  taskCompleted: (data: Record<string, unknown>) => eventBus.emit(EventTypes.TASK_COMPLETED, data),
 
-  featureAdded: (data) => eventBus.emit(EventTypes.FEATURE_ADDED, data),
-  featureShipped: (data) => eventBus.emit(EventTypes.FEATURE_SHIPPED, data),
+  featureAdded: (data: Record<string, unknown>) => eventBus.emit(EventTypes.FEATURE_ADDED, data),
+  featureShipped: (data: Record<string, unknown>) => eventBus.emit(EventTypes.FEATURE_SHIPPED, data),
 
-  ideaCaptured: (data) => eventBus.emit(EventTypes.IDEA_CAPTURED, data),
+  ideaCaptured: (data: Record<string, unknown>) => eventBus.emit(EventTypes.IDEA_CAPTURED, data),
 
-  snapshotCreated: (data) => eventBus.emit(EventTypes.SNAPSHOT_CREATED, data),
-  snapshotRestored: (data) => eventBus.emit(EventTypes.SNAPSHOT_RESTORED, data),
+  snapshotCreated: (data: Record<string, unknown>) => eventBus.emit(EventTypes.SNAPSHOT_CREATED, data),
+  snapshotRestored: (data: Record<string, unknown>) => eventBus.emit(EventTypes.SNAPSHOT_RESTORED, data),
 
-  commitCreated: (data) => eventBus.emit(EventTypes.COMMIT_CREATED, data),
-  pushCompleted: (data) => eventBus.emit(EventTypes.PUSH_COMPLETED, data),
+  commitCreated: (data: Record<string, unknown>) => eventBus.emit(EventTypes.COMMIT_CREATED, data),
+  pushCompleted: (data: Record<string, unknown>) => eventBus.emit(EventTypes.PUSH_COMPLETED, data),
 
-  projectInitialized: (data) => eventBus.emit(EventTypes.PROJECT_INITIALIZED, data),
-  projectSynced: (data) => eventBus.emit(EventTypes.PROJECT_SYNCED, data),
-  analysisCompleted: (data) => eventBus.emit(EventTypes.ANALYSIS_COMPLETED, data)
+  projectInitialized: (data: Record<string, unknown>) => eventBus.emit(EventTypes.PROJECT_INITIALIZED, data),
+  projectSynced: (data: Record<string, unknown>) => eventBus.emit(EventTypes.PROJECT_SYNCED, data),
+  analysisCompleted: (data: Record<string, unknown>) => eventBus.emit(EventTypes.ANALYSIS_COMPLETED, data)
 }
 
-module.exports = {
+export {
   EventBus,
   EventTypes,
   eventBus,
   emit
 }
+
+export default { EventBus, EventTypes, eventBus, emit }

package/core/command-registry/categories.ts

@@ -0,0 +1,23 @@
+/**
+ * Category Definitions
+ */
+
+import type { Categories } from './types'
+
+export const CATEGORIES: Categories = {
+  core: {
+    title: 'Core Workflow',
+    description: '13 essential commands for daily development workflow',
+    order: 1,
+  },
+  optional: {
+    title: 'Optional Commands',
+    description: 'Advanced features for specialized workflows',
+    order: 2,
+  },
+  setup: {
+    title: 'Setup',
+    description: 'Installation and configuration (not for daily use)',
+    order: 3,
+  },
+}

package/core/command-registry/commands.ts

@@ -0,0 +1,15 @@
+/**
+ * Command Definitions
+ * All prjct commands combined from category modules.
+ */
+
+import type { Command } from './types'
+import { CORE_COMMANDS } from './core-commands'
+import { OPTIONAL_COMMANDS } from './optional-commands'
+import { SETUP_COMMANDS } from './setup-commands'
+
+export const COMMANDS: Command[] = [
+  ...CORE_COMMANDS,
+  ...OPTIONAL_COMMANDS,
+  ...SETUP_COMMANDS,
+]

package/core/command-registry/core-commands.ts

@@ -0,0 +1,319 @@
+/**
+ * Core Workflow Commands
+ * 14 essential commands for daily development workflow.
+ */
+
+import type { Command } from './types'
+
+export const CORE_COMMANDS: Command[] = [
+  {
+    name: 'init',
+    category: 'core',
+    description: 'Deep project analysis and initialization',
+    usage: {
+      claude: '/p:init "[idea]"',
+      terminal: 'prjct init "[idea]"',
+    },
+    params: '[idea]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: false,
+    blockingRules: null,
+    features: [
+      'Architect mode for blank projects',
+      'Auto tech stack recommendation',
+      'Project structure generation',
+      'Initial roadmap creation',
+      'Analyzes existing codebases',
+    ],
+  },
+
+  {
+    name: 'idea',
+    category: 'core',
+    description: 'Transform ideas into complete technical architectures',
+    usage: {
+      claude: '/p:idea "build a CRM with AI"',
+      terminal: 'prjct idea "build a CRM with AI"',
+    },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Simple ideas -> Quick capture',
+      'Complex ideas -> Full architecture',
+      'Interactive discovery process',
+      'Tech stack recommendation',
+      'Complete roadmap generation',
+      'Database schema design',
+      'API specification',
+    ],
+  },
+
+  {
+    name: 'feature',
+    category: 'core',
+    description: 'Add feature with value analysis, roadmap, and task breakdown',
+    usage: {
+      claude: '/p:feature "add unit testing"',
+      terminal: 'prjct feature "add unit testing"',
+    },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Value analysis (impact/effort/timing)',
+      'Auto roadmap generation',
+      'Task breakdown',
+      'Auto-start first task',
+      'Timing recommendations',
+    ],
+  },
+
+  {
+    name: 'spec',
+    category: 'core',
+    description: 'Create detailed specifications for complex features',
+    usage: {
+      claude: '/p:spec "Dark Mode"',
+      terminal: 'prjct spec "Dark Mode"',
+    },
+    params: '[feature]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Requirements documentation',
+      'Design decisions tracking',
+      'Tasks broken into 20-30min chunks',
+      'User approval workflow',
+      'Auto-add tasks to queue on approve',
+      'Integrates with /p:feature',
+    ],
+  },
+
+  {
+    name: 'work',
+    category: 'core',
+    description: 'Show current or start new task',
+    usage: {
+      claude: '/p:work ["task"]',
+      terminal: 'prjct work ["task"]',
+    },
+    params: '[task]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'No params -> Show current task',
+      'With task -> Start new task',
+      'Auto agent assignment',
+      'Supports task numbers',
+      'Replaces /p:now and /p:build',
+    ],
+  },
+
+  {
+    name: 'pause',
+    category: 'core',
+    description: 'Pause active task to handle interruption',
+    usage: {
+      claude: '/p:pause ["reason"]',
+      terminal: 'prjct pause ["reason"]',
+    },
+    params: '[reason]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: {
+      check: 'Active task exists',
+      message: 'No active task to pause',
+    },
+    features: [
+      'Preserves task context',
+      'Optional pause reason',
+      'Tracks paused duration',
+      'Allows multiple paused tasks',
+    ],
+  },
+
+  {
+    name: 'resume',
+    category: 'core',
+    description: 'Resume most recently paused task',
+    usage: {
+      claude: '/p:resume [task_id]',
+      terminal: 'prjct resume [task_id]',
+    },
+    params: '[task_id]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: {
+      check: 'Paused tasks exist',
+      message: 'No paused tasks to resume',
+    },
+    features: [
+      'Resume last paused',
+      'Resume specific task',
+      'Resume by number',
+      'Calculates active time',
+    ],
+  },
+
+  {
+    name: 'next',
+    category: 'core',
+    description: 'Show top 5 non-blocking priority tasks',
+    usage: {
+      claude: '/p:next',
+      terminal: 'prjct next',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: {
+      check: 'filters blocked tasks',
+      message: 'Shows warning if now.md is active',
+    },
+    features: [
+      'Filters out blocked tasks',
+      'Shows top 5 by priority',
+      'Numbered 1-5 for quick selection',
+      'Warns if active task exists',
+    ],
+  },
+
+  {
+    name: 'done',
+    category: 'core',
+    description: 'Mark current task as complete',
+    usage: {
+      claude: '/p:done',
+      terminal: 'prjct done',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: {
+      check: 'now.md must have content',
+      message: 'No active task to complete',
+    },
+  },
+
+  {
+    name: 'ship',
+    category: 'core',
+    description: 'Commit, push, and celebrate shipped feature',
+    usage: {
+      claude: '/p:ship "user authentication"',
+      terminal: 'prjct ship "user authentication"',
+    },
+    params: '<feature>',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Lint checks (non-blocking)',
+      'Run tests (non-blocking)',
+      'Update docs',
+      'Update version',
+      'Update CHANGELOG',
+      'Git commit + push',
+      'Recommend compact',
+    ],
+  },
+
+  {
+    name: 'bug',
+    category: 'core',
+    description: 'Report and track bugs with priority',
+    usage: {
+      claude: '/p:bug "login button not working"',
+      terminal: 'prjct bug "login button not working"',
+    },
+    params: '<description>',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Auto-detect severity (critical/high/medium/low)',
+      'Priority placement in next.md',
+      'Bug tracking in memory',
+      'Quick bug resolution workflow',
+    ],
+  },
+
+  {
+    name: 'dash',
+    category: 'core',
+    description: 'Unified dashboard - status, progress, and roadmap',
+    usage: {
+      claude: '/p:dash [view]',
+      terminal: 'prjct dash [view]',
+    },
+    params: '[week|month|roadmap|compact]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Project overview',
+      'Weekly/monthly progress',
+      'Roadmap view',
+      'ASCII graphics',
+      'Replaces 4 commands',
+    ],
+  },
+
+  {
+    name: 'help',
+    category: 'core',
+    description: 'Contextual help and guidance',
+    usage: {
+      claude: '/p:help [topic]',
+      terminal: 'prjct help [topic]',
+    },
+    params: '[topic]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: false,
+    blockingRules: null,
+    features: [
+      'Context-aware suggestions',
+      'Intent to action translator',
+      'Problem solving guidance',
+      'Absorbs ask/suggest/stuck',
+    ],
+  },
+
+  {
+    name: 'sync',
+    category: 'core',
+    description: 'Sync project state and update workflow agents',
+    usage: {
+      claude: '/p:sync',
+      terminal: 'prjct sync',
+    },
+    params: null,
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: true,
+    blockingRules: null,
+    features: [
+      'Syncs project state',
+      'Updates dynamic agents',
+      'Refreshes context',
+    ],
+  },
+]