Merge pull request #15 from doITmagic/feature/skills-system-clean

feat: Intelligent AI Skills System & Smart Auto-Update (v2)

Author: doITmagic

.gitignore

@@ -3,7 +3,6 @@ data/
 test_data/
 qdrant_data/
 barou/
-.agent/
 
 # Binaries
 /cmd/agent-runner/agent-runner
@@ -59,3 +58,8 @@ temp/
 # Scripts
 scripts/
 .ragcode/
+.agent/skills/
+
+# Debug logs
+startup_debug.txt
+windsurf_debug_log.txt

cmd/install/main.go

@@ -511,9 +511,9 @@ func installBinary() {
 	}
 	var binDir string
 	if runtime.GOOS == "windows" {
-		binDir = filepath.Join(home, ".local", "share", "ragcode", "bin")
+		binDir = filepath.Join(home, installDirName, "bin")
 	} else {
-		binDir = filepath.Join(home, ".local", "share", "ragcode", "bin")
+		binDir = filepath.Join(home, installDirName, "bin")
 	}
 	if err := os.MkdirAll(binDir, 0755); err != nil {
 		fail(fmt.Sprintf("Could not create bin directory: %v", err))
@@ -588,10 +588,13 @@ func copyFile(src, dst string) error {
 			return err
 		}
 	}
-	defer destFile.Close()
+	_, copyErr := io.Copy(destFile, sourceFile)
+	closeErr := destFile.Close()
 
-	_, err = io.Copy(destFile, sourceFile)
-	return err
+	if copyErr != nil {
+		return copyErr
+	}
+	return closeErr
 }
 
 // downloadAndExtractBinary fetches the release archive and extracts the binary.
@@ -661,11 +664,17 @@ func downloadAndExtractBinary(dest string) bool {
 		warn(fmt.Sprintf("Could not create destination file: %v", err))
 		return false
 	}
-	defer outFile.Close()
 	cmd.Stdout = outFile
 
