dsh-plugin-t-expert 0.4.26 → 0.4.37

package/data/experts/engineering/vocab-craft-expert/skills/vocab-scheduler/references/spaced-repetition.md

@@ -0,0 +1,156 @@
+# 间隔重复记忆算法参考文档
+
+## 1. 艾宾浩斯遗忘曲线
+
+德国心理学家赫尔曼·艾宾浩斯（Hermann Ebbinghaus）在1885年发表的研究表明，人类记忆遵循指数衰减规律。初始记忆在最初几小时内遗忘最快，随后遗忘速度逐渐减缓。
+
+### 遗忘规律
+| 学习后时间 | 记忆保持率 |
+|-----------|-----------|
+| 20分钟 | 58% |
+| 1小时 | 44% |
+| 8小时 | 36% |
+| 1天 | 34% |
+| 2天 | 28% |
+| 6天 | 25% |
+| 31天 | 21% |
+
+## 2. 本系统复习间隔设计
+
+基于遗忘曲线，在记忆衰减到临界点时安排复习，实现最优记忆强化：
+
+### 复习时间表
+```
+Day 0: 首次学习（新词）
+Day 1: 第1次复习（24小时后，记忆保持约34%）
+Day 3: 第2次复习（间隔2天）
+Day 7: 第3次复习（间隔4天）
+Day 14: 第4次复习（间隔7天）
+Day 29: 第5次复习（间隔15天）
+Day 59: 第6次复习（间隔30天）→ 进入长期记忆，标记为"已掌握"
+```
+
+### 间隔数组
+```javascript
+const REVIEW_INTERVALS = [1, 2, 4, 7, 15, 30]; // 单位：天
+```
+
+## 3. 单词状态机
+
+### 状态定义
+| 状态 | 标识 | 说明 |
+|------|------|------|
+| 新词 | `new` | 尚未学习，在词库队列中等待 |
+| 学习中 | `doing` | 首次学习完成，等待进入复习轮次 |
+| 待复习 | `review` | 在复习调度中，按间隔时间复习 |
+| 已掌握 | `known` | 完成全部6轮复习，进入长期记忆 |
+| 错词 | `wrong` | 在练习中答错，需要强化复习 |
+
+### 状态转换规则
+```
+new → doing       : 首次学习完成
+doing → review    : 第二天到达第1次复习时间
+review → review   : 每次复习正确，推进到下一轮间隔
+review → known    : 第6次复习正确
+review → wrong    : 复习时答错
+wrong → review    : 连续3次答对，回归正常复习轨道
+doing → wrong     : 首次学习时拼写错误
+```
+
+## 4. 错词强化策略
+
+### 进入错词本条件
+- 跟打模式中拼写错误
+- 默写模式中拼写错误
+- 复习模式中标记为"不认识"
+
+### 错词复习频率
+- 错词不受间隔复习时间表约束
+- 每日额外安排 5-10 个错词复习
+- 从错词本中随机抽取（优先最近加入的）
+
+### 移出错词本条件
+- 在后续练习中连续 3 次回答正确
+- 正确计数存储在 `wordStates[word].correctStreak` 中
+- 移出后回归正常复习轨道（从当前 reviewCount 继续）
+
+## 5. 每日任务生成算法
+
+### 伪代码
+```
+function generateDailyTask(progress):
+  today = currentDate()
+  
+  // 1. 错词（最高优先级）
+  wrongBatch = sample(progress.wrongWords, min(10, len(wrongWords)))
+  
+  // 2. 到期复习词
+  reviewBatch = []
+  for word in progress.reviewSchedule[today]:
+    reviewBatch.append(word)
+  
+  // 3. 新词
+  newBatch = dictWords[lastLearnIndex : lastLearnIndex + perDayStudyNumber]
+  
+  // 4. 组装任务
+  return {
+    wrong: wrongBatch,       // 错词强化
+    review: reviewBatch,     // 到期复习
+    new: newBatch,           // 新词学习
+    totalCount: len(wrongBatch) + len(reviewBatch) + len(newBatch)
+  }
+```
+
+### 任务优先级
+1. 错词强化（必须完成）
+2. 到期复习词（必须完成）
+3. 新词学习（可根据时间调整数量）
+
+## 6. 进度持久化方案
+
+### 存储位置
+`.workbuddy/memory/vocab-progress.json`
+
+### 关键字段
+```json
+{
+  "currentDict": "cet6",           // 当前词库ID
+  "perDayStudyNumber": 20,         // 每日新词量
+  "lastLearnIndex": 145,           // 已学到的位置
+  "pushTime": "08:00",             // 推送时间
+  "automationId": "auto-xxx",      // 关联的自动化ID
+  "stats": {
+    "totalLearned": 145,           // 总学习词数
+    "totalMastered": 89,           // 已掌握词数
+    "totalWrong": 23,              // 错词池当前数
+    "streakDays": 7,               // 连续打卡天数
+    "startDate": "2026-05-01",     // 开始日期
+    "lastLearnDate": "2026-05-03"  // 最后学习日期
+  },
+  "wrongWords": [...],             // 错词列表
+  "weakWords": [...],              // 薄弱词列表
+  "reviewSchedule": {              // 按日期的复习安排
+    "2026-05-04": ["word1", ...],
+    "2026-05-05": ["word2", ...]
+  },
+  "wordStates": {                  // 每个词的状态
+    "word1": {
+      "state": "review",
+      "reviewCount": 3,
+      "lastReview": "2026-05-01",
+      "nextReview": "2026-05-08",
+      "correctStreak": 0
+    }
+  }
+}
+```
+
+## 7. 常见过滤词（不计入学习）
+
+以下为高频简单词，在分析文章生词时自动过滤：
+```
+a, an, the, i, my, me, you, your, he, his, she, her, it,
+what, who, where, how, when, which,
+be, am, is, was, are, were, do, did, can, could, will, would,
+to, of, for, at, in, that, this, and, not, no, yes
+```

