prjct-cli 0.35.4 → 0.37.0

package/bin/prjct.ts

@@ -3,17 +3,67 @@
  *
  * Auto-setup on first use (like Astro, Vite, etc.)
  * Supports both Bun and Node.js runtimes.
+ *
+ * IMPORTANT: postinstall.js often doesn't run, so we detect and
+ * auto-install on first CLI use. This is the reliable path.
  */
 
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
 import { VERSION } from '../core/utils/version'
 import editorsConfig from '../core/infrastructure/editors-config'
 import { startServer, DEFAULT_PORT } from '../core/server/server'
 import configManager from '../core/infrastructure/config-manager'
+import { detectAllProviders } from '../core/infrastructure/ai-provider'
+
+/**
+ * Check if routers are installed for detected providers
+ * Returns true if at least one provider has its router installed
+ */
+function checkRoutersInstalled(): boolean {
+  const home = os.homedir()
+  const detection = detectAllProviders()
+
+  // Check Claude router
+  if (detection.claude.installed) {
+    const claudeRouter = path.join(home, '.claude', 'commands', 'p.md')
+    if (!fs.existsSync(claudeRouter)) {
+      return false
+    }
+  }
+
+  // Check Gemini router
+  if (detection.gemini.installed) {
+    const geminiRouter = path.join(home, '.gemini', 'commands', 'p.toml')
+    if (!fs.existsSync(geminiRouter)) {
+      return false
+    }
+  }
+
+  // If no providers detected, consider it "installed" (setup will handle)
+  if (!detection.claude.installed && !detection.gemini.installed) {
+    return true
+  }
+
+  return true
+}
 
 // Check for special subcommands that bypass normal CLI
 const args = process.argv.slice(2)
 
-if (args[0] === 'dev') {
+// Colors for output
+const CYAN = '\x1b[36m'
+const YELLOW = '\x1b[33m'
+const DIM = '\x1b[2m'
+const BOLD = '\x1b[1m'
+const RESET = '\x1b[0m'
+
+if (args[0] === 'start' || args[0] === 'setup') {
+  // Interactive setup with beautiful UI
+  const { runStart } = await import('../core/cli/start')
+  await runStart()
+} else if (args[0] === 'dev') {
   // Dev mode - placeholder for future development server
   console.log('Dev mode is not yet implemented.')
   console.log('Use "prjct serve" to start the web server.')
@@ -35,26 +85,87 @@ if (args[0] === 'dev') {
     console.error('Server error:', (error as Error).message)
     process.exitCode = 1
   }
+} else if (args[0] === 'version' || args[0] === '-v' || args[0] === '--version') {
+  // Show version with provider status
+  const detection = detectAllProviders()
+  const home = os.homedir()
+  const cwd = process.cwd()
+  const claudeConfigured = fs.existsSync(path.join(home, '.claude', 'commands', 'p.md'))
+  const geminiConfigured = fs.existsSync(path.join(home, '.gemini', 'commands', 'p.toml'))
+  const cursorDetected = fs.existsSync(path.join(cwd, '.cursor'))
+  const cursorConfigured = fs.existsSync(path.join(cwd, '.cursor', 'rules', 'prjct.mdc'))
+
+  const GREEN = '\x1b[32m'
+
+  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}`)
+  }
+
+  // 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}`)
+  }
+
+  // Cursor status (project-level)
+  if (cursorDetected) {
+    const status = cursorConfigured ? `${GREEN}✓ ready${RESET}` : `${YELLOW}● detected${RESET}`
+    console.log(`  Cursor IDE    ${status}${DIM} (project)${RESET}`)
+  } else {
+    console.log(`  Cursor IDE    ${DIM}○ not detected${RESET}`)
+  }
+
+  console.log(`
+${DIM}Run 'prjct start' to configure (CLI providers)${RESET}
+${DIM}Run 'prjct init' to configure (Cursor IDE)${RESET}
+${CYAN}https://prjct.app${RESET}
+`)
 } else {
-  // Ensure setup has run for this version
-  try {
-    const lastVersion = await editorsConfig.getLastVersion()
+  // Check if setup has been done
+  const configPath = path.join(os.homedir(), '.prjct-cli', 'config', 'installed-editors.json')
+  const routersInstalled = checkRoutersInstalled()
+
+  if (!fs.existsSync(configPath) || !routersInstalled) {
+    // First time - prompt to run start
+    console.log(`
+${CYAN}${BOLD}  Welcome to prjct!${RESET}
+
+  Run ${BOLD}prjct start${RESET} to configure your AI providers.
 
-    if (!lastVersion || lastVersion !== VERSION) {
-      console.log('\n━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━')
-      console.log('🔧 One-time setup (v' + VERSION + ')...')
-      console.log('━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━\n')
+  ${DIM}This is a one-time setup that lets you choose between
+  Claude Code, Gemini CLI, or both.${RESET}
+`)
+    process.exitCode = 0
+  } else {
+    // Check version and auto-update if needed
+    try {
+      const lastVersion = await editorsConfig.getLastVersion()
 
-      const { default: setup } = await import('../core/infrastructure/setup')
-      await setup.run()
+      if (lastVersion && lastVersion !== VERSION) {
+        console.log(`\n${YELLOW}ℹ${RESET} Updating prjct v${lastVersion} → v${VERSION}...\n`)
 
-      console.log('✓ Setup complete!\n')
+        const { default: setup } = await import('../core/infrastructure/setup')
+        await setup.run()
+      }
+    } catch (error) {
+      // Silent fail on version check
     }
-  } catch (error) {
-    console.error('\n⚠️  Setup warning:', (error as Error).message)
-    console.error('You can run setup manually: prjct setup\n')
-  }
 
-  // Continue to main CLI logic
-  await import('../core/index')
+    // Continue to main CLI logic
+    await import('../core/index')
+  }
 }

