prjct-cli 0.36.1 → 0.37.1

package/core/infrastructure/ai-provider.ts

@@ -1,15 +1,18 @@
 /**
  * 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
+ * Supports multiple AI coding agents with a unified abstraction layer:
+ * - Claude Code (CLI): ~/.claude/, CLAUDE.md, .md commands
+ * - Gemini CLI (CLI): ~/.gemini/, GEMINI.md, .toml commands
+ * - Cursor IDE (GUI): .cursor/ (project-level), .mdc rules
+ *
+ * Key differences:
+ * - CLI providers (Claude/Gemini) have global config directories
+ * - Cursor has project-level config only (no ~/.cursor/)
  *
  * @see https://geminicli.com/docs/cli/gemini-md/
  * @see https://geminicli.com/docs/cli/skills/
+ * @see https://cursor.com/docs/context/rules
  */
 
 import { execSync } from 'child_process'
@@ -22,6 +25,7 @@ import type {
   ProviderDetectionResult,
   ProviderSelectionResult,
   ProviderBranding,
+  CursorProjectDetection,
 } from '../types/provider'
 
 // =============================================================================
@@ -66,12 +70,42 @@ export const GeminiProvider: AIProviderConfig = {
   docsUrl: 'https://geminicli.com/docs',
 }
 
+/**
+ * Cursor IDE provider configuration
+ *
+ * Key differences from Claude/Gemini:
+ * - NOT a CLI (GUI app, VS Code fork)
+ * - No global config directory (~/.cursor/ doesn't exist)
+ * - Project-level config only (.cursor/rules/, .cursor/commands/)
+ * - User can select any model (GPT, Claude, Gemini, DeepSeek, etc.)
+ *
+ * @see https://cursor.com/docs/context/rules
+ */
+export const CursorProvider: AIProviderConfig = {
+  name: 'cursor',
+  displayName: 'Cursor IDE',
+  cliCommand: null,              // Not a CLI - GUI app
+  configDir: null,               // No global config directory
+  contextFile: 'prjct.mdc',      // Uses .mdc format with frontmatter
+  skillsDir: null,               // No skills directory
+  commandsDir: '.cursor/commands',
+  rulesDir: '.cursor/rules',     // Cursor-specific: rules directory
+  commandFormat: 'md',
+  settingsFile: null,
+  projectSettingsFile: null,
+  ignoreFile: '.cursorignore',
+  isProjectLevel: true,          // Config is project-level only
+  websiteUrl: 'https://cursor.com',
+  docsUrl: 'https://cursor.com/docs',
+}
+
 /**
  * All available providers
  */
 export const Providers: Record<AIProviderName, AIProviderConfig> = {
   claude: ClaudeProvider,
   gemini: GeminiProvider,
+  cursor: CursorProvider,
 }
 
 // =============================================================================
