daily-question 2.1.0 → 2.1.1

package/lib/service.js

@@ -1,9 +1,9 @@
 import { randomUUID } from 'node:crypto'
-import { findSubject, allSubjects, QUESTION_TYPE_LABEL, CHOICE_TYPES, subjectTypes, REFERENCE_EXAMS } from './subjects.js'
+import { findSubject, allSubjects, QUESTION_TYPE_LABEL, CHOICE_TYPES, hasChoiceOptions, validChoiceKey, subjectTypes, REFERENCE_EXAMS } from './subjects.js'
 import { computeCountdown, resolveExamDate, todayISO, verifyExamDateOnline, yearOptions } from './exam-dates.js'
 import { createVerifiedQuestion, QuestionGenerationError, reviseAnswer } from './generate.js'
 import { answerFollowup } from './tutor.js'
-import { parseBankText, extractBankPdf } from './bank.js'
+import { parseBankText, extractBankPdf, isUsableBankItem } from './bank.js'
 import { Store, resolveDataDir } from './store.js'
 import { createUpdateChecker, PLUGIN_VERSION } from './updates.js'
 import { withTimeout } from './async.js'
@@ -56,6 +56,8 @@ function normalizeChoice(value, question) {
   for (const letter of upper) {
     if (!keys.includes(letter)) throw new Error(`选项 ${letter} 不在本题选项中`)
   }
+  if (question.type !== 'multiple' && upper.length !== 1) throw new Error('本题只能选择一个选项')
+  if (new Set(upper).size !== upper.length) throw new Error('选项不能重复')
   return upper.split('').sort().join('')
 }
 
@@ -204,7 +206,7 @@ export class DailyQuestionService {
         enabled: enabled.has(subject.id),
         source: data.settings.subjectSource[subject.id] || 'auto',
         bankItemCount: usableBanks.reduce((total, bank) => total
-          + bank.items.filter((item) => item.stem && (!item.type || allowed.has(item.type))).length, 0),
+          + bank.items.filter((item) => isUsableBankItem(item) && (!item.type || allowed.has(item.type))).length, 0),
       }
     })
   }
