prjct-cli 0.20.0 → 0.20.1

package/core/data/md-base-manager.ts

@@ -1,203 +0,0 @@
-/**
- * MD Base Manager
- *
- * Abstract base class for MD file managers.
- * MD-First Architecture: MD is the source of truth.
- *
- * Each concrete manager must implement:
- * - parse(content: string): T - Convert MD to schema
- * - serialize(data: T): string - Convert schema to MD
- * - getDefault(projectId: string): T - Default value when file doesn't exist
- */
-
-import path from 'path'
-import fs from 'fs/promises'
-import * as fileHelper from '../utils/file-helper'
-import pathManager from '../infrastructure/path-manager'
-
-export abstract class MdBaseManager<T> {
-  protected filename: string
-  protected cache: Map<string, T> = new Map()
-  protected cacheTimeout = 5000 // 5 seconds
-  protected lastRead: Map<string, number> = new Map()
-
-  constructor(filename: string) {
-    this.filename = filename
-  }
-
-  /**
-   * Get file path for a project.
-   */
-  protected getFilePath(projectId: string): string {
-    const globalPath = pathManager.getGlobalProjectPath(projectId)
-    return path.join(globalPath, this.filename)
-  }
-
-  /**
-   * Get default value for this data type.
-   */
-  protected abstract getDefault(projectId: string): T
-
-  /**
-   * Parse MD content to schema.
-   */
-  protected abstract parse(content: string): T
-
-  /**
-   * Serialize schema to MD content.
-   */
-  protected abstract serialize(data: T): string
-
-  /**
-   * Read data from MD file.
-   */
-  async read(projectId: string): Promise<T> {
-    const now = Date.now()
-    const lastReadTime = this.lastRead.get(projectId) || 0
-
-    // Return cached if fresh
-    if (now - lastReadTime < this.cacheTimeout && this.cache.has(projectId)) {
-      return this.cache.get(projectId)!
-    }
-
-    const filePath = this.getFilePath(projectId)
-    const content = await fileHelper.readFile(filePath, '')
-
-    const data = content.trim() ? this.parse(content) : this.getDefault(projectId)
-
-    // Update cache
-    this.cache.set(projectId, data)
-    this.lastRead.set(projectId, now)
-
-    return data
-  }
-
-  /**
-   * Write data to MD file using atomic write (prevents partial writes).
-   */
-  async write(projectId: string, data: T): Promise<void> {
-    const filePath = this.getFilePath(projectId)
-    const content = this.serialize(data)
-
-    // Ensure directory exists
-    await fileHelper.ensureDir(path.dirname(filePath))
-
-    // Atomic write: write to temp file, then rename
-    const tempPath = `${filePath}.${Date.now()}.tmp`
-    await fs.writeFile(tempPath, content, 'utf-8')
-    await fs.rename(tempPath, filePath)
-
-    // Update cache
-    this.cache.set(projectId, data)
-    this.lastRead.set(projectId, Date.now())
-  }
-
-  /**
-   * Check if file exists.
-   */
-  async exists(projectId: string): Promise<boolean> {
-    const filePath = this.getFilePath(projectId)
-    return fileHelper.fileExists(filePath)
-  }
-
-  /**
-   * Initialize with default data.
-   */
-  async initialize(projectId: string): Promise<T> {
-    const data = this.getDefault(projectId)
-    await this.write(projectId, data)
-    return data
-  }
-
-  /**
-   * Clear cache.
-   */
-  clearCache(projectId?: string): void {
-    if (projectId) {
-      this.cache.delete(projectId)
-      this.lastRead.delete(projectId)
-    } else {
-      this.cache.clear()
-      this.lastRead.clear()
-    }
-  }
-
-  /**
-   * Update data with an updater function (read-modify-write).
-   */
-  async update(projectId: string, updater: (data: T) => T): Promise<T> {
-    const current = await this.read(projectId)
-    const updated = updater(current)
-    await this.write(projectId, updated)
-    return updated
-  }
-
-  /**
-   * Get raw MD content without parsing.
-   */
-  async readRaw(projectId: string): Promise<string> {
-    const filePath = this.getFilePath(projectId)
-    return fileHelper.readFile(filePath, '')
-  }
-
-  /**
-   * Write raw MD content without serialization.
-   */
-  async writeRaw(projectId: string, content: string): Promise<void> {
-    const filePath = this.getFilePath(projectId)
-    await fileHelper.ensureDir(path.dirname(filePath))
-    await fileHelper.atomicWrite(filePath, content)
-    this.clearCache(projectId)
-  }
-}
-
-/**
- * Base manager for array-based MD files (like shipped, ideas).
- */
-export abstract class MdArrayManager<T> extends MdBaseManager<T[]> {
-  protected getDefault(): T[] {
-    return []
-  }
-
-  /**
-   * Add item to array.
-   */
-  async add(projectId: string, item: T): Promise<T[]> {
-    return this.update(projectId, (data) => [...data, item])
-  }
-
-  /**
-   * Prepend item to array (add at beginning).
-   */
-  async prepend(projectId: string, item: T): Promise<T[]> {
-    return this.update(projectId, (data) => [item, ...data])
-  }
-
-  /**
-   * Remove item by predicate.
-   */
-  async remove(projectId: string, predicate: (item: T) => boolean): Promise<T[]> {
-    return this.update(projectId, (data) => data.filter((item) => !predicate(item)))
-  }
-
-  /**
-   * Find item by predicate.
-   */
-  async find(projectId: string, predicate: (item: T) => boolean): Promise<T | undefined> {
-    const data = await this.read(projectId)
-    return data.find(predicate)
-  }
-
-  /**
-   * Update item by predicate.
-   */
-  async updateItem(
-    projectId: string,
-    predicate: (item: T) => boolean,
-    updater: (item: T) => T
-  ): Promise<T[]> {
-    return this.update(projectId, (data) =>
-      data.map((item) => (predicate(item) ? updater(item) : item))
-    )
-  }
-}

