fix(workspace): overhaul workspace detection and tooling

- Extract hardcoded Tier markers into dynamic detector Options
- Redesign walkUp to retain highest-priority roots instead of returning eagerly
- Refactor rag_index_workspace tool to necessitate a solid 'workspace_root' rather than 'file_path'
- Introduce dual-stage AI validation via the 'confirm' tool schema parameter
- Eradicate legacy hardcoded workspace paths inside test suite (avoid 'backend' assumptions)
- Update documentation and server.json resolving legacy file_path instructions
- Expose FindAlternativeCandidates securely via engine wrappers

Author: doITmagic

cmd/rag-code-install/main.go

@@ -646,6 +646,19 @@ func configureIDEs(selected []string, binDir string, transport string, ssePort i
 		log(fmt.Sprintf(`  command = "%s"`, binPath))
 		log(`  args = []`)
 	}
+
+	// OpenClaw / NemoClaw Logging
+	openclawPath := filepath.Join(home, ".openclaw")
+	if _, err := os.Stat(openclawPath); err == nil {
+		log("OpenClaw detected at ~/.openclaw – requires manual config.")
+		log(fmt.Sprintf(`  Run: openclaw mcp set ragcode "%s"`, binPath))
+	}
+
+	nemoclawPath := filepath.Join(home, ".nemoclaw")
+	if _, err := os.Stat(nemoclawPath); err == nil {
+		log("NemoClaw sandbox detected – requires manual policy config.")
+		log("  Please refer to NVIDIA OpenShell documentation to map the MCP tool.")
+	}
 }
 
 type idePath struct {
@@ -659,13 +672,10 @@ func resolveIDEPaths(home string) map[string]idePath {
 			path:        filepath.Join(home, ".codeium", "windsurf", "mcp_config.json"),
 			displayName: "Windsurf",
 		},
-		"cursor": {
-			path:        filepath.Join(home, ".cursor", "mcp.config.json"),
-			displayName: "Cursor",
-		},
+		"cursor": determineCursorPath(home),
 		"copilot": {
-			path:        filepath.Join(home, ".aitk", "mcp.json"),
-			displayName: "GitHub Copilot",
+			path:        filepath.Join(home, ".copilot", "mcp-config.json"),
+			displayName: "GitHub Copilot CLI",
 		},
 		"antigravity": {
 			path:        filepath.Join(home, ".gemini", "antigravity", "mcp_config.json"),
@@ -685,6 +695,14 @@ func resolveIDEPaths(home string) map[string]idePath {
 			path:        filepath.Join(home, ".gemini", "settings.json"),
 			displayName: "Gemini CLI",
 		},
+		"openhands": {
+			path:        filepath.Join(home, ".openhands", "mcp.json"),
+			displayName: "OpenHands",
+		},
+		"continue": {
+			path:        filepath.Join(home, ".continue", "mcpServers", "ragcode.json"),
+			displayName: "Continue.dev",
+		},
 	}
 
 	// Claude Desktop (GUI app) – OS-specific paths
@@ -711,31 +729,39 @@ func resolveIDEPaths(home string) map[string]idePath {
 		paths["zed"] = idePath{filepath.Join(home, ".config", "zed", "settings.json"), "Zed Editor"}
 	}
 
-	// VS Code (modern copilot mcp.json)
-	if vsPath, ok := determineVSCodePath(home); ok {
-		paths["vs-code"] = vsPath
+	// VS Code (Copilot & popular extensions like Roo Code, Cline)
+	if vsCodeUserDir, ok := getVSCodeUserDir(home); ok {
+		paths["vs-code"] = idePath{path: filepath.Join(vsCodeUserDir, "mcp.json"), displayName: "VS Code (Copilot)"}
+		paths["roo-code"] = idePath{path: filepath.Join(vsCodeUserDir, "globalStorage", "rooveterinaryinc.roo-cline", "settings", "cline_mcp_settings.json"), displayName: "Roo Code (VS Code)"}
+		paths["cline"] = idePath{path: filepath.Join(vsCodeUserDir, "globalStorage", "saoudrizwan.claude-dev", "settings", "cline_mcp_settings.json"), displayName: "Cline (VS Code)"}
 	}
 
 	return paths
 }
 
-func determineVSCodePath(home string) (idePath, bool) {
-	var userDir string
+func determineCursorPath(home string) idePath {
+	if runtime.GOOS == "windows" {
+		appData := os.Getenv("APPDATA")
+		if appData != "" {
+			return idePath{path: filepath.Join(appData, "Cursor", "mcp.json"), displayName: "Cursor"}
+		}
+	}
+	return idePath{path: filepath.Join(home, ".cursor", "mcp.json"), displayName: "Cursor"}
+}
+
+func getVSCodeUserDir(home string) (string, bool) {
 	switch runtime.GOOS {
 	case "windows":
 		appData := os.Getenv("APPDATA")
 		if appData == "" {
-			return idePath{}, false
+			return "", false
 		}
-		userDir = filepath.Join(appData, "Code", "User")
+		return filepath.Join(appData, "Code", "User"), true
 	case "darwin":
-		userDir = filepath.Join(home, "Library", "Application Support", "Code", "User")
+		return filepath.Join(home, "Library", "Application Support", "Code", "User"), true
 	default:
-		userDir = filepath.Join(home, ".config", "Code", "User")
+		return filepath.Join(home, ".config", "Code", "User"), true
 	}
-
-	newPath := filepath.Join(userDir, "mcp.json") // modern copilot mcp standard
-	return idePath{path: newPath, displayName: "VS Code"}, true
 }
 
 type ideSelection struct {

docs/tools/doc_index_workspace.md

@@ -8,7 +8,7 @@
 
 This tool doesn't query the search API. Instead, it triggers the internal **Indexer Service Pipeline**.
 
-1. **Resolution phase**: Resolves the exact boundaries of the Git repository based on `file_path`.
+1. **Resolution phase**: Validates the strictly provided `workspace_root` parameter, checks boundaries & dependencies, and enforces an AI confirmation sequence via the `confirm: true` parameter rule before proceeding.
 2. **Asynchronous Hand-off**: Executes `engine.StartIndexingAsync(wctx.Root, wctx.ID, nil, recreate)`.
 
 ## Features

internal/service/engine/engine.go

@@ -140,6 +140,13 @@ func (e *Engine) Config() *config.Config {
 	return e.config
 }
 
+// FindAlternativeCandidates wraps detector logic to offer alternative root suggestions internally
+func (e *Engine) FindAlternativeCandidates(root string) []string {
+	// Isolate execution using official detection definitions 
+	det := detector.New(detector.DefaultOptions())
+	return det.FindAlternativeCandidates(root)
+}
+
 // WorkspaceContext provides information about a detected workspace.
 type WorkspaceContext struct {
 	Root            string

internal/service/tools/index_workspace.go

@@ -4,6 +4,7 @@ import (
 	"context"
 	"fmt"
 	"runtime"
+	"strings"
 	"time"
 
 	"github.com/doITmagic/rag-code-mcp/internal/logger"
@@ -27,13 +28,14 @@ func NewIndexWorkspaceTool(eng *engine.Engine) *IndexWorkspaceTool {
 func (t *IndexWorkspaceTool) Name() string { return "rag_index_workspace" }
 func (t *IndexWorkspaceTool) Description() string {
 	return "Indexes or reindexes a workspace for semantic code search. " +
-		"Use this tool to manually trigger indexing if search results are stale or 'workspace not indexed'. " +
-		"Analyzes all supported source files and stores vectors for semantic search. " +
-		"The process runs in the background."
+		"Instead of abstract paths, you MUST explicitly provide the absolute 'workspace_root' directory. " +
+		"The tool first validates the root and returns early. Then, you submit a second call with 'confirm': true " +
+		"to actually lock-in the registry root and start the background indexing."
 }
 
 type IndexWorkspaceInput struct {
-	FilePath           string `json:"file_path,omitempty"`
+	WorkspaceRoot      string `json:"workspace_root,omitempty"`
+	Confirm            bool   `json:"confirm,omitempty"`
 	Recreate           bool   `json:"recreate,omitempty"`
 	IncludeRuntimeInfo bool   `json:"include_runtime_info,omitempty"`
 }
@@ -44,7 +46,8 @@ func (t *IndexWorkspaceTool) Register(server *mcp.Server) {
 		Description: t.Description(),
 	}, func(ctx context.Context, req *mcp.CallToolRequest, input IndexWorkspaceInput) (*mcp.CallToolResult, any, error) {
 		args := map[string]interface{}{
-			"file_path":            input.FilePath,
+			"workspace_root":       input.WorkspaceRoot,
+			"confirm":              input.Confirm,
 			"recreate":             input.Recreate,
 			"include_runtime_info": input.IncludeRuntimeInfo,
 		}
@@ -69,17 +72,43 @@ func (t *IndexWorkspaceTool) Register(server *mcp.Server) {
 }
 
 func (t *IndexWorkspaceTool) Execute(ctx context.Context, params map[string]interface{}) (string, error) {
-	filePath, _ := params["file_path"].(string)
+	workspaceRoot, ok := params["workspace_root"].(string)
+	if !ok || workspaceRoot == "" {
+		response := ToolResponse{
+			Status: "error",
+			Error:  "workspace_root parameter is strictly required to explicitly pinpoint the directory to index.",
+		}
+		return response.JSON()
+	}
+
+	confirm, _ := params["confirm"].(bool)
 
-	// Detect workspace context
-	wctx, err := t.engine.DetectContext(ctx, filePath)
+	// Detect workspace context using explicit root validation 
+	wctx, err := t.engine.DetectContext(ctx, workspaceRoot)
 	if err != nil {
+		candidates := t.engine.FindAlternativeCandidates(workspaceRoot)
+		msg := err.Error()
+		if len(candidates) > 0 {
+			msg = fmt.Sprintf("Validation failed: %s.\n\nSuggested local roots (Tiers applied):\n- %s", err.Error(), strings.Join(candidates, "\n- "))
+		}
+		
 		response := ToolResponse{
 			Status: "error",
-			Error:  err.Error(),
+			Error:  msg,
+		}
+		return response.JSON()
+	}
+
+	if !confirm {
+		response := ToolResponse{
+			Status:  "confirmation_required",
+			Message: fmt.Sprintf("Workspace detected successfully at '%s'. \nVerify this is the correct top-level folder! \n\nCall the tool again passing \"confirm\": true alongside the 'workspace_root' to begin indexing.", wctx.Root),
+			Context: ContextMetadata{
+				WorkspaceRoot:   wctx.Root,
+				DetectionSource: wctx.DetectionSource,
+			},
 		}
-		body, _ := response.JSON()
-		return body, nil
+		return response.JSON()
 	}
 
 	recreate, _ := params["recreate"].(bool)
@@ -89,7 +118,7 @@ func (t *IndexWorkspaceTool) Execute(ctx context.Context, params map[string]inte
 
 	response := ToolResponse{
 		Status:  "indexing_started",
-		Message: fmt.Sprintf("🚀 Indexing started for workspace '%s'. The process is running in the background. You can use rag_search immediately - results will appear as indexing progresses.", wctx.Root),
+		Message: fmt.Sprintf("🚀 Indexing started for validated workspace '%s'. The nested constraints were processed and cleanup checks triggered.", wctx.Root),
 		Context: ContextMetadata{
 			WorkspaceRoot:   wctx.Root,
 			DetectionSource: wctx.DetectionSource,

llms-full.txt

@@ -729,7 +729,7 @@ Find all authentication logic in this codebase.
 cd ~/projects/my-awesome-app
 
 # 2. Ask AI to index (using the prompt above)
-# AI will call: rag_index_workspace with file_path="/path/to/my-awesome-app/main.go"
+# AI will call: rag_index_workspace with workspace_root="/path/to/my-awesome-app" (and must submit a second confirmation call via confirm: true)
 
 # 3. Wait for confirmation (usually 1-5 minutes)
 # ✓ Indexing started for workspace '/path/to/my-awesome-app'