@zhouchangui/math-ati 0.1.2 → 0.1.4

package/server/coveragePlanner.js

@@ -0,0 +1,174 @@
+export const COVERAGE_DURATION_CONFIGS = {
+  15: {
+    targetMinutes: 15,
+    questionCount: 6,
+    questionRange: [5, 6],
+    newPointCapacity: 7,
+    reviewRatio: 0.3
+  },
+  25: {
+    targetMinutes: 25,
+    questionCount: 9,
+    questionRange: [8, 10],
+    newPointCapacity: 11,
+    reviewRatio: 0.25
+  },
+  35: {
+    targetMinutes: 35,
+    questionCount: 13,
+    questionRange: [11, 14],
+    newPointCapacity: 16,
+    reviewRatio: 0.2
+  }
+};
+
+function normalizeDuration(durationMinutes = 25) {
+  const value = Number(durationMinutes);
+  return COVERAGE_DURATION_CONFIGS[value] ? value : 25;
+}
+
+function chunkBalanced(items, chunkCount) {
+  if (chunkCount <= 1) return [items];
+  const chunks = [];
+  let cursor = 0;
+  for (let index = 0; index < chunkCount; index += 1) {
+    const remainingItems = items.length - cursor;
+    const remainingChunks = chunkCount - index;
+    const size = Math.ceil(remainingItems / remainingChunks);
+    chunks.push(items.slice(cursor, cursor + size));
+    cursor += size;
+  }
+  return chunks.filter((chunk) => chunk.length);
+}
+
+function uniqueById(points) {
+  const seen = new Set();
+  const result = [];
+  for (const point of points) {
+    if (!point?.id || seen.has(point.id)) continue;
+    seen.add(point.id);
+    result.push(point);
+  }
+  return result;
+}
+
+function rotatePick(points, count, offset = 0) {
+  const unique = uniqueById(points);
+  if (!unique.length || count <= 0) return [];
+  const picked = [];
+  for (let index = 0; index < unique.length && picked.length < count; index += 1) {
+    picked.push(unique[(offset + index) % unique.length]);
+  }
+  return picked;
+}
+
+function reviewPick({ completedPoints, recentPoints, mistakePoints, count, paperIndex }) {
+  if (count <= 0) return [];
+  const prioritized = uniqueById([
+    ...mistakePoints.filter((point) => completedPoints.some((done) => done.id === point.id)),
+    ...recentPoints,
+    ...completedPoints
+  ]);
+  return rotatePick(prioritized, count, paperIndex);
+}
+
+function pointIdList(points) {
+  return uniqueById(points).map((point) => point.id);
+}
+
+export function buildCoverageSchedule({
+  chapterId,
+  durationMinutes = 25,
+  targetPoints = [],
+  includeMistakes = false,
+  now = new Date()
+} = {}) {
+  const duration = normalizeDuration(durationMinutes);
+  const config = COVERAGE_DURATION_CONFIGS[duration];
+  const points = uniqueById(targetPoints).filter((point) => point.id);
+  const totalPoints = points.length;
+  if (!totalPoints) {
+    const error = new Error('coverage_plan_no_points');
+    error.status = 422;
+    throw error;
+  }
+
+  const basePaperCount = Math.max(1, Math.ceil(totalPoints / config.newPointCapacity));
+  const newChunks = chunkBalanced(points, basePaperCount);
+  const mistakePoints = points.filter((point) => /易错|错题|错误|mistake/i.test(point.section || ''));
+  const papers = [];
+  const completedPoints = [];
+  for (let index = 0; index < newChunks.length; index += 1) {
+    const newPoints = newChunks[index];
+    const reviewCount = index === 0 ? 0 : Math.max(1, Math.round(newPoints.length * config.reviewRatio));
+    const recentPoints = completedPoints.slice(-config.newPointCapacity);
+    const reviewPoints = reviewPick({
+      completedPoints,
+      recentPoints,
+      mistakePoints,
+      count: reviewCount,
+      paperIndex: index
+    });
+    papers.push({
+      paperNo: papers.length + 1,
+      mode: 'new_coverage',
+      targetMinutes: config.targetMinutes,
+      questionCount: config.questionCount,
+      questionRange: config.questionRange,
+      newPointIds: pointIdList(newPoints),
+      reviewPointIds: pointIdList(reviewPoints),
+      targetPointIds: pointIdList([...newPoints, ...reviewPoints]),
+      expectedNewCoverageCount: newPoints.length,
+      expectedTotalCoverageCount: uniqueById([...newPoints, ...reviewPoints]).length,
+      repeatPolicy: index === 0
+        ? '首张卷优先建立新覆盖，不安排复习点。'
+        : '复习点来自最近覆盖点、易错专项或高关联前置点；允许少量重复巩固。'
+    });
+    completedPoints.push(...newPoints);
+  }
+
+  if (basePaperCount > 1) {
+    const reviewCount = Math.min(
+      config.newPointCapacity,
+      Math.max(Math.ceil(config.newPointCapacity * 0.75), mistakePoints.length)
+    );
+    const reviewPoints = uniqueById([
+      ...mistakePoints,
+      ...rotatePick(points, reviewCount, papers.length)
+    ]).slice(0, reviewCount);
+    papers.push({
+      paperNo: papers.length + 1,
+      mode: 'review_gap',
+      targetMinutes: config.targetMinutes,
+      questionCount: config.questionCount,
+      questionRange: config.questionRange,
+      newPointIds: [],
+      reviewPointIds: pointIdList(reviewPoints),
+      targetPointIds: pointIdList(reviewPoints),
+      expectedNewCoverageCount: 0,
+      expectedTotalCoverageCount: reviewPoints.length,
+      repeatPolicy: '查漏巩固卷只安排复习点，优先易错专项、近期覆盖点和跨组关联点。'
+    });
+  }
+
+  return {
+    planId: `coverage-plan-${now.toISOString().replace(/[:.]/g, '-')}`,
+    chapterId,
+    strategy: 'first_round_coverage_with_review',
+    durationMinutes: config.targetMinutes,
+    durationConfig: config,
+    includeMistakes: Boolean(includeMistakes),
+    totalKnowledgePointCount: totalPoints,
+    basePaperCount,
+    reviewPaperCount: papers.filter((paper) => paper.mode === 'review_gap').length,
+    totalPaperCount: papers.length,
+    createdAt: now.toISOString(),
+    coveragePolicy: {
+      newPointCapacity: config.newPointCapacity,
+      reviewRatio: config.reviewRatio,
+      questionCount: config.questionCount,
+      rule: '按章节知识点数和单次练习时长排程；前几张卷做首轮覆盖，末张卷查漏巩固；允许有意识重复，但每张卷控制在目标分钟数内。'
+    },
+    papers
+  };
+}

