omnispace 0.16.0 → 0.17.1

package/dist/auto-sync.js

@@ -0,0 +1,99 @@
+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 { pullSpace, remoteMap } from "./pull.js";
+import { pushSpace } from "./sync.js";
+import { LockedError, withLock } from "./lock.js";
+import { loadToken, readSpaceConfig } from "./config.js";
+import { statusSpace, summarizeStatus } from "./status.js";
+/** What to do given the three-way summary. A file changed on both sides stops everything. */
+export function planAuto(summary, head, baseVersion, pullOnly) {
+    if (summary.both.length > 0)
+        return { kind: "diverged", files: summary.both };
+    const pull = head > baseVersion;
+    const push = !pullOnly && summary.local.length > 0;
+    return pull || push ? { kind: "sync", pull, push } : { kind: "nothing" };
+}
+/** Runs `fn` with console output captured: pull and push talk a lot, a hook must say one line. */
+async function captured(fn) {
+    const lines = [];
+    const saved = { log: console.log, error: console.error };
+    const grab = (...args) => void lines.push(args.join(" "));
+    console.log = grab;
+    console.error = grab;
+    try {
+        const code = await fn();
+        const last = [...lines].reverse().map((l) => l.trim()).find((l) => l.length > 0) ?? "";
+        return { code, last };
+    }
+    finally {
+        console.log = saved.log;
+        console.error = saved.error;
+    }
+}
+async function autoOnce(root, opts, deps) {
+    const config = await readSpaceConfig(root);
+    if (!config?.spaceId)
+        return null;
+    const token = await loadToken(config.apiUrl);
+    if (!token)
+        return "CLI sem sessão nesta máquina; rode omnispace login (sync automático parado).";
+    const [journal, markers] = await Promise.all([readJournal(root), unresolvedConflicts(root, { readOnly: true })]);
+    if (journal)
+        return "um pull parou no meio; rode omnispace sync --pull.";
+    if (markers.length > 0)
+        return `${markers.length} arquivo(s) com marcador de conflito; resolva antes do sync automático.`;
+    const manifest = await buildManifest(root);
+    if (manifest.truncated)
+        return "pasta grande demais para o sync automático.";
+    const res = await callApi(config.apiUrl, token, "/api/cli/sync/status", { spaceId: config.spaceId, baseVersion: config.baseVersion }, { retryDelaysMs: RETRY_DELAYS_MS });
+    if (!res.ok)
+        return `servidor não consultado (${res.error}); sync automático adiado.`;
+    const head = res.head;
+    const headMap = remoteMap(res.files);
+    const baseMap = res.base ? remoteMap(res.base) : headMap;
+    const local = new Map(manifest.files.map((f) => [f.path, f.hash]));
+    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));
+    const plan = planAuto(summary, head, config.baseVersion, Boolean(opts.pullOnly));
+    if (plan.kind === "nothing")
+        return null;
+    if (plan.kind === "diverged") {
+        return `${plan.files.length} arquivo(s) mudado(s) nesta pasta e no servidor (${plan.files.slice(0, 3).join(", ")}); sync automático parado, rode omnispace sync --pull para decidir.`;
+    }
+    const parts = [];
+    if (plan.pull) {
+        // conflito: "backup" only matters if a race creates a conflict after the check: it keeps both.
+        const r = await captured(() => deps.pull(root, { conflito: "backup" }));
+        if (r.code !== 0)
+            return `pull automático não terminou: ${r.last || "erro sem mensagem"}`;
+        if (summary.remote > 0)
+            parts.push(`trouxe ${summary.remote} arquivo(s) do servidor`);
+    }
+    if (plan.push) {
+        const r = await captured(() => deps.push(root, { yes: true }));
+        if (r.code !== 0)
+            return `${parts.length ? `${parts.join(", ")}; ` : ""}envio automático não feito: ${r.last || "erro sem mensagem"}`;
+        const after = await readSpaceConfig(root);
+        parts.push(`enviei ${summary.local.length} arquivo(s)${after ? ` (versão ${after.baseVersion})` : ""}`);
+    }
+    return parts.length > 0 ? parts.join(", ") : null;
+}
+export async function syncAuto(root, opts = {}, deps = { pull: pullSpace, push: pushSpace }) {
+    try {
+        const line = await withLock(root, () => autoOnce(root, opts, deps));
+        if (line)
+            console.log(`Omni: sync automático: ${line}`);
+    }
+    catch (err) {
+        // Another sync (another agent in the same folder) holds the lock: it does the work.
+        if (!(err instanceof LockedError))
+            console.log(`Omni: sync automático falhou (${err.message.slice(0, 160)}).`);
+    }
+    if (opts.resumo)
+        await statusSpace(root, { resumo: true });
+    return 0;
+}

