prjct-cli 0.35.4 → 0.36.1

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)
   }
 
@@ -175,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

package/core/infrastructure/ai-provider.ts

@@ -0,0 +1,312 @@
+/**
+ * AI Provider - Multi-agent support for prjct-cli
+ *
+ * Supports both Claude Code and Gemini CLI with a unified abstraction layer.
+ * Both agents share similar architectures:
+ * - Context files: CLAUDE.md / GEMINI.md
+ * - Skills: Both use SKILL.md format (identical!)
+ * - Commands: .md (Claude) / .toml (Gemini)
+ * - MCP: Both support Model Context Protocol
+ *
+ * @see https://geminicli.com/docs/cli/gemini-md/
+ * @see https://geminicli.com/docs/cli/skills/
+ */
+
+import { execSync } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+import os from 'os'
+import type {
+  AIProviderName,
+  AIProviderConfig,
+  ProviderDetectionResult,
+  ProviderSelectionResult,
+  ProviderBranding,
+} from '../types/provider'
+
+// =============================================================================
+// Provider Configurations
+// =============================================================================
+
+/**
+ * Claude Code provider configuration
+ */
+export const ClaudeProvider: AIProviderConfig = {
+  name: 'claude',
+  displayName: 'Claude Code',
+  cliCommand: 'claude',
+  configDir: path.join(os.homedir(), '.claude'),
+  contextFile: 'CLAUDE.md',
+  skillsDir: path.join(os.homedir(), '.claude', 'skills'),
+  commandsDir: '.claude/commands',
+  commandFormat: 'md',
+  settingsFile: 'settings.json',
+  projectSettingsFile: 'settings.local.json',
+  ignoreFile: '.claudeignore',
+  websiteUrl: 'https://www.anthropic.com/claude',
+  docsUrl: 'https://docs.anthropic.com/claude-code',
+}
+
+/**
+ * Gemini CLI provider configuration
+ */
+export const GeminiProvider: AIProviderConfig = {
+  name: 'gemini',
+  displayName: 'Gemini CLI',
+  cliCommand: 'gemini',
+  configDir: path.join(os.homedir(), '.gemini'),
+  contextFile: 'GEMINI.md',
+  skillsDir: path.join(os.homedir(), '.gemini', 'skills'),
+  commandsDir: '.gemini/commands',
+  commandFormat: 'toml',
+  settingsFile: 'settings.json',
+  projectSettingsFile: 'settings.json',
+  ignoreFile: '.geminiignore',
+  websiteUrl: 'https://geminicli.com',
+  docsUrl: 'https://geminicli.com/docs',
+}
+
+/**
+ * All available providers
+ */
+export const Providers: Record<AIProviderName, AIProviderConfig> = {
+  claude: ClaudeProvider,
+  gemini: GeminiProvider,
+}
+
+// =============================================================================
+// Provider Detection
+// =============================================================================
+
+/**
+ * Check if a CLI command is available
+ */
+function whichCommand(command: string): string | null {
+  try {
+    const result = execSync(`which ${command}`, { stdio: 'pipe', encoding: 'utf-8' })
+    return result.trim()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Get CLI version
+ */
+function getCliVersion(command: string): string | null {
+  try {
+    const result = execSync(`${command} --version`, { stdio: 'pipe', encoding: 'utf-8' })
+    // Extract version number from output (e.g., "claude 1.0.0" -> "1.0.0")
+    const match = result.match(/\d+\.\d+\.\d+/)
+    return match ? match[0] : result.trim()
+  } catch {
+    return null
+  }
+}
+
+/**
+ * Detect if a specific provider is installed
+ */
+export function detectProvider(provider: AIProviderName): ProviderDetectionResult {
+  const config = Providers[provider]
+  const cliPath = whichCommand(config.cliCommand)
+
+  if (!cliPath) {
+    return { installed: false }
+  }
+
+  const version = getCliVersion(config.cliCommand)
+
+  return {
+    installed: true,
+    version: version || undefined,
+    path: cliPath,
+  }
+}
+
+/**
+ * Detect all available providers
+ */
+export function detectAllProviders(): Record<AIProviderName, ProviderDetectionResult> {
+  return {
+    claude: detectProvider('claude'),
+    gemini: detectProvider('gemini'),
+  }
+}
+
+/**
+ * Get the active provider based on detection or configuration
+ *
+ * Priority:
+ * 1. Check project config for saved provider preference
+ * 2. Auto-detect single installed provider
+ * 3. Default to Claude if both installed (backward compatibility)
+ */
+export function getActiveProvider(projectProvider?: AIProviderName): AIProviderConfig {
+  // If project has a saved preference, use it
+  if (projectProvider && Providers[projectProvider]) {
+    return Providers[projectProvider]
+  }
+
+  // Auto-detect
+  const detection = detectAllProviders()
+
+  // If only one is installed, use it
+  if (detection.claude.installed && !detection.gemini.installed) {
+    return ClaudeProvider
+  }
+  if (detection.gemini.installed && !detection.claude.installed) {
+    return GeminiProvider
+  }
+
+  // Default to Claude for backward compatibility
+  return ClaudeProvider
+}
+
+/**
+ * Check if config directory exists for a provider
+ */
+export function hasProviderConfig(provider: AIProviderName): boolean {
+  const config = Providers[provider]
+  return fs.existsSync(config.configDir)
+}
+
+// =============================================================================
+// Provider Branding
+// =============================================================================
+
+/**
+ * Get provider-specific branding
+ */
+export function getProviderBranding(provider: AIProviderName): ProviderBranding {
+  const config = Providers[provider]
+
+  if (provider === 'gemini') {
+    return {
+      commitFooter: `🤖 Generated with [p/](https://www.prjct.app/)
+Designed for [Gemini](${config.websiteUrl})`,
+      signature: '⚡ prjct + Gemini',
+    }
+  }
+
+  // Default: Claude
+  return {
+    commitFooter: `🤖 Generated with [p/](https://www.prjct.app/)
+Designed for [Claude](${config.websiteUrl})`,
+    signature: '⚡ prjct + Claude',
+  }
+}
+
+// =============================================================================
+// Provider Paths
+// =============================================================================
+
+/**
+ * Get full path to global context file
+ */
+export function getGlobalContextPath(provider: AIProviderName): string {
+  const config = Providers[provider]
+  return path.join(config.configDir, config.contextFile)
+}
+
+/**
+ * Get full path to global settings file
+ */
+export function getGlobalSettingsPath(provider: AIProviderName): string {
+  const config = Providers[provider]
+  return path.join(config.configDir, config.settingsFile)
+}
+
+/**
+ * Get full path to skills directory
+ */
+export function getSkillsPath(provider: AIProviderName): string {
+  return Providers[provider].skillsDir
+}
+
+/**
+ * Get commands directory relative to project root
+ */
+export function getCommandsDir(provider: AIProviderName): string {
+  return Providers[provider].commandsDir
+}
+
+/**
+ * Get full path to commands directory in a project
+ */
+export function getProjectCommandsPath(provider: AIProviderName, projectRoot: string): string {
+  const config = Providers[provider]
+  return path.join(projectRoot, config.commandsDir)
+}
+
+// =============================================================================
+// Provider Selection (for setup)
+// =============================================================================
+
+/**
+ * Determine which provider to use during setup
+ * Returns selection result with detection details
+ */
+export function selectProvider(): ProviderSelectionResult {
+  const detection = detectAllProviders()
+
+  const claudeInstalled = detection.claude.installed
+  const geminiInstalled = detection.gemini.installed
+
+  // Neither installed
+  if (!claudeInstalled && !geminiInstalled) {
+    // Default to Claude, setup will prompt to install
+    return {
+      provider: 'claude',
+      userSelected: false,
+      detection,
+    }
+  }
+
+  // Only Claude installed
+  if (claudeInstalled && !geminiInstalled) {
+    return {
+      provider: 'claude',
+      userSelected: false,
+      detection,
+    }
+  }
+
+  // Only Gemini installed
+  if (geminiInstalled && !claudeInstalled) {
+    return {
+      provider: 'gemini',
+      userSelected: false,
+      detection,
+    }
+  }
+
+  // Both installed - will need user selection
+  // For now, default to Claude (caller should prompt user)
+  return {
+    provider: 'claude',
+    userSelected: true, // Indicates user should be prompted
+    detection,
+  }
+}
+
+// =============================================================================
+// Exports
+// =============================================================================
+
+export default {
+  Providers,
+  ClaudeProvider,
+  GeminiProvider,
+  detectProvider,
+  detectAllProviders,
+  getActiveProvider,
+  hasProviderConfig,
+  getProviderBranding,
+  getGlobalContextPath,
+  getGlobalSettingsPath,
+  getSkillsPath,
+  getCommandsDir,
+  getProjectCommandsPath,
+  selectProvider,
+}

package/core/infrastructure/command-installer.ts

@@ -1,12 +1,15 @@
 /**
  * Command Installer
- * Installs prjct commands in Claude Code and other editors.
+ * Installs prjct commands in Claude Code and other AI CLI agents.
  *
- * 100% Claude-focused architecture
- * Handles installation and synchronization of /p:* commands
- * to Claude's native slash command system
+ * Architecture:
+ * - Claude: Full command sync to ~/.claude/commands/p/ (workaround for bug #2422)
+ * - Gemini: Simple router (p.toml) to ~/.gemini/commands/ (handled by setup.ts)
  *
- * @version 0.5.0
+ * This module handles the more complex Claude installation.
+ * For Gemini, see setup.ts::installGeminiRouter()
+ *
+ * @version 0.6.0 - Multi-provider support
  */
 
 import fs from 'fs/promises'
@@ -522,6 +525,47 @@ export class CommandInstaller {
   }
 }
 
+// =============================================================================
+// Multi-Provider Support
+// =============================================================================
+
+/**
+ * Get installation paths for all providers
+ */
+export function getProviderPaths(): {
+  claude: { commands: string; config: string; router: string }
+  gemini: { commands: string; config: string; router: string }
+} {
+  const homeDir = os.homedir()
+  return {
+    claude: {
+      commands: path.join(homeDir, '.claude', 'commands', 'p'),
+      config: path.join(homeDir, '.claude'),
+      router: path.join(homeDir, '.claude', 'commands', 'p.md'),
+    },
+    gemini: {
+      commands: path.join(homeDir, '.gemini', 'commands'),
+      config: path.join(homeDir, '.gemini'),
+      router: path.join(homeDir, '.gemini', 'commands', 'p.toml'),
+    },
+  }
+}
+
+/**
+ * Check if provider router is installed
+ */
+export async function isRouterInstalled(provider: 'claude' | 'gemini'): Promise<boolean> {
+  const paths = getProviderPaths()
+  const routerPath = paths[provider].router
+
+  try {
+    await fs.access(routerPath)
+    return true
+  } catch {
+    return false
+  }
+}
+
 // =============================================================================
 // Exports
 // =============================================================================

package/core/infrastructure/editors-config.ts

@@ -1,21 +1,25 @@
 /**
- * EditorsConfig - Manages Claude installation tracking
+ * EditorsConfig - Manages AI CLI installation tracking
  *
- * Tracks prjct commands installation in Claude (Code + Desktop),
+ * Tracks prjct commands installation in AI CLIs (Claude Code, Gemini CLI),
  * enabling automatic updates when npm package is updated.
  *
  * Config location: ~/.prjct-cli/config/installed-editors.json
  *
- * @version 0.5.0
+ * @version 0.6.0
  */
 
 import fs from 'fs/promises'
 import path from 'path'
 import os from 'os'
+import type { AIProviderName } from '../types/provider'
 
 interface EditorConfig {
   version: string
+  /** @deprecated Use 'provider' instead */
   editor: string
+  /** AI provider name (claude or gemini) */
+  provider: AIProviderName
   lastInstall: string
   path: string
 }
@@ -61,15 +65,16 @@ class EditorsConfig {
   /**
    * Save installation configuration
    */
-  async saveConfig(version: string, claudePath: string): Promise<boolean> {
+  async saveConfig(version: string, installPath: string, provider: AIProviderName = 'claude'): Promise<boolean> {
     try {
       await this.ensureConfigDir()
 
       const config: EditorConfig = {
         version,
-        editor: 'claude',
+        editor: provider, // deprecated, kept for backward compatibility
+        provider,
         lastInstall: new Date().toISOString(),
-        path: claudePath,
+        path: installPath,
       }
 
       await fs.writeFile(this.configFile, JSON.stringify(config, null, 2), 'utf-8')
@@ -81,6 +86,15 @@ class EditorsConfig {
     }
   }
 
+  /**
+   * Get the configured provider
+   */
+  async getProvider(): Promise<AIProviderName | null> {
+    const config = await this.loadConfig()
+    if (!config) return null
+    return config.provider || (config.editor as AIProviderName) || 'claude'
+  }
+
   /**
    * Get last installed version
    */