@fitchmultz/pi-subagents 0.49.0 → 0.50.0

package/src/pi-intercom/topics.ts

@@ -1,271 +0,0 @@
-import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
-import {
-  isTopicSubscription,
-  isTopicUpdate,
-  type Message,
-  type SessionInfo,
-  type TopicSubscription,
-  type TopicUpdate,
-} from "./types.ts";
-import { isRecord, isUnknownArray } from "./validation.ts";
-import { createTopicView } from "./ui/topic-view.ts";
-interface TopicRecord {
-  readonly from: Pick<SessionInfo, "id" | "name">;
-  readonly update: TopicUpdate;
-  readonly connected: boolean;
-  readonly notifiedRevision?: number;
-}
-/** Snapshot-oriented consumer contract; the topic owner retains its map implementations. */
-const TOPIC_ENTRY = "intercom-topic";
-function isTopicRecord(value: unknown): value is TopicRecord {
-  return (
-    isRecord(value) &&
-    isRecord(value.from) &&
-    typeof value.from.id === "string" &&
-    (value.from.name === undefined || typeof value.from.name === "string") &&
-    isTopicUpdate(value.update) &&
-    typeof value.connected === "boolean" &&
-    (value.notifiedRevision === undefined || typeof value.notifiedRevision === "number")
-  );
-}
-function quietUpdate(update: TopicUpdate, subscription: TopicSubscription): boolean {
-  return (
-    update.event === "update" || (update.event === "release" && subscription.awaitRelease !== true)
-  );
-}
-function resourceText(record: TopicRecord): string {
-  const { update, connected } = record;
-  if (update.resource === undefined || update.resource === "") {
-    return "";
-  }
-  return `Resource: ${update.resource} · declared ${update.ownership ?? "state unknown"}${!connected && update.ownership !== "released" ? "; disconnect is not release" : ""}\n`;
-}
-function recordText(record: TopicRecord): string {
-  const { from, update, connected } = record;
-  return `\n${update.topic} · ${from.name ?? from.id} · ${connected ? "connected" : "disconnected / unavailable"}\n${resourceText(record)}${new Date(update.updatedAt).toISOString()} · ${update.event}\n${update.text}`;
-}
-/** Owns latest quiet state, subscriptions and durable native audit entries. */
-export class IntercomTopics {
-  private readonly pi: ExtensionAPI;
-  private readonly getContext: () => ExtensionContext | null;
-  private readonly records = new Map<string, TopicRecord>();
-  private readonly disconnectedOwners = new Set<string>();
-  private render?: () => void;
-  private readonly hydrate = new Set<string>();
-  private readonly subscriptionState = new Map<string, TopicSubscription>();
-  private readonly publicationState = new Map<string, TopicUpdate>();
-  constructor(pi: ExtensionAPI, getContext: () => ExtensionContext | null) {
-    this.pi = pi;
-    this.getContext = getContext;
-  }
-  get subscriptions(): ReadonlyMap<string, TopicSubscription> {
-    return this.subscriptionState;
-  }
-  get published(): ReadonlyMap<string, TopicUpdate> {
-    return this.publicationState;
-  }
-  private save(data: Readonly<Record<string, unknown>>): void {
-    const ctx = this.getContext();
-    if (ctx) {
-      this.pi.appendEntry(TOPIC_ENTRY, { sessionId: ctx.sessionManager.getSessionId(), ...data });
-    }
-  }
-  private restore(data: unknown, sessionId: string): void {
-    if (!isRecord(data) || data.sessionId !== sessionId) {
-      return;
-    }
-    if (isUnknownArray(data.subscriptions) && data.subscriptions.every(isTopicSubscription)) {
-      this.subscriptionState.clear();
-      for (const subscription of data.subscriptions) {
-        this.subscriptionState.set(subscription.topic, subscription);
-      }
-    }
-    if (isTopicUpdate(data.published)) {
-      this.publicationState.set(data.published.topic, data.published);
-    }
-    if (isTopicRecord(data.record)) {
-      this.records.set(`${data.record.from.id}:${data.record.update.topic}`, {
-        ...data.record,
-        connected: false,
-      });
-    }
-  }
-  start(ctx: ExtensionContext): void {
-    this.render = undefined;
-    this.records.clear();
-    this.disconnectedOwners.clear();
-    this.hydrate.clear();
-    this.subscriptionState.clear();
-    this.publicationState.clear();
-    for (const entry of ctx.sessionManager.getEntries()) {
-      if (entry.type === "custom" && entry.customType === TOPIC_ENTRY) {
-        this.restore(entry.data, ctx.sessionManager.getSessionId());
-      }
-    }
-    for (const topic of this.subscriptionState.keys()) {
-      this.hydrate.add(topic);
-    }
-  }
-  subscribe(topic: string, awaitRelease?: boolean): void {
-    this.subscriptionState.set(topic, {
-      topic,
-      ...(awaitRelease === true ? { awaitRelease } : {}),
-    });
-    this.hydrate.add(topic);
-    this.save({ subscriptions: [...this.subscriptionState.values()] });
-  }
-  unsubscribe(topic: string): void {
-    this.subscriptionState.delete(topic);
-    this.save({ subscriptions: [...this.subscriptionState.values()] });
-  }
-  publish(update: TopicUpdate, from: Pick<SessionInfo, "id" | "name">): void {
-    this.publicationState.set(update.topic, update);
-    this.save({ published: update });
-    this.record(from, update);
-  }
-  presence(): Required<Pick<SessionInfo, "subscriptions" | "topics">> {
-    return {
-      subscriptions: [...this.subscriptionState.values()],
-      topics: [...this.publicationState.values()],
-    };
-  }
-  private record(
-    from: Pick<SessionInfo, "id" | "name">,
-    update: TopicUpdate,
-    connected = true,
-  ): boolean {
-    const key = `${from.id}:${update.topic}`;
-    const previous = this.records.get(key);
-    if (previous && previous.update.revision >= update.revision) {
-      return false;
-    }
-    const record = {
-      from: { id: from.id, name: from.name },
-      update,
-      connected: connected && !this.disconnectedOwners.has(from.id),
-      notifiedRevision: previous?.notifiedRevision,
-    };
-    this.records.set(key, record);
-    this.save({ record });
-    this.render?.();
-    return true;
-  }
-  receive(from: SessionInfo, message: Message): boolean {
-    const update = message.topic;
-    if (!update) {
-      return false;
-    }
-    const subscription = this.subscriptionState.get(update.topic);
-    if (!subscription) {
-      return true;
-    }
-    const key = `${from.id}:${update.topic}`;
-    if ((this.records.get(key)?.update.revision ?? 0) > update.revision) {
-      return true;
-    }
-    this.record(from, update);
-    if (quietUpdate(update, subscription)) {
-      return true;
-    }
-    const record = this.records.get(key);
-    if (!record || (record.notifiedRevision ?? 0) >= update.revision) {
-      return true;
-    }
-    const notified = { ...record, notifiedRevision: update.revision };
-    this.records.set(key, notified);
-    this.save({ record: notified });
-    return false;
-  }
-  private refreshPublication(session: SessionInfo, update: TopicUpdate): void {
-    if (!this.subscriptionState.has(update.topic)) {
-      return;
-    }
-    this.record(session, update);
-    const key = `${session.id}:${update.topic}`;
-    const record = this.records.get(key);
-    if (
-      record &&
-      this.hydrate.has(update.topic) &&
-      (record.notifiedRevision ?? 0) < update.revision
-    ) {
-      const notified = { ...record, notifiedRevision: update.revision };
-      this.records.set(key, notified);
-      this.save({ record: notified });
-    }
-  }
-  refresh(sessions: readonly SessionInfo[]): void {
-    for (const session of sessions) {
-      this.disconnectedOwners.delete(session.id);
-    }
-    for (const [key, record] of this.records) {
-      this.records.set(key, {
-        ...record,
-        connected: sessions.some((session) => session.id === record.from.id),
-      });
-    }
-    for (const session of sessions) {
-      for (const update of session.topics ?? []) {
-        this.refreshPublication(session, update);
-      }
-    }
-    this.hydrate.clear();
-  }
-  disconnected(id?: string): void {
-    if (id !== undefined && id !== "") {
-      this.disconnectedOwners.add(id);
-    }
-    for (const [key, record] of this.records) {
-      if (id === undefined || id === "" || record.from.id === id) {
-        this.records.set(key, { ...record, connected: false });
-        this.disconnectedOwners.add(record.from.id);
-      }
-    }
-    this.render?.();
-  }
-  inspect(topic?: string): string {
-    const unfiltered = topic === undefined || topic === "";
-    const subscriptions = [...this.subscriptionState.values()].filter(
-      (item) => unfiltered || item.topic === topic,
-    );
-    const records = [...this.records.values()]
-      .filter((record) => unfiltered || record.update.topic === topic)
-      .sort((a, b) => b.update.updatedAt - a.update.updatedAt);
-    const labels = subscriptions
-      .map((item) => `${item.topic}${item.awaitRelease === true ? " (awaiting release)" : ""}`)
-      .join(", ");
-    return [
-      "Intercom topics · latest self-contained state (not a work queue or exclusive lock)",
-      `Subscriptions: ${labels === "" ? "none" : labels}`,
-      ...records.map(recordText),
-      ...(records.length === 0
-        ? ["No current records. Subscribe to an exact topic or publish a self-contained update."]
-        : []),
-    ].join("\n");
-  }
-  async open(ctx: ExtensionContext, notice?: string): Promise<void> {
-    await ctx.ui.custom<null>(
-      (tui, _theme, _keys, done) => {
-        let attached: (() => void) | undefined;
-        return createTopicView({
-          tui,
-          done: () => {
-            done(null);
-          },
-          inspect: () =>
-            [notice, this.inspect()]
-              .filter((value) => value !== undefined && value !== "")
-              .join("\n\n"),
-          attach: (render) => {
-            if (render) {
-              attached = render;
-              this.render = render;
-            } else if (this.render === attached) {
-              this.render = undefined;
-            }
-          },
-        });
-      },
-      { overlay: true, overlayOptions: { width: "100%", maxHeight: "100%", anchor: "top-left" } },
-    );
-  }
-}

