add skills

showkeyjar · showkeyjar · commit 9be1fa24750c · 2026-02-15T14:25:35.000+08:00
diff --git a/App.config b/App.config
@@ -42,6 +42,7 @@
 		<add key="ProactiveAssistEnabled" value="true" />
 		<add key="BehaviorLearningEnabled" value="true" />
 		<add key="StuckNudgesEnabled" value="true" />
+		<add key="LlmSkillAssistEnabled" value="true" />
 		<!-- 安静时段（24小时制，跨天区间） -->
 		<add key="QuietHoursStart" value="22" />
 		<add key="QuietHoursEnd" value="8" />
diff --git a/LlmService.cs b/LlmService.cs
@@ -64,6 +64,24 @@ public class LlmLearningMilestone
         public bool IsCompleted { get; set; }
     }
 
+    public class LlmSkillRecommendation
+    {
+        [JsonPropertyName("skill_id")]
+        public string SkillId { get; set; }
+
+        [JsonPropertyName("title")]
+        public string Title { get; set; }
+
+        [JsonPropertyName("why")]
+        public string Why { get; set; }
+
+        [JsonPropertyName("next_step")]
+        public string NextStep { get; set; }
+
+        [JsonPropertyName("confidence")]
+        public double Confidence { get; set; }
+    }
+
     public class LlmService : ILlmService
     {
         private IOpenAIService _openAiService;
@@ -136,6 +154,18 @@ public class LlmService : ILlmService
             "\n\nUser behavior context (local profile, use as soft guidance only):\n{userContext}\n" +
             "Adapt tone and suggestions to reduce interruption. Keep one clear next step.";
 
+        private const string SkillRecommendationSystemPrompt =
+            "You are a task execution copilot. Based on the task and context, recommend 1-3 skills that best help the user move forward now. " +
+            "Allowed skill_id values ONLY: decompose, focus_sprint, priority_rebalance, risk_check, delegate_prepare, clarify_goal. " +
+            "Return ONLY a valid JSON array. Each item must contain: " +
+            "\"skill_id\", \"title\", \"why\", \"next_step\", \"confidence\" (0 to 1). " +
+            "Keep title/why/next_step concise and actionable.\n" +
+            "Task: {taskDescription}\n" +
+            "Importance: {importance}\n" +
+            "Urgency: {urgency}\n" +
+            "InactiveDuration: {inactiveDuration}\n" +
+            "UserContext: {userContext}";
+
         private const string ConversationTaskExtractPrompt =
             "You are an assistant helping a user capture personal action items from a multi-speaker conversation. " +
             "Extract ONLY tasks that the user should do. " +
@@ -533,6 +563,157 @@ internal static (string reminder, List<string> suggestions) ParseReminderRespons
             return ParseReminderResponse(llmResponse);
         }
 
