Biome fix

index.ts

@@ -1,7 +1,7 @@
 import { api } from "misskey-js";
-import Stream from "./misskey-js/streaming";
 import type { Stream as MisskeyStream } from "misskey-js";
 import type { Note, UserLite } from "misskey-js/entities.js";
+import Stream from "./misskey-js/streaming";
 
 import OpenAI from "openai";
 import type { ChatCompletionMessageParam } from "openai/resources/index.js";
@@ -16,7 +16,6 @@ const openai = new OpenAI({
   apiKey: Bun.env["OPENAI_API_KEY"],
 });
 
-
 // #region util
 
 /** pick up to random N elements from array.
@@ -37,42 +36,40 @@ const sleep = (msec: number) =>
   new Promise((resolve) => setTimeout(resolve, msec));
 // #endregion
 
-
 // #region misskey
 const me = await misskey.request("i", {});
 
 /** check if a note is suitable as an input */
 const isSuitableAsInput = (n: Note) =>
-  !n.user.isBot
+  !n.user.isBot &&
-  && !n.replyId
+  !n.replyId &&
-  && (!n.mentions || n.mentions.length === 0)
+  (!n.mentions || n.mentions.length === 0) &&
-  && n.text?.length && n.text.length > 0
+  n.text?.length &&
+  n.text.length > 0;
 
 /** randomly sample some notes from the timeline */
 async function getNotes() {
-
   // randomly sample N local notes
   const localNotes = (count: number) =>
-    misskey.request("notes/local-timeline", { limit: 100 })
+    misskey
+      .request("notes/local-timeline", { limit: 100 })
       .then((xs) => xs.filter(isSuitableAsInput))
       .then((xs) => sample(xs, count));
 
   // randomly sample N global notes
   const globalNotes = (count: number) =>
-    misskey.request("notes/global-timeline", { limit: 100 })
+    misskey
+      .request("notes/global-timeline", { limit: 100 })
       .then((xs) => xs.filter(isSuitableAsInput))
       .then((xs) => sample(xs, count));
 
   // randomly sample N notes of mine
   const myNotes = (count: number) =>
-    misskey.request("users/notes", { userId: me.id, limit: 100 })
+    misskey
+      .request("users/notes", { userId: me.id, limit: 100 })
       .then((xs) => sample(xs, count));
 
-  const notes = await Promise.all([
+  const notes = await Promise.all([localNotes(5), globalNotes(10), myNotes(2)]);
-    localNotes(5),
-    globalNotes(10),
-    myNotes(2),
-  ]);
   return sample(notes.flat());
 }
 
@@ -87,16 +84,20 @@ async function expandReplyTree(note: Note, acc: Note[] = [], cutoff = 5) {
 const noteToMessage = (note: Note): ChatCompletionMessageParam => ({
   role: note.userId === me.id ? ("assistant" as const) : ("user" as const),
   content: note.text?.replaceAll(`@${me.username}`, "") || "",
-})
+});
 // #endregion
 
-
 // #region job
 type Job =
   // read posts and post a note
   | { type: "post" }
   // reply to a specific note