package/core/data/md-ideas-manager.ts

@@ -1,155 +0,0 @@
-/**
- * MD Ideas Manager
- *
- * MD-First Architecture: Manages ideas via ideas.md.
- * Source of truth is the markdown file, not JSON.
- */
-
-import { MdArrayManager } from './md-base-manager'
-import { parseIdeas, serializeIdeas, type Idea, type IdeaStatus, type IdeaPriority } from '../serializers/ideas-serializer'
-import { generateUUID } from '../schemas'
-
-class MdIdeasManager extends MdArrayManager<Idea> {
-  constructor() {
-    super('planning/ideas.md')
-  }
-
-  protected parse(content: string): Idea[] {
-    return parseIdeas(content)
-  }
-
-  protected serialize(data: Idea[]): string {
-    return serializeIdeas(data)
-  }
-
-  // =========== Ideas Operations ===========
-
-  /**
-   * Add a new idea
-   */
-  async addIdea(
-    projectId: string,
-    text: string,
-    options?: { tags?: string[]; priority?: IdeaPriority }
-  ): Promise<Idea[]> {
-    const idea: Idea = {
-      id: generateUUID(),
-      text,
-      status: 'pending',
-      priority: options?.priority || 'medium',
-      tags: options?.tags || [],
-      addedAt: new Date().toISOString()
-    }
-
-    return this.add(projectId, idea)
-  }
-
-  /**
-   * Get all ideas
-   */
-  async getAll(projectId: string): Promise<Idea[]> {
-    return this.read(projectId)
-  }
-
-  /**
-   * Get pending ideas
-   */
-  async getPending(projectId: string): Promise<Idea[]> {
-    const all = await this.read(projectId)
-    return all.filter(i => i.status === 'pending')
-  }
-
-  /**
-   * Get idea by ID
-   */
-  async getById(projectId: string, id: string): Promise<Idea | undefined> {
-    return this.find(projectId, i => i.id === id)
-  }
-
-  /**
-   * Convert idea to feature
-   */
-  async convertToFeature(projectId: string, id: string, featureId: string): Promise<Idea[]> {
-    return this.updateItem(
-      projectId,
-      i => i.id === id,
-      i => ({ ...i, status: 'converted' as IdeaStatus, convertedTo: featureId })
-    )
-  }
-
-  /**
-   * Archive an idea
-   */
-  async archive(projectId: string, id: string): Promise<Idea[]> {
-    return this.updateItem(
-      projectId,
-      i => i.id === id,
-      i => ({ ...i, status: 'archived' as IdeaStatus })
-    )
-  }
-
-  /**
-   * Update idea priority
-   */
-  async setPriority(projectId: string, id: string, priority: IdeaPriority): Promise<Idea[]> {
-    return this.updateItem(
-      projectId,
-      i => i.id === id,
-      i => ({ ...i, priority })
-    )
-  }
-
-  /**
-   * Add tags to an idea
-   */
-  async addTags(projectId: string, id: string, tags: string[]): Promise<Idea[]> {
-    return this.updateItem(
-      projectId,
-      i => i.id === id,
-      i => ({ ...i, tags: [...new Set([...i.tags, ...tags])] })
-    )
-  }
-
-  /**
-   * Remove an idea
-   */
-  async removeIdea(projectId: string, id: string): Promise<Idea[]> {
-    return this.remove(projectId, i => i.id === id)
-  }
-
-  /**
-   * Get ideas count by status
-   */
-  async getCounts(projectId: string): Promise<{ pending: number; converted: number; archived: number }> {
-    const all = await this.read(projectId)
-    return {
-      pending: all.filter(i => i.status === 'pending').length,
-      converted: all.filter(i => i.status === 'converted').length,
-      archived: all.filter(i => i.status === 'archived').length
-    }
-  }
-
-  /**
-   * Clean up empty sections (remove archived ideas older than 30 days)
-   */
-  async cleanup(projectId: string): Promise<{ removed: number }> {
-    const thirtyDaysAgo = new Date()
-    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30)
-
-    const all = await this.read(projectId)
-    const toKeep = all.filter(i => {
-      if (i.status !== 'archived') return true
-      return new Date(i.addedAt) > thirtyDaysAgo
-    })
-
-    const removed = all.length - toKeep.length
-    if (removed > 0) {
-      await this.write(projectId, toKeep)
-    }
-
-    return { removed }
-  }
-}
-
-export const mdIdeasManager = new MdIdeasManager()
-export default mdIdeasManager