+        public async Task<List<LlmSkillRecommendation>> RecommendTaskSkillsAsync(
+            string taskDescription,
+            string importance,
+            string urgency,
+            TimeSpan inactiveDuration,
+            string userContext,
+            int maxSkills = 3)
+        {
+            if (string.IsNullOrWhiteSpace(taskDescription))
+            {
+                return new List<LlmSkillRecommendation>();
+            }
+
+            string context = string.IsNullOrWhiteSpace(userContext) ? "N/A" : userContext;
+            string prompt = SkillRecommendationSystemPrompt
+                .Replace("{taskDescription}", taskDescription)
+                .Replace("{importance}", string.IsNullOrWhiteSpace(importance) ? "Unknown" : importance)
+                .Replace("{urgency}", string.IsNullOrWhiteSpace(urgency) ? "Unknown" : urgency)
+                .Replace("{inactiveDuration}", FormatTimeSpan(inactiveDuration))
+                .Replace("{userContext}", context);
+
+            try
+            {
+                string llmResponse = await GetCompletionAsync(prompt);
+                if (IsErrorResponse(llmResponse))
+                {
+                    Console.WriteLine($"LLM skill recommendation failed for '{taskDescription}'. Fallback to rules. Response: {llmResponse}");
+                    return GetRuleBasedSkillRecommendations(taskDescription, importance, urgency, inactiveDuration, maxSkills);
+                }
+
+                var options = new JsonSerializerOptions { PropertyNameCaseInsensitive = true };
+                var parsed = JsonSerializer.Deserialize<List<LlmSkillRecommendation>>(llmResponse, options) ?? new List<LlmSkillRecommendation>();
+                var filtered = parsed
+                    .Where(s => s != null && IsAllowedSkillId(s.SkillId))
+                    .Select(s => NormalizeSkillRecommendation(s))
+                    .Take(Math.Max(1, maxSkills))
+                    .ToList();
+
+                if (filtered.Count > 0)
+                {
+                    return filtered;
+                }
+            }
+            catch (Exception ex)
+            {
+                Console.WriteLine($"Error parsing LLM skill recommendation, fallback to rules. {ex.Message}");
+            }
+
+            return GetRuleBasedSkillRecommendations(taskDescription, importance, urgency, inactiveDuration, maxSkills);
+        }
+
+        private static bool IsAllowedSkillId(string skillId)
+        {
+            if (string.IsNullOrWhiteSpace(skillId)) return false;
+            string id = skillId.Trim().ToLowerInvariant();
+            return id == "decompose"
+                || id == "focus_sprint"
+                || id == "priority_rebalance"
+                || id == "risk_check"
+                || id == "delegate_prepare"
+                || id == "clarify_goal";
+        }
+
+        private static LlmSkillRecommendation NormalizeSkillRecommendation(LlmSkillRecommendation s)
+        {
+            return new LlmSkillRecommendation
+            {
+                SkillId = (s.SkillId ?? "clarify_goal").Trim().ToLowerInvariant(),
+                Title = string.IsNullOrWhiteSpace(s.Title) ? "执行技能建议" : s.Title.Trim(),
+                Why = string.IsNullOrWhiteSpace(s.Why) ? "帮助你更快推进任务。" : s.Why.Trim(),
+                NextStep = string.IsNullOrWhiteSpace(s.NextStep) ? "先执行一个可在10分钟内完成的动作。" : s.NextStep.Trim(),
+                Confidence = Math.Max(0, Math.Min(1, s.Confidence))
+            };
+        }
+
+        private static List<LlmSkillRecommendation> GetRuleBasedSkillRecommendations(
+            string taskDescription,
+            string importance,
+            string urgency,
+            TimeSpan inactiveDuration,
+            int maxSkills)
+        {
+            var result = new List<LlmSkillRecommendation>();
+            bool highImportance = string.Equals(importance, "High", StringComparison.OrdinalIgnoreCase);
+            bool highUrgency = string.Equals(urgency, "High", StringComparison.OrdinalIgnoreCase);
+            bool veryStale = inactiveDuration >= TimeSpan.FromDays(3);
+            bool longText = !string.IsNullOrWhiteSpace(taskDescription) && taskDescription.Length > 40;
+
+            if (longText || veryStale)
+            {
+                result.Add(new LlmSkillRecommendation
+                {
+                    SkillId = "decompose",
+                    Title = "任务分解",
+                    Why = "当前任务复杂或停滞，先拆小更容易推进。",
+                    NextStep = "拆成2-3个30分钟内可完成的子任务。",
+                    Confidence = 0.78
+                });
+            }
+
+            if (highImportance && highUrgency)
+            {
+                result.Add(new LlmSkillRecommendation
+                {
+                    SkillId = "focus_sprint",
+                    Title = "专注冲刺",
+                    Why = "高价值高时效任务适合短时冲刺推进。",
+                    NextStep = "立刻开始一个25分钟专注块，仅做此任务。",
+                    Confidence = 0.82
+                });
+            }
+            else if (!highImportance && highUrgency)
+            {
+                result.Add(new LlmSkillRecommendation
+                {
+                    SkillId = "delegate_prepare",
+                    Title = "委托准备",
+                    Why = "紧急但低重要任务可优先考虑委托。",
+                    NextStep = "写一条委托说明：目标、截止时间、验收标准。",
+                    Confidence = 0.72
+                });
+            }
+            else
+            {
+                result.Add(new LlmSkillRecommendation
+                {
+                    SkillId = "priority_rebalance",
+                    Title = "优先级重排",
+                    Why = "通过重排顺序减少低价值任务挤占时间。",
+                    NextStep = "确认该任务本周优先级，不匹配则延期。",
+                    Confidence = 0.68
+                });
+            }
+
+            result.Add(new LlmSkillRecommendation
+            {
+                SkillId = "risk_check",
+                Title = "风险检查",
+                Why = "提前识别阻塞点能降低返工成本。",
+                NextStep = "写下1个可能阻塞因素和1个应对动作。",
+                Confidence = 0.64
+            });
+
+            return result
+                .Where(s => IsAllowedSkillId(s.SkillId))
+                .GroupBy(s => s.SkillId)
+                .Select(g => g.First())
+                .Take(Math.Max(1, maxSkills))
+                .ToList();
+        }
+
         internal static (DecompositionStatus status, List<string> subtasks) ParseDecompositionResponse(string llmResponse)
         {
             Console.WriteLine($"Parsing LLM decomposition response: \"{llmResponse}\"");
diff --git a/MainWindow.xaml.cs b/MainWindow.xaml.cs
@@ -331,13 +331,15 @@ public partial class MainWindow : Window
         private bool _proactiveAssistEnabled = true;
         private bool _behaviorLearningEnabled = true;
         private bool _stuckNudgesEnabled = true;
+        private bool _llmSkillAssistEnabled = true;
         private int _quietHoursStart = 22;
         private int _quietHoursEnd = 8;
         private const int DailyReminderLimit = 3;
         private static readonly TimeSpan ReminderCooldown = TimeSpan.FromMinutes(45);
         private int _remindersShownToday = 0;
         private DateTime _reminderCounterDate = DateTime.Today;
         private readonly Dictionary<string, TaskInteractionState> _taskInteractionStates = new Dictionary<string, TaskInteractionState>();
+        private readonly Dictionary<string, List<string>> _pendingReminderSkillIds = new Dictionary<string, List<string>>();
         private const int DefaultDailyStuckNudgeLimit = 2;
         private static readonly TimeSpan StuckNudgeCooldown = TimeSpan.FromHours(2);
         private static readonly TimeSpan DefaultStuckNoProgressThreshold = TimeSpan.FromMinutes(90);
@@ -656,6 +658,7 @@ private void LoadProactiveConfig()
             _proactiveAssistEnabled = GetAppSettingBool("ProactiveAssistEnabled", true);
             _behaviorLearningEnabled = GetAppSettingBool("BehaviorLearningEnabled", true);
             _stuckNudgesEnabled = GetAppSettingBool("StuckNudgesEnabled", true);
+            _llmSkillAssistEnabled = GetAppSettingBool("LlmSkillAssistEnabled", true);
             _quietHoursStart = GetAppSettingInt("QuietHoursStart", 22, 0, 23);
             _quietHoursEnd = GetAppSettingInt("QuietHoursEnd", 8, 0, 23);
         }
