feat: morritz

Author: typeofweb

src/commands/index.ts

@@ -8,7 +8,7 @@ import { InvalidUsageError } from '../types';
 import { addKarma, karma, KARMA_REGEX } from './karma';
 import co from './co';
 import execute from './execute';
-import grzesiu from './grzesiu';
+import { grzesiu, morritz } from './kocopoly';
 import link from './link';
 import m1 from './m1';
 import markdown from './markdown';
@@ -46,6 +46,7 @@ const allCommands = [
   markdown,
   mdn,
   mongodb,
+  morritz,
   mydevil,
   npm,
   odpowiedz,

src/commands/kocopoly.ts

@@ -0,0 +1,51 @@
+import { Command, CommandWithArgs } from '../types';
+
+import Fsp from 'fs/promises';
+import Path from 'path';
+import { getRandomKocopolyAnswers } from './kocopoly/kocopolyUtils';
+import { capitalizeFirst, wait } from '../utils';
+
+const COOLDOWN = 20;
+const KOCOPOLY_DELAY = 1500;
+
+const kocopolyExecute =
+  (kocopolyFilename: string, kocopolyName: string): CommandWithArgs['execute'] =>
+  async (msg, args) => {
+    const username = (msg.member?.displayName || msg.author.username).trim().split(/\s/)[0];
+    const question = args.join(' ');
+
+    const kocopolyJson = JSON.parse(
+      await Fsp.readFile(Path.join(__dirname, '..', kocopolyFilename), 'utf-8'),
+    ) as string[];
+
+    const messages = await getRandomKocopolyAnswers(username, question, kocopolyJson, kocopolyName);
+
+    if (!messages.length) {
+      return msg.channel.send(
+        `Niestety, ${capitalizeFirst(kocopolyName)} nie miał nic do powiedzenia!`,
+      );
+    }
+
+    return messages.reduce(async (acc, message) => {
+      await acc;
+      await msg.channel.send(`_${message}_`);
+      await wait(200 + Math.random() * KOCOPOLY_DELAY);
+      return null;
+    }, Promise.resolve(null));
+  };
+
+export const grzesiu: Command = {
+  name: 'grzesiu',
+  description: 'Użyj tego, gdy tęsknisz za Grzesiem',
+  args: 'optional',
+  cooldown: COOLDOWN,
+  execute: kocopolyExecute('grzes.json', 'grzegorz'),
+};
+
+export const morritz: Command = {
+  name: 'morritz',
+  description: 'Użyj tego, gdy tęsknisz za Morritzem',
+  args: 'optional',
+  cooldown: COOLDOWN,
+  execute: kocopolyExecute('morritz.json', 'morritz'),
+};

src/commands/grzesiu.ts renamed to src/commands/kocopoly/kocopolyUtils.ts

@@ -1,68 +1,33 @@
-import { Command } from '../types';
 import { Configuration, OpenAIApi } from 'openai';
-import Fsp from 'fs/promises';
-import Path from 'path';
 import Natural from 'natural';
 
-const wait = (ms: number) => new Promise((resolve) => setTimeout(resolve, ms));
-
 const configuration = new Configuration({
   apiKey: process.env.OPENAI_API_KEY,
 });
 const openai = new OpenAIApi(configuration);
 
 const MAX_TOKENS = 2049;
 const RESPONSE_TOKENS = 64;
+
 const MAX_GENERATED_CONTENT_LEN = Math.floor((MAX_TOKENS - RESPONSE_TOKENS) / 2); // make it cheaper
 const BANNED_PATTERNS = /[`\[\]{}\(\)]|http/g;
-const COOLDOWN = 20;
-const GRZESIU_DELAY = 1500;
-const GRZESIU_NAME = 'grzegorz';
-
-const grzesiu: Command = {
-  name: 'grzesiu',
-  description: 'Użyj tego, gdy tęsknisz za Grzesiem',
-  args: 'optional',
-  cooldown: COOLDOWN,
-  async execute(msg, args) {
-    const username = (msg.member?.displayName || msg.author.username).trim().split(/\s/)[0];
-    const question = args.join(' ');
-
-    const grzesJson = JSON.parse(
-      await Fsp.readFile(Path.join(__dirname, '..', 'grzes.json'), 'utf-8'),
-    ) as string[];
-
-    const generators = {
-      getGrzesiuAnswerFromOpenAI,
-      getRandomGrzesiuAnswers,
-    };
-
-    const messages = await generators.getRandomGrzesiuAnswers(username, question, grzesJson);
-
-    if (!messages.length) {
-      return msg.channel.send(`Niestety, Grzesiu nie miał nic do powiedzenia!`);
-    }
-
-    return messages.reduce(async (acc, message) => {
-      await acc;
-      await msg.channel.send(`_${message}_`);
-      await wait(200 + Math.random() * GRZESIU_DELAY);
-      return null;
-    }, Promise.resolve(null));
-  },
-};
-
-export default grzesiu;
 
 const getRandomInt = (len: number) => Math.floor(Math.random() * len);
 
-interface GrzesiuGenerator {
-  (username: string, question: string, grzesJson: string[]): Promise<string[]>;
+interface KocopolyGenerator {
+  (username: string, question: string, kocopolyJson: string[], kocopolyName: string): Promise<
+    string[]
+  >;
 }
 
 // random
-const getRandomGrzesiuAnswers: GrzesiuGenerator = async (_username, question, grzesJson) => {
-  const g = grzesJson
+export const getRandomKocopolyAnswers: KocopolyGenerator = async (
+  _username,
+  question,
+  kocopolyJson,
+  _kocopolyName,
+) => {
+  const g = kocopolyJson
     .map((l) => l.trim())
     .filter((line) => !BANNED_PATTERNS.test(line) && line.length > 0);
 
@@ -92,8 +57,13 @@ const getRandomGrzesiuAnswers: GrzesiuGenerator = async (_username, question, gr
 };
 
 // openAI
-const getGrzesiuAnswerFromOpenAI: GrzesiuGenerator = async (username, question, grzesJson) => {
-  const prompt = await generateGrzesiuPrompt(username, question, grzesJson);
+export const getKocopolyAnswerFromOpenAI: KocopolyGenerator = async (
+  username,
+  question,
+  kocopolyJson,
+  kocopolyName,
+) => {
+  const prompt = await generateKocopolyPrompt(username, question, kocopolyJson, kocopolyName);
 
   const engine = 'text-davinci-001';
   // const engine = 'text-babbage-001';
@@ -116,8 +86,8 @@ const getGrzesiuAnswerFromOpenAI: GrzesiuGenerator = async (username, question,
   const messages = response.data.choices[0].text
     .split('\n')
     .map((l) => l.trim())
-    .filter((l) => l.startsWith(`${GRZESIU_NAME}:`))
-    .flatMap((l) => l.split(`${GRZESIU_NAME}:`))
+    .filter((l) => l.startsWith(`${kocopolyName}:`))
+    .flatMap((l) => l.split(`${kocopolyName}:`))
     .filter((l) => l.trim().length > 0);
   return messages;
 };
@@ -128,21 +98,26 @@ const getRandomIndices = (num: number, max: number) => {
   return [...set];
 };
 
-const generateGrzesiuPrompt = async (username: string, question: string, grzesJson: string[]) => {
-  const indices = getRandomIndices(100, grzesJson.length);
-  const uniqueLines = [...new Set(indices.map((idx) => grzesJson[idx].trim()))].filter(
+const generateKocopolyPrompt = async (
+  username: string,
+  question: string,
+  kocopolyJson: string[],
+  kocopolyName: string,
+) => {
+  const indices = getRandomIndices(100, kocopolyJson.length);
+  const uniqueLines = [...new Set(indices.map((idx) => kocopolyJson[idx].trim()))].filter(
     (line) => !BANNED_PATTERNS.test(line) && line.length > 0,
   );
 
   const getFullConvo = (txt: string, username: string, question: string) => {
     if (question) {
-      return `${txt.trim()}\n${username}: ${question}\n${GRZESIU_NAME}:`;
+      return `${txt.trim()}\n${username}: ${question}\n${kocopolyName}:`;
     }
-    return `${txt.trim()}\n${GRZESIU_NAME}:`;
+    return `${txt.trim()}\n${kocopolyName}:`;
   };
 
   const txt = uniqueLines.reduce((txt, line) => {
-    const newTxt = txt + `${GRZESIU_NAME}: ` + line + '\n';
+    const newTxt = txt + `${kocopolyName}: ` + line + '\n';
     const fullConvo = getFullConvo(newTxt, username, question);
     return fullConvo.length <= MAX_GENERATED_CONTENT_LEN ? newTxt : txt;
   }, '');

src/commands/odpowiedz.ts

@@ -28,7 +28,6 @@ const odpowiedz: Command = {
   description: 'Pomoże ci wybrać odpowiedź',
   args: 'prohibited',
   execute(msg) {
-    // Really randomize the answer
     const randomAnswer = randomizeArray(ANSWERS)[0];
     return msg.channel.send(randomAnswer);
   },