prjct-cli 0.17.0 → 0.18.1

package/core/sync/sync-manager.ts

@@ -0,0 +1,358 @@
+/**
+ * Sync Manager - Orchestrates push/pull operations
+ *
+ * Main entry point for sync operations.
+ * Handles the coordination between local storage (EventBus) and remote API (SyncClient).
+ */
+
+import { syncClient, type SyncBatchResult, type SyncPullResult, type SyncStatus } from './sync-client'
+import authConfig from './auth-config'
+import eventBus, { type SyncEvent } from '../events'
+import { stateStorage } from '../storage/state-storage'
+import { queueStorage } from '../storage/queue-storage'
+import { ideasStorage, type IdeaPriority } from '../storage/ideas-storage'
+import { shippedStorage } from '../storage/shipped-storage'
+import type { TaskType, Priority, TaskSection } from '../schemas/state'
+
+// ============================================
+// Types
+// ============================================
+
+export interface SyncResult {
+  success: boolean
+  skipped: boolean
+  reason?: 'no_auth' | 'no_pending' | 'error'
+  pushed?: {
+    count: number
+    syncedAt: string
+  }
+  pulled?: {
+    count: number
+    syncedAt: string
+  }
+  error?: string
+}
+
+export interface PushResult {
+  success: boolean
+  skipped: boolean
+  reason?: 'no_auth' | 'no_pending' | 'error'
+  count?: number
+  syncedAt?: string
+  error?: string
+}
+
+export interface PullResult {
+  success: boolean
+  skipped: boolean
+  reason?: 'no_auth' | 'error'
+  count?: number
+  applied?: number
+  syncedAt?: string
+  error?: string
+}
+
+// ============================================
+// Sync Manager
+// ============================================
+
+class SyncManager {
+  /**
+   * Check if user is authenticated
+   */
+  async hasAuth(): Promise<boolean> {
+    return await authConfig.hasAuth()
+  }
+
+  /**
+   * Get sync status from API
+   */
+  async getStatus(projectId: string): Promise<SyncStatus | null> {
+    if (!(await this.hasAuth())) {
+      return null
+    }
+
+    try {
+      return await syncClient.getStatus(projectId)
+    } catch {
+      return null
+    }
+  }
+
+  /**
+   * Full sync: push local changes, then pull remote changes
+   */
+  async sync(projectId: string): Promise<SyncResult> {
+    // Check auth first
+    if (!(await this.hasAuth())) {
+      return { success: true, skipped: true, reason: 'no_auth' }
+    }
+
+    const result: SyncResult = { success: true, skipped: false }
+
+    // Push first
+    const pushResult = await this.push(projectId)
+    if (pushResult.success && !pushResult.skipped) {
+      result.pushed = {
+        count: pushResult.count || 0,
+        syncedAt: pushResult.syncedAt || new Date().toISOString(),
+      }
+    }
+
+    // Then pull
+    const pullResult = await this.pull(projectId)
+    if (pullResult.success && !pullResult.skipped) {
+      result.pulled = {
+        count: pullResult.count || 0,
+        syncedAt: pullResult.syncedAt || new Date().toISOString(),
+      }
+    }
+
+    // Determine overall success
+    if (!pushResult.success || !pullResult.success) {
+      result.success = false
+      result.error = pushResult.error || pullResult.error
+    }
+
+    return result
+  }
+
+  /**
+   * Push local pending events to the server
+   */
+  async push(projectId: string): Promise<PushResult> {
+    // Check auth first
+    if (!(await this.hasAuth())) {
+      return { success: true, skipped: true, reason: 'no_auth' }
+    }
+
+    try {
+      // Get pending events
+      const pending = await eventBus.getPending(projectId)
+
+      if (pending.length === 0) {
+        return { success: true, skipped: true, reason: 'no_pending' }
+      }
+
+      // Push to server
+      const result: SyncBatchResult = await syncClient.pushEvents(projectId, pending)
+
+      if (result.success) {
+        // Clear pending events on success
+        await eventBus.clearPending(projectId)
+        await eventBus.updateLastSync(projectId)
+
+        return {
+          success: true,
+          skipped: false,
+          count: result.processed,
+          syncedAt: result.syncedAt,
+        }
+      } else {
+        // Partial success - some events failed
+        const successCount = result.processed
+        const errorCount = result.errors.length
+        const errorMessages = result.errors.map((e) => e.error).join(', ')
+
+        return {
+          success: false,
+          skipped: false,
+          count: successCount,
+          syncedAt: result.syncedAt,
+          error: `${errorCount} events failed: ${errorMessages}`,
+        }
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      return {
+        success: false,
+        skipped: false,
+        reason: 'error',
+        error: message,
+      }
+    }
+  }
+
+  /**
+   * Pull remote changes from the server
+   */
+  async pull(projectId: string): Promise<PullResult> {
+    // Check auth first
+    if (!(await this.hasAuth())) {
+      return { success: true, skipped: true, reason: 'no_auth' }
+    }
+
+    try {
+      // Get last sync timestamp
+      const lastSync = await eventBus.getLastSync(projectId)
+      const since = lastSync?.timestamp
+
+      // Pull from server
+      const result: SyncPullResult = await syncClient.pullEvents(projectId, since)
+
+      if (result.events.length === 0) {
+        return {
+          success: true,
+          skipped: false,
+          count: 0,
+          applied: 0,
+          syncedAt: result.syncedAt,
+        }
+      }
+
+      // Apply pulled events to local storage
+      const applied = await this.applyPulledEvents(projectId, result.events)
+
+      // Update last sync timestamp
+      await eventBus.updateLastSync(projectId)
+
+      return {
+        success: true,
+        skipped: false,
+        count: result.events.length,
+        applied,
+        syncedAt: result.syncedAt,
+      }
+    } catch (error) {
+      const message = error instanceof Error ? error.message : 'Unknown error'
+      return {
+        success: false,
+        skipped: false,
+        reason: 'error',
+        error: message,
+      }
+    }
+  }
+
+  /**
+   * Apply pulled events to local storage
+   * Returns number of events successfully applied
+   */
+  async applyPulledEvents(
+    projectId: string,
+    events: Array<{ type: string; path: string[]; data: unknown; timestamp: string }>
+  ): Promise<number> {
+    let applied = 0
+
+    for (const event of events) {
+      try {
+        await this.applyEvent(projectId, event)
+        applied++
+      } catch (error) {
+        // Log but continue with other events
+        console.error(`Failed to apply event ${event.type}:`, error)
+      }
+    }
+
+    return applied
+  }
+
+  /**
+   * Apply a single event to local storage
+   */
+  private async applyEvent(
+    projectId: string,
+    event: { type: string; path: string[]; data: unknown; timestamp: string }
+  ): Promise<void> {
+    const [entity, action] = event.type.split('.') as [string, string]
+    const data = event.data as Record<string, unknown>
+
+    switch (entity) {
+      case 'task':
+        await this.applyTaskEvent(projectId, action, data)
+        break
+      case 'idea':
+        await this.applyIdeaEvent(projectId, action, data)
+        break
+      case 'shipped':
+        await this.applyShippedEvent(projectId, action, data)
+        break
+      // Add more entity handlers as needed
+    }
+  }
+
+  private async applyTaskEvent(
+    projectId: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
+    switch (action) {
+      case 'started':
+        // Update state if this is a newer task
+        await stateStorage.update(projectId, (state) => {
+          if (!state.currentTask || (data.id as string) !== state.currentTask.id) {
+            return {
+              ...state,
+              currentTask: {
+                id: data.id as string,
+                description: data.description as string,
+                startedAt: data.startedAt as string,
+                sessionId: data.sessionId as string,
+              },
+            }
+          }
+          return state
+        })
+        break
+      case 'completed':
+        // Clear current task if it matches
+        await stateStorage.update(projectId, (state) => {
+          if (state.currentTask?.id === data.id) {
+            return { ...state, currentTask: null }
+          }
+          return state
+        })
+        break
+      case 'created':
+        // Add to queue
+        await queueStorage.addTask(projectId, {
+          description: data.description as string,
+          priority: (data.priority as Priority) || 'medium',
+          type: (data.type as TaskType) || 'feature',
+          section: 'backlog' as TaskSection,
+        })
+        break
+    }
+  }
+
+  private async applyIdeaEvent(
+    projectId: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
+    switch (action) {
+      case 'created':
+        await ideasStorage.addIdea(
+          projectId,
+          (data.title as string) || (data.text as string),
+          { priority: (data.priority as IdeaPriority) || 'medium' }
+        )
+        break
+      case 'archived':
+        await ideasStorage.update(projectId, (ideas) => ({
+          ...ideas,
+          ideas: ideas.ideas.map((idea) =>
+            idea.id === data.id ? { ...idea, status: 'archived' as const } : idea
+          ),
+        }))
+        break
+    }
+  }
+
+  private async applyShippedEvent(
+    projectId: string,
+    action: string,
+    data: Record<string, unknown>
+  ): Promise<void> {
+    if (action === 'created') {
+      await shippedStorage.addShipped(projectId, {
+        name: (data.name as string) || (data.title as string),
+        version: data.version as string,
+        description: data.description as string,
+      })
+    }
+  }
+}
+
+export const syncManager = new SyncManager()
+export default syncManager

package/package.json

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

package/templates/commands/auth.md

@@ -0,0 +1,234 @@
+---
+allowed-tools: [Read, Write, Bash]
+description: 'Manage Cloud Authentication'
+timestamp-rule: 'GetTimestamp() for all timestamps'
+---
+
+# /p:auth - Cloud Authentication
+
+Manage authentication for prjct cloud sync.
+
+## Subcommands
+
+| Command | Purpose |
+|---------|---------|
+| `/p:auth` | Show current auth status |
+| `/p:auth login` | Authenticate with prjct cloud |
+| `/p:auth logout` | Clear authentication |
+| `/p:auth status` | Detailed auth status |
+
+## Context Variables
+- `{authPath}`: `~/.prjct-cli/config/auth.json`
+- `{apiUrl}`: API base URL (default: https://api.prjct.app)
+- `{dashboardUrl}`: Web dashboard URL (https://app.prjct.app)
+
+---
+
+## /p:auth (default) - Show Status
+
+### Flow
+
+1. READ: `{authPath}`
+2. IF authenticated:
+   - Show email and API key prefix
+3. ELSE:
+   - Show "Not authenticated" message
+
+### Output (Authenticated)
+
+```
+☁️ Cloud Sync: Connected
+
+Email: {email}
+API Key: {apiKeyPrefix}...
+Last auth: {lastAuth}
+
+Sync enabled for all projects.
+```
+
+### Output (Not Authenticated)
+
+```
+☁️ Cloud Sync: Not connected
+
+Run `/p:auth login` to enable cloud sync.
+
+Benefits:
+- Sync progress across devices
+- Access from web dashboard
+- Backup your project data
+```
+
+---
+
+## /p:auth login - Authenticate
+
+### Flow
+
+1. **Check existing auth**
+   READ: `{authPath}`
+   IF already authenticated:
+     ASK: "You're already logged in as {email}. Re-authenticate? (y/n)"
+     IF no: STOP
+
+2. **Open dashboard**
+   OUTPUT: "Opening prjct dashboard to get your API key..."
+   OPEN browser: `{dashboardUrl}/settings/api-keys`
+
+3. **Wait for API key**
+   OUTPUT instructions:
+   ```
+   1. Log in to prjct.app (GitHub OAuth)
+   2. Go to Settings → API Keys
+   3. Click "Create New Key"
+   4. Copy the key (starts with prjct_)
+   5. Paste it below
+   ```
+
+4. **Get API key from user**
+   PROMPT: "Paste your API key: "
+   READ: `{apiKey}` from user input
+
+5. **Validate key**
+   - Check format starts with "prjct_"
+   - Test connection with GET /health
+   - Fetch user info with GET /auth/me
+
+   IF invalid:
+     OUTPUT: "Invalid API key. Please try again."
+     STOP
+
+6. **Save auth**
+   WRITE: `{authPath}`
+   ```json
+   {
+     "apiKey": "{apiKey}",
+     "apiUrl": "https://api.prjct.app",
+     "userId": "{userId}",
+     "email": "{email}",
+     "lastAuth": "{GetTimestamp()}"
+   }
+   ```
+
+### Output (Success)
+
+```
+✅ Authentication successful!
+
+Logged in as: {email}
+API Key: {apiKeyPrefix}...
+
+Cloud sync is now enabled. Your projects will sync automatically
+when you run /p:sync or /p:ship.
+```
+
+### Output (Failure)
+
+```
+❌ Authentication failed
+
+{error}
+
+Please check your API key and try again.
+Get a new key at: {dashboardUrl}/settings/api-keys
+```
+
+---
+
+## /p:auth logout - Clear Auth
+
+### Flow
+
+1. READ: `{authPath}`
+   IF not authenticated:
+     OUTPUT: "Not logged in. Nothing to do."
+     STOP
+
+2. ASK: "Are you sure you want to log out? (y/n)"
+   IF no: STOP
+
+3. DELETE or CLEAR: `{authPath}`
+
+### Output
+
+```
+✅ Logged out successfully
+
+Cloud sync is now disabled.
+Run `/p:auth login` to re-enable.
+```
+
+---
+
+## /p:auth status - Detailed Status
+
+### Flow
+
+1. READ: `{authPath}`
+2. IF authenticated:
+   - Test connection
+   - Show detailed status
+3. ELSE:
+   - Show not connected message
+
+### Output (Connected)
+
+```
+☁️ Cloud Authentication Status
+
+Connection:    ✓ Connected
+Email:         {email}
+User ID:       {userId}
+API Key:       {apiKeyPrefix}...
+API URL:       {apiUrl}
+Last Auth:     {lastAuth}
+
+API Status:    ✓ Reachable
+```
+
+### Output (Connection Error)
+
+```
+☁️ Cloud Authentication Status
+
+Connection:    ⚠️ Error
+Email:         {email}
+API Key:       {apiKeyPrefix}...
+API URL:       {apiUrl}
+
+Error: {connectionError}
+
+Try `/p:auth login` to re-authenticate.
+```
+
+---
+
+## Error Handling
+
+| Error | Response |
+|-------|----------|
+| Invalid key format | "API key must start with prjct_" |
+| Key rejected by API | "Invalid or expired API key" |
+| Network error | "Cannot connect to {apiUrl}. Check internet." |
+| Already logged in | Offer to re-authenticate |
+
+---
+
+## Auth File Structure
+
+Location: `~/.prjct-cli/config/auth.json`
+
+```json
+{
+  "apiKey": "prjct_live_xxxxxxxxxxxxxxxxxxxx",
+  "apiUrl": "https://api.prjct.app",
+  "userId": "uuid-from-server",
+  "email": "user@example.com",
+  "lastAuth": "2024-01-15T10:00:00.000Z"
+}
+```
+
+**Security Notes:**
+- API key is stored in plain text (like git credentials)
+- File permissions should be 600 (user read/write only)
+- Never commit this file to version control

package/templates/commands/sync.md

@@ -54,6 +54,42 @@ Git Analysis → Storage (JSON) → Context (MD) → Project Metadata
 
 ---
 
+## Step 0: Migration Check (Legacy Projects)
+
+CHECK: Does `.prjct/prjct.config.json` exist?
+
+IF file exists:
+  READ: `.prjct/prjct.config.json`
+  CHECK: Does `projectId` exist and is it a valid UUID?
+
+  IF projectId is missing OR not a UUID:
+    MIGRATE to UUID:
+    1. Generate new UUID: `{newProjectId}`
+    2. Create global structure: `~/.prjct-cli/projects/{newProjectId}/`
+    3. Create subdirectories: storage/, context/, agents/, memory/, analysis/
+    4. IF legacy data exists in `.prjct/`:
+       - Migrate core/now.md → storage/state.json
+       - Migrate planning/ideas.md → storage/ideas.json
+       - Migrate progress/shipped.md → storage/shipped.json
+    5. Update `.prjct/prjct.config.json` with new `projectId`
+    OUTPUT: "🔄 Migrated to UUID format: {newProjectId}"
+
+IF file not found:
+  CHECK: Does `.prjct/` directory exist? (legacy project without config)
+
+  IF `.prjct/` exists:
+    MIGRATE:
+    1. Generate new UUID: `{newProjectId}`
+    2. Create `.prjct/prjct.config.json` with `projectId`
+    3. Create global structure
+    4. Migrate legacy data
+    OUTPUT: "🔄 Migrated legacy project to UUID: {newProjectId}"
+  ELSE:
+    OUTPUT: "No prjct project. Run /p:init first."
+    STOP
+
+---
+
 ## Step 1: Read Config
 
 READ: `.prjct/prjct.config.json`
@@ -409,6 +445,52 @@ APPEND to: `{globalPath}/memory/events.jsonl`
 
 ---
 
+## Step 9: Backend Sync (Cloud)
+
+Sync with prjct API if authenticated.
+
+### 9.1 Check Authentication
+
+READ: `~/.prjct-cli/config/auth.json`
+
+IF no auth OR no apiKey:
+  SET: `{cloudSync}` = false
+  OUTPUT TIP: "💡 Run `prjct auth` to enable cloud sync"
+  CONTINUE to output (skip 9.2, 9.3)
+
+ELSE:
+  SET: `{cloudSync}` = true
+
+### 9.2 Push Pending Events
+
+READ: `{globalPath}/sync/pending.json`
+COUNT: `{pendingCount}` events
+
+IF pendingCount > 0:
+  CALL syncManager.push(projectId)
+
+  IF success:
+    SET: `{pushedCount}` = result.count
+    OUTPUT: "☁️ Pushed {pushedCount} events to cloud"
+  ELSE:
+    OUTPUT: "⚠️ Cloud sync failed: {error}. Events queued for retry."
+    SET: `{syncError}` = error
+ELSE:
+  SET: `{pushedCount}` = 0
+
+### 9.3 Pull Updates (if push succeeded)
+
+IF cloudSync AND no syncError:
+  CALL syncManager.pull(projectId)
+
+  IF success AND result.count > 0:
+    SET: `{pulledCount}` = result.count
+    OUTPUT: "📥 Pulled {pulledCount} updates from cloud"
+  ELSE:
+    SET: `{pulledCount}` = 0
+
+---
+
 ## Output
 
 ```
@@ -436,6 +518,15 @@ APPEND to: `{globalPath}/memory/events.jsonl`
 ├── Workflow: prjct-workflow, prjct-planner, prjct-shipper
 └── Domain: {domainAgents.join(', ') || 'none'}
 
+{IF cloudSync}
+☁️ Cloud Sync
+├── Pushed: {pushedCount} events
+├── Pulled: {pulledCount} updates
+└── Status: {syncError ? "⚠️ " + syncError : "✓ Synced"}
+{ELSE}
+💡 Cloud sync disabled. Run `prjct auth` to enable.
+{ENDIF}
+
 {IF hasUncommittedChanges}
 ⚠️  You have uncommitted changes