@kodelyth/tlon 2026.5.42 → 2026.6.2

package/src/monitor/cites.ts

@@ -1,54 +0,0 @@
-import type { RuntimeEnv } from "klaw/plugin-sdk/runtime";
-import { asRecord, extractCites, extractMessageText, type ParsedCite } from "./utils.js";
-
-type TlonScryApi = {
-  scry: (path: string) => Promise<unknown>;
-};
-
-export function createTlonCitationResolver(params: { api: TlonScryApi; runtime: RuntimeEnv }) {
-  const { api, runtime } = params;
-
-  const resolveCiteContent = async (cite: ParsedCite): Promise<string | null> => {
-    if (cite.type !== "chan" || !cite.nest || !cite.postId) {
-      return null;
-    }
-
-    try {
-      const scryPath = `/channels/v4/${cite.nest}/posts/post/${cite.postId}.json`;
-      runtime.log?.(`[tlon] Fetching cited post: ${scryPath}`);
-
-      const data = asRecord(await api.scry(scryPath));
-      const essay = asRecord(data?.essay);
-      if (essay?.content) {
-        return extractMessageText(essay.content) || null;
-      }
-
-      return null;
-    } catch (err) {
-      runtime.log?.(`[tlon] Failed to fetch cited post: ${String(err)}`);
-      return null;
-    }
-  };
-
-  const resolveAllCites = async (content: unknown): Promise<string> => {
-    const cites = extractCites(content);
-    if (cites.length === 0) {
-      return "";
-    }
-
-    const resolved: string[] = [];
-    for (const cite of cites) {
-      const text = await resolveCiteContent(cite);
-      if (text) {
-        resolved.push(`> ${cite.author || "unknown"} wrote: ${text}`);
-      }
-    }
-
-    return resolved.length > 0 ? `${resolved.join("\n")}\n\n` : "";
-  };
-
-  return {
-    resolveCiteContent,
-    resolveAllCites,
-  };
-}

package/src/monitor/discovery.ts

@@ -1,68 +0,0 @@
-import type { RuntimeEnv } from "klaw/plugin-sdk/runtime";
-import type { Foreigns } from "../urbit/foreigns.js";
-import { asRecord, formatErrorMessage } from "./utils.js";
-
-interface InitData {
-  channels: string[];
-  foreigns: Foreigns | null;
-}
-
-/**
- * Fetch groups-ui init data, returning channels and foreigns.
- * This is a single scry that provides both channel discovery and pending invites.
- */
-export async function fetchInitData(
-  api: { scry: (path: string) => Promise<unknown> },
-  runtime: RuntimeEnv,
-): Promise<InitData> {
-  try {
-    runtime.log?.("[tlon] Fetching groups-ui init data...");
-    const initData = asRecord(await api.scry("/groups-ui/v6/init.json"));
-
-    const channels: string[] = [];
-    const groups = asRecord(initData?.groups);
-    if (groups) {
-      for (const groupData of Object.values(groups)) {
-        const typedGroupData = asRecord(groupData);
-        const groupChannels = asRecord(typedGroupData?.channels);
-        if (groupChannels) {
-          for (const channelNest of Object.keys(groupChannels)) {
-            if (channelNest.startsWith("chat/")) {
-              channels.push(channelNest);
-            }
-          }
-        }
-      }
-    }
-
-    if (channels.length > 0) {
-      runtime.log?.(`[tlon] Auto-discovered ${channels.length} chat channel(s)`);
-    } else {
-      runtime.log?.("[tlon] No chat channels found via auto-discovery");
-    }
-
-    const foreignsValue = asRecord(initData?.foreigns);
-    const foreigns = foreignsValue ? (foreignsValue as Foreigns) : null;
-    if (foreigns) {
-      const pendingCount = Object.values(foreigns).filter((f) =>
-        f.invites?.some((i) => i.valid),
-      ).length;
-      if (pendingCount > 0) {
-        runtime.log?.(`[tlon] Found ${pendingCount} pending group invite(s)`);
-      }
-    }
-
-    return { channels, foreigns };
-  } catch (error: unknown) {
-    runtime.log?.(`[tlon] Init data fetch failed: ${formatErrorMessage(error)}`);
-    return { channels: [], foreigns: null };
-  }
-}
-
-export async function fetchAllChannels(
-  api: { scry: (path: string) => Promise<unknown> },
-  runtime: RuntimeEnv,
-): Promise<string[]> {
-  const { channels } = await fetchInitData(api, runtime);
-  return channels;
-}

