@zhouchangui/math-ati 0.1.0

package/server/jobStore.js

@@ -0,0 +1,169 @@
+import { randomUUID } from 'node:crypto';
+
+const jobs = new Map();
+
+function publicJob(job) {
+  return {
+    id: job.id,
+    type: job.type,
+    status: job.status,
+    createdAt: job.createdAt,
+    updatedAt: job.updatedAt,
+    progress: job.progress,
+    events: job.events.slice(-20),
+    result: job.result,
+    error: job.error,
+    submissionId: job.submissionId,
+    practiceId: job.practiceId,
+    chapterId: job.chapterId
+  };
+}
+
+export function createJob({ type, practiceId = null, chapterId = null, submissionId = null } = {}) {
+  const job = {
+    id: `job-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`,
+    type,
+    practiceId,
+    chapterId,
+    submissionId,
+    status: 'queued',
+    progress: { message: '任务已创建，等待开始。' },
+    events: [],
+    result: null,
+    error: null,
+    listeners: new Set(),
+    createdAt: new Date().toISOString(),
+    updatedAt: new Date().toISOString()
+  };
+  jobs.set(job.id, job);
+  return publicJob(job);
+}
+
+export function getJob(jobId) {
+  const job = jobs.get(jobId);
+  return job ? publicJob(job) : null;
+}
+
+export function getJobInternal(jobId) {
+  return jobs.get(jobId) || null;
+}
+
+export function updateJob(jobId, patch = {}) {
+  const job = jobs.get(jobId);
+  if (!job) return null;
+  Object.assign(job, patch, { updatedAt: new Date().toISOString() });
+  if (patch.progress) {
+    job.events.push({
+      ts: new Date().toISOString(),
+      ...patch.progress
+    });
+  }
+  broadcastJob(job);
+  return publicJob(job);
+}
+
+export function addJobEvent(jobId, event) {
+  const job = jobs.get(jobId);
+  if (!job) return null;
+  const nextEvent = {
+    ts: new Date().toISOString(),
+    ...event
+  };
+  job.progress = nextEvent;
+  job.events.push(nextEvent);
+  job.updatedAt = new Date().toISOString();
+  broadcastJob(job);
+  return nextEvent;
+}
+
+export function completeJob(jobId, result) {
+  const job = jobs.get(jobId);
+  if (!job) return null;
+  job.status = 'done';
+  job.result = result;
+  job.progress = {
+    ts: new Date().toISOString(),
+    step: 'job.done',
+    message: '任务完成。'
+  };
+  job.events.push(job.progress);
+  job.updatedAt = new Date().toISOString();
+  broadcastJob(job);
+  closeJob(job);
+  return publicJob(job);
+}
+
+export function failJob(jobId, error) {
+  const job = jobs.get(jobId);
+  if (!job) return null;
+  job.status = 'failed';
+  job.error = {
+    message: error?.message || String(error),
+    reason: error?.reason || null,
+    detail: error?.detail || null,
+    status: error?.status || null,
+    stack: error?.stack || null
+  };
+  job.progress = {
+    ts: new Date().toISOString(),
+    step: 'job.failed',
+    message: `任务失败：${job.error.message}${job.error.detail ? `（${job.error.detail}` : ''}${job.error.detail ? '）' : ''}`
+  };
+  job.events.push(job.progress);
+  job.updatedAt = new Date().toISOString();
+  broadcastJob(job);
+  closeJob(job);
+  return publicJob(job);
+}
+
+export function startJob(jobId) {
+  return updateJob(jobId, {
+    status: 'running',
+    progress: {
+      step: 'job.running',
+      message: '任务开始执行。'
+    }
+  });
+}
+
+export function subscribeJob(jobId, res) {
+  const job = jobs.get(jobId);
+  if (!job) return false;
+  job.listeners.add(res);
+  for (const event of job.events.slice(-20)) {
+    sendSse(res, event);
+  }
+  sendSse(res, {
+    step: 'job.snapshot',
+    message: job.progress?.message || '任务状态已同步。',
+    job: publicJob(job)
+  });
+  res.on('close', () => {
+    job.listeners.delete(res);
+  });
+  return true;
+}
+
+function sendSse(res, event) {
+  res.write(`data: ${JSON.stringify(event)}\n\n`);
+}
+
+function broadcastJob(job) {
+  const event = {
+    ...job.progress,
+    job: publicJob(job)
+  };
+  for (const res of job.listeners) sendSse(res, event);
+}
+
+function closeJob(job) {
+  for (const res of job.listeners) {
+    sendSse(res, {
+      step: 'job.closed',
+      message: '任务连接结束。',
+      job: publicJob(job)
+    });
+    res.end();
+  }
+  job.listeners.clear();
+}

