@fabricorg/cli 0.3.6 → 0.3.7

package/dist/fabric.js

@@ -57,7 +57,7 @@ import { Command as Command21 } from "commander";
 // package.json
 var package_default = {
   name: "@fabricorg/cli",
-  version: "0.3.6",
+  version: "0.3.7",
   description: "CLI for the Fabric AI platform",
   keywords: [
     "fabric",
@@ -2048,15 +2048,61 @@ function computeContextPlan(input) {
       }
     }
     push.sort((a, b) => byPath2(a.sourcePath, b.sourcePath));
-    unchangedLocal.sort(byPath2);
     removed.sort(byPath2);
+    const moves = pairMoves(lock, removed, push);
+    const moved = new Set(moves.map((move) => move.from));
+    const arrived = new Set(moves.map((move) => move.to));
+    unchangedLocal.sort(byPath2);
     forgotten.sort(byPath2);
     skipped.sort((a, b) => byPath2(a.path, b.path));
-    return { push, unchangedLocal, removed, forgotten, skipped };
+    return {
+      push: push.filter((entry) => !arrived.has(entry.sourcePath)),
+      moves,
+      unchangedLocal,
+      removed: removed.filter((sourcePath) => !moved.has(sourcePath)),
+      forgotten,
+      skipped
+    };
   });
 }
+function pairMoves(lock, removed, push) {
+  const added = push.filter(
+    (entry) => (lock == null ? void 0 : lock.files[entry.sourcePath]) === void 0
+  );
+  const taken = /* @__PURE__ */ new Set();
+  const moves = [];
+  for (const from of removed) {
+    const entry = lock == null ? void 0 : lock.files[from];
+    if (!entry || entry.state === "duplicate") {
+      continue;
+    }
+    const match = added.find(
+      (candidate) => !taken.has(candidate.sourcePath) && candidate.sha256 === entry.sha256
+    );
+    if (!match) {
+      continue;
+    }
+    taken.add(match.sourcePath);
+    moves.push({
+      from,
+      to: match.sourcePath,
+      diskPath: match.diskPath,
+      sha256: match.sha256,
+      bytes: match.bytes,
+      contextId: entry.contextId
+    });
+  }
+  return moves;
+}
 
 // src/lib/context-sync/push.ts
+var DELETE_STATUSES = /* @__PURE__ */ new Set([
+  "deleted",
+  "already-gone",
+  "delete-in-progress",
+  "delete-conflict",
+  "delete-failed"
+]);
 var RUN_LEVEL_STATUSES = /* @__PURE__ */ new Set([401, 403, 404, 429]);
 var RUN_LEVEL_CODES = /* @__PURE__ */ new Set(["NETWORK_ERROR", "TIMEOUT"]);
 function stopsTheRun(error) {
@@ -2094,158 +2140,439 @@ function readPlannedContent(root, entry) {
     return verdict.content;
   });
 }