package/src/monitor/history.ts

@@ -1,226 +0,0 @@
-import type { RuntimeEnv } from "klaw/plugin-sdk/runtime";
-import { asRecord, extractMessageText, formatErrorMessage } from "./utils.js";
-
-/**
- * Format a number as @ud (with dots every 3 digits from the right)
- * e.g., 170141184507799509469114119040828178432 -> 170.141.184.507.799.509.469.114.119.040.828.178.432
- */
-function formatUd(id: string | number): string {
-  const str = String(id).replace(/\./g, ""); // Remove any existing dots
-  const reversed = str.split("").toReversed();
-  const chunks: string[] = [];
-  for (let i = 0; i < reversed.length; i += 3) {
-    chunks.push(
-      reversed
-        .slice(i, i + 3)
-        .toReversed()
-        .join(""),
-    );
-  }
-  return chunks.toReversed().join(".");
-}
-
-type TlonHistoryEntry = {
-  author: string;
-  content: string;
-  timestamp: number;
-  id?: string;
-};
-
-function createHistoryEntryFromMemo(params: {
-  memo?: Record<string, unknown> | null;
-  seal?: Record<string, unknown> | null;
-  fallbackId?: unknown;
-}): TlonHistoryEntry {
-  const { memo, seal, fallbackId } = params;
-  return {
-    author: typeof memo?.author === "string" ? memo.author : "unknown",
-    content: extractMessageText(memo?.content || []),
-    timestamp: typeof memo?.sent === "number" ? memo.sent : Date.now(),
-    id:
-      typeof seal?.id === "string"
-        ? seal.id
-        : typeof fallbackId === "string"
-          ? fallbackId
-          : undefined,
-  };
-}
-
-const messageCache = new Map<string, TlonHistoryEntry[]>();
-const MAX_CACHED_MESSAGES = 100;
-
-export function cacheMessage(channelNest: string, message: TlonHistoryEntry) {
-  if (!messageCache.has(channelNest)) {
-    messageCache.set(channelNest, []);
-  }
-  const cache = messageCache.get(channelNest);
-  if (!cache) {
-    return;
-  }
-  cache.unshift(message);
-  if (cache.length > MAX_CACHED_MESSAGES) {
-    cache.pop();
-  }
-}
-
-async function fetchChannelHistory(
-  api: { scry: (path: string) => Promise<unknown> },
-  channelNest: string,
-  count = 50,
-  runtime?: RuntimeEnv,
-): Promise<TlonHistoryEntry[]> {
-  try {
-    const scryPath = `/channels/v4/${channelNest}/posts/newest/${count}/outline.json`;
-    runtime?.log?.(`[tlon] Fetching history: ${scryPath}`);
-
-    const data: unknown = await api.scry(scryPath);
-    if (!data) {
-      return [];
-    }
-
-    let posts: unknown[] = [];
-    if (Array.isArray(data)) {
-      posts = data;
-    } else {
-      const dataRecord = asRecord(data);
-      const postMap = asRecord(dataRecord?.posts);
-      if (postMap) {
-        posts = Object.values(postMap);
-      } else if (dataRecord) {
-        posts = Object.values(dataRecord);
-      }
-    }
-
-    const messages = posts
-      .map((item) => {
-        const itemRecord = asRecord(item);
-        const replyPost = asRecord(itemRecord?.["r-post"]);
-        const replyPostSet = asRecord(replyPost?.set);
-        const essay = asRecord(itemRecord?.essay) ?? asRecord(replyPostSet?.essay);
-        const seal = asRecord(itemRecord?.seal) ?? asRecord(replyPostSet?.seal);
-
-        return {
-          author: typeof essay?.author === "string" ? essay.author : "unknown",
-          content: extractMessageText(essay?.content || []),
-          timestamp: typeof essay?.sent === "number" ? essay.sent : Date.now(),
-          id: typeof seal?.id === "string" ? seal.id : undefined,
-        } as TlonHistoryEntry;
-      })
-      .filter((msg) => msg.content);
-
-    runtime?.log?.(`[tlon] Extracted ${messages.length} messages from history`);
-    return messages;
-  } catch (error: unknown) {
-    runtime?.log?.(`[tlon] Error fetching channel history: ${formatErrorMessage(error)}`);
-    return [];
-  }
-}
-
-export async function getChannelHistory(
-  api: { scry: (path: string) => Promise<unknown> },
-  channelNest: string,
-  count = 50,
-  runtime?: RuntimeEnv,
-): Promise<TlonHistoryEntry[]> {
-  const cache = messageCache.get(channelNest) ?? [];
-  if (cache.length >= count) {
-    runtime?.log?.(`[tlon] Using cached messages (${cache.length} available)`);
-    return cache.slice(0, count);
-  }
-
-  runtime?.log?.(`[tlon] Cache has ${cache.length} messages, need ${count}, fetching from scry...`);
-  return await fetchChannelHistory(api, channelNest, count, runtime);
-}
-
-/**
- * Fetch thread/reply history for a specific parent post.
- * Used to get context when entering a thread conversation.
- */
-export async function fetchThreadHistory(
-  api: { scry: (path: string) => Promise<unknown> },
-  channelNest: string,
-  parentId: string,
-  count = 50,
-  runtime?: RuntimeEnv,
-): Promise<TlonHistoryEntry[]> {
-  try {
-    // Tlon API: fetch replies to a specific post
-    // Format: /channels/v4/{nest}/posts/post/{parentId}/replies/newest/{count}.json
-    // parentId needs @ud formatting (dots every 3 digits)
-    const formattedParentId = formatUd(parentId);
-    runtime?.log?.(
-      `[tlon] Thread history - parentId: ${parentId} -> formatted: ${formattedParentId}`,
-    );
-
-    const scryPath = `/channels/v4/${channelNest}/posts/post/id/${formattedParentId}/replies/newest/${count}.json`;
-    runtime?.log?.(`[tlon] Fetching thread history: ${scryPath}`);
-
-    const data: unknown = await api.scry(scryPath);
-    if (!data) {
-      runtime?.log?.(`[tlon] No thread history data returned`);
-      return [];
-    }
-
-    let replies: unknown[] = [];
-    if (Array.isArray(data)) {
-      replies = data;
-    } else {
-      const dataRecord = asRecord(data);
-      const replyValue = dataRecord?.replies;
-      if (Array.isArray(replyValue)) {
-        replies = replyValue;
-      } else if (typeof replyValue === "object" && replyValue) {
-        replies = Object.values(replyValue as Record<string, unknown>);
-      } else if (dataRecord) {
-        replies = Object.values(dataRecord);
-      }
-    }
-
-    const messages = replies
-      .map((item) => {
-        // Thread replies use 'memo' structure
-        const itemRecord = asRecord(item);
-        const replyRecord = asRecord(itemRecord?.["r-reply"]);
-        const replySet = asRecord(replyRecord?.set);
-        const memo = asRecord(itemRecord?.memo) ?? asRecord(replySet?.memo) ?? itemRecord;
-        const seal = asRecord(itemRecord?.seal) ?? asRecord(replySet?.seal);
-
-        return createHistoryEntryFromMemo({ memo, seal, fallbackId: itemRecord?.id });
-      })
-      .filter((msg) => msg.content);
-
-    runtime?.log?.(`[tlon] Extracted ${messages.length} thread replies from history`);
-    return messages;
-  } catch (error: unknown) {
-    runtime?.log?.(`[tlon] Error fetching thread history: ${formatErrorMessage(error)}`);
-    // Fall back to trying alternate path structure
-    try {
-      const altPath = `/channels/v4/${channelNest}/posts/post/id/${formatUd(parentId)}.json`;
-      runtime?.log?.(`[tlon] Trying alternate path: ${altPath}`);
-      const data = asRecord(await api.scry(altPath));
-      const dataSeal = asRecord(data?.seal);
-      const dataMeta = asRecord(dataSeal?.meta);
-      const repliesValue = data?.replies;
-
-      if (typeof dataMeta?.replyCount === "number" && dataMeta.replyCount > 0 && repliesValue) {
-        const replies = Array.isArray(repliesValue)
-          ? repliesValue
-          : Object.values(repliesValue as Record<string, unknown>);
-        const messages = replies
-          .map((reply: unknown) => {
-            const replyRecord = asRecord(reply);
-            const memo = asRecord(replyRecord?.memo);
-            const seal = asRecord(replyRecord?.seal);
-            return createHistoryEntryFromMemo({ memo, seal });
-          })
-          .filter((msg: TlonHistoryEntry) => msg.content);
-
-        runtime?.log?.(`[tlon] Extracted ${messages.length} replies from post data`);
-        return messages;
-      }
-    } catch (altError: unknown) {
-      runtime?.log?.(`[tlon] Alternate path also failed: ${formatErrorMessage(altError)}`);
-    }
-    return [];
-  }
-}