package/core/data/md-queue-manager.ts

@@ -1,180 +0,0 @@
-/**
- * MD Queue Manager
- *
- * MD-First Architecture: Manages queue via next.md.
- * Source of truth is the markdown file, not JSON.
- */
-
-import { MdBaseManager } from './md-base-manager'
-import { parseQueue, serializeQueue } from '../serializers'
-import { generateUUID } from '../schemas'
-import type { QueueJson, QueueTask, Priority, TaskType, TaskSection } from '../schemas/state'
-
-class MdQueueManager extends MdBaseManager<QueueJson> {
-  constructor() {
-    super('core/next.md')
-  }
-
-  protected getDefault(): QueueJson {
-    return {
-      tasks: [],
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }
-  }
-
-  protected parse(content: string): QueueJson {
-    return parseQueue(content)
-  }
-
-  protected serialize(data: QueueJson): string {
-    return serializeQueue(data)
-  }
-
-  // =========== Queue Operations ===========
-
-  async getTasks(projectId: string): Promise<QueueTask[]> {
-    const queue = await this.read(projectId)
-    return queue.tasks
-  }
-
-  async getActiveTasks(projectId: string): Promise<QueueTask[]> {
-    const queue = await this.read(projectId)
-    return queue.tasks.filter(t => t.section === 'active' && !t.completed)
-  }
-
-  async getBacklog(projectId: string): Promise<QueueTask[]> {
-    const queue = await this.read(projectId)
-    return queue.tasks.filter(t => t.section === 'backlog' && !t.completed)
-  }
-
-  async addTask(
-    projectId: string,
-    task: Omit<QueueTask, 'id' | 'createdAt' | 'completed'>
-  ): Promise<QueueJson> {
-    const newTask: QueueTask = {
-      ...task,
-      id: generateUUID(),
-      createdAt: new Date().toISOString(),
-      completed: false
-    }
-
-    return this.update(projectId, (queue) => ({
-      tasks: this.sortTasks([...queue.tasks, newTask]),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  async removeTask(projectId: string, taskId: string): Promise<QueueJson> {
-    return this.update(projectId, (queue) => ({
-      tasks: queue.tasks.filter(t => t.id !== taskId),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  async completeTask(projectId: string, taskId: string): Promise<QueueJson> {
-    return this.update(projectId, (queue) => ({
-      tasks: queue.tasks.map(t =>
-        t.id === taskId
-          ? { ...t, completed: true, completedAt: new Date().toISOString() }
-          : t
-      ),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  async getNextTask(projectId: string): Promise<QueueTask | null> {
-    const queue = await this.read(projectId)
-    return queue.tasks.find(t => t.section === 'active' && !t.completed) || null
-  }
-
-  async moveToSection(
-    projectId: string,
-    taskId: string,
-    section: TaskSection
-  ): Promise<QueueJson> {
-    return this.update(projectId, (queue) => ({
-      tasks: queue.tasks.map(t =>
-        t.id === taskId ? { ...t, section } : t
-      ),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  async setPriority(
-    projectId: string,
-    taskId: string,
-    priority: Priority
-  ): Promise<QueueJson> {
-    return this.update(projectId, (queue) => ({
-      tasks: this.sortTasks(
-        queue.tasks.map(t => t.id === taskId ? { ...t, priority } : t)
-      ),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  /**
-   * Add multiple tasks at once (e.g., from a feature breakdown)
-   */
-  async addTasks(
-    projectId: string,
-    tasks: Array<Omit<QueueTask, 'id' | 'createdAt' | 'completed'>>
-  ): Promise<QueueJson> {
-    const newTasks: QueueTask[] = tasks.map((task) => ({
-      ...task,
-      id: generateUUID(),
-      createdAt: new Date().toISOString(),
-      completed: false
-    }))
-
-    return this.update(projectId, (queue) => ({
-      tasks: this.sortTasks([...queue.tasks, ...newTasks]),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  /**
-   * Clear completed tasks
-   */
-  async clearCompleted(projectId: string): Promise<QueueJson> {
-    return this.update(projectId, (queue) => ({
-      tasks: queue.tasks.filter(t => !t.completed),
-      lastUpdated: new Date().toISOString().split('T')[0]
-    }))
-  }
-
-  /**
-   * Sort tasks by priority then by creation date
-   */
-  private sortTasks(tasks: QueueTask[]): QueueTask[] {
-    const priorityOrder: Record<Priority, number> = {
-      critical: 0,
-      high: 1,
-      medium: 2,
-      low: 3
-    }
-
-    return tasks.sort((a, b) => {
-      // First by section (active first)
-      const sectionOrder: Record<TaskSection, number> = {
-        active: 0,
-        previously_active: 1,
-        backlog: 2
-      }
-      if (sectionOrder[a.section] !== sectionOrder[b.section]) {
-        return sectionOrder[a.section] - sectionOrder[b.section]
-      }
-
-      // Then by priority
-      if (priorityOrder[a.priority] !== priorityOrder[b.priority]) {
-        return priorityOrder[a.priority] - priorityOrder[b.priority]
-      }
-
-      // Finally by creation date
-      return new Date(a.createdAt).getTime() - new Date(b.createdAt).getTime()
-    })
-  }
-}
-
-export const mdQueueManager = new MdQueueManager()
-export default mdQueueManager

package/core/data/md-shipped-manager.ts

@@ -1,90 +0,0 @@
-/**
- * MD Shipped Manager
- *
- * MD-First Architecture: Manages shipped features via shipped.md.
- * Source of truth is the markdown file, not JSON.
- */
-
-import { MdArrayManager } from './md-base-manager'
-import { parseShipped, serializeShipped, type ShippedFeature } from '../serializers/shipped-serializer'
-import { generateUUID } from '../schemas'
-
-class MdShippedManager extends MdArrayManager<ShippedFeature> {
-  constructor() {
-    super('progress/shipped.md')
-  }
-
-  protected parse(content: string): ShippedFeature[] {
-    return parseShipped(content)
-  }
-
-  protected serialize(data: ShippedFeature[]): string {
-    return serializeShipped(data)
-  }
-
-  // =========== Shipped Features ===========
-
-  /**
-   * Add a shipped feature
-   */
-  async addShipped(
-    projectId: string,
-    feature: Omit<ShippedFeature, 'id' | 'shippedAt'>
-  ): Promise<ShippedFeature[]> {
-    const shippedFeature: ShippedFeature = {
-      ...feature,
-      id: generateUUID(),
-      shippedAt: new Date().toISOString()
-    }
-
-    return this.prepend(projectId, shippedFeature)
-  }
-
-  /**
-   * Get all shipped features
-   */
-  async getAll(projectId: string): Promise<ShippedFeature[]> {
-    return this.read(projectId)
-  }
-
-  /**
-   * Get recent shipped features (last N)
-   */
-  async getRecent(projectId: string, limit: number = 5): Promise<ShippedFeature[]> {
-    const all = await this.read(projectId)
-    return all.slice(0, limit)
-  }
-
-  /**
-   * Get shipped features by version
-   */
-  async getByVersion(projectId: string, version: string): Promise<ShippedFeature | undefined> {
-    return this.find(projectId, (f) => f.version === version)
-  }
-
-  /**
-   * Get shipped features count
-   */
-  async getCount(projectId: string): Promise<number> {
-    const all = await this.read(projectId)
-    return all.length
-  }
-
-  /**
-   * Get shipped features for a date range
-   */
-  async getByDateRange(
-    projectId: string,
-    startDate: Date,
-    endDate: Date
-  ): Promise<ShippedFeature[]> {
-    const all = await this.read(projectId)
-    return all.filter((f) => {
-      const date = new Date(f.shippedAt)
-      return date >= startDate && date <= endDate
-    })
-  }
-}
-
-export const mdShippedManager = new MdShippedManager()
-export default mdShippedManager