-function fromResult(sourcePath, result) {
-  if (result.status === "duplicate") {
+function fromResult(sourcePath, result, movedFrom) {
+  if (result.status === "moved") {
     return {
+      sourcePath,
+      status: "moved",
+      movedFrom: movedFrom != null ? movedFrom : result.movedFromSourcePath,
+      contextId: result.contextId,
+      contentHash: result.contentHash
+    };
+  }
+  const move = movedFrom === void 0 ? {} : __spreadValues({
+    movedFrom
+  }, result.moveNotApplied ? { moveNotApplied: result.moveNotApplied.reason } : {});
+  if (result.status === "duplicate") {
+    return __spreadValues({
       sourcePath,
       status: "duplicate",
       contentHash: result.contentHash,
       duplicateOfContextId: result.duplicateOfContextId,
       duplicateOfSourcePath: result.duplicateOfSourcePath
-    };
+    }, move);
   }
-  return {
+  return __spreadValues({
     sourcePath,
     status: result.status,
     contextId: result.contextId,
     contentHash: result.contentHash
-  };
+  }, move);
+}
+function moveKeptOldPath(result) {
+  if ((result.status === "created" || result.status === "updated" || result.status === "unchanged" || result.status === "duplicate") && result.movedFrom !== void 0 && result.moveNotApplied !== "source-missing") {
+    return result.movedFrom;
+  }
+  return null;
 }
 function pushContextPlan(input) {
   return __async(this, null, function* () {
     var _a2;
     const results = [];
-    const send = (entry, content, expectedContentHash) => input.client.contexts.upsertSyncedFile(
+    const pruneTargets = [];
+    const { force } = input;
+    const send = (sourcePath, content, expectedContentHash, movedFromSourcePath) => input.client.contexts.upsertSyncedFile(
       input.projectId,
-      __spreadValues({
-        sourcePath: entry.sourcePath,
+      __spreadValues(__spreadValues({
+        sourcePath,
         content
-      }, expectedContentHash !== void 0 ? { expectedContentHash } : {}),
+      }, expectedContentHash !== void 0 ? { expectedContentHash } : {}), movedFromSourcePath !== void 0 ? { movedFromSourcePath } : {}),
       { org: input.org }
     );
-    for (const entry of input.plan.push) {
+    const pushEntry = (entry) => __async(null, null, function* () {
+      var _a3;
+      const content = yield readPlannedContent(input.root, entry);
+      if (content === null) {
+        return {
+          sourcePath: entry.sourcePath,
+          status: "changed-during-run"
+        };
+      }
       try {
-        const content = yield readPlannedContent(input.root, entry);
-        if (content === null) {
-          results.push({
+        return fromResult(
+          entry.sourcePath,
+          yield send(
+            entry.sourcePath,
+            content,
+            entry.expectedContentHash
+          )
+        );
+      } catch (error) {
+        const conflict = conflictOf(error);
+        if (conflict === null) {
+          throw error;
+        }
+        const { current } = conflict;
+        if (!force || current !== null && current.contentHash === null) {
+          return {
+            sourcePath: entry.sourcePath,
+            status: "conflict",
+            contentHash: conflict.contentHash,
+            wasLocked: entry.expectedContentHash !== void 0,
+            afterForce: false,
+            current
+          };
+        }
+        const forcedContent = yield readPlannedContent(input.root, entry);
+        if (forcedContent === null) {
+          return {
             sourcePath: entry.sourcePath,
             status: "changed-during-run"
-          });
-          continue;
+          };
         }
         try {
-          results.push(
-            fromResult(
+          const forced = fromResult(
+            entry.sourcePath,
+            yield send(
               entry.sourcePath,
-              yield send(entry, content, entry.expectedContentHash)
+              forcedContent,
+              current === null ? void 0 : (_a3 = current.contentHash) != null ? _a3 : void 0
             )
           );
-        } catch (error) {
-          const conflict = conflictOf(error);
-          if (conflict === null) {
-            throw error;
+          return forced.status === "updated" && current !== null ? __spreadProps(__spreadValues({}, forced), { overwrote: current }) : forced;
+        } catch (retryError) {
+          const again = conflictOf(retryError);
+          if (again === null) {
+            throw retryError;
           }
-          const { current } = conflict;
-          if (!input.force || current !== null && current.contentHash === null) {
-            results.push({
-              sourcePath: entry.sourcePath,
-              status: "conflict",
-              contentHash: conflict.contentHash,
-              wasLocked: entry.expectedContentHash !== void 0,
-              afterForce: false,
-              current
-            });
-            continue;
-          }
-          const forcedContent = yield readPlannedContent(
-            input.root,
-            entry
-          );
-          if (forcedContent === null) {
-            results.push({
-              sourcePath: entry.sourcePath,
-              status: "changed-during-run"
+          return {
+            sourcePath: entry.sourcePath,
+            status: "conflict",
+            contentHash: again.contentHash,
+            wasLocked: entry.expectedContentHash !== void 0,
+            afterForce: true,
+            current: again.current
+          };
+        }
+      }
+    });
+    const pushMove = (move) => __async(null, null, function* () {
+      var _a3, _b, _c, _d;
+      const entry = {
+        sourcePath: move.to,
+        diskPath: move.diskPath,
+        sha256: move.sha256,
+        bytes: move.bytes
+      };
+      const moveFields = { movedFrom: move.from };
+      const content = yield readPlannedContent(input.root, entry);
+      if (content === null) {
+        return __spreadValues({
+          sourcePath: move.to,
+          status: "changed-during-run"
+        }, moveFields);
+      }
+      const asConflict = (conflict, afterForce) => {
+        var _a4;
+        return __spreadValues(__spreadValues({
+          sourcePath: move.to,
+          status: "conflict",
+          contentHash: conflict.contentHash,
+          // About the old path (which the lock names) or the new one.
+          wasLocked: ((_a4 = conflict.moveNotApplied) == null ? void 0 : _a4.reason) === "source-changed",
+          afterForce,
+          current: conflict.current
+        }, moveFields), conflict.moveNotApplied ? { moveNotApplied: conflict.moveNotApplied.reason } : {});
+      };
+      try {
+        return fromResult(
+          move.to,
+          yield send(move.to, content, move.sha256, move.from),
+          move.from
+        );
+      } catch (error) {
+        const conflict = conflictOf(error);
+        if (conflict === null) {
+          throw error;
+        }
+        const { current } = conflict;
+        if (current === null && conflict.moveNotApplied === void 0) {
+          return {
+            sourcePath: move.to,
+            status: "move-unsupported",
+            movedFrom: move.from
+          };
+        }
+        if (!force || current !== null && current.contentHash === null) {
+          return asConflict(conflict, false);
+        }
+        const forcedContent = yield readPlannedContent(input.root, entry);
+        if (forcedContent === null) {
+          return __spreadValues({
+            sourcePath: move.to,
+            status: "changed-during-run"
+          }, moveFields);
+        }
+        const aboutOldPath = ((_a3 = conflict.moveNotApplied) == null ? void 0 : _a3.reason) === "source-changed";
+        try {
+          if (aboutOldPath && current === null) {
+            const created = fromResult(
+              move.to,
+              yield send(move.to, forcedContent)
+            );
+            return created.status === "moved" ? created : __spreadProps(__spreadValues(__spreadValues({}, created), moveFields), {
+              moveNotApplied: "source-missing"
             });
-            continue;
           }
-          try {
-            const forced = fromResult(
-              entry.sourcePath,
+          if (aboutOldPath) {
+            return fromResult(
+              move.to,
               yield send(
-                entry,
+                move.to,
                 forcedContent,
-                current === null ? void 0 : (_a2 = current.contentHash) != null ? _a2 : void 0
-              )
+                (_b = current == null ? void 0 : current.contentHash) != null ? _b : void 0,
+                move.from
+              ),
+              move.from
             );
-            results.push(
-              forced.status === "updated" && current !== null ? __spreadProps(__spreadValues({}, forced), { overwrote: current }) : forced
-            );
-          } catch (retryError) {
-            const again = conflictOf(retryError);
-            if (again === null) {
-              throw retryError;
-            }
-            results.push({
-              sourcePath: entry.sourcePath,
-              status: "conflict",
-              contentHash: again.contentHash,
-              wasLocked: entry.expectedContentHash !== void 0,
-              afterForce: true,
-              current: again.current
-            });
           }
+          const forced = fromResult(
+            move.to,
+            yield send(
+              move.to,
+              forcedContent,
+              (_c = current == null ? void 0 : current.contentHash) != null ? _c : void 0
+            )
+          );
+          if (forced.status === "moved") {
+            return forced;
+          }
+          return __spreadValues(__spreadValues(__spreadValues({}, forced.status === "updated" && current !== null ? __spreadProps(__spreadValues({}, forced), { overwrote: current }) : forced), moveFields), conflict.moveNotApplied ? { moveNotApplied: conflict.moveNotApplied.reason } : {});
+        } catch (retryError) {
+          const again = conflictOf(retryError);
+          if (again === null) {
+            throw retryError;
+          }
+          if (again.moveNotApplied !== void 0) {
+            return asConflict(again, true);
+          }
+          const reason = aboutOldPath ? current === null ? "source-missing" : void 0 : (_d = conflict.moveNotApplied) == null ? void 0 : _d.reason;
+          return asConflict(
+            reason === void 0 ? again : __spreadProps(__spreadValues({}, again), {
+              moveNotApplied: {
+                movedFromSourcePath: move.from,
+                reason
+              }
+            }),
+            true
+          );
         }
+      }
+    });
+    const deleteEntry = (sourcePath, sha256) => __async(null, null, function* () {
+      const remove = (expectedContentHash) => input.client.contexts.deleteSyncedFile(
+        input.projectId,
+        { sourcePath, expectedContentHash },
+        { org: input.org }
+      );
+      const fromAnswer = (answer, overwrote) => {
+        switch (answer.status) {
+          case "deleted":
+            return __spreadValues({
+              sourcePath,
+              status: "deleted",
+              contextId: answer.contextId,
+              contentHash: answer.contentHash
+            }, overwrote ? { overwrote } : {});
+          case "absent":
+            return { sourcePath, status: "already-gone" };
+          case "in-progress":
+            return { sourcePath, status: "delete-in-progress" };
+        }
+      };
+      try {
+        return fromAnswer(yield remove(sha256));
+      } catch (error) {
+        const conflict = conflictOf(error);
+        if (conflict === null || conflict.current === null) {
+          throw error;
+        }
+        const { current } = conflict;
+        if (!force || current.contentHash === null) {
+          return {
+            sourcePath,
+            status: "delete-conflict",
+            afterForce: false,
+            current
+          };
+        }
+        try {
+          return fromAnswer(yield remove(current.contentHash), current);
+        } catch (retryError) {
+          const again = conflictOf(retryError);
+          if (again === null || again.current === null) {
+            throw retryError;
+          }
+          return {
+            sourcePath,
+            status: "delete-conflict",
+            afterForce: true,
+            current: again.current
+          };
+        }
+      }
+    });
+    const step = (run3, failed) => __async(null, null, function* () {
+      try {
+        results.push(yield run3());
+        return null;
       } catch (error) {
         const failure = asCliFailure(error);
         if (stopsTheRun(error)) {
-          return { results, stoppedBy: failure };
+          return failure;
         }
-        results.push({
+        results.push(failed(error, failure.exitCode));
+        return null;
+      }
+    });
+    const pruneTargetsSoFar = () => {
+      const keptByMoves = results.map(moveKeptOldPath).filter((path9) => path9 !== null);
+      return [.../* @__PURE__ */ new Set([...input.plan.removed, ...keptByMoves])].filter((path9) => {
+        var _a3;
+        const locked = (_a3 = input.lock) == null ? void 0 : _a3.files[path9];
+        return locked !== void 0 && locked.state !== "duplicate";
+      }).sort((a, b) => a < b ? -1 : a > b ? 1 : 0);
+    };
+    const stopped = (stoppedBy) => {
+      if (input.prune && pruneTargets.length === 0) {
+        pruneTargets.push(...pruneTargetsSoFar());
+      }
+      return { results, stoppedBy, pruneTargets };
+    };
+    for (const move of input.plan.moves) {
+      const stoppedBy = yield step(
+        () => pushMove(move),
+        (error, exitCode) => ({
+          sourcePath: move.to,
+          status: "failed",
+          error: describeError(error),
+          exitCode,
+          movedFrom: move.from
+        })
+      );
+      if (stoppedBy) {
+        return stopped(stoppedBy);
+      }
+    }
+    for (const entry of input.plan.push) {
+      const stoppedBy = yield step(
+        () => pushEntry(entry),
+        (error, exitCode) => ({
           sourcePath: entry.sourcePath,
           status: "failed",
           error: describeError(error),
-          exitCode: failure.exitCode
-        });
+          exitCode
+        })
+      );
+      if (stoppedBy) {
+        return stopped(stoppedBy);
       }
     }
-    return { results, stoppedBy: null };
+    if (input.prune) {
+      pruneTargets.push(...pruneTargetsSoFar());
+      for (const sourcePath of pruneTargets) {
+        const locked = (_a2 = input.lock) == null ? void 0 : _a2.files[sourcePath];
+        if (!locked || locked.state === "duplicate") {
+          continue;
+        }
+        const stoppedBy = yield step(
+          () => deleteEntry(sourcePath, locked.sha256),
+          (error, exitCode) => ({
+            sourcePath,
+            status: "delete-failed",
+            error: describeError(error),
+            exitCode
+          })
+        );
+        if (stoppedBy) {
+          return stopped(stoppedBy);
+        }
+      }
+    }
+    return { results, stoppedBy: null, pruneTargets };
   });
 }
 function nextContextLock(input) {
   var _a2, _b, _c;
   const files = __spreadValues({}, (_b = (_a2 = input.previous) == null ? void 0 : _a2.files) != null ? _b : {});
   let changed = false;
-  for (const sourcePath of (_c = input.forgotten) != null ? _c : []) {
+  const drop = (sourcePath) => {
     if (sourcePath in files) {
       delete files[sourcePath];
       changed = true;
     }
+  };
+  const confirm = (sourcePath, sha256, contextId) => {
+    const before = files[sourcePath];
+    if ((before == null ? void 0 : before.state) === void 0 && (before == null ? void 0 : before.sha256) === sha256 && before.contextId === contextId) {
+      return;
+    }
+    files[sourcePath] = { sha256, contextId };
+    changed = true;
+  };
+  for (const sourcePath of (_c = input.forgotten) != null ? _c : []) {
+    drop(sourcePath);
   }
   for (const result of input.results) {
-    if (result.status === "duplicate") {
-      const before2 = files[result.sourcePath];
-      if ((before2 == null ? void 0 : before2.state) === "duplicate" && before2.sha256 === result.contentHash) {
-        continue;
+    switch (result.status) {
+      case "deleted":
+      case "already-gone":
+        drop(result.sourcePath);
+        break;
+      case "delete-in-progress":
+        break;
+      case "moved":
+        drop(result.movedFrom);
+        confirm(
+          result.sourcePath,
+          result.contentHash,
+          result.contextId
+        );
+        break;
+      case "duplicate": {
+        const before = files[result.sourcePath];
+        if ((before == null ? void 0 : before.state) !== "duplicate" || before.sha256 !== result.contentHash) {
+          files[result.sourcePath] = {
+            sha256: result.contentHash,
+            state: "duplicate"
+          };
+          changed = true;
+        }
+        if (result.moveNotApplied === "source-missing" && result.movedFrom) {
+          drop(result.movedFrom);
+        }
+        break;
       }
-      files[result.sourcePath] = {
-        sha256: result.contentHash,
-        state: "duplicate"
-      };
-      changed = true;
-      continue;
-    }
-    if (result.status !== "created" && result.status !== "updated" && result.status !== "unchanged") {
-      continue;
-    }
-    const before = files[result.sourcePath];
-    if ((before == null ? void 0 : before.state) === void 0 && (before == null ? void 0 : before.sha256) === result.contentHash && before.contextId === result.contextId) {
-      continue;
+      case "created":
+      case "updated":
+      case "unchanged":
+        confirm(
+          result.sourcePath,
+          result.contentHash,
+          result.contextId
+        );
+        if (result.moveNotApplied === "source-missing" && result.movedFrom) {
+          drop(result.movedFrom);
+        }
+        break;
+      case "conflict":
+        if (result.moveNotApplied === "source-missing" && result.movedFrom) {
+          drop(result.movedFrom);
+        }
+        break;
+      default:
+        break;
     }
-    files[result.sourcePath] = {
-      sha256: result.contentHash,
-      contextId: result.contextId
-    };
-    changed = true;
   }
   if (!changed) {
     return null;
@@ -2266,11 +2593,18 @@ function countOutcomes(plan, results) {
     updated: count("updated"),
     unchanged: count("unchanged") + plan.unchangedLocal.length,
     duplicate: count("duplicate"),
+    moved: count("moved"),
+    moveUnsupported: count("move-unsupported"),
     conflict: count("conflict"),
     changedDuringRun: count("changed-during-run"),
     failed: count("failed"),
     removed: plan.removed.length,
-    skipped: plan.skipped.length
+    skipped: plan.skipped.length,
+    deleted: count("deleted"),
+    alreadyGone: count("already-gone"),
+    deleteInProgress: count("delete-in-progress"),
+    deleteConflict: count("delete-conflict"),
+    deleteFailed: count("delete-failed")
   };
 }
 function who(current) {
@@ -2281,7 +2615,30 @@ function when(current) {
   var _a2;
   return (_a2 = current.contentUpdatedAt) != null ? _a2 : "an unknown time";
 }
+function moveSourceConflictLine(result, from) {
+  const { current } = result;
+  if (current === null) {
+    return `${from}: deleted on the server since your last push; not moved to ${result.sourcePath}`;
+  }
+  let text = result.afterForce ? `changed on the server again by ${who(current)} at ${when(current)} while --force was moving it` : `changed on the server by ${who(current)} at ${when(current)} since your last push`;
+  if (current.contentHash === null) {
+    text += "; that version has no content hash, so --force cannot move it";
+  }
+  return `${from}: ${text}; not moved to ${result.sourcePath}`;
+}
 function conflictLine(result) {
+  if (result.movedFrom !== void 0) {
+    if (result.moveNotApplied === "source-changed") {
+      return moveSourceConflictLine(result, result.movedFrom);
+    }
+    if (result.moveNotApplied === "source-missing") {
+      return `${pushConflictLine(result)}; ${result.movedFrom} gone on the server`;
+    }
+    return `${pushConflictLine(result)}; ${result.movedFrom} not moved`;
+  }
+  return pushConflictLine(result);
+}
+function pushConflictLine(result) {
   const { current } = result;
   if (current === null) {
     return `${result.sourcePath}: deleted on the server since your last push`;
@@ -2299,12 +2656,47 @@ function conflictLine(result) {
   }
   return `${result.sourcePath}: ${text}`;
 }
+function deleteConflictLine(result) {
+  const { current } = result;
+  let text = result.afterForce ? `changed on the server again by ${who(current)} at ${when(current)} while --force was deleting it` : `changed on the server by ${who(current)} at ${when(current)} since your last push`;
+  if (current.contentHash === null) {
+    text += "; that version has no content hash, so --force cannot delete it";
+  }
+  return `${result.sourcePath}: ${text}; not deleted`;
+}
 function storedLine(result) {
   if (result.overwrote) {
     return `${result.sourcePath}: replaced the version ${who(result.overwrote)} changed at ${when(result.overwrote)} (--force)`;
   }
   return result.sourcePath;
 }
+function isMoveFallback(result) {
+  return (result.status === "created" || result.status === "updated" || result.status === "unchanged" || result.status === "duplicate") && result.movedFrom !== void 0;
+}
+function moveFallbackLine(result, prune) {
+  var _a2, _b;
+  const from = (_a2 = result.movedFrom) != null ? _a2 : "";
+  const to = result.sourcePath;
+  let pushed;
+  if (result.status === "duplicate") {
+    pushed = `${to} pushed as a duplicate of ${(_b = result.duplicateOfSourcePath) != null ? _b : "another source in this project"}`;
+  } else if (result.overwrote) {
+    pushed = `${to} replaced the version ${who(result.overwrote)} changed at ${when(result.overwrote)} (--force)`;
+  } else {
+    pushed = `${to} pushed as ${result.status}`;
+  }
+  const kept = prune ? "" : `; ${from} kept`;
+  switch (result.moveNotApplied) {
+    case "source-missing":
+      return `${from}: gone on the server; ${pushed}`;
+    case "target-exists":
+      return `${from}: not moved, ${to} is already on the server; ${pushed}${kept}`;
+    case "content-differs":
+      return `${from}: not moved, the server's version of it differs from ${to}; ${pushed}${kept}`;
+    default:
+      return `${from}: not moved; ${pushed}${kept}`;
+  }
+}
 function skippedLine(skip) {
   if (skip.reason === "ignored") {
     return `${skip.path}: now excluded by the ignore rules; server entry kept`;
@@ -2321,24 +2713,42 @@ function group(lines, label, items) {
   }
 }
 function formatPushReport(input) {
+  var _a2;
   const { plan, results } = input;
-  const of = (status) => results.filter((r) => r.status === status);
+  const prune = Boolean(input.prune);
+  const of = (status) => results.filter(
+    (r) => r.status === status && !isMoveFallback(r)
+  );
   const lines = [
     `Context push from ${input.directory} to project ${input.projectId}:`
   ];
   group(lines, "created", of("created").map(storedLine));
   group(lines, "updated", of("updated").map(storedLine));
+  group(
+    lines,
+    "moved",
+    of("moved").map((r) => `${r.movedFrom} -> ${r.sourcePath}`)
+  );
+  group(lines, "not moved", [
+    ...results.filter(isMoveFallback).map((r) => moveFallbackLine(r, prune)),
+    ...of("move-unsupported").map(
+      (r) => `${r.movedFrom} -> ${r.sourcePath}: the server does not support moves yet; ${r.movedFrom} kept, ${r.sourcePath} not pushed`
+    )
+  ]);
   group(
     lines,
     "duplicate",
     of("duplicate").map(
       (r) => {
-        var _a2;
-        return `${r.sourcePath}: duplicate of ${(_a2 = r.duplicateOfSourcePath) != null ? _a2 : "another source in this project"}`;
+        var _a3;
+        return `${r.sourcePath}: duplicate of ${(_a3 = r.duplicateOfSourcePath) != null ? _a3 : "another source in this project"}`;
       }
     )
   );
-  group(lines, "conflict", of("conflict").map(conflictLine));
+  group(lines, "conflict", [
+    ...of("conflict").map(conflictLine),
+    ...of("delete-conflict").map(deleteConflictLine)
+  ]);
   group(
     lines,
     "changed during the run",
@@ -2346,15 +2756,44 @@ function formatPushReport(input) {
       (r) => `${r.sourcePath}: changed-during-run; not sent, the next push sends the new content`
     )
   );
+  group(lines, "failed", [
+    ...of("failed").map((r) => `${r.sourcePath}: ${r.error}`),
+    ...of("delete-failed").map(
+      (r) => `${r.sourcePath}: ${r.error}; not deleted`
+    )
+  ]);
   group(
     lines,
-    "failed",
-    of("failed").map((r) => `${r.sourcePath}: ${r.error}`)
+    "deleted",
+    of("deleted").map(
+      (r) => r.overwrote ? `${r.sourcePath}: deleted the version ${who(r.overwrote)} changed at ${when(r.overwrote)} (--force)` : r.sourcePath
+    )
   );
+  group(
+    lines,
+    "already gone",
+    of("already-gone").map(
+      (r) => `${r.sourcePath}: already gone on the server`
+    )
+  );
+  group(
+    lines,
+    "deletion still running",
+    of("delete-in-progress").map(
+      (r) => `${r.sourcePath}: deletion still running on the server; run again to confirm`
+    )
+  );
+  const pruned = new Set(
+    results.filter((r) => DELETE_STATUSES.has(r.status)).map((r) => r.sourcePath)
+  );
+  const kept = [
+    ...plan.removed,
+    ...((_a2 = input.pruneTargets) != null ? _a2 : []).filter((p) => !plan.removed.includes(p))
+  ];
   group(
     lines,
     "removed",
-    plan.removed.map((p) => `${p}: removed locally; server entry kept`)
+    kept.filter((p) => !pruned.has(p)).map((p) => `${p}: removed locally; server entry kept`)
   );
   group(lines, "skipped", plan.skipped.map(skippedLine));
   const unchanged = countOutcomes(plan, results).unchanged;
@@ -2368,6 +2807,11 @@ function formatDryRunReport(input) {
   const lines = [
     `Dry run of a context push from ${input.directory} to project ${input.projectId}: nothing was sent and the lock was not written.`
   ];
+  group(
+    lines,
+    "moved",
+    plan.moves.map((move) => `${move.from} -> ${move.to}`)
+  );
   group(
     lines,
     "new",
@@ -2378,13 +2822,17 @@ function formatDryRunReport(input) {
     "changed",
     plan.push.filter((entry) => entry.expectedContentHash !== void 0).map((entry) => entry.sourcePath)
   );
-  group(
-    lines,
-    "removed",
-    plan.removed.map(
-      (p) => `${p}: removed locally; server entry would be kept`
-    )
-  );
+  if (input.prune) {
+    group(lines, "would delete", plan.removed);
+  } else {
+    group(
+      lines,
+      "removed",
+      plan.removed.map(
+        (p) => `${p}: removed locally; server entry would be kept`
+      )
+    );
+  }
   group(lines, "skipped", plan.skipped.map(skippedLine));
   if (plan.unchangedLocal.length > 0) {
     lines.push(`unchanged (${plan.unchangedLocal.length})`);
@@ -2397,6 +2845,7 @@ function contextPushJson(input) {
     directory: input.directory,
     dryRun: input.dryRun,
     force: input.force,
+    prune: input.prune,
     lock: input.lockPath,
     lockWritten: input.lockWritten,
     plan: {
@@ -2409,6 +2858,12 @@ function contextPushJson(input) {
           expectedContentHash: (_a2 = entry.expectedContentHash) != null ? _a2 : null
         };
       }),
+      moves: input.plan.moves.map((move) => ({
+        from: move.from,
+        to: move.to,
+        sha256: move.sha256,
+        contextId: move.contextId
+      })),
       unchangedLocal: input.plan.unchangedLocal,
       removed: input.plan.removed,
       forgotten: input.plan.forgotten,
@@ -2437,6 +2892,9 @@ function buildContextCommand() {
   ).requiredOption("--project <id>", "Project ID").option("--org <slug>", "Organization context").option(
     "--force",
     "On a conflict, replace the server's version once with this folder's"
+  ).option(
+    "--prune",
+    "Delete the server entries of files removed locally, only in the version last pushed"
   ).option("--dry-run", "Print the plan; send nothing and write no lock").option(
     "--exclude <pattern>",
     "Also leave out paths matching this gitignore pattern (repeatable)",
@@ -2544,7 +3002,8 @@ function runPush(dir, opts, format) {
         formatDryRunReport({
           projectId: opts.project,
           directory: root,
-          plan
+          plan,
+          prune: Boolean(opts.prune)
         })
       );
       return;
@@ -2555,7 +3014,9 @@ function runPush(dir, opts, format) {
       org: opts.org,
       root,
       plan,
-      force: Boolean(opts.force)
+      force: Boolean(opts.force),
+      prune: Boolean(opts.prune),
+      lock
     });
     const next = nextContextLock({
       previous: lock,
@@ -2584,14 +3045,20 @@ function runPush(dir, opts, format) {
           projectId: opts.project,
           directory: root,
           plan,
-          results: pushed.results
+          results: pushed.results,
+          prune: Boolean(opts.prune),
+          pruneTargets: pushed.pruneTargets
         })
       );
     }
+    const prune = Boolean(opts.prune);
     if (pushed.stoppedBy !== null) {
-      throw pushed.stoppedBy;
+      throw prune ? new CliFailure(
+        `${pushed.stoppedBy.message} (${pruneSummary(pushed.results, pushed.pruneTargets)})`,
+        pushed.stoppedBy.exitCode
+      ) : pushed.stoppedBy;
     }
-    throwIfIncomplete(pushed.results);
+    throwIfIncomplete(pushed.results, prune, pushed.pruneTargets);
   });
 }
 function jsonOutcome(input) {
@@ -2602,36 +3069,93 @@ function jsonOutcome(input) {
     lockWritten: input.lockWritten,
     dryRun: Boolean(input.opts.dryRun),
     force: Boolean(input.opts.force),
+    prune: Boolean(input.opts.prune),
     plan: input.plan,
     results: input.results
   });
 }
-function throwIfIncomplete(results) {
-  const failed = results.filter((r) => r.status === "failed");
-  const conflicts = results.filter((r) => r.status === "conflict");
-  if (failed.length === 0 && conflicts.length === 0) {
+function pruneSummary(results, targets) {
+  const count = (status) => results.filter((r) => r.status === status).length;
+  const settled = new Set(
+    results.filter(
+      (r) => r.status === "deleted" || r.status === "already-gone"
+    ).map((r) => r.sourcePath)
+  );
+  const notDeleted = targets.filter((path9) => !settled.has(path9)).length;
+  let text = `--prune: ${count("deleted")} deleted, ${count("already-gone")} already gone, ${notDeleted} not deleted`;
+  const first = results.find((r) => r.status === "delete-failed");
+  if (first && first.status === "delete-failed") {
+    text += `, first ${first.sourcePath}: ${first.error}`;
+  }
+  return text;
+}
+function throwIfIncomplete(results, prune, pruneTargets) {
+  var _a2;
+  const pushes = results.filter((r) => !DELETE_STATUSES.has(r.status));
+  const failed = pushes.filter((r) => r.status === "failed");
+  const conflicts = pushes.filter((r) => r.status === "conflict");
+  const unsupported = pushes.filter((r) => r.status === "move-unsupported");
+  const deleteFailed = results.filter((r) => r.status === "delete-failed");
+  const deleteConflicts = results.filter(
+    (r) => r.status === "delete-conflict"
+  );
+  const stillDeleting = results.filter(
+    (r) => r.status === "delete-in-progress"
+  );
+  if (failed.length === 0 && conflicts.length === 0 && unsupported.length === 0 && deleteFailed.length === 0 && deleteConflicts.length === 0 && stillDeleting.length === 0) {
     return;
   }
-  const parts = [];
-  if (conflicts.length > 0) {
-    parts.push(
-      `${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"}`
+  const sentences = [];
+  const total = conflicts.length + failed.length + unsupported.length;
+  if (total > 0) {
+    const parts = [];
+    if (conflicts.length > 0) {
+      parts.push(
+        `${conflicts.length} conflict${conflicts.length === 1 ? "" : "s"}`
+      );
+    }
+    if (unsupported.length > 0) {
+      parts.push(
+        `${unsupported.length} move${unsupported.length === 1 ? "" : "s"} the server does not support yet`
+      );
+    }
+    const first = failed[0];
+    if (first && first.status === "failed") {
+      parts.push(
+        `${failed.length} failed, first ${first.sourcePath}: ${first.error}`
+      );
+    }
+    sentences.push(
+      `${total} of ${pushes.length} file${pushes.length === 1 ? "" : "s"} sent ${total === 1 ? "was" : "were"} not stored (${parts.join(", ")}).`
     );
+    if (conflicts.length > 0) {
+      sentences.push(
+        "A conflict means the server holds a version this folder did not name, or deleted the one it named: compare the two in the project's Context tab, and use --force to replace the version the conflict reported with this folder's (or to send a deleted file again with no version, which recreates it, or answers duplicate if that content is already stored under another path)."
+      );
+    }
   }
-  const first = failed[0];
-  if (first && first.status === "failed") {
-    parts.push(
-      `${failed.length} failed, first ${first.sourcePath}: ${first.error}`
+  if (unsupported.length > 0) {
+    sentences.push(
+      "This server does not support moves yet: a moved file's old path stays on the server and in the lock, its new path is not pushed, and the move is sent again on the next push."
     );
   }
-  const total = conflicts.length + failed.length;
-  let message = `${total} of ${results.length} file${results.length === 1 ? "" : "s"} sent ${total === 1 ? "was" : "were"} not stored (${parts.join(", ")}).`;
-  if (conflicts.length > 0) {
-    message += " A conflict means the server holds a version this folder did not name, or deleted the one it named: compare the two in the project's Context tab, and use --force to replace the version the conflict reported with this folder's (or to send a deleted file again with no version, which recreates it, or answers duplicate if that content is already stored under another path).";
+  if (prune) {
+    sentences.push(`${pruneSummary(results, pruneTargets)}.`);
+    if (deleteConflicts.length > 0) {
+      sentences.push(
+        "A file changed on the server since your last push is not deleted: compare it in the project's Context tab, and use --force to delete the version the conflict reported."
+      );
+    }
+    if (stillDeleting.length > 0) {
+      sentences.push(
+        "A deletion still running on the server keeps its lock entry: run again to confirm it."
+      );
+    }
   }
+  const firstFailure = (_a2 = failed[0]) != null ? _a2 : deleteFailed[0];
   throw new CliFailure(
-    message,
-    first && first.status === "failed" ? first.exitCode : 1
+    sentences.join(" "),
+    firstFailure && (firstFailure.status === "failed" || firstFailure.status === "delete-failed") ? firstFailure.exitCode : 1
   );
 }