prjct-cli 0.15.1 → 0.18.0

package/core/infrastructure/path-manager.ts

@@ -114,7 +114,7 @@ class PathManager {
 
     const projectPath = this.getGlobalProjectPath(projectId)
 
-    const layers = ['core', 'progress', 'planning', 'analysis', 'memory']
+    const layers = ['core', 'progress', 'planning', 'analysis', 'memory', 'agents']
 
     for (const layer of layers) {
       await fileHelper.ensureDir(path.join(projectPath, layer))
@@ -252,6 +252,28 @@ class PathManager {
     }
     return absolutePath
   }
+
+  /**
+   * Get the auth config file path for cloud sync
+   * Stored in global config directory, not project-specific
+   */
+  getAuthConfigPath(): string {
+    return path.join(this.globalConfigDir, 'auth.json')
+  }
+
+  /**
+   * Get the sync pending events file path for a project
+   */
+  getSyncPendingPath(projectId: string): string {
+    return path.join(this.getGlobalProjectPath(projectId), 'sync', 'pending.json')
+  }
+
+  /**
+   * Get the last sync timestamp file path for a project
+   */
+  getLastSyncPath(projectId: string): string {
+    return path.join(this.getGlobalProjectPath(projectId), 'sync', 'last-sync.json')
+  }
 }
 
 const pathManager = new PathManager()

package/core/infrastructure/setup.ts

@@ -2,24 +2,18 @@
  * Setup Module - Core installation logic
  *
  * Executes ALL setup needed for prjct-cli:
- * 1. Detect and clean legacy installation (curl-based)
- * 2. Install Claude Code CLI if missing
- * 3. Sync commands to ~/.claude/commands/p/
- * 4. Install global config ~/.claude/CLAUDE.md
- * 5. Migrate legacy projects automatically
- * 6. Save version in editors-config
+ * 1. Install Claude Code CLI if missing
+ * 2. Sync commands to ~/.claude/commands/p/
+ * 3. Install global config ~/.claude/CLAUDE.md
+ * 4. Save version in editors-config
  *
  * This module is called from:
  * - core/index.js (on first CLI use)
  * - scripts/postinstall.js (if npm scripts are enabled)
- *
- * @version 0.8.8
  */
 
 import { execSync } from 'child_process'
 import installer from './command-installer'
-import migrator from './migrator'
-import legacyDetector from './legacy-installer-detector'
 import editorsConfig from './editors-config'
 import { VERSION } from '../utils/version'
 