-	if err := cmd.Run(); err != nil {
-		warn(fmt.Sprintf("Failed to extract binary: %v", err))
+	runErr := cmd.Run()
+	closeErr := outFile.Close()
+
+	if runErr != nil {
+		warn(fmt.Sprintf("Failed to extract binary: %v", runErr))
+		return false
+	}
+	if closeErr != nil {
+		warn(fmt.Sprintf("Failed to finalise binary file: %v", closeErr))
 		return false
 	}
 
@@ -707,10 +716,15 @@ func addToPath(binDir string) {
 		warn(fmt.Sprintf("Could not update shell config: %v", err))
 		return
 	}
-	defer f.Close()
-
 	if _, err := f.WriteString(fmt.Sprintf("\nexport PATH=\"%s:$PATH\"\n", binDir)); err != nil {
 		warn(fmt.Sprintf("Could not write to shell config: %v", err))
+		if cerr := f.Close(); cerr != nil {
+			warn(fmt.Sprintf("Could not finalise shell config after write failure: %v", cerr))
+		}
+		return
+	}
+	if err := f.Close(); err != nil {
+		warn(fmt.Sprintf("Could not finalise shell config: %v", err))
 	} else {
 		success(fmt.Sprintf("Added to %s (restart shell to apply)", shellConfig))
 	}

cmd/rag-code-mcp/main.go

@@ -12,6 +12,7 @@ import (
 	"os/signal"
 	"path/filepath"
 	"strings"
+	"sync"
 	"syscall"
 	"time"
 
@@ -364,16 +365,6 @@ workspace:
 }
 
 func main() {
-	// AGGRESSIVE STARTUP DEBUG
-	f, _ := os.Create("/tmp/ragcode-startup.txt")
-	cwd, _ := os.Getwd()
-	exe, _ := os.Executable()
-	fmt.Fprintf(f, "Time: %s\n", time.Now())
-	fmt.Fprintf(f, "Exe: %s\n", exe)
-	fmt.Fprintf(f, "CWD: %s\n", cwd)
-	fmt.Fprintf(f, "Args: %v\n", os.Args)
-	f.Close()
-
 	// Define flags
 	configPath := flag.String("config", "config.yaml", "Path to configuration file")
 	ollamaBaseURLFlag := flag.String("ollama-base-url", "", "Ollama base URL (overrides config/env)")
@@ -437,7 +428,7 @@ func main() {
 	// Handle update flag
 	if *updateFlag {
 		fmt.Println("Checking for updates...")
-		info, err := updater.CheckForUpdates(Version)
+		info, err := updater.CheckForUpdates(context.Background(), Version, true)
 		if err != nil {
 			log.Fatalf("Failed to check for updates: %v", err)
 		}
@@ -447,8 +438,26 @@ func main() {
 		}
 
 		fmt.Printf("Found new version: %s\nDownloading...\n", info.LatestVersion)
-		tempFile := filepath.Join(os.TempDir(), "ragcode_update.tar.gz")
-		if err := info.DownloadAndVerify(tempFile); err != nil {
+
+		// Determine extension from asset URL
+		ext := ".tar.gz"
+		if strings.HasSuffix(info.AssetURL, ".zip") {
+			ext = ".zip"
+		}
+		// Create a unique temporary file securely
+		tmp, err := os.CreateTemp("", "ragcode_update_*"+ext)
+		if err != nil {
+			log.Fatalf("Failed to create temporary file for update: %v", err)
+		}
+		tempFile := tmp.Name()
+		// We only need the path; close the file descriptor
+		if err := tmp.Close(); err != nil {
+			log.Fatalf("Failed to close temporary file for update: %v", err)
+		}
+		// Ensure the temporary file is removed after applying the update
+		defer os.Remove(tempFile)
+
+		if err := info.DownloadAndVerify(context.Background(), tempFile); err != nil {
 			log.Fatalf("Update failed: %v", err)
 		}
 
@@ -477,12 +486,7 @@ func main() {
 	}
 
 	// Background update check
-	go func() {
-		info, err := updater.CheckForUpdates(Version)
-		if err == nil && info != nil {
-			logger.Info("🌟 New version available: %s. Run 'rag-code-mcp --update' to upgrade.", info.LatestVersion)
-		}
-	}()
+	triggerBackgroundUpdateCheck()
 
 	// Apply logging settings from config unless env vars already override them
 	applyLoggingConfig(cfg.Logging)
@@ -643,6 +647,11 @@ func main() {
 
 	indexWorkspaceTool := tools.NewIndexWorkspaceTool(workspaceManager)
 
+	listSkillsTool := tools.NewListSkillsTool()
+	installSkillTool := tools.NewInstallSkillTool(workspaceManager)
+	checkUpdateTool := tools.NewCheckUpdateTool(Version)
+	applyUpdateTool := tools.NewApplyUpdateTool(Version)
+
 	// Example: use typed ToolHandlerFor for search_code
 	registerSearchCodeToolTyped(server, searchTool, cfg)
 
@@ -655,6 +664,10 @@ func main() {
 	registerAgentTool(server, searchDocsTool, cfg)
 	registerAgentTool(server, hybridTool, cfg)
 	registerAgentTool(server, indexWorkspaceTool, cfg)
+	registerAgentTool(server, listSkillsTool, cfg)
+	registerAgentTool(server, installSkillTool, cfg)
+	registerAgentTool(server, checkUpdateTool, cfg)
+	registerAgentTool(server, applyUpdateTool, cfg)
 
 	if err := registerFileResources(server); err != nil {
 		log.Fatalf("Failed to register resources: %v", err)
@@ -708,6 +721,9 @@ func registerSearchCodeToolTyped(server *mcp.Server, tool *tools.SearchLocalInde
 
 		logger.Info("✅ Tool '%s' completed in %v", tool.Name(), duration)
 
+		// Trigger background update check (non-blocking)
+		triggerBackgroundUpdateCheck()
+
 		return nil, SearchCodeOutput{Results: result}, nil
 	})
 }
@@ -751,6 +767,9 @@ func registerAgentTool(server *mcp.Server, tool MCPTool, cfg *config.Config) {
 
 		logger.Info("✅ Tool '%s' completed in %v", tool.Name(), duration)
 
+		// Trigger background update check (non-blocking)
+		triggerBackgroundUpdateCheck()
+
 		return &mcp.CallToolResult{
 			Content: []mcp.Content{
 				&mcp.TextContent{Text: result},
@@ -1097,6 +1116,54 @@ func getToolSchema(toolName string) map[string]interface{} {
 			"required": []string{"query"},
 		}
 
+	case "list_skills":
+		return map[string]interface{}{
+			"type":       "object",
+			"properties": map[string]interface{}{},
+		}
+
+	case "install_skill":
+		return map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"skill_id": map[string]interface{}{
+					"type":        "string",
+					"description": "The ID of the skill to install or uninstall",
+				},
+				"active": map[string]interface{}{
+					"type":        "boolean",
+					"description": "True to install the skill, false to uninstall it",
+				},
+				"file_path": map[string]interface{}{
+					"type":        "string",
+					"description": "Optional: file path to help detect workspace context",
+				},
+			},
+			"required": []string{"skill_id", "active"},
+		}
+
+	case "check_update":
+		return map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"force": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Force check ignoring cache (default: false)",
+				},
+			},
+		}
+
+	case "apply_update":
+		return map[string]interface{}{
+			"type": "object",
+			"properties": map[string]interface{}{
+				"force": map[string]interface{}{
+					"type":        "boolean",
+					"description": "Force update even if version matches (default: false)",
+				},
+			},
+		}
+
 	default:
 		return map[string]interface{}{
 			"type":       "object",
@@ -1252,6 +1319,7 @@ func ensureIDERules(cfg *config.Config, filePath string) {
 - Always provide 'file_path' to tools to ensure they detect the correct project context.
 - Use 'hybrid_search' if looking for exact variable names or error messages.
 - If the tool says "workspace not indexed", use 'index_workspace' once.
+- **Skills System**: Use 'list_skills' to see available AI behaviors and 'install_skill' to enable them in this workspace (e.g., 'ragcode-priority', 'ragcode-update').
 `
 
 	// 3. Define target rule files
@@ -1287,3 +1355,27 @@ func ensureIDERules(cfg *config.Config, filePath string) {
 		}
 	}
 }
+
+var (
+	lastUpdateCheck      time.Time
+	lastUpdateCheckMutex sync.Mutex
+)
+
+func triggerBackgroundUpdateCheck() {
+	lastUpdateCheckMutex.Lock()
+	defer lastUpdateCheckMutex.Unlock()
+
+	// Only check if more than 1 hour passed since last check in THIS session
+	// to avoid spamming go-routines, while updater.CheckForUpdates handles the 24h logic
+	if time.Since(lastUpdateCheck) < 1*time.Hour {
+		return
+	}
+	lastUpdateCheck = time.Now()
+
+	go func() {
+		info, err := updater.CheckForUpdates(context.Background(), Version, false)
+		if err == nil && info != nil {
+			logger.Info("🌟 New version available: %s. Run 'rag-code-mcp --update' or use the 'apply_update' tool to upgrade.", info.LatestVersion)
+		}
+	}()
+}

internal/skills/embedded/debugging-guide/SKILL.md

@@ -0,0 +1,29 @@
+---
+name: debugging-guide
+description: How to use ragcode tools for fast root-cause analysis and debugging
+---
+
+# 🐞 Skill: Debugging with Ragcode
+
+This skill defines a workflow for using ragcode tools to fix bugs efficiently.
+
+---
+
+## 🔍 The 3-Step Debug Workflow
+
+### Step 1: Locate the Symptom
+- Search for the exact error message using `hybrid_search`.
+- If no error message, search semantically for the failing feature using `search_code`.
+
+### Step 2: Contextualize the Flow
+- Find where the failing function is called using `find_implementations`.
+- Look at the surrounding logic with `get_code_context` (fetch at least 10 lines before and after).
+
+### Step 3: Analyze Data Models
+- Use `find_type_definition` to check if a struct field might be missing or wrongly typed.
+- Use `list_package_exports` to see if there are utility functions already solving the problem.
+
+---
+
+## 💡 Troubleshooting Pro-Tip:
+If you are lost, search for "logger" or "Error" in the package to see how other parts of the system handle failures.

internal/skills/embedded/go-best-practices/SKILL.md

@@ -0,0 +1,52 @@
+---
+name: go-best-practices
+description: Go development patterns, project structure, and idiomatic practices
+---
+
+# 🐹 Skill: Go Best Practices
+
+This skill guides the AI in writing high-quality, idiomatic Go code and understanding Go project structures.
+
+---
+
+## 🔗 External References (Source of Truth)
+- [Google Go Style Guide](https://google.github.io/styleguide/go/)
+- [Effective Go](https://go.dev/doc/effective_go)
+- [Uber Go Style Guide](https://github.com/uber-go/guide/blob/master/style.md)
+
+---
+
+## 🏗️ Project Structure
+Most Go projects in this ecosystem follow the Standard Go Project Layout:
+- `/cmd`: Main applications/binaries.
+- `/internal`: Private packages (not importable by other projects).
+- `/pkg`: Public packages (rarely used here, prefer `internal`).
+- `/api`: API definitions.
+
+## ✅ Implementation Patterns
+
+### 1. Error Handling
+- **Check immediately**: Never ignore errors.
+- **Wrap errors**: Use `fmt.Errorf("context: %w", err)` to provide trace details.
+- **Sentinel Errors**: Define custom errors in the package for specific conditions.
+
+### 2. Interfaces
+- **Small is better**: Prefer `io.Reader` over large monolithic interfaces.
+- **Consumer defines**: Define interfaces where they are USED, not where they are implemented.
+
+### 3. Concurrency
+- **Use Channels**: For communication/orchestration.
+- **Mutex**: For simple state protection.
+- **Context**: Always propagate `context.Context` for cancellation and timeouts.
+
+### 4. Testing
+- **Table-Driven Tests**: Use anonymous structs and `t.Run` for multiple test cases.
+- **Package name**: Use `package_test` for external testing (test only the public API).
+- **Mocking**: Use interfaces to mock dependencies. Avoid complex mocking frameworks if simple stubs work.
+- **Helpers**: Use `t.Helper()` for repetitive assertions.
+
+---
+
+## 🔧 Tools for Go Project Analysis:
+- `mcp_ragcode_find_type_definition`: Essential for understanding structs and interfaces.
+- `mcp_ragcode_list_package_exports`: Quick overview of a package's public API.