package/dist/hooks.js

@@ -0,0 +1,90 @@
+import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+// Hooks do Claude Code que mantêm a pasta em dia sem a pessoa pedir (checklist 2 de
+// docs/plan/visao-jarvis-automacao-2026-09-28.md). Vão em `.claude/settings.json`, que sincroniza
+// entre máquinas: os comandos são iguais em qualquer sistema, ao contrário dos arquivos de MCP.
+//   SessionStart: `omnispace sync --auto --pull-only --resumo` (traz o que chegou e diz o estado;
+//                 troca o `omnispace status --resumo` antigo, que rodaria em paralelo e leria o estado velho)
+//   SessionEnd:   `omnispace sync --auto` (traz e envia o que mudou, sem conflito)
+export const START_COMMAND = "omnispace sync --auto --pull-only --resumo";
+export const END_COMMAND = "omnispace sync --auto";
+const OLD_START = /^\s*(omnispace|omni)\s+status\s+--resumo\s*$/;
+function hasCommand(groups, test) {
+    return groups.some((g) => (g.hooks ?? []).some((h) => typeof h.command === "string" && test(h.command)));
+}
+/** Pure merge: returns the new settings and whether anything changed. Never removes another hook. */
+export function mergeHooks(settings) {
+    const next = { ...settings, hooks: { ...(settings.hooks ?? {}) } };
+    const hooks = next.hooks;
+    let changed = false;
+    const start = (hooks.SessionStart ?? []).map((g) => ({ ...g, hooks: (g.hooks ?? []).map((h) => ({ ...h })) }));
+    if (!hasCommand(start, (c) => c.includes("sync --auto"))) {
+        let replaced = false;
+        for (const group of start) {
+            for (const h of group.hooks ?? []) {
+                if (typeof h.command === "string" && OLD_START.test(h.command)) {
+                    h.command = START_COMMAND;
+                    replaced = true;
+                }
+            }
+        }
+        if (!replaced)
+            start.push({ matcher: "startup|resume", hooks: [{ type: "command", command: START_COMMAND, timeout: 90 }] });
+        hooks.SessionStart = start;
+        changed = true;
+    }
+    const end = (hooks.SessionEnd ?? []).map((g) => ({ ...g, hooks: (g.hooks ?? []).map((h) => ({ ...h })) }));
+    if (!hasCommand(end, (c) => c.includes("sync --auto"))) {
+        end.push({ hooks: [{ type: "command", command: END_COMMAND, timeout: 90 }] });
+        hooks.SessionEnd = end;
+        changed = true;
+    }
+    return { next, changed };
+}
+/** `.claude/settings.json` of the folder. Unreadable (comments, broken JSON): untouched, reported. */
+export async function installHooks(folder) {
+    const path = join(folder, ".claude", "settings.json");
+    let settings = {};
+    let raw;
+    try {
+        raw = await readFile(path, "utf8");
+    }
+    catch {
+        raw = undefined;
+    }
+    if (raw !== undefined) {
+        try {
+            settings = JSON.parse(raw);
+        }
+        catch {
+            return { path, changed: false, skipped: true };
+        }
+    }
+    const { next, changed } = mergeHooks(settings);
+    if (!changed)
+        return { path, changed: false, skipped: false };
+    await mkdir(dirname(path), { recursive: true });
+    const tmp = `${path}.${process.pid}.tmp`;
+    await writeFile(tmp, `${JSON.stringify(next, null, 2)}\n`, "utf8");
+    await rename(tmp, path);
+    return { path, changed: true, skipped: false };
+}
+// Depois de sync, clone, vincular e init (junto do MCP): liga os hooks sozinho na pasta de espaço.
+// Só fala quando mudou algo; `OMNI_NO_HOOKS=1` desliga.
+export async function autoWireHooks(folder) {
+    if (process.env.OMNI_NO_HOOKS)
+        return;
+    try {
+        if (!(await readFile(join(folder, ".omni", "space.json"), "utf8").then(() => true, () => false)))
+            return;
+        const r = await installHooks(folder);
+        if (r.changed) {
+            console.log(`\nSync automático ligado nos hooks do Claude Code (${r.path}): traz o que chegou ao abrir a sessão e envia o que mudou ao fechar. Conflito nunca é forçado.`);
+        }
+        if (r.skipped)
+            console.log(`\nNão mexi em ${r.path} (comentários ou JSON quebrado). Para ligar o sync automático, adicione os hooks à mão: rode omnispace hooks instalar depois de corrigir o arquivo.`);
+    }
+    catch {
+        // ligar os hooks nunca derruba o comando que a pessoa rodou
+    }
+}

