prjct-cli 0.35.2 → 0.35.4

package/core/commands/analysis.ts

@@ -16,6 +16,7 @@ import {
 import analyzer from '../domain/analyzer'
 import { generateContext } from '../context/generator'
 import commandInstaller from '../infrastructure/command-installer'
+import { syncService } from '../services'
 
 export class AnalysisCommands extends PrjctCommandsBase {
   /**
@@ -189,58 +190,83 @@ export class AnalysisCommands extends PrjctCommandsBase {
   }
 
   /**
-   * /p:sync - Sync project state with raw data for Claude to analyze
+   * /p:sync - Comprehensive project sync
    *
-   * AGENTIC: This command gathers RAW data and puts it in CLAUDE.md
-   * Claude then reads the data and decides what agents to create.
-   * NO hardcoded if/else logic for technology detection.
+   * Uses syncService to do ALL operations in one TypeScript execution:
+   * - Git analysis
+   * - Project stats
+   * - Agent generation
+   * - Context file generation
+   * - Skill configuration
+   * - State updates
+   *
+   * This eliminates the need for Claude to make 50+ individual tool calls.
    */
   async sync(projectPath: string = process.cwd()): Promise<CommandResult> {
     try {
       const initResult = await this.ensureProjectInit(projectPath)
       if (!initResult.success) return initResult
 
-      await this.initializeAgent()
-
-      console.log('🔄 Syncing project state...\n')
+      console.log('🔄 Syncing project...\n')
 
-      // 1. Run analysis to gather raw data
-      console.log('📊 Running analysis...')
-      const analysisResult = await this.analyze({}, projectPath)
+      // Use syncService to do EVERYTHING in one call
+      const result = await syncService.sync(projectPath)
 
-      if (!analysisResult.success) {
-        console.error('❌ Analysis failed')
-        return analysisResult
+      if (!result.success) {
+        console.error('❌ Sync failed:', result.error)
+        return { success: false, error: result.error }
       }
 
-      const projectId = await configManager.getProjectId(projectPath)
-
-      // 2. Generate CLAUDE.md with RAW DATA (no processing)
-      // Claude will read this and decide what to do
-      await generateContext(projectId!, projectPath)
-
-      // 3. Update global config
+      // Update global config
       const globalConfigResult = await commandInstaller.installGlobalConfig()
       if (globalConfigResult.success) {
         console.log('📝 Updated ~/.claude/CLAUDE.md')
       }
 
-      // 4. Log to memory
-      await this.logToMemory(projectPath, 'sync_complete', {
-        timestamp: dateHelper.getTimestamp(),
-        projectId,
-      })
+      // Format output
+      console.log(`🔄 Project synced to prjct v${result.cliVersion}\n`)
 
-      console.log('\n✅ Sync complete!\n')
-      console.log('📝 Context: ~/.prjct-cli/projects/' + projectId + '/CLAUDE.md')
-      console.log('\n📋 CLAUDE.md contains RAW project data.')
-      console.log('💡 Claude reads this data and decides what specialists to create.\n')
-      console.log('Next steps:')
-      console.log('• Read CLAUDE.md to see project data')
-      console.log('• /p:feature → Add a feature')
+      console.log('📊 Project Stats')
+      console.log(`├── Files: ~${result.stats.fileCount}`)
+      console.log(`├── Commits: ${result.git.commits}`)
+      console.log(`├── Version: ${result.stats.version}`)
+      console.log(`└── Stack: ${result.stats.ecosystem}\n`)
+
+      console.log('🌿 Git Status')
+      console.log(`├── Branch: ${result.git.branch}`)
+      console.log(`├── Uncommitted: ${result.git.hasChanges ? 'Yes' : 'Clean'}`)
+      console.log(`└── Recent: ${result.git.weeklyCommits} commits this week\n`)
+
+      console.log('📁 Context Updated')
+      for (const file of result.contextFiles) {
+        console.log(`├── ${file}`)
+      }
+      console.log('')
+
+      const workflowAgents = result.agents.filter(a => a.type === 'workflow').map(a => a.name)
+      const domainAgents = result.agents.filter(a => a.type === 'domain').map(a => a.name)
+
+      console.log(`🤖 Agents Regenerated (${result.agents.length})`)
+      console.log(`├── Workflow: ${workflowAgents.join(', ')}`)
+      console.log(`└── Domain: ${domainAgents.join(', ') || 'none'}\n`)
+
+      if (result.skills.length > 0) {
+        console.log('📦 Skills Configured')
+        for (const skill of result.skills) {
+          console.log(`├── ${skill.agent}.md → ${skill.skill}`)
+        }
+        console.log('')
+      }
+
+      if (result.git.hasChanges) {
+        console.log('⚠️  You have uncommitted changes\n')
+      } else {
+        console.log('✨ Repository is clean!\n')
+      }
 
       return {
         success: true,
+        data: result,
       }
     } catch (error) {
       console.error('❌ Error:', (error as Error).message)

package/core/commands/command-data.ts

@@ -62,17 +62,6 @@ export const COMMANDS: CommandMeta[] = [
     requiresProject: true,
     features: ['Agentic type classification', '7-phase workflow', 'Git branch management', 'Task breakdown'],
   },
-  {
-    name: 'feature',
-    group: 'core',
-    description: 'DEPRECATED - Use /p:task instead',
-    usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
-    params: '<description>',
-    implemented: true,
-    hasTemplate: true,
-    requiresProject: true,
-    deprecated: true,
-  },
   {
     name: 'spec',
     group: 'core',
@@ -83,28 +72,6 @@ export const COMMANDS: CommandMeta[] = [
     hasTemplate: true,
     requiresProject: true,
   },
-  {
-    name: 'now',
-    group: 'core',
-    description: 'DEPRECATED - Use /p:task instead',
-    usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
-    params: '[task]',
-    implemented: true,
-    hasTemplate: true,
-    requiresProject: true,
-    deprecated: true,
-  },
-  {
-    name: 'work',
-    group: 'core',
-    description: 'DEPRECATED - Use /p:task instead',
-    usage: { claude: '/p:task "<description>"', terminal: 'prjct task "<description>"' },
-    params: '[task]',
-    implemented: true,
-    hasTemplate: true,
-    requiresProject: true,
-    deprecated: true,
-  },
   {
     name: 'pause',
     group: 'core',
@@ -328,16 +295,6 @@ export const COMMANDS: CommandMeta[] = [
     hasTemplate: true,
     requiresProject: true,
   },
-  {
-    name: 'migrate-all',
-    group: 'setup',
-    description: 'Migrate all legacy projects to UUID format',
-    usage: { claude: '/p:migrate-all', terminal: 'prjct migrate-all' },
-    params: '[--deep-scan] [--dry-run]',
-    implemented: true,
-    hasTemplate: true,
-    requiresProject: false,
-  },
   {
     name: 'auth',
     group: 'setup',
@@ -348,12 +305,16 @@ export const COMMANDS: CommandMeta[] = [
     hasTemplate: true,
     requiresProject: false,
   },
+  {
+    name: 'context',
+    group: 'setup',
+    description: 'Get project context as JSON for Claude templates',
+    usage: { claude: null, terminal: 'prjct context <command> [args]' },
+    params: '<command> [args]',
+    implemented: true,
+    hasTemplate: false,
+    requiresProject: true,
+    features: ['Returns JSON with project context', 'Runs orchestrator', 'Loads agents and skills'],
+  },
 ]
 
-// Legacy compatibility - category field mapping
-export function getCommandsWithCategory(): Array<CommandMeta & { category: string }> {
-  return COMMANDS.map(cmd => ({
-    ...cmd,
-    category: cmd.group, // Map group to category for backward compat
-  }))
-}

package/core/commands/commands.ts

@@ -3,14 +3,15 @@
  *
  * MD-First Architecture - All state in Markdown files.
  *
- * COMMANDS (22 total):
- * - Workflow (5): work, done, next, pause, resume
- * - Planning (5): init, feature, bug, idea, spec
- * - Shipping (1): ship
- * - Analytics (2): dash, help
- * - Maintenance (5): cleanup, design, recover, undo, redo, history
- * - Analysis (2): analyze, sync
- * - Setup (3): start, setup, migrateAll
+ * COMMANDS:
+ * - Workflow: done, next, pause, resume
+ * - Planning: init, bug, idea, spec
+ * - Shipping: ship
+ * - Analytics: dash, help
+ * - Maintenance: cleanup, design, recover, undo, redo, history
+ * - Analysis: analyze, sync
+ * - Setup: start, setup
+ * - Context: context
  */
 
 import { WorkflowCommands } from './workflow'
@@ -20,6 +21,7 @@ import { AnalyticsCommands } from './analytics'
 import { MaintenanceCommands } from './maintenance'
 import { AnalysisCommands } from './analysis'
 import { SetupCommands } from './setup'
+import { ContextCommands } from './context'
 
 import type {
   CommandResult,
@@ -28,7 +30,6 @@ import type {
   DesignOptions,
   CleanupOptions,
   SetupOptions,
-  MigrateOptions,
   AnalyzeOptions
 } from '../types'
 
@@ -45,6 +46,7 @@ class PrjctCommands {
   private maintenance: MaintenanceCommands
   private analysis: AnalysisCommands
   private setupCmds: SetupCommands
+  private contextCmds: ContextCommands
 
   // Shared state
   agent: unknown
@@ -60,6 +62,7 @@ class PrjctCommands {
     this.maintenance = new MaintenanceCommands()
     this.analysis = new AnalysisCommands()
     this.setupCmds = new SetupCommands()
+    this.contextCmds = new ContextCommands()
 
     this.agent = null
     this.agentInfo = null
@@ -69,10 +72,6 @@ class PrjctCommands {
 
   // ========== Workflow Commands ==========
 
-  async work(task: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.workflow.now(task, projectPath)
-  }
-
   async done(projectPath: string = process.cwd()): Promise<CommandResult> {
     return this.workflow.done(projectPath)
   }
@@ -95,10 +94,6 @@ class PrjctCommands {
     return this.planning.init(idea, projectPath)
   }
 
-  async feature(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
-    return this.planning.feature(description, projectPath)
-  }
-
   async bug(description: string, projectPath: string = process.cwd()): Promise<CommandResult> {
     return this.planning.bug(description, projectPath)
   }
@@ -163,6 +158,12 @@ class PrjctCommands {
     return this.analysis.sync(projectPath)
   }
 
+  // ========== Context Commands ==========
+
+  async context(input: string | null = null, projectPath: string = process.cwd()): Promise<CommandResult> {
+    return this.contextCmds.context(input, projectPath)
+  }
+
   // ========== Setup Commands ==========
 
   async start(): Promise<CommandResult> {
@@ -173,10 +174,6 @@ class PrjctCommands {
     return this.setupCmds.setup(options)
   }
 
-  async migrateAll(options: MigrateOptions = {}): Promise<CommandResult> {
-    return this.setupCmds.migrateAll(options)
-  }
-
   async installStatusLine(): Promise<{ success: boolean; error?: string }> {
     return this.setupCmds.installStatusLine()
   }

package/core/commands/context.ts

@@ -0,0 +1,238 @@
+/**
+ * Context Commands - Exposes orchestrator context to Claude
+ *
+ * The `context` command runs the orchestrator and returns JSON with everything
+ * Claude needs to execute workflows:
+ * - projectId and globalPath for file operations
+ * - detected domains from task description
+ * - loaded agents with file paths and previews
+ * - current task state (if any)
+ * - repo analysis data
+ *
+ * This bridges the gap between TypeScript orchestration and Claude Code templates.
+ *
+ * @module commands/context
+ * @version 1.0.0
+ */
+
+import fs from 'fs/promises'
+import path from 'path'
+import configManager from '../infrastructure/config-manager'
+import pathManager from '../infrastructure/path-manager'
+import { stateStorage } from '../storage'
+import orchestratorExecutor from '../agentic/orchestrator-executor'
+import { isNotFoundError } from '../types/fs'
+import type { CommandResult } from '../types'
+
+// =============================================================================
+// Types
+// =============================================================================
+
+export interface ContextOutput {
+  projectId: string
+  globalPath: string
+  currentTask: {
+    id: string
+    description: string
+    startedAt: string
+    subtasks?: Array<{
+      id: string
+      description: string
+      status: string
+      domain: string
+    }>
+    currentSubtaskIndex?: number
+  } | null
+  domains: string[]
+  primaryDomain: string | null
+  agents: Array<{
+    name: string
+    domain: string
+    filePath: string
+    skills: string[]
+    preview: string
+  }>
+  subtasks: Array<{
+    id: string
+    description: string
+    domain: string
+    agent: string
+    status: string
+    order: number
+  }> | null
+  repoAnalysis: {
+    ecosystem: string
+    frameworks: string[]
+    hasTests: boolean
+    technologies: string[]
+  }
+}
+
+// =============================================================================
+// Context Commands Class
+// =============================================================================
+
+export class ContextCommands {
+  /**
+   * Get full project context for Claude
+   *
+   * Usage:
+   *   prjct context task "add user auth"
+   *   prjct context done
+   *   prjct context ship
+   *
+   * Returns JSON with all orchestrator data.
+   */
+  async context(
+    input: string | null = null,
+    projectPath: string = process.cwd()
+  ): Promise<CommandResult> {
+    try {
+      // Parse input: first word is command, rest is arguments
+      const parts = (input || '').trim().split(/\s+/)
+      const command = parts[0] || 'task'
+      const taskDescription = parts.slice(1).join(' ')
+
+      // Get project info
+      const config = await configManager.readConfig(projectPath)
+      if (!config || !config.projectId) {
+        const output: Partial<ContextOutput> = {
+          projectId: '',
+          globalPath: '',
+          currentTask: null,
+          domains: [],
+          primaryDomain: null,
+          agents: [],
+          subtasks: null,
+          repoAnalysis: {
+            ecosystem: 'unknown',
+            frameworks: [],
+            hasTests: false,
+            technologies: [],
+          },
+        }
+        console.log(JSON.stringify(output, null, 2))
+        return {
+          success: false,
+          message: 'No prjct project. Run `p. init` first.',
+        }
+      }
+
+      const projectId = config.projectId
+      const globalPath = pathManager.getGlobalProjectPath(projectId)
+
+      // Get current task state
+      const state = await stateStorage.read(projectId)
+      const currentTask = state?.currentTask
+        ? {
+            id: state.currentTask.id,
+            description: state.currentTask.description,
+            startedAt: state.currentTask.startedAt,
+            subtasks: state.currentTask.subtasks?.map((st) => ({
+              id: st.id,
+              description: st.description,
+              status: st.status,
+              domain: st.domain,
+            })),
+            currentSubtaskIndex: state.currentTask.currentSubtaskIndex,
+          }
+        : null
+
+      // Run orchestrator if we have a task description
+      let orchestratorContext = null
+      if (taskDescription) {
+        try {
+          orchestratorContext = await orchestratorExecutor.execute(
+            command,
+            taskDescription,
+            projectPath
+          )
+        } catch (error) {
+          // Orchestration failed - continue without it
+          console.error(`Warning: Orchestrator failed: ${(error as Error).message}`)
+        }
+      }
+
+      // Load repo analysis
+      const repoAnalysis = await this.loadRepoAnalysis(globalPath)
+
+      // Build output
+      const output: ContextOutput = {
+        projectId,
+        globalPath,
+        currentTask,
+        domains: orchestratorContext?.detectedDomains || [],
+        primaryDomain: orchestratorContext?.primaryDomain || null,
+        agents:
+          orchestratorContext?.agents.map((a) => ({
+            name: a.name,
+            domain: a.domain,
+            filePath: a.filePath,
+            skills: a.skills,
+            preview: a.content.substring(0, 500),
+          })) || [],
+        subtasks:
+          orchestratorContext?.subtasks?.map((st) => ({
+            id: st.id,
+            description: st.description,
+            domain: st.domain,
+            agent: st.agent,
+            status: st.status,
+            order: st.order,
+          })) || null,
+        repoAnalysis: {
+          ecosystem: repoAnalysis?.ecosystem || 'unknown',
+          frameworks: repoAnalysis?.frameworks || [],
+          hasTests: repoAnalysis?.hasTests || false,
+          technologies: repoAnalysis?.technologies || [],
+        },
+      }
+
+      // Output JSON to stdout
+      console.log(JSON.stringify(output, null, 2))
+
+      return {
+        success: true,
+        message: '', // Empty message - JSON output is the result
+      }
+    } catch (error) {
+      return {
+        success: false,
+        message: `Context error: ${(error as Error).message}`,
+      }
+    }
+  }
+
+  /**
+   * Load repo analysis from analysis/repo-analysis.json
+   */
+  private async loadRepoAnalysis(globalPath: string): Promise<{
+    ecosystem: string
+    frameworks: string[]
+    hasTests: boolean
+    technologies: string[]
+  } | null> {
+    try {
+      const analysisPath = path.join(globalPath, 'analysis', 'repo-analysis.json')
+      const content = await fs.readFile(analysisPath, 'utf-8')
+      const data = JSON.parse(content)
+      return {
+        ecosystem: data.ecosystem || 'unknown',
+        frameworks: data.frameworks || [],
+        hasTests: data.hasTests ?? false,
+        technologies: data.technologies || [],
+      }
+    } catch (error) {
+      if (isNotFoundError(error)) return null
+      return null
+    }
+  }
+}
+
+// =============================================================================
+// Exports
+// =============================================================================
+
+const contextCommands = new ContextCommands()
+export default contextCommands
+export { contextCommands }

package/core/commands/register.ts

@@ -17,6 +17,7 @@ import { AnalyticsCommands } from './analytics'
 import { MaintenanceCommands } from './maintenance'
 import { AnalysisCommands } from './analysis'
 import { SetupCommands } from './setup'
+import { ContextCommands } from './context'
 
 // Singleton instances of command groups
 const workflow = new WorkflowCommands()
@@ -26,6 +27,7 @@ const analytics = new AnalyticsCommands()
 const maintenance = new MaintenanceCommands()
 const analysis = new AnalysisCommands()
 const setup = new SetupCommands()
+const context = new ContextCommands()
 
 /**
  * Register categories
@@ -50,8 +52,6 @@ export function registerAllCommands(): void {
   const getMeta = (name: string) => COMMANDS.find(c => c.name === name)
 
   // Workflow commands
-  commandRegistry.registerMethod('work', workflow, 'now', getMeta('work'))
-  commandRegistry.registerMethod('now', workflow, 'now', getMeta('now'))
   commandRegistry.registerMethod('done', workflow, 'done', getMeta('done'))
   commandRegistry.registerMethod('next', workflow, 'next', getMeta('next'))
   commandRegistry.registerMethod('pause', workflow, 'pause', getMeta('pause'))
@@ -59,7 +59,6 @@ export function registerAllCommands(): void {
 
   // Planning commands
   commandRegistry.registerMethod('init', planning, 'init', getMeta('init'))
-  commandRegistry.registerMethod('feature', planning, 'feature', getMeta('feature'))
   commandRegistry.registerMethod('bug', planning, 'bug', getMeta('bug'))
   commandRegistry.registerMethod('idea', planning, 'idea', getMeta('idea'))
   commandRegistry.registerMethod('spec', planning, 'spec', getMeta('spec'))
@@ -86,7 +85,9 @@ export function registerAllCommands(): void {
   // Setup commands
   commandRegistry.registerMethod('start', setup, 'start', getMeta('start'))
   commandRegistry.registerMethod('setup', setup, 'setup', getMeta('setup'))
-  commandRegistry.registerMethod('migrateAll', setup, 'migrateAll', getMeta('migrate-all'))
+
+  // Context command (for Claude templates)
+  commandRegistry.registerMethod('context', context, 'context', getMeta('context'))
 }
 
 // Auto-register on import
@@ -100,5 +101,6 @@ export {
   analytics,
   maintenance,
   analysis,
-  setup
+  setup,
+  context
 }

package/core/commands/setup.ts

@@ -8,7 +8,7 @@ import chalk from 'chalk'
 
 import commandInstaller from '../infrastructure/command-installer'
 import pathManager from '../infrastructure/path-manager'
-import type { CommandResult, SetupOptions, MigrateOptions } from '../types'
+import type { CommandResult, SetupOptions } from '../types'
 import { PrjctCommandsBase } from './base'
 import { VERSION } from '../utils/version'
 
@@ -254,20 +254,4 @@ echo "⚡ prjct"
     console.log('')
   }
 
-  /**
-   * Migrate all projects to UUID format
-   */
-  async migrateAll(_options: MigrateOptions = {}): Promise<CommandResult> {
-    console.log('🔄 Migrating all projects to UUID format...\n')
-
-    // TODO: Implement full migration logic
-    // For now, return success as this is a stub
-    console.log('✅ Migration complete (no projects needed migration)\n')
-
-    return {
-      success: true,
-      message: 'Migration complete',
-    }
-  }
-
 }

package/core/commands/workflow.ts

@@ -81,12 +81,13 @@ export class WorkflowCommands extends PrjctCommandsBase {
         })
 
         return {
+          // Include full CommandExecutor result first (orchestratorContext, prompt, etc.)
+          ...result,
+          // Then override with our specific values
           success: true,
           task,
           agenticMode: true,
           availableAgents,
-          // Include full CommandExecutor result (orchestratorContext, prompt, etc.)
-          ...result,
         }
       } else {
         // Read from storage (JSON is source of truth)

package/core/index.ts

@@ -90,21 +90,17 @@ async function main(): Promise<void> {
       result = await commands.cleanup(options)
     } else if (commandName === 'setup') {
       result = await commands.setup(options)
-    } else if (commandName === 'migrate-all') {
-      result = await commands.migrateAll(options)
     } else {
       // Standard commands - type-safe invocation
       const param = parsedArgs.join(' ') || null
       const standardCommands: Record<string, (p: string | null) => Promise<CommandResult>> = {
         // Core workflow
-        work: (p) => commands.work(p),
         done: () => commands.done(),
         next: () => commands.next(),
         pause: (p) => commands.pause(p || ''),
         resume: (p) => commands.resume(p),
         // Planning
         init: (p) => commands.init(p),
-        feature: (p) => commands.feature(p || ''),
         bug: (p) => commands.bug(p || ''),
         idea: (p) => commands.idea(p || ''),
         spec: (p) => commands.spec(p),
@@ -120,6 +116,8 @@ async function main(): Promise<void> {
         // Setup
         sync: () => commands.sync(),
         start: () => commands.start(),
+        // Context (for Claude templates)
+        context: (p) => commands.context(p),
       }
 
       const handler = standardCommands[commandName]

package/core/services/index.ts

@@ -9,6 +9,8 @@ export { agentService, AgentService } from './agent-service'
 export { projectService, ProjectService } from './project-service'
 export { memoryService, MemoryService } from './memory-service'
 export { breakdownService, BreakdownService } from './breakdown-service'
+export { syncService, SyncService } from './sync-service'
+export type { SyncResult } from './sync-service'
 
 // Re-export types from canonical source
 export type {