flowmind 1.0.0

package/skills/learning-engine/SKILL.md

@@ -0,0 +1,352 @@
+---
+name: learning-engine
+description: Core learning engine that powers FlowMind's ability to learn from user corrections and preferences. This is the heart of FlowMind's intelligence.
+metadata:
+  version: "1.0.0"
+  author: flowmind
+  category: core
+  priority: highest
+---
+
+# FlowMind Learning Engine
+
+The core intelligence that makes FlowMind learn and adapt to your workflow.
+
+## How Learning Works
+
+### The Learning Loop
+
+```mermaid
+graph TD
+    A[User Request] --> B[FlowMind Executes]
+    B --> C{User Feedback?}
+    C -->|Correction| D[Capture Learning]
+    C -->|Confirmation| E[Reinforce Learning]
+    C -->|No Feedback| F[Continue]
+    D --> G[Store Learning]
+    E --> G
+    G --> H[Apply Next Time]
+    H --> A
+```
+
+### Learning Types
+
+| Type | Trigger | Example |
+|------|---------|---------|
+| **Correction** | User corrects output | "不对，用表格格式" |
+| **Refinement** | User improves process | "先查错误再查链路" |
+| **Preference** | User specifies style | "用中文回复" |
+| **Scene Mapping** | User defines workflow | "这类需求走xxx流程" |
+
+## Learning Storage
+
+### Directory Structure
+
+```
+~/.flowmind/learning/
+├── records/                    # Learning records by skill
+│   ├── log-audit/
+│   │   ├── 2026-06-22-001.json
+│   │   └── 2026-06-22-002.json
+│   ├── code-review/
+│   └── _global/
+├── scenes.json                # Scene-skill mappings
+├── skill-bindings.json        # Skill learning bindings
+└── stats.json                 # Learning statistics
+```
+
+### Learning Record Format
+
+```json
+{
+  "id": "learn-20260622-001",
+  "timestamp": "2026-06-22T10:30:00Z",
+  "skill": "log-audit",
+  "type": "output_format",
+  "severity": "major",
+  "context": {
+    "userRequest": "查询 traceId 日志",
+    "executionContext": "Log audit skill execution"
+  },
+  "correction": {
+    "original": "Tree format output",
+    "corrected": "Sequential list format",
+    "reason": "User prefers chronological view"
+  },
+  "application": {
+    "condition": "When outputting trace results",
+    "action": "Use sequential list format",
+    "priority": "high"
+  },
+  "verification": {
+    "verified": true,
+    "verifiedAt": "2026-06-22T10:31:00Z"
+  },
+  "stats": {
+    "appliedCount": 5,
+    "successCount": 5
+  }
+}
+```
+
+### Scene Mapping Format
+
+```json
+{
+  "version": "1.0",
+  "mappings": [
+    {
+      "id": "scene-001",
+      "name": "Trace Log Query",
+      "keywords": ["traceId", "日志", "链路", "trace"],
+      "patterns": [
+        "查询.*traceId.*日志",
+        "查看.*链路"
+      ],
+      "workflow": {
+        "skills": ["log-audit"],
+        "params": {
+          "format": "sequential-list",
+          "includeRequest": true,
+          "includeResponse": true
+        }
+      },
+      "preferences": {
+        "outputFormat": "sequential-list",
+        "language": "zh-CN"
+      },
+      "stats": {
+        "useCount": 10,
+        "lastUsed": "2026-06-22T15:00:00Z",
+        "successRate": 1.0
+      }
+    }
+  ]
+}
+```
+
+## Learning Process
+
+### Step 1: Detect Learning Opportunity
+
+```javascript
+function detectLearning(input, context) {
+  // Check for correction patterns
+  if (isCorrectionPattern(input)) {
+    return { type: 'correction', ... };
+  }
+
+  // Check for scene mapping patterns
+  if (isSceneMappingPattern(input)) {
+    return { type: 'scene_mapping', ... };
+  }
+
+  // Check for preference patterns
+  if (isPreferencePattern(input)) {
+    return { type: 'preference', ... };
+  }
+
+  return null;
+}
+```
+
+### Step 2: Capture Context
+
+```javascript
+function captureContext(userRequest, executionResult) {
+  return {
+    userRequest: userRequest,
+    executionContext: executionResult.context,
+    timestamp: new Date().toISOString(),
+    skill: executionResult.skill
+  };
+}
+```
+
+### Step 3: Create Learning Record
+
+```javascript
+function createLearningRecord(context, correction) {
+  const record = {
+    id: generateId(),
+    timestamp: new Date().toISOString(),
+    skill: context.skill,
+    type: correction.type,
+    context: context,
+    correction: correction,
+    application: generateApplicationRule(correction)
+  };
+
+  return saveLearningRecord(record);
+}
+```
+
+### Step 4: Update Bindings
+
+```javascript
+function updateSkillBindings(skill, record) {
+  const bindings = loadSkillBindings();
+
+  if (!bindings[skill]) {
+    bindings[skill] = { records: [], rules: [] };
+  }
+
+  bindings[skill].records.push(record.id);
+  bindings[skill].rules.push(record.application);
+
+  saveSkillBindings(bindings);
+}
+```
+
+## Knowledge Application
+
+### Pre-Execution Check
+
+Before executing any task:
+
+```javascript
+async function executeWithLearning(request, context) {
+  // 1. Check scene mappings
+  const sceneMatch = matchScene(request);
+  if (sceneMatch && sceneMatch.confidence >= 0.7) {
+    return applySceneWorkflow(sceneMatch, request);
+  }
+
+  // 2. Check skill learning bindings
+  const skill = selectSkill(request);
+  const learnings = getSkillLearnings(skill);
+
+  // 3. Apply learnings
+  let result = await executeSkill(skill, request, context);
+  result = applyLearnings(result, learnings);
+
+  return result;
+}
+```
+
+### Matching Algorithm
+
+```javascript
+function matchScene(request) {
+  const scenes = loadScenes();
+  let bestMatch = null;
+  let bestScore = 0;
+
+  for (const scene of scenes) {
+    const score = calculateMatchScore(request, scene);
+    if (score > bestScore) {
+      bestScore = score;
+      bestMatch = scene;
+    }
+  }
+
+  return bestScore >= 0.7 ? bestMatch : null;
+}
+
+function calculateMatchScore(request, scene) {
+  const keywordScore = matchKeywords(request, scene.keywords) * 0.4;
+  const patternScore = matchPatterns(request, scene.patterns) * 0.3;
+  const historyScore = (scene.stats.useCount / 100) * 0.2;
+  const confidenceScore = scene.stats.successRate * 0.1;
+
+  return keywordScore + patternScore + historyScore + confidenceScore;
+}
+```
+
+## User Confirmation
+
+When learning is captured:
+
+```
+┌─────────────────────────────────────────────────────┐
+│ 🧠 Learning Captured                                │
+├─────────────────────────────────────────────────────┤
+│ ID: learn-20260622-001                              │
+│ Skill: log-audit                                    │
+│ Type: output_format                                 │
+├─────────────────────────────────────────────────────┤
+│ Your preference has been recorded.                  │
+│ FlowMind will apply this automatically next time.   │
+└─────────────────────────────────────────────────────┘
+```
+
+When learning is applied:
+
+```
+┌─────────────────────────────────────────────────────┐
+│ ✨ Applying Learned Workflow                        │
+├─────────────────────────────────────────────────────┤
+│ Based on: learn-20260622-001                        │
+│ Applied: 5 times                                    │
+│ Success rate: 100%                                  │
+├─────────────────────────────────────────────────────┤
+│ Using your preferred: sequential list format        │
+└─────────────────────────────────────────────────────┘
+```
+
+## Management Commands
+
+### View Learnings
+
+```bash
+flowmind learn list [--skill <name>] [--type <type>]
+```
+
+### View Scenes
+
+```bash
+flowmind scenes list
+```
+
+### Delete Learning
+
+```bash
+flowmind learn delete <id>
+```
+
+### Reset Skill
+
+```bash
+flowmind learn reset <skill>
+```
+
+### Export/Import
+
+```bash
+flowmind learn export [--output <file>]
+flowmind learn import <file>
+```
+
+## Privacy & Security
+
+- **Local Only**: All learning data stored locally
+- **No Cloud**: Nothing sent to external servers
+- **User Control**: Full control over all data
+- **Encryption**: Optional encryption for sensitive data
+
+## Best Practices
+
+1. **Be Specific**: More specific corrections = better learning
+2. **Confirm Patterns**: Verify learned patterns are correct
+3. **Review Regularly**: Check and clean old learnings
+4. **Share Knowledge**: Export and share with team
+
+## Troubleshooting
+
+### Learning Not Applying
+
+1. Check if learning exists: `flowmind learn list`
+2. Verify confidence threshold in config
+3. Check skill bindings
+
+### Wrong Behavior
+
+1. Review scene mappings: `flowmind scenes list`
+2. Check learning records
+3. Reset if needed: `flowmind learn reset <skill>`
+
+### Performance Issues
+
+1. Limit learning records per skill
+2. Archive old learnings
+3. Clean up unused scenes

