prjct-cli 0.17.0 → 0.18.1

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

@@ -2,14 +2,13 @@
  * Agent Router
  * Orchestrates agent loading and context building for Claude delegation.
  *
- * Loads agents from two locations:
- * 1. {projectPath}/.claude/agents/ - Claude Code sub-agents (PRIMARY, per-project)
- * 2. ~/.prjct-cli/projects/{id}/agents/ - Legacy agents (fallback)
+ * Loads agents from global storage:
+ * ~/.prjct-cli/projects/{id}/agents/
  *
- * Claude Code sub-agents are prioritized as they're more specific to the project.
+ * Agents are dynamically generated by /p:sync based on project tech stack.
  *
  * @module agentic/agent-router
- * @version 3.0.0
+ * @version 4.0.0
  */
 
 import fs from 'fs/promises'
@@ -20,7 +19,6 @@ import pathManager from '../infrastructure/path-manager'
 interface Agent {
   name: string
   content: string
-  source: 'claude-code' | 'legacy'
 }
 
 interface AssignmentContext {
@@ -38,15 +36,7 @@ interface AssignmentContext {
 class AgentRouter {
   projectId: string | null = null
   projectPath: string | null = null
-  legacyAgentsPath: string | null = null
-
-  /**
-   * Get path to Claude Code sub-agents directory
-   */
-  getClaudeCodeAgentsPath(): string | null {
-    if (!this.projectPath) return null
-    return path.join(this.projectPath, '.claude', 'agents')
-  }
+  agentsPath: string | null = null
 
   /**
    * Initialize router with project context
@@ -54,25 +44,24 @@ 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.agentsPath = pathManager.getFilePath(this.projectId!, 'agents', '')
   }
 
   /**
-   * Load agents from a specific directory
+   * Load all available agents from global storage
    */
-  private async loadAgentsFromPath(
-    agentsPath: string,
-    source: 'claude-code' | 'legacy'
-  ): Promise<Agent[]> {
+  async loadAvailableAgents(): Promise<Agent[]> {
+    if (!this.agentsPath) return []
+
     try {
-      const files = await fs.readdir(agentsPath)
+      const files = await fs.readdir(this.agentsPath)
       const agents: Agent[] = []
 
       for (const file of files) {
         if (file.endsWith('.md')) {
           const name = file.replace('.md', '')
-          const content = await fs.readFile(path.join(agentsPath, file), 'utf-8')
-          agents.push({ name, content, source })
+          const content = await fs.readFile(path.join(this.agentsPath, file), 'utf-8')
+          agents.push({ name, content })
         }
       }
 
@@ -82,33 +71,6 @@ class AgentRouter {
     }
   }
 
-  /**
-   * Load all available agents from both Claude Code and legacy locations
-   * Claude Code sub-agents take priority over legacy agents with same name
-   */
-  async loadAvailableAgents(): Promise<Agent[]> {
-    const agentMap = new Map<string, Agent>()
-
-    // Load legacy agents first (lower priority)
-    if (this.legacyAgentsPath) {
-      const legacyAgents = await this.loadAgentsFromPath(this.legacyAgentsPath, 'legacy')
-      for (const agent of legacyAgents) {
-        agentMap.set(agent.name, agent)
-      }
-    }
-
-    // Load Claude Code sub-agents (higher priority - overwrites legacy)
-    const claudeCodePath = this.getClaudeCodeAgentsPath()
-    if (claudeCodePath) {
-      const claudeCodeAgents = await this.loadAgentsFromPath(claudeCodePath, 'claude-code')
-      for (const agent of claudeCodeAgents) {
-        agentMap.set(agent.name, agent)
-      }
-    }
-
-    return Array.from(agentMap.values())
-  }
-
   /**
    * Get list of available agent names
    */
@@ -118,34 +80,18 @@ class AgentRouter {
   }
 
   /**
-   * Load a specific agent by name
-   * Checks Claude Code sub-agents first, then falls back to legacy
+   * Load a specific agent by name from global storage
    */
   async loadAgent(name: string): Promise<Agent | null> {
-    // Try Claude Code sub-agents first (higher priority)
-    const claudeCodePath = this.getClaudeCodeAgentsPath()
-    if (claudeCodePath) {
-      try {
-        const filePath = path.join(claudeCodePath, `${name}.md`)
-        const content = await fs.readFile(filePath, 'utf-8')
-        return { name, content, source: 'claude-code' }
-      } catch {
-        // Not found in Claude Code path, try legacy
-      }
-    }
+    if (!this.agentsPath) return null
 
-    // Fall back to legacy agents
-    if (this.legacyAgentsPath) {
-      try {
-        const filePath = path.join(this.legacyAgentsPath, `${name}.md`)
-        const content = await fs.readFile(filePath, 'utf-8')
-        return { name, content, source: 'legacy' }
-      } catch {
-        // Not found
-      }
+    try {
+      const filePath = path.join(this.agentsPath, `${name}.md`)
+      const content = await fs.readFile(filePath, 'utf-8')
+      return { name, content }
+    } catch {
+      return null
     }
-
-    return null
   }
 
   /**

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'