prjct-cli 0.19.0 → 0.20.1

package/core/infrastructure/command-installer.ts

@@ -1,8 +1,480 @@
 /**
- * CommandInstaller
- * Re-exports from command-installer/index.ts for backwards compatibility.
+ * Command Installer
+ * Installs prjct commands in Claude Code and other editors.
+ *
+ * 100% Claude-focused architecture
+ * Handles installation and synchronization of /p:* commands
+ * to Claude's native slash command system
+ *
+ * @version 0.5.0
  */
 
-import commandInstaller from './command-installer/index'
-export * from './command-installer/index'
+import fs from 'fs/promises'
+import path from 'path'
+import os from 'os'
+import type {
+  InstallResult,
+  UninstallResult,
+  CheckResult,
+  SyncResult,
+  GlobalConfigResult,
+} from '../types'
+
+// =============================================================================
+// Global Config
+// =============================================================================
+
+/**
+ * Install documentation files to ~/.prjct-cli/docs/
+ */
+export async function installDocs(): Promise<{ success: boolean; error?: string }> {
+  try {
+    const docsDir = path.join(os.homedir(), '.prjct-cli', 'docs')
+    const templateDocsDir = path.join(__dirname, '../../templates/global/docs')
+
+    // Ensure docs directory exists
+    await fs.mkdir(docsDir, { recursive: true })
+
+    // Read all doc files from template
+    const docFiles = await fs.readdir(templateDocsDir)
+
+    // Copy each doc file
+    for (const file of docFiles) {
+      if (file.endsWith('.md')) {
+        const srcPath = path.join(templateDocsDir, file)
+        const destPath = path.join(docsDir, file)
+        const content = await fs.readFile(srcPath, 'utf-8')
+        await fs.writeFile(destPath, content, 'utf-8')
+      }
+    }
+
+    return { success: true }
+  } catch (error) {
+    return { success: false, error: (error as Error).message }
+  }
+}
+
+/**
+ * Install or update global CLAUDE.md configuration
+ */
+export async function installGlobalConfig(
+  claudeConfigPath: string,
+  detectClaude: () => Promise<boolean>
+): Promise<GlobalConfigResult> {
+  const claudeDetected = await detectClaude()
+
+  if (!claudeDetected) {
+    return {
+      success: false,
+      error: 'Claude not detected',
+      action: 'skipped',
+    }
+  }
+
+  try {
+    // Ensure ~/.claude directory exists
+    const claudeDir = path.join(os.homedir(), '.claude')
+    await fs.mkdir(claudeDir, { recursive: true })
+
+    const globalConfigPath = path.join(claudeDir, 'CLAUDE.md')
+    const templatePath = path.join(__dirname, '../../templates/global/CLAUDE.md')
+
+    // Read template content
+    const templateContent = await fs.readFile(templatePath, 'utf-8')
+
+    // Check if global config already exists
+    let existingContent = ''
+    let fileExists = false
+
+    try {
+      existingContent = await fs.readFile(globalConfigPath, 'utf-8')
+      fileExists = true
+    } catch {
+      // File doesn't exist, will create new
+      fileExists = false
+    }
+
+    if (!fileExists) {
+      // Create new file with full template
+      await fs.writeFile(globalConfigPath, templateContent, 'utf-8')
+      return {
+        success: true,
+        action: 'created',
+        path: globalConfigPath,
+      }
+    } else {
+      // File exists - perform intelligent merge
+      const startMarker = '<!-- prjct:start - DO NOT REMOVE THIS MARKER -->'
+      const endMarker = '<!-- prjct:end - DO NOT REMOVE THIS MARKER -->'
+
+      // Check if markers exist in existing file
+      const hasMarkers =
+        existingContent.includes(startMarker) && existingContent.includes(endMarker)
+
+      if (!hasMarkers) {
+        // No markers - append prjct section at the end
+        const updatedContent = existingContent + '\n\n' + templateContent
+        await fs.writeFile(globalConfigPath, updatedContent, 'utf-8')
+        return {
+          success: true,
+          action: 'appended',
+          path: globalConfigPath,
+        }
+      } else {
+        // Markers exist - replace content between markers
+        const beforeMarker = existingContent.substring(0, existingContent.indexOf(startMarker))
+        const afterMarker = existingContent.substring(
+          existingContent.indexOf(endMarker) + endMarker.length
+        )
+
+        // Extract prjct section from template
+        const prjctSection = templateContent.substring(
+          templateContent.indexOf(startMarker),
+          templateContent.indexOf(endMarker) + endMarker.length
+        )
+
+        const updatedContent = beforeMarker + prjctSection + afterMarker
+        await fs.writeFile(globalConfigPath, updatedContent, 'utf-8')
+        return {
+          success: true,
+          action: 'updated',
+          path: globalConfigPath,
+        }
+      }
+    }
+  } catch (error) {
+    return {
+      success: false,
+      error: (error as Error).message,
+      action: 'failed',
+    }
+  }
+}
+
+// =============================================================================
+// Command Installer
+// =============================================================================
+
+export class CommandInstaller {
+  homeDir: string
+  claudeCommandsPath: string
+  claudeConfigPath: string
+  templatesDir: string
+
+  constructor() {
+    this.homeDir = os.homedir()
+    this.claudeCommandsPath = path.join(this.homeDir, '.claude', 'commands', 'p')
+    this.claudeConfigPath = path.join(this.homeDir, '.claude')
+    this.templatesDir = path.join(__dirname, '..', '..', 'templates', 'commands')
+  }
+
+  /**
+   * Detect if Claude is installed
+   */
+  async detectClaude(): Promise<boolean> {
+    try {
+      await fs.access(this.claudeConfigPath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Get list of command files to install
+   */
+  async getCommandFiles(): Promise<string[]> {
+    try {
+      const files = await fs.readdir(this.templatesDir)
+      return files.filter((f) => f.endsWith('.md'))
+    } catch {
+      // Fallback to core commands if template directory not accessible
+      return [
+        'init.md',
+        'now.md',
+        'done.md',
+        'ship.md',
+        'next.md',
+        'idea.md',
+        'recap.md',
+        'progress.md',
+        'stuck.md',
+        'context.md',
+        'analyze.md',
+        'sync.md',
+        'roadmap.md',
+        'task.md',
+        'git.md',
+        'fix.md',
+        'test.md',
+        'cleanup.md',
+        'design.md',
+      ]
+    }
+  }
+
+  /**
+   * Install commands to Claude
+   */
+  async installCommands(): Promise<InstallResult> {
+    const claudeDetected = await this.detectClaude()
+
+    if (!claudeDetected) {
+      return {
+        success: false,
+        error: 'Claude not detected. Please install Claude Code or Claude Desktop first.',
+      }
+    }
+
+    try {
+      // Ensure commands directory exists
+      await fs.mkdir(this.claudeCommandsPath, { recursive: true })
+
+      const commandFiles = await this.getCommandFiles()
+      const installed: string[] = []
+      const errors: Array<{ file: string; error: string }> = []
+
+      for (const file of commandFiles) {
+        try {
+          const sourcePath = path.join(this.templatesDir, file)
+          const destPath = path.join(this.claudeCommandsPath, file)
+
+          const content = await fs.readFile(sourcePath, 'utf-8')
+          await fs.writeFile(destPath, content, 'utf-8')
+
+          installed.push(file.replace('.md', ''))
+        } catch (error) {
+          errors.push({ file, error: (error as Error).message })
+        }
+      }
+
+      return {
+        success: true,
+        installed,
+        errors,
+        path: this.claudeCommandsPath,
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: (error as Error).message,
+      }
+    }
+  }
+
+  /**
+   * Uninstall commands from Claude
+   */
+  async uninstallCommands(): Promise<UninstallResult> {
+    try {
+      const commandFiles = await this.getCommandFiles()
+      const uninstalled: string[] = []
+      const errors: Array<{ file: string; error: string }> = []
+
+      for (const file of commandFiles) {
+        try {
+          const filePath = path.join(this.claudeCommandsPath, file)
+          await fs.unlink(filePath)
+          uninstalled.push(file.replace('.md', ''))
+        } catch (error) {
+          if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {
+            errors.push({ file, error: (error as Error).message })
+          }
+        }
+      }
+
+      // Try to remove the /p directory if empty
+      try {
+        await fs.rmdir(this.claudeCommandsPath)
+      } catch {
+        // Directory not empty or doesn't exist - that's fine
+      }
+
+      return {
+        success: true,
+        uninstalled,
+        errors,
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: (error as Error).message,
+      }
+    }
+  }
+
+  /**
+   * Check if commands are already installed
+   */
+  async checkInstallation(): Promise<CheckResult> {
+    const claudeDetected = await this.detectClaude()
+
+    if (!claudeDetected) {
+      return {
+        installed: false,
+        claudeDetected: false,
+      }
+    }
+
+    try {
+      await fs.access(this.claudeCommandsPath)
+      const files = await fs.readdir(this.claudeCommandsPath)
+      const installedCommands = files
+        .filter((f) => f.endsWith('.md'))
+        .map((f) => f.replace('.md', ''))
+
+      return {
+        installed: installedCommands.length > 0,
+        claudeDetected: true,
+        commands: installedCommands,
+        path: this.claudeCommandsPath,
+      }
+    } catch {
+      return {
+        installed: false,
+        claudeDetected: true,
+        commands: [],
+      }
+    }
+  }
+
+  /**
+   * Update commands (reinstall with latest templates)
+   */
+  async updateCommands(): Promise<InstallResult> {
+    // Simply reinstall - will overwrite with latest templates
+    console.log('Updating commands with latest templates...')
+    const result = await this.installCommands()
+    if (result.success && result.installed) {
+      console.log(`Updated ${result.installed.length} commands`)
+    }
+    return result
+  }
+
+  /**
+   * Install to all detected editors (alias for installCommands)
+   */
+  async installToAll(): Promise<InstallResult> {
+    return await this.installCommands()
+  }
+
+  /**
+   * Get installation path for Claude commands
+   */
+  getInstallPath(): string {
+    return this.claudeCommandsPath
+  }
+
+  /**
+   * Verify command template exists
+   */
+  async verifyTemplate(commandName: string): Promise<boolean> {
+    try {
+      const templatePath = path.join(this.templatesDir, `${commandName}.md`)
+      await fs.access(templatePath)
+      return true
+    } catch {
+      return false
+    }
+  }
+
+  /**
+   * Sync commands - intelligent update that detects and removes orphans
+   */
+  async syncCommands(): Promise<SyncResult> {
+    const claudeDetected = await this.detectClaude()
+
+    if (!claudeDetected) {
+      return {
+        success: false,
+        error: 'Claude not detected',
+        added: 0,
+        updated: 0,
+        removed: 0,
+      }
+    }
+
+    try {
+      // Ensure commands directory exists
+      await fs.mkdir(this.claudeCommandsPath, { recursive: true })
+
+      // Get current state
+      const templateFiles = await this.getCommandFiles()
+      let installedFiles: string[] = []
+
+      try {
+        installedFiles = await fs.readdir(this.claudeCommandsPath)
+        installedFiles = installedFiles.filter((f) => f.endsWith('.md'))
+      } catch {
+        // Directory doesn't exist yet
+        installedFiles = []
+      }
+
+      const results: SyncResult = {
+        success: true,
+        added: 0,
+        updated: 0,
+        removed: 0,
+        errors: [],
+      }
+
+      // Install/update all template files (always overwrite)
+      for (const file of templateFiles) {
+        try {
+          const sourcePath = path.join(this.templatesDir, file)
+          const destPath = path.join(this.claudeCommandsPath, file)
+
+          // Check if file exists in installed location
+          const exists = installedFiles.includes(file)
+
+          // Read and write (always overwrite to ensure latest version)
+          const content = await fs.readFile(sourcePath, 'utf-8')
+          await fs.writeFile(destPath, content, 'utf-8')
+
+          if (!exists) {
+            results.added++
+          } else {
+            results.updated++
+          }
+        } catch (error) {
+          results.errors!.push({ file, error: (error as Error).message })
+        }
+      }
+
+      // Note: We do NOT remove orphaned files
+      // Legacy commands from older versions are preserved
+      // to avoid breaking existing workflows
+
+      return results
+    } catch (error) {
+      return {
+        success: false,
+        error: (error as Error).message,
+        added: 0,
+        updated: 0,
+        removed: 0,
+      }
+    }
+  }
+
+  /**
+   * Install or update global CLAUDE.md configuration
+   */
+  async installGlobalConfig(): Promise<GlobalConfigResult> {
+    return installGlobalConfig(this.claudeConfigPath, () => this.detectClaude())
+  }
+
+  /**
+   * Install documentation files to ~/.prjct-cli/docs/
+   */
+  async installDocs(): Promise<{ success: boolean; error?: string }> {
+    return installDocs()
+  }
+}
+
+// =============================================================================
+// Exports
+// =============================================================================
+
+const commandInstaller = new CommandInstaller()
 export default commandInstaller

package/core/infrastructure/config-manager.ts

@@ -2,59 +2,58 @@
  * ConfigManager - Manages prjct.config.json files
  *
  * Key responsibilities:
- * - Read and write prjct.config.json
+ * - Read and write prjct.config.json (supports .jsonc with comments)
  * - Validate configuration structure
  * - Create new configurations
  * - Update existing configurations
  *
- * @version 0.2.1
+ * @version 0.3.0
  */
 
 import fs from 'fs/promises'
 import path from 'path'
+import * as jsonc from 'jsonc-parser'
 import pathManager from './path-manager'
 import authorDetector from './author-detector'
 import { VERSION } from '../utils/version'
-import { ConfigError, getErrorMessage } from '../errors'
-
-interface Author {
-  name: string
-  email: string
-  github: string
-  firstContribution?: string
-  lastActivity?: string
-}
+import { getTimestamp } from '../utils/date-helper'
+import { getErrorMessage } from '../errors'
+import { isNotFoundError } from '../types/fs'
+import type { Author, LocalConfig, GlobalConfig } from '../types'
 
-interface LocalConfig {
-  projectId: string
-  dataPath: string
-  authors?: Author[]
-  author?: Author
-  version?: string
-  created?: string
-  lastSync?: string
-}
+// Re-export types for convenience
+export type { Author, LocalConfig, GlobalConfig } from '../types'
 
-interface GlobalConfig {
-  projectId: string
-  authors: Author[]
-  version: string
-  created?: string
-  lastSync: string
+/**
+ * Parse JSON or JSONC content safely
+ * Supports comments (line and block style) in config files
+ */
+function parseJsonc<T>(content: string): T {
+  const errors: jsonc.ParseError[] = []
+  const result = jsonc.parse(content, errors, {
+    allowTrailingComma: true,
+    disallowComments: false,
+  })
+  if (errors.length > 0) {
+    const firstError = errors[0]
+    throw new SyntaxError(`JSON parse error at offset ${firstError.offset}: ${jsonc.printParseErrorCode(firstError.error)}`)
+  }
+  return result
 }
 
 class ConfigManager {
   /**
    * Read the project configuration file
+   * Supports both .json and .jsonc formats (with comments)
    */
   async readConfig(projectPath: string): Promise<LocalConfig | null> {
     try {
       const configPath = pathManager.getLocalConfigPath(projectPath)
       const content = await fs.readFile(configPath, 'utf-8')
-      return JSON.parse(content)
+      return parseJsonc<LocalConfig>(content)
     } catch (error) {
       // File not found is expected - return null
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if (isNotFoundError(error)) {
         return null
       }
       // JSON parse errors or other issues - log and return null
@@ -79,15 +78,16 @@ class ConfigManager {
   /**
    * Read the global project configuration file
    * Contains authors array and other system data
+   * Supports both .json and .jsonc formats (with comments)
    */
   async readGlobalConfig(projectId: string): Promise<GlobalConfig | null> {
     try {
       const configPath = pathManager.getGlobalProjectConfigPath(projectId)
       const content = await fs.readFile(configPath, 'utf-8')
-      return JSON.parse(content)
+      return parseJsonc<GlobalConfig>(content)
     } catch (error) {
       // File not found is expected for new projects
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if (isNotFoundError(error)) {
         return null
       }
       // Log other errors for debugging
@@ -116,7 +116,7 @@ class ConfigManager {
     let globalConfig = await this.readGlobalConfig(projectId)
 
     if (!globalConfig) {
-      const now = new Date().toISOString()
+      const now = getTimestamp()
       globalConfig = {
         projectId,
         authors: [],
@@ -139,7 +139,7 @@ class ConfigManager {
     const projectId = pathManager.generateProjectId(projectPath)
     const globalPath = pathManager.getGlobalProjectPath(projectId)
     const displayPath = pathManager.getDisplayPath(globalPath)
-    const now = new Date().toISOString()
+    const now = getTimestamp()
 
     const localConfig: LocalConfig = {
       projectId,
@@ -176,7 +176,7 @@ class ConfigManager {
     const projectId = await this.getProjectId(projectPath)
     const globalConfig = await this.readGlobalConfig(projectId)
     if (globalConfig) {
-      globalConfig.lastSync = new Date().toISOString()
+      globalConfig.lastSync = getTimestamp()
       await this.writeGlobalConfig(projectId, globalConfig)
     }
   }
@@ -218,7 +218,7 @@ class ConfigManager {
       return coreFiles.length === 0
     } catch (error) {
       // Directory not found means migration needed
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') {
+      if (isNotFoundError(error)) {
         return true
       }
       // Permission errors or other issues - assume migration needed
@@ -261,7 +261,7 @@ class ConfigManager {
     const exists = globalConfig.authors.some((a) => a.github === author.github)
     if (exists) return
 
-    const now = new Date().toISOString()
+    const now = getTimestamp()
     globalConfig.authors.push({
       name: author.name || 'Unknown',
       email: author.email || '',
@@ -284,7 +284,7 @@ class ConfigManager {
 
     const author = globalConfig.authors.find((a) => a.github === githubUsername)
     if (author) {
-      author.lastActivity = new Date().toISOString()
+      author.lastActivity = getTimestamp()
       globalConfig.lastSync = author.lastActivity
       await this.writeGlobalConfig(projectId, globalConfig)
     }
@@ -297,7 +297,11 @@ class ConfigManager {
     const author = await authorDetector.detect()
 
     const projectId = await this.getProjectId(projectPath)
-    await this.addAuthor(projectId, author)
+    await this.addAuthor(projectId, {
+      name: author.name ?? undefined,
+      email: author.email ?? undefined,
+      github: author.github ?? undefined
+    })
 
     return author.github || author.name || 'Unknown'
   }