@@ -105,10 +139,17 @@ function getCliVersion(command: string): string | null {
 }
 
 /**
- * Detect if a specific provider is installed
+ * Detect if a specific CLI-based provider is installed
+ * Note: Cursor is NOT a CLI, use detectCursorProject() instead
  */
 export function detectProvider(provider: AIProviderName): ProviderDetectionResult {
   const config = Providers[provider]
+
+  // Cursor is not a CLI - return not installed for CLI detection
+  if (!config.cliCommand) {
+    return { installed: false }
+  }
+
   const cliPath = whichCommand(config.cliCommand)
 
   if (!cliPath) {
@@ -125,9 +166,10 @@ export function detectProvider(provider: AIProviderName): ProviderDetectionResul
 }
 
 /**
- * Detect all available providers
+ * Detect all available CLI-based providers
+ * Note: Cursor detection is project-level, use detectCursorProject() separately
  */
-export function detectAllProviders(): Record<AIProviderName, ProviderDetectionResult> {
+export function detectAllProviders(): { claude: ProviderDetectionResult; gemini: ProviderDetectionResult } {
   return {
     claude: detectProvider('claude'),
     gemini: detectProvider('gemini'),
@@ -165,9 +207,13 @@ export function getActiveProvider(projectProvider?: AIProviderName): AIProviderC
 
 /**
  * Check if config directory exists for a provider
+ * Returns false for project-level providers (Cursor)
  */
 export function hasProviderConfig(provider: AIProviderName): boolean {
   const config = Providers[provider]
+  if (!config.configDir) {
+    return false // Cursor has no global config directory
+  }
   return fs.existsSync(config.configDir)
 }
 
@@ -189,6 +235,14 @@ Designed for [Gemini](${config.websiteUrl})`,
     }
   }
 
+  if (provider === 'cursor') {
+    return {
+      commitFooter: `🤖 Generated with [p/](https://www.prjct.app/)
+Built with [Cursor](${config.websiteUrl})`,
+      signature: '⚡ prjct + Cursor',
+    }
+  }
+
   // Default: Claude
   return {
     commitFooter: `🤖 Generated with [p/](https://www.prjct.app/)
@@ -197,30 +251,75 @@ Designed for [Claude](${config.websiteUrl})`,
   }
 }
 
+// =============================================================================
+// Cursor Project Detection
+// =============================================================================
+
+/**
+ * Detect if a project is configured for Cursor IDE
+ *
+ * Cursor has NO global config (~/.cursor/ doesn't exist).
+ * Detection is based on project-level .cursor/ directory.
+ */
+export function detectCursorProject(projectRoot: string): CursorProjectDetection {
+  const cursorDir = path.join(projectRoot, '.cursor')
+  const rulesDir = path.join(cursorDir, 'rules')
+  const routerPath = path.join(rulesDir, 'prjct.mdc')
+
+  const detected = fs.existsSync(cursorDir)
+  const routerInstalled = fs.existsSync(routerPath)
+
+  return {
+    detected,
+    routerInstalled,
+    projectRoot: detected ? projectRoot : undefined,
+  }
+}
+
+/**
+ * Check if Cursor routers need to be regenerated
+ */
+export function needsCursorRouterRegeneration(projectRoot: string): boolean {
+  const detection = detectCursorProject(projectRoot)
+
+  // Only check if .cursor/ exists (project uses Cursor)
+  // and prjct router is missing
+  return detection.detected && !detection.routerInstalled
+}
+
 // =============================================================================
 // Provider Paths
 // =============================================================================
 
 /**
  * Get full path to global context file
+ * Returns null for project-level providers (Cursor)
  */
-export function getGlobalContextPath(provider: AIProviderName): string {
+export function getGlobalContextPath(provider: AIProviderName): string | null {
   const config = Providers[provider]
+  if (!config.configDir) {
+    return null // Cursor has no global config
+  }
   return path.join(config.configDir, config.contextFile)
 }
 
 /**
  * Get full path to global settings file
+ * Returns null for project-level providers (Cursor)
  */
-export function getGlobalSettingsPath(provider: AIProviderName): string {
+export function getGlobalSettingsPath(provider: AIProviderName): string | null {
   const config = Providers[provider]
+  if (!config.configDir || !config.settingsFile) {
+    return null // Cursor has no global settings
+  }
   return path.join(config.configDir, config.settingsFile)
 }
 
 /**
  * Get full path to skills directory
+ * Returns null for providers without skill support (Cursor)
  */
-export function getSkillsPath(provider: AIProviderName): string {
+export function getSkillsPath(provider: AIProviderName): string | null {
   return Providers[provider].skillsDir
 }
 
@@ -298,6 +397,7 @@ export default {
   Providers,
   ClaudeProvider,
   GeminiProvider,
+  CursorProvider,
   detectProvider,
   detectAllProviders,
   getActiveProvider,
@@ -309,4 +409,6 @@ export default {
   getCommandsDir,
   getProjectCommandsPath,
   selectProvider,
+  detectCursorProject,
+  needsCursorRouterRegeneration,
 }

package/core/infrastructure/command-installer.ts

@@ -60,32 +60,43 @@ export async function installDocs(): Promise<{ success: boolean; error?: string
 }
 
 /**
- * Install or update global CLAUDE.md configuration
+ * Install or update global AI agent configuration (CLAUDE.md / GEMINI.md)
  */
-export async function installGlobalConfig(
-  claudeConfigPath: string,
-  detectClaude: () => Promise<boolean>
-): Promise<GlobalConfigResult> {
-  const claudeDetected = await detectClaude()
-
-  if (!claudeDetected) {
+export async function installGlobalConfig(): Promise<GlobalConfigResult> {
+  const aiProvider = require('./ai-provider')
+  const activeProvider = aiProvider.getActiveProvider()
+  const providerName = activeProvider.name
+
+  // Check if provider is installed
+  const detection = aiProvider.detectProvider(providerName)
+  if (!detection.installed && !activeProvider.configDir) {
     return {
       success: false,
-      error: 'Claude not detected',
+      error: `${activeProvider.displayName} not detected`,
       action: 'skipped',
     }
   }
 
   try {
-    // Ensure ~/.claude directory exists
-    const claudeDir = path.join(os.homedir(), '.claude')
-    await fs.mkdir(claudeDir, { recursive: true })
+    // Ensure config directory exists
+    await fs.mkdir(activeProvider.configDir, { recursive: true })
 
-    const globalConfigPath = path.join(claudeDir, 'CLAUDE.md')
-    const templatePath = path.join(getPackageRoot(), 'templates/global/CLAUDE.md')
+    const globalConfigPath = path.join(activeProvider.configDir, activeProvider.contextFile)
+    const templatePath = path.join(getPackageRoot(), 'templates', 'global', activeProvider.contextFile)
 
     // Read template content
-    const templateContent = await fs.readFile(templatePath, 'utf-8')
+    let templateContent = ''
+    try {
+      templateContent = await fs.readFile(templatePath, 'utf-8')
+    } catch (error) {
+      // Fallback if provider-specific template not found
+      const fallbackTemplatePath = path.join(getPackageRoot(), 'templates/global/CLAUDE.md')
+      templateContent = await fs.readFile(fallbackTemplatePath, 'utf-8')
+      // If it is Gemini, we should rename Claude to Gemini in the fallback content
+      if (providerName === 'gemini') {
+        templateContent = templateContent.replace(/Claude/g, 'Gemini')
+      }
+    }
 
     // Check if global config already exists
     let existingContent = ''
@@ -172,19 +183,26 @@ export class CommandInstaller {
 
   constructor() {
     this.homeDir = os.homedir()
-    // Commands are stored in p/ subdirectory, accessed via p. trigger
-    // Note: Claude Code bug #2422 prevents native slash command discovery
-    // We use the p.md router in commands/ root instead
-    this.claudeCommandsPath = path.join(this.homeDir, '.claude', 'commands', 'p')
-    this.claudeConfigPath = path.join(this.homeDir, '.claude')
-    // Use getPackageRoot() to find templates - works from both source and compiled
+    
+    const aiProvider = require('./ai-provider')
+    const activeProvider = aiProvider.getActiveProvider()
+    
+    // Command paths are provider-specific
+    if (activeProvider.name === 'gemini') {
+      this.claudeCommandsPath = path.join(activeProvider.configDir, 'commands')
+    } else {
+      // Claude: Commands are in p/ subdirectory to avoid cluttering commands/
+      this.claudeCommandsPath = path.join(activeProvider.configDir, 'commands', 'p')
+    }
+    
+    this.claudeConfigPath = activeProvider.configDir
     this.templatesDir = path.join(getPackageRoot(), 'templates', 'commands')
   }
 
   /**
-   * Detect if Claude is installed
+   * Detect if active provider is installed
    */
-  async detectClaude(): Promise<boolean> {
+  async detectActiveProvider(): Promise<boolean> {
     try {
       await fs.access(this.claudeConfigPath)
       return true
@@ -196,6 +214,13 @@ export class CommandInstaller {
     }
   }
 
+  /**
+   * Detect if Claude is installed (legacy support)
+   */
+  async detectClaude(): Promise<boolean> {
+    return this.detectActiveProvider()
+  }
+
   /**
    * Get list of command files to install
    */
@@ -230,20 +255,22 @@ export class CommandInstaller {
   }
 
   /**
-   * Install commands to Claude
+   * Install commands to active AI agent
    */
   async installCommands(): Promise<InstallResult> {
-    const claudeDetected = await this.detectClaude()
+    const providerDetected = await this.detectActiveProvider()
+    const aiProvider = require('./ai-provider')
+    const activeProvider = aiProvider.getActiveProvider()
 
-    if (!claudeDetected) {
+    if (!providerDetected) {
       return {
         success: false,
-        error: 'Claude not detected. Please install Claude Code or Claude Desktop first.',
+        error: `${activeProvider.displayName} not detected. Please install it first.`,
       }
     }
 
     try {
-      // Install the p.md router to enable "p. task" trigger
+      // Install the router to enable "p. task" trigger
       await this.installRouter()
 
       // Ensure commands directory exists
@@ -404,14 +431,20 @@ export class CommandInstaller {
   }
 
   /**
-   * Install the p.md router to ~/.claude/commands/
+   * Install the router (p.md for Claude, p.toml for Gemini) to commands directory
    * This enables the "p. task" natural language trigger
-   * Claude Code bug #2422 prevents subdirectory slash command discovery
    */
   async installRouter(): Promise<boolean> {
+    const aiProvider = require('./ai-provider')
+    const activeProvider = aiProvider.getActiveProvider()
+    const routerFile = activeProvider.name === 'gemini' ? 'p.toml' : 'p.md'
+    
     try {
-      const routerSource = path.join(this.templatesDir, 'p.md')
-      const routerDest = path.join(this.homeDir, '.claude', 'commands', 'p.md')
+      const routerSource = path.join(this.templatesDir, routerFile)
+      const routerDest = path.join(activeProvider.configDir, 'commands', routerFile)
+
+      // Ensure commands directory exists
+      await fs.mkdir(path.dirname(routerDest), { recursive: true })
 
       const content = await fs.readFile(routerSource, 'utf-8')
       await fs.writeFile(routerDest, content, 'utf-8')
@@ -428,12 +461,12 @@ export class CommandInstaller {
    * Sync commands - intelligent update that detects and removes orphans
    */
   async syncCommands(): Promise<SyncResult> {
-    const claudeDetected = await this.detectClaude()
+    const providerDetected = await this.detectActiveProvider()
 
-    if (!claudeDetected) {
+    if (!providerDetected) {
       return {
         success: false,
-        error: 'Claude not detected',
+        error: 'AI agent not detected',
         added: 0,
         updated: 0,
         removed: 0,
@@ -511,10 +544,10 @@ export class CommandInstaller {
   }
 
   /**
-   * Install or update global CLAUDE.md configuration
+   * Install or update global AI agent configuration (CLAUDE.md / GEMINI.md)
    */
   async installGlobalConfig(): Promise<GlobalConfigResult> {
-    return installGlobalConfig(this.claudeConfigPath, () => this.detectClaude())
+    return installGlobalConfig()
   }
 
   /**

package/core/infrastructure/path-manager.ts

@@ -301,23 +301,32 @@ class PathManager {
   }
 
   /**
-   * Get the Claude directory path (~/.claude)
-   * Contains Claude Code/Desktop configuration
+   * Get the Claude/Gemini directory path (~/.claude or ~/.gemini)
+   * Contains AI CLI configuration
    */
-  getClaudeDir(): string {
-    return path.join(os.homedir(), '.claude')
+  getAgentDir(): string {
+    const provider = require('./ai-provider').getActiveProvider()
+    return provider.configDir
+  }
+
+  /**
+   * Get the agent settings file path (~/.claude/settings.json or ~/.gemini/settings.json)
+   */
+  getAgentSettingsPath(): string {
+    const provider = require('./ai-provider').getActiveProvider()
+    const aiProvider = require('./ai-provider')
+    return aiProvider.getGlobalSettingsPath(provider.name)
   }
 
   /**
-   * Get the Claude commands directory path (~/.claude/commands)
-   * Contains custom slash commands for Claude
+   * Get the Claude directory path (~/.claude) - Legacy support
    */
-  getClaudeCommandsDir(): string {
-    return path.join(this.getClaudeDir(), 'commands')
+  getClaudeDir(): string {
+    return path.join(os.homedir(), '.claude')
   }
 
   /**
-   * Get the Claude settings file path (~/.claude/settings.json)
+   * Get the Claude settings file path (~/.claude/settings.json) - Legacy support
    */
   getClaudeSettingsPath(): string {
     return path.join(this.getClaudeDir(), 'settings.json')

package/core/infrastructure/setup.ts

@@ -106,10 +106,11 @@ export async function run(): Promise<SetupResults> {
     configAction: null,
   }
 
-  // Step 1: Install for each detected provider
-  const providerNames: AIProviderName[] = ['claude', 'gemini']
+  // Step 1: Install for each CLI-based provider (Claude, Gemini)
+  // Note: Cursor is project-level and handled separately via installCursorProject()
+  const cliProviderNames: ('claude' | 'gemini')[] = ['claude', 'gemini']
 
-  for (const providerName of providerNames) {
+  for (const providerName of cliProviderNames) {
     const providerConfig = Providers[providerName]
     const providerDetection = detection[providerName]
 
@@ -295,6 +296,148 @@ async function installGeminiGlobalConfig(): Promise<{ success: boolean; action:
   }
 }
 
+// =============================================================================
+// Cursor IDE Installation (Project-Level)
+// =============================================================================
+
+/**
+ * Install prjct routers for Cursor IDE in a project
+ *
+ * Unlike Claude/Gemini which have global config, Cursor uses project-level
+ * configuration in .cursor/rules/ and .cursor/commands/.
+ *
+ * Creates minimal routers that point to the npm package for real instructions.
+ * Installs individual command files for better Cursor UX (/sync, /task, etc.)
+ *
+ * @param projectRoot - The project root directory
+ * @returns Object with success status and files created
+ */
+export async function installCursorProject(projectRoot: string): Promise<{
+  success: boolean
+  rulesCreated: boolean
+  commandsCreated: boolean
+  gitignoreUpdated: boolean
+}> {
+  const result = {
+    success: false,
+    rulesCreated: false,
+    commandsCreated: false,
+    gitignoreUpdated: false,
+  }
+
+  try {
+    const cursorDir = path.join(projectRoot, '.cursor')
+    const rulesDir = path.join(cursorDir, 'rules')
+    const commandsDir = path.join(cursorDir, 'commands')
+
+    const routerMdcDest = path.join(rulesDir, 'prjct.mdc')
+
+    const routerMdcSource = path.join(getPackageRoot(), 'templates', 'cursor', 'router.mdc')
+    const cursorCommandsSource = path.join(getPackageRoot(), 'templates', 'cursor', 'commands')
+
+    // Ensure directories exist
+    fs.mkdirSync(rulesDir, { recursive: true })
+    fs.mkdirSync(commandsDir, { recursive: true })
+
+    // Copy router.mdc → .cursor/rules/prjct.mdc
+    if (fs.existsSync(routerMdcSource)) {
+      fs.copyFileSync(routerMdcSource, routerMdcDest)
+      result.rulesCreated = true
+    }
+
+    // Copy individual command files → .cursor/commands/
+    // This enables /sync, /task, /done, /ship, etc. syntax in Cursor
+    if (fs.existsSync(cursorCommandsSource)) {
+      const commandFiles = fs.readdirSync(cursorCommandsSource)
+        .filter(f => f.endsWith('.md'))
+
+      for (const file of commandFiles) {
+        const src = path.join(cursorCommandsSource, file)
+        const dest = path.join(commandsDir, file)
+        fs.copyFileSync(src, dest)
+      }
+      result.commandsCreated = commandFiles.length > 0
+    }
+
+    // Update .gitignore to exclude prjct Cursor routers
+    result.gitignoreUpdated = await addCursorToGitignore(projectRoot)
+
+    result.success = result.rulesCreated || result.commandsCreated
+    return result
+  } catch (error) {
+    console.error(`Cursor installation warning: ${(error as Error).message}`)
+    return result
+  }
+}
+
+/**
+ * Add Cursor prjct routers to .gitignore
+ *
+ * These files are per-developer and regenerated automatically.
+ */
+async function addCursorToGitignore(projectRoot: string): Promise<boolean> {
+  try {
+    const gitignorePath = path.join(projectRoot, '.gitignore')
+    const entriesToAdd = [
+      '# prjct Cursor routers (regenerated per-developer)',
+      '.cursor/rules/prjct.mdc',
+      '.cursor/commands/sync.md',
+      '.cursor/commands/task.md',
+      '.cursor/commands/done.md',
+      '.cursor/commands/ship.md',
+      '.cursor/commands/bug.md',
+      '.cursor/commands/pause.md',
+      '.cursor/commands/resume.md',
+    ]
+
+    let content = ''
+    let fileExists = false
+
+    try {
+      content = fs.readFileSync(gitignorePath, 'utf-8')
+      fileExists = true
+    } catch (error) {
+      if (!isNotFoundError(error)) {
+        throw error
+      }
+    }
+
+    // Check if already added
+    if (content.includes('.cursor/rules/prjct.mdc')) {
+      return false // Already added
+    }
+
+    // Append to .gitignore
+    const newContent = fileExists
+      ? content.trimEnd() + '\n\n' + entriesToAdd.join('\n') + '\n'
+      : entriesToAdd.join('\n') + '\n'
+
+    fs.writeFileSync(gitignorePath, newContent, 'utf-8')
+    return true
+  } catch (error) {
+    console.error(`Gitignore update warning: ${(error as Error).message}`)
+    return false
+  }
+}
+
+/**
+ * Check if a project has Cursor configured (has .cursor/ directory)
+ */
+export function hasCursorProject(projectRoot: string): boolean {
+  return fs.existsSync(path.join(projectRoot, '.cursor'))
+}
+
+/**
+ * Check if Cursor routers need regeneration
+ */
+export function needsCursorRegeneration(projectRoot: string): boolean {
+  const cursorDir = path.join(projectRoot, '.cursor')
+  const routerPath = path.join(cursorDir, 'rules', 'prjct.mdc')
+
+  // Only check if .cursor/ exists (project uses Cursor)
+  return fs.existsSync(cursorDir) && !fs.existsSync(routerPath)
+}
+
 /**
  * Migrate existing projects to add cliVersion field
  * This clears the status line warning after npm update