prjct-cli 0.13.3 → 0.15.1

package/core/context-sync.ts

@@ -1,360 +1,17 @@
 /**
- * Context Sync - Generates RICH dynamic project context for Claude
+ * Context Sync
  *
- * Creates ~/.prjct-cli/projects/{id}/CLAUDE.md with:
- * - Full stack info (languages, frameworks, dependencies)
- * - Project structure and stats
- * - Agent expertise summaries
- * - Current task and priority queue
- * - Active features from roadmap
- *
- * GOAL: Give Claude ALL the context it needs WITHOUT extra file reads
- *
- * Called by: /p:sync, /p:analyze, /p:init
- */
-
-import fs from 'fs/promises'
-import path from 'path'
-import os from 'os'
-
-interface StackInfo {
-  primary: string | null
-  full: string | null
-  languages: string[]
-  frameworks: string[]
-  dependencies: string[]
-}
-
-interface ProjectStructure {
-  fileCount: number | null
-  directories: string[]
-}
-
-interface GitCommit {
-  hash: string
-  message: string
-}
-
-interface GitStats {
-  commits: number | null
-  contributors: number | null
-  recentCommits: GitCommit[]
-}
-
-interface AgentExpertise {
-  name: string
-  role: string
-  expertise: string
-}
-
-interface ContextResult {
-  agents: string[]
-  stack: StackInfo
-  currentTask: string | null
-}
-
-/**
- * Generate RICH project context file for Claude
- * Embeds key information so Claude doesn't need to read multiple files
- */
-async function generateLocalContext(projectPath: string, projectId: string): Promise<ContextResult> {
-  const globalPath = path.join(os.homedir(), '.prjct-cli/projects', projectId)
-  const projectName = path.basename(projectPath)
-
-  // Helper to read files safely
-  const readSafe = async (p: string): Promise<string | null> => {
-    try {
-      return await fs.readFile(p, 'utf-8')
-    } catch {
-      return null
-    }
-  }
-
-  // 1. Read ALL data sources in parallel
-  const agentsDir = path.join(globalPath, 'agents')
-  let agentFiles: string[] = []
-  try {
-    agentFiles = await fs.readdir(agentsDir)
-    agentFiles = agentFiles.filter(f => f.endsWith('.md'))
-  } catch {
-    // No agents directory yet
-  }
-
-  const [repoSummary, now, next, roadmap, ideas] = await Promise.all([
-    readSafe(path.join(globalPath, 'analysis/repo-summary.md')),
-    readSafe(path.join(globalPath, 'core/now.md')),
-    readSafe(path.join(globalPath, 'core/next.md')),
-    readSafe(path.join(globalPath, 'planning/roadmap.md')),
-    readSafe(path.join(globalPath, 'planning/ideas.md'))
-  ])
-
-  // 2. Extract RICH stack info from repo-summary
-  const stackInfo = extractFullStack(repoSummary)
-
-  // 3. Extract project structure from repo-summary
-  const projectStructure = extractProjectStructure(repoSummary)
-
-  // 4. Extract git stats
-  const gitStats = extractGitStats(repoSummary)
-
-  // 5. Read agent expertise (just the key parts, not full templates)
-  const agentExpertise = await extractAgentExpertise(agentsDir, agentFiles)
-
-  // 6. Extract current task
-  const currentTask = extractCurrentTask(now)
-
-  // 7. Extract priority queue (top 5)
-  const nextTasks = extractTopTasks(next, 5)
-
-  // 8. Extract active features from roadmap
-  const activeFeatures = extractActiveFeatures(roadmap)
-
-  // 9. Extract recent ideas
-  const recentIdeas = extractRecentIdeas(ideas)
-
-  // 10. Generate RICH CLAUDE.md content
-  const content = `# ${projectName} - Project Context
-<!-- Auto-generated by /p:sync - DO NOT EDIT MANUALLY -->
-<!-- projectId: ${projectId} -->
-<!-- Last sync: ${new Date().toISOString()} -->
-
-## Quick Reference
-
-| Attribute | Value |
-|-----------|-------|
-| **Project** | ${projectName} |
-| **Stack** | ${stackInfo.primary || 'Not detected'} |
-| **Files** | ${projectStructure.fileCount || '?'} |
-| **Commits** | ${gitStats.commits || '?'} |
-| **Contributors** | ${gitStats.contributors || '?'} |
-
-## Tech Stack
-
-${stackInfo.full || 'Run /p:analyze to detect stack'}
-
-## Project Structure
-
-${projectStructure.directories?.length ? projectStructure.directories.map(d => `- \`${d}/\``).join('\n') : 'Run /p:analyze to detect structure'}
-
-## Available Agents
-
-${agentExpertise.length ? agentExpertise.map(a => `### ${a.name}
-- **Role**: ${a.role}
-- **Expertise**: ${a.expertise}
-`).join('\n') : 'None. Run /p:sync to generate agents.'}
-
-## Current Focus
-
-${currentTask ? `**Active Task**: ${currentTask}` : 'No active task. Use /p:now to start.'}
-
-## Priority Queue
-
-${nextTasks.length ? nextTasks.map((t, i) => `${i + 1}. ${t}`).join('\n') : 'Empty queue. Use /p:next to add tasks.'}
-
-## Active Features (Roadmap)
-
-${activeFeatures.length ? activeFeatures.map(f => `- [ ] ${f}`).join('\n') : 'No features in progress.'}
-
-## Recent Ideas
-
-${recentIdeas.length ? recentIdeas.map(i => `- ${i}`).join('\n') : 'No recent ideas.'}
-
-## Git Activity
-
-${gitStats.recentCommits?.length ? gitStats.recentCommits.map(c => `- \`${c.hash}\` ${c.message}`).join('\n') : 'No recent commits.'}
-
----
-
-## Deep Dive (Read When Needed)
-
-For detailed information, read these files:
-- \`~/.prjct-cli/projects/${projectId}/agents/*.md\` - Full agent templates with code patterns
-- \`~/.prjct-cli/projects/${projectId}/analysis/repo-summary.md\` - Complete technical analysis
-- \`~/.prjct-cli/projects/${projectId}/planning/roadmap.md\` - Full feature roadmap
-- \`~/.prjct-cli/projects/${projectId}/memory/context.jsonl\` - Decision history
-`
-
-  // 11. Write to global storage
-  const contextPath = path.join(globalPath, 'CLAUDE.md')
-  await fs.writeFile(contextPath, content, 'utf-8')
-
-  return { agents: agentFiles.map(f => f.replace('.md', '')), stack: stackInfo, currentTask }
-}
-
-/**
- * Extract FULL stack info from repo-summary
+ * Wrapper that generates context MD files from JSON data.
+ * Uses the context generator to create CLAUDE.md, now.md, queue.md, summary.md
  */
