@zhouchangui/math-ati 0.1.0

package/server/practicePaperHtml.js

@@ -0,0 +1,313 @@
+function escapeHtml(value) {
+  return String(value ?? '')
+    .replaceAll('&', '&')
+    .replaceAll('<', '&lt;')
+    .replaceAll('>', '&gt;')
+    .replaceAll('"', '&quot;')
+    .replaceAll("'", '&#39;');
+}
+
+function textHtml(text) {
+  return escapeHtml(text)
+    .replace(/\n{2,}/g, '</p><p>')
+    .replace(/\n/g, '<br />');
+}
+
+function splitMarkdownRow(line) {
+  return line
+    .trim()
+    .replace(/^\|/, '')
+    .replace(/\|$/, '')
+    .split('|')
+    .map((cell) => cell.trim());
+}
+
+function isMarkdownTableSeparator(line) {
+  return /^\s*\|?\s*:?-{3,}:?\s*(\|\s*:?-{3,}:?\s*)+\|?\s*$/.test(line || '');
+}
+
+function markdownTableHtml(lines, startIndex) {
+  if (!lines[startIndex]?.includes('|') || !isMarkdownTableSeparator(lines[startIndex + 1])) {
+    return null;
+  }
+  const header = splitMarkdownRow(lines[startIndex]);
+  const rows = [];
+  let index = startIndex + 2;
+  while (index < lines.length && lines[index].includes('|') && lines[index].trim()) {
+    rows.push(splitMarkdownRow(lines[index]));
+    index += 1;
+  }
+  const headHtml = header.map((cell) => `<th>${escapeHtml(cell)}</th>`).join('');
+  const bodyHtml = rows
+    .map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join('')}</tr>`)
+    .join('');
+  return {
+    html: `<table class="question-table"><thead><tr>${headHtml}</tr></thead><tbody>${bodyHtml}</tbody></table>`,
+    nextIndex: index
+  };
+}
+
+function contentHtml(text) {
+  const lines = String(text || '').split(/\r?\n/);
+  const blocks = [];
+  let paragraph = [];
+  const flushParagraph = () => {
+    if (!paragraph.length) return;
+    blocks.push(`<p>${textHtml(paragraph.join('\n'))}</p>`);
+    paragraph = [];
+  };
+
+  for (let index = 0; index < lines.length;) {
+    const table = markdownTableHtml(lines, index);
+    if (table) {
+      flushParagraph();
+      blocks.push(table.html);
+      index = table.nextIndex;
+      continue;
+    }
+    if (!lines[index].trim()) {
+      flushParagraph();
+      index += 1;
+      continue;
+    }
+    paragraph.push(lines[index]);
+    index += 1;
+  }
+  flushParagraph();
+  return blocks.join('\n');
+}
+
+function figureHtml(question) {
+  const parts = [];
+  if (question.svg) parts.push(`<div class="question-figure">${question.svg}</div>`);
+  if (question.svgPath) parts.push(`<img class="question-image" src="${escapeHtml(question.svgPath)}" alt="题目配图" />`);
+  if (question.imagePath) parts.push(`<img class="question-image" src="${escapeHtml(question.imagePath)}" alt="题目配图" />`);
+  return parts.join('\n');
+}
+
+function answerSpaceLines(question) {
+  const byKind = {
+    choice: 2,
+    blank: 3,
+    short_answer: 6
+  };
+  return Math.max(byKind[question.questionKind] || 5, Number(question.answerSpaceLines || 0));
+}
+
+function paperDisplayTitle(title) {
+  return String(title || '')
+    .replace(/最终版/g, '')
+    .replace(/\s*（第\s*\d+\s*\/\s*\d+\s*批）/g, '')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+}
+
+function listItemsHtml(items) {
+  return (Array.isArray(items) ? items : [])
+    .map((item) => `<li>${contentHtml(item)}</li>`)
+    .join('');
+}
+
+function rubricHtml(rubric) {
+  if (!Array.isArray(rubric) || !rubric.length) return '';
+  return rubric
+    .map((item) => {
+      if (typeof item === 'string') return `<li>${contentHtml(item)}</li>`;
+      const point = item?.point || item?.criterion || item?.description || '';
+      const score = item?.score || item?.points || '';
+      return `<li>${contentHtml(`${point}${score ? `（${score} 分）` : ''}`)}</li>`;
+    })
+    .join('');
+}
+
+function tagText(value) {
+  return String(value ?? '')
+    .replace(/\$\$([^$]+)\$\$/g, '$1')
+    .replace(/\$([^$]+)\$/g, '$1')
+    .replace(/\\\((.*?)\\\)/g, '$1')
+    .replace(/\\\[(.*?)\\\]/g, '$1')
+    .replace(/\\left|\\right/g, '')
+    .replace(/\\frac\{([^{}]+)\}\{([^{}]+)\}/g, '$1/$2')
+    .trim();
+}
+
+function tagsHtml(items) {
+  return (Array.isArray(items) ? items : [])
+    .filter(Boolean)
+    .map((item) => `<span>${escapeHtml(tagText(item))}</span>`)
+    .join('');
+}
+
+function practiceHtmlShell({ title, body, print = true, sheetClass = '' }) {
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>${escapeHtml(title)}</title>
+  <script>
+    (function () {
+      var katexBase = window.location.protocol === 'file:'
+        ? '../../../../node_modules/katex/dist'
+        : '/vendor/katex';
+      document.write('<link rel="stylesheet" href="' + katexBase + '/katex.min.css" />');
+      document.write('<script defer src="' + katexBase + '/katex.min.js"><\\/script>');
+      document.write('<script defer src="' + katexBase + '/contrib/auto-render.min.js"><\\/script>');
+    })();
+  </script>
+  <script>
+    document.addEventListener('DOMContentLoaded', function () {
+      if (!window.renderMathInElement) return;
+      window.renderMathInElement(document.body, {
+        ignoredClasses: ['no-math-render'],
+        delimiters: [
+          { left: '$$', right: '$$', display: true },
+          { left: '$', right: '$', display: false },
+          { left: '\\\\(', right: '\\\\)', display: false },
+          { left: '\\\\[', right: '\\\\]', display: true },
+          { left: '\\\\begin{equation}', right: '\\\\end{equation}', display: true },
+          { left: '\\\\begin{align}', right: '\\\\end{align}', display: true },
+          { left: '\\\\begin{gather}', right: '\\\\end{gather}', display: true }
+        ],
+        throwOnError: false
+      });
+    });
+  </script>
+  <style>
+    :root { color: #17201b; font-family: "PingFang SC", "Microsoft YaHei", Arial, sans-serif; }
+    * { box-sizing: border-box; }
+    body { margin: 0; background: #f5f2eb; }
+    .sheet { width: min(210mm, 100%); min-height: 297mm; margin: 0 auto; padding: 14mm; background: #fffdf7; }
+    .sheet-header { display: flex; justify-content: space-between; gap: 20px; border-bottom: 2px solid #17201b; padding-bottom: 12px; margin-bottom: 14px; }
+    h1 { margin: 0; font-size: 26px; line-height: 1.25; }
+    h2 { margin: 24px 0 12px; font-size: 18px; }
+    p { margin: 0; line-height: 1.75; }
+    .meta { margin-top: 8px; color: #5f6b63; }
+    .questions { column-count: 2; column-gap: 10mm; margin: 0; }
+    .question { break-inside: avoid; page-break-inside: avoid; margin: 0 0 14px; padding-bottom: 12px; }
+    .question-row { display: grid; grid-template-columns: auto minmax(0, 1fr); gap: 6px; align-items: start; }
+    .question-number { font-weight: 700; line-height: 1.75; }
+    .question-body { min-width: 0; }
+    .stem { margin-bottom: 10px; }
+    .stem p { margin: 0 0 8px; }
+    .question-table { width: 100%; border-collapse: collapse; margin: 8px 0 10px; font-size: 14px; }
+    .question-table th, .question-table td { border: 1px solid #9f9689; padding: 6px 8px; text-align: left; vertical-align: top; }
+    .question-table th { background: #f0eadf; font-weight: 700; }
+    .answer-space { min-height: 42px; margin-top: 8px; }
+    .question-figure { margin: 10px 0; }
+    .question-figure svg { max-width: 100%; height: auto; display: block; }
+    .question-image { max-width: 100%; height: auto; display: block; margin: 8px 0; }
+    .answer-card { break-inside: avoid; page-break-inside: avoid; border-bottom: 1px solid #e1dacd; padding: 14px 0; }
+    .answer-card h3 { margin: 0 0 8px; font-size: 16px; }
+    .steps { margin: 8px 0 0; padding-left: 20px; }
+    .steps li { margin: 4px 0; line-height: 1.65; }
+    .answer-questions { margin: 0; }
+    .answer-questions .question { margin-bottom: 18px; padding-bottom: 16px; border-bottom: 1px solid #e1dacd; }
+    .explain-block { display: grid; gap: 8px; margin-top: 10px; padding: 10px 12px; border: 1px solid #ded7ca; border-radius: 6px; background: #fffaf0; }
+    .explain-block h3 { margin: 0; font-size: 15px; }
+    .answer-value { font-weight: 700; }
+    .tag-list { display: flex; flex-wrap: wrap; gap: 6px; }
+    .tag-list span { border: 1px solid #cfc7b9; border-radius: 999px; padding: 2px 8px; font-size: 12px; color: #4f5b54; background: white; }
+    .rubric-list { margin: 0; padding-left: 20px; }
+    .explain-missing { color: #7b665a; }
+    @page { size: A4; margin: 14mm; }
+    @media print {
+      body { background: white; }
+      .sheet { width: 100%; padding: 0; }
+      .questions { column-count: 2; column-gap: 10mm; }
+      ${print ? '.no-print { display: none !important; }' : ''}
+    }
+  </style>
+</head>
+<body>
+  <main class="sheet ${escapeHtml(sheetClass)}">
+${body}
+  </main>
+</body>
+</html>
+`;
+}
+
+export function practiceQuestionsToHtml(practice) {
+  const title = paperDisplayTitle(practice.title);
+  const body = [
+    '    <header class="sheet-header">',
+    '      <div>',
+    `        <h1>${escapeHtml(title)}</h1>`,
+    '      </div>',
+    '    </header>',
+    '    <div class="questions">'
+  ];
+  for (const [index, question] of (practice.questions || []).entries()) {
+    const answerLines = answerSpaceLines(question);
+    body.push(
+      `      <article class="question" data-question-id="${escapeHtml(question.id)}">`,
+      '        <div class="question-row">',
+      `          <span class="question-number">${index + 1}.</span>`,
+      '          <div class="question-body">',
+      `            <div class="stem">${contentHtml(question.stem)}</div>`,
+      figureHtml(question),
+      `            <div class="answer-space" style="min-height:${Math.max(2, answerLines) * 24}px"></div>`,
+      '          </div>',
+      '        </div>',
+      '      </article>'
+    );
+  }
+  body.push('    </div>');
+  return practiceHtmlShell({ title, body: body.filter(Boolean).join('\n') });
+}
+
+export function practiceAnswersToHtml(practice) {
+  const title = paperDisplayTitle(practice.title);
+  const body = [
+    '    <header class="sheet-header">',
+    '      <div>',
+    `        <h1>${escapeHtml(title)} 讲解版</h1>`,
+    `        <p class="meta">${(practice.questions || []).length} 题 · 含标准答案、解题步骤和知识点</p>`,
+    '      </div>',
+    '    </header>'
+  ];
+  body.push('    <div class="answer-questions">');
+  for (const [index, question] of (practice.questions || []).entries()) {
+    const knowledgeTags = tagsHtml(question.knowledgePoints?.length ? question.knowledgePoints : question.knowledgePointIds);
+    const errorTags = tagsHtml(question.expectedErrorTypes);
+    const steps = listItemsHtml(question.solutionSteps);
+    const rubric = rubricHtml(question.rubric);
+    const hasExplanation = question.answer || steps || knowledgeTags || rubric;
+    body.push(
+      `      <article class="question" data-question-id="${escapeHtml(question.id)}">`,
+      '        <div class="question-row">',
+      `          <span class="question-number">${index + 1}.</span>`,
+      '          <div class="question-body">',
+      `            <div class="stem">${contentHtml(question.stem)}</div>`,
+      figureHtml(question),
+      '            <section class="explain-block">',
+      '          <h3>标准答案</h3>',
+      hasExplanation && question.answer
+        ? `          <div class="answer-value">${contentHtml(question.answer)}</div>`
+        : '          <p class="explain-missing">这份旧试卷没有生成阶段答案；新生成试卷会包含标准答案和元数据。</p>',
+      steps
+        ? `          <h3>解题过程</h3><ol class="steps">${steps}</ol>`
+        : '',
+      knowledgeTags
+        ? `          <h3>覆盖知识点</h3><div class="tag-list no-math-render">${knowledgeTags}</div>`
+        : '',
+      errorTags
+        ? `          <h3>易错点</h3><div class="tag-list no-math-render">${errorTags}</div>`
+        : '',
+      rubric
+        ? `          <h3>批改要点</h3><ul class="rubric-list">${rubric}</ul>`
+        : '',
+      '            </section>',
+      '          </div>',
+      '        </div>',
+      '      </article>'
+    );
+  }
+  body.push('    </div>');
+  return practiceHtmlShell({
+    title: `${title} 讲解版`,
+    body: body.filter(Boolean).join('\n'),
+    sheetClass: 'explain-sheet'
+  });
+}