package/core/agentic/template-executor.ts

@@ -27,7 +27,11 @@ export interface TemplateExecutionContext {
   command: string
   args: string
 
-  // Paths for Claude (not content - Claude reads what it needs)
+  // Agent information
+  agentName: string
+  agentSettingsPath: string
+
+  // Paths for agent (not content)
   paths: {
     orchestrator: string
     agentRouting: string
@@ -85,6 +89,8 @@ export class TemplateExecutor {
   ): Promise<TemplateExecutionContext> {
     const projectId = await this.getProjectId(projectPath)
     const globalPath = pathManager.getGlobalProjectPath(projectId)
+    const aiProvider = require('../infrastructure/ai-provider')
+    const activeProvider = aiProvider.getActiveProvider()
 
     // Get templates directory - use local path during development
     let templatesDir: string
@@ -102,6 +108,8 @@ export class TemplateExecutor {
       globalPath,
       command,
       args,
+      agentName: activeProvider.displayName,
+      agentSettingsPath: pathManager.getAgentSettingsPath(),
       paths: {
         orchestrator: path.join(templatesDir, 'agentic', 'orchestrator.md'),
         agentRouting: path.join(templatesDir, 'agentic', 'agent-routing.md'),
@@ -109,7 +117,7 @@ export class TemplateExecutor {
         commandTemplate: path.join(templatesDir, 'commands', `${command}.md`),
         repoAnalysis: path.join(globalPath, 'analysis', 'repo-analysis.json'),
         agentsDir: path.join(globalPath, 'agents'),
-        skillsDir: path.join(os.homedir(), '.claude', 'skills'),
+        skillsDir: activeProvider.skillsDir,
         stateJson: path.join(globalPath, 'storage', 'state.json'),
       }
     }
@@ -157,7 +165,7 @@ export class TemplateExecutor {
   }
 
   /**
-   * Build prompt that tells Claude to execute templates agentically
+   * Build prompt that tells agent to execute templates agentically
    */
   buildAgenticPrompt(context: TemplateExecutionContext): AgenticPromptInfo {
     const requiresOrchestration = this.requiresOrchestration(context.command)
@@ -165,9 +173,11 @@ export class TemplateExecutor {
     const prompt = `
 ## Agentic Execution Mode
 
-You are executing a prjct command. Follow the template-first approach.
+You are executing a prjct command as ${context.agentName}. Follow the template-first approach.
 
 ### Context
+- Agent: ${context.agentName}
+- Settings: ${context.agentSettingsPath}
 - Command: ${context.command}
 - Args: ${context.args}
 - Project: ${context.projectPath}

package/core/cli/start.ts

@@ -0,0 +1,397 @@
+/**
+ * prjct start - Global initialization with beautiful UI
+ *
+ * First-time setup command that:
+ * 1. Shows beautiful ASCII banner
+ * 2. Detects available AI providers
+ * 3. Lets user select which to configure
+ * 4. Installs routers and global config
+ */
+
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import readline from 'readline'
+import { VERSION } from '../utils/version'
+import { detectAllProviders, Providers } from '../infrastructure/ai-provider'
+import type { AIProviderName } from '../types/provider'
+
+// Colors
+const RESET = '\x1b[0m'
+const BOLD = '\x1b[1m'
+const DIM = '\x1b[2m'
+const GREEN = '\x1b[32m'
+const YELLOW = '\x1b[33m'
+const BLUE = '\x1b[34m'
+const MAGENTA = '\x1b[35m'
+const CYAN = '\x1b[36m'
+const WHITE = '\x1b[37m'
+const BG_BLUE = '\x1b[44m'
+
+// True color gradient (cyan -> blue -> purple -> pink)
+const G1 = '\x1b[38;2;0;255;255m'    // Cyan
+const G2 = '\x1b[38;2;80;180;255m'   // Sky blue
+const G3 = '\x1b[38;2;140;120;255m'  // Blue-purple
+const G4 = '\x1b[38;2;200;80;220m'   // Purple
+const G5 = '\x1b[38;2;255;80;180m'   // Pink
+
+// Large block letters - PRJCT (7 lines tall)
+const BANNER = `
+
+${G1} ██████╗ ${G2} ██████╗ ${G3}     ██╗${G4} ██████╗${G5}████████╗${RESET}
+${G1} ██╔══██╗${G2} ██╔══██╗${G3}     ██║${G4}██╔════╝${G5}╚══██╔══╝${RESET}
+${G1} ██████╔╝${G2} ██████╔╝${G3}     ██║${G4}██║     ${G5}   ██║   ${RESET}
+${G1} ██╔═══╝ ${G2} ██╔══██╗${G3}██   ██║${G4}██║     ${G5}   ██║   ${RESET}
+${G1} ██║     ${G2} ██║  ██║${G3}╚█████╔╝${G4}╚██████╗${G5}   ██║   ${RESET}
+${G1} ╚═╝     ${G2} ╚═╝  ╚═╝${G3} ╚════╝ ${G4} ╚═════╝${G5}   ╚═╝   ${RESET}
+
+`
+
+const WELCOME_BOX = `  ${WHITE}Context Layer for AI Agents${RESET}  ${DIM}v${VERSION}${RESET}
+
+  ${DIM}Project context layer for AI coding agents.
+  Works with Claude Code, Gemini CLI, and more.${RESET}
+  ${CYAN}https://prjct.app${RESET}
+`
+
+interface ProviderOption {
+  name: AIProviderName
+  displayName: string
+  installed: boolean
+  selected: boolean
+}
+
+/**
+ * Create readline interface for user input
+ */
+function createReadline(): readline.Interface {
+  return readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+}
+
+/**
+ * Clear screen and show banner
+ */
+function showBanner(): void {
+  // Clear screen
+  console.clear()
+  console.log(BANNER)
+  console.log(WELCOME_BOX)
+}
+
+/**
+ * Show provider selection UI
+ */
+function showProviderSelection(options: ProviderOption[], currentIndex: number): void {
+  console.log(`\n${BOLD}  Select AI providers to configure:${RESET}\n`)
+  console.log(`  ${DIM}(Use arrow keys to navigate, space to toggle, enter to confirm)${RESET}\n`)
+
+  options.forEach((option, index) => {
+    const cursor = index === currentIndex ? `${CYAN}❯${RESET}` : ' '
+    const checkbox = option.selected ? `${GREEN}[✓]${RESET}` : `${DIM}[ ]${RESET}`
+    const status = option.installed
+      ? `${GREEN}(installed)${RESET}`
+      : `${YELLOW}(will install)${RESET}`
+    const name = index === currentIndex
+      ? `${BOLD}${option.displayName}${RESET}`
+      : option.displayName
+
+    console.log(`  ${cursor} ${checkbox} ${name} ${status}`)
+  })
+
+  console.log('')
+}
+
+/**
+ * Interactive provider selection (with fallback for non-TTY)
+ */
+async function selectProviders(): Promise<AIProviderName[]> {
+  const detection = detectAllProviders()
+
+  const options: ProviderOption[] = [
+    {
+      name: 'claude',
+      displayName: 'Claude Code',
+      installed: detection.claude.installed,
+      selected: detection.claude.installed,
+    },
+    {
+      name: 'gemini',
+      displayName: 'Gemini CLI',
+      installed: detection.gemini.installed,
+      selected: detection.gemini.installed,
+    },
+  ]
+
+  // If neither installed, select Claude by default
+  if (!options.some(o => o.selected)) {
+    options[0].selected = true
+  }
+
+  // Non-interactive mode: auto-select detected providers
+  if (!process.stdin.isTTY) {
+    console.log(`\n${BOLD}  Detected providers:${RESET}\n`)
+    options.forEach(option => {
+      if (option.installed) {
+        console.log(`  ${GREEN}✓${RESET} ${option.displayName}`)
+      }
+    })
+    console.log('')
+    return options.filter(o => o.selected).map(o => o.name)
+  }
+
+  return new Promise((resolve) => {
+    let currentIndex = 0
+
+    const render = () => {
+      process.stdout.write('\x1b[8A')
+      process.stdout.write('\x1b[0J')
+      showProviderSelection(options, currentIndex)
+    }
+
+    showProviderSelection(options, currentIndex)
+
+    process.stdin.setRawMode(true)
+    process.stdin.resume()
+    process.stdin.setEncoding('utf8')
+
+    const cleanup = () => {
+      process.stdin.setRawMode(false)
+      process.stdin.removeListener('data', handleKey)
+      process.stdin.pause()
+    }
+
+    const handleKey = (key: string) => {
+      if (key === '\u0003') {
+        cleanup()
+        console.log('\n  Cancelled.\n')
+        process.exit(0)
+      }
+
+      if (key === '\r' || key === '\n') {
+        cleanup()
+        const selected = options.filter(o => o.selected).map(o => o.name)
+        resolve(selected.length > 0 ? selected : ['claude'])
+        return
+      }
+
+      if (key === '\x1b[A') {
+        currentIndex = Math.max(0, currentIndex - 1)
+        render()
+      }
+
+      if (key === '\x1b[B') {
+        currentIndex = Math.min(options.length - 1, currentIndex + 1)
+        render()
+      }
+
+      if (key === ' ') {
+        options[currentIndex].selected = !options[currentIndex].selected
+        render()
+      }
+    }
+
+    process.stdin.on('data', handleKey)
+  })
+}
+
+/**
+ * Install router for a CLI-based provider (Claude/Gemini)
+ * Note: Cursor uses project-level config, not global
+ */
+async function installRouter(provider: AIProviderName): Promise<boolean> {
+  const config = Providers[provider]
+
+  // Skip project-level providers (Cursor)
+  if (!config.configDir) {
+    return false
+  }
+
+  try {
+    // Create commands directory
+    const commandsDir = path.join(config.configDir, 'commands')
+    fs.mkdirSync(commandsDir, { recursive: true })
+
+    // Find package root (where templates are)
+    const { getPackageRoot } = await import('../utils/version')
+    const packageRoot = getPackageRoot()
+
+    // Copy router file
+    const routerFile = provider === 'claude' ? 'p.md' : 'p.toml'
+    const src = path.join(packageRoot, 'templates', 'commands', routerFile)
+    const dest = path.join(commandsDir, routerFile)
+
+    if (fs.existsSync(src)) {
+      fs.copyFileSync(src, dest)
+      return true
+    }
+
+    return false
+  } catch (error) {
+    console.error(`  ${YELLOW}⚠${RESET} Failed to install ${provider} router: ${(error as Error).message}`)
+    return false
+  }
+}
+
+/**
+ * Install global config for a CLI-based provider (Claude/Gemini)
+ * Note: Cursor uses project-level config, not global
+ */
+async function installGlobalConfig(provider: AIProviderName): Promise<boolean> {
+  const config = Providers[provider]
+
+  // Skip project-level providers (Cursor)
+  if (!config.configDir) {
+    return false
+  }
+
+  try {
+    // Ensure config directory exists
+    fs.mkdirSync(config.configDir, { recursive: true })
+
+    // Find package root
+    const { getPackageRoot } = await import('../utils/version')
+    const packageRoot = getPackageRoot()
+
+    // Copy global config
+    const configFile = provider === 'claude' ? 'CLAUDE.md' : 'GEMINI.md'
+    const src = path.join(packageRoot, 'templates', 'global', configFile)
+    const dest = path.join(config.configDir, configFile)
+
+    if (fs.existsSync(src)) {
+      const content = fs.readFileSync(src, 'utf-8')
+
+      // Check if file exists and has our markers
+      if (fs.existsSync(dest)) {
+        const existing = fs.readFileSync(dest, 'utf-8')
+        const startMarker = '<!-- prjct:start - DO NOT REMOVE THIS MARKER -->'
+        const endMarker = '<!-- prjct:end - DO NOT REMOVE THIS MARKER -->'
+
+        if (existing.includes(startMarker) && existing.includes(endMarker)) {
+          // Replace between markers
+          const before = existing.substring(0, existing.indexOf(startMarker))
+          const after = existing.substring(existing.indexOf(endMarker) + endMarker.length)
+          const prjctSection = content.substring(
+            content.indexOf(startMarker),
+            content.indexOf(endMarker) + endMarker.length
+          )
+          fs.writeFileSync(dest, before + prjctSection + after)
+        } else {
+          // Append
+          fs.writeFileSync(dest, existing + '\n\n' + content)
+        }
+      } else {
+        // Create new
+        fs.writeFileSync(dest, content)
+      }
+
+      return true
+    }
+
+    return false
+  } catch (error) {
+    console.error(`  ${YELLOW}⚠${RESET} Failed to install ${provider} config: ${(error as Error).message}`)
+    return false
+  }
+}
+
+/**
+ * Save setup configuration
+ */
+async function saveSetupConfig(providers: AIProviderName[]): Promise<void> {
+  const configDir = path.join(os.homedir(), '.prjct-cli', 'config')
+  fs.mkdirSync(configDir, { recursive: true })
+
+  const configPath = path.join(configDir, 'installed-editors.json')
+  const config = {
+    version: VERSION,
+    providers,
+    editor: providers[0], // deprecated, for backward compat
+    provider: providers[0],
+    lastInstall: new Date().toISOString(),
+    path: path.join(os.homedir(), `.${providers[0]}`, 'commands'),
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify(config, null, 2))
+}
+
+/**
+ * Show completion message
+ */
+function showCompletion(providers: AIProviderName[]): void {
+  console.log(`\n${GREEN}${BOLD}  ✓ Setup complete!${RESET}\n`)
+
+  console.log(`  ${DIM}Configured providers:${RESET}`)
+  providers.forEach(p => {
+    const config = Providers[p]
+    console.log(`    ${GREEN}✓${RESET} ${config.displayName}`)
+  })
+
+  console.log(`
+  ${BOLD}Next steps:${RESET}
+
+  ${CYAN}1.${RESET} Navigate to your project directory
+  ${CYAN}2.${RESET} Run ${BOLD}p. init${RESET} to initialize prjct for that project
+  ${CYAN}3.${RESET} Start tracking with ${BOLD}p. task "your task"${RESET}
+
+  ${DIM}Tips:${RESET}
+  ${DIM}•${RESET} Use ${BOLD}p. sync${RESET} to analyze your codebase
+  ${DIM}•${RESET} Use ${BOLD}p. done${RESET} to complete tasks
+  ${DIM}•${RESET} Use ${BOLD}p. ship${RESET} to create PRs
+
+  ${DIM}Learn more: https://prjct.app/docs${RESET}
+`)
+}
+
+/**
+ * Main start command
+ */
+export async function runStart(): Promise<void> {
+  showBanner()
+
+  // Check if already configured
+  const configPath = path.join(os.homedir(), '.prjct-cli', 'config', 'installed-editors.json')
+  if (fs.existsSync(configPath)) {
+    const existing = JSON.parse(fs.readFileSync(configPath, 'utf-8'))
+    if (existing.version === VERSION) {
+      console.log(`  ${YELLOW}ℹ${RESET} Already configured for v${VERSION}`)
+      console.log(`  ${DIM}Run with --force to reconfigure${RESET}\n`)
+
+      if (!process.argv.includes('--force')) {
+        return
+      }
+    }
+  }
+
+  // Select providers
+  const selectedProviders = await selectProviders()
+
+  console.log(`\n  ${CYAN}Setting up...${RESET}\n`)
+
+  // Install for each selected provider
+  for (const provider of selectedProviders) {
+    const config = Providers[provider]
+    process.stdout.write(`  ${DIM}•${RESET} ${config.displayName}... `)
+
+    const routerOk = await installRouter(provider)
+    const configOk = await installGlobalConfig(provider)
+
+    if (routerOk && configOk) {
+      console.log(`${GREEN}✓${RESET}`)
+    } else if (routerOk || configOk) {
+      console.log(`${YELLOW}partial${RESET}`)
+    } else {
+      console.log(`${YELLOW}skipped${RESET}`)
+    }
+  }
+
+  // Save configuration
+  await saveSetupConfig(selectedProviders)
+
+  // Show completion
+  showCompletion(selectedProviders)
+}
+
+export default { runStart }

package/core/commands/analysis.ts

@@ -74,14 +74,17 @@ export class AnalysisCommands extends PrjctCommandsBase {
 
       await generateContext(projectId!, projectPath)
 
+      const aiProvider = require('../infrastructure/ai-provider')
+      const activeProvider = aiProvider.getActiveProvider()
+
       const globalConfigResult = await commandInstaller.installGlobalConfig()
       if (globalConfigResult.success) {
-        console.log('📝 Updated ~/.claude/CLAUDE.md')
+        console.log(`📝 Updated ${pathManager.getDisplayPath(globalConfigResult.path!)}`)
       }
 
       console.log('✅ Analysis complete!\n')
       console.log('📄 Full report: analysis/repo-summary.md')
-      console.log('📝 Context: ~/.prjct-cli/projects/' + projectId + '/CLAUDE.md\n')
+      console.log(`📝 Context: ~/.prjct-cli/projects/${projectId}/${activeProvider.contextFile}\n`)
       console.log('Next steps:')
       console.log('• /p:sync → Generate agents based on stack')
       console.log('• /p:feature → Add a new feature')
@@ -220,7 +223,7 @@ export class AnalysisCommands extends PrjctCommandsBase {
       // Update global config
       const globalConfigResult = await commandInstaller.installGlobalConfig()
       if (globalConfigResult.success) {
-        console.log('📝 Updated ~/.claude/CLAUDE.md')
+        console.log(`📝 Updated ${pathManager.getDisplayPath(globalConfigResult.path!)}`)
       }
 
       // Format output