@gobi-ai/cli 0.6.1 → 0.6.3

package/dist/commands/sense.js

@@ -8,18 +8,13 @@ export function registerSenseCommand(program) {
     sense
         .command("activities")
         .description("Fetch activity records within a time range.")
-        .requiredOption("--timezone <tz>", "IANA timezone (e.g. America/New_York)")
-        .option("--start-time <iso>", "Start of time range (ISO 8601, inclusive)")
-        .option("--end-time <iso>", "End of time range (ISO 8601, inclusive); requires --start-time")
+        .requiredOption("--start-time <iso>", "Start of time range (ISO 8601 UTC, e.g. 2026-03-20T00:00:00Z)")
+        .requiredOption("--end-time <iso>", "End of time range (ISO 8601 UTC, e.g. 2026-03-20T23:59:59Z)")
         .action(async (opts) => {
-        if (opts.endTime && !opts.startTime) {
-            throw new Error("--end-time requires --start-time.");
-        }
-        const params = { timezone: opts.timezone };
-        if (opts.startTime)
-            params.startTime = opts.startTime;
-        if (opts.endTime)
-            params.endTime = opts.endTime;
+        const params = {
+            startTime: opts.startTime,
+            endTime: opts.endTime,
+        };
         const resp = (await apiGet("/app/activities", params));
         const activities = (resp.activities || []);
         const pagination = (resp.pagination || {});
@@ -46,18 +41,13 @@ export function registerSenseCommand(program) {
     sense
         .command("transcriptions")
         .description("Fetch transcription records within a time range.")
-        .requiredOption("--timezone <tz>", "IANA timezone (e.g. America/New_York)")
-        .option("--start-time <iso>", "Start of time range (ISO 8601, inclusive)")
-        .option("--end-time <iso>", "End of time range (ISO 8601, inclusive); requires --start-time")
+        .requiredOption("--start-time <iso>", "Start of time range (ISO 8601 UTC, e.g. 2026-03-20T00:00:00Z)")
+        .requiredOption("--end-time <iso>", "End of time range (ISO 8601 UTC, e.g. 2026-03-20T23:59:59Z)")
         .action(async (opts) => {
-        if (opts.endTime && !opts.startTime) {
-            throw new Error("--end-time requires --start-time.");
-        }
-        const params = { timezone: opts.timezone };
-        if (opts.startTime)
-            params.startTime = opts.startTime;
-        if (opts.endTime)
-            params.endTime = opts.endTime;
+        const params = {
+            startTime: opts.startTime,
+            endTime: opts.endTime,
+        };
         const resp = (await apiGet("/app/transcriptions", params));
         const transcriptions = (resp.transcriptions || []);
         const pagination = (resp.pagination || {});

package/dist/commands/sync.js

@@ -0,0 +1,618 @@
+import { createHash } from "crypto";
+import { existsSync, readFileSync, rmSync, mkdirSync, readdirSync, statSync } from "fs";
+import { writeFile } from "fs/promises";
+import { join, dirname, extname, resolve as pathResolve } from "path";
+import Database from "better-sqlite3";
+import inquirer from "inquirer";
+import ignore from "ignore";
+import trash from "trash";
+import { WEBDRIVE_BASE_URL } from "../constants.js";
+import { getValidToken } from "../auth/manager.js";
+import { GobiError } from "../errors.js";
+import { getVaultSlug } from "./init.js";
+import { isJsonMode, jsonOut } from "./utils.js";
+// ─── Constants ────────────────────────────────────────────────────────────────
+const SYNC_IGNORE_NAMES = new Set([
+    ".gobi",
+    ".DS_Store",
+    "Thumbs.db",
+    "desktop.ini",
+    ".git",
+    ".gitignore",
+    ".gitattributes",
+    ".vscode",
+    ".idea",
+    ".cursor",
+    ".claude",
+    "node_modules",
+    ".npm",
+    ".yarn",
+    "__pycache__",
+    ".env",
+    "venv",
+    ".venv",
+    ".Spotlight-V100",
+    ".Trashes",
+    ".fseventsd",
+]);
+const SYNC_IGNORE_EXTENSIONS = new Set([".pyc", ".tmp", ".temp"]);
+// ─── Ignore Patterns ──────────────────────────────────────────────────────────
+export function isSyncIgnored(relativePath) {
+    const parts = relativePath.split("/");
+    for (const part of parts) {
+        if (SYNC_IGNORE_NAMES.has(part))
+            return true;
+        const ext = extname(part).toLowerCase();
+        if (ext && SYNC_IGNORE_EXTENSIONS.has(ext))
+            return true;
+        if (part.startsWith("._"))
+            return true; // macOS resource forks
+    }
+    return false;
+}
+// ─── State (SQLite) ───────────────────────────────────────────────────────────
+const EMPTY_STATE = {
+    cursor: null,
+    syncfilesHash: null,
+    patterns: [],
+    hashCache: {},
+};
+function openDb(gobiDir) {
+    const db = new Database(join(gobiDir, "sync.db"));
+    db.pragma("journal_mode = WAL");
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS sync_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+    CREATE TABLE IF NOT EXISTS hash_cache (
+      path  TEXT PRIMARY KEY,
+      hash  TEXT NOT NULL,
+      mtime REAL NOT NULL,
+      size  INTEGER NOT NULL
+    );
+  `);
+    return db;
+}
+export function loadSyncState(gobiDir) {
+    // One-time migration from legacy sync_state.json
+    const jsonPath = join(gobiDir, "sync_state.json");
+    if (existsSync(jsonPath)) {
+        try {
+            const parsed = JSON.parse(readFileSync(jsonPath, "utf-8"));
+            const state = {
+                cursor: parsed.cursor ?? null,
+                syncfilesHash: parsed.syncfilesHash ?? null,
+                patterns: parsed.patterns ?? [],
+                hashCache: parsed.hashCache ?? {},
+            };
+            saveSyncState(gobiDir, state);
+            rmSync(jsonPath);
+            return state;
+        }
+        catch {
+            rmSync(jsonPath, { force: true });
+            return { ...EMPTY_STATE, hashCache: {} };
+        }
+    }
+    const db = openDb(gobiDir);
+    try {
+        const meta = db.prepare("SELECT key, value FROM sync_meta").all();
+        const metaMap = Object.fromEntries(meta.map((r) => [r.key, r.value]));
+        const rows = db.prepare("SELECT path, hash, mtime, size FROM hash_cache").all();
+        const hashCache = {};
+        for (const row of rows) {
+            hashCache[row.path] = { hash: row.hash, mtime: row.mtime, size: row.size };
+        }
+        return {
+            cursor: metaMap.cursor ? Number(metaMap.cursor) : EMPTY_STATE.cursor,
+            syncfilesHash: metaMap.syncfiles_hash || EMPTY_STATE.syncfilesHash,
+            patterns: metaMap.patterns ? JSON.parse(metaMap.patterns) : EMPTY_STATE.patterns,
+            hashCache,
+        };
+    }
+    finally {
+        db.close();
+    }
+}
+export function saveSyncState(gobiDir, state) {
+    const db = openDb(gobiDir);
+    try {
+        db.transaction(() => {
+            const upsert = db.prepare("INSERT OR REPLACE INTO sync_meta (key, value) VALUES (?, ?)");
+            upsert.run("cursor", state.cursor !== null ? String(state.cursor) : "");
+            upsert.run("syncfiles_hash", state.syncfilesHash ?? "");
+            upsert.run("patterns", JSON.stringify(state.patterns));
+            db.exec("DELETE FROM hash_cache");
+            const insert = db.prepare("INSERT INTO hash_cache (path, hash, mtime, size) VALUES (?, ?, ?, ?)");
+            for (const [path, entry] of Object.entries(state.hashCache)) {
+                insert.run(path, entry.hash, entry.mtime, entry.size);
+            }
+        })();
+    }
+    finally {
+        db.close();
+    }
+}
+// ─── Syncfiles ────────────────────────────────────────────────────────────────
+export function readSyncfiles(gobiDir) {
+    const syncfilesPath = join(gobiDir, "syncfiles");
+    if (!existsSync(syncfilesPath)) {
+        return { patterns: [], contentHash: "" };
+    }
+    const content = readFileSync(syncfilesPath, "utf-8");
+    const patterns = content
+        .split("\n")
+        .map((l) => l.trim())
+        .filter((l) => l.length > 0 && !l.startsWith("#"));
+    const contentHash = createHash("md5").update(content).digest("hex");
+    return { patterns, contentHash };
+}
+export function buildWhitelistMatcher(patterns) {
+    if (patterns.length === 0)
+        return () => false;
+    const ig = ignore().add(patterns);
+    return (filePath) => ig.ignores(filePath.replace(/\\/g, "/"));
+}
+export function computeSyncfilesChanges(prevPatterns, currPatterns) {
+    const prevSet = new Set(prevPatterns);
+    const currSet = new Set(currPatterns);
+    return {
+        added: currPatterns.filter((p) => !prevSet.has(p)),
+        removed: prevPatterns.filter((p) => !currSet.has(p)),
+    };
+}
+// ─── Hashing ──────────────────────────────────────────────────────────────────
+export function md5Hex(content) {
+    return createHash("md5").update(content).digest("hex");
+}
+function hashFile(absPath, relPath, cache) {
+    const stat = statSync(absPath);
+    const cached = cache[relPath];
+    if (cached && cached.mtime === stat.mtimeMs && cached.size === stat.size) {
+        return cached;
+    }
+    const content = readFileSync(absPath);
+    return { hash: md5Hex(content), mtime: stat.mtimeMs, size: stat.size };
+}
+// ─── File Walking ─────────────────────────────────────────────────────────────
+function walkDir(dir, base, results) {
+    for (const entry of readdirSync(dir, { withFileTypes: true })) {
+        const relPath = base ? `${base}/${entry.name}` : entry.name;
+        if (isSyncIgnored(relPath))
+            continue;
+        if (entry.isDirectory()) {
+            walkDir(join(dir, entry.name), relPath, results);
+        }
+        else if (entry.isFile()) {
+            results.push(relPath);
+        }
+    }
+}
+function walkLocalFiles(vaultDir, cache, isWhitelisted) {
+    const allRelPaths = [];
+    walkDir(vaultDir, "", allRelPaths);
+    const files = [];
+    for (const relPath of allRelPaths) {
+        if (!isWhitelisted(relPath))
+            continue;
+        const absPath = join(vaultDir, relPath);
+        try {
+            const entry = hashFile(absPath, relPath, cache);
+            files.push({ path: relPath, hash: entry.hash, mtime: entry.mtime });
+            // Update cache in-place
+            cache[relPath] = entry;
+        }
+        catch {
+            // File may have been removed between walk and hash; skip it
+        }
+    }
+    return files;
+}
+// ─── HTTP ─────────────────────────────────────────────────────────────────────
+function fileUrl(baseUrl, vaultSlug, filePath) {
+    const encoded = filePath
+        .split("/")
+        .map((s) => encodeURIComponent(s))
+        .join("/");
+    return `${baseUrl}/api/v1/vaults/${vaultSlug}/files/${encoded}`;
+}
+async function webdriveGet(baseUrl, vaultSlug, filePath, token) {
+    const res = await fetch(fileUrl(baseUrl, vaultSlug, filePath), {
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    }
+    return Buffer.from(await res.arrayBuffer());
+}
+async function webdrivePut(baseUrl, vaultSlug, filePath, content, hash, token) {
+    const res = await fetch(fileUrl(baseUrl, vaultSlug, filePath), {
+        method: "PUT",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/octet-stream",
+            "X-Content-MD5": hash,
+        },
+        body: new Uint8Array(content),
+    });
+    if (!res.ok) {
+        throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    }
+    const cursor = res.headers.get("x-cursor");
+    return cursor ? Number(cursor) : null;
+}
+async function webdriveDelete(baseUrl, vaultSlug, filePath, token) {
+    const res = await fetch(fileUrl(baseUrl, vaultSlug, filePath), {
+        method: "DELETE",
+        headers: { Authorization: `Bearer ${token}` },
+    });
+    if (!res.ok && res.status !== 404) {
+        throw new Error(`HTTP ${res.status}: ${await res.text()}`);
+    }
+    const cursor = res.headers.get("x-cursor");
+    return cursor ? Number(cursor) : null;
+}
+async function webdriveSync(baseUrl, vaultSlug, body, token) {
+    const url = `${baseUrl}/api/v1/vaults/${vaultSlug}/sync`;
+    const res = await fetch(url, {
+        method: "POST",
+        headers: {
+            Authorization: `Bearer ${token}`,
+            "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        if (res.status === 409) {
+            const err = new GobiError("Sync cursor invalid", "SYNC_CURSOR_INVALID");
+            err.status = 409;
+            throw err;
+        }
+        throw new Error(`Sync request failed: HTTP ${res.status}: ${await res.text()}`);
+    }
+    return (await res.json());
+}
+// ─── Conflict Resolution ──────────────────────────────────────────────────────
+function formatDate(ms) {
+    return new Date(ms).toLocaleString();
+}
+async function resolveConflict(filePath, strategy, conflict, jsonMode) {
+    if (strategy === "server")
+        return "server";
+    if (strategy === "client")
+        return "client";
+    if (strategy === "skip")
+        return "skip";
+    // strategy === "ask"
+    if (jsonMode) {
+        // Can't show interactive prompt in JSON mode
+        return "skip";
+    }
+    const serverTime = conflict ? formatDate(conflict.serverMtime) : "unknown";
+    const clientTime = conflict ? formatDate(conflict.clientMtime) : "unknown";
+    const { choice } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "choice",
+            message: `Conflict: ${filePath}\n  Server modified: ${serverTime}\n  Local  modified: ${clientTime}`,
+            choices: [
+                { name: "Keep server version (overwrite local)", value: "server" },
+                { name: "Keep local version (skip download)", value: "client" },
+                { name: "Skip (resolve later)", value: "skip" },
+            ],
+        },
+    ]);
+    return choice;
+}
+// ─── Path Filtering ──────────────────────────────────────────────────────────
+/**
+ * Returns true if filePath is at or under any of the specified paths.
+ * An empty paths array matches everything.
+ */
+function matchesPaths(filePath, paths) {
+    if (paths.length === 0)
+        return true;
+    const normalized = filePath.replace(/\\/g, "/");
+    for (const p of paths) {
+        const np = p.replace(/\\/g, "/").replace(/\/+$/, "");
+        if (normalized === np || normalized.startsWith(np + "/"))
+            return true;
+    }
+    return false;
+}
+// ─── Core Sync ────────────────────────────────────────────────────────────────
+async function performSync(baseUrl, vaultSlug, state, syncfilesChanges, localFiles, opts, token) {
+    const body = {
+        cursor: state.cursor,
+        syncfilesChanges,
+        clientFiles: localFiles,
+        uploadOnly: opts.uploadOnly,
+        downloadOnly: opts.downloadOnly,
+    };
+    return await webdriveSync(baseUrl, vaultSlug, body, token);
+}
+export async function runSync(opts) {
+    const { vaultSlug, dir: vaultDir, jsonMode } = opts;
+    const baseUrl = opts.webdriveUrl ?? WEBDRIVE_BASE_URL;
+    const gobiDir = join(vaultDir, ".gobi");
+    mkdirSync(gobiDir, { recursive: true });
+    const state = loadSyncState(gobiDir);
+    // --full: treat this run as a first-time sync (re-check every file against the server)
+    if (opts.full) {
+        state.cursor = null;
+        state.hashCache = {};
+        if (!jsonMode)
+            console.log("Full sync: ignoring cursor and hash cache.");
+    }
+    const token = opts.authToken ?? (await getValidToken());
+    // Read syncfiles whitelist
+    const { patterns: currPatterns, contentHash: currSyncfilesHash } = readSyncfiles(gobiDir);
+    if (currPatterns.length === 0 && !jsonMode) {
+        console.warn("Warning: No patterns found in .gobi/syncfiles. Nothing will be synced.\n" +
+            "Add gitignore-style patterns to .gobi/syncfiles to select files for sync.");
+    }
+    const isWhitelisted = buildWhitelistMatcher(currPatterns);
+    const syncfilesChanges = computeSyncfilesChanges(state.patterns, currPatterns);
+    // Walk local files (only whitelisted, non-ignored)
+    if (!jsonMode)
+        process.stdout.write("Scanning local files...");
+    const localFiles = walkLocalFiles(vaultDir, state.hashCache, isWhitelisted);
+    if (!jsonMode)
+        console.log(` ${localFiles.length} file(s) found.`);
+    const localPathSet = new Set(localFiles.map((f) => f.path));
+    // Detect and send offline deletions
+    let maxMutationCursor = null;
+    for (const cachedPath of Object.keys(state.hashCache)) {
+        if (!localPathSet.has(cachedPath) && !existsSync(join(vaultDir, cachedPath))) {
+            // File was in our cache but no longer on disk — deleted offline.
+            // In download-only mode, skip the DELETE: the server's client_deleted_paths
+            // mechanism will re-download the file instead (server-side download_only path).
+            if (opts.downloadOnly)
+                continue;
+            if (!opts.jsonMode)
+                console.log(`  Deleting remote (offline deletion): ${cachedPath}`);
+            if (!opts.dryRun) {
+                try {
+                    const cursor = await webdriveDelete(baseUrl, vaultSlug, cachedPath, token);
+                    if (cursor !== null && (maxMutationCursor === null || cursor > maxMutationCursor)) {
+                        maxMutationCursor = cursor;
+                    }
+                }
+                catch (err) {
+                    if (!jsonMode)
+                        console.error(`  Error deleting remote ${cachedPath}: ${err.message}`);
+                }
+                delete state.hashCache[cachedPath];
+            }
+        }
+    }
+    // In dry-run mode, include cached-but-locally-deleted files in clientFiles so the
+    // server does not propagate the deletion (the whole point of dry-run is no changes).
+    const clientFilesForSync = opts.dryRun
+        ? [
+            ...localFiles,
+            ...Object.entries(state.hashCache)
+                .filter(([p]) => !localPathSet.has(p) && !existsSync(join(vaultDir, p)))
+                .map(([path, entry]) => ({ path, hash: entry.hash, mtime: entry.mtime })),
+        ]
+        : localFiles;
+    // POST sync request
+    if (!jsonMode)
+        process.stdout.write("Syncing with server...");
+    let syncResp;
+    try {
+        syncResp = await performSync(baseUrl, vaultSlug, state, syncfilesChanges, clientFilesForSync, opts, token);
+    }
+    catch (err) {
+        if (err instanceof GobiError && err.status === 409) {
+            // Cursor is stale (server wiped the vault or syncfiles are missing).
+            // Reset all state including patterns so the retry re-registers current patterns
+            // as "added" — this allows vault resurrection after the server deleted an empty vault.
+            if (!jsonMode)
+                console.log("Sync cursor stale, resetting state and retrying...");
+            state.cursor = null;
+            state.hashCache = {};
+            state.patterns = []; // reset so retry sends currPatterns as syncfilesChanges.added
+            const retryChanges = computeSyncfilesChanges([], currPatterns);
+            syncResp = await performSync(baseUrl, vaultSlug, state, retryChanges, clientFilesForSync, opts, token);
+        }
+        else {
+            throw err;
+        }
+    }
+    if (!jsonMode)
+        console.log(` ${syncResp.files.length} action(s).`);
+    // Process actions
+    let uploaded = 0, downloaded = 0, deletedLocally = 0, conflicts = 0, skipped = 0, errors = 0;
+    const errorDetails = [];
+    const conflictWarnings = [];
+    const filterPaths = opts.paths ?? [];
+    for (const entry of syncResp.files) {
+        // --path: skip actions for files outside the specified scope
+        if (!matchesPaths(entry.path, filterPaths))
+            continue;
+        try {
+            const absPath = join(vaultDir, entry.path);
+            if (entry.action === "upload") {
+                if (opts.downloadOnly)
+                    continue;
+                if (opts.dryRun) {
+                    if (!jsonMode)
+                        console.log(`  [dry-run] would upload: ${entry.path}`);
+                    uploaded++;
+                    continue;
+                }
+                const content = readFileSync(absPath);
+                const hash = md5Hex(content);
+                const cursor = await webdrivePut(baseUrl, vaultSlug, entry.path, content, hash, token);
+                if (cursor !== null && (maxMutationCursor === null || cursor > maxMutationCursor)) {
+                    maxMutationCursor = cursor;
+                }
+                state.hashCache[entry.path] = {
+                    hash,
+                    mtime: statSync(absPath).mtimeMs,
+                    size: content.length,
+                };
+                if (!jsonMode)
+                    console.log(`  Uploaded: ${entry.path}`);
+                uploaded++;
+            }
+            else if (entry.action === "download") {
+                if (opts.uploadOnly)
+                    continue;
+                if (opts.dryRun) {
+                    if (!jsonMode)
+                        console.log(`  [dry-run] would download: ${entry.path}`);
+                    downloaded++;
+                    continue;
+                }
+                const content = await webdriveGet(baseUrl, vaultSlug, entry.path, token);
+                mkdirSync(dirname(absPath), { recursive: true });
+                await writeFile(absPath, content);
+                const hash = md5Hex(content);
+                state.hashCache[entry.path] = {
+                    hash,
+                    mtime: statSync(absPath).mtimeMs,
+                    size: content.length,
+                };
+                if (!jsonMode)
+                    console.log(`  Downloaded: ${entry.path}`);
+                downloaded++;
+            }
+            else if (entry.action === "delete_local") {
+                if (opts.uploadOnly)
+                    continue;
+                if (!existsSync(absPath))
+                    continue;
+                if (opts.dryRun) {
+                    if (!jsonMode)
+                        console.log(`  [dry-run] would delete local: ${entry.path}`);
+                    deletedLocally++;
+                    continue;
+                }
+                await trash(absPath);
+                delete state.hashCache[entry.path];
+                if (!jsonMode)
+                    console.log(`  Deleted local (moved to trash): ${entry.path}`);
+                deletedLocally++;
+            }
+            else if (entry.action === "conflict") {
+                conflicts++;
+                const choice = await resolveConflict(entry.path, opts.conflict, entry.conflict, jsonMode);
+                if (choice === "server") {
+                    if (opts.dryRun) {
+                        if (!jsonMode)
+                            console.log(`  [dry-run] would download (conflict→server): ${entry.path}`);
+                    }
+                    else {
+                        const content = await webdriveGet(baseUrl, vaultSlug, entry.path, token);
+                        mkdirSync(dirname(absPath), { recursive: true });
+                        await writeFile(absPath, content);
+                        const hash = md5Hex(content);
+                        state.hashCache[entry.path] = {
+                            hash,
+                            mtime: statSync(absPath).mtimeMs,
+                            size: content.length,
+                        };
+                        if (!jsonMode)
+                            console.log(`  Conflict resolved (server): ${entry.path}`);
+                    }
+                    downloaded++;
+                }
+                else if (choice === "client") {
+                    if (!jsonMode)
+                        console.log(`  Conflict resolved (local kept): ${entry.path}`);
+                }
+                else {
+                    skipped++;
+                    const warning = `Conflict skipped (resolve later): ${entry.path}`;
+                    conflictWarnings.push(warning);
+                    if (!jsonMode)
+                        console.log(`  ${warning}`);
+                }
+            }
+        }
+        catch (err) {
+            errors++;
+            const msg = err.message;
+            errorDetails.push({ path: entry.path, action: entry.action, error: msg });
+            if (!jsonMode)
+                console.error(`  Error [${entry.action}] ${entry.path}: ${msg}`);
+        }
+    }
+    // Persist state (always, even on partial failures)
+    const finalCursor = Math.max(syncResp.cursor, maxMutationCursor !== null ? maxMutationCursor : 0);
+    state.cursor = finalCursor;
+    state.syncfilesHash = currSyncfilesHash;
+    // If the server returned an empty syncfilesHash the vault was deleted server-side
+    // (empty patterns path). Reset patterns so the next sync re-registers them as "added",
+    // which lets the 409 retry resurrect the vault.
+    state.patterns = syncResp.syncfilesHash === "" ? [] : currPatterns;
+    saveSyncState(gobiDir, state);
+    // Output summary
+    const result = {
+        uploaded,
+        downloaded,
+        deletedLocally,
+        conflicts,
+        skipped,
+        errors,
+        cursor: finalCursor,
+        errorDetails,
+    };
+    if (jsonMode) {
+        if (conflictWarnings.length > 0 && opts.conflict === "ask") {
+            result.conflictWarning =
+                "Interactive conflict resolution skipped in JSON mode. Conflicts were skipped.";
+        }
+        jsonOut(result);
+    }
+    else {
+        const conflictSuffix = skipped > 0 ? ` (${skipped} skipped)` : "";
+        console.log("\nSync complete.");
+        console.log(`  Uploaded:      ${uploaded}`);
+        console.log(`  Downloaded:    ${downloaded}`);
+        console.log(`  Deleted local: ${deletedLocally}`);
+        console.log(`  Conflicts:     ${conflicts}${conflictSuffix}`);
+        console.log(`  Errors:        ${errors}`);
+        if (errors > 0) {
+            process.exitCode = 1;
+        }
+    }
+}
+// ─── Commander Registration ───────────────────────────────────────────────────
+export function registerSyncCommand(program) {
+    program
+        .command("sync")
+        .description("Sync local vault files with Gobi Webdrive.")
+        .option("--upload-only", "Only upload local changes to server")
+        .option("--download-only", "Only download server changes to local")
+        .option("--conflict <strategy>", "Conflict resolution strategy: ask|server|client|skip", "ask")
+        .option("--dir <path>", "Local vault directory (default: current directory)")
+        .option("--dry-run", "Preview changes without making them")
+        .option("--full", "Full sync: ignore cursor and hash cache, re-check every file")
+        .option("--path <path>", "Restrict sync to a specific file or folder (repeatable)", (v, prev) => prev.concat(v), [])
+        .action(async function (opts) {
+        if (opts.uploadOnly && opts.downloadOnly) {
+            throw new GobiError("--upload-only and --download-only are mutually exclusive.", "INVALID_OPTION");
+        }
+        const validStrategies = ["ask", "server", "client", "skip"];
+        if (!validStrategies.includes(opts.conflict)) {
+            throw new GobiError(`Invalid --conflict value "${opts.conflict}". Use: ask|server|client|skip`, "INVALID_OPTION");
+        }
+        const vaultSlug = getVaultSlug();
+        const dir = opts.dir ? pathResolve(opts.dir) : process.cwd();
+        await runSync({
+            vaultSlug,
+            dir,
+            uploadOnly: !!opts.uploadOnly,
+            downloadOnly: !!opts.downloadOnly,
+            conflict: opts.conflict,
+            dryRun: !!opts.dryRun,
+            full: !!opts.full,
+            paths: opts.path ?? [],
+            jsonMode: isJsonMode(this),
+        });
+    });
+}

package/dist/main.js

@@ -8,6 +8,7 @@ import { registerSpaceCommand } from "./commands/space.js";
 import { registerBrainCommand } from "./commands/brain.js";
 import { registerSessionsCommand } from "./commands/sessions.js";
 import { registerSenseCommand } from "./commands/sense.js";
+import { registerSyncCommand } from "./commands/sync.js";
 const require = createRequire(import.meta.url);
 const { version } = require("../package.json");
 const SKIP_BANNER_COMMANDS = new Set(["auth", "init"]);
@@ -32,6 +33,7 @@ export async function cli() {
     registerBrainCommand(program);
     registerSessionsCommand(program);
     registerSenseCommand(program);
+    registerSyncCommand(program);
     // Propagate helpWidth to all subcommands
     const helpWidth = process.stdout.columns || 200;
     for (const cmd of program.commands) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gobi-ai/cli",
-  "version": "0.6.1",
+  "version": "0.6.3",
   "description": "CLI client for the Gobi collaborative knowledge platform",
   "license": "MIT",
   "type": "module",
@@ -37,17 +37,21 @@
     "build": "npm run clean && tsc && chmod +x dist/index.js",
     "dev": "tsx src/index.ts",
     "start": "node dist/index.js",
-    "test": "node --test dist/*.test.js",
+    "test": "node --test dist/*.test.js dist/**/*.test.js",
     "generate-skill-docs": "npm run build && npx tsx skills/gobi/scripts/generate-docs.ts",
     "prepare": "npm run build",
     "prepublishOnly": "npm run build"
   },
   "dependencies": {
+    "better-sqlite3": "^12.8.0",
     "commander": "^12.1.0",
+    "ignore": "^7.0.5",
     "inquirer": "^12.3.0",
-    "js-yaml": "^4.1.0"
+    "js-yaml": "^4.1.0",
+    "trash": "^10.1.1"
   },
   "devDependencies": {
+    "@types/better-sqlite3": "^7.6.13",
     "@types/inquirer": "^9.0.7",
     "@types/js-yaml": "^4.0.9",
     "@types/node": "^22.0.0",

package/skills/gobi/SKILL.md

@@ -10,12 +10,12 @@ description: >-
 allowed-tools: Bash(gobi:*)
 metadata:
   author: gobi-ai
-  version: "0.6.1"
+  version: "0.6.3"
 ---
 
 # gobi-cli
 
-A CLI client for the Gobi collaborative knowledge platform (v0.6.1).
+A CLI client for the Gobi collaborative knowledge platform (v0.6.3).
 
 ## Prerequisites
 
@@ -167,6 +167,10 @@ Note: `--space-slug` is not available on other `brain` subcommands or on `sessio
   - `gobi session get` — Get a session and its messages (paginated).
   - `gobi session list` — List all sessions you are part of, sorted by most recent activity.
   - `gobi session reply` — Send a human reply to a session you are a member of.
+- `gobi sense` — Sense commands (activities, transcriptions).
+  - `gobi sense activities` — Fetch activity records within a time range.
+  - `gobi sense transcriptions` — Fetch transcription records within a time range.
+- `gobi sync` — Sync local vault files with Gobi Webdrive.
 
 ## Reference Documentation
 
@@ -175,6 +179,8 @@ Note: `--space-slug` is not available on other `brain` subcommands or on `sessio
 - [gobi space](references/space.md)
 - [gobi brain](references/brain.md)
 - [gobi session](references/session.md)
+- [gobi sense](references/sense.md)
+- [gobi sync](references/sync.md)
 
 ## Discovering Options
 

package/skills/gobi/references/sense.md

@@ -0,0 +1,41 @@
+# gobi sense
+
+```
+Usage: gobi sense [options] [command]
+
+Sense commands (activities, transcriptions).
+
+Options:
+  -h, --help                display help for command
+
+Commands:
+  activities [options]      Fetch activity records within a time range.
+  transcriptions [options]  Fetch transcription records within a time range.
+  help [command]            display help for command
+```
+
+## activities
+
+```
+Usage: gobi sense activities [options]
+
+Fetch activity records within a time range.
+
+Options:
+  --start-time <iso>  Start of time range (ISO 8601 UTC, e.g. 2026-03-20T00:00:00Z)
+  --end-time <iso>    End of time range (ISO 8601 UTC, e.g. 2026-03-20T23:59:59Z)
+  -h, --help          display help for command
+```
+
+## transcriptions
+
+```
+Usage: gobi sense transcriptions [options]
+
+Fetch transcription records within a time range.
+
+Options:
+  --start-time <iso>  Start of time range (ISO 8601 UTC, e.g. 2026-03-20T00:00:00Z)
+  --end-time <iso>    End of time range (ISO 8601 UTC, e.g. 2026-03-20T23:59:59Z)
+  -h, --help          display help for command
+```

package/skills/gobi/references/sync.md

@@ -0,0 +1,17 @@
+# gobi sync
+
+```
+Usage: gobi sync [options]
+
+Sync local vault files with Gobi Webdrive.
+
+Options:
+  --upload-only          Only upload local changes to server
+  --download-only        Only download server changes to local
+  --conflict <strategy>  Conflict resolution strategy: ask|server|client|skip (default: "ask")
+  --dir <path>           Local vault directory (default: current directory)
+  --dry-run              Preview changes without making them
+  --full                 Full sync: ignore cursor and hash cache, re-check every file
+  --path <path>          Restrict sync to a specific file or folder (repeatable) (default: [])
+  -h, --help             display help for command
+```