prjct-cli 0.13.3 → 0.15.0

package/core/outcomes/recorder.ts

@@ -8,6 +8,7 @@
 import path from 'path'
 import * as fileHelper from '../utils/file-helper'
 import pathManager from '../infrastructure/path-manager'
+import { generateUUID } from '../schemas'
 import type { Outcome, OutcomeInput, OutcomeFilter } from './types'
 
 const OUTCOMES_DIR = 'outcomes'
@@ -38,7 +39,7 @@ export class OutcomeRecorder {
   async record(projectId: string, input: OutcomeInput): Promise<Outcome> {
     const outcome: Outcome = {
       ...input,
-      id: `outcome_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`,
+      id: generateUUID(),
     }
 
     const outcomesPath = this.getOutcomesPath(projectId)

package/core/plugin/loader.ts

@@ -167,8 +167,9 @@ class PluginLoader {
       // Check if file exists
       await fs.access(pluginPath)
 
-      // Require the plugin
-      const plugin: Plugin = require(pluginPath)
+      // Import the plugin dynamically
+      const pluginModule = await import(pluginPath)
+      const plugin: Plugin = pluginModule.default || pluginModule
 
       // Validate plugin structure
       if (!plugin.name) {
@@ -259,11 +260,7 @@ class PluginLoader {
     // Remove from loaded plugins
     this.plugins.delete(name)
 
-    // Clear require cache
-    const pluginPath = this.pluginPaths.get(name)
-    if (pluginPath) {
-      delete require.cache[require.resolve(pluginPath)]
-    }
+    // Clear plugin path reference
     this.pluginPaths.delete(name)
   }
 

package/core/plugin/registry.ts

@@ -122,9 +122,9 @@ class PluginRegistry {
         }
       }
 
-      // Fallback: try to require (might have side effects)
-      const plugin = require(pluginPath)
-      delete require.cache[require.resolve(pluginPath)]
+      // Fallback: try to import (might have side effects)
+      const pluginModule = await import(pluginPath)
+      const plugin = pluginModule.default || pluginModule
 
       if (plugin.name) {
         return {

package/core/schemas/index.ts

@@ -1,11 +1,15 @@
 /**
  * Schemas Module
  *
- * TypeScript types and defaults for all JSON data files.
- * These schemas define the source-of-truth for all project data.
+ * TypeScript types and defaults for all project data.
+ * MD-First Architecture: Markdown files are the source of truth.
  *
- * Data lives in: ~/.prjct-cli/projects/{projectId}/data/
- * Views are generated in: ~/.prjct-cli/projects/{projectId}/views/
+ * Structure: ~/.prjct-cli/projects/{projectId}/
+ *   - core/     (now.md, next.md, context.md)
+ *   - progress/ (shipped.md, metrics.md)
+ *   - planning/ (ideas.md, roadmap.md, tasks/)
+ *   - analysis/ (repo-summary.md)
+ *   - memory/   (context.jsonl, patterns.json)
  */
 
 // State (current task + queue)
@@ -33,23 +37,25 @@ export * from './analysis'
 export * from './outcomes'
 
 // ============================================
-// ID GENERATORS
+// ID GENERATORS - UUID ONLY
 // ============================================
 
-function generateId(prefix: string): string {
-  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
-  let id = ''
-  for (let i = 0; i < 8; i++) {
-    id += chars[Math.floor(Math.random() * chars.length)]
-  }
-  return `${prefix}_${id}`
+import crypto from 'crypto'
+
+/**
+ * Generate a standard UUID.
+ * All IDs in the system use this format for PostgreSQL consistency.
+ */
+export function generateUUID(): string {
+  return crypto.randomUUID()
 }
 
-export const generateTaskId = (): string => generateId('task')
-export const generateFeatureId = (): string => generateId('feat')
-export const generateIdeaId = (): string => generateId('idea')
-export const generateShipId = (): string => generateId('ship')
-export const generateSessionId = (): string => generateId('sess')
+// All use the same UUID generator
+export const generateTaskId = generateUUID
+export const generateFeatureId = generateUUID
+export const generateIdeaId = generateUUID
+export const generateShipId = generateUUID
+export const generateSessionId = generateUUID
 
 // ============================================
 // PATH HELPERS
@@ -63,11 +69,3 @@ export const GLOBAL_STORAGE = join(homedir(), '.prjct-cli', 'projects')
 export function getProjectPath(projectId: string): string {
   return join(GLOBAL_STORAGE, projectId)
 }
-
-export function getDataPath(projectId: string): string {
-  return join(GLOBAL_STORAGE, projectId, 'data')
-}
-
-export function getViewsPath(projectId: string): string {
-  return join(GLOBAL_STORAGE, projectId, 'views')
-}

package/core/schemas/state.ts

@@ -25,6 +25,7 @@ export interface PreviousTask {
   status: 'paused'
   startedAt: string           // ISO8601
   pausedAt: string            // ISO8601
+  pauseReason?: string        // Optional reason for pausing
 }
 
 // StateJson is the wrapper for state.json file

package/core/serializers/ideas-serializer.ts

@@ -0,0 +1,187 @@
+/**
+ * Ideas Serializer
+ *
+ * Parses and serializes ideas.md for idea backlog.
+ *
+ * MD Format (ideas.md):
+ * ```
+ * # IDEAS 💡
+ *
+ * ## Brain Dump
+ *
+ * - Add dark mode _(2025-12-10)_ #ui #enhancement
+ * - Improve caching _(2025-12-09)_ #performance
+ *
+ * ## Converted
+ *
+ * - ✓ Add user auth → feat_123 _(2025-12-08)_
+ * ```
+ */
+
+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         // ISO8601
+  convertedTo?: string    // featureId if converted
+}
+
+/**
+ * Parse ideas.md content to Idea[]
+ */
+export function parseIdeas(content: string): Idea[] {
+  if (!content || !content.trim()) {
+    return []
+  }
+
+  const ideas: Idea[] = []
+
+  // Split by sections
+  const sections = content.split(/\n## /).slice(1)
+
+  for (const section of sections) {
+    const lines = section.trim().split('\n')
+    const sectionName = lines[0]?.trim().toLowerCase() || ''
+
+    // Determine status based on section
+    let status: IdeaStatus = 'pending'
+    if (sectionName.includes('converted')) {
+      status = 'converted'
+    } else if (sectionName.includes('archived')) {
+      status = 'archived'
+    }
+
+    // Parse list items
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim()
+      if (!line.startsWith('-')) continue
+
+      const itemText = line.slice(1).trim()
+      if (!itemText) continue
+
+      // Extract date: _(date)_
+      const dateMatch = itemText.match(/_\((.+?)\)_/)
+      const addedAt = dateMatch ? dateMatch[1].trim() : new Date().toISOString()
+
+      // Extract tags: #tag1 #tag2
+      const tags = (itemText.match(/#(\w+)/g) || []).map(t => t.slice(1))
+
+      // Extract converted feature id: → feat_123
+      const convertedMatch = itemText.match(/→\s*(\w+)/)
+      const convertedTo = convertedMatch ? convertedMatch[1] : undefined
+
+      // Clean text: remove date, tags, and conversion marker
+      let text = itemText
+        .replace(/_\(.+?\)_/g, '')
+        .replace(/#\w+/g, '')
+        .replace(/→\s*\w+/g, '')
+        .replace(/^✓\s*/, '')
+        .trim()
+
+      // Detect priority from keywords
+      let priority: IdeaPriority = 'medium'
+      if (text.toLowerCase().includes('urgent') || text.toLowerCase().includes('critical')) {
+        priority = 'high'
+      } else if (text.toLowerCase().includes('nice to have') || text.toLowerCase().includes('maybe')) {
+        priority = 'low'
+      }
+
+      ideas.push({
+        id: `idea_${Date.parse(addedAt) || Date.now()}_${i}`,
+        text,
+        status,
+        priority,
+        tags,
+        addedAt,
+        convertedTo
+      })
+    }
+  }
+
+  return ideas
+}
+
+/**
+ * Serialize Idea[] to ideas.md format
+ */
+export function serializeIdeas(ideas: Idea[]): string {
+  const lines: string[] = ['# IDEAS 💡', '']
+
+  const pending = ideas.filter(i => i.status === 'pending')
+  const converted = ideas.filter(i => i.status === 'converted')
+  const archived = ideas.filter(i => i.status === 'archived')
+
+  // Brain Dump section (pending ideas)
+  lines.push('## Brain Dump', '')
+
+  if (pending.length === 0) {
+    lines.push('_No pending ideas. Use `/p:idea` to capture one._', '')
+  } else {
+    // Sort by addedAt descending (newest first)
+    const sorted = [...pending].sort(
+      (a, b) => new Date(b.addedAt).getTime() - new Date(a.addedAt).getTime()
+    )
+
+    for (const idea of sorted) {
+      const tagsStr = idea.tags.length > 0 ? ' ' + idea.tags.map(t => `#${t}`).join(' ') : ''
+      const dateStr = formatDate(idea.addedAt)
+      lines.push(`- ${idea.text} _(${dateStr})_${tagsStr}`)
+    }
+    lines.push('')
+  }
+
+  // Converted section
+  if (converted.length > 0) {
+    lines.push('## Converted', '')
+    const sorted = [...converted].sort(
+      (a, b) => new Date(b.addedAt).getTime() - new Date(a.addedAt).getTime()
+    )
+
+    for (const idea of sorted) {
+      const convStr = idea.convertedTo ? ` → ${idea.convertedTo}` : ''
+      const dateStr = formatDate(idea.addedAt)
+      lines.push(`- ✓ ${idea.text}${convStr} _(${dateStr})_`)
+    }
+    lines.push('')
+  }
+
+  // Archived section
+  if (archived.length > 0) {
+    lines.push('## Archived', '')
+    const sorted = [...archived].sort(
+      (a, b) => new Date(b.addedAt).getTime() - new Date(a.addedAt).getTime()
+    )
+
+    for (const idea of sorted) {
+      const dateStr = formatDate(idea.addedAt)
+      lines.push(`- ${idea.text} _(${dateStr})_`)
+    }
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Format date for display
+ */
+function formatDate(isoDate: string): string {
+  try {
+    const date = new Date(isoDate)
+    return date.toISOString().split('T')[0] // YYYY-MM-DD
+  } catch {
+    return isoDate
+  }
+}
+
+/**
+ * Create empty ideas.md
+ */
+export function createEmptyIdeasMd(): string {
+  return serializeIdeas([])
+}

package/core/serializers/index.ts

@@ -18,3 +18,19 @@ export {
   serializeQueue,
   createEmptyQueueMd
 } from './queue-serializer'
+
+// Shipped (shipped.md)
+export {
+  parseShipped,
+  serializeShipped,
+  createEmptyShippedMd
+} from './shipped-serializer'
+export type { ShippedFeature } from './shipped-serializer'
+
+// Ideas (ideas.md)
+export {
+  parseIdeas,
+  serializeIdeas,
+  createEmptyIdeasMd
+} from './ideas-serializer'
+export type { Idea, IdeaStatus, IdeaPriority } from './ideas-serializer'

package/core/serializers/shipped-serializer.ts

@@ -0,0 +1,108 @@
+/**
+ * Shipped Serializer
+ *
+ * Parses and serializes shipped.md for shipped features.
+ *
+ * MD Format (shipped.md):
+ * ```
+ * # SHIPPED 🚀
+ *
+ * ## Feature Name
+ *
+ * Shipped: 2025-12-10T10:00:00.000Z
+ * Version: 0.1.5
+ *
+ * ## Another Feature
+ *
+ * Shipped: 2025-12-09T14:30:00.000Z
+ * Version: 0.1.4
+ * ```
+ */
+
+export interface ShippedFeature {
+  id: string
+  name: string
+  shippedAt: string      // ISO8601
+  version: string
+  description?: string
+}
+
+/**
+ * Parse shipped.md content to ShippedFeature[]
+ */
+export function parseShipped(content: string): ShippedFeature[] {
+  if (!content || !content.trim()) {
+    return []
+  }
+
+  const features: ShippedFeature[] = []
+  const sections = content.split(/\n## /).slice(1) // Skip header
+
+  for (const section of sections) {
+    const lines = section.trim().split('\n')
+    const name = lines[0]?.trim()
+
+    if (!name) continue
+
+    const shippedMatch = section.match(/Shipped:\s*(.+)/i)
+    const versionMatch = section.match(/Version:\s*(.+)/i)
+
+    const shippedAt = shippedMatch ? shippedMatch[1].trim() : new Date().toISOString()
+    const version = versionMatch ? versionMatch[1].trim() : '0.0.0'
+
+    // Extract description (lines between name and metadata)
+    const descLines: string[] = []
+    for (let i = 1; i < lines.length; i++) {
+      const line = lines[i].trim()
+      if (line.startsWith('Shipped:') || line.startsWith('Version:') || !line) break
+      descLines.push(line)
+    }
+
+    features.push({
+      id: `ship_${Date.parse(shippedAt) || Date.now()}`,
+      name,
+      shippedAt,
+      version,
+      description: descLines.join(' ') || undefined
+    })
+  }
+
+  return features
+}
+
+/**
+ * Serialize ShippedFeature[] to shipped.md format
+ */
+export function serializeShipped(features: ShippedFeature[]): string {
+  const lines: string[] = ['# SHIPPED 🚀', '']
+
+  if (features.length === 0) {
+    lines.push('_No features shipped yet._', '')
+    lines.push('Use `/p:ship` to celebrate your first ship!')
+    return lines.join('\n')
+  }
+
+  // Sort by shippedAt descending (newest first)
+  const sorted = [...features].sort(
+    (a, b) => new Date(b.shippedAt).getTime() - new Date(a.shippedAt).getTime()
+  )
+
+  for (const feature of sorted) {
+    lines.push(`## ${feature.name}`, '')
+    if (feature.description) {
+      lines.push(feature.description, '')
+    }
+    lines.push(`Shipped: ${feature.shippedAt}`)
+    lines.push(`Version: ${feature.version}`)
+    lines.push('')
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Create empty shipped.md
+ */
+export function createEmptyShippedMd(): string {
+  return serializeShipped([])
+}

package/core/session/utils.ts

@@ -3,18 +3,12 @@
  */
 
 import type { Session, TimelineEvent } from './types'
+import { generateUUID } from '../schemas'
 
 /**
- * Generate unique session ID
+ * Generate unique session ID (re-export from schemas)
  */
-export function generateId(): string {
-  const chars = 'abcdefghijklmnopqrstuvwxyz0123456789'
-  let id = 'sess_'
-  for (let i = 0; i < 8; i++) {
-    id += chars.charAt(Math.floor(Math.random() * chars.length))
-  }
-  return id
-}
+export const generateId = generateUUID
 
 /**
  * Calculate total duration in seconds