@@ -30,13 +24,10 @@ const DIM = '\x1b[2m'
 const NC = '\x1b[0m'
 
 interface SetupResults {
-  legacyCleaned: boolean
-  legacyProjectsMigrated: number
   claudeInstalled: boolean
   commandsAdded: number
   commandsUpdated: number
   configAction: string | null
-  projectsMigrated: number
 }
 
 /**
@@ -76,21 +67,10 @@ async function installClaudeCode(): Promise<boolean> {
  */
 export async function run(): Promise<SetupResults> {
   const results: SetupResults = {
-    legacyCleaned: false,
-    legacyProjectsMigrated: 0,
     claudeInstalled: false,
     commandsAdded: 0,
     commandsUpdated: 0,
     configAction: null,
-    projectsMigrated: 0,
-  }
-
-  // Step 0: Detect and clean legacy curl installation
-  const needsLegacyCleanup = await legacyDetector.needsCleanup()
-  if (needsLegacyCleanup) {
-    const cleanupResult = await legacyDetector.performCleanup({ verbose: true })
-    results.legacyCleaned = cleanupResult.success
-    results.legacyProjectsMigrated = cleanupResult.steps.projectsMigrated
   }
 
   // Step 1: Ensure Claude Code CLI is installed
@@ -123,20 +103,9 @@ export async function run(): Promise<SetupResults> {
     if (configResult.success) {
       results.configAction = configResult.action
     }
-
-    // Step 5: Migrate legacy projects automatically
-    const migrationResult = await migrator.migrateAll({
-      deepScan: false,
-      cleanupLegacy: true,
-      dryRun: false,
-    })
-
-    if (migrationResult.successfullyMigrated > 0) {
-      results.projectsMigrated = migrationResult.successfullyMigrated
-    }
   }
 
-  // Step 6: Save version in editors-config
+  // Step 5: Save version in editors-config
   await editorsConfig.saveConfig(VERSION, installer.getInstallPath())
 
   // Show results
@@ -154,16 +123,6 @@ export default { run }
 function showResults(results: SetupResults): void {
   console.log('')
 
-  // Show what was done
-  if (results.legacyCleaned) {
-    console.log(`   ${GREEN}✓${NC} Legacy curl installation cleaned up`)
-    if (results.legacyProjectsMigrated > 0) {
-      console.log(
-        `   ${GREEN}✓${NC} ${results.legacyProjectsMigrated} project(s) migrated from legacy`
-      )
-    }
-  }
-
   if (results.claudeInstalled) {
     console.log(`   ${GREEN}✓${NC} Claude Code CLI installed`)
   } else {
@@ -188,9 +147,5 @@ function showResults(results: SetupResults): void {
     console.log(`   ${GREEN}✓${NC} Global config merged`)
   }
 
-  if (results.projectsMigrated > 0) {
-    console.log(`   ${GREEN}✓${NC} ${results.projectsMigrated} projects migrated to global storage`)
-  }
-
   console.log('')
 }

package/core/storage/ideas-storage.ts

@@ -42,6 +42,10 @@ class IdeasStorage extends StorageManager<IdeasJson> {
     return 'ideas.md'
   }
 
+  protected getLayer(): string {
+    return 'planning'
+  }
+
   protected getEventType(action: 'update' | 'create' | 'delete'): string {
     return `ideas.${action}d`
   }

package/core/storage/queue-storage.ts

@@ -25,6 +25,10 @@ class QueueStorage extends StorageManager<QueueJson> {
     return 'next.md'
   }
 
+  protected getLayer(): string {
+    return 'core'
+  }
+
   protected getEventType(action: 'update' | 'create' | 'delete'): string {
     return `queue.${action}d`
   }

package/core/storage/shipped-storage.ts

@@ -39,6 +39,10 @@ class ShippedStorage extends StorageManager<ShippedJson> {
     return 'shipped.md'
   }
 
+  protected getLayer(): string {
+    return 'progress'
+  }
+
   protected getEventType(action: 'update' | 'create' | 'delete'): string {
     return `shipped.${action}d`
   }

package/core/storage/state-storage.ts

@@ -26,6 +26,10 @@ class StateStorage extends StorageManager<StateJson> {
     return 'now.md'
   }
 
+  protected getLayer(): string {
+    return 'core'
+  }
+
   protected getEventType(action: 'update' | 'create' | 'delete'): string {
     return `state.${action}d`
   }

package/core/storage/storage-manager.ts

@@ -13,16 +13,46 @@ import fs from 'fs/promises'
 import path from 'path'
 import os from 'os'
 import { eventBus, type SyncEvent } from '../events'
+import pathManager from '../infrastructure/path-manager'
+
+interface CacheEntry<T> {
+  data: T
+  timestamp: number
+}
 
 export abstract class StorageManager<T> {
   protected filename: string
-  protected cache: Map<string, T> = new Map()
+  protected cache: Map<string, CacheEntry<T>> = new Map()
   protected cacheTimeout = 5000 // 5 seconds
+  protected maxCacheSize = 50 // Max projects to cache
 
   constructor(filename: string) {
     this.filename = filename
   }
 
+  /**
+   * Check if cache entry is still valid
+   */
+  private isCacheValid(entry: CacheEntry<T>): boolean {
+    return Date.now() - entry.timestamp < this.cacheTimeout
+  }
+
+  /**
+   * Evict oldest entries if cache exceeds max size
+   */
+  private evictOldEntries(): void {
+    if (this.cache.size <= this.maxCacheSize) return
+
+    // Sort by timestamp and remove oldest
+    const entries = Array.from(this.cache.entries())
+      .sort((a, b) => a[1].timestamp - b[1].timestamp)
+
+    const toRemove = entries.slice(0, this.cache.size - this.maxCacheSize)
+    for (const [key] of toRemove) {
+      this.cache.delete(key)
+    }
+  }
+
   /**
    * Get file path for storage JSON
    */
@@ -38,17 +68,19 @@ export abstract class StorageManager<T> {
 
   /**
    * Get file path for context MD
+   * Uses layer-based paths to match MdBaseManager structure
    */
   protected getContextPath(projectId: string, mdFilename: string): string {
-    return path.join(
-      os.homedir(),
-      '.prjct-cli/projects',
-      projectId,
-      'context',
-      mdFilename
-    )
+    const layer = this.getLayer()
+    return pathManager.getFilePath(projectId, layer, mdFilename)
   }
 
+  /**
+   * Get the layer for context MD files
+   * Override in subclasses: 'core' | 'planning' | 'progress'
+   */
+  protected abstract getLayer(): string
+
   /**
    * Get default data structure
    */
@@ -73,10 +105,15 @@ export abstract class StorageManager<T> {
    * Read data from storage
    */
   async read(projectId: string): Promise<T> {
-    // Check cache first
+    // Check cache first (with expiration)
     const cached = this.cache.get(projectId)
+    if (cached && this.isCacheValid(cached)) {
+      return cached.data
+    }
+
+    // Remove expired entry
     if (cached) {
-      return cached
+      this.cache.delete(projectId)
     }
 
     const filePath = this.getStoragePath(projectId)
@@ -84,7 +121,8 @@ export abstract class StorageManager<T> {
     try {
       const content = await fs.readFile(filePath, 'utf-8')
       const data = JSON.parse(content) as T
-      this.cache.set(projectId, data)
+      this.cache.set(projectId, { data, timestamp: Date.now() })
+      this.evictOldEntries()
       return data
     } catch {
       // Return default if file doesn't exist
@@ -112,8 +150,9 @@ export abstract class StorageManager<T> {
     const md = this.toMarkdown(data)
     await fs.writeFile(contextPath, md, 'utf-8')
 
-    // 3. Update cache
-    this.cache.set(projectId, data)
+    // 3. Update cache with timestamp
+    this.cache.set(projectId, { data, timestamp: Date.now() })
+    this.evictOldEntries()
 
     // 4. Publish event for backend sync (NOT included in this call - subclass handles)
   }

package/core/sync/auth-config.ts

@@ -0,0 +1,145 @@
+/**
+ * Auth Config - Manages API key storage for cloud sync
+ *
+ * Stores credentials in ~/.prjct-cli/config/auth.json
+ * Used by SyncClient to authenticate with prjct API
+ */
+
+import path from 'path'
+import os from 'os'
+import * as fileHelper from '../utils/file-helper'
+
+export interface AuthConfig {
+  apiKey: string | null
+  apiUrl: string
+  userId: string | null
+  email: string | null
+  lastAuth: string | null
+}
+
+const DEFAULT_API_URL = 'https://api.prjct.app'
+
+const DEFAULT_CONFIG: AuthConfig = {
+  apiKey: null,
+  apiUrl: DEFAULT_API_URL,
+  userId: null,
+  email: null,
+  lastAuth: null,
+}
+
+class AuthConfigManager {
+  private configPath: string
+  private cachedConfig: AuthConfig | null = null
+
+  constructor() {
+    this.configPath = path.join(os.homedir(), '.prjct-cli', 'config', 'auth.json')
+  }
+
+  /**
+   * Get the auth config file path
+   */
+  getConfigPath(): string {
+    return this.configPath
+  }
+
+  /**
+   * Read auth config from disk
+   */
+  async read(): Promise<AuthConfig> {
+    if (this.cachedConfig) {
+      return this.cachedConfig
+    }
+
+    const config = await fileHelper.readJson<AuthConfig>(this.configPath)
+    this.cachedConfig = config ?? { ...DEFAULT_CONFIG }
+    return this.cachedConfig
+  }
+
+  /**
+   * Write auth config to disk
+   */
+  async write(config: Partial<AuthConfig>): Promise<void> {
+    const current = await this.read()
+    const updated: AuthConfig = {
+      ...current,
+      ...config,
+      lastAuth: new Date().toISOString(),
+    }
+
+    await fileHelper.ensureDir(path.dirname(this.configPath))
+    await fileHelper.writeJson(this.configPath, updated)
+    this.cachedConfig = updated
+  }
+
+  /**
+   * Check if user is authenticated (has valid API key)
+   */
+  async hasAuth(): Promise<boolean> {
+    const config = await this.read()
+    return config.apiKey !== null && config.apiKey.length > 0
+  }
+
+  /**
+   * Get the API key if available
+   */
+  async getApiKey(): Promise<string | null> {
+    const config = await this.read()
+    return config.apiKey
+  }
+
+  /**
+   * Get the API URL (allows override for dev/staging)
+   */
+  async getApiUrl(): Promise<string> {
+    const config = await this.read()
+    return config.apiUrl || DEFAULT_API_URL
+  }
+
+  /**
+   * Save API key and user info after successful auth
+   */
+  async saveAuth(apiKey: string, userId: string, email: string): Promise<void> {
+    await this.write({
+      apiKey,
+      userId,
+      email,
+    })
+  }
+
+  /**
+   * Clear all auth data (logout)
+   */
+  async clearAuth(): Promise<void> {
+    this.cachedConfig = { ...DEFAULT_CONFIG }
+    await fileHelper.writeJson(this.configPath, this.cachedConfig)
+  }
+
+  /**
+   * Get auth status for display
+   */
+  async getStatus(): Promise<{
+    authenticated: boolean
+    email: string | null
+    apiKeyPrefix: string | null
+    lastAuth: string | null
+  }> {
+    const config = await this.read()
+
+    return {
+      authenticated: config.apiKey !== null,
+      email: config.email,
+      apiKeyPrefix: config.apiKey ? config.apiKey.substring(0, 12) + '...' : null,
+      lastAuth: config.lastAuth,
+    }
+  }
+
+  /**
+   * Clear cache (useful for testing)
+   */
+  clearCache(): void {
+    this.cachedConfig = null
+  }
+}
+
+export const authConfig = new AuthConfigManager()
+export default authConfig

package/core/sync/index.ts

@@ -0,0 +1,30 @@
+/**
+ * Sync Module - Cloud synchronization for prjct-cli
+ *
+ * Provides:
+ * - AuthConfig: API key storage and management
+ * - SyncClient: HTTP client for prjct API
+ * - SyncManager: Orchestrates push/pull operations
+ * - OAuthHandler: Authentication flow management
+ */
+
+// Auth
+export { authConfig, type AuthConfig } from './auth-config'
+
+// OAuth
+export { oauthHandler, type AuthResult } from './oauth-handler'
+
+// Client
+export {
+  syncClient,
+  type SyncBatchResult,
+  type SyncPullResult,
+  type SyncStatus,
+  type SyncClientError,
+} from './sync-client'
+
+// Manager
+export { syncManager, type SyncResult, type PushResult, type PullResult } from './sync-manager'
+
+// Default export is the main sync manager
+export { syncManager as default } from './sync-manager'

package/core/sync/oauth-handler.ts

@@ -0,0 +1,148 @@
+/**
+ * OAuth Handler - Manages authentication flow for CLI
+ *
+ * Two modes:
+ * 1. Simple: User copies API key from web dashboard
+ * 2. Browser (future): Full OAuth device flow
+ */
+
+import { authConfig } from './auth-config'
+import { syncClient } from './sync-client'
+
+export interface AuthResult {
+  success: boolean
+  email?: string
+  error?: string
+}
+
+class OAuthHandler {
+  /**
+   * Start authentication flow
+   * Opens browser to dashboard where user can create/copy API key
+   */
+  async startAuthFlow(): Promise<{ url: string }> {
+    const apiUrl = await authConfig.getApiUrl()
+    // Dashboard URL where user can get their API key
+    const dashboardUrl = apiUrl.replace('api.', 'app.')
+    const authUrl = `${dashboardUrl}/settings/api-keys`
+
+    return { url: authUrl }
+  }
+
+  /**
+   * Save API key after user provides it
+   */
+  async saveApiKey(apiKey: string): Promise<AuthResult> {
+    // Validate format
+    if (!apiKey.startsWith('prjct_')) {
+      return {
+        success: false,
+        error: 'Invalid API key format. Keys start with "prjct_"',
+      }
+    }
+
+    // Save temporarily to test connection
+    await authConfig.write({ apiKey })
+
+    // Test the key by making a request
+    const isValid = await syncClient.testConnection()
+
+    if (!isValid) {
+      // Clear the invalid key
+      await authConfig.clearAuth()
+      return {
+        success: false,
+        error: 'API key is invalid or expired',
+      }
+    }
+
+    // Key is valid - fetch user info
+    try {
+      const userInfo = await this.fetchUserInfo(apiKey)
+
+      await authConfig.saveAuth(apiKey, userInfo.id, userInfo.email)
+
+      return {
+        success: true,
+        email: userInfo.email,
+      }
+    } catch {
+      // Key works but couldn't fetch user info - still save it
+      await authConfig.write({ apiKey })
+      return {
+        success: true,
+      }
+    }
+  }
+
+  /**
+   * Fetch user info using the API key
+   */
+  private async fetchUserInfo(
+    apiKey: string
+  ): Promise<{ id: string; email: string; name: string }> {
+    const apiUrl = await authConfig.getApiUrl()
+
+    const response = await fetch(`${apiUrl}/auth/me`, {
+      headers: {
+        'X-Api-Key': apiKey,
+      },
+    })
+
+    if (!response.ok) {
+      throw new Error('Failed to fetch user info')
+    }
+
+    const data = (await response.json()) as {
+      user: { id: string; email: string; name: string }
+    }
+    return data.user
+  }
+
+  /**
+   * Check if currently authenticated
+   */
+  async isAuthenticated(): Promise<boolean> {
+    return await authConfig.hasAuth()
+  }
+
+  /**
+   * Get current auth status
+   */
+  async getStatus(): Promise<{
+    authenticated: boolean
+    email: string | null
+    apiKeyPrefix: string | null
+  }> {
+    return await authConfig.getStatus()
+  }
+
+  /**
+   * Logout - clear all auth data
+   */
+  async logout(): Promise<void> {
+    await authConfig.clearAuth()
+  }
+
+  /**
+   * Open URL in default browser
+   */
+  async openBrowser(url: string): Promise<void> {
+    const { exec } = await import('child_process')
+    const { promisify } = await import('util')
+    const execAsync = promisify(exec)
+
+    const platform = process.platform
+    const command =
+      platform === 'darwin'
+        ? `open "${url}"`
+        : platform === 'win32'
+          ? `start "${url}"`
+          : `xdg-open "${url}"`
+
+    await execAsync(command)
+  }
+}
+
+export const oauthHandler = new OAuthHandler()
+export default oauthHandler