package/src/pi-intercom/transcript.ts

@@ -1,226 +0,0 @@
-import type { ExtensionContext, SessionEntry } from "@earendil-works/pi-coding-agent";
-type ReadonlySessionManager = ExtensionContext["sessionManager"];
-type BoundedOptions = TranscriptOptions & { readonly limit: number; readonly maxBytes: number };
-import { isRecord, isUnknownArray } from "../shared/unknown.ts";
-import { Fault, label, object } from "./bridge-protocol.ts";
-
-export interface TranscriptOptions {
-  readonly limit?: number;
-  readonly maxBytes?: number;
-  readonly cursor?: string;
-}
-export interface TranscriptRecord {
-  readonly id: string;
-  readonly timestamp: string;
-  readonly role: string;
-  readonly text: string;
-  readonly truncated: boolean;
-}
-export interface TranscriptPage {
-  readonly sessionId: string;
-  readonly leafId: string | null;
-  readonly records: readonly TranscriptRecord[];
-  readonly bytes: number;
-  readonly truncated: boolean;
-  readonly cursor?: string;
-  readonly scanLimitReached: boolean;
-  readonly finalizedOnly: true;
-  readonly streaming: "unavailable";
-}
-const SCAN_LIMIT = 1024;
-export function transcriptOptions(value: unknown = {}): BoundedOptions {
-  const input = object(value, ["limit", "maxBytes", "cursor"]);
-  const limit = integer(input.limit, 50, 1, 100);
-  const maxBytes = integer(input.maxBytes, 65536, 256, 131072);
-  const cursor = input.cursor === undefined ? undefined : label(input.cursor, "cursor", 512);
-  return { limit, maxBytes, cursor };
-}
-function integer(value: unknown, fallback: number, min: number, max: number): number {
-  const result = value === undefined ? fallback : value;
-  if (typeof result !== "number" || !Number.isInteger(result) || result < min || result > max) {
-    throw new Fault(
-      400,
-      "invalid_input",
-      `Transcript limit must be an integer from ${min} to ${max}.`,
-    );
-  }
-  return result;
-}
-interface TextOutput {
-  readonly text: string;
-  readonly truncated: boolean;
-}
-function textualContent(content: unknown): TextOutput {
-  if (typeof content === "string") {
-    return { text: content, truncated: false };
-  }
-  if (!isUnknownArray(content)) {
-    return { text: "", truncated: false };
-  }
-  const pieces: string[] = [];
-  let remaining = 131073;
-  let truncated = content.length > 4096;
-  for (const part of content.slice(0, 4096)) {
-    if (remaining <= 0) {
-      truncated = true;
-      break;
-    }
-    if (isRecord(part) && part.type === "text" && typeof part.text === "string") {
-      const text = part.text.slice(0, remaining);
-      pieces.push(text);
-      truncated ||= text.length < part.text.length;
-      remaining -= text.length + 1;
-    }
-  }
-  return { text: pieces.join("\n"), truncated };
-}
-function visible(entry: SessionEntry): (TextOutput & { readonly role: string }) | undefined {
-  if (entry.type === "custom_message") {
-    return entry.display ? { role: "custom", ...textualContent(entry.content) } : undefined;
-  }
-  if (entry.type !== "message") {
-    return undefined;
-  }
-  const message = entry.message;
-  if (message.role === "bashExecution") {
-    return {
-      role: "toolResult",
-      text: message.output,
-      truncated: nativeTruncation(message.truncated),
-    };
-  }
-  if (!["user", "assistant", "toolResult", "custom"].includes(message.role)) {
-    return undefined;
-  }
-  if (message.role === "custom" && !message.display) {
-    return undefined;
-  }
-  return "content" in message
-    ? { role: message.role, ...textualContent(message.content) }
-    : undefined;
-}
-function nativeTruncation(value: unknown): boolean {
-  // Older saved bash entries may predate the native boolean field.
-  return value === true;
-}
-function boundedText(text: string, budget: number): string {
-  // Slice before UTF-8 encoding to avoid copying arbitrarily large live tool output.
-  const bytes = Buffer.from(text.slice(0, budget));
-  if (bytes.length <= budget) {
-    return bytes.toString();
-  }
-  let end = budget;
-  while (end > 0 && (bytes[end] & 0xc0) === 0x80) {
-    end -= 1;
-  }
-  return bytes.subarray(0, end).toString();
-}
-function startId(
-  manager: ReadonlySessionManager,
-  leaf: string | null,
-  cursor?: string,
-): { readonly id: string | null; readonly scanned: number } {
-  if (cursor === undefined) {
-    return { id: leaf, scanned: 0 };
-  }
-  let raw: unknown;
-  try {
-    raw = JSON.parse(Buffer.from(cursor, "base64url").toString("utf8"));
-  } catch {
-    throw new Fault(400, "invalid_cursor", "Invalid transcript cursor.");
-  }
-  const data = object(raw, ["leaf", "before"]);
-  if (data.leaf !== leaf) {
-    throw new Fault(409, "branch_changed", "Active branch changed; request a new transcript page.");
-  }
-  const before = label(data.before, "cursor entry", 128);
-  let id = leaf;
-  for (let scanned = 0; id !== null && scanned < SCAN_LIMIT; scanned += 1) {
-    if (id === before) {
-      return { id, scanned };
-    }
-    id = manager.getEntry(id)?.parentId ?? null;
-  }
-  throw new Fault(400, "invalid_cursor", "Cursor is outside the bounded active branch.");
-}
-/** Finalized textual output on the selected branch; never builds full history/context. */
-export function readLiveTranscript(
-  manager: ReadonlySessionManager,
-  input: TranscriptOptions = {},
-): TranscriptPage {
-  const options = transcriptOptions(input);
-  const leaf = manager.getLeafId();
-  const start = startId(manager, leaf, options.cursor);
-  let id = start.id;
-  let scanned = start.scanned;
-  const records: TranscriptRecord[] = [];
-  let bytes = 0;
-  let textTruncated = false;
-  while (id !== null && scanned < SCAN_LIMIT) {
-    scanned += 1;
-    const entry = manager.getEntry(id);
-    if (!entry) {
-      textTruncated = true;
-      id = null;
-      break;
-    }
-    const record = transcriptRecord(entry, options.maxBytes - bytes);
-    if (record !== undefined) {
-      records.push(record);
-      bytes += Buffer.byteLength(record.text);
-      textTruncated ||= record.truncated;
-    }
-    id = entry.parentId;
-    if (records.length >= options.limit || bytes >= options.maxBytes) {
-      break;
-    }
-  }
-  return transcriptPage(manager, {
-    leaf,
-    records,
-    bytes,
-    textTruncated,
-    id,
-    scanLimitReached: scanned >= SCAN_LIMIT && id !== null,
-  });
-}
-function transcriptRecord(entry: SessionEntry, budget: number): TranscriptRecord | undefined {
-  const output = visible(entry);
-  if (output === undefined || output.text.length === 0) {
-    return undefined;
-  }
-  const text = boundedText(output.text, budget);
-  return {
-    id: entry.id,
-    timestamp: entry.timestamp,
-    role: output.role,
-    text,
-    truncated: text !== output.text || output.truncated,
-  };
-}
-function transcriptPage(
-  manager: ReadonlySessionManager,
-  state: {
-    readonly leaf: string | null;
-    readonly records: TranscriptRecord[];
-    readonly bytes: number;
-    readonly textTruncated: boolean;
-    readonly id: string | null;
-    readonly scanLimitReached: boolean;
-  },
-): TranscriptPage {
-  const { leaf, records, bytes, textTruncated, id, scanLimitReached } = state;
-  return {
-    sessionId: manager.getSessionId(),
-    leafId: leaf,
-    records: records.reverse(),
-    bytes,
-    truncated: id !== null || textTruncated,
-    scanLimitReached,
-    ...(id !== null && !scanLimitReached
-      ? { cursor: Buffer.from(JSON.stringify({ leaf, before: id })).toString("base64url") }
-      : {}),
-    finalizedOnly: true,
-    streaming: "unavailable",
-  };
-}

