@zhouchangui/math-ati 0.1.0

package/server/index.js

@@ -0,0 +1,655 @@
+import './env.js';
+import express from 'express';
+import multer from 'multer';
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { mkdir, readdir } from 'node:fs/promises';
+import {
+  ensureDataDirs,
+  paths,
+  readJson,
+  seedChaptersFromManifest,
+  getKnowledgeBundle,
+  readChapterMistakes,
+  writeJson,
+  chapterDataPaths
+} from './fileStore.js';
+import { gradeSubmission } from './grading.js';
+import { extractChapterKnowledge } from './knowledgeExtractor.js';
+import { buildChapterAbilities, syncAbilityIndex, syncChapterAbilities } from './abilityService.js';
+import {
+  buildGeneratedCoverage,
+  createPractice,
+  ensurePracticeHtml,
+  practiceSummary,
+  readPractice,
+  syncGeneratedCoverage,
+  updatePracticeStatus
+} from './practiceService.js';
+import { gradePdfSubmission } from './pdfSubmissionGrader.js';
+import {
+  addJobEvent,
+  completeJob,
+  createJob,
+  failJob,
+  getJob,
+  getJobInternal,
+  startJob,
+  subscribeJob,
+  updateJob
+} from './jobStore.js';
+import {
+  confirmSubmission,
+  deleteSubmission,
+  readSubmission,
+  writeSubmissionMirrors
+} from './submissionService.js';
+import { weakPointsFromMistakes } from './mistakeLifecycle.js';
+import { readLlmSettings, writeLlmSettings } from './llmConfig.js';
+
+const app = express();
+const port = Number(process.env.PORT || 4173);
+
+await seedChaptersFromManifest();
+
+app.use(express.json({ limit: '2mb' }));
+app.use('/chapter-images', express.static(paths.imageRoot));
+app.use('/chapter-data', express.static(paths.chapterData));
+app.use('/vendor/katex', express.static(path.join(paths.rootDir, 'node_modules/katex/dist')));
+
+const upload = multer({
+  storage: multer.diskStorage({
+    async destination(req, file, callback) {
+      const submissionId = req.params.submissionId || `upload-${Date.now()}`;
+      const submission = await readSubmission(submissionId).catch(() => null);
+      if (!submission?.chapterId) {
+        callback(new Error(`submission_not_found:${submissionId}`));
+        return;
+      }
+      const dir = path.join(chapterDataPaths(submission.chapterId).submissions, submissionId, 'photos');
+      await mkdir(dir, { recursive: true });
+      callback(null, dir);
+    },
+    filename(req, file, callback) {
+      const ext = path.extname(file.originalname) || '.jpg';
+      callback(null, `${Date.now()}-${randomUUID()}${ext}`);
+    }
+  })
+});
+
+const pdfUpload = multer({
+  storage: multer.diskStorage({
+    async destination(req, file, callback) {
+      const practice = await readPractice(req.params.id);
+      const submissionId = `submission-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
+      req.createdSubmissionId = submissionId;
+      req.pdfPractice = practice;
+      const dir = path.join(chapterDataPaths(practice.chapterId).submissions, submissionId, 'source');
+      await mkdir(dir, { recursive: true });
+      callback(null, dir);
+    },
+    filename(req, file, callback) {
+      callback(null, 'submission.pdf');
+    }
+  }),
+  fileFilter(req, file, callback) {
+    if (file.mimetype === 'application/pdf' || /\.pdf$/i.test(file.originalname)) {
+      callback(null, true);
+    } else {
+      callback(new Error('only_pdf_supported'));
+    }
+  },
+  limits: { fileSize: 50 * 1024 * 1024 }
+});
+
+async function refreshAbilityStateAfterLearningReset(chapterId, didReset) {
+  if (!didReset) return;
+  await syncChapterAbilities(chapterId);
+  await syncAbilityIndex();
+}
+
+app.get('/api/profile', async (req, res, next) => {
+  try {
+    res.json(await readJson(paths.profile));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.put('/api/profile', async (req, res, next) => {
+  try {
+    const current = await readJson(paths.profile);
+    const body = req.body || {};
+    const updated = {
+      ...current,
+      name: String(body.name || current.name || '').trim(),
+      gender: String(body.gender || current.gender || '').trim(),
+      age: Number.isFinite(Number(body.age)) ? Number(body.age) : current.age,
+      stage: String(body.stage || current.stage || '').trim(),
+      primaryGoal: String(body.primaryGoal || current.primaryGoal || '').trim(),
+      priorityTrack: String(body.priorityTrack || current.priorityTrack || '').trim(),
+      preferences: String(body.preferences || current.preferences || '').trim(),
+      profileNotes: String(body.profileNotes || current.profileNotes || '').trim(),
+      updatedAt: new Date().toISOString()
+    };
+    await writeJson(paths.profile, updated);
+    res.json(updated);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/settings/llm', async (req, res, next) => {
+  try {
+    res.json(await readLlmSettings());
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.put('/api/settings/llm', async (req, res, next) => {
+  try {
+    const body = req.body || {};
+    res.json(await writeLlmSettings({
+      baseUrl: body.baseUrl,
+      model: body.model,
+      apiKey: body.apiKey,
+      clearApiKey: body.clearApiKey
+    }));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/chapters', async (req, res, next) => {
+  try {
+    res.json(await readJson(paths.chapters, []));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/knowledge', async (req, res, next) => {
+  try {
+    res.json(await getKnowledgeBundle());
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/knowledge/:chapterId', async (req, res, next) => {
+  try {
+    res.json(await getKnowledgeBundle(req.params.chapterId));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/knowledge/:chapterId/extract', async (req, res, next) => {
+  try {
+    const limitPages = Math.max(0, Math.min(50, Number(req.body.limitPages || 0)));
+    const resetLearningState = Boolean(req.body.resetLearningState);
+    const result = await extractChapterKnowledge({
+      chapterId: req.params.chapterId,
+      limitPages,
+      force: Boolean(req.body.force),
+      extractProfile: req.body.extractProfile || req.body.profile || {},
+      resetLearningState
+    });
+    await refreshAbilityStateAfterLearningReset(req.params.chapterId, resetLearningState);
+    res.json(result[0]);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/jobs/knowledge-extract', async (req, res, next) => {
+  try {
+    const chapterId = req.body.chapterId;
+    const job = createJob({ type: 'knowledge-extract', chapterId });
+    res.json(job);
+    queueMicrotask(async () => {
+      try {
+        startJob(job.id);
+        addJobEvent(job.id, { step: 'knowledge_extract.start', message: '正在提取章节知识点。' });
+        if (req.body.resetLearningState) {
+          addJobEvent(job.id, {
+            step: 'knowledge_extract.reset_pending',
+            message: '重新提取完成后会清空本章练习、批改、薄弱点和能力评估状态。'
+          });
+        }
+        const result = await extractChapterKnowledge({
+          chapterId,
+          limitPages: Math.max(0, Math.min(50, Number(req.body.limitPages || 0))),
+          force: Boolean(req.body.force),
+          extractProfile: req.body.extractProfile || req.body.profile || {},
+          resetLearningState: Boolean(req.body.resetLearningState)
+        });
+        await refreshAbilityStateAfterLearningReset(chapterId, Boolean(req.body.resetLearningState));
+        addJobEvent(job.id, { step: 'knowledge_extract.done', message: '章节知识点提取完成。' });
+        completeJob(job.id, result[0]);
+      } catch (error) {
+        failJob(job.id, error);
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/practices', async (req, res, next) => {
+  try {
+    await ensureDataDirs();
+    const practices = [];
+    const chapterDirs = (await readdir(paths.chapterData, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name);
+    for (const chapterId of chapterDirs) {
+      const chapterPaths = chapterDataPaths(chapterId);
+      const files = (await readdir(chapterPaths.practices))
+        .filter((file) => file.endsWith('.json'));
+      for (const file of files) {
+        const practice = await ensurePracticeHtml(await readJson(path.join(chapterPaths.practices, file)));
+        practices.push(practiceSummary(practice));
+      }
+    }
+    res.json(practices
+      .sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt)))
+      .slice(0, 50));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/practices/:id', async (req, res, next) => {
+  try {
+    res.json(await readPractice(req.params.id));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/practices/generate', async (req, res, next) => {
+  try {
+    const practice = await createPractice({
+      chapterId: req.body.chapterId,
+      type: req.body.type || 'knowledge_coverage',
+      questionCount: req.body.questionCount,
+      difficulty: req.body.difficulty || '基础巩固',
+      includeMistakes: Boolean(req.body.includeMistakes),
+      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'
+    });
+    console.log(
+      `[practice.generated] ${practice.id} chapter=${practice.chapterId} questions=${practice.questions.length} source=${practice.source} review=${practice.review?.passed ? 'pass' : 'fail'}` +
+        (practice.agentReason ? ` reason=${practice.agentReason}` : '')
+    );
+    res.json(practice);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/jobs/practice-generate', async (req, res, next) => {
+  try {
+    const job = createJob({ type: 'practice-generate', chapterId: req.body.chapterId });
+    res.json(job);
+    queueMicrotask(async () => {
+      try {
+        startJob(job.id);
+        addJobEvent(job.id, { step: 'practice_generate.start', message: '正在生成练习卷。' });
+        const practice = await createPractice({
+          chapterId: req.body.chapterId,
+          type: req.body.type || 'knowledge_coverage',
+          questionCount: req.body.questionCount,
+          difficulty: req.body.difficulty || '基础巩固',
+          includeMistakes: Boolean(req.body.includeMistakes),
+          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',
+          onProgress: (event) => addJobEvent(job.id, event)
+        });
+        addJobEvent(job.id, { step: 'practice_generate.done', message: `练习卷生成完成，共 ${practice.questions.length} 题。` });
+        updateJob(job.id, { practiceId: practice.id });
+        completeJob(job.id, practice);
+      } catch (error) {
+        failJob(job.id, error);
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/jobs/:jobId', (req, res) => {
+  const job = getJob(req.params.jobId);
+  if (!job) return res.status(404).json({ error: 'job_not_found' });
+  res.json(job);
+});
+
+app.get('/api/jobs/:jobId/events', (req, res) => {
+  res.writeHead(200, {
+    'Content-Type': 'text/event-stream',
+    'Cache-Control': 'no-cache, no-transform',
+    Connection: 'keep-alive'
+  });
+  const ok = subscribeJob(req.params.jobId, res);
+  if (!ok) {
+    res.write(`data: ${JSON.stringify({ step: 'job.not_found', message: '任务不存在。' })}\n\n`);
+    res.end();
+  }
+});
+
+app.get('/api/chapters/:chapterId/practices', async (req, res, next) => {
+  try {
+    const chapterPaths = chapterDataPaths(req.params.chapterId);
+    const files = (await readdir(chapterPaths.practices))
+      .filter((file) => file.endsWith('.json'))
+      .sort()
+      .reverse();
+    const practices = [];
+    for (const file of files) {
+      const practice = await readJson(path.join(chapterPaths.practices, file));
+      if (req.query.type && practice.type !== req.query.type) continue;
+      practices.push(practiceSummary(await ensurePracticeHtml(practice)));
+    }
+    res.json(practices.slice(0, Number(req.query.limit || 50)));
+  } catch (error) {
+    if (error.code === 'ENOENT') return res.json([]);
+    next(error);
+  }
+});
+
+app.get('/api/chapters/:chapterId/generated-coverage', async (req, res, next) => {
+  try {
+    res.json(await buildGeneratedCoverage(req.params.chapterId));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/chapters/:chapterId/abilities', async (req, res, next) => {
+  try {
+    res.json(await buildChapterAbilities(req.params.chapterId));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/chapters/:chapterId/submissions', async (req, res, next) => {
+  try {
+    const chapterPaths = chapterDataPaths(req.params.chapterId);
+    const entries = (await readdir(chapterPaths.submissions, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name)
+      .sort()
+      .reverse();
+    const submissions = [];
+    for (const id of entries) {
+      const metadata = await readJson(path.join(chapterPaths.submissions, id, 'metadata.json'), null);
+      if (metadata) submissions.push(metadata);
+    }
+    res.json(submissions.slice(0, Number(req.query.limit || 50)));
+  } catch (error) {
+    if (error.code === 'ENOENT') return res.json([]);
+    next(error);
+  }
+});
+
+app.get('/api/chapters/:chapterId/weak-points', async (req, res, next) => {
+  try {
+    const mistakes = await readChapterMistakes(req.params.chapterId);
+    res.json(weakPointsFromMistakes(mistakes, {
+      includeResolved: req.query.includeResolved === 'true'
+    }));
+  } catch (error) {
+    if (error.code === 'ENOENT') return res.json([]);
+    next(error);
+  }
+});
+
+app.post('/api/practices/:id/submissions', async (req, res, next) => {
+  try {
+    const practice = await readPractice(req.params.id);
+    const id = `submission-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
+    const submission = {
+      id,
+      practiceId: practice.id,
+      chapterId: practice.chapterId,
+      status: 'created',
+      notes: req.body.notes || '',
+      photoPaths: [],
+      gradingResult: null,
+      parentConfirmed: false,
+      createdAt: new Date().toISOString()
+    };
+    await writeSubmissionMirrors(submission);
+    res.json(submission);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/practices/:id/printed', async (req, res, next) => {
+  try {
+    res.json(await updatePracticeStatus(req.params.id, 'printed'));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/practices/:id/previewed', async (req, res, next) => {
+  try {
+    res.json(await updatePracticeStatus(req.params.id, 'previewed'));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/practices/:id/pdf-submissions', pdfUpload.single('pdf'), async (req, res, next) => {
+  try {
+    const practice = req.pdfPractice || await readPractice(req.params.id);
+    const submissionId = req.createdSubmissionId;
+    const job = createJob({
+      type: 'pdf-grade',
+      practiceId: practice.id,
+      chapterId: practice.chapterId,
+      submissionId
+    });
+    res.json({ ...job, submissionId });
+    queueMicrotask(async () => {
+      try {
+        startJob(job.id);
+        const result = await gradePdfSubmission({
+          practiceId: practice.id,
+          pdfPath: req.file.path,
+          notes: req.body.notes || '',
+          autoArchive: false,
+          submissionId,
+          useAgent: true,
+          maxRechecks: Math.max(0, Number(req.body.maxRechecks || 12)),
+          gradingBatchSize: Math.max(1, Number(req.body.gradingBatchSize || 5)),
+          onProgress: (event) => addJobEvent(job.id, event)
+        });
+        updateJob(job.id, { submissionId: result.submission.id });
+        completeJob(job.id, result);
+      } catch (error) {
+        try {
+          const submission = await readSubmission(submissionId);
+          await writeSubmissionMirrors({
+            ...submission,
+            status: 'failed_grade',
+            gradingResult: null,
+            error: {
+              message: error.message,
+              reason: error.reason || null,
+              detail: error.detail || null,
+              status: error.status || null
+            },
+            failedAt: new Date().toISOString()
+          });
+          updateJob(job.id, { submissionId });
+        } catch (submissionError) {
+          addJobEvent(job.id, {
+            stage: 'submission.fail_write_failed',
+            message: `批改失败状态写入失败：${submissionError.message}`
+          });
+        }
+        failJob(job.id, error);
+      }
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/submissions/:submissionId/photos', upload.array('photos', 8), async (req, res, next) => {
+  try {
+    const submission = await readSubmission(req.params.submissionId);
+    const practice = await readPractice(submission.practiceId);
+    const profile = await readJson(paths.profile);
+    const files = req.files || [];
+    const photoPaths = files.map((file) => file.path);
+    const gradingResult = await gradeSubmission({
+      practice,
+      profile,
+      files,
+      notes: req.body.notes || submission.notes || ''
+    });
+    const updated = {
+      ...submission,
+      notes: req.body.notes || submission.notes || '',
+      photoPaths,
+      gradingResult,
+      status: 'graded',
+      gradedAt: new Date().toISOString()
+    };
+    await writeSubmissionMirrors(updated);
+    console.log(`[submission.graded] ${submission.id} practice=${practice.id} photos=${files.length} source=${gradingResult.source}`);
+    res.json(updated);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/submissions/:id', async (req, res, next) => {
+  try {
+    res.json(await readSubmission(req.params.id));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.delete('/api/submissions/:id', async (req, res, next) => {
+  try {
+    res.json(await deleteSubmission(req.params.id));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/submissions/:id/artifacts', async (req, res, next) => {
+  try {
+    const submission = await readSubmission(req.params.id);
+    res.json(submission.artifactPaths || {});
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/submissions/:id/artifacts/:name', async (req, res, next) => {
+  try {
+    const submission = await readSubmission(req.params.id);
+    const filePath = submission.artifactPaths?.[req.params.name];
+    if (!filePath) return res.status(404).json({ error: 'artifact_not_found' });
+    res.sendFile(path.join(paths.rootDir, filePath));
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.post('/api/submissions/:id/confirm', async (req, res, next) => {
+  try {
+    const updated = await confirmSubmission({
+      submissionId: req.params.id,
+      grading: req.body.grading,
+      parentSummary: req.body.parentSummary || ''
+    });
+    console.log(`[submission.archived] ${updated.id} accuracy=${updated.accuracy}`);
+    res.json(updated);
+  } catch (error) {
+    next(error);
+  }
+});
+
+app.get('/api/archive', async (req, res, next) => {
+  try {
+    const fs = await import('node:fs/promises');
+    const practices = await readJson(paths.chapters, []);
+    const submissionFiles = [];
+    try {
+      const chapterDirs = (await fs.readdir(paths.chapterData, { withFileTypes: true }))
+        .filter((entry) => entry.isDirectory())
+        .map((entry) => entry.name);
+      for (const chapterId of chapterDirs) {
+        const dir = chapterDataPaths(chapterId).submissions;
+        try {
+          const ids = (await fs.readdir(dir, { withFileTypes: true }))
+            .filter((entry) => entry.isDirectory())
+            .map((entry) => entry.name);
+          submissionFiles.push(...ids.map((id) => path.join(dir, id, 'metadata.json')));
+        } catch {
+          // Ignore chapters without submissions.
+        }
+      }
+    } catch {
+      // Ignore missing chapter data dir.
+    }
+    const submissions = [];
+    for (const file of [...new Set(submissionFiles)]) {
+      try {
+        submissions.push(await readJson(file));
+      } catch {
+        // Ignore incomplete upload folders.
+      }
+    }
+    const uniqueSubmissions = [...new Map(submissions.map((item) => [item.id, item])).values()];
+    res.json({
+      chapters: practices,
+      submissions: uniqueSubmissions.sort((a, b) => String(b.createdAt).localeCompare(String(a.createdAt))),
+      mistakes: await readJson(paths.mistakes, []),
+      mastery: (await getKnowledgeBundle()).mastery
+    });
+  } catch (error) {
+    next(error);
+  }
+});
+
+const distDir = path.join(paths.rootDir, 'dist');
+app.use(express.static(distDir));
+app.use((req, res, next) => {
+  const isAssetRoute = ['/api/', '/chapter-images/', '/chapter-data/', '/vendor/']
+    .some((prefix) => req.path.startsWith(prefix));
+  if (req.method !== 'GET' || isAssetRoute) {
+    next();
+    return;
+  }
+  res.sendFile(path.join(distDir, 'index.html'), (error) => {
+    if (error) next();
+  });
+});
+
+app.use((error, req, res, next) => {
+  console.error('[api.error]', error);
+  res.status(error.status || 500).json({
+    error: error.status ? error.message : 'internal_error',
+    message: error.message
+  });
+});
+
+app.listen(port, '127.0.0.1', () => {
+  console.log(`[server.ready] http://127.0.0.1:${port}`);
+});