package/dist/index.js

@@ -22,6 +22,8 @@ import { runPermissoes } from "./permissoes.js";
 import { runUso } from "./uso.js";
 import { runLlm } from "./llm.js";
 import { confirmarSpace } from "./confirmar.js";
+import { syncAuto } from "./auto-sync.js";
+import { autoWireHooks, installHooks } from "./hooks.js";
 import { autoWireMcp, detectEditors, installMcpConfig, mcpNextSteps, mcpSkippedNote, runMcpServer } from "./mcp.js";
 const USAGE = `
 Omni CLI
@@ -49,6 +51,8 @@ Uso:
   omni llm [set anthropic|rm]       usar a sua chave da Anthropic no lugar do modelo do Omni, com teto diário
   omni mcp                          servidor MCP local (stdio) pro Claude Code e pro Cursor lerem este espaço
   omni mcp instalar [pasta]         acrescenta o servidor omni ao MCP do Claude Code, Cursor (e VS Code, Trae se a pasta usa) (mescla, nunca apaga outro)
+  omni sync [pasta] --auto [--pull-only] [--resumo]  o que os hooks rodam: traz e envia sem perguntar, para se houver conflito
+  omni hooks instalar [pasta]       liga o sync automático nos hooks do Claude Code da pasta (mescla, nunca apaga outro)
   omni confirmar [pedido] [pasta]   decide s/n um pedido pendente de escrita, visto por inteiro no terminal
 
 A CLI não reorganiza a sua pasta. Com --link, o que fazer com o que foi
@@ -74,6 +78,12 @@ async function main(argv) {
         return printWhoami();
     if (command === "sync") {
         const rest = args.slice(1);
+        if (rest.includes("--auto")) {
+            return syncAuto(resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd()), {
+                pullOnly: rest.includes("--pull-only"),
+                resumo: rest.includes("--resumo"),
+            });
+        }
         return withMcp(await runSync(rest), resolve(rest.find((a) => !a.startsWith("-")) ?? process.cwd()));
     }
     if (command === "clone") {
@@ -103,6 +113,23 @@ async function main(argv) {
         }
         return runMcpServer(process.cwd());
     }
+    if (command === "hooks") {
+        const rest = args.slice(1);
+        if (rest[0] !== "instalar") {
+            console.error("Use omnispace hooks instalar [pasta].");
+            return 1;
+        }
+        const folder = resolve(rest.slice(1).find((a) => !a.startsWith("-")) ?? process.cwd());
+        const r = await installHooks(folder);
+        console.log(r.skipped ? `
+Não mexi em ${r.path}: comentários ou JSON quebrado. Corrija e rode de novo.
+` : r.changed ? `
+Hooks de sync automático ligados em ${r.path}.
+` : `
+Os hooks já estavam em ${r.path}.
+`);
+        return r.skipped ? 1 : 0;
+    }
     if (command === "confirmar") {
         const rest = args.slice(1);
         const pedido = rest.find((a) => !a.startsWith("-"));
@@ -211,8 +238,10 @@ Só quer ver o que o Omni leria nesta pasta, sem enviar nada?
     return 0;
 }
 async function withMcp(code, folder) {
-    if (code === 0)
+    if (code === 0) {
         await autoWireMcp(folder);
+        await autoWireHooks(folder);
+    }
     return code;
 }
 async function runSync(rest) {

package/package.json

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