@memoring/cli 0.12.1 → 0.15.0

package/dist/commands/batch.js

@@ -0,0 +1,327 @@
+import { execFile } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, renameSync, writeFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { apiFetch } from '../api.js';
+import { listDecks } from './deck.js';
+import { fail, green, printJson, yellow } from './shared.js';
+const MAIN_PATH = fileURLToPath(new URL('../main.js', import.meta.url));
+function parseJsonFile(filePath) {
+    return JSON.parse(readFileSync(filePath, 'utf8'));
+}
+function batchItems(filePath) {
+    const payload = parseJsonFile(filePath);
+    return Array.isArray(payload) ? payload : payload.items;
+}
+function sha256(value) {
+    return createHash('sha256').update(value).digest('hex');
+}
+function loadPlan(planPath) {
+    const raw = readFileSync(planPath, 'utf8');
+    const plan = JSON.parse(raw);
+    if (plan.version !== 1 || !Array.isArray(plan.activities) || plan.activities.length === 0) {
+        fail('manifesto inválido: esperado version=1 e activities não vazio.');
+    }
+    if (typeof plan.pdfMap !== 'object' || plan.pdfMap === null || Array.isArray(plan.pdfMap)) {
+        fail('manifesto inválido: pdfMap deve ser um objeto driveFileId → PDF local.');
+    }
+    const base = dirname(resolve(planPath));
+    const ids = new Set();
+    for (const [index, activity] of plan.activities.entries()) {
+        const where = `atividade #${index + 1}`;
+        if (!activity.id || ids.has(activity.id))
+            fail(`${where}: id ausente ou duplicado (${activity.id}).`);
+        ids.add(activity.id);
+        if (!activity.batchFile || !activity.deckName)
+            fail(`${where} (${activity.id}): batchFile/deckName obrigatórios.`);
+        activity.batchFile = resolve(base, activity.batchFile);
+        if (activity.generationFile)
+            activity.generationFile = resolve(base, activity.generationFile);
+        if (!Array.isArray(activity.expectedReferences))
+            activity.expectedReferences = [];
+    }
+    for (const [id, file] of Object.entries(plan.pdfMap)) {
+        if (typeof file !== 'string' || file.trim() === '')
+            fail(`pdfMap.${id}: caminho inválido.`);
+        plan.pdfMap[id] = resolve(base, file);
+    }
+    return { plan, raw };
+}
+function strictDeck(decks, ref, activityId) {
+    const numeric = Number(ref);
+    const matches = Number.isInteger(numeric) && numeric > 0
+        ? decks.filter((deck) => deck.id === numeric)
+        : decks.filter((deck) => deck.name.trim().toLocaleLowerCase('pt-BR') === ref.trim().toLocaleLowerCase('pt-BR'));
+    if (matches.length === 0) {
+        throw new Error(`${activityId}: baralho ${ref} não existe; crie-o explicitamente antes do batch.`);
+    }
+    if (matches.length > 1) {
+        throw new Error(`${activityId}: baralho ${ref} é ambíguo (${matches.map((deck) => `#${deck.id}`).join(', ')}); use o ID.`);
+    }
+    return matches[0];
+}
+async function runCliJson(args) {
+    return new Promise((resolvePromise, reject) => {
+        execFile(process.execPath, [MAIN_PATH, ...args, '--json', '--no-color'], {
+            env: { ...process.env, MEMORING_NO_UPDATE_CHECK: '1' },
+            encoding: 'utf8',
+            maxBuffer: 32 * 1024 * 1024,
+        }, (error, stdout, stderr) => {
+            const code = error && typeof error.code === 'number'
+                ? Number(error.code)
+                : error ? 1 : 0;
+            try {
+                resolvePromise({ code, data: JSON.parse(stdout), stdout, stderr });
+            }
+            catch {
+                reject(new Error(`CLI retornou saída inválida (${args.join(' ')}): ${stderr || stdout || error?.message}`));
+            }
+        });
+    });
+}
+function pageRange(raw) {
+    const match = /^(\d+)(?:-(\d+))?$/.exec(raw);
+    if (!match)
+        throw new Error(`faixa de páginas inválida: ${raw}`);
+    const from = Number(match[1]);
+    const to = Number(match[2] ?? match[1]);
+    if (from < 1 || to < from)
+        throw new Error(`faixa de páginas inválida: ${raw}`);
+    return { from, to };
+}
+function writeJsonAtomic(filePath, value) {
+    const temp = `${filePath}.${process.pid}.tmp`;
+    writeFileSync(temp, JSON.stringify(value, null, 2));
+    renameSync(temp, filePath);
+}
+async function checkPlan(planPath, plan) {
+    const errors = [];
+    const warnings = [];
+    const checked = [];
+    const pdfMapFile = `${planPath}.pdf-map.json`;
+    writeJsonAtomic(pdfMapFile, plan.pdfMap);
+    let decks;
+    try {
+        decks = await listDecks();
+    }
+    catch (error) {
+        return { valid: false, errors: [`não consegui listar os baralhos: ${error.message}`], warnings, activities: [], pdfMapFile };
+    }
+    for (const activity of plan.activities) {
+        let deck;
+        try {
+            deck = strictDeck(decks, activity.deckName, activity.id);
+        }
+        catch (error) {
+            errors.push(error.message);
+            continue;
+        }
+        if (!existsSync(activity.batchFile)) {
+            errors.push(`${activity.id}: batchFile não encontrado (${activity.batchFile}).`);
+            continue;
+        }
+        if (activity.generationFile && !existsSync(activity.generationFile)) {
+            errors.push(`${activity.id}: generationFile não encontrado (${activity.generationFile}).`);
+            continue;
+        }
+        const items = batchItems(activity.batchFile);
+        for (const [index, item] of items.entries()) {
+            if (item.deckName !== activity.deckName) {
+                errors.push(`${activity.id}, item #${index + 1} (${item.title}): deckName ${item.deckName} difere de ${activity.deckName}.`);
+            }
+            for (const reference of item.materialReferences ?? []) {
+                if (activity.expectedReferences.length === 0)
+                    continue;
+                const matches = activity.expectedReferences.some((expected) => {
+                    if (expected.driveFileId !== reference.driveFileId)
+                        return false;
+                    const range = pageRange(expected.pages);
+                    return reference.page >= range.from && reference.page <= range.to;
+                });
+                if (!matches) {
+                    errors.push(`${activity.id}, item #${index + 1} (${item.title}): referência ${reference.driveFileId} página ${reference.page} fora do esperado.`);
+                }
+            }
+        }
+        const validation = await runCliJson(['stage', 'validate', '--file', activity.batchFile, '--pdf-map', pdfMapFile]);
+        if (!validation.data.valid) {
+            errors.push(...(validation.data.errors ?? []).map((error) => `${activity.id}: ${error}`));
+        }
+        warnings.push(...(validation.data.warnings ?? []).map((warning) => `${activity.id}: ${warning}`));
+        checked.push({
+            ...activity,
+            deckId: deck.id,
+            items,
+            batchHash: sha256(readFileSync(activity.batchFile, 'utf8')),
+        });
+    }
+    return { valid: errors.length === 0, errors, warnings, activities: checked, pdfMapFile };
+}
+function statePath(planPath) {
+    return `${planPath}.state.json`;
+}
+function loadState(planPath, planHash) {
+    const path = statePath(planPath);
+    if (!existsSync(path))
+        return { version: 1, planHash, activities: {} };
+    let state;
+    try {
+        state = parseJsonFile(path);
+    }
+    catch (error) {
+        fail(`state corrompido (${path}): ${error.message}`);
+    }
+    if (state.version !== 1 || state.planHash !== planHash || typeof state.activities !== 'object') {
+        fail(`state incompatível com o manifesto (${path}); revise-o ou use outro manifesto.`);
+    }
+    return state;
+}
+async function verifyActivities(activities, state) {
+    const errors = [];
+    const inbox = (await apiFetch('/notes/review-inbox'));
+    const byId = new Map(inbox.map((note) => [note.id, note]));
+    for (const activity of activities) {
+        const current = state.activities[activity.id];
+        if (!current) {
+            errors.push(`${activity.id}: ainda não foi estagiada.`);
+            continue;
+        }
+        if (current.ids.length !== activity.items.length) {
+            errors.push(`${activity.id}: ${current.ids.length} IDs para ${activity.items.length} itens.`);
+            continue;
+        }
+        for (const [index, noteId] of current.ids.entries()) {
+            const note = byId.get(noteId);
+            if (!note) {
+                errors.push(`${activity.id}: nota #${noteId} ausente da caixa de revisão.`);
+                continue;
+            }
+            if (note.deckId !== activity.deckId) {
+                errors.push(`${activity.id}/${noteId}: deckId ${note.deckId}, esperado ${activity.deckId}.`);
+            }
+            const body = (await apiFetch(`/notes/${noteId}/material-references`));
+            const expected = activity.items[index].materialReferences ?? [];
+            const actual = body.references;
+            if (actual.length !== expected.length) {
+                errors.push(`${activity.id}/${noteId}: ${actual.length} referências, esperado ${expected.length}.`);
+                continue;
+            }
+            for (const [refIndex, reference] of actual.entries()) {
+                const source = expected[refIndex];
+                if (reference.driveFileId !== source.driveFileId ||
+                    reference.pageIndex + 1 !== source.page ||
+                    (reference.quote ?? undefined) !== source.quote ||
+                    (reference.contextBefore ?? undefined) !== source.contextBefore ||
+                    (reference.contextAfter ?? undefined) !== source.contextAfter ||
+                    JSON.stringify(reference.region ?? null) !== JSON.stringify(source.region ?? null)) {
+                    errors.push(`${activity.id}/${noteId}: referência #${refIndex + 1} divergente.`);
+                }
+            }
+        }
+        if (current.importRunId) {
+            const run = (await apiFetch(`/notes/import-runs/${current.importRunId}`));
+            const linked = new Set(run.noteIds);
+            for (const noteId of current.ids) {
+                if (!linked.has(noteId))
+                    errors.push(`${activity.id}: nota #${noteId} ausente no import run ${current.importRunId}.`);
+            }
+        }
+    }
+    return errors;
+}
+function emit(parsed, result, valid) {
+    if (parsed.flags.json) {
+        printJson(result);
+    }
+    else {
+        process.stdout.write(JSON.stringify(result, null, 2) + '\n');
+    }
+    if (!valid)
+        process.exitCode = 1;
+}
+export async function batchCommand(parsed) {
+    const [sub, planArg] = parsed._;
+    if (!sub || !planArg) {
+        fail('uso: memoring batch <check|run|status|verify> plan.json [--resume] [--json]');
+    }
+    const planPath = resolve(planArg);
+    if (sub === 'status') {
+        const { raw } = loadPlan(planPath);
+        const state = loadState(planPath, sha256(raw));
+        emit(parsed, state, true);
+        return;
+    }
+    const { plan, raw } = loadPlan(planPath);
+    if (sub === 'check') {
+        const result = await checkPlan(planPath, plan);
+        emit(parsed, result, result.valid);
+        return;
+    }
+    if (sub === 'verify') {
+        const checked = await checkPlan(planPath, plan);
+        if (!checked.valid) {
+            emit(parsed, checked, false);
+            return;
+        }
+        const state = loadState(planPath, sha256(raw));
+        const errors = await verifyActivities(checked.activities, state);
+        emit(parsed, { valid: errors.length === 0, errors }, errors.length === 0);
+        return;
+    }
+    if (sub !== 'run') {
+        fail(`subcomando inválido: ${sub}; use check, run, status ou verify.`);
+    }
+    const checked = await checkPlan(planPath, plan);
+    if (!checked.valid) {
+        emit(parsed, checked, false);
+        return;
+    }
+    const state = loadState(planPath, sha256(raw));
+    for (const activity of checked.activities) {
+        let current = state.activities[activity.id];
+        if (current && current.batchHash !== activity.batchHash) {
+            fail(`${activity.id}: o lote mudou desde o último envio; revise o state antes de continuar.`);
+        }
+        if (current?.status === 'verified' && parsed.flags.resume) {
+            continue;
+        }
+        if (!current || current.ids.length !== activity.items.length) {
+            const args = ['stage', 'create', '--file', activity.batchFile];
+            if (activity.generationFile)
+                args.push('--generation-file', activity.generationFile);
+            const created = await runCliJson(args);
+            if (created.code !== 0) {
+                fail(`${activity.id}: stage create falhou: ${created.stderr || created.stdout}`);
+            }
+            if (!Array.isArray(created.data.ids)) {
+                fail(`${activity.id}: stage create não devolveu os IDs esperados.`);
+            }
+            current = {
+                batchHash: activity.batchHash,
+                deckId: activity.deckId,
+                ids: created.data.ids,
+                importRunId: created.data.importRunId ?? null,
+                status: 'staged',
+                updatedAt: new Date().toISOString(),
+            };
+            state.activities[activity.id] = current;
+            writeJsonAtomic(statePath(planPath), state);
+        }
+    }
+    const errors = await verifyActivities(checked.activities, state);
+    if (errors.length === 0) {
+        for (const activity of checked.activities) {
+            state.activities[activity.id].status = 'verified';
+            state.activities[activity.id].updatedAt = new Date().toISOString();
+        }
+        writeJsonAtomic(statePath(planPath), state);
+    }
+    emit(parsed, { valid: errors.length === 0, errors, state }, errors.length === 0);
+    if (errors.length === 0 && !parsed.flags.json) {
+        process.stdout.write(green('Batch enviado e conferido.\n'));
+    }
+    else if (errors.length > 0) {
+        process.stderr.write(yellow(`${errors.length} divergência(s) na auditoria.\n`));
+    }
+}

package/dist/commands/inbox.js

@@ -60,6 +60,7 @@ async function updateInboxItem(parsed, id) {
         subtopicName: overrides.subtopicName ?? stringFlag(flags, 'subtopic') ?? current.subtopicName ?? null,
         tags: overrides.tags ?? (tagsFlag !== undefined ? parseTagsFlag(tagsFlag) : current.tags ?? []),
         source: overrides.source ?? stringFlag(flags, 'source') ?? current.source ?? null,
+        conceptKey: overrides.conceptKey ?? stringFlag(flags, 'concept') ?? current.conceptKey ?? null,
         deckId: deckId ?? overrides.deckId ?? current.deckId ?? null,
         question: overrides.question ?? current.question ?? null,
     };
@@ -166,7 +167,8 @@ export async function inboxCommand(parsed) {
                 '  discard-all  descarta todos os itens pendentes\n' +
                 '  update <id>  edita um item PENDENTE (merge: --file parcial.json e/ou flags\n' +
                 '               --title --content --front --back --subject --subtopic\n' +
-                '               --tags a,b,c --source --type)\n');
+                '               --tags a,b,c --source --concept trib-art-4 --type)\n' +
+                '               (--concept preserva/define o conceptKey; sem ele, o valor atual é mantido)\n');
             if (sub) {
                 process.exitCode = 1;
             }