prjct-cli 0.17.0 → 0.18.0

package/core/__tests__/agentic/memory-system.test.ts

@@ -29,7 +29,8 @@ describe('MemorySystem P3.3', () => {
         userTriggered: true
       })
 
-      expect(memoryId).toMatch(/^mem_/)
+      // UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+      expect(memoryId).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
 
       const memories = await memorySystem.getAllMemories(TEST_PROJECT_ID)
       expect(memories.length).toBe(1)

package/core/__tests__/agentic/plan-mode.test.ts

@@ -92,7 +92,8 @@ describe('PlanMode P3.4', () => {
     it('should create a new plan with correct initial state', () => {
       const plan = planMode.startPlanning(TEST_PROJECT_ID, 'feature', { description: 'Add dark mode' })
 
-      expect(plan.id).toMatch(/^plan_/)
+      // UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx
+      expect(plan.id).toMatch(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i)
       expect(plan.projectId).toBe(TEST_PROJECT_ID)
       expect(plan.command).toBe('feature')
       expect(plan.status).toBe(PLAN_STATUS.GATHERING)

package/core/agentic/agent-router.ts

@@ -54,7 +54,7 @@ class AgentRouter {
   async initialize(projectPath: string): Promise<void> {
     this.projectId = await configManager.getProjectId(projectPath)
     this.projectPath = projectPath
-    this.legacyAgentsPath = pathManager.getPath(this.projectId!, 'agents')
+    this.legacyAgentsPath = pathManager.getFilePath(this.projectId!, 'agents', '')
   }
 
   /**

package/core/command-registry/setup-commands.ts

@@ -65,4 +65,19 @@ export const SETUP_COMMANDS: Command[] = [
     requiresInit: false,
     blockingRules: null,
   },
+
+  {
+    name: 'auth',
+    category: 'setup',
+    description: 'Manage cloud authentication',
+    usage: {
+      claude: '/p:auth [login|logout|status]',
+      terminal: 'prjct auth [login|logout|status]',
+    },
+    params: '[login|logout|status]',
+    implemented: true,
+    hasTemplate: true,
+    requiresInit: false,
+    blockingRules: null,
+  },
 ]

package/core/domain/agent-generator.ts

@@ -38,9 +38,9 @@ class AgentGenerator {
 
   constructor(projectId: string | null = null) {
     this.projectId = projectId
-    // NEW: Write to data/agents/ for JSON storage (OpenCode-style)
+    // Write to agents/ for MD storage (matches AgentLoader)
     this.outputDir = projectId
-      ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'data', 'agents')
+      ? path.join(os.homedir(), '.prjct-cli', 'projects', projectId, 'agents')
       : path.join(os.homedir(), '.prjct-cli', 'agents')
     this.loader = new AgentLoader(projectId)
   }
@@ -54,18 +54,10 @@ class AgentGenerator {
     log.debug(`Generating ${agentName} agent...`)
     await fs.mkdir(this.outputDir, { recursive: true })
 
-    // Write as JSON (OpenCode-style storage)
-    const agent = {
-      name: agentName,
-      role: config.role || agentName,
-      domain: config.domain || 'general',
-      expertise: config.expertise || '',
-      contextFilter: config.contextFilter || 'Only relevant files',
-      createdAt: new Date().toISOString()
-    }
-
-    const outputPath = path.join(this.outputDir, `${agentName}.json`)
-    await fs.writeFile(outputPath, JSON.stringify(agent, null, 2), 'utf-8')
+    // Write as MD (matches AgentLoader which reads .md files)
+    const content = this.buildAgentPrompt(agentName, config)
+    const outputPath = path.join(this.outputDir, `${agentName}.md`)
+    await fs.writeFile(outputPath, content, 'utf-8')
     log.debug(`${agentName} agent created`)
 
     return { name: agentName }
@@ -135,10 +127,10 @@ ${config.contextFilter || 'Only relevant files'}
 
     try {
       const files = await fs.readdir(this.outputDir)
-      const agentFiles = files.filter((f) => f.endsWith('.json') && !f.startsWith('.'))
+      const agentFiles = files.filter((f) => f.endsWith('.md') && !f.startsWith('.'))
 
       for (const file of agentFiles) {
-        const type = file.replace('.json', '')
+        const type = file.replace('.md', '')
 
         if (!requiredAgents.includes(type)) {
           const filePath = path.join(this.outputDir, file)
@@ -160,7 +152,7 @@ ${config.contextFilter || 'Only relevant files'}
   async listAgents(): Promise<string[]> {
     try {
       const files = await fs.readdir(this.outputDir)
-      return files.filter((f) => f.endsWith('.json') && !f.startsWith('.')).map((f) => f.replace('.json', ''))
+      return files.filter((f) => f.endsWith('.md') && !f.startsWith('.')).map((f) => f.replace('.md', ''))
     } catch {
       return []
     }

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/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,6 +13,7 @@ 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
@@ -67,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
    */

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