feat: LLM-enhanced skill learning and curation

- New internal/skills/llm_enhance.go: GenerateSkillWithLLM and
  EnhanceCurationWithLLM use SimpleCall for better skill generation
- SkillsConfig gains llm_learn and llm_curate (both default true)
- runLearnLoop uses LLM to generate richer skill names, descriptions,
  bodies, and trigger keywords before presenting to user
- Heuristic detection still runs first; LLM enriches the result
- Zero new dependencies

Author: jkyberneees

cmd/kode/main.go

@@ -818,7 +818,9 @@ func run(args []string) error {
 
 	// ── Learn loop: run self-improvement heuristics ──
 	if resolved.Skills.Learn && sm != nil {
-		runLearnLoop(allMessages, f.Task, sm)
+		// Create LLM client for skill enhancement
+		skillsLLM := llm.New(resolved.BaseURL, resolved.APIKey, resolved.Model, "", 30*time.Second)
+		runLearnLoop(allMessages, f.Task, sm, skillsLLM, resolved.Skills.LLMLearn)
 	}
 
 	// ── Session end — extract episode if enough turns ──
@@ -1033,7 +1035,8 @@ func getVersion() string {
 
 // runLearnLoop runs self-improvement heuristics on agent output and
 // offers to save detected patterns as skills.
-func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager) {
+func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager, llmClient skills.LLMClient, llmLearn bool) {
+	// Convert llm.Message to skills.llmMessage
 	// Convert llm.Message to skills.llmMessage
 	skillMsgs := make([]skills.LlmMessage, 0, len(messages))
 	for _, m := range messages {
@@ -1061,6 +1064,16 @@ func runLearnLoop(messages []llm.Message, task string, sm *skills.SkillManager)
 
 	fmt.Fprintf(os.Stderr, "\n🔍 Learning: detected %d skill pattern(s)\n", len(suggestions))
 	for _, s := range suggestions {
+		// Try LLM enhancement (generates better name, description, body, triggers)
+		if llmLearn && llmClient != nil {
+			calls := skills.ExtractToolCalls(skillMsgs)
+			if enhanced := skills.GenerateSkillWithLLM(llmClient, calls, userMessages, s.Heuristic); enhanced != nil {
+				enhanced.CommandLog = s.CommandLog // preserve original command log
+				enhanced.Heuristic = s.Heuristic    // preserve original heuristic tag
+				s = *enhanced
+			}
+		}
+
 		fmt.Fprint(os.Stderr, skills.FormatSuggestion(s))
 		fmt.Fprintf(os.Stderr, "   Save as skill? [Y/n]: ")
 

internal/skills/llm_enhance.go

@@ -0,0 +1,165 @@
+package skills
+
+import (
+	"context"
+	"fmt"
+	"strings"
+)
+
+// LLMClient abstracts the LLM calls needed for skill enhancement.
+type LLMClient interface {
+	SimpleCall(ctx context.Context, system, user string) (string, error)
+}
+
+// GenerateSkillWithLLM takes heuristic-detected tool calls and user messages
+// and uses the LLM to generate a rich, accurate skill with proper name,
+// description, trigger keywords, and structured body.
+// Returns nil if the LLM call fails or returns empty output.
+func GenerateSkillWithLLM(llm LLMClient, calls []ToolCall, userMessages []string, heuristic string) *SkillSuggestion {
+	if llm == nil {
+		return nil
+	}
+
+	// Build a compact summary of the session for the LLM
+	var b strings.Builder
+	b.WriteString("Analyze these tool calls from an AI coding agent session:\n\n")
+
+	// Add user messages (last 5)
+	msgCount := len(userMessages)
+	start := 0
+	if msgCount > 5 {
+		start = msgCount - 5
+	}
+	for i := start; i < msgCount; i++ {
+		msg := userMessages[i]
+		if len(msg) > 200 {
+			msg = msg[:197] + "..."
+		}
+		b.WriteString(fmt.Sprintf("User: %s\n", msg))
+	}
+
+	// Add tool calls (capped)
+	limit := 10
+	if len(calls) < limit {
+		limit = len(calls)
+	}
+	for i := 0; i < limit; i++ {
+		c := calls[i]
+		input := c.Input
+		if len(input) > 120 {
+			input = input[:117] + "..."
+		}
+		status := "✓"
+		if c.ExitCode != 0 {
+			status = "✗"
+		}
+		b.WriteString(fmt.Sprintf("[%s] %s: %s\n", status, c.Tool, input))
+	}
+	if len(calls) > limit {
+		b.WriteString(fmt.Sprintf("... and %d more calls\n", len(calls)-limit))
+	}
+
+	b.WriteString(fmt.Sprintf("\nHeuristic trigger: %s\n", heuristic))
+	b.WriteString("\nGenerate a skill file for this pattern. Output in this exact format:\n")
+	b.WriteString("NAME: <short kebab-case name>\n")
+	b.WriteString("DESCRIPTION: <one-line description, max 100 chars>\n")
+	b.WriteString("TOPICS: <3-5 comma-separated topic keywords>\n")
+	b.WriteString("ACTIONS: <2-3 comma-separated action keywords>\n")
+	b.WriteString("BODY:\n")
+	b.WriteString("<markdown body with ## Overview, ## Step-by-Step, ## Common Pitfalls, ## Verification sections>")
+
+	resp, err := llm.SimpleCall(context.Background(),
+		"You are a skill authoring system. Given a session trace, generate a structured skill file. Output the exact format requested. Be concise and specific.",
+		b.String(),
+	)
+	if err != nil || resp == "" {
+		return nil
+	}
+
+	return parseLLMSuggestion(resp)
+}
+
+// parseLLMSuggestion parses the LLM's structured output into a SkillSuggestion.
+func parseLLMSuggestion(text string) *SkillSuggestion {
+	s := &SkillSuggestion{
+		Heuristic: "llm-enhanced",
+	}
+
+	lines := strings.Split(text, "\n")
+	var inBody bool
+	var bodyLines []string
+
+	for _, line := range lines {
+		trimmed := strings.TrimSpace(line)
+
+		if strings.HasPrefix(trimmed, "NAME:") {
+			s.Name = strings.TrimSpace(strings.TrimPrefix(trimmed, "NAME:"))
+		} else if strings.HasPrefix(trimmed, "DESCRIPTION:") {
+			s.Description = strings.TrimSpace(strings.TrimPrefix(trimmed, "DESCRIPTION:"))
+		} else if strings.HasPrefix(trimmed, "TOPICS:") {
+			topics := strings.TrimSpace(strings.TrimPrefix(trimmed, "TOPICS:"))
+			if topics != "" {
+				for _, t := range strings.Split(topics, ",") {
+					t = strings.TrimSpace(t)
+					if t != "" {
+						s.CommandLog = append(s.CommandLog, "topic:"+t)
+					}
+				}
+			}
+		} else if strings.HasPrefix(trimmed, "ACTIONS:") {
+			actions := strings.TrimSpace(strings.TrimPrefix(trimmed, "ACTIONS:"))
+			if actions != "" {
+				for _, a := range strings.Split(actions, ",") {
+					a = strings.TrimSpace(a)
+					if a != "" {
+						s.CommandLog = append(s.CommandLog, "action:"+a)
+					}
+				}
+			}
+		} else if strings.HasPrefix(trimmed, "BODY:") {
+			inBody = true
+		} else if inBody {
+			bodyLines = append(bodyLines, line)
+		}
+	}
+
+	if s.Name == "" || len(bodyLines) == 0 {
+		return nil
+	}
+
+	s.Body = strings.Join(bodyLines, "\n")
+	s.Body = strings.TrimSpace(s.Body)
+	return s
+}
+
+// EnhanceCurationWithLLM uses the LLM to assess skill quality and suggest
+// improvements. Returns a message describing findings, or empty string.
+func EnhanceCurationWithLLM(llm LLMClient, report *CurationReport) string {
+	if llm == nil || report == nil || report.TotalSkills == 0 {
+		return ""
+	}
+
+	var b strings.Builder
+	b.WriteString("Review these skills and identify quality issues, overlap, or improvement suggestions:\n\n")
+	for _, s := range report.QualityIssues {
+		b.WriteString(fmt.Sprintf("- %s: %s\n", s.Name, strings.Join(s.Issues, "; ")))
+	}
+	for _, g := range report.OverlapGroups {
+		b.WriteString(fmt.Sprintf("- Overlap: %s share keywords: %s\n", strings.Join(g.Skills, ", "), strings.Join(g.Shared, ", ")))
+	}
+	b.WriteString("\nSuggest specific improvements or merge recommendations. Be concise.")
+
+	resp, err := llm.SimpleCall(context.Background(),
+		"You are a skill curation assistant. Review the quality report and suggest actionable improvements. Keep it brief.",
+		b.String(),
+	)
+	if err != nil {
+		return ""
+	}
+
+	resp = strings.TrimSpace(resp)
+	if resp == "" {
+		return ""
+	}
+	return resp
+}

internal/skills/types.go

@@ -73,6 +73,8 @@ type SkillsConfig struct {
 	Dirs         []string       `json:"dirs,omitempty"`
 	Import       ImportConfig   `json:"import"`
 	Curation     CurationConfig `json:"curation"`
+	LLMLearn     bool           `json:"llm_learn"`
+	LLMCurate    bool           `json:"llm_curate"`
 }
 
 // ImportConfig controls the URI import flow.
@@ -104,6 +106,8 @@ func DefaultSkillsConfig() SkillsConfig {
 			StalenessDays: 90,
 			AutoPrune:     false,
 		},
+		LLMLearn:  true,
+		LLMCurate: true,
 	}
 }