@memoring/cli 0.13.0 → 0.15.0

package/dist/commands/plan-analyze.js

@@ -0,0 +1,256 @@
+import { openAsBlob, statSync, writeFileSync } from 'node:fs';
+import { basename, extname, resolve } from 'node:path';
+import { apiFetch, apiFetchMultipart } from '../api.js';
+import { createDraftHandoff } from './planDrafts.js';
+import { fail, green, printJson, stringFlag, yellow } from './shared.js';
+import { normalized, object, readJson, } from './plan-shared.js';
+const MAX_ANALYSIS_FILES = 10;
+const MAX_PDF_BYTES = 50 * 1024 * 1024;
+const ANALYSIS_POLL_INTERVAL_MS = 1_000;
+const ANALYSIS_TIMEOUT_MS = 10 * 60 * 1_000;
+const MATURITIES = ['BEGINNER', 'INTERMEDIATE', 'ADVANCED'];
+export const ERROR_REASONS = ['UNKNOWN', 'FORGETTING', 'CONCEPTUAL_CONFUSION', 'INATTENTION', 'INTERPRETATION', 'TIME_SHORTAGE'];
+export const PLAN_SCHEMA = {
+    version: 1,
+    description: 'Contrato editável de memoring plan analyze/create. A análise usa IA somente no backend; revise o rascunho antes de criar.',
+    maturity: {
+        BEGINNER: 'Iniciante',
+        INTERMEDIATE: 'Intermediário',
+        ADVANCED: 'Avançado',
+    },
+    errorReasons: ERROR_REASONS,
+    plan: {
+        name: 'Planejamento para o concurso',
+        objective: 'Objetivo revisável do planejamento',
+        weeklyMinutes: 600,
+        activeSubjectLimit: 4,
+        programs: [
+            {
+                subjectName: 'Direito Constitucional',
+                maturity: 'BEGINNER',
+                relevance: 3,
+                deckId: null,
+                materials: [
+                    {
+                        name: 'constitucional.pdf',
+                        pageCount: 120,
+                        charCount: 240000,
+                        confidence: 0.85,
+                        warnings: [],
+                    },
+                ],
+                topics: [
+                    {
+                        title: 'Princípios fundamentais',
+                        materialIndex: 0,
+                        prerequisiteTopicIndex: null,
+                        sourceName: 'constitucional.pdf',
+                        sourceRef: null,
+                        tecNotebookId: null,
+                        pageFrom: 1,
+                        pageTo: 12,
+                        charCount: 24000,
+                        estimatedMinutes: 50,
+                    },
+                ],
+            },
+        ],
+    },
+    exam: {
+        planId: 123,
+        name: 'Simulado 1',
+        examDate: new Date().toISOString().slice(0, 10),
+        totalQuestions: 40,
+        correctAnswers: 28,
+        subjectResults: [{ subjectName: 'Direito Constitucional', totalQuestions: 20, correctAnswers: 15 }],
+    },
+    notes: [
+        'maturity é obrigatória em toda disciplina; os rótulos Iniciante, Intermediário e Avançado também são aceitos no arquivo.',
+        'materialIndex e prerequisiteTopicIndex são índices 0-based dentro da mesma disciplina.',
+        'next sem handoff exige --activities N (1..200), correspondente ao activityTarget da nova Meta.',
+        'analyze --web e next --web criam apenas rascunhos; create/next --draft exigem status REVIEWED.',
+        'review <draftId> [--wait] [--out payload.json] lê o status e exporta somente o payload já revisado.',
+        'result usa --total N --correct N [--seconds N] [--errors FORGETTING:2,INATTENTION:1].',
+        'Regravação sem --seconds/--errors preserva os valores atuais; no backend, errors omitido preserva e errors: [] limpa.',
+    ],
+};
+function maturity(value, programIndex) {
+    if (typeof value !== 'string') {
+        fail(`programs[${programIndex}].maturity é obrigatória: use BEGINNER, INTERMEDIATE ou ADVANCED.`);
+    }
+    const key = normalized(value);
+    const aliases = {
+        BEGINNER: 'BEGINNER',
+        INICIANTE: 'BEGINNER',
+        INTERMEDIATE: 'INTERMEDIATE',
+        INTERMEDIARIO: 'INTERMEDIATE',
+        ADVANCED: 'ADVANCED',
+        AVANCADO: 'ADVANCED',
+    };
+    const parsed = aliases[key];
+    if (!parsed) {
+        fail(`programs[${programIndex}].maturity inválida: use Iniciante, Intermediário ou Avançado.`);
+    }
+    return parsed;
+}
+export function planPayload(value) {
+    const body = object(value, 'a proposta deve ser um objeto JSON.');
+    if (typeof body.name !== 'string' || body.name.trim() === '') {
+        fail('a proposta precisa de name não vazio.');
+    }
+    if (!Array.isArray(body.programs) || body.programs.length < 1 || body.programs.length > 8) {
+        fail('a proposta precisa de programs com 1 a 8 disciplinas.');
+    }
+    const programs = body.programs.map((programValue, index) => {
+        const program = object(programValue, `programs[${index}] deve ser um objeto.`);
+        if (typeof program.subjectName !== 'string' || program.subjectName.trim() === '') {
+            fail(`programs[${index}].subjectName é obrigatório.`);
+        }
+        if (!Array.isArray(program.topics) || program.topics.length === 0) {
+            fail(`programs[${index}] precisa de ao menos um assunto em topics.`);
+        }
+        return { ...program, maturity: maturity(program.maturity, index) };
+    });
+    return { ...body, name: body.name.trim(), programs };
+}
+export function planBody(file) {
+    return planPayload(readJson(file));
+}
+function analysisDraft(proposal) {
+    const materialsByName = new Map(proposal.materials.map((material) => [material.sourceName, material]));
+    const programs = proposal.subjects.map((subject, subjectIndex) => {
+        const sourceNames = [...new Set(subject.topics.map((topic) => topic.sourceName))];
+        const materials = sourceNames.map((sourceName, materialIndex) => {
+            const source = materialsByName.get(sourceName);
+            const topics = subject.topics.filter((topic) => topic.sourceName === sourceName);
+            const confidence = topics.length
+                ? Math.round((topics.reduce((sum, topic) => sum + topic.confidence, 0) / topics.length) * 100) / 100
+                : undefined;
+            const warnings = [
+                ...(subjectIndex === 0 && materialIndex === 0 ? (proposal.warnings ?? []) : []),
+                ...(subject.warnings ?? []),
+                ...topics.flatMap((topic) => topic.warnings ?? []),
+            ];
+            return {
+                name: sourceName,
+                pageCount: source?.pageCount ?? 0,
+                charCount: source?.charCount ?? topics.reduce((sum, topic) => sum + topic.charCount, 0),
+                confidence,
+                warnings: [...new Set(warnings)],
+            };
+        });
+        return {
+            subjectName: subject.name,
+            maturity: 'BEGINNER',
+            relevance: 3,
+            materials,
+            topics: subject.topics.map((topic) => ({
+                title: topic.title,
+                materialIndex: Math.max(0, sourceNames.indexOf(topic.sourceName)),
+                sourceName: topic.sourceName,
+                pageFrom: topic.pageFrom,
+                pageTo: topic.pageTo,
+                charCount: topic.charCount,
+                estimatedMinutes: topic.estimatedMinutes,
+            })),
+        };
+    });
+    return {
+        name: 'Planejamento de estudos',
+        activeSubjectLimit: Math.min(4, programs.length),
+        programs,
+    };
+}
+async function pollAnalysis(jobId) {
+    const deadline = Date.now() + ANALYSIS_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+        const job = (await apiFetch(`/planning/analysis/${jobId}`));
+        if (job.status === 'PROPOSED') {
+            if (!job.proposal) {
+                fail('a análise terminou sem uma proposta.');
+            }
+            return job;
+        }
+        if (job.status === 'FAILED') {
+            fail(`a análise falhou: ${job.error ?? 'erro não informado pelo servidor'}`);
+        }
+        if (job.status !== 'RUNNING') {
+            fail(`status desconhecido da análise: ${String(job.status)}`);
+        }
+        await new Promise((resolveDelay) => setTimeout(resolveDelay, ANALYSIS_POLL_INTERVAL_MS));
+    }
+    fail('a análise demorou mais de 10 minutos; tente consultar novamente com PDFs menores.');
+}
+export async function analyze(parsed, files) {
+    if (files.length === 0) {
+        fail('informe ao menos um PDF: memoring plan analyze <arquivo.pdf...>.');
+    }
+    if (files.length > MAX_ANALYSIS_FILES) {
+        fail(`envie no máximo ${MAX_ANALYSIS_FILES} PDFs por análise.`);
+    }
+    const fileNames = new Set();
+    for (const file of files) {
+        const fileName = basename(resolve(file));
+        if (fileNames.has(fileName)) {
+            fail(`nome de arquivo duplicado: ${fileName}; renomeie um dos PDFs antes do upload.`);
+        }
+        fileNames.add(fileName);
+    }
+    const uploads = await Promise.all(files.map(async (file) => {
+        const path = resolve(file);
+        if (extname(path).toLowerCase() !== '.pdf') {
+            fail(`tipo de arquivo não suportado: ${file} (envie somente PDFs).`);
+        }
+        let size;
+        try {
+            size = statSync(path).size;
+        }
+        catch (error) {
+            fail(`não foi possível abrir ${file}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+        if (size === 0) {
+            fail(`o PDF está vazio: ${file}.`);
+        }
+        if (size > MAX_PDF_BYTES) {
+            fail(`PDF acima de 50 MB: ${file}.`);
+        }
+        return {
+            fieldName: 'files',
+            fileName: basename(path),
+            contentType: 'application/pdf',
+            data: await openAsBlob(path, { type: 'application/pdf' }),
+        };
+    }));
+    if (!parsed.flags.json) {
+        process.stderr.write(`Enviando ${uploads.length} PDF(s) para análise no Memoring…\n`);
+    }
+    const started = (await apiFetchMultipart('/planning/analysis', uploads));
+    if (!started.jobId) {
+        fail('o servidor não devolveu o jobId da análise.');
+    }
+    const job = await pollAnalysis(started.jobId);
+    const draft = analysisDraft(job.proposal);
+    const output = stringFlag(parsed.flags, 'out');
+    if (output) {
+        writeFileSync(resolve(output), `${JSON.stringify(draft, null, 2)}\n`, 'utf8');
+    }
+    if (parsed.flags.web) {
+        await createDraftHandoff('PLAN', null, draft, parsed);
+        return;
+    }
+    if (parsed.flags.json) {
+        printJson(draft);
+        return;
+    }
+    const subjects = job.proposal.subjects.length;
+    const topics = job.proposal.subjects.reduce((sum, subject) => sum + subject.topics.length, 0);
+    process.stdout.write(green(`Análise concluída: ${subjects} disciplina(s), ${topics} assunto(s).\n`));
+    if (output) {
+        process.stdout.write(`Proposta salva em ${output}.\n`);
+    }
+    else {
+        process.stdout.write('Use --out proposta.json para salvar a proposta editável.\n');
+    }
+    process.stdout.write(yellow('Revise nome, maturidade de cada disciplina, tempo semanal, baralhos e assuntos antes de criar.\n') +
+        `Depois rode: memoring plan create --file ${output ?? 'proposta.json'}\n`);
+}

package/dist/commands/plan-diagnostics.js

@@ -0,0 +1,65 @@
+import { apiFetch } from '../api.js';
+import { bold, printJson, printTable } from './shared.js';
+import { ERROR_LABELS, STATUS_LABELS, formatPercent, formatSeconds, } from './plan-shared.js';
+export async function diagnostics(sub, planId, json) {
+    const data = (await apiFetch(`/planning/${planId}/${sub}`));
+    if (json) {
+        printJson(data);
+        return;
+    }
+    if (sub === 'performance') {
+        process.stdout.write(bold(`Desempenho do planejamento #${planId}\n`));
+        process.stdout.write(`${String(data.correctCount)}/${String(data.questionCount)} corretas — ${formatPercent(data.accuracyPercent)}; ` +
+            `${String(data.errorCount)} erros; ${formatSeconds(data.actualSeconds)} registrados.\n`);
+        const subjects = Array.isArray(data.subjects) ? data.subjects : [];
+        printTable(subjects.map((subject) => ({
+            subject: subject.subjectName,
+            result: `${String(subject.correctCount)}/${String(subject.questionCount)}`,
+            accuracy: formatPercent(subject.accuracyPercent),
+            average: formatSeconds(subject.averageSecondsPerQuestion),
+        })), [
+            { key: 'subject', label: 'DISCIPLINA' },
+            { key: 'result', label: 'ACERTOS' },
+            { key: 'accuracy', label: 'DESEMPENHO' },
+            { key: 'average', label: 'TEMPO/QUESTÃO' },
+        ]);
+        return;
+    }
+    if (sub === 'error-patterns') {
+        process.stdout.write(bold(`Padrões de erro do planejamento #${planId}\n`));
+        process.stdout.write(`${String(data.totalErrors)} erros; ${String(data.classifiedErrors)} classificados ` +
+            `(${formatPercent(data.classificationCoveragePercent)}); ${String(data.unclassifiedErrors)} sem classificação.\n`);
+        const reasons = Array.isArray(data.reasons) ? data.reasons : [];
+        printTable(reasons.map((entry) => ({
+            reason: ERROR_LABELS[String(entry.reason)] ?? entry.reason,
+            count: entry.count,
+        })), [{ key: 'reason', label: 'MOTIVO' }, { key: 'count', label: 'ERROS' }]);
+        return;
+    }
+    if (sub === 'comparison') {
+        process.stdout.write(bold(`Comparação do planejamento #${planId}\n`));
+        process.stdout.write(`Meta atual: ${formatPercent(data.currentAccuracyPercent)}\n`);
+        process.stdout.write(`Média das Metas anteriores: ${formatPercent(data.previousAverageAccuracyPercent)}\n`);
+        process.stdout.write(`Referência: ${formatPercent(data.referenceAccuracyPercent)}\n`);
+        process.stdout.write(`Variação: ${typeof data.deltaFromPreviousPercent === 'number' ? `${data.deltaFromPreviousPercent >= 0 ? '+' : ''}${data.deltaFromPreviousPercent.toFixed(2).replace('.', ',')} p.p. vs anterior` : '—'}; ` +
+            `${typeof data.deltaFromReferencePercent === 'number' ? `${data.deltaFromReferencePercent >= 0 ? '+' : ''}${data.deltaFromReferencePercent.toFixed(2).replace('.', ',')} p.p. vs referência` : '—'}.\n`);
+        return;
+    }
+    const goals = Array.isArray(data.goals) ? data.goals : [];
+    process.stdout.write(bold(`Jornada do planejamento #${planId}\n`));
+    printTable(goals.map((goal) => ({
+        goal: `#${String(goal.goalNumber)}`,
+        status: STATUS_LABELS[String(goal.status)] ?? goal.status,
+        activities: `${String(goal.completedActivities)}/${String(goal.activityTarget)}`,
+        result: `${String(goal.correctCount)}/${String(goal.questionCount)}`,
+        accuracy: formatPercent(goal.accuracyPercent),
+        seconds: formatSeconds(goal.actualSeconds),
+    })), [
+        { key: 'goal', label: 'META' },
+        { key: 'status', label: 'STATUS' },
+        { key: 'activities', label: 'ATIVIDADES' },
+        { key: 'result', label: 'ACERTOS' },
+        { key: 'accuracy', label: 'DESEMPENHO' },
+        { key: 'seconds', label: 'TEMPO' },
+    ]);
+}

package/dist/commands/plan-exams.js

@@ -0,0 +1,122 @@
+import { apiFetch } from '../api.js';
+import { fail, green, printJson, printTable, stringFlag } from './shared.js';
+import { formatPercent, integerFlag, object, positiveId, readJson } from './plan-shared.js';
+function examBody(parsed) {
+    const file = stringFlag(parsed.flags, 'file');
+    if (file) {
+        return object(readJson(file), 'a prova deve ser um objeto JSON.');
+    }
+    const name = stringFlag(parsed.flags, 'name');
+    const examDate = stringFlag(parsed.flags, 'date');
+    if (!name || !examDate) {
+        fail('informe --file prova.json ou --name, --date, --total e --correct.');
+    }
+    const planId = integerFlag(parsed.flags, 'plan-id', { min: 1 });
+    const totalQuestions = integerFlag(parsed.flags, 'total', { required: true, min: 1 });
+    const correctAnswers = integerFlag(parsed.flags, 'correct', { required: true, min: 0 });
+    const subjectsRaw = stringFlag(parsed.flags, 'subjects');
+    let subjectResults;
+    if (subjectsRaw !== undefined) {
+        try {
+            subjectResults = JSON.parse(subjectsRaw);
+        }
+        catch (error) {
+            fail(`--subjects deve ser um array JSON válido: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
+    return {
+        ...(planId !== undefined ? { planId } : {}),
+        name,
+        examDate,
+        totalQuestions,
+        correctAnswers,
+        ...(subjectResults !== undefined ? { subjectResults } : {}),
+    };
+}
+function validateExam(value) {
+    if (typeof value.name !== 'string' || value.name.trim() === '') {
+        fail('a prova precisa de name não vazio.');
+    }
+    if (typeof value.examDate !== 'string' || !/^\d{4}-\d{2}-\d{2}$/.test(value.examDate) || Number.isNaN(Date.parse(`${value.examDate}T00:00:00Z`))) {
+        fail('examDate deve estar no formato YYYY-MM-DD.');
+    }
+    for (const [field, min] of [['totalQuestions', 1], ['correctAnswers', 0]]) {
+        const fieldValue = value[field];
+        if (typeof fieldValue !== 'number' || !Number.isInteger(fieldValue) || fieldValue < min) {
+            fail(`${field} deve ser um inteiro >= ${min}.`);
+        }
+    }
+    if (value.correctAnswers > value.totalQuestions) {
+        fail('correctAnswers não pode superar totalQuestions.');
+    }
+    if (value.planId !== undefined && value.planId !== null &&
+        (typeof value.planId !== 'number' || !Number.isInteger(value.planId) || value.planId < 1)) {
+        fail('planId deve ser um inteiro positivo.');
+    }
+    if (value.subjectResults !== undefined && !Array.isArray(value.subjectResults)) {
+        fail('subjectResults deve ser um array.');
+    }
+    return value;
+}
+export async function examsCommand(parsed, rest) {
+    const [sub, ...args] = rest;
+    switch (sub) {
+        case 'list': {
+            const exams = (await apiFetch('/planning/exams'));
+            if (parsed.flags.json) {
+                printJson(exams);
+                return;
+            }
+            if (exams.length === 0) {
+                process.stdout.write('Nenhuma prova registrada.\n');
+                return;
+            }
+            printTable(exams.map((exam) => ({
+                id: `#${String(exam.id)}`,
+                name: exam.name,
+                date: exam.examDate,
+                result: `${String(exam.correctAnswers)}/${String(exam.totalQuestions)}`,
+                accuracy: formatPercent(exam.accuracyPercent),
+                plan: exam.planId ? `#${String(exam.planId)}` : '—',
+            })), [
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'PROVA' },
+                { key: 'date', label: 'DATA' },
+                { key: 'result', label: 'ACERTOS' },
+                { key: 'accuracy', label: 'DESEMPENHO' },
+                { key: 'plan', label: 'PLANO' },
+            ]);
+            return;
+        }
+        case 'create': {
+            const body = validateExam(examBody(parsed));
+            const exam = await apiFetch('/planning/exams', { method: 'POST', body });
+            if (parsed.flags.json) {
+                printJson(exam);
+                return;
+            }
+            const created = object(exam, 'resposta inválida ao criar prova.');
+            process.stdout.write(green(`Prova "${String(created.name)}" registrada (#${String(created.id)}).\n`));
+            return;
+        }
+        case 'delete': {
+            const examId = positiveId(args[0], 'examId');
+            await apiFetch(`/planning/exams/${examId}`, { method: 'DELETE' });
+            if (parsed.flags.json) {
+                printJson({ deleted: true, examId });
+                return;
+            }
+            process.stdout.write(green(`Prova #${examId} excluída.\n`));
+            return;
+        }
+        default:
+            process.stdout.write('Uso: memoring plan exams <list|create|delete>\n' +
+                '  list\n' +
+                '  create --file prova.json\n' +
+                '  create --name "Simulado 1" --date YYYY-MM-DD --total N --correct N [--plan-id N] [--subjects JSON]\n' +
+                '  delete <examId>\n');
+            if (sub) {
+                process.exitCode = 1;
+            }
+    }
+}