package/server/fileStore.js

@@ -1,4 +1,4 @@
-import { access, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
+import { access, copyFile, mkdir, readFile, readdir, rm, writeFile } from 'node:fs/promises';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import {
@@ -175,9 +175,16 @@ export async function ensureChapterWorkspace(chapter) {
 
   const folderPath = path.join(paths.imageRoot, chapter.imageFolder);
   const sourceFiles = await listSourcePageImages(folderPath);
+  // source_pages/ holds the chapter's local source-page copies (see AGENTS.md).
+  // When the manifest is stale and no local copies exist, copy the images from
+  // the shared imageRoot into source_pages/ so chapterImages can resolve them.
+  await Promise.all(sourceFiles.map((file) => copyFile(
+    path.join(folderPath, file),
+    path.join(chapterPaths.sourcePages, file)
+  )));
   await writeJson(
     chapterPaths.sourceManifest,
-    buildSourceManifest(chapter, chapterPaths, sourceFiles, folderPath)
+    buildSourceManifest(chapter, chapterPaths, sourceFiles, chapterPaths.sourcePages)
   );
   return chapterPaths;
 }
@@ -331,14 +338,14 @@ export async function syncGlobalIndexes() {
   const legacyMistakes = await readJson(paths.mistakes, []);
   const ids = await chapterIdsWithData(chapters);
   const masteryIndex = {
-    student: '周子烊',
+    student: '学生',
     version: 1,
     updatedAt: new Date().toISOString(),
     source: 'chapter-masteries',
     chapters: {}
   };
   const mistakesIndex = {
-    student: '周子烊',
+    student: '学生',
     version: 1,
     updatedAt: new Date().toISOString(),
     source: 'chapter-mistakes',
@@ -503,7 +510,8 @@ function normalizeKnowledgeDoc(chapter, doc, source = 'seed') {
       formulas: Array.isArray(point.formulas) ? point.formulas : [],
       pitfalls: Array.isArray(point.pitfalls) ? point.pitfalls : [],
       examples: Array.isArray(point.examples) ? point.examples : [],
-      questionTemplates: Array.isArray(point.questionTemplates) ? point.questionTemplates : []
+      questionTemplates: Array.isArray(point.questionTemplates) ? point.questionTemplates : [],
+      sources: Array.isArray(point.sources) ? point.sources : []
     }))
   })).filter((section) => section.points.length);
   return {
@@ -517,9 +525,40 @@ function normalizeKnowledgeDoc(chapter, doc, source = 'seed') {
   };
 }
 
