prjct-cli 0.12.1 → 0.13.0

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

@@ -0,0 +1,133 @@
+/**
+ * MD State Manager
+ *
+ * MD-First Architecture: Manages state via now.md.
+ * Source of truth is the markdown file, not JSON.
+ */
+
+import { MdBaseManager } from './md-base-manager'
+import { parseState, serializeState } from '../serializers'
+import type { StateJson, CurrentTask, PreviousTask } from '../schemas/state'
+
+class MdStateManager extends MdBaseManager<StateJson> {
+  constructor() {
+    super('core/now.md')
+  }
+
+  protected getDefault(): StateJson {
+    return {
+      currentTask: null,
+      lastUpdated: ''
+    }
+  }
+
+  protected parse(content: string): StateJson {
+    return parseState(content)
+  }
+
+  protected serialize(data: StateJson): string {
+    return serializeState(data)
+  }
+
+  // =========== Current Task ===========
+
+  async getCurrentTask(projectId: string): Promise<CurrentTask | null> {
+    const state = await this.read(projectId)
+    return state.currentTask
+  }
+
+  async setCurrentTask(projectId: string, task: CurrentTask | null): Promise<StateJson> {
+    return this.update(projectId, (state) => ({
+      ...state,
+      currentTask: task,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  async startTask(
+    projectId: string,
+    task: Omit<CurrentTask, 'startedAt'>
+  ): Promise<StateJson> {
+    const currentTask: CurrentTask = {
+      ...task,
+      startedAt: new Date().toISOString()
+    }
+
+    return this.update(projectId, () => ({
+      currentTask,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  async completeTask(projectId: string): Promise<StateJson> {
+    const state = await this.read(projectId)
+    if (!state.currentTask) {
+      throw new Error('No active task to complete')
+    }
+
+    return this.update(projectId, () => ({
+      currentTask: null,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  async pauseTask(projectId: string): Promise<StateJson> {
+    const state = await this.read(projectId)
+    if (!state.currentTask) {
+      throw new Error('No active task to pause')
+    }
+
+    const previousTask: PreviousTask = {
+      id: state.currentTask.id,
+      description: state.currentTask.description,
+      status: 'paused',
+      startedAt: state.currentTask.startedAt,
+      pausedAt: new Date().toISOString()
+    }
+
+    return this.update(projectId, () => ({
+      currentTask: null,
+      previousTask,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  async resumeTask(projectId: string): Promise<StateJson> {
+    const state = await this.read(projectId)
+    if (!state.previousTask) {
+      throw new Error('No paused task to resume')
+    }
+
+    const currentTask: CurrentTask = {
+      id: state.previousTask.id,
+      description: state.previousTask.description,
+      startedAt: new Date().toISOString(), // Reset start time
+      sessionId: `sess_${Date.now()}`
+    }
+
+    return this.update(projectId, () => ({
+      currentTask,
+      previousTask: null,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  async clearTask(projectId: string): Promise<StateJson> {
+    return this.update(projectId, () => ({
+      currentTask: null,
+      previousTask: null,
+      lastUpdated: new Date().toISOString()
+    }))
+  }
+
+  /**
+   * Check if there's an active or paused task
+   */
+  async hasTask(projectId: string): Promise<boolean> {
+    const state = await this.read(projectId)
+    return state.currentTask !== null || state.previousTask !== null
+  }
+}
+
+export const mdStateManager = new MdStateManager()
+export default mdStateManager

package/core/serializers/index.ts

@@ -0,0 +1,20 @@
+/**
+ * Serializers Index
+ *
+ * MD-First Architecture: These serializers convert between TypeScript schemas and MD format.
+ */
+
+// State (now.md)
+export {
+  parseState,
+  serializeState,
+  createCurrentTaskMd,
+  createEmptyStateMd
+} from './state-serializer'
+
+// Queue (next.md)
+export {
+  parseQueue,
+  serializeQueue,
+  createEmptyQueueMd
+} from './queue-serializer'

package/core/serializers/queue-serializer.ts

@@ -0,0 +1,210 @@
+/**
+ * Queue Serializer
+ *
+ * Parses and serializes next.md for task queue.
+ *
+ * MD Format (next.md):
+ * ```
+ * # Priority Queue
+ *
+ * > Tasks ready to start
+ *
+ * ## Active Tasks
+ * 1. [ ] Task description @agent (from: Feature Name)
+ * 2. [x] Completed task ✅
+ *
+ * ## Previously Active
+ * - [ ] Paused task
+ *
+ * ## Backlog
+ * - [ ] 🐛 [HIGH] Bug description
+ * - [ ] Feature task
+ * ```
+ */
+
+import type { QueueJson, QueueTask, Priority, TaskType, TaskSection } from '../schemas/state'
+
+/**
+ * Parse next.md content to QueueJson
+ */
+export function parseQueue(content: string): QueueJson {
+  if (!content || !content.trim()) {
+    return { tasks: [], lastUpdated: '' }
+  }
+
+  const lines = content.split('\n')
+  const tasks: QueueTask[] = []
+  let currentSection: TaskSection = 'active'
+  let taskIndex = 0
+
+  for (const line of lines) {
+    // Detect section headers
+    if (line.match(/^##\s*Active/i)) {
+      currentSection = 'active'
+      continue
+    }
+    if (line.match(/^##\s*Previously/i)) {
+      currentSection = 'previously_active'
+      continue
+    }
+    if (line.match(/^##\s*Backlog/i)) {
+      currentSection = 'backlog'
+      continue
+    }
+
+    // Parse task lines: "1. [ ] Task" or "- [ ] Task" or "- [x] Task"
+    const taskMatch = line.match(/^(?:\d+\.|[-*])\s*\[([\sx])\]\s*(.+)$/i)
+    if (!taskMatch) continue
+
+    const isCompleted = taskMatch[1].toLowerCase() === 'x'
+    let taskText = taskMatch[2].trim()
+
+    // Extract agent: @fe, @be, @fe+be
+    const agentMatch = taskText.match(/@(\w+(?:\+\w+)?)/)
+    const agent = agentMatch ? agentMatch[1] : undefined
+    taskText = taskText.replace(/@\w+(?:\+\w+)?/, '').trim()
+
+    // Extract origin feature: (from: Feature Name)
+    const fromMatch = taskText.match(/\(from:\s*([^)]+)\)/)
+    const originFeature = fromMatch ? fromMatch[1].trim() : undefined
+    taskText = taskText.replace(/\(from:\s*[^)]+\)/, '').trim()
+
+    // Detect task type from emoji/prefix
+    let type: TaskType = 'feature'
+    let priority: Priority = 'medium'
+
+    if (taskText.includes('🐛') || taskText.toLowerCase().includes('bug')) {
+      type = 'bug'
+      taskText = taskText.replace('🐛', '').trim()
+    }
+    if (taskText.includes('🔧') || taskText.toLowerCase().includes('fix')) {
+      type = 'improvement'
+    }
+    if (taskText.includes('♻️') || taskText.toLowerCase().includes('refactor')) {
+      type = 'chore'
+    }
+
+    // Extract priority: [HIGH], [MEDIUM], [LOW], [CRITICAL]
+    const priorityMatch = taskText.match(/\[(HIGH|MEDIUM|LOW|CRITICAL)\]/i)
+    if (priorityMatch) {
+      priority = priorityMatch[1].toLowerCase() as Priority
+      taskText = taskText.replace(/\[(HIGH|MEDIUM|LOW|CRITICAL)\]/i, '').trim()
+    }
+
+    // Remove checkmarks and clean up
+    taskText = taskText.replace(/✅/g, '').trim()
+
+    // Skip empty descriptions
+    if (!taskText) continue
+
+    const task: QueueTask = {
+      id: `task_${Date.now()}_${taskIndex++}`,
+      description: taskText,
+      priority,
+      type,
+      completed: isCompleted,
+      createdAt: new Date().toISOString(),
+      section: currentSection
+    }
+
+    if (agent) task.agent = agent
+    if (originFeature) task.originFeature = originFeature
+    if (isCompleted) task.completedAt = new Date().toISOString()
+
+    tasks.push(task)
+  }
+
+  // Extract updated date
+  const updatedMatch = content.match(/_Updated:\s*(\d{4}-\d{2}-\d{2})/)
+  const lastUpdated = updatedMatch ? updatedMatch[1] : new Date().toISOString().split('T')[0]
+
+  return { tasks, lastUpdated }
+}
+
+/**
+ * Serialize QueueJson to next.md format
+ */
+export function serializeQueue(data: QueueJson): string {
+  const lines: string[] = [
+    '# Priority Queue',
+    '',
+    '> Tasks ready to start (max 100)',
+    '> Auto-updated by prjct',
+    ''
+  ]
+
+  // Group tasks by section
+  const active = data.tasks.filter(t => t.section === 'active')
+  const previouslyActive = data.tasks.filter(t => t.section === 'previously_active')
+  const backlog = data.tasks.filter(t => t.section === 'backlog')
+
+  // Active Tasks
+  if (active.length > 0) {
+    lines.push('## Active Tasks', '')
+    active.forEach((task, i) => {
+      lines.push(formatTask(task, i + 1, true))
+    })
+    lines.push('')
+  }
+
+  // Previously Active
+  if (previouslyActive.length > 0) {
+    lines.push('## Previously Active', '')
+    previouslyActive.forEach(task => {
+      lines.push(formatTask(task, 0, false))
+    })
+    lines.push('')
+  }
+
+  // Backlog
+  lines.push('---', '', '## Backlog', '')
+  if (backlog.length > 0) {
+    backlog.forEach(task => {
+      lines.push(formatTask(task, 0, false))
+    })
+  } else {
+    lines.push('_No backlog items_')
+  }
+
+  lines.push('')
+  lines.push('---', '')
+  lines.push(`_Updated: ${data.lastUpdated || new Date().toISOString().split('T')[0]}_`)
+
+  return lines.join('\n')
+}
+
+/**
+ * Format a single task as markdown
+ */
+function formatTask(task: QueueTask, num: number, numbered: boolean): string {
+  const checkbox = task.completed ? '[x]' : '[ ]'
+  const prefix = numbered && num > 0 ? `${num}.` : '-'
+
+  let text = task.description
+
+  // Add emoji for type
+  if (task.type === 'bug') text = `🐛 ${text}`
+
+  // Add priority tag for high/critical
+  if (task.priority === 'high' || task.priority === 'critical') {
+    text = `[${task.priority.toUpperCase()}] ${text}`
+  }
+
+  // Add agent
+  if (task.agent) text = `${text} @${task.agent}`
+
+  // Add origin feature
+  if (task.originFeature) text = `${text} (from: ${task.originFeature})`
+
+  // Add checkmark for completed
+  if (task.completed) text = `${text} ✅`
+
+  return `${prefix} ${checkbox} ${text}`
+}
+
+/**
+ * Quick helpers
+ */
+export function createEmptyQueueMd(): string {
+  return serializeQueue({ tasks: [], lastUpdated: new Date().toISOString().split('T')[0] })
+}

package/core/serializers/state-serializer.ts

@@ -0,0 +1,136 @@
+/**
+ * State Serializer
+ *
+ * Parses and serializes now.md for current task state.
+ *
+ * MD Format (now.md):
+ * ```
+ * # NOW
+ *
+ * **Task description here**
+ *
+ * Started: 2025-12-10T10:00:00.000Z
+ * Session: sess_abc123
+ * Feature: feat_xyz789
+ * Agent: fe
+ * ```
+ */
+
+import type { StateJson, CurrentTask, PreviousTask } from '../schemas/state'
+
+/**
+ * Parse now.md content to StateJson
+ */
+export function parseState(content: string): StateJson {
+  if (!content || !content.trim()) {
+    return { currentTask: null, lastUpdated: '' }
+  }
+
+  const lines = content.split('\n')
+  let currentTask: CurrentTask | null = null
+  let previousTask: PreviousTask | null = null
+
+  // Find task description (bold line after # NOW)
+  let description = ''
+  for (const line of lines) {
+    const boldMatch = line.match(/^\*\*(.+)\*\*$/)
+    if (boldMatch) {
+      description = boldMatch[1].trim()
+      break
+    }
+  }
+
+  if (!description || description.toLowerCase().includes('no active task')) {
+    return { currentTask: null, lastUpdated: '' }
+  }
+
+  // Extract metadata
+  const startedMatch = content.match(/Started:\s*(.+)/i)
+  const sessionMatch = content.match(/Session:\s*(.+)/i)
+  const featureMatch = content.match(/Feature:\s*(.+)/i)
+  const idMatch = content.match(/ID:\s*(.+)/i)
+  const agentMatch = content.match(/Agent:\s*(.+)/i)
+  const pausedMatch = content.match(/Paused:\s*(.+)/i)
+
+  const id = idMatch ? idMatch[1].trim() : `task_${Date.now()}`
+  const startedAt = startedMatch ? startedMatch[1].trim() : new Date().toISOString()
+  const sessionId = sessionMatch ? sessionMatch[1].trim() : `sess_${Date.now()}`
+
+  if (pausedMatch) {
+    // This is a paused task
+    previousTask = {
+      id,
+      description,
+      status: 'paused',
+      startedAt,
+      pausedAt: pausedMatch[1].trim()
+    }
+  } else {
+    // Active task
+    currentTask = {
+      id,
+      description,
+      startedAt,
+      sessionId
+    }
+
+    if (featureMatch) {
+      currentTask.featureId = featureMatch[1].trim()
+    }
+  }
+
+  return {
+    currentTask,
+    previousTask,
+    lastUpdated: startedAt
+  }
+}
+
+/**
+ * Serialize StateJson to now.md format
+ */
+export function serializeState(data: StateJson): string {
+  const lines: string[] = ['# NOW', '']
+
+  if (!data.currentTask && !data.previousTask) {
+    lines.push('_No active task_', '')
+    lines.push('Use `/p:now` to start working on something.')
+    return lines.join('\n')
+  }
+
+  const task = data.currentTask || data.previousTask
+
+  if (task) {
+    lines.push(`**${task.description}**`, '')
+
+    if ('pausedAt' in task && task.pausedAt) {
+      lines.push(`Started: ${task.startedAt}`)
+      lines.push(`Paused: ${task.pausedAt}`)
+    } else if (data.currentTask) {
+      lines.push(`Started: ${data.currentTask.startedAt}`)
+      lines.push(`Session: ${data.currentTask.sessionId}`)
+      if (data.currentTask.featureId) {
+        lines.push(`Feature: ${data.currentTask.featureId}`)
+      }
+    }
+  }
+
+  return lines.join('\n')
+}
+
+/**
+ * Quick helpers for common operations
+ */
+export function createCurrentTaskMd(task: CurrentTask): string {
+  return serializeState({
+    currentTask: task,
+    lastUpdated: task.startedAt
+  })
+}
+
+export function createEmptyStateMd(): string {
+  return serializeState({
+    currentTask: null,
+    lastUpdated: ''
+  })
+}

package/core/utils/file-helper.ts

@@ -66,6 +66,17 @@ export async function writeFile(filePath: string, content: string): Promise<void
   await fs.writeFile(filePath, content, 'utf-8')
 }
 
+/**
+ * Atomic write - writes to temp file then renames (prevents partial writes)
+ */
+export async function atomicWrite(filePath: string, content: string): Promise<void> {
+  const dir = path.dirname(filePath)
+  await fs.mkdir(dir, { recursive: true })
+  const tempPath = `${filePath}.${Date.now()}.tmp`
+  await fs.writeFile(tempPath, content, 'utf-8')
+  await fs.rename(tempPath, filePath)
+}
+
 /**
  * Append to text file
  */
@@ -245,6 +256,7 @@ export default {
   writeJson,
   readFile,
   writeFile,
+  atomicWrite,
   fileExists,
   ensureDir,
   deleteFile,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "prjct-cli",
-  "version": "0.12.1",
+  "version": "0.13.0",
   "description": "Built for Claude - Ship fast, track progress, stay focused. Developer momentum tool for indie hackers.",
   "main": "core/index.ts",
   "bin": {

package/packages/web/app/api/projects/[id]/stats/route.ts

@@ -1,7 +1,11 @@
 import { NextRequest, NextResponse } from 'next/server'
-import { loadUnifiedJsonData, hasJsonState } from '@/lib/json-loader'
 import { getProjectStats, getRawProjectFiles } from '@/lib/parse-prjct-files'
 
+/**
+ * GET /api/projects/[id]/stats
+ *
+ * MD-First Architecture: Returns stats parsed from MD files.
+ */
 export async function GET(
   request: NextRequest,
   { params }: { params: Promise<{ id: string }> }
@@ -16,33 +20,6 @@ export async function GET(
   }
 
   try {
-    // Check if JSON files exist (new format)
-    const hasJson = await hasJsonState(projectId)
-
-    if (hasJson) {
-      // Use new JSON loader (fast path)
-      const jsonData = await loadUnifiedJsonData(projectId)
-
-      // Convert to stats-compatible format using new architecture
-      return NextResponse.json({
-        success: true,
-        version: 'v2',
-        data: {
-          currentTask: jsonData.state?.currentTask || null,
-          queue: jsonData.queue?.tasks?.filter(t => !t.completed) || [],
-          metrics: jsonData.metrics || null,
-          agents: jsonData.agents,
-          ideas: jsonData.ideas?.ideas || [],
-          roadmap: jsonData.roadmap?.features || [],
-          shipped: jsonData.shipped?.items || [],
-          analysis: jsonData.analysis,
-          outcomes: jsonData.outcomes,
-          insights: jsonData.insights
-        }
-      })
-    }
-
-    // Fallback to legacy markdown parsing
     const [stats, raw] = await Promise.all([
       getProjectStats(projectId),
       getRawProjectFiles(projectId)
@@ -50,7 +27,7 @@ export async function GET(
 
     return NextResponse.json({
       success: true,
-      version: 'v1-legacy',
+      version: 'md-first',
       data: stats,
       raw
     })

package/packages/web/app/project/[id]/page.tsx

@@ -44,7 +44,8 @@ import {
   Undo2,
   Redo2,
   Command,
-  X
+  X,
+  RefreshCw
 } from 'lucide-react'
 import { cn } from '@/lib/utils'
 
@@ -111,6 +112,15 @@ function CommandSidebarContent({
             onCommandClick?.()
           }}
         />
+        {/* Sync button - prominent, always visible */}
+        <CommandButton
+          cmd="p. sync"
+          icon={RefreshCw}
+          tip="Sync"
+          disabled={!isActiveConnected}
+          onClick={() => handleCommand('p. sync')}
+          variant="primary"
+        />
         <div className="border-b border-border w-8 my-2 mx-auto" />
 
         {COMMAND_GROUPS.map((group, groupIndex) => (
@@ -268,6 +278,29 @@ function ProjectPageContent({ projectId, project }: { projectId: string; project
                       <span className="text-xs text-muted-foreground">Stats</span>
                     </button>
 
+                    {/* Sync button - prominent */}
+                    <button
+                      onClick={() => {
+                        sendCommandToActive('p. sync')
+                        setCommandSheetOpen(false)
+                      }}
+                      disabled={!isActiveConnected}
+                      className={cn(
+                        "flex flex-col items-center gap-1.5 p-3 rounded-lg transition-colors",
+                        isActiveConnected
+                          ? "hover:bg-primary/10"
+                          : "opacity-50 cursor-not-allowed"
+                      )}
+                    >
+                      <div className={cn(
+                        "h-10 w-10 rounded-full flex items-center justify-center",
+                        isActiveConnected ? "bg-primary text-primary-foreground" : "bg-muted"
+                      )}>
+                        <RefreshCw className="h-5 w-5" />
+                      </div>
+                      <span className="text-xs text-primary font-medium">Sync</span>
+                    </button>
+
                     {WORKFLOW_COMMANDS.map(({ cmd, icon: Icon, tip }) => (
                       <button
                         key={cmd}