omnispace 0.6.0 → 0.7.0

package/README.md

@@ -2,7 +2,7 @@
 
 CLI do [Omni](https://omni.tzolkin.cloud): transforma uma pasta da sua máquina em um espaço Omni e sincroniza esse espaço entre máquinas.
 
-> Alpha. Existem `login`, `logout`, `whoami`, `init`, `sync --push`, `sync --pull` e `clone`.
+> Alpha. Existem `login`, `logout`, `whoami`, `init`, `status`, `sync --push`, `sync --pull` e `clone`.
 
 Precisa do Node 20 ou mais novo.
 
@@ -34,6 +34,12 @@ Só ler a pasta, sem vincular nem enviar nada:
 npx -y omnispace@latest init . --scan-only
 ```
 
+Ver o que mudou nesta pasta e no servidor, e qual o próximo comando (só lê, não altera nada):
+
+```
+npx -y omnispace@latest status
+```
+
 Publicar uma nova versão do espaço no servidor:
 
 ```

package/dist/conflicts.js

@@ -27,8 +27,11 @@ export async function addConflicts(root, paths) {
     if (paths.length > 0)
         await writeList(root, [...(await readList(root)), ...paths]);
 }
-/** Paths still holding markers. Resolved (or deleted) files leave the list as a side effect. */
-export async function unresolvedConflicts(root) {
+/**
+ * Paths still holding markers. Resolved (or deleted) files leave the list as a side effect,
+ * unless `readOnly` (omnispace status never writes to the folder).
+ */
+export async function unresolvedConflicts(root, opts = {}) {
     const list = await readList(root);
     const pending = [];
     for (const path of list) {
@@ -40,7 +43,7 @@ export async function unresolvedConflicts(root) {
             // file gone: nothing left to resolve
         }
     }
-    if (pending.length !== list.length)
+    if (!opts.readOnly && pending.length !== list.length)
         await writeList(root, pending);
     return pending;
 }

package/dist/index.js

@@ -13,6 +13,7 @@ import { LockedError } from "./lock.js";
 import { defaultApiUrl, insecureApiUrl } from "./config.js";
 import { login, logout, printWhoami, whoami } from "./login.js";
 import { initWithAccount } from "./init-account.js";
+import { statusSpace } from "./status.js";
 const USAGE = `
 Omni CLI
 
@@ -23,13 +24,14 @@ Uso:
   omni init [pasta] [--nome <nome>] com a CLI logada, cria o espaço na sua conta e liga a pasta
   omni init [pasta] --scan-only     varre a pasta e mostra o que encontrou
   omni init [pasta] --link <código> varre a pasta e envia pro código mostrado no navegador
+  omni status [pasta]               o que mudou aqui e no servidor, e o próximo comando (só lê)
   omni sync [pasta] --push [--yes]  publica uma nova versão do espaço no servidor
   omni sync [pasta] --pull          traz para a pasta a versão mais nova do servidor
         [--conflito=local|mesclar|backup]  mesma resposta para todos os conflitos, sem perguntar
   omni clone <código> <pasta>       baixa um espaço da sua conta numa pasta nova desta máquina
 
-A CLI ainda não reorganiza a sua pasta. O que fazer com o que foi varrido
-é decidido na tela de revisão, no navegador.
+A CLI não reorganiza a sua pasta. Com --link, o que fazer com o que foi
+varrido é decidido na tela de revisão, no navegador.
 `;
 async function main(argv) {
     const args = argv.slice(2);
@@ -53,6 +55,8 @@ async function main(argv) {
         return runSync(args.slice(1));
     if (command === "clone")
         return runClone(args.slice(1));
+    if (command === "status")
+        return statusSpace(resolve(args.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd()));
     if (command !== "init") {
         console.error(`Comando desconhecido: ${command}`);
         console.log(USAGE.trim());

package/dist/status.js

@@ -0,0 +1,159 @@
+import { basename } from "node:path";
+import { callApi } from "./api.js";
+import { RETRY_DELAYS_MS } from "./retry.js";
+import { buildManifest } from "./include.js";
+import { unresolvedConflicts } from "./conflicts.js";
+import { readJournal } from "./journal.js";
+import { planPull } from "./pull.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+/**
+ * What `omnispace status` reports, from the same three-way comparison the pull uses (ADR 002).
+ * A path equal on both sides (same edit made twice) counts as nothing to do.
+ */
+export function summarizeStatus(local, base, head) {
+    const plan = planPull(local, base, head);
+    const kind = (path) => !base.has(path) ? "nova" : !local.has(path) ? "apagada" : "editada";
+    return {
+        local: [...plan.localOnly, ...plan.conflicts].sort().map((path) => ({ path, kind: kind(path) })),
+        remote: plan.writes.length + plan.deletes.length + plan.conflicts.length,
+        both: plan.conflicts,
+    };
+}
+/** The commands to run next, in order. Empty when the folder and the server agree. */
+export function nextSteps(opts) {
+    const { head, baseVersion, summary, markers, pullInterrupted } = opts;
+    if (pullInterrupted)
+        return ["omnispace sync --pull   (termina o pull que parou no meio)"];
+    if (markers.length > 0) {
+        return ["resolva os marcadores de conflito nos arquivos acima", "omnispace sync --push"];
+    }
+    const steps = [];
+    if (head > baseVersion) {
+        steps.push(summary.both.length > 0
+            ? `omnispace sync --pull   (vai pedir decisão em ${summary.both.length} arquivo(s) mudado(s) dos dois lados)`
+            : "omnispace sync --pull");
+    }
+    if (summary.local.length > 0)
+        steps.push("omnispace sync --push");
+    return steps;
+}
+export function timeAgo(iso, now = Date.now()) {
+    const minutes = Math.round((now - new Date(iso).getTime()) / 60000);
+    if (minutes < 1)
+        return "agora";
+    if (minutes < 60)
+        return `há ${minutes} min`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 24)
+        return `há ${hours} h`;
+    return `há ${Math.round(hours / 24)} d`;
+}
+const KIND_MARK = { nova: "+", editada: "~", apagada: "-" };
+function listChanges(changes, max = 20) {
+    for (const change of changes.slice(0, max))
+        console.log(`    ${KIND_MARK[change.kind]} ${change.path}`);
+    if (changes.length > max)
+        console.log(`    ... e mais ${changes.length - max}`);
+}
+function countKinds(changes) {
+    const parts = ["editada", "nova", "apagada"]
+        .map((k) => [k, changes.filter((c) => c.kind === k).length])
+        .filter(([, n]) => n > 0)
+        .map(([k, n]) => `${n} ${n === 1 ? k : `${k}s`}`);
+    return parts.join(", ");
+}
+/**
+ * `omnispace status` (P1, docs/plan/p1-continuidade-visivel.md): what this folder has that the
+ * server does not, what the server has that the folder does not, and the next command. Read only:
+ * no lock, nothing written to the folder or to `.omni/`.
+ */
+export async function statusSpace(root) {
+    const config = await readSpaceConfig(root);
+    if (!config) {
+        console.log(`\n${basename(root)} não é um espaço Omni (não tem .omni/space.json).`);
+        console.log("Para transformar esta pasta num espaço: omnispace init\n");
+        return 1;
+    }
+    if (!config.spaceId) {
+        console.log("\nEsta pasta foi vinculada pelo navegador, mas o espaço ainda não foi criado.");
+        console.log("Termine a conta no navegador e depois rode: omnispace sync --push\n");
+        return 1;
+    }
+    const token = await loadToken(config.apiUrl);
+    if (!token) {
+        console.log(`\nNenhuma sessão da CLI nesta máquina para ${config.apiUrl}.`);
+        console.log("Para entrar: omnispace login\n");
+        return 1;
+    }
+    const [journal, markers] = await Promise.all([readJournal(root), unresolvedConflicts(root, { readOnly: true })]);
+    console.log("\n→ Lendo a pasta...");
+    const manifest = await buildManifest(root);
+    if (manifest.truncated) {
+        console.error("Pasta grande ou funda demais para comparar (limite de 20.000 arquivos e 12 níveis).");
+        return 1;
+    }
+    const res = await callApi(config.apiUrl, token, "/api/cli/sync/status", { spaceId: config.spaceId, baseVersion: config.baseVersion }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok) {
+        console.log(`\nServidor não consultado: ${res.error}`);
+        if (res.expired || res.status === 401)
+            console.log("Para entrar de novo: omnispace login");
+        console.log(`Esta pasta está na versão ${config.baseVersion}. Sem o servidor não dá para dizer o que mudou.\n`);
+        return 1;
+    }
+    const head = res.head;
+    const headMap = new Map(res.files.map((f) => [f.path, f.hash]));
+    const baseMap = res.base ? new Map(res.base.map((f) => [f.path, f.hash])) : headMap;
+    const local = new Map(manifest.files.map((f) => [f.path, f.hash]));
+    // An unreadable file is missing from the manifest; left in, it would show up as deleted here.
+    const skip = (path) => manifest.unreadable.some((u) => path === u || path.startsWith(`${u}/`));
+    const readable = (map) => new Map([...map].filter(([path]) => !skip(path)));
+    const summary = summarizeStatus(local, readable(baseMap), readable(headMap));
+    console.log(`\nEspaço: ${res.name} (${res.slug})`);
+    console.log(`Nesta pasta: ${config.baseVersion === 0 ? "nenhuma versão ainda" : `versão ${config.baseVersion}`}`);
+    if (head === 0) {
+        console.log("No servidor: nenhuma versão publicada ainda");
+    }
+    else {
+        const when = res.publishedAt ? `, publicada ${timeAgo(res.publishedAt)}` : "";
+        const who = res.publishedBy ? ` por ${res.publishedBy}` : "";
+        console.log(`No servidor: versão ${head}${when}${who}`);
+    }
+    if (summary.local.length > 0) {
+        console.log(`\nMudanças nesta pasta ainda não enviadas: ${summary.local.length} (${countKinds(summary.local)})`);
+        listChanges(summary.local);
+    }
+    if (head > config.baseVersion) {
+        console.log(`\nNo servidor há ${summary.remote} arquivo(s) diferente(s) da versão desta pasta.`);
+    }
+    if (summary.both.length > 0) {
+        console.log(`\nMudados dos dois lados (o pull pergunta o que fazer):`);
+        for (const path of summary.both.slice(0, 20))
+            console.log(`    ${path}`);
+    }
+    if (markers.length > 0) {
+        console.log("\nAinda com marcadores de conflito (<<<<<<< esta máquina), o push recusa até serem editados:");
+        for (const path of markers)
+            console.log(`    ${path}`);
+    }
+    if (manifest.unreadable.length > 0) {
+        console.log(`\n${manifest.unreadable.length} arquivo(s) não puderam ser lidos (abertos em outro programa?); a comparação ignora esses.`);
+    }
+    const steps = nextSteps({
+        head,
+        baseVersion: config.baseVersion,
+        summary,
+        markers,
+        pullInterrupted: journal !== null,
+    });
+    if (journal)
+        console.log(`\nUm pull da versão ${journal.head} parou no meio.`);
+    if (steps.length === 0) {
+        console.log(head === 0 ? "\n✓ Pasta vazia e nada publicado ainda.\n" : `\n✓ Em dia com a versão ${head}.\n`);
+    }
+    else {
+        console.log("\nPróximo passo:");
+        steps.forEach((step, i) => console.log(`  ${i + 1}. ${step}`));
+        console.log("");
+    }
+    return 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omnispace",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Omni CLI (alpha): transforma uma pasta da sua máquina em um espaço Omni e sincroniza entre máquinas.",
   "type": "module",
   "bin": {