+function markdownSection(markdown, title) {
+  const lines = String(markdown || '').split(/\r?\n/);
+  const start = lines.findIndex((line) => new RegExp(`^##\\s+${title}\\s*$`).test(line.trim()));
+  if (start < 0) return '';
+  const end = lines.findIndex((line, index) => index > start && /^##\s+/.test(line.trim()));
+  return lines.slice(start + 1, end < 0 ? undefined : end).join('\n').trim();
+}
+
+function markdownHeadingTitles(sectionText) {
+  return String(sectionText || '')
+    .split(/\r?\n/)
+    .map((line) => line.match(/^###\s+(.+?)\s*$/)?.[1]?.trim())
+    .filter(Boolean);
+}
+
+function parsePageExtractMarkdown(markdown, fallback = {}) {
+  const pageTitle = markdownSection(markdown, '页面标题').split(/\r?\n/).find(Boolean) || fallback.imageFile || '';
+  const knowledgeTitles = markdownHeadingTitles(markdownSection(markdown, '知识点'));
+  const mistakeTitles = markdownHeadingTitles(markdownSection(markdown, '易错点'));
+  return {
+    pageTitle: pageTitle.replace(/^#+\s*/, '').trim(),
+    rawOutline: markdownSection(markdown, '原文结构')
+      .split(/\r?\n/)
+      .map((line) => line.replace(/^\s*-\s*/, '').trim())
+      .filter(Boolean),
+    knowledgePoints: knowledgeTitles.map((title) => ({ title })),
+    easyMistakes: mistakeTitles.map((title) => ({ title, errorType: title })),
+    markdown
+  };
+}
+
 function buildInitialMastery(chapters, knowledgeDocs, existing = null) {
   const next = {
-    student: '周子烊',
+    student: '学生',
     version: 1,
     updatedAt: new Date().toISOString(),
     chapters: existing?.chapters || {}
@@ -638,11 +677,12 @@ export async function getKnowledgeBundle(chapterId = null) {
   const summary = await readJson(chapterPaths.knowledgeSummary, null);
   const pageExtracts = sourceManifest?.pages
     ? await Promise.all(sourceManifest.pages.map(async (page, index) => {
-      const extractFile = `${path.basename(page.file, path.extname(page.file))}.json`;
+      const extractFile = `${path.basename(page.file, path.extname(page.file))}.md`;
       const extractPath = path.join(chapterPaths.pageExtracts, extractFile);
-      const extract = await readJson(extractPath, null);
+      const markdown = await readText(extractPath, '');
+      const extract = markdown ? parsePageExtractMarkdown(markdown, { imageFile: page.file }) : null;
       return extract
-        ? { ...extract, extractPath: relativeDataPath(extractPath) }
+        ? { chapterId, imageFile: page.file, pageIndex: index + 1, ...extract, extractPath: relativeDataPath(extractPath) }
         : {
           chapterId,
           imageFile: page.file,

package/server/index.js

@@ -53,6 +53,18 @@ const port = Number(process.env.PORT || 4173);
 
 await seedChaptersFromManifest();
 
+function safeGenerationCacheKey(value, fallback) {
+  const key = String(value || '').trim();
+  if (/^ui-[a-zA-Z0-9_.-]{8,120}$/.test(key)) return key;
+  return fallback;
+}
+
+async function practiceGenerationCacheDir({ chapterId, cacheKey }) {
+  const dir = path.join(chapterDataPaths(chapterId).context, 'generation-cache', cacheKey);
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+
 app.use(express.json({ limit: '2mb' }));
 app.use('/chapter-images', express.static(paths.imageRoot));
 app.use('/chapter-data', express.static(paths.chapterData));
@@ -140,6 +152,54 @@ app.put('/api/profile', async (req, res, next) => {
   }
 });
 
+// ── First-time setup ────────────────────────────────────────────────
+
+app.get('/api/setup/status', async (req, res, next) => {
+  try {
+    const profile = await readJson(paths.profile, null).catch(() => null);
+    const needsSetup = !profile?.setupCompletedAt;
+    res.json({ needsSetup });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/setup', async (req, res, next) => {
+  try {
+    const body = req.body || {};
+    const profileFields = body.profile || {};
+    const llm = body.llm || {};
+
+    // Save profile with setup completion marker
+    const current = await readJson(paths.profile, {}).catch(() => ({}));
+    const profile = {
+      ...current,
+      name: String(profileFields.name || current.name || '学生').trim(),
+      gender: String(profileFields.gender || current.gender || '').trim(),
+      age: Number.isFinite(Number(profileFields.age)) ? Number(profileFields.age) : current.age || 14,
+      stage: String(profileFields.stage || current.stage || '').trim(),
+      primaryGoal: String(profileFields.primaryGoal || current.primaryGoal || '').trim(),
+      priorityTrack: String(profileFields.priorityTrack || current.priorityTrack || '').trim(),
+      preferences: String(profileFields.preferences || current.preferences || '').trim(),
+      profileNotes: String(profileFields.profileNotes || current.profileNotes || '').trim(),
+      setupCompletedAt: new Date().toISOString(),
+      updatedAt: new Date().toISOString()
+    };
+    await writeJson(paths.profile, profile);
+
+    // Save LLM settings
+    await writeLlmSettings({
+      baseUrl: llm.baseUrl,
+      model: llm.model,
+      apiKey: llm.apiKey
+    });
+
+    res.json({ ok: true });
+  } catch (error) {
+    next(error);
+  }
+});
+
 app.get('/api/settings/llm', async (req, res, next) => {
   try {
     res.json(await readLlmSettings());
@@ -282,7 +342,10 @@ app.post('/api/practices/generate', async (req, res, next) => {
       knowledgePointId: req.body.knowledgePointId || '',
       knowledgePointIds: Array.isArray(req.body.knowledgePointIds) ? req.body.knowledgePointIds : [],
       abilityIds: Array.isArray(req.body.abilityIds) ? req.body.abilityIds : [],
-      questionKind: req.body.questionKind || 'auto'
+      questionKind: req.body.questionKind || 'auto',
+      verifySvgFigures: Boolean(req.body.verifySvgFigures),
+      requireSvg: Boolean(req.body.requireSvg),
+      minSvgQuestions: req.body.minSvgQuestions
     });
     console.log(
       `[practice.generated] ${practice.id} chapter=${practice.chapterId} questions=${practice.questions.length} source=${practice.source} review=${practice.review?.passed ? 'pass' : 'fail'}` +
@@ -302,6 +365,15 @@ app.post('/api/jobs/practice-generate', async (req, res, next) => {
       try {
         startJob(job.id);
         addJobEvent(job.id, { step: 'practice_generate.start', message: '正在生成练习卷。' });
+        const generationCacheKey = safeGenerationCacheKey(req.body.generationCacheKey, `ui-${job.id}`);
+        const generationCacheDir = await practiceGenerationCacheDir({
+          chapterId: req.body.chapterId,
+          cacheKey: generationCacheKey
+        });
+        addJobEvent(job.id, {
+          step: 'practice_generate.cache_ready',
+          message: `阶段缓存已启用：${path.basename(generationCacheDir)}。失败后重试会复用已完成阶段。`
+        });
         const practice = await createPractice({
           chapterId: req.body.chapterId,
           type: req.body.type || 'knowledge_coverage',
@@ -312,6 +384,11 @@ app.post('/api/jobs/practice-generate', async (req, res, next) => {
           knowledgePointIds: Array.isArray(req.body.knowledgePointIds) ? req.body.knowledgePointIds : [],
           abilityIds: Array.isArray(req.body.abilityIds) ? req.body.abilityIds : [],
           questionKind: req.body.questionKind || 'auto',
+          generationCacheDir,
+          fastReview: Boolean(req.body.fastReview),
+          verifySvgFigures: Boolean(req.body.verifySvgFigures),
+          requireSvg: Boolean(req.body.requireSvg),
+          minSvgQuestions: req.body.minSvgQuestions,
           onProgress: (event) => addJobEvent(job.id, event)
         });
         addJobEvent(job.id, { step: 'practice_generate.done', message: `练习卷生成完成，共 ${practice.questions.length} 题。` });