0

src/api/miaoguo/miaoguoController.js

@@ -1511,8 +1511,12 @@ export async function GetMiaoguoTaskTime(ctx) {
             };
             const tasks = await miaoguo.GetUserMiaoguoTask(param);
             if (tasks && tasks.length > 0) {
+                // 当天任务已存在，dayNumberArr 已包含当天记录，直接用累计练习天数
+                obj.DayNumber = dayNumberArr.length;
                 await miaoguo.UpdateMiaoguoTask(obj);
             } else {
+                // 新增当天任务，DayNumber 为已有累计天数 + 1（注意用原始长度，新用户首日应为 1）
+                obj.DayNumber = dayNumberArr.length + 1;
                 await miaoguo.AddMiaoguoTask(obj);
                 await updateMiaoguoMilestoneInfoByUserID(param.UserID);
             }

秒过知识库更新/04-英语词书导入/ielts/generate_examples.js

@@ -0,0 +1,232 @@
+// 为雅思英语单词批量补充例句（写入 Words.ExampleSentence）
+// 策略：
+//   1) 复用：97% 的雅思词在现有词典(BookID=110, 47401词)或其它词书中已有例句，
+//      直接复用其 ExampleSentence，并按难度筛选为 2简单(A2)+2中等(B1/B2)+1难(C1)。
+//   2) 生成：仅对完全没例句的少量词，用本机 Ollama(qwen3) 本地生成，不依赖外网。
+// 输出格式对齐六级：{"word":..,"CEFR_Level":..,"Sentences":[{"Sentence":..,"Translate":..,"Level":..}]}
+//
+// 用法：
+//   node generate_examples.js                 # 复用+本地生成
+//   REUSE_ONLY=1 node generate_examples.js    # 只做复用（跳过 Ollama），可先跑这步看覆盖
+//   LIMIT=50 node generate_examples.js        # 只处理前 N 个未生成词（验证）
+//   OLLAMA_MODEL=qwen3.8:27b-mlx BATCH=8 node generate_examples.js
+
+import { query } from '../../../src/util/db.js';
+import axios from 'axios';
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const PROGRESS_FILE = path.join(__dirname, '.ielts_examples_progress.json');
+
+const BOOK_IDS = [212, 213, 214, 215, 216, 217];
+const OLLAMA_URL = process.env.OLLAMA_URL || 'http://localhost:11434/api/generate';
+const OLLAMA_MODEL = process.env.OLLAMA_MODEL || 'qwen3.8:27b-mlx';
+const BATCH = Number(process.env.BATCH || 8);        // Ollama 每批词数
+const LIMIT = Number(process.env.LIMIT || 0);        // >0 只处理前 N 个
+const REUSE_ONLY = process.env.REUSE_ONLY === '1';
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+// ---------- 难度筛选：2 A2 + 2 B1/B2 + 1 C1，不足则就近补 ----------
+function pickSentences(sentences) {
+  const valid = (sentences || []).filter((s) => s && s.Sentence);
+  const byLevel = {};
+  for (const s of valid) {
+    const l = (s.Level || 'B1').toUpperCase();
+    (byLevel[l] = byLevel[l] || []).push(s);
+  }
+  const chosen = [];
+  const take = (levels, n) => {
+    for (const lv of levels) {
+      while (n > 0 && byLevel[lv] && byLevel[lv].length) {
+        chosen.push(byLevel[lv].shift());
+        n--;
+      }
+      if (n <= 0) break;
+    }
+    return n;
+  };
+  take(['A2', 'A1'], 2); // 简单
+  take(['B1', 'B2'], 2); // 中等
+  take(['C1', 'C2'], 1); // 难
+  const order = ['A2', 'A1', 'B1', 'B2', 'C1', 'C2'];
+  const rem = [];
+  for (const lv of order) if (byLevel[lv]) rem.push(...byLevel[lv]);
+  while (chosen.length < 5 && rem.length) chosen.push(rem.shift());
+  return chosen.slice(0, 5).map((s) => ({
+    Sentence: s.Sentence,
+    Translate: s.Translate || '',
+    Level: (s.Level || 'B1').toUpperCase(),
+  }));
+}
+
+function buildExampleSentence(word, cefr, sentences) {
+  return JSON.stringify({
+    word,
+    CEFR_Level: (cefr || 'B1').toUpperCase(),
+    Sentences: sentences,
+  });
+}
+
+// ---------- 复用源：优先 BookID=110 大词典 ----------
+async function buildSourceMap() {
+  const rows = await query(
+    `select Word, ExampleSentence, BookID from kylx365_db.Words where ExampleSentence is not null and ExampleSentence!=''`
+  );
+  const map = new Map();
+  for (const r of rows) {
+    const key = r.Word.toLowerCase();
+    const cur = map.get(key);
+    if (!cur) map.set(key, r);
+    else if (cur.BookID !== 110 && r.BookID === 110) map.set(key, r); // 大词典优先
+  }
+  return map;
+}
+
+function parseSourceExample(raw) {
+  try {
+    const o = JSON.parse(raw);
+    const sents = o.Sentences || o.sentences || [];
+    if (!sents.length) return null;
+    return { cefr: o.CEFR_Level || o.cefr, sentences: sents };
+  } catch {
+    return null;
+  }
+}
+
+// ---------- 本地 Ollama 生成 ----------
+async function callOllama(userPrompt) {
+  const resp = await axios.post(
+    OLLAMA_URL,
+    { model: OLLAMA_MODEL, format: 'json', stream: false, think: false, prompt: userPrompt },
+    { timeout: 300000 }
+  );
+  const data = resp.data || {};
+  let text = data.response || '';
+  if (!text && data.thinking) text = data.thinking; // 思考模式兜底
+  text = (text || '').replace(/^```(?:json)?\s*\n/i, '').replace(/\n```\s*$/i, '');
+  return text;
+}
+
+function buildGenPrompt(words) {
+  const lines = words.map((w, i) => `${i + 1}. ${w.Word} | ${w.Translate || ''}`);
+  return `Generate example sentences for each English word (with Chinese meaning).
+Per word: exactly 5 sentences — 2 at CEFR A2 (simple), 2 at B1-B2 (medium), 1 at C1 (relatively hard).
+Each sentence must use the word naturally and correctly per its meaning. Add a concise Chinese translation. Also give the word's approximate CEFR level.
+Return JSON only: {"items":[{"word":"emperor","cefr":"B1","sentences":[{"sentence":"...","translate":"...","level":"A2"}, ...5]}]}
+The "word" field must exactly match the input word. Include every input word once.
+
+Input words (word | meaning):
+${lines.join('\n')}`;
+}
+
+function loadProgress() {
+  try {
+    return JSON.parse(fs.readFileSync(PROGRESS_FILE, 'utf8'));
+  } catch {
+    return { done: [] };
+  }
+}
+function saveProgress(p) {
+  fs.writeFileSync(PROGRESS_FILE, JSON.stringify(p));
+}
+
+async function main() {
+  let words = await query(
+    `select ID, Word, Translate from kylx365_db.Words where BookID in (${BOOK_IDS.join(',')}) and (ExampleSentence is null or ExampleSentence='') order by BookID, ID`
+  );
+  if (LIMIT > 0) words = words.slice(0, LIMIT);
+  console.log(`待处理雅思词行数: ${words.length}`);
+
+  const progress = loadProgress();
+  const doneIds = new Set(progress.done);
+  words = words.filter((w) => !doneIds.has(w.ID));
+  console.log(`本次新增处理: ${words.length}（已跳过 ${doneIds.size}）`);
+
+  const srcMap = await buildSourceMap();
+  console.log(`复用源词条数: ${srcMap.size}`);
+
+  let reuseOk = 0,
+    genOk = 0,
+    fail = 0;
+  const genQueue = [];
+
+  // 第一步：尽量复用
+  for (const w of words) {
+    const src = srcMap.get(w.Word.toLowerCase());
+    const parsed = src ? parseSourceExample(src.ExampleSentence) : null;
+    if (parsed && parsed.sentences.length) {
+      const picked = pickSentences(parsed.sentences);
+      if (picked.length >= 1) {
+        const json = buildExampleSentence(w.Word, parsed.cefr, picked);
+        await query('update kylx365_db.Words set ExampleSentence=? where ID=?', [json, w.ID]);
+        reuseOk++;
+        progress.done.push(w.ID);
+        continue;
+      }
+    }
+    if (!REUSE_ONLY) genQueue.push(w);
+    else {
+      fail++;
+      console.warn(`  ✗ 无复用源: ${w.Word}`);
+    }
+  }
+  saveProgress(progress);
+  console.log(`复用完成: ${reuseOk}，待生成: ${genQueue.length}`);
+
+  // 第二步：本地 Ollama 生成剩余
+  if (genQueue.length) {
+    const batches = [];
+    for (let i = 0; i < genQueue.length; i += BATCH) batches.push(genQueue.slice(i, i + BATCH));
+    console.log(`Ollama 生成批次数: ${batches.length}`);
+    for (let bi = 0; bi < batches.length; bi++) {
+      const b = batches[bi];
+      const label = `gen batch ${bi + 1}/${batches.length} (${b.map((w) => w.Word).join(',')})`;
+      let ok = false;
+      for (let attempt = 1; attempt <= 3 && !ok; attempt++) {
+        try {
+          const raw = await callOllama(buildGenPrompt(b));
+          let parsed = JSON.parse(raw);
+          const items = parsed.items || parsed;
+          const m = new Map();
+          for (const it of items) if (it && it.word) m.set(it.word.toLowerCase(), it);
+          for (const w of b) {
+            const it = m.get(w.Word.toLowerCase());
+            if (it && it.sentences && it.sentences.length >= 5) {
+              const sents = it.sentences.slice(0, 5).map((s) => ({
+                Sentence: s.sentence,
+                Translate: s.translate || '',
+                Level: (s.level || 'B1').toUpperCase(),
+              }));
+              const json = buildExampleSentence(w.Word, it.cefr, sents);
+              await query('update kylx365_db.Words set ExampleSentence=? where ID=?', [json, w.ID]);
+              progress.done.push(w.ID);
+              genOk++;
+            } else {
+              console.warn(`  ✗ 生成缺句: ${w.Word} (got ${(it?.sentences || []).length})`);
+            }
+          }
+          saveProgress(progress);
+          ok = true;
+          console.log(`✓ ${label} (genOk=${genOk})`);
+        } catch (err) {
+          console.error(`✗ ${label} 尝试${attempt}失败: ${err?.message || err}`);
+          await sleep(3000 * attempt);
+        }
+      }
+      if (!ok) fail += b.length;
+      await sleep(500);
+    }
+  }
+
+  console.log(`\n完成。reuseOk=${reuseOk}, genOk=${genOk}, fail=${fail}, 累计已生成=${progress.done.length}`);
+}
+
+main()
+  .then(() => process.exit(0))
+  .catch((e) => {
+    console.error(e);
+    process.exit(1);
+  });