sfora-cli 0.16.0 → 0.17.0

package/dist/watch.js

@@ -111,3 +111,112 @@ export function parseWatchTarget(target) {
     }
     return { kind: "path", path: trimmed.startsWith("/") ? trimmed : `/${trimmed}` };
 }
+/**
+ * My own row in one document, out of a `GET /v1/presence?member=self` answer:
+ * `view.member` is me, and each document lists who is in it with the block
+ * they hold. Matched on the document id, or on its path (the fs has two
+ * spellings of a document path, and the server answers with one).
+ */
+export function myBlockIn(view, doc) {
+    const me = view.member?.memberId;
+    if (!me)
+        return undefined;
+    const found = view.documents.find((d) => (doc.docId !== undefined && d.docId === doc.docId) || d.path === doc.path);
+    const row = found?.here.find((h) => h.memberId === me);
+    return row ? { block: row.block } : undefined;
+}
+/** A roster as one comparable string: who, how, and on which block. */
+export function rosterKey(here) {
+    return here
+        .map((m) => `${m.memberId}:${m.kind}:${m.blockId ?? ""}`)
+        .sort()
+        .join("|");
+}
+/** `here: Ada (editing block k1a2), sfora-bot [agent] (viewing)`. */
+export function renderRoster(presence) {
+    if (!presence.here.length)
+        return `here: nobody — ${presence.document}`;
+    const who = presence.here.map((m) => {
+        const what = m.kind === "editing" && m.blockId ? `editing block ${m.blockId}` : m.kind;
+        return `${m.name}${m.type === "agent" ? " [agent]" : ""} (${what})`;
+    });
+    return `here: ${who.join(", ")}`;
+}
+/**
+ * Presence as the editor of one block: `kind=editing&block=<id>` on every
+ * beat, the roster printed on joining and again whenever it changes, and
+ * `?leave` on the way out (the watch loop's `finally` sends it).
+ *
+ * `start()` is the first declaration, made before the loop so a refusal is a
+ * clear error rather than a watch that quietly never shows up:
+ *  - no roster (`null`, the server's 422): only documents have one;
+ *  - a block id that resolves to nothing: the server keeps the row at
+ *    document level and says `blockResolved: false`
+ *    (convex/lib/docPresence.ts claimableBlockId), so this retracts it and
+ *    names the fix.
+ *
+ * FOLLOWING THE BLOCK. Block ids are fingerprints of the text, so an edit to
+ * the claimed block gives it a new id. The server moves claims along with it:
+ * the writer's own `?block=` write rebinds the writer's row to the new id
+ * (convex/httpHelpers.ts:3116-3132, the `reboundOwn` touch after a doc PUT), and
+ * everybody else's claims ride the same ledger (carryDocPresenceBlocks,
+ * convex/lib/docPresence.ts:417-442) — but only on fs writes: its one caller
+ * is httpHelpers.ts:3125. An edit saved from the app carries no claims, so a
+ * person editing the claimed block in the app reads here as "gone". But a declare names its block, and a declare
+ * of the OLD id resolves to nothing (claimableBlockId) and touchDocPresence
+ * overwrites the rebound row with a
+ * block-less one, so the answer to that declare can no longer say what the
+ * new id was. So each beat first READS my row (`whereAmI`, a GET that joins
+ * nothing) and, when the server holds a different block for me, adopts it
+ * and declares that. Only a block whose old id no longer resolves and that
+ * the server did not move my claim to (removed, or edited in the app) is a
+ * warning, once,
+ * after which the watch stays in the document without a block.
+ */
+export function editingPresence(deps, opts) {
+    let lastKey;
+    /** The block being declared; `undefined` once it is gone (document level). */
+    let current = opts.block;
+    const show = (presence) => {
+        const key = rosterKey(presence.here);
+        if (key === lastKey)
+            return;
+        lastKey = key;
+        deps.write(opts.json
+            ? `${ndjson({ type: "presence", document: presence.document, block: presence.block, blockResolved: presence.blockResolved, here: presence.here })}\n`
+            : `${renderRoster(presence)}\n`);
+    };
+    return {
+        async start() {
+            const presence = await deps.declare({ kind: "editing", block: opts.block });
+            if (presence === null) {
+                throw new Error(`${opts.path} has no roster to edit in: --block works on documents ` +
+                    "(/projects/<slug>/docs/<file>.md), not on posts or board cards");
+            }
+            if (presence.blockResolved === false) {
+                await deps.declare({ kind: "editing", block: opts.block, leave: true }).catch(() => null);
+                throw new Error(`no block ${opts.block} in ${opts.path} — ids follow the content, so it may have ` +
+                    `changed; run \`sfora blocks ${opts.path}\` for the current ids`);
+            }
+            show(presence);
+        },
+        async beat({ leave }) {
+            if (!leave && current !== undefined && deps.whereAmI) {
+                const mine = await deps.whereAmI().catch(() => undefined);
+                if (mine?.block && mine.block !== current) {
+                    deps.warn(`following block ${current} → ${mine.block} (it was edited; the server moved your claim)`);
+                    current = mine.block;
+                }
+            }
+            const presence = await deps.declare({ kind: "editing", ...(current !== undefined ? { block: current } : {}), leave });
+            if (!presence || leave)
+                return;
+            if (presence.blockResolved === false && current !== undefined) {
+                deps.warn(`block ${current} is gone (it was edited or removed) — you show as in the document, ` +
+                    `not on a block; run \`sfora blocks ${opts.path}\` and watch a current id`);
+                current = undefined;
+            }
+            show(presence);
+        },
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sfora-cli",
-  "version": "0.16.0",
+  "version": "0.17.0",
   "type": "module",
   "description": "Your sfora workspace as a markdown filesystem \u2014 a CLI + MCP server. Post/task/doc, ls/cat/grep, and a shell so agents operate sfora natively.",
   "keywords": [
@@ -36,13 +36,13 @@
     "README.md"
   ],
   "scripts": {
-    "build": "node scripts/sync-format.mjs && tsc -p .",
+    "build": "node scripts/sync-format.mjs && tsc -p . && node scripts/bundle-skills-packet.mjs",
     "dev": "node scripts/sync-format.mjs && tsx src/cli.ts",
     "typecheck": "node scripts/sync-format.mjs && tsc --noEmit"
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.0.0",
-    "just-bash": "^3.0.1"
+    "just-bash": "3.0.1"
   },
   "devDependencies": {
     "@types/mdast": "^4.0.4",