@@ -860,9 +863,31 @@ private async void ShowFriendlyReminder(ItemGrid task, string message)
                 TimeSpan inactiveDuration = DateTime.Now - task.LastProgressDate;
                 string reminderContext = ShouldRecordBehavior() ? _userProfileManager.BuildReminderContext(task, inactiveDuration) : null;
                 var (reminder, suggestions) = await _llmService.GenerateTaskReminderAsync(task.Task, taskAge, reminderContext);
+                var mergedSuggestions = new List<string>(suggestions ?? new List<string>());
+
+                if (_llmSkillAssistEnabled)
+                {
+                    try
+                    {
+                        var skillRecs = await _llmService.RecommendTaskSkillsAsync(
+                            task.Task,
+                            task.Importance,
+                            task.Urgency,
+                            inactiveDuration,
+                            reminderContext,
+                            2);
+                        var shownSkillIds = new List<string>();
+                        mergedSuggestions = MergeSkillSuggestions(mergedSuggestions, skillRecs, shownSkillIds);
+                        RememberPendingReminderSkills(task, shownSkillIds);
+                    }
+                    catch (Exception skillEx)
+                    {
+                        Console.WriteLine($"Skill recommendation failed: {skillEx.Message}");
+                    }
+                }
                 
                 // Show modern reminder window
-                var reminderWindow = new TaskReminderWindow(task, reminder ?? message, suggestions)
+                var reminderWindow = new TaskReminderWindow(task, reminder ?? message, mergedSuggestions)
                 {
                     Owner = this
                 };
@@ -872,6 +897,10 @@ private async void ShowFriendlyReminder(ItemGrid task, string message)
                 {
                     await HandleTaskReminderResult(task, reminderWindow.Result);
                 }
