Auto-install support for cursor

* Uses a hook that runs on every prompt (run install once per convo)
* Added better logging, inc context like which client and path

Author: mrdon

cmd/skills/main.go

@@ -23,9 +23,28 @@ func init() {
 }
 
 func main() {
-	// Log command invocation
+	// Log command invocation with context
 	log := logger.Get()
-	log.Info("command invoked", "version", buildinfo.Version, "command", strings.Join(os.Args[1:], " "))
+	cwd, _ := os.Getwd()
+
+	// Extract --client flag if present (for hook mode context)
+	client := ""
+	for i, arg := range os.Args {
+		if strings.HasPrefix(arg, "--client=") {
+			client = strings.TrimPrefix(arg, "--client=")
+			break
+		}
+		if arg == "--client" && i+1 < len(os.Args) {
+			client = os.Args[i+1]
+			break
+		}
+	}
+
+	logArgs := []any{"version", buildinfo.Version, "command", strings.Join(os.Args[1:], " "), "cwd", cwd}
+	if client != "" {
+		logArgs = append(logArgs, "client", client)
+	}
+	log.Info("command invoked", logArgs...)
 
 	// Check for updates in the background (non-blocking, once per day)
 	// Skip if user is explicitly running the update command

internal/cache/sessions.go

@@ -0,0 +1,152 @@
+package cache
+
+import (
+	"bufio"
+	"fmt"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/sleuth-io/skills/internal/utils"
+)
+
+// SessionCache provides fast conversation/session ID tracking for clients
+// that fire hooks on every prompt rather than once per session.
+//
+// File format: Line-based, space-separated `session_id timestamp`
+// Example:
+//
+//	668320d2-2fd8-4888-b33c-2a466fec86e7 2025-12-12T10:30:00Z
+//	490b90b7-a2ce-4c2c-bb76-cb77b125df2f 2025-12-11T15:45:00Z
+type SessionCache struct {
+	filePath string
+}
+
+// NewSessionCache creates a session cache for the given client ID
+func NewSessionCache(clientID string) (*SessionCache, error) {
+	cacheDir, err := GetCacheDir()
+	if err != nil {
+		return nil, fmt.Errorf("failed to get cache dir: %w", err)
+	}
+
+	filePath := filepath.Join(cacheDir, clientID+"-sessions")
+	return &SessionCache{filePath: filePath}, nil
+}
+
+// HasSession checks if a session ID has been seen before.
+// This is optimized for fast checks (~1ms) by scanning the file line by line.
+func (s *SessionCache) HasSession(sessionID string) bool {
+	if sessionID == "" {
+		return false
+	}
+
+	file, err := os.Open(s.filePath)
+	if err != nil {
+		// File doesn't exist = session not seen
+		return false
+	}
+	defer file.Close()
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.SplitN(line, " ", 2)
+		if len(parts) >= 1 && parts[0] == sessionID {
+			return true
+		}
+	}
+
+	return false
+}
+
+// RecordSession records a session ID with the current timestamp.
+// Should be called optimistically before installation starts.
+func (s *SessionCache) RecordSession(sessionID string) error {
+	if sessionID == "" {
+		return nil
+	}
+
+	// Ensure directory exists
+	if err := utils.EnsureDir(filepath.Dir(s.filePath)); err != nil {
+		return fmt.Errorf("failed to create cache directory: %w", err)
+	}
+
+	// Open file for appending (create if not exists)
+	file, err := os.OpenFile(s.filePath, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
+	if err != nil {
+		return fmt.Errorf("failed to open session file: %w", err)
+	}
+	defer file.Close()
+
+	// Write new entry
+	entry := fmt.Sprintf("%s %s\n", sessionID, time.Now().UTC().Format(time.RFC3339))
+	if _, err := file.WriteString(entry); err != nil {
+		return fmt.Errorf("failed to write session entry: %w", err)
+	}
+
+	return nil
+}
+
+// CullOldEntries removes entries older than the specified max age.
+// This keeps the session file from growing indefinitely.
+func (s *SessionCache) CullOldEntries(maxAge time.Duration) error {
+	file, err := os.Open(s.filePath)
+	if err != nil {
+		if os.IsNotExist(err) {
+			return nil // Nothing to cull
+		}
+		return fmt.Errorf("failed to open session file: %w", err)
+	}
+	defer file.Close()
+
+	cutoff := time.Now().Add(-maxAge)
+	var keepLines []string
+
+	scanner := bufio.NewScanner(file)
+	for scanner.Scan() {
+		line := scanner.Text()
+		parts := strings.SplitN(line, " ", 2)
+		if len(parts) < 2 {
+			continue // Malformed line, skip
+		}
+
+		timestamp, err := time.Parse(time.RFC3339, parts[1])
+		if err != nil {
+			continue // Can't parse timestamp, skip
+		}
+
+		if timestamp.After(cutoff) {
+			keepLines = append(keepLines, line)
+		}
+	}
+
+	if err := scanner.Err(); err != nil {
+		return fmt.Errorf("failed to scan session file: %w", err)
+	}
+
+	// Write filtered content back
+	content := strings.Join(keepLines, "\n")
+	if len(keepLines) > 0 {
+		content += "\n"
+	}
+
+	if err := os.WriteFile(s.filePath, []byte(content), 0644); err != nil {
+		return fmt.Errorf("failed to write filtered sessions: %w", err)
+	}
+
+	return nil
+}
+
+// Clear removes all session entries.
+func (s *SessionCache) Clear() error {
+	if err := os.Remove(s.filePath); err != nil && !os.IsNotExist(err) {
+		return fmt.Errorf("failed to remove session file: %w", err)
+	}
+	return nil
+}
+
+// FilePath returns the path to the session cache file (for testing/debugging).
+func (s *SessionCache) FilePath() string {
+	return s.filePath
+}

internal/cache/sessions_test.go

@@ -0,0 +1,207 @@
+package cache
+
+import (
+	"os"
+	"path/filepath"
+	"testing"
+	"time"
+)
+
+func TestSessionCache_HasSession(t *testing.T) {
+	// Create temp cache dir
+	tmpDir := t.TempDir()
+	t.Setenv("SKILLS_CACHE_DIR", tmpDir)
+
+	cache, err := NewSessionCache("test-client")
+	if err != nil {
+		t.Fatalf("Failed to create session cache: %v", err)
+	}
+
+	// Test empty cache
+	if cache.HasSession("session-1") {
+		t.Error("Expected HasSession to return false for empty cache")
+	}
+
+	// Record a session
+	if err := cache.RecordSession("session-1"); err != nil {
+		t.Fatalf("Failed to record session: %v", err)
+	}
+
+	// Test that session is now found
+	if !cache.HasSession("session-1") {
+		t.Error("Expected HasSession to return true after recording")
+	}
+
+	// Test that other sessions are not found
+	if cache.HasSession("session-2") {
+		t.Error("Expected HasSession to return false for unrecorded session")
+	}
+}
+
+func TestSessionCache_RecordSession(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("SKILLS_CACHE_DIR", tmpDir)
+
+	cache, err := NewSessionCache("test-client")
+	if err != nil {
+		t.Fatalf("Failed to create session cache: %v", err)
+	}
+
+	// Record multiple sessions
+	sessions := []string{"session-1", "session-2", "session-3"}
+	for _, s := range sessions {
+		if err := cache.RecordSession(s); err != nil {
+			t.Fatalf("Failed to record session %s: %v", s, err)
+		}
+	}
+
+	// Verify all are recorded
+	for _, s := range sessions {
+		if !cache.HasSession(s) {
+			t.Errorf("Expected session %s to be recorded", s)
+		}
+	}
+
+	// Verify file format
+	data, err := os.ReadFile(cache.FilePath())
+	if err != nil {
+		t.Fatalf("Failed to read session file: %v", err)
+	}
+
+	// File should have 3 lines
+	lines := 0
+	for _, b := range data {
+		if b == '\n' {
+			lines++
+		}
+	}
+	if lines != 3 {
+		t.Errorf("Expected 3 lines in session file, got %d", lines)
+	}
+}
+
+func TestSessionCache_EmptySessionID(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("SKILLS_CACHE_DIR", tmpDir)
+
+	cache, err := NewSessionCache("test-client")
+	if err != nil {
+		t.Fatalf("Failed to create session cache: %v", err)
+	}
+
+	// Empty session ID should not be recorded
+	if err := cache.RecordSession(""); err != nil {
+		t.Fatalf("RecordSession with empty ID should not error: %v", err)
+	}
+
+	// File should not exist
+	if _, err := os.Stat(cache.FilePath()); !os.IsNotExist(err) {
+		t.Error("Expected no file to be created for empty session ID")
+	}
+
+	// HasSession should return false for empty
+	if cache.HasSession("") {
+		t.Error("Expected HasSession to return false for empty session ID")
+	}
+}
+
+func TestSessionCache_CullOldEntries(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("SKILLS_CACHE_DIR", tmpDir)
+
+	cache, err := NewSessionCache("test-client")
+	if err != nil {
+		t.Fatalf("Failed to create session cache: %v", err)
+	}
+
+	// Write some entries with old timestamps manually
+	oldTime := time.Now().Add(-10 * 24 * time.Hour).UTC().Format(time.RFC3339)
+	newTime := time.Now().UTC().Format(time.RFC3339)
+
+	// Ensure directory exists
+	if err := os.MkdirAll(filepath.Dir(cache.FilePath()), 0755); err != nil {
+		t.Fatalf("Failed to create directory: %v", err)
+	}
+
+	content := "old-session " + oldTime + "\n" +
+		"new-session " + newTime + "\n"
+
+	if err := os.WriteFile(cache.FilePath(), []byte(content), 0644); err != nil {
+		t.Fatalf("Failed to write test data: %v", err)
+	}
+
+	// Cull entries older than 5 days
+	if err := cache.CullOldEntries(5 * 24 * time.Hour); err != nil {
+		t.Fatalf("Failed to cull old entries: %v", err)
+	}
+
+	// Old session should be gone
+	if cache.HasSession("old-session") {
+		t.Error("Expected old session to be culled")
+	}
+
+	// New session should still exist
+	if !cache.HasSession("new-session") {
+		t.Error("Expected new session to still exist after culling")
+	}
+}
+
+func TestSessionCache_Clear(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("SKILLS_CACHE_DIR", tmpDir)
+
+	cache, err := NewSessionCache("test-client")
+	if err != nil {
+		t.Fatalf("Failed to create session cache: %v", err)
+	}
+
+	// Record a session
+	if err := cache.RecordSession("session-1"); err != nil {
+		t.Fatalf("Failed to record session: %v", err)
+	}
+
+	// Clear cache
+	if err := cache.Clear(); err != nil {
+		t.Fatalf("Failed to clear cache: %v", err)
+	}
+
+	// Session should no longer exist
+	if cache.HasSession("session-1") {
+		t.Error("Expected session to be cleared")
+	}
+}
+
+func TestSessionCache_MultipleClients(t *testing.T) {
+	tmpDir := t.TempDir()
+	t.Setenv("SKILLS_CACHE_DIR", tmpDir)
+
+	cache1, err := NewSessionCache("client-1")
+	if err != nil {
+		t.Fatalf("Failed to create cache 1: %v", err)
+	}
+
+	cache2, err := NewSessionCache("client-2")
+	if err != nil {
+		t.Fatalf("Failed to create cache 2: %v", err)
+	}
+
+	// Record to client 1
+	if err := cache1.RecordSession("session-a"); err != nil {
+		t.Fatalf("Failed to record to cache 1: %v", err)
+	}
+
+	// Client 1 should have it
+	if !cache1.HasSession("session-a") {
+		t.Error("Client 1 should have session-a")
+	}
+
+	// Client 2 should NOT have it
+	if cache2.HasSession("session-a") {
+		t.Error("Client 2 should not have session-a")
+	}
+
+	// Verify different files
+	if cache1.FilePath() == cache2.FilePath() {
+		t.Error("Different clients should have different cache files")
+	}
+}