@memoring/cli 0.13.0 → 0.15.0

package/dist/commands/plan-shared.js

@@ -0,0 +1,133 @@
+import { readFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { dim, fail, green, printTable, stringFlag } from './shared.js';
+export const STATUS_LABELS = {
+    ACTIVE: 'Ativo',
+    ARCHIVED: 'Arquivado',
+    COMPLETED: 'Concluída',
+    PENDING: 'Pendente',
+    IN_PROGRESS: 'Em andamento',
+    POSTPONED: 'Adiada',
+    DISMISSED: 'Dispensada',
+    CANCELLED: 'Cancelada',
+};
+// PlanStatus da web usa COMPLETED no masculino ("planejamento concluído");
+// STATUS_LABELS acima atende atividades/Metas ("concluída").
+export const PLAN_STATUS_LABELS = {
+    ...STATUS_LABELS,
+    COMPLETED: 'Concluído',
+};
+export const TYPE_LABELS = {
+    THEORY: 'Teoria',
+    MAPPING: 'Mapeamento',
+    REVIEW: 'Revisão',
+    QUESTIONS: 'Questões',
+    TEST: 'Teste',
+    REINFORCEMENT: 'Reforço',
+};
+export const MATURITY_LABELS = {
+    BEGINNER: 'Iniciante',
+    INTERMEDIATE: 'Intermediário',
+    ADVANCED: 'Avançado',
+};
+export const ERROR_LABELS = {
+    UNKNOWN: 'Não identificado',
+    FORGETTING: 'Esquecimento',
+    CONCEPTUAL_CONFUSION: 'Confusão conceitual',
+    INATTENTION: 'Desatenção',
+    INTERPRETATION: 'Interpretação',
+    TIME_SHORTAGE: 'Falta de tempo',
+};
+export function object(value, message) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        fail(message);
+    }
+    return value;
+}
+export function readJson(file) {
+    try {
+        const raw = file === '-' ? readFileSync(0, 'utf8') : readFileSync(resolve(file), 'utf8');
+        return JSON.parse(raw);
+    }
+    catch (error) {
+        fail(`não foi possível ler JSON de ${file === '-' ? 'stdin' : file}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+export function positiveId(raw, label) {
+    if (raw === undefined || !/^\d+$/.test(raw) || Number(raw) < 1 || !Number.isSafeInteger(Number(raw))) {
+        fail(`${label} deve ser um inteiro positivo.`);
+    }
+    return Number(raw);
+}
+export function integerFlag(flags, name, options) {
+    const raw = stringFlag(flags, name);
+    if (raw === undefined) {
+        if (options.required) {
+            fail(`--${name} é obrigatório.`);
+        }
+        return undefined;
+    }
+    if (!/^-?\d+$/.test(raw)) {
+        fail(`--${name} deve ser um inteiro.`);
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < options.min || (options.max !== undefined && value > options.max)) {
+        fail(`--${name} deve estar entre ${options.min} e ${options.max ?? '∞'}.`);
+    }
+    return value;
+}
+export function normalized(value) {
+    return value
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .trim()
+        .replace(/[\s-]+/g, '_')
+        .toUpperCase();
+}
+export function formatPercent(value) {
+    return typeof value === 'number' ? `${value.toFixed(2).replace('.', ',')}%` : '—';
+}
+export function formatSeconds(value) {
+    if (typeof value !== 'number') {
+        return '—';
+    }
+    if (value < 60) {
+        return `${Math.round(value)}s`;
+    }
+    const minutes = Math.floor(value / 60);
+    const seconds = Math.round(value % 60);
+    return minutes < 60 ? `${minutes}min${seconds ? ` ${seconds}s` : ''}` : `${Math.floor(minutes / 60)}h${String(minutes % 60).padStart(2, '0')}`;
+}
+export function printActivity(activity, heading = 'Atividade atualizada') {
+    process.stdout.write(green(`${heading}: #${activity.id} — ${activity.title}\n`));
+    process.stdout.write(`  tipo: ${TYPE_LABELS[activity.type] ?? activity.type}  status: ${STATUS_LABELS[activity.status] ?? activity.status}  estimativa: ${activity.estimatedMinutes}min\n`);
+    if (activity.command) {
+        process.stdout.write(`  ${activity.command}\n`);
+    }
+}
+export function printGoal(details, heading) {
+    process.stdout.write(green(`${heading}: Meta #${details.goal.number} (id ${details.goal.id}) — alvo de ${details.goal.activityTarget} atividades.\n`));
+    if (details.activities.length === 0) {
+        process.stdout.write('Nenhuma atividade nesta Meta.\n');
+        return;
+    }
+    printTable(details.activities.map((activity) => ({
+        id: `#${activity.id}`,
+        type: TYPE_LABELS[activity.type] ?? activity.type,
+        title: activity.title,
+        status: STATUS_LABELS[activity.status] ?? activity.status,
+        minutes: `${activity.estimatedMinutes}min`,
+        questions: activity.questionTarget ?? activity.questionCount ?? '—',
+    })), [
+        { key: 'id', label: 'ID' },
+        { key: 'type', label: 'TIPO' },
+        { key: 'title', label: 'ATIVIDADE' },
+        { key: 'status', label: 'STATUS' },
+        { key: 'minutes', label: 'ESTIMATIVA' },
+        { key: 'questions', label: 'QUESTÕES' },
+    ]);
+    const first = details.activities.find((activity) => activity.status === 'PENDING' || activity.status === 'IN_PROGRESS');
+    if (first) {
+        process.stdout.write(dim(`\nPróxima: memoring plan start ${first.id}\n`));
+    }
+}

package/dist/commands/plan.js

@@ -0,0 +1,219 @@
+import { apiFetch } from '../api.js';
+import { deleteDraftAfterCreation, readPlanningDraft, requireReviewed, reviewDraft, } from './planDrafts.js';
+import { PLAN_SCHEMA, analyze, planBody, planPayload } from './plan-analyze.js';
+import { diagnostics } from './plan-diagnostics.js';
+import { examsCommand } from './plan-exams.js';
+import { goalCommand, recordResult } from './plan-goal.js';
+import { MATURITY_LABELS, PLAN_STATUS_LABELS, STATUS_LABELS, formatPercent, object, positiveId, printActivity, } from './plan-shared.js';
+import { bold, fail, green, printJson, printTable, stringFlag } from './shared.js';
+/**
+ * `memoring plan` — dispatcher dos subcomandos do Planejamento. O módulo
+ * ficou grande demais como arquivo único; cada família coesa vive no seu
+ * próprio módulo: `plan-analyze` (schema/analyze/create payload), `plan-goal`
+ * (current/next/start/complete/postpone/dismiss/cancel/result), `plan-exams`,
+ * `plan-diagnostics` e `plan-shared` (rótulos, parsers e impressão).
+ */
+function printHelp() {
+    process.stdout.write(`Uso: memoring plan <subcomando> [argumentos] [flags]
+
+  schema                         contrato JSON editável do planejamento e das provas
+  analyze <pdfs...>              analisa PDFs no backend e aguarda a proposta
+         [--out proposta.json]   salva o rascunho (com --json, imprime só o rascunho)
+         [--web] [--no-open]     envia a proposta para revisão web, sem criar o plano
+  review <draftId> [--wait]      lê o rascunho; --wait aguarda REVIEWED
+         [--timeout N] [--out f] timeout em segundos; exporta o payload já REVIEWED
+  create --file proposta.json    cria o planejamento após sua revisão no arquivo
+  create --draft <uuid>          cria somente de um rascunho PLAN REVIEWED e o exclui
+  list                           lista planejamentos
+  show <planId>                  detalha disciplinas e assuntos
+  current <planId>               mostra a Meta ativa
+  next <planId> --activities N   gera a próxima Meta (activityTarget obrigatório)
+  next <planId> --web            cria handoff de Meta para revisão web, sem gerar a Meta
+  next <planId> --draft <uuid>   gera de um rascunho GOAL REVIEWED e o exclui
+  start|complete|postpone|dismiss|cancel <activityId>
+                                 transições de uma atividade
+                                 (cancel = redução definitiva de escopo:
+                                 encerra na Meta e nunca é recomposta)
+  result <activityId> --total N --correct N [--seconds N]
+         [--errors motivo:N,...] registra desempenho e motivos dos erros
+  tec-result <activityId>        importa resultado do caderno TEC já disponível
+  performance|error-patterns|comparison|journey <planId>
+                                 diagnósticos do planejamento
+  coordinates                    coordenadas do método de planejamento
+  exams list                     lista provas
+  exams create --file prova.json registra prova (ou use --name/--date/--total/--correct)
+  exams delete <examId>          exclui prova
+
+Maturidades: BEGINNER (Iniciante), INTERMEDIATE (Intermediário), ADVANCED (Avançado).
+Motivos de erro: UNKNOWN, FORGETTING, CONCEPTUAL_CONFUSION, INATTENTION, INTERPRETATION, TIME_SHORTAGE (aliases em PT-BR também são aceitos).
+`);
+}
+export async function planCommand(parsed) {
+    const [sub, ...rest] = parsed._;
+    switch (sub) {
+        case 'schema':
+            printJson(PLAN_SCHEMA);
+            return;
+        case 'analyze':
+            await analyze(parsed, rest);
+            return;
+        case 'review':
+        case 'draft':
+            await reviewDraft(parsed, rest[0]);
+            return;
+        case 'create': {
+            const file = stringFlag(parsed.flags, 'file');
+            if (file && parsed.flags.draft !== undefined) {
+                fail('use --file ou --draft, não os dois.');
+            }
+            let body;
+            let reviewedDraft = null;
+            if (parsed.flags.draft !== undefined) {
+                reviewedDraft = await readPlanningDraft(stringFlag(parsed.flags, 'draft'));
+                requireReviewed(reviewedDraft, 'PLAN');
+                body = planPayload(reviewedDraft.payload);
+            }
+            else if (file) {
+                body = planBody(file);
+            }
+            else {
+                fail('informe a proposta revisada: memoring plan create --file proposta.json ou --draft <uuid>.');
+            }
+            const details = (await apiFetch('/planning/plans', { method: 'POST', body }));
+            if (reviewedDraft) {
+                await deleteDraftAfterCreation(reviewedDraft);
+            }
+            if (parsed.flags.json) {
+                printJson(details);
+                return;
+            }
+            const plan = object(details.plan, 'resposta inválida ao criar planejamento.');
+            process.stdout.write(green(`Planejamento "${String(plan.name)}" criado (#${String(plan.id)}).\n`));
+            process.stdout.write(`Gere a primeira Meta: memoring plan next ${String(plan.id)} --activities N\n`);
+            return;
+        }
+        case 'list': {
+            const plans = (await apiFetch('/planning/plans'));
+            if (parsed.flags.json) {
+                printJson(plans);
+                return;
+            }
+            if (plans.length === 0) {
+                process.stdout.write('Nenhum planejamento. Analise PDFs com `memoring plan analyze <pdfs...>`.\n');
+                return;
+            }
+            printTable(plans.map((plan) => ({
+                id: `#${String(plan.id)}`,
+                name: plan.name,
+                status: PLAN_STATUS_LABELS[String(plan.status)] ?? plan.status,
+                subjects: plan.activeSubjectLimit,
+                weekly: plan.weeklyMinutes ? `${String(plan.weeklyMinutes)}min` : '—',
+            })), [
+                { key: 'id', label: 'ID' },
+                { key: 'name', label: 'PLANEJAMENTO' },
+                { key: 'status', label: 'STATUS' },
+                { key: 'subjects', label: 'DISCIPLINAS ATIVAS' },
+                { key: 'weekly', label: 'TEMPO SEMANAL' },
+            ]);
+            return;
+        }
+        case 'show': {
+            const planId = positiveId(rest[0], 'planId');
+            const details = (await apiFetch(`/planning/plans/${planId}`));
+            if (parsed.flags.json) {
+                printJson(details);
+                return;
+            }
+            const plan = object(details.plan, 'resposta inválida ao consultar planejamento.');
+            process.stdout.write(bold(`${String(plan.name)} (#${planId}) — ${PLAN_STATUS_LABELS[String(plan.status)] ?? String(plan.status)}\n`));
+            if (plan.objective) {
+                process.stdout.write(`${String(plan.objective)}\n`);
+            }
+            const programs = Array.isArray(details.programs) ? details.programs : [];
+            const topics = Array.isArray(details.topics) ? details.topics : [];
+            for (const program of programs) {
+                process.stdout.write(`\n${String(program.subjectName)} — ${MATURITY_LABELS[String(program.maturity)] ?? String(program.maturity)}\n`);
+                const programTopics = topics.filter((topic) => topic.programId === program.id);
+                printTable(programTopics.map((topic) => ({
+                    id: `#${String(topic.id)}`,
+                    title: topic.title,
+                    pages: topic.pageFrom ? `${String(topic.pageFrom)}${topic.pageTo !== topic.pageFrom ? `–${String(topic.pageTo)}` : ''}` : '—',
+                    minutes: `${String(topic.estimatedMinutes)}min`,
+                    status: STATUS_LABELS[String(topic.status)] ?? topic.status,
+                })), [
+                    { key: 'id', label: 'ID' },
+                    { key: 'title', label: 'ASSUNTO' },
+                    { key: 'pages', label: 'PÁGINAS' },
+                    { key: 'minutes', label: 'ESTIMATIVA' },
+                    { key: 'status', label: 'STATUS' },
+                ]);
+            }
+            return;
+        }
+        case 'current':
+        case 'next':
+            await goalCommand(sub, positiveId(rest[0], 'planId'), parsed);
+            return;
+        case 'start':
+        case 'complete':
+        case 'postpone':
+        case 'dismiss':
+        case 'cancel': {
+            const activityId = positiveId(rest[0], 'activityId');
+            const activity = (await apiFetch(`/planning/activities/${activityId}/${sub}`, { method: 'POST' }));
+            if (parsed.flags.json) {
+                printJson(activity);
+            }
+            else {
+                printActivity(activity);
+            }
+            return;
+        }
+        case 'result':
+            await recordResult(positiveId(rest[0], 'activityId'), parsed);
+            return;
+        case 'tec-result': {
+            const activityId = positiveId(rest[0], 'activityId');
+            const result = (await apiFetch(`/planning/activities/${activityId}/tec-result`, { method: 'POST' }));
+            if (parsed.flags.json) {
+                printJson(result);
+                return;
+            }
+            process.stdout.write(green(`Resultado TEC importado para a atividade #${activityId}.\n`));
+            process.stdout.write(`  ${String(result.correctCount)}/${String(result.questionCount)} corretas (${formatPercent(result.accuracyPercent)}); ` +
+                `${String(result.errorCount)} erros.\n`);
+            return;
+        }
+        case 'performance':
+        case 'error-patterns':
+        case 'comparison':
+        case 'journey':
+            await diagnostics(sub, positiveId(rest[0], 'planId'), parsed.flags.json === true);
+            return;
+        case 'coordinates': {
+            const guides = (await apiFetch('/planning/coordinates'));
+            if (parsed.flags.json) {
+                printJson(guides);
+                return;
+            }
+            for (const guide of guides) {
+                process.stdout.write(bold(`${String(guide.title)}\n`));
+                process.stdout.write(`${String(guide.description)}\n`);
+                const actions = Array.isArray(guide.actions) ? guide.actions : [];
+                for (const action of actions) {
+                    process.stdout.write(`  • ${String(action)}\n`);
+                }
+                process.stdout.write('\n');
+            }
+            return;
+        }
+        case 'exams':
+            await examsCommand(parsed, rest);
+            return;
+        default:
+            printHelp();
+            if (sub) {
+                process.exitCode = 1;
+            }
+    }
+}

package/dist/commands/planDrafts.js

@@ -0,0 +1,162 @@
+import { writeFileSync } from 'node:fs';
+import { resolve } from 'node:path';
+import { apiFetch } from '../api.js';
+import { openBrowser } from '../auth.js';
+import { loadConfig } from '../config.js';
+import { fail, green, printJson, stringFlag, yellow } from './shared.js';
+const DRAFT_POLL_INTERVAL_MS = 2_000;
+const DRAFT_REVIEW_TIMEOUT_SECONDS = 10 * 60;
+function object(value, message) {
+    if (value === null || typeof value !== 'object' || Array.isArray(value)) {
+        fail(message);
+    }
+    return value;
+}
+function draftId(raw) {
+    if (!raw || !/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(raw)) {
+        fail('draftId deve ser um UUID.');
+    }
+    return raw;
+}
+function planningDraft(value) {
+    const draft = object(value, 'resposta inválida ao consultar rascunho de planejamento.');
+    const id = draftId(typeof draft.id === 'string' ? draft.id : undefined);
+    if (draft.kind !== 'PLAN' && draft.kind !== 'GOAL') {
+        fail('resposta inválida: kind do rascunho deve ser PLAN ou GOAL.');
+    }
+    if (draft.status !== 'OPEN' && draft.status !== 'REVIEWED') {
+        fail('resposta inválida: status do rascunho deve ser OPEN ou REVIEWED.');
+    }
+    if (draft.planId !== null && (typeof draft.planId !== 'number' || !Number.isSafeInteger(draft.planId) || draft.planId < 1)) {
+        fail('resposta inválida: planId do rascunho deve ser um inteiro positivo ou null.');
+    }
+    for (const field of ['createdAt', 'updatedAt', 'expiresAt']) {
+        if (typeof draft[field] !== 'string') {
+            fail(`resposta inválida: ${field} do rascunho é obrigatório.`);
+        }
+    }
+    return {
+        id,
+        kind: draft.kind,
+        planId: draft.planId,
+        payload: object(draft.payload, 'resposta inválida: payload do rascunho deve ser um objeto.'),
+        status: draft.status,
+        createdAt: draft.createdAt,
+        updatedAt: draft.updatedAt,
+        expiresAt: draft.expiresAt,
+    };
+}
+function draftReviewUrl(draft) {
+    const webBase = loadConfig().webBase.replace(/\/+$/, '');
+    if (draft.kind === 'PLAN') {
+        return `${webBase}/planning/new?draft=${encodeURIComponent(draft.id)}`;
+    }
+    if (draft.planId === null) {
+        fail('resposta inválida: rascunho de Meta sem planId.');
+    }
+    return `${webBase}/planning/${draft.planId}?goalDraft=${encodeURIComponent(draft.id)}`;
+}
+function nextDraftCommand(draft) {
+    return draft.kind === 'PLAN'
+        ? `memoring plan create --draft ${draft.id} --json`
+        : `memoring plan next ${draft.planId} --draft ${draft.id} --json`;
+}
+function reviewTimeoutSeconds(parsed) {
+    const raw = stringFlag(parsed.flags, 'timeout');
+    if (raw === undefined) {
+        return DRAFT_REVIEW_TIMEOUT_SECONDS;
+    }
+    if (!/^-?\d+$/.test(raw)) {
+        fail('--timeout deve ser um inteiro.');
+    }
+    const value = Number(raw);
+    if (!Number.isSafeInteger(value) || value < 1 || value > 86_400) {
+        fail('--timeout deve estar entre 1 e 86400.');
+    }
+    return value;
+}
+export async function readPlanningDraft(rawId) {
+    const id = draftId(rawId);
+    return planningDraft(await apiFetch(`/planning/drafts/${id}`));
+}
+export function requireReviewed(draft, kind, planId) {
+    if (draft.kind !== kind) {
+        fail(`o rascunho ${draft.id} é do tipo ${draft.kind}; era esperado ${kind}.`);
+    }
+    if (draft.status !== 'REVIEWED') {
+        fail(`o rascunho ${draft.id} ainda está ${draft.status}; conclua a revisão web antes de criar.`);
+    }
+    if (kind === 'PLAN' && draft.planId !== null) {
+        fail('o rascunho de planejamento não pode estar associado a um planId.');
+    }
+    if (kind === 'GOAL' && draft.planId !== planId) {
+        fail(`o rascunho ${draft.id} pertence ao planejamento #${draft.planId ?? 'desconhecido'}, não ao #${planId}.`);
+    }
+}
+export async function createDraftHandoff(kind, planId, payload, parsed) {
+    const draft = planningDraft(await apiFetch('/planning/drafts', {
+        method: 'POST',
+        body: { kind, planId, payload },
+    }));
+    const reviewUrl = draftReviewUrl(draft);
+    const handoff = { draft, reviewUrl, nextCommand: nextDraftCommand(draft) };
+    if (!parsed.flags['no-open']) {
+        openBrowser(reviewUrl);
+    }
+    if (parsed.flags.json) {
+        printJson(handoff);
+        return;
+    }
+    process.stdout.write(green('Rascunho criado. Nenhum planejamento ou Meta foi criado.\n'));
+    process.stdout.write(`Revise no navegador: ${reviewUrl}\n`);
+    process.stdout.write('O botão da página apenas conclui a revisão; depois volte ao terminal.\n');
+    process.stdout.write(`Consulte ou aguarde: memoring plan review ${draft.id} --wait\n`);
+    process.stdout.write(`Quando estiver REVIEWED, rode: ${handoff.nextCommand}\n`);
+}
+export async function deleteDraftAfterCreation(draft) {
+    try {
+        await apiFetch(`/planning/drafts/${draft.id}`, { method: 'DELETE' });
+    }
+    catch (error) {
+        process.stderr.write(yellow(`Aviso: a criação foi concluída, mas não foi possível excluir o rascunho ${draft.id} ` +
+            `(${error instanceof Error ? error.message : String(error)}). Ele expira em ${draft.expiresAt}.\n`));
+    }
+}
+export async function reviewDraft(parsed, rawId) {
+    let draft = await readPlanningDraft(rawId);
+    if (parsed.flags.wait && draft.status === 'OPEN') {
+        const timeoutSeconds = reviewTimeoutSeconds(parsed);
+        const deadline = Date.now() + timeoutSeconds * 1_000;
+        if (!parsed.flags.json) {
+            process.stderr.write(`Aguardando a revisão do rascunho ${draft.id} por até ${timeoutSeconds}s…\n`);
+        }
+        while (draft.status === 'OPEN') {
+            if (Date.now() >= deadline) {
+                fail(`a revisão não foi concluída em ${timeoutSeconds}s; o rascunho continua OPEN. Consulte depois com memoring plan review ${draft.id}.`);
+            }
+            await new Promise((resolveDelay) => setTimeout(resolveDelay, DRAFT_POLL_INTERVAL_MS));
+            draft = await readPlanningDraft(draft.id);
+        }
+    }
+    const output = stringFlag(parsed.flags, 'out');
+    if (output && draft.status !== 'REVIEWED') {
+        fail(`o rascunho ${draft.id} ainda está OPEN; use --wait ou conclua a revisão antes de exportar o payload.`);
+    }
+    if (output) {
+        writeFileSync(resolve(output), `${JSON.stringify(draft.payload, null, 2)}\n`, 'utf8');
+    }
+    if (parsed.flags.json) {
+        printJson(draft);
+        return;
+    }
+    process.stdout.write(`${draft.kind} ${draft.id}: ${draft.status} (expira em ${draft.expiresAt}).\n`);
+    if (draft.status === 'OPEN') {
+        process.stdout.write(`Revise em ${draftReviewUrl(draft)}\n`);
+        process.stdout.write(`Para aguardar: memoring plan review ${draft.id} --wait\n`);
+        return;
+    }
+    if (output) {
+        process.stdout.write(`Payload revisado salvo em ${output}.\n`);
+    }
+    process.stdout.write(`Próximo passo: ${nextDraftCommand(draft)}\n`);
+}