stoops 0.1.0 → 0.2.0

package/dist/chunk-LC5WPWR2.js

@@ -0,0 +1,690 @@
+import {
+  EventCategory,
+  MessageSchema
+} from "./chunk-5ADJGMXQ.js";
+import {
+  createEvent
+} from "./chunk-HQS7HBZR.js";
+
+// src/core/storage.ts
+function paginate(items, limit, cursor, key) {
+  let subset;
+  if (cursor != null) {
+    const cursorIdx = items.findIndex((item) => key(item) === cursor);
+    if (cursorIdx === -1) {
+      return { items: [], next_cursor: null, has_more: false };
+    }
+    subset = items.slice(0, cursorIdx);
+  } else {
+    subset = items;
+  }
+  const page = limit < subset.length ? subset.slice(-limit) : subset.slice();
+  page.reverse();
+  const has_more = subset.length > limit;
+  const next_cursor = has_more && page.length > 0 ? key(page[page.length - 1]) : null;
+  return { items: page, next_cursor, has_more };
+}
+function paginateByIndex(items, limit, cursor) {
+  const parsedCursor = cursor != null ? parseInt(cursor, 10) : items.length;
+  const endIdx = Number.isNaN(parsedCursor) ? items.length : parsedCursor;
+  const startIdx = Math.max(0, endIdx - limit);
+  const page = items.slice(startIdx, endIdx).reverse();
+  const has_more = startIdx > 0;
+  const next_cursor = has_more ? String(startIdx) : null;
+  return { items: page, next_cursor, has_more };
+}
+var InMemoryStorage = class {
+  _messages = /* @__PURE__ */ new Map();
+  _events = /* @__PURE__ */ new Map();
+  async addMessage(message) {
+    const list = this._messages.get(message.room_id) ?? [];
+    list.push(message);
+    this._messages.set(message.room_id, list);
+    return message;
+  }
+  async getMessage(room_id, message_id) {
+    const list = this._messages.get(room_id) ?? [];
+    return list.find((m) => m.id === message_id) ?? null;
+  }
+  async getMessages(room_id, limit = 30, cursor = null) {
+    const messages = this._messages.get(room_id) ?? [];
+    return paginate(messages, limit, cursor, (m) => m.id);
+  }
+  async searchMessages(room_id, query, limit = 10, cursor = null) {
+    const messages = this._messages.get(room_id) ?? [];
+    const q = query.toLowerCase();
+    const filtered = messages.filter(
+      (m) => m.content.toLowerCase().includes(q)
+    );
+    return paginate(filtered, limit, cursor, (m) => m.id);
+  }
+  async addEvent(event) {
+    const list = this._events.get(event.room_id) ?? [];
+    list.push(event);
+    this._events.set(event.room_id, list);
+  }
+  async getEvents(room_id, category = null, limit = 50, cursor = null) {
+    let events = this._events.get(room_id) ?? [];
+    if (category != null) {
+      events = events.filter((e) => e.category === category);
+    }
+    return paginateByIndex(events, limit, cursor);
+  }
+};
+
+// src/core/channel.ts
+var Channel = class {
+  participantId;
+  participantName;
+  subscriptions;
+  _room;
+  _queue = [];
+  _waiters = [];
+  _disconnected = false;
+  constructor(room, participantId, participantName, subscriptions) {
+    this._room = room;
+    this.participantId = participantId;
+    this.participantName = participantName;
+    this.subscriptions = subscriptions;
+  }
+  get roomId() {
+    return this._room.roomId;
+  }
+  /**
+   * Send a chat message from this participant.
+   *
+   * Persists the message to storage, broadcasts a `MessageSentEvent` to all
+   * participants (including the sender), and fires `MentionedEvent` for any
+   * `@name` or `@identifier` patterns found in the content.
+   *
+   * @param content    — message text (may be empty if image is provided)
+   * @param replyToId  — ID of the message being replied to (optional)
+   * @param image      — optional image attachment
+   */
+  async sendMessage(content, replyToId, image) {
+    if (this._disconnected) {
+      throw new Error("Channel is disconnected");
+    }
+    const message = MessageSchema.parse({
+      room_id: this._room.roomId,
+      sender_id: this.participantId,
+      sender_name: this.participantName,
+      content,
+      reply_to_id: replyToId ?? null,
+      image_url: image?.url ?? null,
+      image_mime_type: image?.mimeType ?? null,
+      image_size_bytes: image?.sizeBytes ?? null
+    });
+    await this._room._handleMessage(message);
+    return message;
+  }
+  /**
+   * Emit a non-message activity event to the room.
+   *
+   * Use this for platform events: tool use indicators, mode changes, compaction
+   * notices, etc. The event is persisted and broadcast to all subscribed
+   * participants.
+   */
+  async emit(event) {
+    if (this._disconnected) {
+      throw new Error("Channel is disconnected");
+    }
+    await this._room._handleEvent(event);
+  }
+  /**
+   * Change which event categories this channel receives.
+   * Takes effect immediately — buffered events from unsubscribed categories
+   * are not retroactively removed.
+   */
+  updateSubscriptions(categories) {
+    this.subscriptions = categories;
+  }
+  /**
+   * Leave the room.
+   *
+   * @param silent — if true, suppresses the `ParticipantLeft` broadcast.
+   *                 Agents disconnect silently to avoid chat noise.
+   */
+  async disconnect(silent = false) {
+    if (!this._disconnected) {
+      this._disconnected = true;
+      const waiters = this._waiters;
+      this._waiters = [];
+      for (const w of waiters) {
+        w.reject(new Error("Channel disconnected"));
+      }
+      await this._room._disconnectChannel(this, silent);
+    }
+  }
+  /** @internal Called by Room to mark this channel as disconnected without removing from room maps. */
+  _markDisconnected() {
+    if (!this._disconnected) {
+      this._disconnected = true;
+      const waiters = this._waiters;
+      this._waiters = [];
+      for (const w of waiters) {
+        w.reject(new Error("Channel disconnected"));
+      }
+    }
+  }
+  /** @internal Called by Room to deliver an incoming event. Filters by subscription. */
+  _deliver(event) {
+    if (this._disconnected) return;
+    if (!this.subscriptions.has(event.category)) return;
+    if (this._waiters.length > 0) {
+      const waiter = this._waiters.shift();
+      waiter.resolve(event);
+    } else {
+      this._queue.push(event);
+    }
+  }
+  /**
+   * Receive the next event, waiting up to `timeoutMs`.
+   *
+   * Returns null if no event arrives within the timeout. Drains buffered events
+   * before waiting. Used by `EventMultiplexer` to fan-in events from multiple
+   * rooms into a single stream.
+   */
+  receive(timeoutMs) {
+    if (this._queue.length > 0) {
+      return Promise.resolve(this._queue.shift());
+    }
+    if (this._disconnected) {
+      return Promise.resolve(null);
+    }
+    return new Promise((resolve) => {
+      let settled = false;
+      const waiter = {
+        resolve: (event) => {
+          if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(event);
+          }
+        },
+        reject: () => {
+          if (!settled) {
+            settled = true;
+            clearTimeout(timer);
+            resolve(null);
+          }
+        }
+      };
+      this._waiters.push(waiter);
+      const timer = setTimeout(() => {
+        if (!settled) {
+          settled = true;
+          const idx = this._waiters.indexOf(waiter);
+          if (idx !== -1) this._waiters.splice(idx, 1);
+          resolve(null);
+        }
+      }, timeoutMs);
+    });
+  }
+  /**
+   * Async iterator — yields events as they arrive.
+   *
+   * Used by `EventMultiplexer` to fan-in all room channels into a single stream.
+   * The iterator completes when the channel is disconnected.
+   *
+   * @example
+   * for await (const event of channel) {
+   *   console.log(event.type);
+   * }
+   */
+  [Symbol.asyncIterator]() {
+    return {
+      next: () => {
+        if (this._queue.length > 0) {
+          return Promise.resolve({
+            value: this._queue.shift(),
+            done: false
+          });
+        }
+        if (this._disconnected) {
+          return Promise.resolve({
+            value: void 0,
+            done: true
+          });
+        }
+        return new Promise((resolve, reject) => {
+          this._waiters.push({
+            resolve: (event) => resolve({ value: event, done: false }),
+            reject
+          });
+        });
+      }
+    };
+  }
+};
+
+// src/core/room.ts
+var ALL_CATEGORIES = /* @__PURE__ */ new Set([
+  EventCategory.MESSAGE,
+  EventCategory.PRESENCE,
+  EventCategory.ACTIVITY,
+  EventCategory.MENTION
+]);
+var Room = class {
+  roomId;
+  /** Direct access to the underlying storage. Useful for bulk reads. */
+  storage;
+  _channels = /* @__PURE__ */ new Map();
+  _participants = /* @__PURE__ */ new Map();
+  _observers = /* @__PURE__ */ new Set();
+  _nextObserverId = 0;
+  /**
+   * @param roomId  — stable identifier for this room (e.g. a UUID or slug)
+   * @param storage — storage backend; defaults to `InMemoryStorage`
+   */
+  constructor(roomId, storage) {
+    this.roomId = roomId;
+    this.storage = storage ?? new InMemoryStorage();
+  }
+  /**
+   * Connect a participant and return their channel.
+   */
+  async connect(participantId, name, options) {
+    const type = options?.type ?? "human";
+    const identifier = options?.identifier;
+    const subscribe = options?.subscribe;
+    const silent = options?.silent ?? false;
+    const authority = options?.authority;
+    const participant = {
+      id: participantId,
+      name,
+      status: "online",
+      type,
+      ...identifier ? { identifier } : {},
+      ...authority ? { authority } : {}
+    };
+    this._participants.set(participantId, participant);
+    const existingChannel = this._channels.get(participantId);
+    if (existingChannel) {
+      existingChannel._markDisconnected();
+    }
+    const subscriptions = subscribe ?? new Set(ALL_CATEGORIES);
+    const channel = new Channel(this, participantId, name, subscriptions);
+    this._channels.set(participantId, channel);
+    if (!silent) {
+      const event = createEvent({
+        type: "ParticipantJoined",
+        category: "PRESENCE",
+        room_id: this.roomId,
+        participant_id: participantId,
+        participant
+      });
+      await this._storeAndBroadcast(event, participantId);
+    }
+    return channel;
+  }
+  /**
+   * Observe all room events without being a participant.
+   *
+   * Returns a channel that receives every event — broadcasts AND targeted
+   * @mention events directed at other participants. Observers do NOT appear
+   * in `listParticipants()` and do not emit join/leave presence events,
+   * since they are not participants.
+   *
+   * Disconnect via `observer.disconnect()` when done.
+   *
+   * @example
+   * const observer = room.observe();
+   * for await (const event of observer) {
+   *   // sees everything, including mentions for other participants
+   * }
+   */
+  observe() {
+    const id = `__obs_${this.roomId}_${this._nextObserverId++}`;
+    const channel = new Channel(this, id, "__observer__", new Set(ALL_CATEGORIES));
+    this._observers.add(channel);
+    return channel;
+  }
+  // ── Read methods ───────────────────────────────────────────────────────────
+  /**
+   * Paginate messages, newest-first. Pass the returned `next_cursor` to get
+   * the next (older) page.
+   */
+  async listMessages(limit = 30, cursor = null) {
+    return this.storage.getMessages(this.roomId, limit, cursor);
+  }
+  /**
+   * Full-text search across message content, newest-first.
+   * `query` is matched case-insensitively against message content.
+   */
+  async searchMessages(query, limit = 10, cursor = null) {
+    return this.storage.searchMessages(this.roomId, query, limit, cursor);
+  }
+  /** All currently connected participants (including agents). Observers excluded. */
+  listParticipants() {
+    return [...this._participants.values()];
+  }
+  /**
+   * Paginate room events, newest-first.
+   * `category` optionally filters to one EventCategory.
+   */
+  async listEvents(category = null, limit = 50, cursor = null) {
+    return this.storage.getEvents(this.roomId, category, limit, cursor);
+  }
+  /** Look up a single message by ID. Returns null if not found. */
+  async getMessage(id) {
+    return this.storage.getMessage(this.roomId, id);
+  }
+  /** Update a participant's authority level at runtime. */
+  setParticipantAuthority(participantId, authority) {
+    const participant = this._participants.get(participantId);
+    if (!participant) return false;
+    participant.authority = authority;
+    return true;
+  }
+  // ── Internal methods (called by Channel) ──────────────────────────────────
+  /**
+   * @internal
+   * Store a message, broadcast MessageSentEvent, and fire MentionedEvents.
+   *
+   * @mention scanning: looks for `@token` patterns in content and matches
+   * against each connected participant's `identifier` and display `name`
+   * (case-insensitive). Fires a `MentionedEvent` for each match, delivered
+   * to the mentioned participant AND all observers.
+   */
+  async _handleMessage(message) {
+    await this.storage.addMessage(message);
+    const event = createEvent({
+      type: "MessageSent",
+      category: "MESSAGE",
+      room_id: this.roomId,
+      participant_id: message.sender_id,
+      message
+    });
+    await this._storeAndBroadcast(event);
+    const mentions = this._detectMentions(message.content);
+    for (const mentionedId of mentions) {
+      const ch = this._channels.get(mentionedId);
+      if (ch) {
+        const mentionEvent = createEvent({
+          type: "Mentioned",
+          category: "MENTION",
+          room_id: this.roomId,
+          participant_id: mentionedId,
+          message
+        });
+        await this.storage.addEvent(mentionEvent);
+        ch._deliver(mentionEvent);
+        for (const observer of this._observers) {
+          observer._deliver(mentionEvent);
+        }
+      }
+    }
+  }
+  /** @internal Store and broadcast an activity event. */
+  async _handleEvent(event) {
+    await this._storeAndBroadcast(event, event.participant_id);
+  }
+  /** @internal Remove a channel and optionally broadcast ParticipantLeftEvent. */
+  async _disconnectChannel(channel, silent = false) {
+    if (this._observers.delete(channel)) {
+      return;
+    }
+    const pid = channel.participantId;
+    const participant = this._participants.get(pid);
+    this._channels.delete(pid);
+    this._participants.delete(pid);
+    if (!silent && participant) {
+      const event = createEvent({
+        type: "ParticipantLeft",
+        category: "PRESENCE",
+        room_id: this.roomId,
+        participant_id: pid,
+        participant
+      });
+      await this._storeAndBroadcast(event);
+    }
+  }
+  async _storeAndBroadcast(event, exclude) {
+    await this.storage.addEvent(event);
+    this._broadcast(event, exclude);
+  }
+  _broadcast(event, exclude) {
+    for (const [pid, channel] of this._channels) {
+      if (pid !== exclude) {
+        channel._deliver(event);
+      }
+    }
+    for (const observer of this._observers) {
+      observer._deliver(event);
+    }
+  }
+  /**
+   * Scan message content for `@token` patterns and return matching participant IDs.
+   * Matches against both `identifier` (e.g. `@my-agent`) and display `name` (e.g. `@Alice`).
+   * Case-insensitive. Deduplicates — each participant appears at most once.
+   */
+  _detectMentions(content) {
+    const mentionedIds = [];
+    const pattern = /@([a-zA-Z0-9_-]+)/g;
+    let match;
+    while ((match = pattern.exec(content)) !== null) {
+      const token = match[1].toLowerCase();
+      for (const [pid, participant] of this._participants) {
+        const matchesId = participant.identifier?.toLowerCase() === token;
+        const matchesName = participant.name.toLowerCase() === token;
+        if ((matchesId || matchesName) && !mentionedIds.includes(pid)) {
+          mentionedIds.push(pid);
+        }
+      }
+    }
+    return mentionedIds;
+  }
+};
+
+// src/core/names.ts
+var PLACES = [
+  "bay",
+  "cove",
+  "glen",
+  "moor",
+  "fjord",
+  "cape",
+  "crag",
+  "bluff",
+  "cliff",
+  "ridge",
+  "peak",
+  "mesa",
+  "butte",
+  "canyon",
+  "gorge",
+  "ravine",
+  "gulch",
+  "dell",
+  "dune",
+  "plain",
+  "heath",
+  "fell",
+  "bog",
+  "marsh",
+  "pond",
+  "lake",
+  "tarn",
+  "pool",
+  "harbor",
+  "haven",
+  "inlet",
+  "gulf",
+  "sound",
+  "strait",
+  "channel",
+  "delta",
+  "lagoon",
+  "atoll",
+  "shoal",
+  "shore",
+  "coast",
+  "isle",
+  "forest",
+  "grove",
+  "copse",
+  "glade",
+  "meadow",
+  "field",
+  "valley",
+  "hollow",
+  "nook",
+  "ford",
+  "falls",
+  "spring",
+  "well",
+  "crest",
+  "knoll",
+  "summit",
+  "slope",
+  "basin",
+  "bank",
+  "strand",
+  "loch",
+  "steppe",
+  "tundra",
+  "prairie",
+  "savanna",
+  "jungle",
+  "desert",
+  "highland",
+  "estuary",
+  "bight",
+  "spit",
+  "islet",
+  "island",
+  "tor",
+  "vale",
+  "brook",
+  "creek",
+  "river",
+  "weir",
+  "cascade",
+  "scarp",
+  "tower",
+  "plateau",
+  "upland",
+  "lowland"
+];
+function randomRoomName() {
+  const place = PLACES[Math.floor(Math.random() * PLACES.length)];
+  const digits = String(Math.floor(Math.random() * 9e3) + 1e3);
+  return `${place}-${digits}`;
+}
+var NAMES = [
+  "ash",
+  "kai",
+  "sol",
+  "pip",
+  "kit",
+  "zev",
+  "bly",
+  "rue",
+  "dex",
+  "nix",
+  "wren",
+  "gray",
+  "clay",
+  "reed",
+  "roux",
+  "roan",
+  "jade",
+  "max",
+  "val",
+  "xen",
+  "zen",
+  "pax",
+  "jude",
+  "finn",
+  "sage",
+  "remy",
+  "nico",
+  "noel",
+  "lumi",
+  "jules",
+  "hero",
+  "eden",
+  "blake",
+  "bram",
+  "clem",
+  "flint",
+  "nox",
+  "oak",
+  "moss",
+  "bryn",
+  "lyra",
+  "mars",
+  "neve",
+  "onyx",
+  "sable",
+  "thea",
+  "koa",
+  "ren",
+  "ora",
+  "lev",
+  "tru",
+  "vox",
+  "quinn",
+  "rowan",
+  "avery",
+  "cass",
+  "greer",
+  "holt",
+  "arlo",
+  "drew",
+  "emery",
+  "finley",
+  "harley",
+  "harper",
+  "jamie",
+  "vesper",
+  "west",
+  "wynne",
+  "yael",
+  "zion",
+  "sawyer",
+  "scout",
+  "tatum",
+  "toby",
+  "toni",
+  "riley",
+  "reese",
+  "morgan",
+  "micah",
+  "logan",
+  "lane",
+  "jordan",
+  "perry",
+  "piper",
+  "erin",
+  "dylan",
+  "camden",
+  "seren",
+  "elio",
+  "cael",
+  "davi",
+  "lyric",
+  "kiran",
+  "arrow",
+  "riven",
+  "cleo",
+  "sora",
+  "tae",
+  "cade",
+  "milo"
+];
+function randomName() {
+  const name = NAMES[Math.floor(Math.random() * NAMES.length)];
+  const digits = String(Math.floor(Math.random() * 9e3) + 1e3);
+  return `${name}-${digits}`;
+}
+
+export {
+  InMemoryStorage,
+  Channel,
+  Room,
+  randomRoomName,
+  randomName
+};
+//# sourceMappingURL=chunk-LC5WPWR2.js.map