package/server/knowledgeBase.js

@@ -0,0 +1,30 @@
+export function flattenKnowledgePoints(knowledgeDoc) {
+  return knowledgeDoc.sections.flatMap((section) =>
+    section.points.map((point) => ({
+      ...point,
+      sectionTitle: section.title
+    }))
+  );
+}
+
+export function knowledgeToMarkdown(chapter, knowledgeDoc) {
+  const lines = [`# ${chapter.fullTitle} 知识点文档`, ''];
+  for (const section of knowledgeDoc.sections) {
+    lines.push(`## ${section.title}`, '');
+    for (const point of section.points) {
+      lines.push(`### ${point.title}`, '');
+      lines.push(point.summary, '');
+      if (point.formulas?.length) {
+        lines.push('**公式/定律**', '');
+        for (const formula of point.formulas) lines.push(`- ${formula}`);
+        lines.push('');
+      }
+      if (point.pitfalls?.length) {
+        lines.push('**易错点**', '');
+        for (const pitfall of point.pitfalls) lines.push(`- ${pitfall}`);
+        lines.push('');
+      }
+    }
+  }
+  return `${lines.join('\n').trim()}\n`;
+}

package/server/knowledgeExtractor.js

@@ -0,0 +1,360 @@
+import { readdir } from 'node:fs/promises';
+import path from 'node:path';
+import { callChatAgent, callVisionAgent } from './agentClient.js';
+import {
+  chapterDataPaths,
+  ensureChapterDataDirs,
+  ensureChapterWorkspace,
+  paths,
+  readJson,
+  resetChapterLearningLoop,
+  saveKnowledgeDoc,
+  writeJson
+} from './fileStore.js';
+import { promptPayload, readPrompt } from './promptStore.js';
+
+function extractionDir(chapterId) {
+  return chapterDataPaths(chapterId).pageExtracts;
+}
+
+function pageExtractPath(chapterId, imageFile) {
+  return path.join(extractionDir(chapterId), `${path.basename(imageFile, path.extname(imageFile))}.json`);
+}
+
+function summaryPath(chapterId) {
+  return chapterDataPaths(chapterId).knowledgeSummary;
+}
+
+async function chapterImages(chapter) {
+  const folderPath = path.join(paths.imageRoot, chapter.imageFolder);
+  const files = (await readdir(folderPath))
+    .filter((file) => /\.(png|jpe?g|webp)$/i.test(file))
+    .sort();
+  return files.map((file) => path.join(folderPath, file));
+}
+
+function normalizeExtractProfile(profile = {}) {
+  const detailLevels = new Set(['exam_focus', 'balanced', 'fine_grained']);
+  const baselines = new Set(['strong', 'normal', 'weak']);
+  const allowedFocus = new Set(['exam_points', 'error_prone', 'prerequisite_gaps', 'calculation_links']);
+  const focus = Array.isArray(profile.focus)
+    ? profile.focus.filter((item) => allowedFocus.has(item))
+    : [];
+  return {
+    detailLevel: detailLevels.has(profile.detailLevel) ? profile.detailLevel : 'exam_focus',
+    studentBaseline: baselines.has(profile.studentBaseline) ? profile.studentBaseline : 'strong',
+    focus: focus.length ? focus : ['exam_points', 'error_prone'],
+    displayLayer: profile.displayLayer === 'fine_grained_wall' ? 'fine_grained_wall' : 'exam_point_wall'
+  };
+}
+
+function normalizePageExtract(chapter, imagePath, pageIndex, data, source = 'agent') {
+  const points = Array.isArray(data?.knowledgePoints) ? data.knowledgePoints : [];
+  const mistakes = Array.isArray(data?.easyMistakes) ? data.easyMistakes : [];
+  return {
+    chapterId: chapter.id,
+    chapterTitle: chapter.fullTitle,
+    imageFile: path.basename(imagePath),
+    pageIndex,
+    source,
+    extractedAt: new Date().toISOString(),
+    pageTitle: data?.pageTitle || '',
+    rawOutline: Array.isArray(data?.rawOutline) ? data.rawOutline : [],
+    knowledgePoints: points.map((point, index) => ({
+      title: point.title || `知识点 ${index + 1}`,
+      summary: point.summary || '',
+      formulas: Array.isArray(point.formulas) ? point.formulas : [],
+      examples: Array.isArray(point.examples) ? point.examples : [],
+      prerequisite: point.prerequisite || '',
+      difficulty: point.difficulty || 'basic'
+    })),
+    easyMistakes: mistakes.map((mistake) => ({
+      title: mistake.title || mistake.errorType || '易错点',
+      errorType: mistake.errorType || mistake.title || '易错点',
+      description: mistake.description || '',
+      correction: mistake.correction || ''
+    })),
+    exerciseHints: Array.isArray(data?.exerciseHints) ? data.exerciseHints : []
+  };
+}
+
+function knowledgeExtractionError(reason, detail = '') {
+  const error = new Error(`knowledge_extraction_failed:${reason}`);
+  error.status = 502;
+  error.reason = reason;
+  error.detail = detail;
+  return error;
+}
+
+export async function extractChapterPage({ chapter, imagePath, pageIndex, force = false, extractProfile = null }) {
+  await ensureChapterWorkspace(chapter);
+  const outputPath = pageExtractPath(chapter.id, imagePath);
+  if (!force) {
+    const existing = await readJson(outputPath, null);
+    if (existing) return existing;
+  }
+  const systemPrompt = await readPrompt('knowledge-extract.system.md');
+  const agent = await callVisionAgent({
+    timeoutMs: 60000,
+    system: systemPrompt,
+    text: promptPayload({
+      task: '从这一页提分笔记图片中逐项提取知识点、公式、例题线索和易错点。',
+      context: {
+        chapter: {
+          id: chapter.id,
+          title: chapter.fullTitle,
+          track: chapter.track
+        },
+        extractProfile: normalizeExtractProfile(extractProfile || {})
+      },
+      requirements: [
+        'knowledgePoints 要覆盖页面出现的每个概念、性质、公式、方法或题型。',
+        'easyMistakes 要提取页面明确写出的易错点，也可以从页面中的提醒、比较、条件限制中归纳，但不能凭空添加。',
+        'summary 用学生能懂的短句；公式必须使用 $...$。',
+        'exerciseHints 只写题型方向，不写完整答案。'
+      ],
+      schema: {
+        pageTitle: 'string',
+        rawOutline: ['string'],
+        knowledgePoints: [{
+          title: 'string',
+          summary: 'string',
+          formulas: ['string with LaTeX'],
+          examples: ['short example or expression'],
+          prerequisite: 'string',
+          difficulty: 'basic|medium|challenge'
+        }],
+        easyMistakes: [{
+          title: 'string',
+          errorType: 'string',
+          description: 'string',
+          correction: 'string'
+        }],
+        exerciseHints: ['string']
+      }
+    }),
+    imagePaths: [imagePath]
+  });
+  if (!agent.ok) {
+    throw knowledgeExtractionError(agent.reason || 'agent_failed', agent.detail || '');
+  }
+  const extract = normalizePageExtract(chapter, imagePath, pageIndex, agent.data, 'agent');
+  await writeJson(outputPath, extract);
+  await writeJson(path.join(paths.knowledgeExtracts, chapter.id, `${path.basename(imagePath, path.extname(imagePath))}.json`), extract);
+  return extract;
+}
+
+function dedupeByTitle(items) {
+  const seen = new Map();
+  for (const item of items) {
+    const key = String(item.title || item.errorType || '').replace(/\s+/g, '');
+    if (!key) continue;
+    if (!seen.has(key)) {
+      seen.set(key, { ...item });
+    } else {
+      const current = seen.get(key);
+      current.summary ||= item.summary;
+      current.description ||= item.description;
+      current.formulas = [...new Set([...(current.formulas || []), ...(item.formulas || [])])];
+      current.examples = [...new Set([...(current.examples || []), ...(item.examples || [])])].slice(0, 6);
+      current.sources = [...new Set([...(current.sources || []), ...(item.sources || [])])];
+    }
+  }
+  return [...seen.values()];
+}
+
+function localMergeChapter(chapter, pageExtracts) {
+  const points = dedupeByTitle(pageExtracts.flatMap((page) =>
+    page.knowledgePoints.map((point) => ({
+      ...point,
+      sources: [page.imageFile]
+    }))
+  ));
+  const mistakes = dedupeByTitle(pageExtracts.flatMap((page) =>
+    page.easyMistakes.map((mistake) => ({
+      ...mistake,
+      sources: [page.imageFile]
+    }))
+  ));
+  return {
+    sections: [
+      {
+        title: '知识点覆盖',
+        points: points.map((point, index) => ({
+          id: `${chapter.id}-kp-${String(index + 1).padStart(2, '0')}`,
+          title: point.title,
+          summary: point.summary || '从章节图片提取，待人工复核完善。',
+          formulas: point.formulas || [],
+          pitfalls: mistakes
+            .filter((mistake) => mistake.description?.includes(point.title) || mistake.title?.includes(point.title))
+            .map((mistake) => mistake.errorType)
+            .slice(0, 4),
+          examples: point.examples || [],
+          questionTemplates: [
+            [
+              `围绕「${point.title}」完成一道基础覆盖题，并写出关键结论。`,
+              point.summary || '答案需符合知识点定义、公式或方法。',
+              point.title
+            ]
+          ],
+          sources: point.sources || []
+        }))
+      },
+      {
+        title: '易错题专项',
+        points: mistakes.map((mistake, index) => ({
+          id: `${chapter.id}-mistake-${String(index + 1).padStart(2, '0')}`,
+          title: mistake.title || mistake.errorType,
+          summary: mistake.description || mistake.errorType,
+          formulas: [],
+          pitfalls: [mistake.errorType || mistake.title].filter(Boolean),
+          examples: [],
+          questionTemplates: [
+            [
+              `针对易错点「${mistake.errorType || mistake.title}」设计一道辨析或改错题。`,
+              mistake.correction || '指出错误原因并给出正确做法。',
+              mistake.errorType || mistake.title
+            ]
+          ],
+          sources: mistake.sources || []
+        }))
+      }
+    ].filter((section) => section.points.length)
+  };
+}
+
+export async function summarizeChapterExtraction({
+  chapter,
+  pageExtracts,
+  extractProfile = null,
+  resetLearningState = false
+}) {
+  const local = localMergeChapter(chapter, pageExtracts);
+  const normalizedProfile = normalizeExtractProfile(extractProfile || {});
+  const systemPrompt = await readPrompt('knowledge-summarize.system.md');
+  const agent = await callChatAgent({
+    timeoutMs: 60000,
+    temperature: 0.1,
+    system: systemPrompt,
+    user: promptPayload({
+      task: '把逐页提取结果合并成章节知识文档，并做覆盖检查。',
+      context: {
+        chapter,
+        pageExtracts,
+        localDraft: local,
+        extractProfile: normalizedProfile
+      },
+      requirements: [
+        '合并同义知识点，保留来源页。',
+        normalizedProfile.detailLevel === 'fine_grained'
+          ? '当前提取画像要求细粒度拆分：保留必要前置概念、步骤性方法和基础易错点。'
+          : '当前提取画像要求考点优先：优先保留考试常见考点、易错点、变式边界和必要前置关系，不把教材说明拆得过碎。',
+        'sections 至少包含“知识点覆盖”；如果有易错点，单独包含“易错题专项”。',
+        '每个知识点必须有 id、title、summary、formulas、pitfalls、questionTemplates。',
+        'questionTemplates 用于后续出题，题干只写题目，不写解题过程。',
+        'review.missingOrWeak 列出疑似遗漏或需要人工复核的点。'
+      ],
+      schema: {
+        sections: [{
+          title: '知识点覆盖',
+          points: [{
+            id: `${chapter.id}-kp-01`,
+            title: 'string',
+            summary: 'string',
+            formulas: ['string with LaTeX'],
+            pitfalls: ['string'],
+            examples: ['string'],
+            questionTemplates: [['stem', 'answer', 'expectedErrorType']],
+            sources: ['image filename']
+          }]
+        }],
+        review: {
+          passed: true,
+          coverageSummary: 'string',
+          missingOrWeak: ['string'],
+          duplicateMerged: ['string']
+        }
+      }
+    })
+  });
+  if (!agent.ok || !Array.isArray(agent.data?.sections)) {
+    throw knowledgeExtractionError(agent.reason || 'invalid_agent_response', agent.detail || '');
+  }
+  const merged = agent.data;
+  const extractedAt = new Date().toISOString();
+  const normalized = await saveKnowledgeDoc(chapter, merged, 'agent', {
+    extractProfile: normalizedProfile,
+    extractorVersion: 1,
+    extractedAt,
+    resetLearningState
+  });
+  const summary = {
+    chapterId: chapter.id,
+    chapterTitle: chapter.fullTitle,
+    source: 'agent',
+    pageCount: pageExtracts.length,
+    updatedAt: extractedAt,
+    extractProfile: normalizedProfile,
+    extractorVersion: 1,
+    review: merged.review || null,
+    knowledgePointCount: normalized.sections.reduce((sum, section) => sum + section.points.length, 0)
+  };
+  await writeJson(summaryPath(chapter.id), summary);
+  await writeJson(path.join(paths.knowledgeExtracts, chapter.id, 'summary.json'), summary);
+  const reset = resetLearningState ? await resetChapterLearningLoop(chapter.id) : null;
+  return { knowledge: normalized, summary, reset };
+}
+
+export async function extractChapterKnowledge({
+  chapterId,
+  limitPages = 0,
+  force = false,
+  extractProfile = null,
+  resetLearningState = false
+} = {}) {
+  const chapters = await readJson(paths.chapters, []);
+  const selected = chapterId ? chapters.filter((chapter) => chapter.id === chapterId) : chapters;
+  const results = [];
+  const normalizedProfile = normalizeExtractProfile(extractProfile || {});
+  for (const chapter of selected) {
+    const images = await chapterImages(chapter);
+    const scopedImages = limitPages > 0 ? images.slice(0, limitPages) : images;
+    const pageExtracts = [];
+    for (let index = 0; index < scopedImages.length; index += 1) {
+      pageExtracts.push(await extractChapterPage({
+        chapter,
+        imagePath: scopedImages[index],
+        pageIndex: index + 1,
+        force,
+        extractProfile: normalizedProfile
+      }));
+    }
+    results.push(await summarizeChapterExtraction({
+      chapter,
+      pageExtracts,
+      extractProfile: normalizedProfile,
+      resetLearningState
+    }));
+  }
+  return results;
+}
+
+export async function extractKnowledgeFromImages({ chapterId, imagePaths, force = false } = {}) {
+  const chapters = await readJson(paths.chapters, []);
+  const chapter = chapters.find((item) => item.id === chapterId);
+  if (!chapter) {
+    const error = new Error('chapter_not_found');
+    error.status = 404;
+    throw error;
+  }
+  const pageExtracts = [];
+  for (let index = 0; index < imagePaths.length; index += 1) {
+    pageExtracts.push(await extractChapterPage({
+      chapter,
+      imagePath: imagePaths[index],
+      pageIndex: index + 1,
+      force
+    }));
+  }
+  return summarizeChapterExtraction({ chapter, pageExtracts });
+}