prjct-cli 0.35.3 → 0.36.1

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/index.ts

@@ -9,6 +9,10 @@ import { commandRegistry } from './commands/registry'
 import './commands/register' // Ensure commands are registered
 import out from './utils/output'
 import type { CommandMeta } from './commands/registry'
+import { detectAllProviders, Providers } from './infrastructure/ai-provider'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
 
 interface ParsedCommandArgs {
   parsedArgs: string[]
@@ -27,7 +31,7 @@ async function main(): Promise<void> {
 
   if (['-v', '--version', 'version'].includes(commandName)) {
     const packageJson = await import('../package.json')
-    console.log(`prjct-cli v${packageJson.version}`)
+    displayVersion(packageJson.version)
     process.exit(0)
   }
 
@@ -90,21 +94,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 +120,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]
@@ -177,44 +179,106 @@ function parseCommandArgs(cmd: CommandMeta, rawArgs: string[]): ParsedCommandArg
   return { parsedArgs, options }
 }
 
+// Colors for version display
+const CYAN = '\x1b[36m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const DIM = '\x1b[2m'
+const RESET = '\x1b[0m'
+
 /**
- * Display help using registry
+ * Display version with provider status
  */
-function displayHelp(): void {
-  const categories = commandRegistry.getAllCategories()
-  const categorizedCommands: Record<string, CommandMeta[]> = {}
+function displayVersion(version: string): void {
+  const detection = detectAllProviders()
+
+  // Check if prjct commands are installed for each provider
+  const claudeCommandPath = path.join(os.homedir(), '.claude', 'commands', 'p.md')
+  const geminiCommandPath = path.join(os.homedir(), '.gemini', 'commands', 'p.toml')
+  const claudeConfigured = fs.existsSync(claudeCommandPath)
+  const geminiConfigured = fs.existsSync(geminiCommandPath)
+
+  console.log(`
+${CYAN}p/${RESET} prjct v${version}
+${DIM}Context layer for AI coding agents${RESET}
+
+${DIM}Providers:${RESET}`)
+
+  // Claude status
+  if (detection.claude.installed) {
+    const status = claudeConfigured ? `${GREEN}✓ ready${RESET}` : `${YELLOW}● installed${RESET}`
+    const ver = detection.claude.version ? ` (v${detection.claude.version})` : ''
+    console.log(`  Claude Code   ${status}${DIM}${ver}${RESET}`)
+  } else {
+    console.log(`  Claude Code   ${DIM}○ not installed${RESET}`)
+  }
 
-  // Group commands by category (exclude deprecated)
-  commandRegistry.getTerminalCommands().forEach((cmd) => {
-    if (cmd.deprecated) return
+  // Gemini status
+  if (detection.gemini.installed) {
+    const status = geminiConfigured ? `${GREEN}✓ ready${RESET}` : `${YELLOW}● installed${RESET}`
+    const ver = detection.gemini.version ? ` (v${detection.gemini.version})` : ''
+    console.log(`  Gemini CLI    ${status}${DIM}${ver}${RESET}`)
+  } else {
+    console.log(`  Gemini CLI    ${DIM}○ not installed${RESET}`)
+  }
 
-    if (!categorizedCommands[cmd.group]) {
-      categorizedCommands[cmd.group] = []
-    }
-    categorizedCommands[cmd.group].push(cmd)
-  })
-
-  console.log('prjct - Developer momentum tool for solo builders')
-  console.log('\nAvailable commands:\n')
-
-  // Display commands by category
-  Object.entries(categorizedCommands).forEach(([categoryKey, cmds]) => {
-    const categoryInfo = categories.get(categoryKey)
-    console.log(`  ${categoryInfo?.title || categoryKey}:`)
-
-    cmds.forEach((cmd) => {
-      const params = cmd.params ? ` ${cmd.params}` : ''
-      const spacing = ' '.repeat(Math.max(20 - cmd.name.length - params.length, 1))
-      const impl = cmd.implemented ? '' : ' (not implemented)'
-      console.log(`    ${cmd.name}${params}${spacing}${cmd.description}${impl}`)
-    })
-
-    console.log('')
-  })
-
-  const stats = commandRegistry.getStats()
-  console.log(`Total: ${stats.implemented} implemented / ${stats.total} commands`)
-  console.log('\nFor more info: https://prjct.app')
+  console.log(`
+${DIM}Run 'prjct start' to configure providers${RESET}
+${CYAN}https://prjct.app${RESET}
+`)
+}
+
+/**
+ * Display help using registry
+ */
+function displayHelp(): void {
+  console.log(`
+prjct - Context layer for AI coding agents
+Works with Claude Code, Gemini CLI, and more.
+
+QUICK START
+-----------
+  1. prjct start          Configure your AI provider (Claude/Gemini)
+  2. Open project in your AI coding agent
+  3. Type: p. sync        Analyze project and generate context
+  4. Type: p. task "..."  Start working on a task
+
+HOW IT WORKS
+------------
+  prjct gives AI agents the context they need about your project.
+  Use "p." commands inside Claude Code or Gemini CLI:
+
+    p. sync              Analyze project, generate domain agents
+    p. task "desc"       Start task with auto-classification
+    p. done              Complete current subtask
+    p. ship "name"       Ship feature with PR + version
+
+TERMINAL COMMANDS (this CLI)
+----------------------------
+  prjct start            First-time setup
+  prjct setup            Reconfigure installations
+  prjct init             Initialize project (creates .prjct/)
+  prjct sync             Sync project state
+
+EXAMPLES
+--------
+  # First time setup
+  $ prjct start
+
+  # Initialize a new project
+  $ cd my-project && prjct init
+
+  # Inside Claude Code or Gemini CLI
+  > p. sync
+  > p. task "add user authentication"
+  > p. done
+  > p. ship "user auth"
+
+MORE INFO
+---------
+  Documentation:  https://prjct.app
+  GitHub:         https://github.com/jlopezlira/prjct-cli
+`)
 }
 
 // Run CLI