package/dist/commands/plan-goal.js

@@ -0,0 +1,131 @@
+import { apiFetch } from '../api.js';
+import { createDraftHandoff, deleteDraftAfterCreation, readPlanningDraft, requireReviewed, } from './planDrafts.js';
+import { fail, printJson, stringFlag } from './shared.js';
+import { formatPercent, integerFlag, normalized, printActivity, printGoal, } from './plan-shared.js';
+import { ERROR_REASONS } from './plan-analyze.js';
+export async function goalCommand(sub, planId, parsed) {
+    let details;
+    if (sub === 'current') {
+        details = (await apiFetch(`/planning/plans/${planId}/goals/current`));
+    }
+    else if (parsed.flags.web) {
+        if (parsed.flags.draft !== undefined || parsed.flags.activities !== undefined) {
+            fail('next --web não aceita --draft nem --activities; a Meta será definida na revisão web.');
+        }
+        await createDraftHandoff('GOAL', planId, {}, parsed);
+        return;
+    }
+    else {
+        let reviewedDraft = null;
+        let activityTarget;
+        if (parsed.flags.draft !== undefined) {
+            if (parsed.flags.activities !== undefined) {
+                fail('use --draft ou --activities, não os dois.');
+            }
+            reviewedDraft = await readPlanningDraft(stringFlag(parsed.flags, 'draft'));
+            requireReviewed(reviewedDraft, 'GOAL', planId);
+            const value = reviewedDraft.payload.activityTarget;
+            if (typeof value !== 'number' || !Number.isSafeInteger(value) || value < 1 || value > 200) {
+                fail('o payload revisado precisa de activityTarget inteiro entre 1 e 200.');
+            }
+            activityTarget = value;
+        }
+        else {
+            activityTarget = integerFlag(parsed.flags, 'activities', { required: true, min: 1, max: 200 });
+        }
+        details = (await apiFetch(`/planning/plans/${planId}/goals`, {
+            method: 'POST',
+            body: { activityTarget },
+        }));
+        if (reviewedDraft) {
+            await deleteDraftAfterCreation(reviewedDraft);
+        }
+    }
+    if (parsed.flags.json) {
+        printJson(details);
+        return;
+    }
+    if (!details) {
+        process.stdout.write(`Nenhuma Meta ativa no planejamento #${planId}. Gere uma com \`memoring plan next ${planId} --activities N\`.\n`);
+        return;
+    }
+    printGoal(details, sub === 'next' ? 'Meta gerada' : 'Meta atual');
+}
+function errorReason(raw) {
+    const key = normalized(raw);
+    const aliases = {
+        UNKNOWN: 'UNKNOWN',
+        DESCONHECIDO: 'UNKNOWN',
+        NAO_IDENTIFICADO: 'UNKNOWN',
+        FORGETTING: 'FORGETTING',
+        ESQUECIMENTO: 'FORGETTING',
+        CONCEPTUAL_CONFUSION: 'CONCEPTUAL_CONFUSION',
+        CONFUSAO_CONCEITUAL: 'CONCEPTUAL_CONFUSION',
+        INATTENTION: 'INATTENTION',
+        DESATENCAO: 'INATTENTION',
+        INTERPRETATION: 'INTERPRETATION',
+        INTERPRETACAO: 'INTERPRETATION',
+        TIME_SHORTAGE: 'TIME_SHORTAGE',
+        FALTA_DE_TEMPO: 'TIME_SHORTAGE',
+    };
+    const reason = aliases[key];
+    if (!reason) {
+        fail(`motivo de erro desconhecido: ${raw}. Use ${ERROR_REASONS.join(', ')}.`);
+    }
+    return reason;
+}
+function parseErrors(raw, incorrectCount) {
+    if (raw === undefined) {
+        return undefined;
+    }
+    const entries = raw.split(/[,;]/).map((entry) => entry.trim()).filter(Boolean);
+    if (entries.length === 0) {
+        fail('--errors vazio; use motivo:N separado por vírgulas.');
+    }
+    const seen = new Set();
+    const errors = entries.map((entry) => {
+        const match = /^(.+):(\d+)$/.exec(entry);
+        if (!match) {
+            fail(`--errors inválido em ${JSON.stringify(entry)}; use motivo:N (ex.: FORGETTING:2).`);
+        }
+        const reason = errorReason(match[1]);
+        const errorCount = Number(match[2]);
+        if (errorCount < 1) {
+            fail(`a contagem de ${reason} deve ser pelo menos 1.`);
+        }
+        if (seen.has(reason)) {
+            fail(`o motivo ${reason} aparece mais de uma vez em --errors.`);
+        }
+        seen.add(reason);
+        return { reason, errorCount };
+    });
+    const classified = errors.reduce((sum, error) => sum + error.errorCount, 0);
+    if (classified > incorrectCount) {
+        fail(`a soma de --errors (${classified}) não pode superar os ${incorrectCount} erros da atividade.`);
+    }
+    return errors;
+}
+export async function recordResult(activityId, parsed) {
+    const questionCount = integerFlag(parsed.flags, 'total', { required: true, min: 1 });
+    const correctCount = integerFlag(parsed.flags, 'correct', { required: true, min: 0 });
+    const actualSeconds = integerFlag(parsed.flags, 'seconds', { min: 0 });
+    if (correctCount > questionCount) {
+        fail('--correct não pode superar --total.');
+    }
+    const errors = parseErrors(stringFlag(parsed.flags, 'errors'), questionCount - correctCount);
+    const activity = (await apiFetch(`/planning/activities/${activityId}/result`, {
+        method: 'POST',
+        body: {
+            questionCount,
+            correctCount,
+            ...(actualSeconds !== undefined ? { actualSeconds } : {}),
+            ...(errors !== undefined ? { errors } : {}),
+        },
+    }));
+    if (parsed.flags.json) {
+        printJson(activity);
+        return;
+    }
+    printActivity(activity, 'Resultado registrado');
+    process.stdout.write(`  ${correctCount}/${questionCount} corretas (${formatPercent((100 * correctCount) / questionCount)}).\n`);
+}