@@ -218,23 +220,22 @@ export class DailyQuestionService {
       subjectId: bank.subjectId || '',
       importedAt: bank.importedAt,
       itemCount: bank.items.length,
-      usable: bank.items.filter((item) => item.stem).length,
+      usable: bank.items.filter(isUsableBankItem).length,
       pendingAnswers: bank.items.filter((item) => item.answerStatus !== 'verified').length,
     }))
   }
 
   counts(data) {
-    const result = {}
-    const enabled=new Set(data.settings.subjects)
-    for(const id of enabled)result[id]={all:0,favorite:0,wrong:0}
+    const result = Object.create(null)
+    for (const id of data.settings.subjects) result[id] = { all: 0, favorite: 0, wrong: 0 }
     for(const question of Object.values(data.questions)) {
-      if(!enabled.has(question.subjectId))continue
-      const count=result[question.subjectId]
+      if (!question.subjectId) continue
+      const count = result[question.subjectId] ??= { all: 0, favorite: 0, wrong: 0 }
       count.all++
       if(question.favoriteAt)count.favorite++
       if(this.isWrong(question,this.attemptsOf(data,question.id)))count.wrong++
     }
-    return result
+    return { ...result }
   }
 
   isWrong(question, attempts) {
@@ -419,6 +420,7 @@ export class DailyQuestionService {
 
       await this.store.update((draft) => {
         signal?.throwIfAborted()
+        if (!draft.settings.subjects.includes(subject.id)) throw new Error('该科目已停用')
         const history=Object.values(draft.questions).filter(question=>question.subjectId===subject.id)
         if(findQuestionRepeat(generated,indexQuestionHistory(history)))throw new Error('题目与已发布题目重复，已阻止发布，请重试生成新题')
         draft.questions[qid] = record
@@ -433,8 +435,7 @@ export class DailyQuestionService {
         ? error.message
         : `在线出题失败：${error?.message || error}`
       await this.store.update((draft) => {
-        draft.failures[subject.id] = { at: nowISO(), message }
-        return draft
+        if (draft.settings.subjects.includes(subject.id)) draft.failures[subject.id] = { at: nowISO(), message }
       }).catch(() => {})
       throw new Error(message)
     }
@@ -446,7 +447,7 @@ export class DailyQuestionService {
     for (const bank of data.banks) {
       if (bank.subjectId && bank.subjectId !== subject.id) continue
       for (const item of bank.items) {
-        if (!item.stem) continue
+        if (!isUsableBankItem(item)) continue
         const qid = bankQuestionId(bank.id, item.id)
         const existing = data.questions[qid]
         if (existing && existing.subjectId !== subject.id) continue
@@ -467,6 +468,7 @@ export class DailyQuestionService {
     const stamp = nowISO()
     await this.store.update((draft) => {
       signal?.throwIfAborted()
+      if (!draft.settings.subjects.includes(subject.id)) throw new Error('该科目已停用')
       const existing = draft.questions[qid]
       if (existing) {
         existing.assignedCount = (existing.assignedCount || 1) + 1
@@ -546,6 +548,8 @@ export class DailyQuestionService {
     const revealed = currentAttempts.length > 0
     const last = (attemptId ? currentAttempts.find((attempt) => attempt.id === attemptId) : currentAttempts[currentAttempts.length - 1]) || null
     const answer = question.currentAnswer
+    const isChoice = CHOICE_TYPES.has(question.type)
+    const canSelect = isChoice && hasChoiceOptions(question.options)
     return {
       id: question.id,
       subjectId: question.subjectId,
@@ -553,7 +557,8 @@ export class DailyQuestionService {
       type: question.type,
       typeLabel: QUESTION_TYPE_LABEL[question.type] || question.type,
       /** 完形填空 / 阅读理解按选择题判分，前端据此渲染选项而不是“作答完毕”。 */
-      isChoice: CHOICE_TYPES.has(question.type),
+      isChoice,
+      canSelect,
       stem: question.stem,
       options: question.options || [],
       knowledge: question.knowledge || [],
@@ -566,7 +571,7 @@ export class DailyQuestionService {
         paperEvidence: revealed ? question.examAlignment.paperEvidence : [],
       } : null,
       source: question.source,
-      assignedDate: isToday?date:question.assignedDate,
+      assignedDate: isToday ? date : question.lastAssignedDate || question.assignedDate,
       practiceDate:isToday?date:null,
       todayAttemptCount:isToday?currentAttempts.length:0,
       createdAt: question.createdAt,
@@ -602,7 +607,7 @@ export class DailyQuestionService {
         ? {
           versionId: answer.versionId,
           answer: answer.answer,
-          answerKey: answer.answerKey || '',
+          answerKey: canSelect && validChoiceKey(question.type, answer.answerKey, question.options) ? answer.answerKey : '',
           explanation: answer.explanation,
           verified: Boolean(answer.verified),
           basis: answer.basis,
@@ -638,7 +643,7 @@ export class DailyQuestionService {
       typeLabel: QUESTION_TYPE_LABEL[question.type] || question.type,
       summary: summariseStem(question.stem),
       stem: question.stem,
-      assignedDate: question.assignedDate,
+      assignedDate: question.lastAssignedDate || question.assignedDate,
       attemptCount: attempts.length,
       favorite: Boolean(question.favoriteAt),
       wrongEver: this.isWrong(question, attempts),
@@ -666,7 +671,7 @@ export class DailyQuestionService {
       const record = data.daily[`${todayISO()}|${subjectId}`]
       questions = questions.filter((question) => question.id === record?.questionId)
     }
-    questions.sort((a, b) => String(b.assignedDate).localeCompare(String(a.assignedDate))
+    questions.sort((a, b) => String(b.lastAssignedDate || b.assignedDate).localeCompare(String(a.lastAssignedDate || a.assignedDate))
       || String(b.createdAt).localeCompare(String(a.createdAt)) || String(b.id).localeCompare(String(a.id)))
     const total=questions.length,totalPages=Math.max(1,Math.ceil(total/pageSize))
     if(idsOnly===true)return {ok:true,kind,subjectId,total,ids:questions.map(q=>q.id)}
@@ -680,14 +685,14 @@ export class DailyQuestionService {
     }
   }
 
-  async getQuestion({ qid }) {
+  async getQuestion({ qid, attemptId }) {
     const data = await this.data()
     const question = data.questions[qid]
     if (!question) throw new Error('题目不存在（可能已随题库删除而失效）')
     const thread = this.threadView(data, qid)
     const date=todayISO()
     const isToday = data.daily[`${date}|${question.subjectId}`]?.questionId === qid
-    return { ok: true, question: this.questionView(data, question, {date}), thread, isToday }
+    return { ok: true, question: this.questionView(data, question, { date, attemptId }), thread, isToday }
   }
 
   threadView(data, qid) {
@@ -703,58 +708,46 @@ export class DailyQuestionService {
   /* ------------------------------ 作答 ------------------------------ */
 
   async reveal({ qid, mode = 'submit', choice = '', attemptId }) {
-    const data = await this.data()
-    const question = data.questions[qid]
-    if (!question) throw new Error('题目不存在')
-    const isChoice = CHOICE_TYPES.has(question.type)
-    let result = 'pending'
-    let normalizedChoice = ''
-    if (mode === 'submit') {
-      if (!isChoice) throw new Error('主观题不支持提交选项')
-      normalizedChoice = normalizeChoice(choice, question)
-      const key = sortLetters(question.currentAnswer?.answerKey)
-      const canGrade = key && key.split('').every((letter) => question.options?.some((option) => option.key === letter))
-        && (question.type !== 'single' || key.length === 1)
-      result = canGrade ? (normalizedChoice === key ? 'correct' : 'wrong') : 'pending'
-    } else if (mode === 'giveup') {
-      result = 'wrong'
-    } else if (mode === 'done') {
-      result = 'pending'
-    } else {
-      throw new Error(`未知的作答方式：${mode}`)
-    }
-
-    const stamp = nowISO()
-    const attempt = {
-      id: attemptId || randomUUID(),
-      questionId: qid,
-      at: stamp,
-      practiceDate:todayISO(new Date(stamp)),
-      type: question.type,
-      mode,
-      choice: normalizedChoice,
-      result,
-      revealedAt: stamp,
-      judgedAt: result === 'pending' ? null : stamp,
-    }
-
+    const id = attemptId || randomUUID()
     const duplicated = await this.store.update((draft) => {
-      const target = draft.questions[qid]
-      if (!target) throw new Error('题目不存在')
-      const existing = draft.attempts.find((item) => item.id === attempt.id)
+      const question = draft.questions[qid]
+      if (!question) throw new Error('题目不存在')
+      const existing = draft.attempts.find((item) => item.id === id)
       if (existing) {
         if (existing.questionId !== qid) throw new Error('作答 ID 已用于其他题目')
+        if (existing.mode !== mode || (existing.choice || '') !== (mode === 'submit' ? sortLetters(choice) : '')) {
+          throw Object.assign(new Error('本轮已保存另一份作答，请查看已保存的结果'), { code: 'ATTEMPT_CONFLICT' })
+        }
         return true
       }
-      draft.attempts.push(attempt)
-      if (target.currentAnswer && !target.currentAnswer.firstShownAt) {
-        target.currentAnswer.firstShownAt = stamp
+      let result = 'pending'
+      let normalizedChoice = ''
+      if (mode === 'submit') {
+        if (!CHOICE_TYPES.has(question.type)) throw new Error('主观题不支持提交选项')
+        if (!hasChoiceOptions(question.options)) throw new Error('选项不完整，请使用“作答完毕”查看答案')
+        normalizedChoice = normalizeChoice(choice, question)
+        const key = question.currentAnswer?.answerKey
+        if (validChoiceKey(question.type, key, question.options)) result = normalizedChoice === sortLetters(key) ? 'correct' : 'wrong'
+      } else if (mode === 'giveup') {
+        result = 'wrong'
+      } else if (mode !== 'done') {
+        throw new Error(`未知的作答方式：${mode}`)
       }
-      target.updatedAt = stamp
+      const stamp = nowISO()
+      draft.attempts.push({
+        id, questionId: qid, at: stamp, practiceDate: todayISO(new Date(stamp)),
+        type: question.type, mode, choice: normalizedChoice, result,
+        revealedAt: stamp, judgedAt: result === 'pending' ? null : stamp,
+      })
+      if (question.currentAnswer && !question.currentAnswer.firstShownAt) {
+        question.currentAnswer.firstShownAt = stamp
+      }
+      question.updatedAt = stamp
       return false
     })
     const fresh = await this.data()
-    return { ok: true, question: this.questionView(fresh, fresh.questions[qid] || question, {attemptId:attempt.id}), duplicated }
+    if (!fresh.questions[qid]) throw new Error('题目已删除')
+    return { ok: true, question: this.questionView(fresh, fresh.questions[qid], { attemptId: id }), duplicated }
   }
 
   async judge({ qid, verdict, attemptId }) {
@@ -1115,12 +1108,13 @@ export class DailyQuestionService {
         knowledge: item.knowledge,
         difficulty: item.difficulty,
         issues: item.issues,
+        usable: isUsableBankItem(item),
         answerStatus: item.answerStatus,
       })),
       stats: {
         total: parsed.items.length,
         withAnswer: parsed.items.filter((item) => item.answer).length,
-        blocked: parsed.items.filter((item) => !item.stem).length,
+        blocked: parsed.items.length - parsed.usable,
       },
     }
   }
@@ -1132,10 +1126,14 @@ export class DailyQuestionService {
     }
   }
 
-  async commitBank({ importId, name, subjectId }) {
+  async commitBank({ importId, name, subjectId, excludedIndexes = [] }) {
     const pending = this.imports.get(importId)
     if (!pending) throw new Error('导入结果已过期，请重新选择文件导入')
-    const usable = pending.items.filter((item) => item.stem && item.stem.length >= 4)
+    if (!Array.isArray(excludedIndexes) || excludedIndexes.some((index) => !Number.isInteger(index) || index < 1 || index > pending.items.length)) {
+      throw new Error('导入勾选有误，请重新选择题目')
+    }
+    const excluded = new Set(excludedIndexes)
+    const usable = pending.items.filter((item) => !excluded.has(item.index) && isUsableBankItem(item))
     if (!usable.length) throw new Error('没有可用的题目可以入库：请检查文件结构后重新导入')
     const bankId = `bank_${randomUUID().slice(0, 8)}`
     const bank = {
@@ -1159,11 +1157,13 @@ export class DailyQuestionService {
         answerStatus: item.answer ? 'unverified' : 'missing',
       })),
     }
-    await this.store.update((draft) => {
-      draft.banks.push(bank)
-      return draft
-    })
     this.imports.delete(importId)
+    try {
+      await this.store.update((draft) => { draft.banks.push(bank) })
+    } catch (error) {
+      this.imports.set(importId, pending)
+      throw error
+    }
     const data = await this.data()
     return { ok: true, bank: this.bankViews(data).find((item) => item.id === bankId), banks: this.bankViews(data), subjects: this.subjectViews(data) }
   }
@@ -1240,11 +1240,11 @@ export class DailyQuestionService {
     const kept = Object.values(data.questions).filter((question) => question.subjectId === subjectId).length
     const result = await this.saveSettings({
       subjects: remaining,
-      activeSubject: data.settings.activeSubject === subjectId ? (remaining[0] || null) : data.settings.activeSubject,
+      activeSubject: data.settings.activeSubject === subjectId && !kept ? (remaining[0] || null) : data.settings.activeSubject,
     })
     return {
       ...result,
-      message: `科目已移出每日出题，历史数据保留：${kept} 道题目及其作答记录仍可在“全部”中查看。`,
+      message: `科目已移出每日出题，历史数据保留：${kept} 道题目及其作答记录可通过“已停用科目”查看。`,
     }
   }
 }

package/lib/store.js

@@ -1,6 +1,7 @@
 import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
 import { homedir } from 'node:os'
 import path from 'node:path'
+import { todayISO, yearOptions } from './exam-dates.js'
 
 /** Bump when the persisted shape changes incompatibly. */
 export const DATA_VERSION = 1
@@ -27,7 +28,7 @@ export function emptyData() {
     updatedAt: now,
     settings: {
       /** 目标考研年份（入学年份），例如 2028 表示 2028 年入学。 */
-      targetYear: defaultTargetYear(),
+      targetYear: yearOptions()[0],
       /** 已启用科目 id，按用户顺序排列。 */
       subjects: [],
       /** 科目 id -> 'online' | 'bank' | 'auto' */
@@ -54,12 +55,6 @@ export function emptyData() {
   }
 }
 
-/** 默认目标年份：若 12 月考试尚未过去则取今年入学，否则取明年。 */
-function defaultTargetYear() {
-  const now = new Date()
-  return now.getMonth() >= 11 ? now.getFullYear() + 2 : now.getFullYear() + 1
-}
-
 function isPlainObject(value) {
   return value !== null && typeof value === 'object' && !Array.isArray(value)
 }
@@ -85,7 +80,7 @@ function normalize(raw) {
       data.settings[key] = base.settings[key]
     }
   }
-  if (!Number.isFinite(data.settings.targetYear)) data.settings.targetYear = base.settings.targetYear
+  if (!Number.isFinite(raw.settings?.targetYear)) data.settings.targetYear = yearOptions(todayISO(), data.examDates)[0]
   data.version = DATA_VERSION
   return data
 }

package/lib/subjects.js

@@ -22,6 +22,18 @@ export const QUESTION_TYPE_LABEL = {
 /** 选择题类题型（判分依据唯一选项）。完形填空与阅读理解同样按四选一判分。 */
 export const CHOICE_TYPES = new Set(['single', 'multiple', 'cloze', 'reading'])
 
+export function hasChoiceOptions(options) {
+  return Array.isArray(options) && options.length >= 2
+    && options.every((option) => /^[A-H]$/.test(option?.key) && typeof option.text === 'string' && option.text.trim())
+    && new Set(options.map((option) => option.key)).size === options.length
+}
+
+export function validChoiceKey(type, key, options) {
+  return typeof key === 'string' && /^[A-H]+$/.test(key) && (type === 'multiple' || key.length === 1)
+    && new Set(key).size === key.length
+    && [...key].every((letter) => options?.some((option) => option?.key === letter))
+}
+
 export const SUBJECT_CATALOG = [
   {
     id: 'politics',

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "daily-question",
-  "version": "2.1.0",
+  "version": "2.1.1",
   "private": false,
   "type": "module",
   "description": "考研每日一题 — DSH 插件：每科每天一道独立校验过的考研题，含倒计时、错题本、收藏与按题隔离的追问。",