-  | { type: "reply"; id: string, visibility: Note["visibility"], replyTree: Note[] };
+  | {
+      type: "reply";
+      id: string;
+      visibility: Note["visibility"];
+      replyTree: Note[];
+    };
 
 /** create a prompt for the job */
 async function preparePrompt(job: Job): Promise<ChatCompletionMessageParam[]> {
@@ -154,7 +155,7 @@ user が SNS 上で、あなたへのメッセージを送ってきています
 
 このような文体を真似して、user の発言に返答してください。`,
         },
-        ...(job.replyTree.map(noteToMessage))
+        ...job.replyTree.map(noteToMessage),
       ];
     }
   }
@@ -187,7 +188,8 @@ async function processJob(job: Job) {
   console.log();
 
   // concatenate the partial responses
-  const text = responses.join("")
+  const text = responses
+    .join("")
     .replaceAll(/(\r\n|\r|\n)\s+/g, "\n\n") // remove extra newlines
     .replaceAll("@", ""); // remove mentions
 
@@ -221,8 +223,8 @@ function initializeStream() {
       token: Bun.env["MISSKEY_CREDENTIAL"] ?? "",
     },
     {
-      binaryType: "arraybuffer"
+      binaryType: "arraybuffer",
-    }
+    },
   ) as unknown as MisskeyStream;
   channel = stream.useChannel("main");
 
@@ -241,7 +243,12 @@ function initializeStream() {
     if (e.text && e.userId !== me.id && !e.user.isBot) {
       const replyTree = await expandReplyTree(e);
       console.log(`* push: reply (${e.id}, ${replyTree.length} msgs)`);
-      jobs.push({ type: "reply", id: e.id, visibility: e.visibility, replyTree });
+      jobs.push({
+        type: "reply",
+        id: e.id,
+        visibility: e.visibility,
+        replyTree,
+      });
     }
   });
 
@@ -276,7 +283,10 @@ async function pushJob() {
   while (true) {
     const now = new Date(Date.now());
     // push a post job every 15 minutes (XX:00, XX:15, XX:30, XX:45)
-    if (now.getMinutes() % 15 < Number.EPSILON && !jobs.some((job) => job.type === "post")) {
+    if (
+      now.getMinutes() % 15 < Number.EPSILON &&
+      !jobs.some((job) => job.type === "post")
+    ) {
       console.log("* push: post");
       jobs.push({ type: "post" });
     }

misskey-js/streaming.ts

@@ -1,18 +1,23 @@
-import { EventEmitter } from 'eventemitter3';
+import { EventEmitter } from "eventemitter3";
-import ReconnectingWebsocket, { type Options } from 'reconnecting-websocket';
+import ReconnectingWebsocket, { type Options } from "reconnecting-websocket";
-import type { BroadcastEvents, Channels } from './streaming.types.js';
+import type { BroadcastEvents, Channels } from "./streaming.types.js";
 
-export function urlQuery(obj: Record<string, string | number | boolean | undefined>): string {
+export function urlQuery(
+  obj: Record<string, string | number | boolean | undefined>,
+): string {
   const params = Object.entries(obj)
-		.filter(([, v]) => Array.isArray(v) ? v.length : v !== undefined)
+    .filter(([, v]) => (Array.isArray(v) ? v.length : v !== undefined))
     // biome-ignore lint/suspicious/noAssignInExpressions: <explanation>
     // biome-ignore lint/style/noCommaOperator: <explanation>
     // biome-ignore lint/style/noNonNullAssertion: <explanation>
-		.reduce((a, [k, v]) => (a[k] = v!, a), {} as Record<string, string | number | boolean>);
+    .reduce(
+      (a, [k, v]) => ((a[k] = v!), a),
+      {} as Record<string, string | number | boolean>,
+    );
 
   return Object.entries(params)
     .map((e) => `${e[0]}=${encodeURIComponent(e[1])}`)
-		.join('&');
+    .join("&");
 }
 
 type AnyOf<T extends Record<PropertyKey, unknown>> = T[keyof T];
@@ -23,16 +28,23 @@ export type StreamEvents = {
 } & BroadcastEvents;
 
 export interface IStream extends EventEmitter<StreamEvents> {
-	state: 'initializing' | 'reconnecting' | 'connected';
+  state: "initializing" | "reconnecting" | "connected";
 
-	useChannel<C extends keyof Channels>(channel: C, params?: Channels[C]['params'], name?: string): IChannelConnection<Channels[C]>;
+  useChannel<C extends keyof Channels>(
+    channel: C,
+    params?: Channels[C]["params"],
+    name?: string,
+  ): IChannelConnection<Channels[C]>;
   removeSharedConnection(connection: SharedConnection): void;
   removeSharedConnectionPool(pool: Pool): void;
   disconnectToChannel(connection: NonSharedConnection): void;
   send(typeOrPayload: string): void;
   send(typeOrPayload: string, payload: unknown): void;
   send(typeOrPayload: Record<string, unknown> | unknown[]): void;
-	send(typeOrPayload: string | Record<string, unknown> | unknown[], payload?: unknown): void;
+  send(
+    typeOrPayload: string | Record<string, unknown> | unknown[],
+    payload?: unknown,
+  ): void;
   ping(): void;
   heartbeat(): void;
   close(): void;
@@ -42,25 +54,33 @@ export interface IStream extends EventEmitter<StreamEvents> {
  * Misskey stream connection
  */
 // eslint-disable-next-line import/no-default-export
-export default class Stream extends EventEmitter<StreamEvents> implements IStream {
+export default class Stream
+  extends EventEmitter<StreamEvents>
+  implements IStream
+{
   private stream: ReconnectingWebsocket;
-	public state: 'initializing' | 'reconnecting' | 'connected' = 'initializing';
+  public state: "initializing" | "reconnecting" | "connected" = "initializing";
   private sharedConnectionPools: Pool[] = [];
   private sharedConnections: SharedConnection[] = [];
   private nonSharedConnections: NonSharedConnection[] = [];
   private idCounter = 0;
 
-	constructor(origin: string, user: { token: string; } | null, options: {
+  constructor(
-		WebSocket?: Options['WebSocket'];
+    origin: string,
-		binaryType?: ReconnectingWebsocket['binaryType'];
+    user: { token: string } | null,
-	} = {}) {
+    options: {
+      WebSocket?: Options["WebSocket"];
+      binaryType?: ReconnectingWebsocket["binaryType"];
+    } = {},
+  ) {
     super();
 
     this.genId = this.genId.bind(this);
     this.useChannel = this.useChannel.bind(this);
     this.useSharedConnection = this.useSharedConnection.bind(this);
     this.removeSharedConnection = this.removeSharedConnection.bind(this);
-		this.removeSharedConnectionPool = this.removeSharedConnectionPool.bind(this);
+    this.removeSharedConnectionPool =
+      this.removeSharedConnectionPool.bind(this);
     this.connectToChannel = this.connectToChannel.bind(this);
     this.disconnectToChannel = this.disconnectToChannel.bind(this);
     this.onOpen = this.onOpen.bind(this);
@@ -76,70 +96,104 @@ export default class Stream extends EventEmitter<StreamEvents> implements IStrea
       _t: Date.now(),
     });
 
-		const wsOrigin = origin.replace('http://', 'ws://').replace('https://', 'wss://');
+    const wsOrigin = origin
+      .replace("http://", "ws://")
+      .replace("https://", "wss://");
 
-		this.stream = new ReconnectingWebsocket(`${wsOrigin}/streaming?${query}`, '', {
+    this.stream = new ReconnectingWebsocket(
+      `${wsOrigin}/streaming?${query}`,
+      "",
+      {
         minReconnectionDelay: 1, // https://github.com/pladaria/reconnecting-websocket/issues/91
         WebSocket: options.WebSocket,
-		});
+      },
+    );
     if (options.binaryType) {
       this.stream.binaryType = options.binaryType;
     }
-		this.stream.addEventListener('open', this.onOpen);
+    this.stream.addEventListener("open", this.onOpen);
-		this.stream.addEventListener('close', this.onClose);
+    this.stream.addEventListener("close", this.onClose);
-		this.stream.addEventListener('message', this.onMessage);
+    this.stream.addEventListener("message", this.onMessage);
   }
 
   private genId(): string {
     return (++this.idCounter).toString();
   }
 
-	public useChannel<C extends keyof Channels>(channel: C, params?: Channels[C]['params'], name?: string): Connection<Channels[C]> {
+  public useChannel<C extends keyof Channels>(
+    channel: C,
+    params?: Channels[C]["params"],
+    name?: string,
+  ): Connection<Channels[C]> {
     if (params) {
       return this.connectToChannel(channel, params);
     }
     return this.useSharedConnection(channel, name);
   }
 
-	private useSharedConnection<C extends keyof Channels>(channel: C, name?: string): SharedConnection<Channels[C]> {
+  private useSharedConnection<C extends keyof Channels>(
-		let pool = this.sharedConnectionPools.find(p => p.channel === channel);
+    channel: C,
+    name?: string,
+  ): SharedConnection<Channels[C]> {
+    let pool = this.sharedConnectionPools.find((p) => p.channel === channel);
 
     if (pool == null) {
       pool = new Pool(this, channel, this.genId());
       this.sharedConnectionPools.push(pool);
     }
 
-		const connection = new SharedConnection<Channels[C]>(this, channel, pool, name);
+    const connection = new SharedConnection<Channels[C]>(
+      this,
+      channel,
+      pool,
+      name,
+    );
     this.sharedConnections.push(connection as unknown as SharedConnection);
     return connection;
   }
 
   public removeSharedConnection(connection: SharedConnection): void {
-		this.sharedConnections = this.sharedConnections.filter(c => c !== connection);
+    this.sharedConnections = this.sharedConnections.filter(
+      (c) => c !== connection,
+    );
   }
 
   public removeSharedConnectionPool(pool: Pool): void {
-		this.sharedConnectionPools = this.sharedConnectionPools.filter(p => p !== pool);
+    this.sharedConnectionPools = this.sharedConnectionPools.filter(
+      (p) => p !== pool,
+    );
   }
 
-	private connectToChannel<C extends keyof Channels>(channel: C, params: Channels[C]['params']): NonSharedConnection<Channels[C]> {
+  private connectToChannel<C extends keyof Channels>(
-		const connection = new NonSharedConnection(this, channel, this.genId(), params);
+    channel: C,
-		this.nonSharedConnections.push(connection as unknown as NonSharedConnection);
+    params: Channels[C]["params"],
+  ): NonSharedConnection<Channels[C]> {
+    const connection = new NonSharedConnection(
+      this,
+      channel,
+      this.genId(),
+      params,
+    );
+    this.nonSharedConnections.push(
+      connection as unknown as NonSharedConnection,
+    );
     return connection;
   }
 
   public disconnectToChannel(connection: NonSharedConnection): void {
-		this.nonSharedConnections = this.nonSharedConnections.filter(c => c !== connection);
+    this.nonSharedConnections = this.nonSharedConnections.filter(
+      (c) => c !== connection,
+    );
   }
 
   /**
    * Callback of when open connection
    */
   private onOpen(): void {
-		const isReconnect = this.state === 'reconnecting';
+    const isReconnect = this.state === "reconnecting";
 
-		this.state = 'connected';
+    this.state = "connected";
-		this.emit('_connected_');
+    this.emit("_connected_");
 
     // チャンネル再接続
     if (isReconnect) {
@@ -152,27 +206,27 @@ export default class Stream extends EventEmitter<StreamEvents> implements IStrea
    * Callback of when close connection
    */
   private onClose(): void {
-		if (this.state === 'connected') {
+    if (this.state === "connected") {
-			this.state = 'reconnecting';
+      this.state = "reconnecting";
-			this.emit('_disconnected_');
+      this.emit("_disconnected_");
     }
   }
 
   /**
    * Callback of when received a message from connection
    */
-	private onMessage(message: { data: string; }): void {
+  private onMessage(message: { data: string }): void {
     const { type, body } = JSON.parse(message.data);
 
-		if (type === 'channel') {
+    if (type === "channel") {
       const id = body.id;
 
       let connections: Connection[];
 
-			connections = this.sharedConnections.filter(c => c.id === id);
+      connections = this.sharedConnections.filter((c) => c.id === id);
 
       if (connections.length === 0) {
-				const found = this.nonSharedConnections.find(c => c.id === id);
+        const found = this.nonSharedConnections.find((c) => c.id === id);
         if (found) {
           connections = [found];
         }
@@ -191,15 +245,20 @@ export default class Stream extends EventEmitter<StreamEvents> implements IStrea
    * Send a message to connection
    * ! ストリーム上のやり取りはすべてJSONで行われます !
    */
-	public send(typeOrPayload: string): void
+  public send(typeOrPayload: string): void;
-	public send(typeOrPayload: string, payload: unknown): void
+  public send(typeOrPayload: string, payload: unknown): void;
-	public send(typeOrPayload: Record<string, unknown> | unknown[]): void
+  public send(typeOrPayload: Record<string, unknown> | unknown[]): void;
-	public send(typeOrPayload: string | Record<string, unknown> | unknown[], payload?: unknown): void {
+  public send(
-		if (typeof typeOrPayload === 'string') {
+    typeOrPayload: string | Record<string, unknown> | unknown[],
-			this.stream.send(JSON.stringify({
+    payload?: unknown,
+  ): void {
+    if (typeof typeOrPayload === "string") {
+      this.stream.send(
+        JSON.stringify({
           type: typeOrPayload,
           ...(payload === undefined ? {} : { body: payload }),
-			}));
+        }),
+      );
       return;
     }
 
@@ -207,11 +266,11 @@ export default class Stream extends EventEmitter<StreamEvents> implements IStrea
   }
 
   public ping(): void {
-		this.stream.send('ping');
+    this.stream.send("ping");
   }
 
   public heartbeat(): void {
-		this.stream.send('h');
+    this.stream.send("h");
   }
 
   /**
@@ -243,7 +302,7 @@ class Pool {
     this.stream = stream;
     this.id = id;
 
-		this.stream.on('_disconnected_', this.onStreamDisconnected);
+    this.stream.on("_disconnected_", this.onStreamDisconnected);
   }
 
   private onStreamDisconnected(): void {
@@ -280,31 +339,41 @@ class Pool {
   public connect(): void {
     if (this.isConnected) return;
     this.isConnected = true;
-		this.stream.send('connect', {
+    this.stream.send("connect", {
       channel: this.channel,
       id: this.id,
     });
   }
 
   private disconnect(): void {
-		this.stream.off('_disconnected_', this.onStreamDisconnected);
+    this.stream.off("_disconnected_", this.onStreamDisconnected);
-		this.stream.send('disconnect', { id: this.id });
+    this.stream.send("disconnect", { id: this.id });
     this.stream.removeSharedConnectionPool(this);
   }
 }
 
-export interface IChannelConnection<Channel extends AnyOf<Channels> = AnyOf<Channels>> extends EventEmitter<Channel['events']> {
+export interface IChannelConnection<
+  Channel extends AnyOf<Channels> = AnyOf<Channels>,
+> extends EventEmitter<Channel["events"]> {
   id: string;
   name?: string;
   inCount: number;
   outCount: number;
   channel: string;
 
-	send<T extends keyof Channel['receives']>(type: T, body: Channel['receives'][T]): void;
+  send<T extends keyof Channel["receives"]>(
+    type: T,
+    body: Channel["receives"][T],
+  ): void;
   dispose(): void;
 }
 
-export abstract class Connection<Channel extends AnyOf<Channels> = AnyOf<Channels>> extends EventEmitter<Channel['events']> implements IChannelConnection<Channel> {
+export abstract class Connection<
+    Channel extends AnyOf<Channels> = AnyOf<Channels>,
+  >
+  extends EventEmitter<Channel["events"]>
+  implements IChannelConnection<Channel>
+{
   public channel: string;
   protected stream: Stream;
   public abstract id: string;
@@ -325,8 +394,11 @@ export abstract class Connection<Channel extends AnyOf<Channels> = AnyOf<Channel
     }
   }
 
-	public send<T extends keyof Channel['receives']>(type: T, body: Channel['receives'][T]): void {
+  public send<T extends keyof Channel["receives"]>(
-		this.stream.send('ch', {
+    type: T,
+    body: Channel["receives"][T],
+  ): void {
+    this.stream.send("ch", {
       id: this.id,
       type: type,
       body: body,
@@ -338,7 +410,9 @@ export abstract class Connection<Channel extends AnyOf<Channels> = AnyOf<Channel
   public abstract dispose(): void;
 }
 
-class SharedConnection<Channel extends AnyOf<Channels> = AnyOf<Channels>> extends Connection<Channel> {
+class SharedConnection<
+  Channel extends AnyOf<Channels> = AnyOf<Channels>,
+> extends Connection<Channel> {
   private pool: Pool;
 
   public get id(): string {
@@ -361,11 +435,18 @@ class SharedConnection<Channel extends AnyOf<Channels> = AnyOf<Channels>> extend
   }
 }
 
-class NonSharedConnection<Channel extends AnyOf<Channels> = AnyOf<Channels>> extends Connection<Channel> {
+class NonSharedConnection<
+  Channel extends AnyOf<Channels> = AnyOf<Channels>,
+> extends Connection<Channel> {
   public id: string;
-	protected params: Channel['params'];
+  protected params: Channel["params"];
 
-	constructor(stream: Stream, channel: string, id: string, params: Channel['params']) {
+  constructor(
+    stream: Stream,
+    channel: string,
+    id: string,
+    params: Channel["params"],
+  ) {
     super(stream, channel);
 
     this.connect = this.connect.bind(this);
@@ -378,7 +459,7 @@ class NonSharedConnection<Channel extends AnyOf<Channels> = AnyOf<Channels>> ext
   }
 
   public connect(): void {
-		this.stream.send('connect', {
+    this.stream.send("connect", {
       channel: this.channel,
       id: this.id,
       params: this.params,
@@ -387,7 +468,7 @@ class NonSharedConnection<Channel extends AnyOf<Channels> = AnyOf<Channels>> ext
 
   public dispose(): void {
     this.removeAllListeners();
-		this.stream.send('disconnect', { id: this.id });
+    this.stream.send("disconnect", { id: this.id });
     this.stream.disconnectToChannel(this as unknown as NonSharedConnection);
   }
 }

tsconfig.json

@@ -2,10 +2,7 @@
   "extends": "@tsconfig/strictest/tsconfig.json",
   "compilerOptions": {
     // Enable latest features
-    "lib": [
+    "lib": ["ESNext", "DOM"],
-      "ESNext",
-      "DOM"
-    ],
     "target": "ESNext",
     "module": "ESNext",
     "moduleDetection": "force",