+                else
+                {
+                    await HandleTaskReminderResult(task, TaskReminderResult.Dismissed);
+                }
             }
             catch (Exception ex)
             {
@@ -945,6 +974,7 @@ private async Task HandleTaskReminderResult(ItemGrid task, TaskReminderResult re
                     break;
             }
 
+            ResolveReminderSkillFeedback(task, result);
             RecordReminderResultProfile(task, result);
             
             // Save changes to CSV
@@ -1140,6 +1170,91 @@ private void UpdateAdaptiveNudgeParameters(bool force = false)
             }
         }
 
+        private List<string> MergeSkillSuggestions(List<string> baseSuggestions, List<LlmSkillRecommendation> skills)
+        {
+            return MergeSkillSuggestions(baseSuggestions, skills, null);
+        }
+
+        private List<string> MergeSkillSuggestions(List<string> baseSuggestions, List<LlmSkillRecommendation> skills, List<string> shownSkillIds)
+        {
+            var result = baseSuggestions ?? new List<string>();
+            if (skills == null || skills.Count == 0)
+            {
+                return result;
+            }
+
+            foreach (var skill in skills)
+            {
+                if (skill == null) continue;
+                string text = $"Skill[{skill.Title}]: {skill.NextStep}";
+                if (!result.Any(s => string.Equals(s, text, StringComparison.OrdinalIgnoreCase)))
+                {
+                    result.Insert(0, text);
+                }
+                if (shownSkillIds != null && !string.IsNullOrWhiteSpace(skill.SkillId))
+                {
+                    string id = skill.SkillId.Trim().ToLowerInvariant();
+                    if (!shownSkillIds.Contains(id))
+                    {
+                        shownSkillIds.Add(id);
+                        RecordSuggestionShownProfile(id);
+                    }
+                }
+            }
+            return result.Take(5).ToList();
+        }
+
+        private void RememberPendingReminderSkills(ItemGrid task, List<string> shownSkillIds)
+        {
+            if (task == null) return;
+            string key = GetTaskTrackingKey(task);
+            if (shownSkillIds == null || shownSkillIds.Count == 0)
+            {
+                _pendingReminderSkillIds.Remove(key);
+                return;
+            }
+            _pendingReminderSkillIds[key] = shownSkillIds;
+        }
+
+        private void ResolveReminderSkillFeedback(ItemGrid task, TaskReminderResult result)
+        {
+            if (task == null) return;
+            string key = GetTaskTrackingKey(task);
+            if (!_pendingReminderSkillIds.TryGetValue(key, out var ids) || ids == null || ids.Count == 0)
+            {
+                return;
+            }
+
+            string feedbackType = null;
+            string targetSkillId = ids[0];
+
+            switch (result)
+            {
+                case TaskReminderResult.Decompose:
+                    feedbackType = "accepted";
+                    targetSkillId = ids.FirstOrDefault(id => string.Equals(id, "decompose", StringComparison.OrdinalIgnoreCase)) ?? targetSkillId;
+                    break;
+                case TaskReminderResult.Completed:
+                case TaskReminderResult.Updated:
+                    feedbackType = "accepted";
+                    break;
+                case TaskReminderResult.Snoozed:
+                    feedbackType = "deferred";
+                    break;
+                case TaskReminderResult.Dismissed:
+                default:
+                    feedbackType = "rejected";
+                    break;
+            }
+
+            if (!string.IsNullOrWhiteSpace(feedbackType) && !string.IsNullOrWhiteSpace(targetSkillId))
+            {
+                RecordSuggestionFeedbackProfile(targetSkillId, feedbackType);
+            }
+
+            _pendingReminderSkillIds.Remove(key);
+        }
+
         private static TimeSpan ClampThreshold(TimeSpan threshold)
         {
             if (threshold < MinStuckNoProgressThreshold)
diff --git a/ReminderSettingsWindow.xaml b/ReminderSettingsWindow.xaml
@@ -197,6 +197,9 @@
                                   Margin="0,4"/>
                         <CheckBox Content="启用卡点轻提醒"
                                   IsChecked="{Binding StuckNudgesEnabled}"
+                                  Margin="0,4"/>
+                        <CheckBox Content="启用LLM技能建议"
+                                  IsChecked="{Binding LlmSkillAssistEnabled}"
                                   Margin="0,4,0,10"/>
 
                         <Grid>
diff --git a/ReminderSettingsWindow.xaml.cs b/ReminderSettingsWindow.xaml.cs
diff --git a/readme.md b/readme.md