package/data/experts/engineering/vocab-craft-expert/skills/vocab-scheduler/scripts/generate-daily-task.js

@@ -0,0 +1,102 @@
+#!/usr/bin/env node
+/**
+ * 生成每日学习任务
+ * 用法: node generate-daily-task.js [--date YYYY-MM-DD]
+ * 
+ * 读取学习进度文件，按照间隔重复算法生成当日任务：
+ * 1. 错词强化（最高优先级，最多10个）
+ * 2. 到期复习词（必须完成）
+ * 3. 新词学习（按每日目标量）
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 解析参数
+const args = process.argv.slice(2);
+const params = {};
+for (let i = 0; i < args.length; i += 2) {
+  if (args[i] && args[i].startsWith('--')) {
+    params[args[i].replace('--', '')] = args[i + 1];
+  }
+}
+
+const today = params.date || new Date().toISOString().split('T')[0];
+
+// 读取进度文件
+const progressFile = path.join(process.cwd(), '.workbuddy', 'memory', 'vocab-progress.json');
+
+if (!fs.existsSync(progressFile)) {
+  console.error('错误: 未找到学习进度文件。请先运行 init-progress.js 初始化。');
+  process.exit(1);
+}
+
+const progress = JSON.parse(fs.readFileSync(progressFile, 'utf-8'));
+
+// 1. 错词强化批次
+const wrongBatch = [];
+if (progress.wrongWords && progress.wrongWords.length > 0) {
+  const maxWrong = Math.min(10, progress.wrongWords.length);
+  // 优先最近加入的错词
+  const shuffled = [...progress.wrongWords].sort(() => Math.random() - 0.5);
+  wrongBatch.push(...shuffled.slice(0, maxWrong));
+}
+
+// 2. 到期复习词
+const reviewBatch = [];
+if (progress.reviewSchedule && progress.reviewSchedule[today]) {
+  reviewBatch.push(...progress.reviewSchedule[today]);
+}
+// 也检查过期未复习的（昨天及之前遗留的）
+const todayDate = new Date(today);
+for (const [dateStr, words] of Object.entries(progress.reviewSchedule || {})) {
+  const schedDate = new Date(dateStr);
+  if (schedDate < todayDate && words.length > 0) {
+    reviewBatch.push(...words);
+  }
+}
+
+// 3. 新词批次
+const newWordCount = progress.perDayStudyNumber || 20;
+const startIdx = progress.lastLearnIndex || 0;
+const endIdx = startIdx + newWordCount;
+
+// 输出任务摘要
+const task = {
+  date: today,
+  dict: progress.currentDict,
+  dictName: progress.dictName,
+  newWords: {
+    count: newWordCount,
+    startIndex: startIdx,
+    endIndex: endIdx
+  },
+  reviewWords: {
+    count: reviewBatch.length,
+    words: reviewBatch
+  },
+  wrongWords: {
+    count: wrongBatch.length,
+    words: wrongBatch
+  },
+  totalCount: newWordCount + reviewBatch.length + wrongBatch.length,
+  stats: {
+    totalLearned: progress.stats.totalLearned,
+    totalMastered: progress.stats.totalMastered,
+    streakDays: progress.stats.streakDays,
+    dictLength: progress.dictLength,
+    progressPercent: ((progress.stats.totalLearned / progress.dictLength) * 100).toFixed(1)
+  }
+};
+
+// 检查是否已完成词库
+if (startIdx >= progress.dictLength) {
+  task.newWords.count = 0;
+  task.newWords.note = '词库已学完，仅复习';
+  task.totalCount = reviewBatch.length + wrongBatch.length;
+}
+
+// 计算预计用时（每词约1.5分钟）
+task.estimatedMinutes = Math.ceil(task.totalCount * 1.5);
+
+console.log(JSON.stringify(task, null, 2));

package/data/experts/engineering/vocab-craft-expert/skills/vocab-scheduler/scripts/init-progress.js

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+/**
+ * 初始化学习进度文件
+ * 用法: node init-progress.js --dict <词库ID> --daily <每日词量> --push <推送时间HH:MM>
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 解析命令行参数
+const args = process.argv.slice(2);
+const params = {};
+for (let i = 0; i < args.length; i += 2) {
+  const key = args[i].replace('--', '');
+  params[key] = args[i + 1];
+}
+
+const dict = params.dict || 'cet6';
+const daily = parseInt(params.daily) || 20;
+const push = params.push || '08:00';
+
+// 支持的词库列表
+const SUPPORTED_DICTS = {
+  'cet4': { name: 'CET-4 大学英语四级', length: 4500 },
+  'cet6': { name: 'CET-6 大学英语六级', length: 6000 },
+  'kaoyan': { name: '考研英语', length: 5500 },
+  'ielts': { name: 'IELTS 雅思', length: 8000 },
+  'toefl': { name: 'TOEFL 托福', length: 8000 },
+  'gre': { name: 'GRE', length: 12000 },
+  'sat': { name: 'SAT', length: 4000 },
+  'gmat': { name: 'GMAT', length: 3000 },
+  'tem4': { name: '专业四级', length: 8000 },
+  'tem8': { name: '专业八级', length: 13000 },
+  'gaokao': { name: '高考英语', length: 3500 },
+  'zhongkao': { name: '中考英语', length: 1600 },
+  'programmer': { name: '程序员词汇', length: 2000 }
+};
+
+if (!SUPPORTED_DICTS[dict]) {
+  console.error(`错误: 不支持的词库 "${dict}"`);
+  console.log('支持的词库:', Object.keys(SUPPORTED_DICTS).join(', '));
+  process.exit(1);
+}
+
+const today = new Date().toISOString().split('T')[0];
+const dictInfo = SUPPORTED_DICTS[dict];
+const estimatedDays = Math.ceil(dictInfo.length / daily);
+
+// 生成进度文件
+const progress = {
+  currentDict: dict,
+  dictName: dictInfo.name,
+  dictLength: dictInfo.length,
+  perDayStudyNumber: daily,
+  lastLearnIndex: 0,
+  pushTime: push,
+  automationId: null,
+  stats: {
+    totalLearned: 0,
+    totalMastered: 0,
+    totalWrong: 0,
+    streakDays: 0,
+    startDate: today,
+    lastLearnDate: null
+  },
+  wrongWords: [],
+  weakWords: [],
+  reviewSchedule: {},
+  wordStates: {}
+};
+
+// 确定输出路径
+const outputDir = path.join(process.cwd(), '.workbuddy', 'memory');
+const outputFile = path.join(outputDir, 'vocab-progress.json');
+
+// 创建目录
+if (!fs.existsSync(outputDir)) {
+  fs.mkdirSync(outputDir, { recursive: true });
+}
+
+// 写入文件
+fs.writeFileSync(outputFile, JSON.stringify(progress, null, 2), 'utf-8');
+
+console.log('=== 学习计划初始化成功 ===');
+console.log(`词库: ${dictInfo.name} (${dictInfo.length} 词)`);
+console.log(`每日新词: ${daily} 个`);
+console.log(`推送时间: 每天 ${push}`);
+console.log(`预计完成: ${estimatedDays} 天`);
+console.log(`进度文件: ${outputFile}`);
+console.log('========================');

package/data/experts/engineering/vocab-craft-expert/skills/vocab-scheduler/scripts/learning-report.js

@@ -0,0 +1,95 @@
+#!/usr/bin/env node
+/**
+ * 生成学习统计报告
+ * 用法: node learning-report.js --period <week|month|all>
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 解析参数
+const args = process.argv.slice(2);
+const params = {};
+for (let i = 0; i < args.length; i += 2) {
+  if (args[i] && args[i].startsWith('--')) {
+    params[args[i].replace('--', '')] = args[i + 1];
+  }
+}
+
+const period = params.period || 'week';
+
+// 读取进度文件
+const progressFile = path.join(process.cwd(), '.workbuddy', 'memory', 'vocab-progress.json');
+
+if (!fs.existsSync(progressFile)) {
+  console.error('错误: 未找到学习进度文件');
+  process.exit(1);
+}
+
+const progress = JSON.parse(fs.readFileSync(progressFile, 'utf-8'));
+const today = new Date().toISOString().split('T')[0];
+
+// 计算学习天数
+const startDate = new Date(progress.stats.startDate);
+const todayDate = new Date(today);
+const totalDays = Math.floor((todayDate - startDate) / (1000 * 60 * 60 * 24)) + 1;
+
+// 计算各状态词数
+let stateCount = { new: 0, doing: 0, review: 0, known: 0, wrong: 0 };
+for (const [word, state] of Object.entries(progress.wordStates || {})) {
+  if (stateCount[state.state] !== undefined) {
+    stateCount[state.state] += 1;
+  }
+}
+
+// 计算未来7天复习负载
+const upcomingReview = {};
+for (let i = 0; i < 7; i++) {
+  const d = new Date(todayDate);
+  d.setDate(d.getDate() + i);
+  const dateStr = d.toISOString().split('T')[0];
+  upcomingReview[dateStr] = (progress.reviewSchedule[dateStr] || []).length;
+}
+
+// 计算平均每日学习量
+const avgDaily = totalDays > 0 ? Math.round(progress.stats.totalLearned / totalDays) : 0;
+
+// 预估剩余天数
+const remainingWords = progress.dictLength - progress.stats.totalLearned;
+const estimatedRemaining = avgDaily > 0 ? Math.ceil(remainingWords / avgDaily) : '未知';
+
+// 正确率估算（基于错词比例）
+const totalAttempted = progress.stats.totalLearned;
+const wrongCount = Object.values(progress.wordStates || {}).filter(s => s.state === 'wrong').length;
+const accuracy = totalAttempted > 0 ? (((totalAttempted - wrongCount) / totalAttempted) * 100).toFixed(1) : '100.0';
+
+const report = {
+  period: period,
+  generatedAt: today,
+  overview: {
+    dict: progress.dictName,
+    dictLength: progress.dictLength,
+    startDate: progress.stats.startDate,
+    totalDays: totalDays,
+    streakDays: progress.stats.streakDays,
+    pushTime: progress.pushTime
+  },
+  progress: {
+    totalLearned: progress.stats.totalLearned,
+    totalMastered: progress.stats.totalMastered,
+    progressPercent: ((progress.stats.totalLearned / progress.dictLength) * 100).toFixed(1) + '%',
+    remainingWords: remainingWords,
+    estimatedRemainingDays: estimatedRemaining
+  },
+  performance: {
+    avgDailyWords: avgDaily,
+    accuracy: accuracy + '%',
+    wrongPoolSize: progress.wrongWords.length,
+    weakPoolSize: progress.weakWords.length
+  },
+  wordStates: stateCount,
+  upcomingReviewLoad: upcomingReview,
+  topWrongWords: progress.wrongWords.slice(0, 10)
+};
+
+console.log(JSON.stringify(report, null, 2));

package/data/experts/engineering/vocab-craft-expert/skills/vocab-scheduler/scripts/update-progress.js

@@ -0,0 +1,200 @@
+#!/usr/bin/env node
+/**
+ * 更新学习进度
+ * 用法: node update-progress.js --results '<JSON学习结果>'
+ * 
+ * 学习结果格式:
+ * {
+ *   "date": "2026-05-03",
+ *   "newLearned": 20,
+ *   "reviewCompleted": ["word1", "word2"],
+ *   "wrongAnswers": ["word3", "word4"],
+ *   "correctFromWrong": ["word5"],
+ *   "markedWeak": ["word6"],
+ *   "timeSpent": 1800
+ * }
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// 间隔重复配置（天数）
+const REVIEW_INTERVALS = [1, 2, 4, 7, 15, 30];
+const CORRECT_STREAK_TO_REMOVE = 3;
+
+// 解析参数
+const args = process.argv.slice(2);
+let resultsJson = '';
+for (let i = 0; i < args.length; i++) {
+  if (args[i] === '--results' && args[i + 1]) {
+    resultsJson = args[i + 1];
+    break;
+  }
+}
+
+if (!resultsJson) {
+  console.error('错误: 请提供 --results 参数');
+  process.exit(1);
+}
+
+const results = JSON.parse(resultsJson);
+const progressFile = path.join(process.cwd(), '.workbuddy', 'memory', 'vocab-progress.json');
+
+if (!fs.existsSync(progressFile)) {
+  console.error('错误: 未找到学习进度文件');
+  process.exit(1);
+}
+
+const progress = JSON.parse(fs.readFileSync(progressFile, 'utf-8'));
+const today = results.date || new Date().toISOString().split('T')[0];
+
+// 1. 更新 lastLearnIndex
+if (results.newLearned > 0) {
+  progress.lastLearnIndex += results.newLearned;
+  progress.stats.totalLearned = progress.lastLearnIndex;
+}
+
+// 2. 为新学单词写入复习计划
+if (results.newWords && results.newWords.length > 0) {
+  for (const word of results.newWords) {
+    // 初始化词状态
+    progress.wordStates[word] = {
+      state: 'doing',
+      reviewCount: 0,
+      lastReview: today,
+      nextReview: addDays(today, REVIEW_INTERVALS[0]),
+      correctStreak: 0
+    };
+    // 写入第1次复习时间
+    const nextDate = addDays(today, REVIEW_INTERVALS[0]);
+    if (!progress.reviewSchedule[nextDate]) {
+      progress.reviewSchedule[nextDate] = [];
+    }
+    progress.reviewSchedule[nextDate].push(word);
+  }
+}
+
+// 3. 处理复习完成的词
+if (results.reviewCompleted && results.reviewCompleted.length > 0) {
+  for (const word of results.reviewCompleted) {
+    if (progress.wordStates[word]) {
+      const state = progress.wordStates[word];
+      state.reviewCount += 1;
+      state.lastReview = today;
+      state.correctStreak = (state.correctStreak || 0) + 1;
+      
+      if (state.reviewCount >= REVIEW_INTERVALS.length) {
+        // 完成所有复习轮次，标记为已掌握
+        state.state = 'known';
+        state.nextReview = null;
+        progress.stats.totalMastered += 1;
+      } else {
+        // 安排下一轮复习
+        state.state = 'review';
+        const nextInterval = REVIEW_INTERVALS[state.reviewCount];
+        state.nextReview = addDays(today, nextInterval);
+        if (!progress.reviewSchedule[state.nextReview]) {
+          progress.reviewSchedule[state.nextReview] = [];
+        }
+        progress.reviewSchedule[state.nextReview].push(word);
+      }
+    }
+  }
+}
+
+// 4. 处理答错的词
+if (results.wrongAnswers && results.wrongAnswers.length > 0) {
+  for (const word of results.wrongAnswers) {
+    if (!progress.wrongWords.includes(word)) {
+      progress.wrongWords.push(word);
+    }
+    if (progress.wordStates[word]) {
+      progress.wordStates[word].state = 'wrong';
+      progress.wordStates[word].correctStreak = 0;
+    }
+  }
+  progress.stats.totalWrong = progress.wrongWords.length;
+}
+
+// 5. 处理从错词本中正确回答的词
+if (results.correctFromWrong && results.correctFromWrong.length > 0) {
+  for (const word of results.correctFromWrong) {
+    if (progress.wordStates[word]) {
+      progress.wordStates[word].correctStreak = (progress.wordStates[word].correctStreak || 0) + 1;
+      
+      if (progress.wordStates[word].correctStreak >= CORRECT_STREAK_TO_REMOVE) {
+        // 连续正确达标，移出错词本
+        progress.wrongWords = progress.wrongWords.filter(w => w !== word);
+        progress.wordStates[word].state = 'review';
+        // 回归正常复习轨道
+        const reviewCount = progress.wordStates[word].reviewCount || 0;
+        if (reviewCount < REVIEW_INTERVALS.length) {
+          const nextInterval = REVIEW_INTERVALS[reviewCount];
+          const nextDate = addDays(today, nextInterval);
+          progress.wordStates[word].nextReview = nextDate;
+          if (!progress.reviewSchedule[nextDate]) {
+            progress.reviewSchedule[nextDate] = [];
+          }
+          progress.reviewSchedule[nextDate].push(word);
+        }
+      }
+    }
+  }
+  progress.stats.totalWrong = progress.wrongWords.length;
+}
+
+// 6. 处理标记为薄弱的词
+if (results.markedWeak && results.markedWeak.length > 0) {
+  for (const word of results.markedWeak) {
+    if (!progress.weakWords.includes(word)) {
+      progress.weakWords.push(word);
+    }
+  }
+}
+
+// 7. 更新连续打卡天数
+if (progress.stats.lastLearnDate) {
+  const lastDate = new Date(progress.stats.lastLearnDate);
+  const todayDate = new Date(today);
+  const diffDays = Math.floor((todayDate - lastDate) / (1000 * 60 * 60 * 24));
+  if (diffDays === 1) {
+    progress.stats.streakDays += 1;
+  } else if (diffDays > 1) {
+    progress.stats.streakDays = 1; // 中断后重新计数
+  }
+} else {
+  progress.stats.streakDays = 1;
+}
+progress.stats.lastLearnDate = today;
+
+// 8. 清理过期的复习计划条目
+for (const dateStr of Object.keys(progress.reviewSchedule)) {
+  if (new Date(dateStr) < new Date(today)) {
+    delete progress.reviewSchedule[dateStr];
+  }
+}
+
+// 写入更新后的进度
+fs.writeFileSync(progressFile, JSON.stringify(progress, null, 2), 'utf-8');
+
+// 输出摘要
+const summary = {
+  status: 'success',
+  date: today,
+  progress: {
+    totalLearned: progress.stats.totalLearned,
+    totalMastered: progress.stats.totalMastered,
+    wrongPoolSize: progress.wrongWords.length,
+    streakDays: progress.stats.streakDays,
+    dictProgress: `${progress.stats.totalLearned}/${progress.dictLength} (${((progress.stats.totalLearned / progress.dictLength) * 100).toFixed(1)}%)`
+  }
+};
+
+console.log(JSON.stringify(summary, null, 2));
+
+// 辅助函数：日期加天数
+function addDays(dateStr, days) {
+  const date = new Date(dateStr);
+  date.setDate(date.getDate() + days);
+  return date.toISOString().split('T')[0];
+}