package/server/practiceReviewer.js

@@ -0,0 +1,307 @@
+import path from 'node:path';
+import { chapterDataPaths, readJson } from './fileStore.js';
+
+const typeProfiles = {
+  knowledge_coverage: {
+    label: '知识点覆盖',
+    allowedDifficulties: ['basic', 'medium'],
+    requiredBasicRatio: 0.65,
+    intent: '按章节知识点字典逐项覆盖，帮助判断哪些知识点已经接触、掌握或需要复习。'
+  },
+  foundation: {
+    label: '知识点覆盖',
+    allowedDifficulties: ['basic', 'medium'],
+    requiredBasicRatio: 0.6,
+    intent: '巩固核心概念、基本计算、基本变形，不追求综合难题。'
+  },
+  mistake_repair: {
+    label: '错因修复',
+    allowedDifficulties: ['basic', 'medium'],
+    requiredBasicRatio: 0.5,
+    intent: '围绕历史错因和预期错因生成同类变式，避免无关拓展。'
+  },
+  ability_assessment: {
+    label: '能力评估',
+    allowedDifficulties: ['basic', 'medium'],
+    requiredBasicRatio: 0.75,
+    intent: '围绕章节启用能力生成短题、多题、低语境的能力诊断卷。'
+  },
+  mastery_check: {
+    label: '达标检测',
+    allowedDifficulties: ['basic', 'medium', 'challenge'],
+    requiredBasicRatio: 0.35,
+    intent: '覆盖核心知识点，允许少量综合题，用于判断是否达标。'
+  }
+};
+
+function normalizeText(text) {
+  return String(text || '')
+    .replace(/\$[^$]*\$/g, (match) => match.replace(/\s+/g, ''))
+    .replace(/\s+/g, '')
+    .replace(/[，。！？,.!?；;：:（）()]/g, '')
+    .toLowerCase();
+}
+
+function similarity(a, b) {
+  const leftText = normalizeText(a);
+  const rightText = normalizeText(b);
+  if (leftText === rightText) return 1;
+  const ngrams = (text) => {
+    const grams = [];
+    for (let index = 0; index < text.length - 1; index += 1) {
+      grams.push(text.slice(index, index + 2));
+    }
+    return grams.length ? grams : [text];
+  };
+  const left = new Set(ngrams(leftText));
+  const right = new Set(ngrams(rightText));
+  if (!left.size || !right.size) return 0;
+  let overlap = 0;
+  for (const char of left) {
+    if (right.has(char)) overlap += 1;
+  }
+  return (2 * overlap) / (left.size + right.size);
+}
+
+async function recentPracticeQuestions(chapterId, limit = 30) {
+  try {
+    const fs = await import('node:fs/promises');
+    const practiceDir = chapterDataPaths(chapterId).practices;
+    const files = (await fs.readdir(practiceDir))
+      .filter((file) => file.endsWith('.json'))
+      .map((file) => path.join(practiceDir, file))
+      .sort()
+      .reverse();
+    const questions = [];
+    for (const file of files) {
+      if (questions.length >= limit) break;
+      try {
+        const practice = await readJson(file);
+        if (practice.chapterId === chapterId) {
+          questions.push(...practice.questions.map((question) => ({
+            practiceId: practice.id,
+            stem: question.stem
+          })));
+        }
+      } catch {
+        // Ignore partial files.
+      }
+    }
+    return questions.slice(0, limit);
+  } catch {
+    return [];
+  }
+}
+
+function duplicateFindings(questions, historicalQuestions) {
+  const findings = [];
+  const seen = [];
+  for (const question of questions) {
+    const normalized = normalizeText(question.stem);
+    if (seen.some((item) => item.normalized === normalized || similarity(item.stem, question.stem) > 0.92)) {
+      findings.push({
+        level: 'blocker',
+        type: 'duplicate_in_sheet',
+        questionId: question.id,
+        message: '本卷内题目高度重复。'
+      });
+    }
+    const historical = historicalQuestions.find((item) => similarity(item.stem, question.stem) > 0.9);
+    if (historical) {
+      findings.push({
+        level: 'warning',
+        type: 'duplicate_history',
+        questionId: question.id,
+        message: `与历史练习 ${historical.practiceId} 中的题目接近。`
+      });
+    }
+    seen.push({ stem: question.stem, normalized });
+  }
+  return findings;
+}
+
+function personalizationFindings(practice, options) {
+  const profile = typeProfiles[options.type] ?? typeProfiles.foundation;
+  const findings = [];
+  const allKnowledgeIds = (options.knowledgeDoc?.sections || [])
+    .flatMap((section) => section.points || [])
+    .map((point) => point.id)
+    .filter(Boolean);
+  const scopedIds = Array.isArray(options.knowledgePointIds) && options.knowledgePointIds.length
+    ? options.knowledgePointIds
+    : options.knowledgePointId
+      ? [options.knowledgePointId]
+      : allKnowledgeIds;
+  const knowledgeIds = new Set(scopedIds);
+  const enabledAbilityIds = new Set(Array.isArray(options.abilityIds) ? options.abilityIds : []);
+  const coveredIds = new Set();
+  const total = practice.questions.length || 1;
+  const basicCount = practice.questions.filter((question) => question.difficulty === 'basic').length;
+  const basicRatio = basicCount / total;
+  const requiredBasicRatio = scopedIds.length && scopedIds.length <= 5
+    ? Math.min(profile.requiredBasicRatio, 0.4)
+    : profile.requiredBasicRatio;
+  if (basicRatio < requiredBasicRatio) {
+    findings.push({
+      level: 'warning',
+      type: 'difficulty_mix',
+      message: `${profile.label} 的基础题比例不足。`
+    });
+  }
+  for (const question of practice.questions) {
+    if (!profile.allowedDifficulties.includes(question.difficulty)) {
+      findings.push({
+        level: 'warning',
+        type: 'difficulty_out_of_scope',
+        questionId: question.id,
+        message: `${profile.label} 中出现了不推荐难度：${question.difficulty}。`
+      });
+    }
+    if (!question.knowledgePoints?.length) {
+      findings.push({
+        level: 'blocker',
+        type: 'missing_knowledge_point',
+        questionId: question.id,
+        message: '题目缺少知识点标签。'
+      });
+    }
+    if (!question.knowledgePointIds?.length) {
+      findings.push({
+        level: 'blocker',
+        type: 'missing_knowledge_point_id',
+        questionId: question.id,
+        message: '题目缺少知识点 ID，无法回写掌握状态。'
+      });
+    }
+    for (const pointId of question.knowledgePointIds || []) {
+      coveredIds.add(pointId);
+      if (knowledgeIds.size && !knowledgeIds.has(pointId)) {
+        findings.push({
+          level: 'blocker',
+          type: 'unknown_knowledge_point_id',
+          questionId: question.id,
+          message: `题目引用了知识点字典中不存在的 ID：${pointId}。`
+        });
+      }
+    }
+    if (!question.expectedErrorTypes?.length) {
+      findings.push({
+        level: 'warning',
+        type: 'missing_error_type',
+        questionId: question.id,
+        message: '题目缺少预期错因标签。'
+      });
+    }
+    if (options.type === 'ability_assessment') {
+      if (!question.abilityIds?.length) {
+        findings.push({
+          level: 'blocker',
+          type: 'missing_ability_id',
+          questionId: question.id,
+          message: '能力评估题缺少能力 ID，无法回写能力状态。'
+        });
+      }
+      for (const abilityId of question.abilityIds || []) {
+        if (!enabledAbilityIds.has(abilityId)) {
+          findings.push({
+            level: 'blocker',
+            type: 'unknown_ability_id',
+            questionId: question.id,
+            message: `题目引用了本章未启用的能力 ID：${abilityId}。`
+          });
+        }
+      }
+      if (!question.skillAtoms?.length) {
+        findings.push({
+          level: 'warning',
+          type: 'missing_skill_atom',
+          questionId: question.id,
+          message: '能力评估题缺少计算技能原子标签。'
+        });
+      }
+      if (!question.expectedAbilityErrors?.length) {
+        findings.push({
+          level: 'warning',
+          type: 'missing_ability_error',
+          questionId: question.id,
+          message: '能力评估题缺少预期能力错误标签。'
+        });
+      }
+    }
+  }
+  if ((options.type === 'knowledge_coverage' || options.type === 'foundation') && knowledgeIds.size) {
+    const expectedCoverage = options.adaptiveQuestionCount
+      ? Math.min(knowledgeIds.size, Math.max(practice.questions.length, Math.ceil(practice.questions.length * 2)))
+      : knowledgeIds.size > 20
+        ? Math.min(knowledgeIds.size, Math.ceil(practice.questions.length * 3))
+        : Math.min(knowledgeIds.size, practice.questions.length);
+    const coverageCount = [...coveredIds].filter((id) => knowledgeIds.has(id)).length;
+    if (coverageCount < expectedCoverage) {
+      findings.push({
+        level: 'warning',
+        type: 'knowledge_coverage_gap',
+        message: `知识点覆盖不足：应覆盖约 ${expectedCoverage} 个，当前覆盖 ${coverageCount} 个。`
+      });
+    }
+  }
+  return findings;
+}
+
+function makeSummary(findings, options, historicalQuestions) {
+  const blockers = findings.filter((item) => item.level === 'blocker').length;
+  const warnings = findings.filter((item) => item.level === 'warning').length;
+  const profile = typeProfiles[options.type] ?? typeProfiles.foundation;
+  return {
+    passed: blockers === 0,
+    blockers,
+    warnings,
+    mode: profile.label,
+    intent: profile.intent,
+    historicalCompared: historicalQuestions.length,
+    coverage: coverageSummary(options, findings),
+    findings
+  };
+}
+
+function coverageSummary(options, findings) {
+  const points = (options.knowledgeDoc?.sections || []).flatMap((section) =>
+    (section.points || []).map((point) => ({
+      id: point.id,
+      title: point.title,
+      section: section.title
+    }))
+  );
+  const scopedIds = Array.isArray(options.knowledgePointIds) && options.knowledgePointIds.length
+    ? new Set(options.knowledgePointIds)
+    : options.knowledgePointId
+      ? new Set([options.knowledgePointId])
+      : null;
+  const scopedPoints = scopedIds
+    ? points.filter((point) => scopedIds.has(point.id))
+    : points;
+  const coveredIds = new Set();
+  for (const finding of findings) {
+    if (finding.type === 'unknown_knowledge_point_id') continue;
+  }
+  for (const question of options.practiceQuestions || []) {
+    for (const pointId of question.knowledgePointIds || []) coveredIds.add(pointId);
+  }
+  const covered = scopedPoints.filter((point) => coveredIds.has(point.id));
+  const missing = scopedPoints.filter((point) => !coveredIds.has(point.id));
+  return {
+    total: scopedPoints.length,
+    covered: covered.length,
+    coveredPointIds: covered.map((point) => point.id),
+    missingPointIds: missing.map((point) => point.id)
+  };
+}
+
+export async function reviewPractice(practice, options) {
+  const historicalQuestions = await recentPracticeQuestions(practice.chapterId);
+  const reviewOptions = { ...options, practiceQuestions: practice.questions };
+  const findings = [
+    ...duplicateFindings(practice.questions, historicalQuestions),
+    ...personalizationFindings(practice, reviewOptions)
+  ];
+  return makeSummary(findings, reviewOptions, historicalQuestions);
+}