package/skills/learning-feedback/SKILL.md

@@ -0,0 +1,174 @@
+---
+name: learning-feedback
+description: Global learning skill for FlowMind. Captures user corrections, feedback, and refined processing logic. Automatically binds learning to relevant skills for future application.
+metadata:
+  version: "1.0.0"
+  author: flowmind
+  category: core
+  priority: global
+---
+
+# Learning Feedback Skill
+
+Global learning skill that captures user corrections, feedback, and refined processing logic. Learning records are automatically bound to relevant skills for future application.
+
+## Features
+
+### Correction Learning
+- Captures user corrections ("不对", "错了", "应该是")
+- Records original vs corrected approach
+- Binds learning to affected skills
+
+### Refinement Learning
+- Captures optimization suggestions ("优化一下", "改进")
+- Records processing logic refinements
+- Applies to future similar tasks
+
+### Scene-Skill Mapping
+- Records user-specified handling preferences
+- Auto-applies on matching scenes
+- Supports complex multi-skill workflows
+
+### Knowledge Application
+- Pre-execution learning check
+- Automatic correction application
+- Learning effectiveness tracking
+
+## Trigger Patterns
+
+```
+"不对", "错了", "应该是", "正确的是"
+"不是这样", "重新处理", "修改为"
+"你应该...", "需要...", "改成..."
+"更准确的做法是", "更好的方式是"
+"优化一下", "改进", "调整"
+"流程不对", "顺序错了", "逻辑有问题"
+"先...再...", "应该先..."
+"记住这个方式", "下次直接这样"
+"按照上次的方式处理"
+```
+
+## Output Format
+
+```
+┌─────────────────────────────────────────────────────┐
+│ ✅ Learning Record Saved                            │
+├─────────────────────────────────────────────────────┤
+│ Record ID: {uuid}                                   │
+│ Skill: {affected-skill}                             │
+│ Type: {correction-type}                             │
+├─────────────────────────────────────────────────────┤
+│ Original: {brief-summary}                           │
+│ Corrected: {brief-summary}                          │
+├─────────────────────────────────────────────────────┤
+│ This learning will be auto-applied in future tasks  │
+└─────────────────────────────────────────────────────┘
+```
+
+## Learning Types
+
+| Type | Description | Example |
+|------|-------------|---------|
+| output_format | Output format correction | "用表格格式" |
+| logic_flow | Processing logic correction | "先查错误再查链路" |
+| data_accuracy | Data accuracy correction | "source_id 不是 host" |
+| skill_execution | Skill execution correction | "应该用 SLS 技能" |
+| query_syntax | Query syntax correction | "用 PromQL 不是 SQL" |
+
+## Scene Mapping
+
+### Scene Detection
+
+```
+User Input → Keyword Extraction → Pattern Matching → Scene Match
+                                                    ↓
+                                            [Match] → Apply Recorded Workflow
+                                            [No Match] → Normal Flow → Record if Confirmed
+```
+
+### Scene Mapping Examples
+
+```
+场景: 查询TraceId链路
+关键词: traceId, 链路, 调用链
+技能: sls-log-audit
+偏好: 顺序列表格式
+
+→ 自动应用: 使用 sls-log-audit，输出顺序列表
+```
+
+## Learning Storage
+
+```
+~/.flowmind/learning/
+├── records/               # Learning records
+│   ├── _global/          # Global learning
+│   ├── code-review/      # Per-skill learning
+│   └── log-audit/
+├── skill-bindings.json   # Skill binding mapping
+├── scene-mappings.json   # Scene-skill mappings
+└── stats.json            # Learning statistics
+```
+
+## Learning Integration
+
+This skill is a **global skill** that enhances all other skills:
+
+- Before executing any skill, check for applicable learning
+- Apply learned corrections automatically
+- Track learning effectiveness over time
+
+## Examples
+
+### Example 1: Output Format Correction
+
+```
+User: 查询 traceId abc123 的日志
+FlowMind: [Returns tree format]
+User: 不对，应该用顺序列表格式
+
+FlowMind:
+┌─────────────────────────────────────────────────────┐
+│ ✅ Learning Record Saved                            │
+├─────────────────────────────────────────────────────┤
+│ Skill: log-audit                                    │
+│ Type: output_format                                 │
+│ Original: Tree format                               │
+│ Corrected: Sequential list format                   │
+├─────────────────────────────────────────────────────┤
+│ Future log queries will use sequential list format  │
+└─────────────────────────────────────────────────────┘
+```
+
+### Example 2: Scene Mapping
+
+```
+User: 排查线上问题先查错误日志，再查链路，最后查代码
+
+FlowMind:
+┌─────────────────────────────────────────────────────┐
+│ ✅ Scene Mapping Saved                              │
+├─────────────────────────────────────────────────────┤
+│ Scene: 线上问题排查                                  │
+│ Keywords: 排查, 线上问题, 故障排查                    │
+│ Skill Sequence:                                     │
+│  1. log-audit (错误日志)                            │
+│  2. log-audit (链路分析)                            │
+│  3. code-review (代码审查)                          │
+├─────────────────────────────────────────────────────┤
+│ Next time will auto-apply this workflow             │
+└─────────────────────────────────────────────────────┘
+```
+
+## Configuration
+
+```json
+{
+  "learning-feedback": {
+    "autoApply": true,
+    "confidenceThreshold": 0.7,
+    "maxRecordsPerSkill": 100,
+    "archiveAfterDays": 90
+  }
+}
+```