prjct-cli 0.13.3 → 0.15.0

package/core/storage/queue-storage.ts

@@ -0,0 +1,297 @@
+/**
+ * Queue Storage
+ *
+ * Manages task queue via storage/queue.json
+ * Generates context/next.md for Claude
+ */
+
+import { StorageManager } from './storage-manager'
+import { generateUUID } from '../schemas'
+import type { QueueJson, QueueTask, Priority, TaskType, TaskSection } from '../schemas/state'
+
+class QueueStorage extends StorageManager<QueueJson> {
+  constructor() {
+    super('queue.json')
+  }
+
+  protected getDefault(): QueueJson {
+    return {
+      tasks: [],
+      lastUpdated: ''
+    }
+  }
+
+  protected getMdFilename(): string {
+    return 'next.md'
+  }
+
+  protected getEventType(action: 'update' | 'create' | 'delete'): string {
+    return `queue.${action}d`
+  }
+
+  protected toMarkdown(data: QueueJson): string {
+    const lines = ['# Priority Queue', '']
+
+    const activeTasks = data.tasks.filter(t => t.section === 'active' && !t.completed)
+    const backlogTasks = data.tasks.filter(t => t.section === 'backlog' && !t.completed)
+    const previouslyActive = data.tasks.filter(t => t.section === 'previously_active' && !t.completed)
+
+    // Active section
+    lines.push('## Active Tasks')
+    if (activeTasks.length > 0) {
+      activeTasks.forEach((task, i) => {
+        const checkbox = task.completed ? '[x]' : '[ ]'
+        const priority = task.priority !== 'medium' ? ` [${task.priority.toUpperCase()}]` : ''
+        const agent = task.agent ? ` @${task.agent}` : ''
+        const origin = task.originFeature ? ` (from: ${task.originFeature})` : ''
+        const bug = task.type === 'bug' ? ' \u{1F41B}' : ''
+        lines.push(`${i + 1}. ${checkbox}${bug}${priority} ${task.description}${agent}${origin}`)
+      })
+    } else {
+      lines.push('_No active tasks_')
+    }
+    lines.push('')
+
+    // Previously active section (if any)
+    if (previouslyActive.length > 0) {
+      lines.push('## Previously Active')
+      previouslyActive.forEach(task => {
+        lines.push(`- [ ] ${task.description}`)
+      })
+      lines.push('')
+    }
+
+    // Backlog section
+    lines.push('## Backlog')
+    if (backlogTasks.length > 0) {
+      backlogTasks.forEach(task => {
+        const priority = task.priority !== 'medium' ? ` [${task.priority.toUpperCase()}]` : ''
+        const bug = task.type === 'bug' ? ' \u{1F41B}' : ''
+        lines.push(`- [ ]${bug}${priority} ${task.description}`)
+      })
+    } else {
+      lines.push('_No backlog items_')
+    }
+    lines.push('')
+
+    return lines.join('\n')
+  }
+
+  // =========== Domain Methods ===========
+
+  /**
+   * Get all tasks
+   */
+  async getTasks(projectId: string): Promise<QueueTask[]> {
+    const queue = await this.read(projectId)
+    return queue.tasks
+  }
+
+  /**
+   * Get active (non-backlog) tasks
+   */
+  async getActiveTasks(projectId: string): Promise<QueueTask[]> {
+    const queue = await this.read(projectId)
+    return queue.tasks.filter(t => t.section === 'active' && !t.completed)
+  }
+
+  /**
+   * Get backlog tasks
+   */
+  async getBacklog(projectId: string): Promise<QueueTask[]> {
+    const queue = await this.read(projectId)
+    return queue.tasks.filter(t => t.section === 'backlog' && !t.completed)
+  }
+
+  /**
+   * Get next task (highest priority incomplete)
+   */
+  async getNextTask(projectId: string): Promise<QueueTask | null> {
+    const tasks = await this.getActiveTasks(projectId)
+    return this.sortTasks(tasks)[0] || null
+  }
+
+  /**
+   * Add a task to the queue
+   */
+  async addTask(
+    projectId: string,
+    task: Omit<QueueTask, 'id' | 'createdAt' | 'completed' | 'completedAt'>
+  ): Promise<QueueTask> {
+    const newTask: QueueTask = {
+      ...task,
+      id: generateUUID(),
+      createdAt: new Date().toISOString(),
+      completed: false
+    }
+
+    await this.update(projectId, (queue) => ({
+      tasks: [...queue.tasks, newTask],
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish incremental event
+    await this.publishEvent(projectId, 'queue.task_added', {
+      taskId: newTask.id,
+      description: newTask.description,
+      priority: newTask.priority,
+      section: newTask.section
+    })
+
+    return newTask
+  }
+
+  /**
+   * Add multiple tasks
+   */
+  async addTasks(
+    projectId: string,
+    tasks: Omit<QueueTask, 'id' | 'createdAt' | 'completed' | 'completedAt'>[]
+  ): Promise<QueueTask[]> {
+    const now = new Date().toISOString()
+    const newTasks: QueueTask[] = tasks.map(task => ({
+      ...task,
+      id: generateUUID(),
+      createdAt: now,
+      completed: false
+    }))
+
+    await this.update(projectId, (queue) => ({
+      tasks: [...queue.tasks, ...newTasks],
+      lastUpdated: now
+    }))
+
+    // Publish event for batch add
+    await this.publishEvent(projectId, 'queue.tasks_added', {
+      count: newTasks.length,
+      tasks: newTasks.map(t => ({ id: t.id, description: t.description }))
+    })
+
+    return newTasks
+  }
+
+  /**
+   * Remove a task
+   */
+  async removeTask(projectId: string, taskId: string): Promise<void> {
+    await this.update(projectId, (queue) => ({
+      tasks: queue.tasks.filter(t => t.id !== taskId),
+      lastUpdated: new Date().toISOString()
+    }))
+
+    await this.publishEvent(projectId, 'queue.task_removed', { taskId })
+  }
+
+  /**
+   * Mark a task as completed
+   */
+  async completeTask(projectId: string, taskId: string): Promise<QueueTask | null> {
+    let completedTask: QueueTask | null = null
+
+    await this.update(projectId, (queue) => {
+      const tasks = queue.tasks.map(t => {
+        if (t.id === taskId) {
+          completedTask = {
+            ...t,
+            completed: true,
+            completedAt: new Date().toISOString()
+          }
+          return completedTask
+        }
+        return t
+      })
+      return { tasks, lastUpdated: new Date().toISOString() }
+    })
+
+    if (completedTask) {
+      await this.publishEvent(projectId, 'queue.task_completed', {
+        taskId,
+        description: completedTask.description,
+        completedAt: completedTask.completedAt
+      })
+    }
+
+    return completedTask
+  }
+
+  /**
+   * Move task to different section
+   */
+  async moveToSection(
+    projectId: string,
+    taskId: string,
+    section: TaskSection
+  ): Promise<void> {
+    await this.update(projectId, (queue) => ({
+      tasks: queue.tasks.map(t =>
+        t.id === taskId ? { ...t, section } : t
+      ),
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Set task priority
+   */
+  async setPriority(
+    projectId: string,
+    taskId: string,
+    priority: Priority
+  ): Promise<void> {
+    await this.update(projectId, (queue) => ({
+      tasks: queue.tasks.map(t =>
+        t.id === taskId ? { ...t, priority } : t
+      ),
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Clear completed tasks
+   */
+  async clearCompleted(projectId: string): Promise<number> {
+    const queue = await this.read(projectId)
+    const completedCount = queue.tasks.filter(t => t.completed).length
+
+    await this.update(projectId, (q) => ({
+      tasks: q.tasks.filter(t => !t.completed),
+      lastUpdated: new Date().toISOString()
+    }))
+
+    return completedCount
+  }
+
+  /**
+   * Sort tasks by priority and section
+   */
+  private sortTasks(tasks: QueueTask[]): QueueTask[] {
+    const priorityOrder: Record<Priority, number> = {
+      critical: 0,
+      high: 1,
+      medium: 2,
+      low: 3
+    }
+
+    const sectionOrder: Record<TaskSection, number> = {
+      active: 0,
+      previously_active: 1,
+      backlog: 2
+    }
+
+    return [...tasks].sort((a, b) => {
+      // Section first
+      const sectionDiff = sectionOrder[a.section] - sectionOrder[b.section]
+      if (sectionDiff !== 0) return sectionDiff
+
+      // Then priority
+      const priorityDiff = priorityOrder[a.priority] - priorityOrder[b.priority]
+      if (priorityDiff !== 0) return priorityDiff
+
+      // Then creation date
+      return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
+    })
+  }
+}
+
+export const queueStorage = new QueueStorage()
+export default queueStorage

package/core/storage/shipped-storage.ts

@@ -0,0 +1,223 @@
+/**
+ * Shipped Storage
+ *
+ * Manages shipped features via storage/shipped.json
+ * Generates context/shipped.md for Claude
+ */
+
+import { StorageManager } from './storage-manager'
+import { generateUUID } from '../schemas'
+
+export interface ShippedFeature {
+  id: string
+  name: string
+  shippedAt: string
+  version: string
+  description?: string
+  tasks?: string[] // Task IDs that were part of this ship
+  duration?: string // How long it took
+}
+
+export interface ShippedJson {
+  shipped: ShippedFeature[]
+  lastUpdated: string
+}
+
+class ShippedStorage extends StorageManager<ShippedJson> {
+  constructor() {
+    super('shipped.json')
+  }
+
+  protected getDefault(): ShippedJson {
+    return {
+      shipped: [],
+      lastUpdated: ''
+    }
+  }
+
+  protected getMdFilename(): string {
+    return 'shipped.md'
+  }
+
+  protected getEventType(action: 'update' | 'create' | 'delete'): string {
+    return `shipped.${action}d`
+  }
+
+  protected toMarkdown(data: ShippedJson): string {
+    const lines = ['# SHIPPED \u{1F680}', '']
+
+    if (data.shipped.length === 0) {
+      lines.push('_No features shipped yet. Use /p:ship to celebrate!_')
+      lines.push('')
+      return lines.join('\n')
+    }
+
+    // Group by month
+    const byMonth = new Map<string, ShippedFeature[]>()
+
+    data.shipped.forEach(ship => {
+      const date = new Date(ship.shippedAt)
+      const month = date.toLocaleDateString('en-US', { year: 'numeric', month: 'long' })
+
+      if (!byMonth.has(month)) {
+        byMonth.set(month, [])
+      }
+      byMonth.get(month)!.push(ship)
+    })
+
+    // Render by month (most recent first)
+    const sortedMonths = Array.from(byMonth.keys()).sort((a, b) => {
+      const dateA = new Date(byMonth.get(a)![0].shippedAt)
+      const dateB = new Date(byMonth.get(b)![0].shippedAt)
+      return dateB.getTime() - dateA.getTime()
+    })
+
+    sortedMonths.forEach(month => {
+      lines.push(`## ${month}`)
+      lines.push('')
+
+      const ships = byMonth.get(month)!.sort(
+        (a, b) => new Date(b.shippedAt).getTime() - new Date(a.shippedAt).getTime()
+      )
+
+      ships.forEach(ship => {
+        const date = new Date(ship.shippedAt).toLocaleDateString('en-US', {
+          month: 'short',
+          day: 'numeric'
+        })
+        const version = ship.version ? ` v${ship.version}` : ''
+        const duration = ship.duration ? ` (${ship.duration})` : ''
+        lines.push(`- **${ship.name}**${version}${duration} - ${date}`)
+        if (ship.description) {
+          lines.push(`  _${ship.description}_`)
+        }
+      })
+
+      lines.push('')
+    })
+
+    // Stats
+    lines.push('---')
+    lines.push('')
+    lines.push(`**Total shipped:** ${data.shipped.length}`)
+    lines.push('')
+
+    return lines.join('\n')
+  }
+
+  // =========== Domain Methods ===========
+
+  /**
+   * Get all shipped features
+   */
+  async getAll(projectId: string): Promise<ShippedFeature[]> {
+    const data = await this.read(projectId)
+    return data.shipped
+  }
+
+  /**
+   * Get recent shipped features
+   */
+  async getRecent(projectId: string, limit: number = 5): Promise<ShippedFeature[]> {
+    const data = await this.read(projectId)
+    return data.shipped
+      .sort((a, b) => new Date(b.shippedAt).getTime() - new Date(a.shippedAt).getTime())
+      .slice(0, limit)
+  }
+
+  /**
+   * Add a shipped feature
+   */
+  async addShipped(
+    projectId: string,
+    feature: Omit<ShippedFeature, 'id' | 'shippedAt'>
+  ): Promise<ShippedFeature> {
+    const shipped: ShippedFeature = {
+      ...feature,
+      id: generateUUID(),
+      shippedAt: new Date().toISOString()
+    }
+
+    await this.update(projectId, (data) => ({
+      shipped: [shipped, ...data.shipped], // Prepend
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish event
+    await this.publishEvent(projectId, 'feature.shipped', {
+      shipId: shipped.id,
+      name: shipped.name,
+      version: shipped.version,
+      shippedAt: shipped.shippedAt
+    })
+
+    return shipped
+  }
+
+  /**
+   * Get shipped by version
+   */
+  async getByVersion(
+    projectId: string,
+    version: string
+  ): Promise<ShippedFeature | undefined> {
+    const data = await this.read(projectId)
+    return data.shipped.find(s => s.version === version)
+  }
+
+  /**
+   * Get count
+   */
+  async getCount(projectId: string): Promise<number> {
+    const data = await this.read(projectId)
+    return data.shipped.length
+  }
+
+  /**
+   * Get shipped in date range
+   */
+  async getByDateRange(
+    projectId: string,
+    startDate: Date,
+    endDate: Date
+  ): Promise<ShippedFeature[]> {
+    const data = await this.read(projectId)
+    return data.shipped.filter(s => {
+      const date = new Date(s.shippedAt)
+      return date >= startDate && date <= endDate
+    })
+  }
+
+  /**
+   * Get stats for a period
+   */
+  async getStats(
+    projectId: string,
+    period: 'week' | 'month' | 'year' = 'month'
+  ): Promise<{ count: number; period: string }> {
+    const now = new Date()
+    let startDate: Date
+
+    switch (period) {
+      case 'week':
+        startDate = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000)
+        break
+      case 'month':
+        startDate = new Date(now.getFullYear(), now.getMonth(), 1)
+        break
+      case 'year':
+        startDate = new Date(now.getFullYear(), 0, 1)
+        break
+    }
+
+    const shipped = await this.getByDateRange(projectId, startDate, now)
+
+    return {
+      count: shipped.length,
+      period
+    }
+  }
+}
+
+export const shippedStorage = new ShippedStorage()
+export default shippedStorage