@memoring/cli 0.12.1 → 0.15.0

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`);
+}