-function extractFullStack(summary: string | null): StackInfo {
-  if (!summary) return { primary: null, full: null, languages: [], frameworks: [], dependencies: [] }
-
-  const result: StackInfo = { primary: null, full: null, languages: [], frameworks: [], dependencies: [] }
-
-  // Extract languages (e.g., "### JavaScript/TypeScript")
-  const langMatch = summary.match(/###\s*(JavaScript|TypeScript|Python|Go|Rust|Ruby|Java|C#|PHP)/i)
-  if (langMatch) result.primary = langMatch[1]
-
-  // Extract dependencies
-  const depsMatch = summary.match(/\*\*Dependencies\*\*:\s*([^\n]+)/i)
-  if (depsMatch) result.dependencies = depsMatch[1].split(',').map(d => d.trim())
 
-  // Extract full stack section (between ## Stack Detected and next ##)
-  const stackSection = summary.match(/## Stack Detected\n([\s\S]*?)(?=\n## |$)/i)
-  if (stackSection && stackSection[1]) {
-    result.full = stackSection[1].trim()
-  }
-
-  return result
-}
+import { generateContext } from './context/generator'
 
 /**
- * Extract project structure from repo-summary
+ * Generate local context files for Claude
  */
-function extractProjectStructure(summary: string | null): ProjectStructure {
-  if (!summary) return { fileCount: null, directories: [] }
-
-  const result: ProjectStructure = { fileCount: null, directories: [] }
-
-  // Extract file count
-  const fileMatch = summary.match(/\*\*Total Files\*\*:\s*(\d+)/i)
-  if (fileMatch) result.fileCount = parseInt(fileMatch[1])
-
-  // Extract directories
-  const dirMatch = summary.match(/\*\*Directories\*\*:\s*([^\n]+)/i)
-  if (dirMatch) result.directories = dirMatch[1].split(',').map(d => d.trim())
-
-  return result
-}
-
-/**
- * Extract git stats from repo-summary
- */
-function extractGitStats(summary: string | null): GitStats {
-  if (!summary) return { commits: null, contributors: null, recentCommits: [] }
-
-  const result: GitStats = { commits: null, contributors: null, recentCommits: [] }
-
-  // Extract commit count
-  const commitMatch = summary.match(/\*\*Total Commits\*\*:\s*(\d+)/i)
-  if (commitMatch) result.commits = parseInt(commitMatch[1])
-
-  // Extract contributors
-  const contribMatch = summary.match(/\*\*Contributors\*\*:\s*(\d+)/i)
-  if (contribMatch) result.contributors = parseInt(contribMatch[1])
-
-  // Extract recent commits
-  const recentSection = summary.match(/## Recent Activity[\s\S]*?(?=##|$)/i)
-  if (recentSection) {
-    const commitLines = recentSection[0].match(/- `([a-f0-9]+)` (.+?) \(/g)
-    if (commitLines) {
-      result.recentCommits = commitLines.slice(0, 5).map(line => {
-        const match = line.match(/- `([a-f0-9]+)` (.+?) \(/)
-        return match ? { hash: match[1], message: match[2] } : null
-      }).filter((c): c is GitCommit => c !== null)
-    }
-  }
-
-  return result
-}
-
-/**
- * Extract agent expertise from agent files
- */
-async function extractAgentExpertise(agentsDir: string, agentFiles: string[]): Promise<AgentExpertise[]> {
-  const expertise: AgentExpertise[] = []
-
-  for (const file of agentFiles.slice(0, 6)) { // Max 6 agents to keep context small
-    try {
-      const content = await fs.readFile(path.join(agentsDir, file), 'utf-8')
-      const name = file.replace('.md', '')
-
-      // Extract role
-      const roleMatch = content.match(/Role:\s*([^\n]+)/i)
-      const role = roleMatch ? roleMatch[1].trim() : 'Specialist'
-
-      // Extract domain or expertise
-      const domainMatch = content.match(/domain[:\s]+([^\n]+)/i) ||
-                          content.match(/expertise[:\s]+([^\n]+)/i) ||
-                          content.match(/owner of the ([^\n.]+)/i)
-      const expertiseText = domainMatch ? domainMatch[1].trim() : 'General'
-
-      expertise.push({ name, role, expertise: expertiseText })
-    } catch {
-      // Skip unreadable agents
-    }
-  }
-
-  return expertise
-}
-
-/**
- * Extract current task from now.md
- */
-function extractCurrentTask(now: string | null): string | null {
-  if (!now) return null
-
-  const lines = now.split('\n')
-  for (const line of lines) {
-    const trimmed = line.trim()
-    if (trimmed && !trimmed.startsWith('#') && !trimmed.startsWith('<!--') && !trimmed.startsWith('No current')) {
-      return trimmed
-    }
-  }
-  return null
-}
-
-/**
- * Extract top N tasks from next.md
- */
-function extractTopTasks(next: string | null, count: number): string[] {
-  if (!next) return []
-
-  return next
-    .split('\n')
-    .filter(l => l.match(/^[-*\d.]\s/))
-    .slice(0, count)
-    .map(l => l.replace(/^[-*\d.]\s+/, '').trim())
-    .filter(Boolean)
-}
-
-/**
- * Extract active features from roadmap.md
- */
-function extractActiveFeatures(roadmap: string | null): string[] {
-  if (!roadmap) return []
-
-  const features: string[] = []
-  const lines = roadmap.split('\n')
-  let inActive = false
-
-  for (const line of lines) {
-    if (line.includes('Active') || line.includes('In Progress') || line.includes('Current')) {
-      inActive = true
-      continue
-    }
-    if (line.startsWith('## ') && inActive) {
-      break
-    }
-    if (inActive && line.match(/^[-*]\s*\[[ x]\]/i)) {
-      const feature = line.replace(/^[-*]\s*\[[ x]\]\s*/, '').replace(/\*\*/g, '').trim()
-      if (feature) features.push(feature)
-    }
-  }
-
-  return features.slice(0, 5)
-}
-
-/**
- * Extract recent ideas from ideas.md
- */
-function extractRecentIdeas(ideas: string | null): string[] {
-  if (!ideas) return []
-
-  return ideas
-    .split('\n')
-    .filter(l => l.match(/^[-*]\s/))
-    .slice(0, 3)
-    .map(l => l.replace(/^[-*]\s+/, '').trim())
-    .filter(Boolean)
+async function generateLocalContext(projectPath: string, projectId: string): Promise<void> {
+  await generateContext(projectId, projectPath)
 }
 
 export { generateLocalContext }

package/core/data/index.ts

@@ -2,45 +2,26 @@
  * Data Module
  *
  * MD-First Architecture: MD files are the source of truth.
- * JSON managers are deprecated in favor of MD managers.
  */
 
-// Base (legacy JSON)
-export { BaseManager, ArrayManager } from './base-manager'
+// MD managers
+import { mdStateManager } from './md-state-manager'
+import { mdQueueManager } from './md-queue-manager'
+import { mdShippedManager } from './md-shipped-manager'
+import { mdIdeasManager } from './md-ideas-manager'
 
-// MD-First Base
+// Base classes
 export { MdBaseManager, MdArrayManager } from './md-base-manager'
 
-// MD-First Managers (NEW - use these!)
-export { mdStateManager } from './md-state-manager'
-export { mdQueueManager } from './md-queue-manager'
+// MD managers
+export { mdStateManager, mdQueueManager, mdShippedManager, mdIdeasManager }
 
-// Legacy JSON Managers (deprecated - for backwards compatibility only)
-export { stateManager, default as stateManagerDefault } from './state-manager'
-export { projectManager, default as projectManagerDefault } from './project-manager'
-export { agentsManager, default as agentsManagerDefault } from './agents-manager'
-export { ideasManager, default as ideasManagerDefault } from './ideas-manager'
-export { roadmapManager, default as roadmapManagerDefault } from './roadmap-manager'
-export { shippedManager, default as shippedManagerDefault } from './shipped-manager'
-export { analysisManager, default as analysisManagerDefault } from './analysis-manager'
-export { outcomesManager, default as outcomesManagerDefault } from './outcomes-manager'
-
-// MD-First managers (preferred)
+// MD managers object
 export const mdManagers = {
-  state: require('./md-state-manager').mdStateManager,
-  queue: require('./md-queue-manager').mdQueueManager
-}
-
-// Legacy JSON managers (deprecated)
-export const dataManagers = {
-  state: require('./state-manager').stateManager,
-  project: require('./project-manager').projectManager,
-  agents: require('./agents-manager').agentsManager,
-  ideas: require('./ideas-manager').ideasManager,
-  roadmap: require('./roadmap-manager').roadmapManager,
-  shipped: require('./shipped-manager').shippedManager,
-  analysis: require('./analysis-manager').analysisManager,
-  outcomes: require('./outcomes-manager').outcomesManager
+  state: mdStateManager,
+  queue: mdQueueManager,
+  shipped: mdShippedManager,
+  ideas: mdIdeasManager
 }
 
 export default mdManagers

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

@@ -0,0 +1,155 @@
+/**
+ * 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

@@ -7,6 +7,7 @@
 
 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> {
@@ -52,7 +53,7 @@ class MdQueueManager extends MdBaseManager<QueueJson> {
   ): Promise<QueueJson> {
     const newTask: QueueTask = {
       ...task,
-      id: `task_${Date.now()}`,
+      id: generateUUID(),
       createdAt: new Date().toISOString(),
       completed: false
     }
@@ -119,9 +120,9 @@ class MdQueueManager extends MdBaseManager<QueueJson> {
     projectId: string,
     tasks: Array<Omit<QueueTask, 'id' | 'createdAt' | 'completed'>>
   ): Promise<QueueJson> {
-    const newTasks: QueueTask[] = tasks.map((task, i) => ({
+    const newTasks: QueueTask[] = tasks.map((task) => ({
       ...task,
-      id: `task_${Date.now()}_${i}`,
+      id: generateUUID(),
       createdAt: new Date().toISOString(),
       completed: false
     }))

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

@@ -0,0 +1,90 @@
+/**
+ * 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