prjct-cli 0.13.3 → 0.15.0

package/core/commands/workflow.ts

@@ -1,16 +1,20 @@
 /**
- * Workflow Commands: now, done, next, build
- * Core task management
+ * Workflow Commands: work (now), done, next, pause, resume
+ * Core task management - Write-Through Architecture
+ *
+ * Uses storage layer: JSON (source) → MD (context) → Event (sync)
  */
 
 import type { CommandResult, Context } from './types'
+import { generateUUID } from '../schemas'
 import {
   PrjctCommandsBase,
   contextBuilder,
-  toolRegistry,
+  configManager,
   dateHelper,
   out
 } from './base'
+import { stateStorage, queueStorage } from '../storage'
 
 export class WorkflowCommands extends PrjctCommandsBase {
   /**
@@ -21,39 +25,43 @@ export class WorkflowCommands extends PrjctCommandsBase {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
-      const context = await contextBuilder.build(projectPath, { task }) as Context
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        out.fail('no project ID')
+        return { success: false, error: 'No project ID found' }
+      }
 
       if (task) {
+        const context = await contextBuilder.build(projectPath, { task }) as Context
         const agentResult = await this._assignAgentForTask(task, projectPath, context)
         const agent = agentResult.agent?.name || 'generalist'
-        const confidence = agentResult.routing?.confidence || 0.5
 
-        const nowContent = `# NOW\n\n**${task}**\n\nStarted: ${new Date().toLocaleString()}\nAgent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`
-        await toolRegistry.get('Write')!(context.paths.now, nowContent)
+        // Write-through: JSON → MD → Event
+        await stateStorage.startTask(projectId, {
+          id: generateUUID(),
+          description: task,
+          sessionId: generateUUID()
+        })
 
         out.done(`${task} [${agent}]`)
 
         await this.logToMemory(projectPath, 'task_started', {
           task,
           agent,
-          confidence,
           timestamp: dateHelper.getTimestamp(),
         })
         return { success: true, task, agent }
       } else {
-        const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
+        // Read from storage (JSON is source of truth)
+        const currentTask = await stateStorage.getCurrentTask(projectId)
 
-        if (!nowContent || nowContent.includes('No current task')) {
+        if (!currentTask) {
           out.warn('no active task')
           return { success: true, message: 'No active task' }
         }
 
-        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
-        const agentMatch = nowContent.match(/Agent: ([^\s(]+)/)
-        const currentTask = taskMatch ? taskMatch[1] : 'unknown'
-        const currentAgent = agentMatch ? agentMatch[1] : ''
-        out.done(`working on: ${currentTask}${currentAgent ? ` [${currentAgent}]` : ''}`)
-        return { success: true, content: nowContent }
+        out.done(`working on: ${currentTask.description}`)
+        return { success: true, task: currentTask.description, currentTask }
       }
     } catch (error) {
       out.fail((error as Error).message)
@@ -69,26 +77,29 @@ export class WorkflowCommands extends PrjctCommandsBase {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
-      const context = await contextBuilder.build(projectPath) as Context
-      const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        out.fail('no project ID')
+        return { success: false, error: 'No project ID found' }
+      }
+
+      // Read from storage
+      const currentTask = await stateStorage.getCurrentTask(projectId)
 
-      if (!nowContent || nowContent.includes('No current task') || nowContent.trim() === '# NOW') {
+      if (!currentTask) {
         out.warn('no active task')
         return { success: true, message: 'No active task to complete' }
       }
 
-      const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
-      const task = taskMatch ? taskMatch[1] : 'task'
-
-      const startedMatch = nowContent.match(/Started: (.+)/)
+      const task = currentTask.description
       let duration = ''
-      if (startedMatch) {
-        const started = new Date(startedMatch[1])
+      if (currentTask.startedAt) {
+        const started = new Date(currentTask.startedAt)
         duration = dateHelper.calculateDuration(started)
       }
 
-      const emptyNow = '# NOW\n\nNo current task. Use `/p:now` to set focus.\n'
-      await toolRegistry.get('Write')!(context.paths.now, emptyNow)
+      // Write-through: Complete task (JSON → MD → Event)
+      await stateStorage.completeTask(projectId)
 
       out.done(`${task}${duration ? ` (${duration})` : ''}`)
 
@@ -112,18 +123,23 @@ export class WorkflowCommands extends PrjctCommandsBase {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
-      const context = await contextBuilder.build(projectPath) as Context
-      const nextContent = await toolRegistry.get('Read')!(context.paths.next) as string
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        out.fail('no project ID')
+        return { success: false, error: 'No project ID found' }
+      }
+
+      // Read queue from storage
+      const tasks = await queueStorage.getActiveTasks(projectId)
 
-      if (!nextContent || nextContent.trim() === '# NEXT\n\n## Priority Queue') {
+      if (tasks.length === 0) {
         out.warn('queue empty')
         return { success: true, message: 'Queue is empty' }
       }
 
-      const taskCount = (nextContent.match(/^- \[/gm) || []).length
-      out.done(`${taskCount} task${taskCount !== 1 ? 's' : ''} queued`)
+      out.done(`${tasks.length} task${tasks.length !== 1 ? 's' : ''} queued`)
 
-      return { success: true, content: nextContent }
+      return { success: true, tasks, count: tasks.length }
     } catch (error) {
       out.fail((error as Error).message)
       return { success: false, error: (error as Error).message }
@@ -131,95 +147,84 @@ export class WorkflowCommands extends PrjctCommandsBase {
   }
 
   /**
-   * /p:build - Start task with agent assignment
+   * /p:pause - Pause active task to handle interruption
    */
-  async build(taskOrNumber: string, projectPath: string = process.cwd()): Promise<CommandResult> {
+  async pause(reason: string = '', projectPath: string = process.cwd()): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
-      const context = await contextBuilder.build(projectPath, { task: taskOrNumber }) as Context
-
-      const nowContent = await toolRegistry.get('Read')!(context.paths.now) as string
-      if (nowContent && !nowContent.includes('No current task')) {
-        console.log('⚠️  Already working on a task!')
-        console.log('   Complete it with /p:done first\n')
-        const taskMatch = nowContent.match(/\*\*(.+?)\*\*/)
-        const currentTask = taskMatch ? taskMatch[1] : 'current task'
-        console.log(`   Current: ${currentTask}`)
-        return { success: false, message: 'Task already active' }
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        out.fail('no project ID')
+        return { success: false, error: 'No project ID found' }
       }
 
-      let task = taskOrNumber
-
-      if (!isNaN(Number(taskOrNumber))) {
-        const nextContent = await toolRegistry.get('Read')!(context.paths.next) as string
-        const tasks = nextContent
-          .split('\n')
-          .filter((line) => line.trim().match(/^\d+\./) || line.includes('[ ]'))
-
-        const index = parseInt(taskOrNumber) - 1
-        if (index >= 0 && index < tasks.length) {
-          task = tasks[index].replace(/^\d+\.\s*\[.\]\s*/, '').trim()
-          console.log(`📋 Selected from queue: ${task}\n`)
-        } else {
-          console.log(`❌ Invalid task number. Queue has ${tasks.length} tasks.`)
-          console.log('   Use /p:next to see queue')
-          return { success: false, error: 'Invalid task number' }
-        }
-      }
+      const currentTask = await stateStorage.getCurrentTask(projectId)
 
-      if (!task) {
-        console.log('❌ Task description required')
-        console.log('Usage: /p:build "task description"')
-        console.log('   or: /p:build 1 (select from queue)')
-        return { success: false, error: 'Task required' }
+      if (!currentTask) {
+        out.warn('no active task to pause')
+        return { success: false, message: 'No active task to pause' }
       }
 
-      console.log(`🏗️  Building: ${task}\n`)
+      // Write-through: Pause task (JSON → MD → Event)
+      await stateStorage.pauseTask(projectId, reason)
 
-      const complexity = this._detectComplexity(task)
-      const estimate = complexity.hours
+      const taskDesc = currentTask.description.slice(0, 40)
+      out.done(`paused: ${taskDesc}${reason ? ` (${reason})` : ''}`)
 
-      console.log('📊 Analysis:')
-      console.log(`   Complexity: ${complexity.level}`)
-      console.log(`   Estimated: ${estimate}h`)
-      console.log(`   Type: ${complexity.type}\n`)
+      await this.logToMemory(projectPath, 'task_paused', {
+        task: currentTask.description,
+        reason,
+        timestamp: dateHelper.getTimestamp(),
+      })
 
-      const agentResult = await this._assignAgentForTask(task, projectPath, context)
-      const agent = agentResult.agent?.name || 'generalist'
-      const confidence = agentResult.routing?.confidence || 0.5
-      console.log(`🤖 Agent: ${agent} (${Math.round(confidence * 100)}% confidence)\n`)
+      return { success: true, task: currentTask.description, reason }
+    } catch (error) {
+      out.fail((error as Error).message)
+      return { success: false, error: (error as Error).message }
+    }
+  }
+
+  /**
+   * /p:resume - Resume most recently paused task
+   */
+  async resume(taskId: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    try {
+      const initResult = await this.ensureProjectInit(projectPath)
+      if (!initResult.success) return initResult
 
-      const nowContentNew = `# NOW
+      const projectId = await configManager.getProjectId(projectPath)
+      if (!projectId) {
+        out.fail('no project ID')
+        return { success: false, error: 'No project ID found' }
+      }
 
-**${task}**
+      // Check if already working on a task
+      const currentTask = await stateStorage.getCurrentTask(projectId)
+      if (currentTask) {
+        out.warn('already working on a task')
+        return { success: false, message: `Already working on: ${currentTask.description}` }
+      }
 
-Started: ${new Date().toLocaleString()}
-Estimated: ${estimate}h
-Complexity: ${complexity.level}
-Agent: ${agent} (${Math.round(confidence * 100)}% confidence)
-`
-      await toolRegistry.get('Write')!(context.paths.now, nowContentNew)
+      // Write-through: Resume task (JSON → MD → Event)
+      const resumed = await stateStorage.resumeTask(projectId)
 
-      console.log('✅ Task started!\n')
-      console.log('💡 Next steps:')
-      console.log('• Start coding')
-      console.log('• /p:done → Mark complete')
-      console.log('• /p:stuck → Get help if needed')
+      if (!resumed) {
+        out.warn('no paused task to resume')
+        return { success: false, message: 'No paused task found' }
+      }
 
-      await this.logToMemory(projectPath, 'task_built', {
-        task,
-        complexity: complexity.level,
-        estimate,
-        agent,
-        confidence,
+      out.done(`resumed: ${resumed.description.slice(0, 40)}`)
+
+      await this.logToMemory(projectPath, 'task_resumed', {
+        task: resumed.description,
         timestamp: dateHelper.getTimestamp(),
       })
 
-      return { success: true, task, complexity, estimate, agent }
+      return { success: true, task: resumed.description }
     } catch (error) {
-      console.error('❌ Error:', (error as Error).message)
+      out.fail((error as Error).message)
       return { success: false, error: (error as Error).message }
     }
   }

package/core/context/generator.ts

@@ -0,0 +1,317 @@
+/**
+ * Context Generator
+ *
+ * Generates MD files in context/ from JSON data in data/
+ * These MD files are for Claude to read.
+ *
+ * context/
+ * ├── CLAUDE.md    - Full project context
+ * ├── now.md       - Current task context
+ * ├── queue.md     - Task queue
+ * └── summary.md   - Project summary
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import { exec } from 'child_process'
+import { promisify } from 'util'
+import { getStorage } from '../storage'
+
+const execAsync = promisify(exec)
+
+interface Task {
+  id: string
+  description: string
+  status: string
+  priority?: string
+  startedAt?: string
+  completedAt?: string
+}
+
+interface Feature {
+  id: string
+  name: string
+  status: string
+  description?: string
+}
+
+interface Idea {
+  id: string
+  title: string
+  status?: string
+}
+
+interface ProjectData {
+  name?: string
+  repoPath?: string
+  techStack?: string[]
+  version?: string
+}
+
+interface Agent {
+  name: string
+  role?: string
+  domain?: string
+}
+
+/**
+ * Generate all context MD files from JSON data
+ */
+export async function generateContext(projectId: string, repoPath: string): Promise<void> {
+  const globalPath = path.join(os.homedir(), '.prjct-cli/projects', projectId)
+  const contextPath = path.join(globalPath, 'context')
+  const storage = getStorage(projectId)
+
+  // Ensure context directory exists
+  await fs.mkdir(contextPath, { recursive: true })
+
+  // Read all data
+  const project = await storage.read<ProjectData>(['project']) || {}
+  const taskPaths = await storage.list(['task'])
+  const featurePaths = await storage.list(['feature'])
+  const ideaPaths = await storage.list(['idea'])
+  const agentPaths = await storage.list(['agent'])
+
+  const tasks: Task[] = []
+  for (const p of taskPaths) {
+    const task = await storage.read<Task>(p)
+    if (task) tasks.push({ ...task, id: p[1] })
+  }
+
+  const features: Feature[] = []
+  for (const p of featurePaths) {
+    const feature = await storage.read<Feature>(p)
+    if (feature) features.push({ ...feature, id: p[1] })
+  }
+
+  const ideas: Idea[] = []
+  for (const p of ideaPaths) {
+    const idea = await storage.read<Idea>(p)
+    if (idea) ideas.push({ ...idea, id: p[1] })
+  }
+
+  const agents: Agent[] = []
+  for (const p of agentPaths) {
+    const agent = await storage.read<Agent>(p)
+    if (agent) agents.push({ ...agent, name: p[1] })
+  }
+
+  // Get git data
+  const gitData = await getGitData(repoPath)
+
+  // Get package.json data
+  const pkgData = await getPackageData(repoPath)
+
+  // Generate each context file
+  await generateClaudeMd(contextPath, projectId, project, tasks, features, ideas, agents, gitData, pkgData, repoPath)
+  await generateNowMd(contextPath, tasks)
+  await generateQueueMd(contextPath, tasks)
+  await generateSummaryMd(contextPath, project, gitData, pkgData)
+}
+
+async function getGitData(repoPath: string) {
+  const data = {
+    branch: 'main',
+    commits: 0,
+    contributors: 0,
+    hasChanges: false,
+    recentCommits: [] as { hash: string; message: string; date: string }[]
+  }
+
+  try {
+    const { stdout: branch } = await execAsync('git branch --show-current', { cwd: repoPath })
+    data.branch = branch.trim() || 'main'
+
+    const { stdout: commits } = await execAsync('git rev-list --count HEAD', { cwd: repoPath })
+    data.commits = parseInt(commits.trim()) || 0
+
+    const { stdout: contributors } = await execAsync('git shortlog -sn --all | wc -l', { cwd: repoPath })
+    data.contributors = parseInt(contributors.trim()) || 0
+
+    const { stdout: status } = await execAsync('git status --porcelain', { cwd: repoPath })
+    data.hasChanges = status.trim().length > 0
+
+    const { stdout: log } = await execAsync('git log --oneline -10 --pretty=format:"%h|%s|%ad" --date=short', { cwd: repoPath })
+    data.recentCommits = log.split('\n').filter(Boolean).map(line => {
+      const [hash, message, date] = line.split('|')
+      return { hash, message, date }
+    })
+  } catch { /* not git */ }
+
+  return data
+}
+
+async function getPackageData(repoPath: string) {
+  const data = {
+    dependencies: {} as Record<string, string>,
+    devDependencies: {} as Record<string, string>,
+    scripts: {} as Record<string, string>
+  }
+
+  try {
+    const pkgPath = path.join(repoPath, 'package.json')
+    const pkg = JSON.parse(await fs.readFile(pkgPath, 'utf-8'))
+    data.dependencies = pkg.dependencies || {}
+    data.devDependencies = pkg.devDependencies || {}
+    data.scripts = pkg.scripts || {}
+  } catch { /* no package.json */ }
+
+  return data
+}
+
+async function generateClaudeMd(
+  contextPath: string,
+  projectId: string,
+  project: ProjectData,
+  tasks: Task[],
+  features: Feature[],
+  ideas: Idea[],
+  agents: Agent[],
+  gitData: Awaited<ReturnType<typeof getGitData>>,
+  pkgData: Awaited<ReturnType<typeof getPackageData>>,
+  repoPath: string
+) {
+  const projectName = project.name || path.basename(repoPath)
+  const currentTask = tasks.find(t => t.status === 'in_progress')
+  const pendingTasks = tasks.filter(t => t.status === 'pending')
+  const activeFeatures = features.filter(f => f.status === 'in_progress' || f.status === 'active')
+
+  const deps = Object.keys(pkgData.dependencies)
+  const devDeps = Object.keys(pkgData.devDependencies)
+
+  const content = `# ${projectName} - Project Context
+<!-- projectId: ${projectId} -->
+<!-- Generated: ${new Date().toISOString()} -->
+
+## PROJECT DATA
+
+### Dependencies (${deps.length + devDeps.length})
+
+**Production** (${deps.length}):
+${deps.length > 0 ? deps.map(d => `- ${d}: ${pkgData.dependencies[d]}`).join('\n') : '_None_'}
+
+**Dev** (${devDeps.length}):
+${devDeps.length > 0 ? devDeps.map(d => `- ${d}: ${pkgData.devDependencies[d]}`).join('\n') : '_None_'}
+
+### Scripts
+
+${Object.keys(pkgData.scripts).length > 0 ? Object.entries(pkgData.scripts).map(([k, v]) => `- \`${k}\`: ${v}`).join('\n') : '_None_'}
+
+### Git
+
+- Branch: ${gitData.branch}
+- Commits: ${gitData.commits}
+- Contributors: ${gitData.contributors}
+- Uncommitted: ${gitData.hasChanges ? 'Yes' : 'No'}
+
+**Recent:**
+${gitData.recentCommits.length > 0 ? gitData.recentCommits.slice(0, 5).map(c => `- \`${c.hash}\` ${c.message}`).join('\n') : '_None_'}
+
+---
+
+## CURRENT STATE
+
+**Now:** ${currentTask ? currentTask.description : '_No active task_'}
+
+**Queue (${pendingTasks.length}):**
+${pendingTasks.length > 0 ? pendingTasks.slice(0, 10).map((t, i) => `${i + 1}. ${t.description}`).join('\n') : '_Empty_'}
+
+**Active Features (${activeFeatures.length}):**
+${activeFeatures.length > 0 ? activeFeatures.map(f => `- ${f.name}`).join('\n') : '_None_'}
+
+**Ideas (${ideas.length}):**
+${ideas.length > 0 ? ideas.slice(0, 5).map(i => `- ${i.title}`).join('\n') : '_None_'}
+
+---
+
+## AGENTS
+
+${agents.length > 0 ? agents.map(a => `- **${a.name}**: ${a.role || 'Specialist'}`).join('\n') : '_None_'}
+
+---
+
+## DATA LOCATION
+
+\`\`\`
+~/.prjct-cli/projects/${projectId}/
+├── data/           # JSON (source of truth)
+│   ├── project.json
+│   ├── tasks/
+│   ├── features/
+│   ├── ideas/
+│   └── agents/
+├── context/        # MD (for Claude)
+│   ├── CLAUDE.md
+│   ├── now.md
+│   └── queue.md
+└── sync/           # Sync state
+    └── pending.json
+\`\`\`
+`
+
+  await fs.writeFile(path.join(contextPath, 'CLAUDE.md'), content, 'utf-8')
+}
+
+async function generateNowMd(contextPath: string, tasks: Task[]) {
+  const currentTask = tasks.find(t => t.status === 'in_progress')
+
+  const content = currentTask
+    ? `# NOW
+
+**Task:** ${currentTask.description}
+
+**Started:** ${currentTask.startedAt || 'Unknown'}
+
+**Priority:** ${currentTask.priority || 'medium'}
+`
+    : `# NOW
+
+_No active task. Use /p:now to start._
+`
+
+  await fs.writeFile(path.join(contextPath, 'now.md'), content, 'utf-8')
+}
+
+async function generateQueueMd(contextPath: string, tasks: Task[]) {
+  const pendingTasks = tasks.filter(t => t.status === 'pending')
+
+  const content = `# QUEUE
+
+${pendingTasks.length > 0
+    ? pendingTasks.map((t, i) => `${i + 1}. ${t.description}${t.priority ? ` [${t.priority}]` : ''}`).join('\n')
+    : '_Empty queue. Use /p:next to add tasks._'
+}
+`
+
+  await fs.writeFile(path.join(contextPath, 'queue.md'), content, 'utf-8')
+}
+
+async function generateSummaryMd(
+  contextPath: string,
+  project: ProjectData,
+  gitData: Awaited<ReturnType<typeof getGitData>>,
+  pkgData: Awaited<ReturnType<typeof getPackageData>>
+) {
+  const content = `# PROJECT SUMMARY
+
+**Name:** ${project.name || 'Unknown'}
+**Version:** ${project.version || 'N/A'}
+**Stack:** ${project.techStack?.join(', ') || 'Not detected'}
+
+## Git
+
+- Branch: ${gitData.branch}
+- Commits: ${gitData.commits}
+- Status: ${gitData.hasChanges ? 'Has uncommitted changes' : 'Clean'}
+
+## Dependencies
+
+- Production: ${Object.keys(pkgData.dependencies).length}
+- Dev: ${Object.keys(pkgData.devDependencies).length}
+`
+
+  await fs.writeFile(path.join(contextPath, 'summary.md'), content, 'utf-8')
+}
+
+export default { generateContext }