feat: Add sync-ide functionality for IDE integration

zmotso · SergK · commit 44f8dda68e94 · 2025-10-16T19:21:31.000+03:00
Introduced a new command-line flag `--sync-ide` for install command
to sync IDE integration files from installed agents.
diff --git a/.vscode/launch.json b/.vscode/launch.json
@@ -48,6 +48,17 @@
                 "KRCI_AI_PROJECT_DIR": "${workspaceFolder}"
             }
         },
+        {
+            "name": "install sync ide",
+            "type": "go",
+            "request": "launch",
+            "mode": "auto",
+            "program": "${workspaceFolder}/cmd/krci-ai/main.go",
+            "args": ["install", "--sync-ide"],
+            "env": {
+                "KRCI_AI_PROJECT_DIR": "${workspaceFolder}"
+            }
+        },
         {
             "name": "install krci-ai go-dev",
             "type": "go",
diff --git a/cmd/krci-ai/cmd/install.go b/cmd/krci-ai/cmd/install.go
@@ -74,7 +74,11 @@ Examples:
 
   # Force operations
   krci-ai install --ide cursor --force         # Add IDE integration to existing install
-  krci-ai install --all --force                # Force reinstall everything`,
+  krci-ai install --all --force                # Force reinstall everything
+
+  # Sync IDE files from installed agents (instead of embedded assets)
+  krci-ai install --sync-ide                   # Sync all existing IDE integrations from installed agents
+  krci-ai install --agent dev --sync-ide       # Install dev agent + sync IDE files`,
 	Run: func(cmd *cobra.Command, args []string) {
 		errorHandler := cli.NewErrorHandler()
 
@@ -111,23 +115,31 @@ Examples:
 
 		// Check aliases flag if main flag is empty
 		if agentFlag == "" {
-			if agentsFlag, err := cmd.Flags().GetString("agents"); err == nil && agentsFlag != "" {
+			agentsFlag, flagErr := cmd.Flags().GetString("agents")
+			if flagErr == nil && agentsFlag != "" {
 				agentFlag = agentsFlag
 			}
 		}
 
+		// Check sync-ide flag
+		syncIDEFlag, err := cmd.Flags().GetBool("sync-ide")
+		if err != nil {
+			errorHandler.HandleError(err, "Failed to read sync-ide flag")
+			return
+		}
+
 		if agentFlag != "" {
-			runSelectiveInstallation(cmd, agentFlag, ideFlag, output, errorHandler)
+			runSelectiveInstallation(cmd, agentFlag, ideFlag, syncIDEFlag, output, errorHandler)
 			return
 		}
 
 		// Standard full installation
-		runFullInstallation(cmd, ideFlag, output, errorHandler)
+		runFullInstallation(cmd, ideFlag, syncIDEFlag, output, errorHandler)
 	},
 }
 
 // runSelectiveInstallation handles installation of specific agents only
-func runSelectiveInstallation(_ *cobra.Command, agentFlag string, ideFlag string, output *cli.OutputHandler, errorHandler *cli.ErrorHandler) {
+func runSelectiveInstallation(_ *cobra.Command, agentFlag string, ideFlag string, syncIDEFlag bool, output *cli.OutputHandler, errorHandler *cli.ErrorHandler) {
 	// Parse agent list using existing bundle logic
 	agentNames := ParseAgentList(agentFlag)
 	if len(agentNames) == 0 {
@@ -161,11 +173,17 @@ func runSelectiveInstallation(_ *cobra.Command, agentFlag string, ideFlag string
 		handleIDEIntegration(installer, ideFlag, output, errorHandler)
 	}
 
+	// Handle sync-ide flag at the end
+	if syncIDEFlag {
+		output.PrintInfo("Syncing IDE integration files from installed agents...")
+		handleIDESync(installer, output, errorHandler)
+	}
+
 	output.PrintSuccess(fmt.Sprintf("Selected agents installed successfully: %v", agentNames))
 }
 
 // runFullInstallation handles standard full framework installation
-func runFullInstallation(cmd *cobra.Command, ideFlag string, output *cli.OutputHandler, errorHandler *cli.ErrorHandler) {
+func runFullInstallation(cmd *cobra.Command, ideFlag string, syncIDEFlag bool, output *cli.OutputHandler, errorHandler *cli.ErrorHandler) {
 	output.PrintProgress("Installing KubeRocketAI framework components...")
 
 	// Get force flag (other flags already processed upfront)
@@ -193,37 +211,45 @@ func runFullInstallation(cmd *cobra.Command, ideFlag string, output *cli.OutputH
 		assets.NewEmbeddedDiscovery(GetEmbeddedAssets(), assets.EmbeddedPrefix),
 	)
 
-	// Check installation status and force flag
-	if !handleInstallationCheck(installer, forceFlag, output) {
-		return
-	}
+	// Check installation status
+	isAlreadyInstalled := installer.IsInstalled()
 
-	// Perform core installation
-	if err := performCoreInstallation(installer, output, errorHandler); err != nil {
+	// Special case: If already installed and only syncing IDE files (no reinstall needed)
+	if isAlreadyInstalled && syncIDEFlag && !forceFlag {
+		output.PrintInfo("Framework already installed. Syncing IDE integration files from installed agents...")
+		handleIDESync(installer, output, errorHandler)
+		output.PrintSuccess("IDE integration files synced successfully!")
 		return
 	}
 
-	// Handle IDE integration using existing function
-	handleIDEIntegration(installer, ideFlag, output, errorHandler)
-
-	// Show success and next steps
-	showInstallationSuccess(installer, ideFlag, output)
-}
-
-// handleInstallationCheck checks if installation should proceed
-func handleInstallationCheck(installer *assets.Installer, forceFlag bool, output *cli.OutputHandler) bool {
-	if installer.IsInstalled() && !forceFlag {
+	// Check if installation should proceed
+	if isAlreadyInstalled && !forceFlag {
 		output.PrintWarning("Framework already installed in current directory")
 		output.PrintInfo("If you want to proceed with installation, use the --force flag:")
 		output.PrintInfo("  krci-ai install --force")
-		return false
+		return
 	}
 
-	if installer.IsInstalled() && forceFlag {
+	if isAlreadyInstalled && forceFlag {
 		output.PrintWarning("Framework already installed - proceeding with forced installation")
 	}
 
-	return true
+	// Perform core installation
+	if err := performCoreInstallation(installer, output, errorHandler); err != nil {
+		return
+	}
+
+	// Handle IDE integration
+	// If sync-ide is set, use installed agents; otherwise use embedded assets
+	if syncIDEFlag {
+		output.PrintInfo("Setting up IDE integration from installed agents...")
+		handleIDESync(installer, output, errorHandler)
+	} else if ideFlag != "" {
+		handleIDEIntegration(installer, ideFlag, output, errorHandler)
+	}
+
+	// Show success and next steps
+	showInstallationSuccess(installer, ideFlag, output)
 }
 
 // performCoreInstallation handles the core framework installation
@@ -284,6 +310,9 @@ func init() {
 	// Add selective installation flags (following bundle command patterns)
 	installCmd.Flags().String("agent", "", "Install specific agents (comma or space separated: 'pm,architect' or 'pm architect')")
 	installCmd.Flags().String("agents", "", "Alias for --agent flag")
+
+	// Add sync-ide flag
+	installCmd.Flags().Bool("sync-ide", false, "Sync IDE integration files from installed agents")
 }
 
 // validateIDEFlag validates the IDE flag value and returns error if invalid
@@ -335,3 +364,43 @@ func handleIDEIntegration(installer *assets.Installer, ideFlag string, output *c
 		output.PrintSuccess("Windsurf IDE integration installed successfully!")
 	}
 }
+
+// handleIDESync syncs IDE integration files from installed agents
+func handleIDESync(installer *assets.Installer, output *cli.OutputHandler, errorHandler *cli.ErrorHandler) {
+	// Check which IDE directories exist and sync them
+	if installer.HasCursorIntegration() {
+		output.PrintInfo("Syncing Cursor IDE integration...")
+		if err := installer.SyncCursorIntegration(); err != nil {
+			errorHandler.HandleError(err, "Failed to sync Cursor IDE integration")
+			return
+		}
+		output.PrintSuccess("Cursor IDE integration synced successfully!")
+	}
+
+	if installer.HasClaudeIntegration() {
+		output.PrintInfo("Syncing Claude Code integration...")
+		if err := installer.SyncClaudeIntegration(); err != nil {
+			errorHandler.HandleError(err, "Failed to sync Claude Code integration")
+			return
+		}
+		output.PrintSuccess("Claude Code integration synced successfully!")
+	}
+
+	if installer.HasVSCodeIntegration() {
+		output.PrintInfo("Syncing VS Code integration...")
+		if err := installer.SyncVSCodeIntegration(); err != nil {
+			errorHandler.HandleError(err, "Failed to sync VS Code integration")
+			return
+		}
+		output.PrintSuccess("VS Code integration synced successfully!")
+	}
+
+	if installer.HasWindsurfIntegration() {
+		output.PrintInfo("Syncing Windsurf IDE integration...")
+		if err := installer.SyncWindsurfIntegration(); err != nil {
+			errorHandler.HandleError(err, "Failed to sync Windsurf IDE integration")
+			return
+		}
+		output.PrintSuccess("Windsurf IDE integration synced successfully!")
+	}
+}
diff --git a/internal/assets/installer_ide.go b/internal/assets/installer_ide.go
@@ -253,3 +253,75 @@ func (i *Installer) GetTemplatesPath() string {
 func (i *Installer) GetDataPath() string {
 	return GetDataPath(i.krciPath)
 }
+
+// HasCursorIntegration checks if Cursor IDE integration directory exists
+func (i *Installer) HasCursorIntegration() bool {
+	cursorPath := i.GetCursorRulesPath()
+	info, err := os.Stat(cursorPath)
+	return err == nil && info.IsDir()
+}
+
+// HasClaudeIntegration checks if Claude Code integration directory exists
+func (i *Installer) HasClaudeIntegration() bool {
+	claudePath := i.GetClaudeCommandsPath()
+	info, err := os.Stat(claudePath)
+	return err == nil && info.IsDir()
+}
+
+// HasVSCodeIntegration checks if VS Code integration directory exists
+func (i *Installer) HasVSCodeIntegration() bool {
+	vscodePath := i.GetVSCodeChatmodesPath()
+	info, err := os.Stat(vscodePath)
+	return err == nil && info.IsDir()
+}
+
+// HasWindsurfIntegration checks if Windsurf IDE integration directory exists
+func (i *Installer) HasWindsurfIntegration() bool {
+	windsurfPath := i.GetWindsurfRulesPath()
+	info, err := os.Stat(windsurfPath)
+	return err == nil && info.IsDir()
+}
+
+// SyncCursorIntegration syncs Cursor IDE integration from installed agents
+func (i *Installer) SyncCursorIntegration() error {
+	integration := &CursorIntegration{projectDir: i.projectDir}
+	return i.syncIDEIntegration(integration, "Cursor IDE")
+}
+
+// SyncClaudeIntegration syncs Claude Code integration from installed agents
+func (i *Installer) SyncClaudeIntegration() error {
+	integration := &ClaudeIntegration{projectDir: i.projectDir}
+	return i.syncIDEIntegration(integration, "Claude Code")
+}
+
+// SyncVSCodeIntegration syncs VS Code integration from installed agents
+func (i *Installer) SyncVSCodeIntegration() error {
+	integration := &VSCodeIntegration{targetDir: i.projectDir}
+	return i.syncIDEIntegration(integration, "VS Code")
+}
+
+// SyncWindsurfIntegration syncs Windsurf IDE integration from installed agents
+func (i *Installer) SyncWindsurfIntegration() error {
+	integration := &WindsurfIntegration{targetDir: i.projectDir}
+	return i.syncIDEIntegration(integration, "Windsurf IDE")
+}
+
+// syncIDEIntegration is a generic method for syncing IDE integrations from installed agents
+func (i *Installer) syncIDEIntegration(integration IDEIntegration, ideName string) error {
+	// Get list of agent files from installed location (not embedded)
+	agentsPath := i.GetAgentsPath()
+	agentFiles, err := filepath.Glob(filepath.Join(agentsPath, "*.yaml"))
+	if err != nil {
+		return fmt.Errorf("failed to find agent files: %w", err)
+	}
+
+	// Generate IDE-specific files for each agent
+	for _, agentFile := range agentFiles {
+		if err := i.generateIDEFile(agentFile, integration); err != nil {
+			agentName := strings.TrimSuffix(filepath.Base(agentFile), ".yaml")
+			return fmt.Errorf("failed to generate %s file for %s: %w", ideName, agentName, err)
+		}
+	}
+
+	return nil
+}