package/src/pi-intercom/ui/compose-paste.ts

@@ -1,109 +0,0 @@
-const START = "\x1b[200~";
-const END = "\x1b[201~";
-const MAX_PASTE_CHARS = 1_000_000;
-const IDLE_MS = 200;
-export const PASTE_RENDER_TAIL_CHARS = 8192;
-
-export function printableInput(text: string): string {
-  return Array.from(text)
-    .filter((character) => character >= " " || character === "\n" || character === "\t")
-    .join("");
-}
-
-interface PasteHandlers {
-  readonly flush: (text: string) => void;
-  readonly escape: (prefix: string) => void;
-  readonly render: () => void;
-}
-
-/** Owns split bracketed-paste prefixes, bounded buffering and the idle fallback timer. */
-export class ComposePaste {
-  private buffer: string | null = null;
-  private prefix = "";
-  private timer: NodeJS.Timeout | null = null;
-
-  private readonly handlers: PasteHandlers;
-
-  constructor(handlers: PasteHandlers) {
-    this.handlers = handlers;
-  }
-
-  dispose(): void {
-    this.clearTimer();
-  }
-  get busy(): boolean {
-    return this.buffer !== null || this.prefix.length > 0;
-  }
-  get preview(): string {
-    return printableInput(this.buffer?.slice(-PASTE_RENDER_TAIL_CHARS) ?? "");
-  }
-
-  private clearTimer(): void {
-    if (this.timer) {
-      clearTimeout(this.timer);
-    }
-    this.timer = null;
-  }
-
-  private waitForBody(): void {
-    this.clearTimer();
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      if (this.buffer === null) {
-        return;
-      }
-      const text = printableInput(this.buffer.replace(/\r\n?/g, "\n"));
-      this.buffer = null;
-      this.handlers.flush(text);
-    }, IDLE_MS);
-    this.timer.unref();
-    this.handlers.render();
-  }
-
-  private waitForPrefix(text: string): void {
-    this.prefix = text;
-    this.timer = setTimeout(() => {
-      this.timer = null;
-      const prefix = this.prefix;
-      this.prefix = "";
-      if (prefix === "\x1b") {
-        this.handlers.escape(prefix);
-      }
-    }, IDLE_MS);
-    this.timer.unref();
-  }
-
-  private consumeBody(body: string): string | undefined {
-    const end = body.indexOf(END);
-    if (end === -1 && body.length <= MAX_PASTE_CHARS) {
-      this.buffer = body;
-      this.waitForBody();
-      return;
-    }
-    this.buffer = null;
-    this.clearTimer();
-    const text = end === -1 ? body : body.slice(0, end) + body.slice(end + END.length);
-    return text.replace(/\r\n?/g, "\n");
-  }
-
-  consume(input: string): { readonly text: string; readonly pasted: boolean } | undefined {
-    if (this.buffer !== null) {
-      const text = this.consumeBody(this.buffer + input);
-      return text === undefined ? undefined : { text, pasted: true };
-    }
-    const text = this.prefix + input;
-    if (this.prefix.length > 0) {
-      this.clearTimer();
-      this.prefix = "";
-    }
-    if (text !== START && START.startsWith(text)) {
-      this.waitForPrefix(text);
-      return;
-    }
-    if (text.startsWith(START)) {
-      const body = this.consumeBody(text.slice(START.length));
-      return body === undefined ? undefined : { text: body, pasted: true };
-    }
-    return { text: text.replaceAll(END, ""), pasted: false };
-  }
-}