prjct-cli 0.13.2 → 0.15.0

package/core/storage/ideas-storage.ts

@@ -0,0 +1,273 @@
+/**
+ * Ideas Storage
+ *
+ * Manages ideas via storage/ideas.json
+ * Generates context/ideas.md for Claude
+ */
+
+import { StorageManager } from './storage-manager'
+import { generateUUID } from '../schemas'
+
+export type IdeaStatus = 'pending' | 'converted' | 'archived'
+export type IdeaPriority = 'low' | 'medium' | 'high'
+
+export interface Idea {
+  id: string
+  text: string
+  status: IdeaStatus
+  priority: IdeaPriority
+  tags: string[]
+  addedAt: string
+  convertedTo?: string // featureId if converted
+}
+
+export interface IdeasJson {
+  ideas: Idea[]
+  lastUpdated: string
+}
+
+class IdeasStorage extends StorageManager<IdeasJson> {
+  constructor() {
+    super('ideas.json')
+  }
+
+  protected getDefault(): IdeasJson {
+    return {
+      ideas: [],
+      lastUpdated: ''
+    }
+  }
+
+  protected getMdFilename(): string {
+    return 'ideas.md'
+  }
+
+  protected getEventType(action: 'update' | 'create' | 'delete'): string {
+    return `ideas.${action}d`
+  }
+
+  protected toMarkdown(data: IdeasJson): string {
+    const lines = ['# IDEAS \u{1F4A1}', '']
+
+    const pending = data.ideas.filter(i => i.status === 'pending')
+    const converted = data.ideas.filter(i => i.status === 'converted')
+    const archived = data.ideas.filter(i => i.status === 'archived')
+
+    // Brain Dump (pending)
+    lines.push('## Brain Dump')
+    if (pending.length > 0) {
+      pending.forEach(idea => {
+        const date = idea.addedAt.split('T')[0]
+        const tags = idea.tags.length > 0 ? ' ' + idea.tags.map(t => `#${t}`).join(' ') : ''
+        const priority = idea.priority !== 'medium' ? ` [${idea.priority.toUpperCase()}]` : ''
+        lines.push(`- ${idea.text}${priority} _(${date})_${tags}`)
+      })
+    } else {
+      lines.push('_No pending ideas_')
+    }
+    lines.push('')
+
+    // Converted
+    if (converted.length > 0) {
+      lines.push('## Converted')
+      converted.forEach(idea => {
+        const date = idea.addedAt.split('T')[0]
+        const feat = idea.convertedTo ? ` \u2192 ${idea.convertedTo}` : ''
+        lines.push(`- \u2713 ${idea.text}${feat} _(${date})_`)
+      })
+      lines.push('')
+    }
+
+    // Archived
+    if (archived.length > 0) {
+      lines.push('## Archived')
+      archived.forEach(idea => {
+        const date = idea.addedAt.split('T')[0]
+        lines.push(`- ${idea.text} _(${date})_`)
+      })
+      lines.push('')
+    }
+
+    return lines.join('\n')
+  }
+
+  // =========== Domain Methods ===========
+
+  /**
+   * Get all ideas
+   */
+  async getAll(projectId: string): Promise<Idea[]> {
+    const data = await this.read(projectId)
+    return data.ideas
+  }
+
+  /**
+   * Get pending ideas
+   */
+  async getPending(projectId: string): Promise<Idea[]> {
+    const data = await this.read(projectId)
+    return data.ideas.filter(i => i.status === 'pending')
+  }
+
+  /**
+   * 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()
+    }
+
+    await this.update(projectId, (data) => ({
+      ideas: [idea, ...data.ideas], // Prepend new ideas
+      lastUpdated: new Date().toISOString()
+    }))
+
+    // Publish event
+    await this.publishEvent(projectId, 'idea.created', {
+      ideaId: idea.id,
+      text: idea.text,
+      priority: idea.priority
+    })
+
+    return idea
+  }
+
+  /**
+   * Get idea by ID
+   */
+  async getById(projectId: string, id: string): Promise<Idea | undefined> {
+    const data = await this.read(projectId)
+    return data.ideas.find(i => i.id === id)
+  }
+
+  /**
+   * Convert idea to feature
+   */
+  async convertToFeature(
+    projectId: string,
+    ideaId: string,
+    featureId: string
+  ): Promise<void> {
+    await this.update(projectId, (data) => ({
+      ideas: data.ideas.map(i =>
+        i.id === ideaId
+          ? { ...i, status: 'converted' as IdeaStatus, convertedTo: featureId }
+          : i
+      ),
+      lastUpdated: new Date().toISOString()
+    }))
+
+    await this.publishEvent(projectId, 'idea.converted', {
+      ideaId,
+      featureId
+    })
+  }
+
+  /**
+   * Archive an idea
+   */
+  async archive(projectId: string, ideaId: string): Promise<void> {
+    await this.update(projectId, (data) => ({
+      ideas: data.ideas.map(i =>
+        i.id === ideaId ? { ...i, status: 'archived' as IdeaStatus } : i
+      ),
+      lastUpdated: new Date().toISOString()
+    }))
+
+    await this.publishEvent(projectId, 'idea.archived', { ideaId })
+  }
+
+  /**
+   * Set priority
+   */
+  async setPriority(
+    projectId: string,
+    ideaId: string,
+    priority: IdeaPriority
+  ): Promise<void> {
+    await this.update(projectId, (data) => ({
+      ideas: data.ideas.map(i =>
+        i.id === ideaId ? { ...i, priority } : i
+      ),
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Add tags to an idea
+   */
+  async addTags(
+    projectId: string,
+    ideaId: string,
+    tags: string[]
+  ): Promise<void> {
+    await this.update(projectId, (data) => ({
+      ideas: data.ideas.map(i =>
+        i.id === ideaId
+          ? { ...i, tags: [...new Set([...i.tags, ...tags])] }
+          : i
+      ),
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Remove an idea
+   */
+  async removeIdea(projectId: string, ideaId: string): Promise<void> {
+    await this.update(projectId, (data) => ({
+      ideas: data.ideas.filter(i => i.id !== ideaId),
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Get counts by status
+   */
+  async getCounts(projectId: string): Promise<{ pending: number; converted: number; archived: number }> {
+    const data = await this.read(projectId)
+    return {
+      pending: data.ideas.filter(i => i.status === 'pending').length,
+      converted: data.ideas.filter(i => i.status === 'converted').length,
+      archived: data.ideas.filter(i => i.status === 'archived').length
+    }
+  }
+
+  /**
+   * Cleanup old archived ideas (keep last 50)
+   */
+  async cleanup(projectId: string): Promise<{ removed: number }> {
+    const data = await this.read(projectId)
+    const archived = data.ideas.filter(i => i.status === 'archived')
+
+    if (archived.length <= 50) {
+      return { removed: 0 }
+    }
+
+    // Sort by date and keep newest 50
+    const sortedArchived = archived.sort(
+      (a, b) => new Date(b.addedAt).getTime() - new Date(a.addedAt).getTime()
+    )
+    const toRemove = new Set(sortedArchived.slice(50).map(i => i.id))
+    const removed = toRemove.size
+
+    await this.update(projectId, (d) => ({
+      ideas: d.ideas.filter(i => !toRemove.has(i.id)),
+      lastUpdated: new Date().toISOString()
+    }))
+
+    return { removed }
+  }
+}
+
+export const ideasStorage = new IdeasStorage()
+export default ideasStorage

package/core/storage/index.ts

@@ -0,0 +1,204 @@
+/**
+ * Storage Layer
+ *
+ * Two storage patterns:
+ *
+ * 1. AGGREGATE STORAGE (Write-Through Pattern)
+ *    For main state - writes JSON + regenerates MD + publishes events
+ *    - stateStorage: storage/state.json → context/now.md
+ *    - queueStorage: storage/queue.json → context/next.md
+ *    - ideasStorage: storage/ideas.json → context/ideas.md
+ *    - shippedStorage: storage/shipped.json → context/shipped.md
+ *
+ * 2. GRANULAR STORAGE (OpenCode-style) - Legacy
+ *    For future per-entity storage
+ *    - getStorage(projectId): data/{entity}s/{id}.json
+ *
+ * Structure:
+ * ~/.prjct-cli/projects/{projectId}/
+ * ├── storage/              # Aggregate JSON (source of truth)
+ * │   ├── state.json
+ * │   ├── queue.json
+ * │   ├── ideas.json
+ * │   └── shipped.json
+ * ├── context/              # Generated MD (for Claude)
+ * │   ├── CLAUDE.md
+ * │   ├── now.md
+ * │   ├── next.md
+ * │   ├── ideas.md
+ * │   └── shipped.md
+ * ├── data/                 # Granular JSON (legacy/future)
+ * │   └── ...
+ * └── sync/                 # Backend sync
+ *     ├── pending.json
+ *     └── last-sync.json
+ */
+
+// ========== AGGREGATE STORAGE (Recommended) ==========
+export { StorageManager } from './storage-manager'
+export { stateStorage } from './state-storage'
+export { queueStorage } from './queue-storage'
+export { ideasStorage, type Idea, type IdeasJson, type IdeaStatus, type IdeaPriority } from './ideas-storage'
+export { shippedStorage, type ShippedFeature, type ShippedJson } from './shipped-storage'
+
+// ========== GRANULAR STORAGE (Legacy) ==========
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { eventBus, inferEventType } from '../events'
+
+export interface Storage {
+  write<T>(path: string[], data: T): Promise<void>
+  read<T>(path: string[]): Promise<T | null>
+  list(prefix: string[]): Promise<string[][]>
+  delete(path: string[]): Promise<void>
+  exists(path: string[]): Promise<boolean>
+}
+
+class FileStorage implements Storage {
+  private projectId: string
+  private basePath: string
+
+  constructor(projectId: string) {
+    this.projectId = projectId
+    this.basePath = path.join(os.homedir(), '.prjct-cli/projects', projectId, 'data')
+  }
+
+  /**
+   * Convert path array to file path
+   * ["task", "abc123"] → data/tasks/abc123.json
+   * ["project"] → data/project.json
+   */
+  private pathToFile(pathArray: string[]): string {
+    if (pathArray.length === 1) {
+      return path.join(this.basePath, `${pathArray[0]}.json`)
+    }
+
+    // Pluralize first segment for directory
+    const dir = pathArray[0] + 's'
+    const rest = pathArray.slice(1)
+    const filename = rest.join('/') + '.json'
+
+    return path.join(this.basePath, dir, filename)
+  }
+
+  async write<T>(pathArray: string[], data: T): Promise<void> {
+    const filePath = this.pathToFile(pathArray)
+
+    // Ensure directory exists
+    await fs.mkdir(path.dirname(filePath), { recursive: true })
+
+    // Write data
+    await fs.writeFile(filePath, JSON.stringify(data, null, 2), 'utf-8')
+
+    // Publish event for sync
+    eventBus.publish({
+      type: inferEventType(pathArray, 'write'),
+      path: pathArray,
+      data,
+      timestamp: new Date().toISOString(),
+      projectId: this.projectId
+    })
+
+    // Update index if it's a collection item
+    if (pathArray.length === 2) {
+      await this.updateIndex(pathArray[0], pathArray[1], 'add')
+    }
+  }
+
+  async read<T>(pathArray: string[]): Promise<T | null> {
+    const filePath = this.pathToFile(pathArray)
+
+    try {
+      const content = await fs.readFile(filePath, 'utf-8')
+      return JSON.parse(content) as T
+    } catch {
+      return null
+    }
+  }
+
+  async list(prefix: string[]): Promise<string[][]> {
+    const dir = path.join(this.basePath, prefix[0] + 's')
+
+    try {
+      const files = await fs.readdir(dir)
+      return files
+        .filter(f => f.endsWith('.json') && f !== 'index.json')
+        .map(f => [...prefix, f.replace('.json', '')])
+    } catch {
+      return []
+    }
+  }
+
+  async delete(pathArray: string[]): Promise<void> {
+    const filePath = this.pathToFile(pathArray)
+
+    try {
+      await fs.unlink(filePath)
+
+      // Publish event for sync
+      eventBus.publish({
+        type: inferEventType(pathArray, 'delete'),
+        path: pathArray,
+        data: null,
+        timestamp: new Date().toISOString(),
+        projectId: this.projectId
+      })
+
+      // Update index if it's a collection item
+      if (pathArray.length === 2) {
+        await this.updateIndex(pathArray[0], pathArray[1], 'remove')
+      }
+    } catch {
+      // File doesn't exist, ignore
+    }
+  }
+
+  async exists(pathArray: string[]): Promise<boolean> {
+    const filePath = this.pathToFile(pathArray)
+
+    try {
+      await fs.access(filePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Update collection index
+   */
+  private async updateIndex(collection: string, id: string, action: 'add' | 'remove'): Promise<void> {
+    const indexPath = path.join(this.basePath, collection + 's', 'index.json')
+
+    let index: { ids: string[]; updatedAt: string } = { ids: [], updatedAt: '' }
+
+    try {
+      const content = await fs.readFile(indexPath, 'utf-8')
+      index = JSON.parse(content)
+    } catch {
+      // Index doesn't exist yet
+    }
+
+    if (action === 'add' && !index.ids.includes(id)) {
+      index.ids.push(id)
+    } else if (action === 'remove') {
+      index.ids = index.ids.filter(i => i !== id)
+    }
+
+    index.updatedAt = new Date().toISOString()
+
+    await fs.mkdir(path.dirname(indexPath), { recursive: true })
+    await fs.writeFile(indexPath, JSON.stringify(index, null, 2), 'utf-8')
+  }
+}
+
+/**
+ * Get storage instance for a project
+ */
+export function getStorage(projectId: string): Storage {
+  return new FileStorage(projectId)
+}
+
+export default { getStorage }