@zhouchangui/math-ati 0.1.0

package/server/practiceService.js

@@ -0,0 +1,331 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { readFile, readdir, writeFile } from 'node:fs/promises';
+import {
+  chapterDataPaths,
+  ensureChapterDataDirs,
+  ensureChapterWorkspace,
+  ensureDataDirs,
+  getKnowledgeBundle,
+  paths,
+  readJson,
+  writeJson
+} from './fileStore.js';
+import { generatePracticeContent } from './practiceGenerator.js';
+import { reviewPractice } from './practiceReviewer.js';
+import {
+  practiceAnswersToHtml,
+  practiceQuestionsToHtml
+} from './practicePaperHtml.js';
+import { flattenKnowledgePoints } from './knowledgeBase.js';
+import { markRepairPracticeStarted } from './mistakeLifecycle.js';
+import { assertChapterAbilitiesEnabled } from './abilityService.js';
+
+export async function findPracticePath(id) {
+  const fs = await import('node:fs/promises');
+  const chapters = (await fs.readdir(paths.chapterData, { withFileTypes: true }))
+    .filter((entry) => entry.isDirectory())
+    .map((entry) => entry.name);
+  for (const chapterId of chapters) {
+    const candidate = path.join(chapterDataPaths(chapterId).practices, `${id}.json`);
+    if (await readJson(candidate, null)) return candidate;
+  }
+  const error = new Error(`practice_not_found:${id}`);
+  error.status = 404;
+  throw error;
+}
+
+export async function readPractice(id) {
+  return ensurePracticeHtml(await readJson(await findPracticePath(id)));
+}
+
+export async function updatePracticeStatus(id, status) {
+  const filePath = await findPracticePath(id);
+  const practice = await readJson(filePath);
+  if (status === 'printed' && practice.status !== 'previewed' && practice.status !== 'printed') {
+    const error = new Error('practice_must_be_previewed_before_print');
+    error.status = 409;
+    throw error;
+  }
+  const next = {
+    ...practice,
+    status,
+    updatedAt: new Date().toISOString()
+  };
+  if (status === 'previewed' && !next.previewedAt) next.previewedAt = new Date().toISOString();
+  if (status === 'printed' && !next.printedAt) next.printedAt = new Date().toISOString();
+  await writeJson(filePath, next);
+  return next;
+}
+
+function practiceFileUrl(relativePath) {
+  if (!relativePath) return '';
+  if (relativePath.startsWith('data/chapters/')) {
+    return `/chapter-data/${relativePath.slice('data/chapters/'.length)}`;
+  }
+  return '';
+}
+
+function practiceDisplayTitle(title) {
+  return String(title || '')
+    .replace(/最终版/g, '')
+    .replace(/[（(][^）)]*(?:修订版|第\s*\d+(?:\s*\/\s*\d+)?\s*批)[^）)]*[）)]/g, '')
+    .replace(/[（(]\s*[·｜|:：-]*\s*[）)]/g, '')
+    .replace(/修订版/g, '')
+    .replace(/[（(]\s*第\s*\d+\s*\/\s*\d+\s*批\s*[）)]/g, '')
+    .replace(/[（(]\s*第\s*\d+\s*批\s*[）)]/g, '')
+    .replace(/第\s*\d+\s*\/\s*\d+\s*批/g, '')
+    .replace(/第\s*\d+\s*批/g, '')
+    .replace(/[｜|]\s*$/g, '')
+    .replace(/[:：]\s*$/g, '')
+    .replace(/·\s*$/g, '')
+    .replace(/\s+（/g, '（')
+    .replace(/·\s+/g, '·')
+    .replace(/\s{2,}/g, ' ')
+    .trim();
+}
+
+export function practiceSummary(practice) {
+  const knowledgePointIds = [
+    ...new Set((practice.questions || [])
+      .flatMap((question) => Array.isArray(question.knowledgePointIds) ? question.knowledgePointIds : [])
+      .filter(Boolean))
+  ];
+  const abilityIds = [
+    ...new Set([
+      ...(Array.isArray(practice.abilityIds) ? practice.abilityIds : []),
+      ...(practice.questions || [])
+        .flatMap((question) => Array.isArray(question.abilityIds) ? question.abilityIds : [])
+    ].filter(Boolean))
+  ];
+  return {
+    id: practice.id,
+    title: practiceDisplayTitle(practice.title),
+    chapterId: practice.chapterId,
+    chapterTitle: practice.chapterTitle,
+    type: practice.type,
+    createdAt: practice.createdAt,
+    status: practice.status,
+    questionCount: practice.questions?.length || 0,
+    knowledgePointIds,
+    abilityIds,
+    coveragePlan: practice.coveragePlan || null,
+    source: practice.source,
+    htmlPath: practice.htmlPath,
+    answersHtmlPath: practice.answersHtmlPath,
+    htmlUrl: practiceFileUrl(practice.htmlPath),
+    answersHtmlUrl: practiceFileUrl(practice.answersHtmlPath)
+  };
+}
+
+async function readPracticeJsonFiles(chapterId) {
+  const chapterPaths = chapterDataPaths(chapterId);
+  try {
+    const files = (await readdir(chapterPaths.practices))
+      .filter((file) => file.endsWith('.json'))
+      .sort();
+    const practices = [];
+    for (const file of files) {
+      const practice = await readJson(path.join(chapterPaths.practices, file), null);
+      if (practice) practices.push(practice);
+    }
+    return practices;
+  } catch (error) {
+    if (error.code === 'ENOENT') return [];
+    throw error;
+  }
+}
+
+export async function buildGeneratedCoverage(chapterId) {
+  const knowledgeBundle = await getKnowledgeBundle(chapterId);
+  const allPointIds = flattenKnowledgePoints(knowledgeBundle.knowledge || {}).map((point) => point.id);
+  const allPointIdSet = new Set(allPointIds);
+  const practices = (await readPracticeJsonFiles(chapterId))
+    .filter((practice) => practice.type === 'knowledge_coverage');
+  const generatedPointIds = [
+    ...new Set(practices
+      .flatMap((practice) => practice.questions || [])
+      .flatMap((question) => Array.isArray(question.knowledgePointIds) ? question.knowledgePointIds : [])
+      .filter((pointId) => allPointIdSet.has(pointId)))
+  ].sort();
+  const remainingPointIds = allPointIds.filter((pointId) => !generatedPointIds.includes(pointId));
+  return {
+    chapterId,
+    evidenceSource: 'knowledge_coverage_practices',
+    updatedAt: new Date().toISOString(),
+    totalKnowledgePointCount: allPointIds.length,
+    generatedCount: generatedPointIds.length,
+    remainingCount: remainingPointIds.length,
+    practiceCount: practices.length,
+    questionCount: practices.reduce((sum, practice) => sum + (practice.questions?.length || 0), 0),
+    generatedPointIds,
+    remainingPointIds,
+    practices: practices.map((practice) => ({
+      id: practice.id,
+      status: practice.status,
+      createdAt: practice.createdAt,
+      questionCount: practice.questions?.length || 0,
+      knowledgePointIds: [
+        ...new Set((practice.questions || [])
+          .flatMap((question) => Array.isArray(question.knowledgePointIds) ? question.knowledgePointIds : [])
+          .filter((pointId) => allPointIdSet.has(pointId)))
+      ].sort()
+    }))
+  };
+}
+
+export async function syncGeneratedCoverage(chapterId) {
+  const coverage = await buildGeneratedCoverage(chapterId);
+  const chapterPaths = await ensureChapterDataDirs(chapterId);
+  await writeJson(chapterPaths.generatedCoverage, coverage);
+  return coverage;
+}
+
+function shouldRegeneratePracticeHtml(html, answersHtml) {
+  return [
+    !html.includes('katex.min.js') || !answersHtml.includes('katex.min.js'),
+    !html.includes('node_modules/katex/dist') || !answersHtml.includes('node_modules/katex/dist'),
+    !html.includes('column-count: 2'),
+    html.includes('姓名：__________'),
+    html.includes('日期：__________'),
+    html.includes('用时：__________'),
+    !html.includes('data-question-id='),
+    !answersHtml.includes('data-question-id='),
+    answersHtml.includes('批改后生成讲解'),
+    html.includes('border: 1px dashed #cfc7b9'),
+    html.includes('repeating-linear-gradient')
+  ].some(Boolean);
+}
+
+export async function ensurePracticeHtml(practice) {
+  if (!practice?.id || !practice?.chapterId) {
+    const error = new Error('invalid_practice_record');
+    error.status = 422;
+    throw error;
+  }
+  if (!practice.htmlPath || !practice.answersHtmlPath) {
+    const error = new Error(`practice_html_missing:${practice.id}`);
+    error.status = 422;
+    throw error;
+  }
+  const htmlPath = path.join(paths.rootDir, practice.htmlPath);
+  const answersHtmlPath = path.join(paths.rootDir, practice.answersHtmlPath);
+  const [html, answersHtml] = await Promise.all([
+    readFile(htmlPath, 'utf8').catch(() => ''),
+    readFile(answersHtmlPath, 'utf8').catch(() => '')
+  ]);
+  if (shouldRegeneratePracticeHtml(html, answersHtml)) {
+    await writeFile(htmlPath, practiceQuestionsToHtml(practice), 'utf8');
+    await writeFile(answersHtmlPath, practiceAnswersToHtml(practice), 'utf8');
+  }
+  return practice;
+}
+
+export function cleanPracticeOptions(options) {
+  const persisted = { ...options };
+  delete persisted.knowledgeDoc;
+  return persisted;
+}
+
+export async function createPractice({
+  chapterId,
+  type = 'knowledge_coverage',
+  questionCount = null,
+  difficulty = '基础巩固',
+  includeMistakes = false,
+  knowledgePointId = '',
+  knowledgePointIds = [],
+  abilityIds = [],
+  questionKind = 'auto',
+  onProgress = () => {}
+}) {
+  await ensureDataDirs();
+  const profile = await readJson(paths.profile);
+  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;
+  }
+  await ensureChapterWorkspace(chapter);
+  const knowledgeBundle = await getKnowledgeBundle(chapter.id);
+  const scopedKnowledgePointIds = Array.isArray(knowledgePointIds) && knowledgePointIds.length
+    ? knowledgePointIds
+    : knowledgePointId
+      ? [knowledgePointId]
+      : [];
+  const scopedAbilityIds = type === 'ability_assessment'
+    ? await assertChapterAbilitiesEnabled(chapter.id, Array.isArray(abilityIds) ? abilityIds : [])
+    : [];
+  const requestedQuestionCount = Number(questionCount);
+  const hasRequestedQuestionCount = Number.isFinite(requestedQuestionCount) && requestedQuestionCount > 0;
+  const maxQuestionCount = scopedKnowledgePointIds.length === 1
+    ? Math.max(1, Math.min(3, hasRequestedQuestionCount ? requestedQuestionCount : 1))
+    : type === 'mistake_repair'
+      ? Math.max(3, Math.min(30, hasRequestedQuestionCount ? requestedQuestionCount : 8))
+      : Math.max(6, Math.min(24, hasRequestedQuestionCount ? requestedQuestionCount : 18));
+  const adaptiveQuestionCount = !hasRequestedQuestionCount && (type === 'knowledge_coverage' || type === 'mastery_check');
+  const options = {
+    type,
+    questionCount: adaptiveQuestionCount ? null : maxQuestionCount,
+    maxQuestionCount,
+    adaptiveQuestionCount,
+    difficulty,
+    includeMistakes: Boolean(includeMistakes),
+    knowledgePointId: scopedKnowledgePointIds.length === 1 ? scopedKnowledgePointIds[0] : '',
+    knowledgePointIds: scopedKnowledgePointIds,
+    abilityIds: scopedAbilityIds,
+    questionKind,
+    knowledgeDoc: knowledgeBundle.knowledge,
+    mastery: knowledgeBundle.mastery
+  };
+  onProgress({ step: 'practice_generate.context', message: '已读取学生画像、章节知识点和历史练习。' });
+  const content = await generatePracticeContent({ profile, chapter, options, onProgress });
+  const id = `practice-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
+  let practice = {
+    id,
+    chapterId: chapter.id,
+    chapterTitle: chapter.fullTitle,
+    track: chapter.track,
+    type: options.type,
+    options: cleanPracticeOptions(options),
+    abilityIds: scopedAbilityIds,
+    title: content.title,
+    personalizationBasis: content.personalizationBasis,
+    questions: content.questions,
+    coveragePlan: content.coveragePlan || null,
+    source: content.source,
+    agentReason: content.agentReason,
+    createdAt: new Date().toISOString(),
+    status: 'generated'
+  };
+  const structuralReview = await reviewPractice(practice, options);
+  if (!structuralReview.passed) {
+    const error = new Error(`practice_structural_review_failed:${structuralReview.findings.map((item) => item.type).join('|')}`);
+    error.status = 422;
+    error.review = structuralReview;
+    throw error;
+  }
+  practice.review = structuralReview;
+  practice.llmReview = content.llmReview || null;
+  practice.initialLlmReview = content.initialLlmReview || null;
+  practice.structuralReview = structuralReview;
+  practice.revision = content.revision;
+  const chapterPaths = await ensureChapterDataDirs(chapter.id);
+  const chapterPracticePath = path.join(chapterPaths.practices, `${id}.json`);
+  const chapterHtmlPath = path.join(chapterPaths.practices, `${id}.html`);
+  const chapterAnswersHtmlPath = path.join(chapterPaths.practices, `${id}.answers.html`);
+  practice.htmlPath = path.relative(paths.rootDir, chapterHtmlPath);
+  practice.answersHtmlPath = path.relative(paths.rootDir, chapterAnswersHtmlPath);
+  await writeJson(chapterPracticePath, practice);
+  await writeFile(chapterHtmlPath, practiceQuestionsToHtml(practice), 'utf8');
+  await writeFile(chapterAnswersHtmlPath, practiceAnswersToHtml(practice), 'utf8');
+  if (practice.type === 'knowledge_coverage') {
+    await syncGeneratedCoverage(chapter.id);
+  } else if (practice.type === 'mistake_repair') {
+    await markRepairPracticeStarted(practice);
+  }
+  onProgress({ step: 'practice_generate.write', message: '已写入练习 JSON、试卷 HTML 和答案 HTML。' });
+  return practice;
+}

package/server/promptStore.js

@@ -0,0 +1,16 @@
+import { readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { paths } from './fileStore.js';
+
+export async function readPrompt(name) {
+  return readFile(path.join(paths.rootDir, 'prompts', name), 'utf8');
+}
+
+export function promptPayload({ task, context, schema, requirements = [] }) {
+  return JSON.stringify({
+    task,
+    requirements,
+    context,
+    schema
+  });
+}

package/server/submissionService.js

@@ -0,0 +1,184 @@
+import path from 'node:path';
+import { randomUUID } from 'node:crypto';
+import { rm, writeFile } from 'node:fs/promises';
+import {
+  chapterDataPaths,
+  ensureChapterDataDirs,
+  ensureDataDirs,
+  paths,
+  readJson,
+  updateChapterAfterArchive,
+  updateKnowledgeMasteryAfterArchive,
+  writeJson
+} from './fileStore.js';
+import { readPractice } from './practiceService.js';
+import { gradeSubmissionImages } from './grading.js';
+import { updateMistakesAfterArchive } from './mistakeLifecycle.js';
+import { updateAbilitiesAfterArchive } from './abilityService.js';
+
+export function chapterSubmissionPath(chapterId, id) {
+  return path.join(chapterDataPaths(chapterId).submissions, id, 'metadata.json');
+}
+
+export function chapterReportPath(chapterId, id) {
+  return path.join(chapterDataPaths(chapterId).reports, `${id}.md`);
+}
+
+export async function findSubmissionPath(id) {
+  const fs = await import('node:fs/promises');
+  let chapters = [];
+  try {
+    chapters = (await fs.readdir(paths.chapterData, { withFileTypes: true }))
+      .filter((entry) => entry.isDirectory())
+      .map((entry) => entry.name);
+  } catch {
+    chapters = [];
+  }
+  for (const chapterId of chapters) {
+    const candidate = chapterSubmissionPath(chapterId, id);
+    if (await readJson(candidate, null)) return candidate;
+  }
+  const error = new Error(`submission_not_found:${id}`);
+  error.status = 404;
+  throw error;
+}
+
+export async function readSubmission(id) {
+  return readJson(await findSubmissionPath(id));
+}
+
+export async function deleteSubmission(id) {
+  const metadataPath = await findSubmissionPath(id);
+  const submission = await readJson(metadataPath);
+  if (submission?.parentConfirmed || submission?.status === 'archived') {
+    const error = new Error(`confirmed_submission_cannot_delete:${id}`);
+    error.status = 409;
+    throw error;
+  }
+  await rm(path.dirname(metadataPath), { recursive: true, force: true });
+  return {
+    deleted: true,
+    submissionId: id,
+    practiceId: submission?.practiceId || null,
+    chapterId: submission?.chapterId || null
+  };
+}
+
+export async function writeSubmissionMirrors(submission) {
+  await ensureChapterDataDirs(submission.chapterId);
+  await writeJson(chapterSubmissionPath(submission.chapterId, submission.id), submission);
+}
+
+function gradingStats(grading) {
+  const total = grading.reduce((sum, item) => sum + Number(item.maxScore || 0), 0);
+  const earned = grading.reduce((sum, item) => sum + Number(item.score || 0), 0);
+  const accuracy = total > 0 ? Math.round((earned / total) * 100) : 0;
+  const errorTypes = [...new Set(grading.flatMap((item) => item.errorTypes || []).filter(Boolean))].slice(0, 6);
+  return { total, earned, accuracy, errorTypes };
+}
+
+export async function createSubmissionRecord(practiceId, notes = '') {
+  await ensureDataDirs();
+  const practice = await readPractice(practiceId);
+  const id = `submission-${new Date().toISOString().replace(/[:.]/g, '-')}-${randomUUID().slice(0, 8)}`;
+  const submission = {
+    id,
+    practiceId: practice.id,
+    chapterId: practice.chapterId,
+    status: 'created',
+    notes,
+    photoPaths: [],
+    gradingResult: null,
+    parentConfirmed: false,
+    createdAt: new Date().toISOString()
+  };
+  await writeSubmissionMirrors(submission);
+  return submission;
+}
+
+export async function gradePracticeImages({ practiceId, imagePaths, notes = '', autoConfirm = true }) {
+  await ensureDataDirs();
+  const profile = await readJson(paths.profile);
+  const practice = await readPractice(practiceId);
+  let submission = await createSubmissionRecord(practice.id, notes);
+  const gradingResult = await gradeSubmissionImages({
+    practice,
+    profile,
+    imagePaths,
+    notes
+  });
+  submission = {
+    ...submission,
+    notes,
+    photoPaths: imagePaths,
+    gradingResult,
+    status: 'graded',
+    gradedAt: new Date().toISOString()
+  };
+  await writeSubmissionMirrors(submission);
+  if (!autoConfirm) return { submission, practice };
+  const archived = await confirmSubmission({
+    submissionId: submission.id,
+    grading: gradingResult.grading,
+    parentSummary: gradingResult.summary || ''
+  });
+  return { submission: archived, practice };
+}
+
+export async function confirmSubmission({ submissionId, grading = null, parentSummary = '' }) {
+  const submission = await readSubmission(submissionId);
+  const practice = await readPractice(submission.practiceId);
+  const confirmedGrading = grading || submission.gradingResult?.grading || [];
+  const { accuracy, errorTypes } = gradingStats(confirmedGrading);
+  const updated = {
+    ...submission,
+    gradingResult: {
+      ...submission.gradingResult,
+      grading: confirmedGrading,
+      parentSummary
+    },
+    parentConfirmed: true,
+    status: 'archived',
+    accuracy,
+    confirmedAt: new Date().toISOString()
+  };
+  await writeSubmissionMirrors(updated);
+  await updateChapterAfterArchive(practice.chapterId, accuracy, errorTypes);
+  if (practice.type === 'ability_assessment') {
+    await updateAbilitiesAfterArchive({
+      practice,
+      grading: confirmedGrading,
+      submissionId: submission.id
+    });
+  } else {
+    await updateKnowledgeMasteryAfterArchive(
+      practice,
+      confirmedGrading.map((item) => ({ ...item, submissionId: submission.id }))
+    );
+  }
+
+  await updateMistakesAfterArchive({
+    practice,
+    grading: confirmedGrading,
+    submissionId: submission.id
+  });
+
+  const report = [
+    `# ${practice.chapterTitle} 学习报告`,
+    '',
+    `- 学生：周子烊`,
+    `- 练习：${practice.title}`,
+    `- 正确率：${accuracy}%`,
+    `- 错因：${errorTypes.join('、') || '暂无'}`,
+    '',
+    '## 本次总结',
+    '',
+    updated.gradingResult?.summary || '已完成归档。',
+    '',
+    '## 下一步建议',
+    '',
+    updated.gradingResult?.nextPracticeSuggestion || '继续完成同章知识点探测。'
+  ].join('\n');
+  await writeFile(chapterReportPath(practice.chapterId, submission.id), `${report}\n`, 'utf8');
+  return updated;
+}

package/templates/workspace/.env.local.example

@@ -0,0 +1,6 @@
+AI_BASE_URL=https://code.shoestravel.xin
+AI_API_KEY=
+AI_MODEL=gpt-5.5
+IMAGE_BASE_URL=https://code.shoestravel.xin
+IMAGE_API_KEY=
+IMAGE_MODEL=gpt-image-2

package/templates/workspace/data/global/ability_index.json

@@ -0,0 +1,5 @@
+{
+  "version": 1,
+  "updatedAt": null,
+  "chapters": {}
+}