@ccmsg/cli 0.5.0 → 0.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ccmsg/cli",
-  "version": "0.5.0",
+  "version": "0.5.1",
   "description": "The ccmsg daemon, CLI and agent plugins for one instance (= one config home)",
   "license": "MIT",
   "author": "kawaz",
@@ -20,7 +20,7 @@
     "test": "bun test"
   },
   "dependencies": {
-    "@ccmsg/protocol": "1.13.0"
+    "@ccmsg/protocol": "1.14.0"
   },
   "devDependencies": {
     "@types/bun": "^1.3.0",

package/src/sessions/items.ts

@@ -69,37 +69,69 @@ export function itemsRead(
   }
   const keep = selection(args.types === undefined ? {} : { types: args.types }, deps.presets);
   const { items } = select(within(classify(located(text)), args), keep);
-  const page = paged(items, args.limit);
+  const page = paged(items, args.limit, backwards(args));
   return {
     items: page.items,
     ...(page.next === undefined ? {} : { next: page.next }),
+    ...(page.prev === undefined ? {} : { prev: page.prev }),
     ...(keep.keeps(IDS) ? { ids: ledger(page.items) } : {}),
   };
 }
 
+/** Whether the range's end is the part to answer with.
+ *
+ * A caller that named where to start is reading forward from there; one that
+ * named only where to stop is looking at the newest of what it asked for, and
+ * answering with the oldest of that range would hand it the far side of a
+ * transcript it is walking back through. With neither bound the range is the
+ * whole transcript, which is read from its beginning. */
+function backwards(bounds: TranscriptItemsReadArgs): boolean {
+  const lower =
+    bounds.since_at !== undefined ||
+    bounds.since_uuid !== undefined ||
+    bounds.since_id !== undefined;
+  const upper =
+    bounds.until_at !== undefined ||
+    bounds.until_uuid !== undefined ||
+    bounds.until_id !== undefined;
+  return upper && !lower;
+}
+
 /** As much of the range as one answer carries, and where the next one starts.
  *
  * Two bounds, because either alone leaves a case unanswered: a count cannot
  * keep a page of long briefs inside what a connection should carry, and bytes
  * alone would answer with a number of items that varied with what was said in
- * them. Whichever is reached first ends the page, and the first item left out
- * is named so the caller resumes exactly where this stopped. */
+ * them. Whichever is reached first ends the page.
+ *
+ * Which end of the range is kept is the caller's, and the item named back is
+ * the one it continues from: reading forward, the first item left out, to be
+ * given as `since_id`; reading back, the first item answered, to be given as
+ * `until_id`. Either way the answer is oldest first, because that is the order
+ * a transcript has. */
 function paged(
   items: readonly Item[],
   limit: number | undefined,
-): { items: Item[]; next?: string } {
+  back: boolean,
+): { items: Item[]; next?: string; prev?: string } {
   const most = Math.min(limit ?? ITEMS_LIMIT, ITEMS_LIMIT);
   const kept: Item[] = [];
   let held = 0;
-  for (const item of items) {
+  for (let at = 0; at < items.length; at += 1) {
+    const item = items[back ? items.length - 1 - at : at];
+    if (item === undefined) continue;
     // A first item larger than the whole budget is still answered: a page of
     // nothing would leave the caller resuming at the item it just failed to
     // get, forever.
     if (kept.length > 0 && (kept.length >= most || held >= READ_LIMIT)) {
-      return { items: kept, next: item.id };
+      if (!back) return { items: kept, next: item.id };
+      kept.reverse();
+      const first = kept[0];
+      return first === undefined ? { items: kept } : { items: kept, prev: first.id };
     }
     kept.push(item);
     held += JSON.stringify(item).length;
   }
+  if (back) kept.reverse();
   return { items: kept };
 }

package/src/transcript/items/select.ts

@@ -149,13 +149,16 @@ export function select(
  * A record bound cuts at that record's position rather than at its clock, so
  * records sharing an instant stay on their own side of the cut — which is the
  * whole reason there are two kinds. An item bound is finer than either: it
- * resumes inside a record whose earlier items were already answered for. */
+ * cuts inside a record whose other items were already answered for, closed at
+ * the lower end where it resumes a read and open at the upper end where it
+ * stops short of what the caller already holds. */
 export interface Bounds {
   readonly since_at?: number;
   readonly since_uuid?: string;
   readonly since_id?: string;
   readonly until_at?: number;
   readonly until_uuid?: string;
+  readonly until_id?: string;
 }
 
 /** The bounds as stated, refused where they say two things at once.
@@ -170,8 +173,11 @@ export function bounded(bounds: Bounds): void {
   if (lower > 1) {
     throw new OpError("invalid_args", "a lower bound is a time, a record or an item, not several");
   }
-  if (bounds.until_at !== undefined && bounds.until_uuid !== undefined) {
-    throw new OpError("invalid_args", "an upper bound is a time or a record, not both");
+  const upper = [bounds.until_at, bounds.until_uuid, bounds.until_id].filter(
+    (one) => one !== undefined,
+  ).length;
+  if (upper > 1) {
+    throw new OpError("invalid_args", "an upper bound is a time, a record or an item, not several");
   }
 }
 
@@ -200,6 +206,9 @@ export function within(items: readonly Item[], bounds: Bounds): Item[] {
     }
     if (bounds.since_at !== undefined && item.at < bounds.since_at) continue;
     if (bounds.until_at !== undefined && item.at > bounds.until_at) break;
+    // An upper bound by item is open: it names an item the caller already
+    // holds, so the range ends before it rather than at it.
+    if (bounds.until_id !== undefined && item.id === bounds.until_id) break;
     kept.push(item);
     // An upper bound by record is inclusive and cuts after the last item that
     // record became, so the rest of the same record is still let through.