only_ever_generator 0.0.7 → 0.0.9

package/dist/typology_gen/generate_typology.js

@@ -11,23 +11,24 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateTypology = void 0;
 class GenerateTypology {
-    constructor(openAiService, prompt, content) {
+    constructor(openAiService, prompt, content, expected_fields) {
         this.prompt = '';
         this.content = '';
         this.openAiService = openAiService;
         this.prompt = prompt;
         this.content = content;
+        this.expectedFields = expected_fields.map((elem) => elem.toLowerCase());
     }
     generate() {
         return __awaiter(this, void 0, void 0, function* () {
-            var _a;
+            var _a, _b, _c;
             const response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(this.prompt, this.content));
             response['type'] = 'typology';
             response.metadata = {
                 "req_time": response.generated_at,
                 "req_type": response.type,
-                "req_tokens": response.usage_data.prompt_tokens,
-                "res_tokens": response.usage_data.completion_tokens,
+                "req_tokens": (_b = response.usage_data) === null || _b === void 0 ? void 0 : _b.prompt_tokens,
+                "res_tokens": (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.completion_tokens,
             };
             if (response.status_code == 200) {
                 return this.parseTypologyOnSuccess(response);
@@ -43,14 +44,21 @@ class GenerateTypology {
         return {
             status_code: 200,
             metadata: responseData.metadata,
-            field: generatedContent.field,
+            field: this.parseFields(generatedContent.field),
             concepts: generatedContent.concepts,
             facts: generatedContent.facts,
             generate_cards: generatedContent.generate_cards,
             summary_cards: generatedContent.summary_cards,
-            type: responseData.type,
+            type: responseData.type
         };
     }
+    parseFields(fields) {
+        const fieldKeys = ['primary_field', 'secondary_field', 'tertiary_field'];
+        return fields.slice(0, 3).map((item, index) => ({
+            [fieldKeys[index]]: item,
+            "reconcile": !(this.expectedFields.includes(item.toLowerCase()))
+        }));
+    }
     parseTypologyOnFailure(responseData) {
         return __awaiter(this, void 0, void 0, function* () {
             responseData.metadata.status = 'failed';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "only_ever_generator",
-  "version": "0.0.7",
+  "version": "0.0.9",
   "main": "dist/index.js",
   "scripts": {
     "start": "nodemon dist/index.js",

package/src/bootstrap/app.ts

@@ -1,18 +1,26 @@
-import { ParseSourceContent } from "../class/parse/parse_source_content";
-import { OpenAiService } from "../class/services/open_ai_service";
+import { GenerateCards } from "../card_gen/generate_cards";
+import { ParseSourceContent } from "../parse/parse_source_content";
+import { OpenAiService } from "../services/open_ai_service";
 import { returnCardGenPrompt } from "../constants/prompts/card_gen_prompt";
 import { returnTypologyPrompt } from "../constants/prompts/typology_prompt";
 import { GenerateTypology } from "../typology_gen/generate_typology";
 import { GenerateArgs } from "../utils/generate_args";
+import { returnFields } from "../constants/source_data";
+import { returnTypologyData } from "../parse/response_format_typology";
+
+
+/// OnlyEverGenerator 
 
 export class OnlyEverGenerator{
     public api_key: string = '';
     public openAiService: OpenAiService;
     parsedContent: string = '';
-    constructor(apiKey:string, model: string, content: Array<any>){
+    expectedFields: Array<string>
+    constructor(apiKey:string, model: string, content: Array<any>, expected_fields: Array<string>){
         this.api_key = apiKey;
         this.openAiService = new OpenAiService(apiKey,model ?? 'gpt-3.5-turbo-1106');
         this.parsedContent = new ParseSourceContent(content).parse();
+        this.expectedFields = returnFields()
     };
 
     typologyResponse = {};
@@ -23,8 +31,8 @@ export class OnlyEverGenerator{
     
 
     async generate( 
-       generate_card : boolean = false,
        generate_typology: boolean =false,
+       generate_card : boolean = false,
     ): Promise<Array<any>> {
       let typologyPrompt = returnTypologyPrompt();
       let cardPrompt = returnCardGenPrompt();
@@ -46,7 +54,6 @@ export class OnlyEverGenerator{
             this.typologyResponse = await this.generateTypology(args.prompts.typology_prompt ?? '');
             responseToReturn.push(this.typologyResponse);
         }else if(elem == 'generate_card'){
-
             this.cardgenResponse =  await this.generateCard(args.prompts.card_gen_prompt ?? '', this.parsedContent +  JSON.stringify(this.typologyResponse));
             responseToReturn.push(this.cardgenResponse);
         }
@@ -61,16 +68,19 @@ export class OnlyEverGenerator{
 
 
     async generateCard(prompt: string, content: string){
-        let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
-        response['type'] = 'card_gen';
-        return response;
+        let generateCards = new GenerateCards(this.openAiService);
+        let cardgenResponse =  await generateCards.generateCards(prompt ?? '', content);
+        // let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
+        // response['type'] = 'card_gen';
+         return cardgenResponse;
     }
 
     async generateTypology(prompt:string){
         let response =  await new GenerateTypology(
             this.openAiService,
             prompt,
-            this.parsedContent
+            this.parsedContent,
+            this.expectedFields,
         ).generate();
         return response;
     }

package/src/card_gen/generate_cards.ts

@@ -0,0 +1,192 @@
+import { OpenAiService } from "../services/open_ai_service";
+
+export class GenerateCards {
+  openAiService: OpenAiService;
+  constructor(openAiService: OpenAiService) {
+    this.openAiService = openAiService;
+  }
+
+  async generateCards(prompt: string, parsedContent: string) {
+    let response = await this.openAiService?.sendRequest(prompt, parsedContent);
+    console.log("response to card generation ", response);
+    response["type"] = "card_gen";
+       response.metadata = {
+        "req_time": response.generated_at,
+        "req_type": response.type,
+        "req_tokens": response.usage_data?.prompt_tokens,
+        "res_tokens": response.usage_data?.completion_tokens,
+    };
+      if(response.status_code == 200){
+        return this.parse(response);
+      } else {
+        return response;
+      }
+  }
+
+  parse(generatedData: any) {
+    const cardData = [];
+    const usage_data = generatedData.metadata;
+    const created_at = generatedData.created_at;
+    const status_code = generatedData.status_code;
+    const missing_concepts = generatedData.generated_content.missing_concepts;
+    const missing_facts = generatedData.generated_content.missing_facts;
+    const unparsedTestCards = generatedData.generated_content.test_cards;
+
+    for (let elem of unparsedTestCards) {
+      if (elem.type == "flash") {
+        cardData.push(this.parseFlashCard(elem));
+      } else if (elem.type == "mcq") {
+        cardData.push(this.parseMcqCard(elem));
+      } else if (elem.type == "cloze") {
+        cardData.push(this.parseClozeCard(elem));
+      } else if (elem.type == "match") {
+        cardData.push(this.parseMatchCard(elem));
+      }
+    }
+    usage_data["created_at"] = created_at;
+    usage_data["type"] = "card_gen";
+
+    return {
+      status_code: status_code,
+      metadata: usage_data,
+      missing_concepts: missing_concepts,
+      missing_facts: missing_facts,
+      cards_data: cardData,
+    };
+  }
+
+  parseFlashCard(data: any) {
+    let displayTitle = this.generateFlashCardDisplayTitle(
+      data.card_content.front,
+      data.card_content.back
+    );
+    let flashCardData = {
+      type: data.type,
+      heading: data.card_reference,
+      displayTitle: displayTitle,
+      content: {
+        front_content: data.card_content.front,
+        back_content: data.card_content.back,
+      },
+      concepts: data.concepts,
+      facts: data.facts,
+    };
+
+    return flashCardData;
+  }
+
+  generateFlashCardDisplayTitle(front: string, back: string) {
+    return `${front} ---- ${back}`;
+  }
+
+  parseMcqCard(data: any) {
+    let mcqAnswers = [];
+    for (let choice of data.card_content.choices) {
+      let answer = {
+        answer: choice.choice,
+        is_correct: choice.is_correct,
+      };
+      mcqAnswers.push(answer);
+    }
+    let displayTitle = this.generateMcqCardDisplayTitle(
+      data.card_content.prompt,
+      mcqAnswers
+    );
+    let mcqCard = {
+      type: data.type,
+      heading: data.card_reference,
+      displayTitle: displayTitle,
+      content: {
+        question: data.card_content.prompt,
+        answers: mcqAnswers,
+      },
+      concepts: data.concepts,
+      facts: data.facts,
+    };
+    return mcqCard;
+  }
+
+  generateMcqCardDisplayTitle(question: string, answers: any) {
+    let answersString = [];
+    for (let option of answers) {
+      let currentIndex = answers.indexOf(option) + 1;
+      let temp = `${currentIndex} . ${option.answer} `;
+      answersString.push(temp);
+    }
+    let resultString = answersString.join("");
+    let finalDisplayTitle = `${question} ---- ${resultString}`;
+    return finalDisplayTitle;
+  }
+
+  parseClozeCard(data: any) {
+    let displayTitle = this.generateClozeCardDisplayTitle(
+      data.card_content.text,
+      data.card_content.options
+    );
+    let clozeCardData = {
+      type: data.type,
+      heading: data.card_reference,
+      displayTitle: displayTitle,
+      content: {
+        question: data.card_content.text,
+        options: data.card_content.options,
+      },
+      concepts: data.concepts,
+      facts: data.facts,
+    };
+
+    return clozeCardData;
+  }
+
+  generateClozeCardDisplayTitle(question: string, answers: any) {
+    let optionsString = answers
+      .map((item: { option: any }) => item.option)
+      .join(", ");
+    return `${question} ---- ${optionsString}`;
+  }
+
+  parseMatchCard(cardData: any) {
+    let data = cardData.card_content;
+    const transformedData: { [key: string]: string[] } = {};
+
+    for (let key in data) {
+      if (data.hasOwnProperty(key)) {
+        transformedData[key] = [data[key]];
+        //     let value = data[key].replace(/[\[\]]/g, '');
+        //  let items = data[key].split(',').map((item: string) => item.trim());
+        //     map.set(key, items);
+        //   }
+      }
+      let displayTitle = this.generateMatchCardDisplayTitle(transformedData);
+      let matchCard = {
+        type: cardData.type,
+        heading: cardData.card_reference,
+        content: transformedData,
+        //  content: cardData.card_content,
+        displayTitle: displayTitle,
+        concepts: cardData.concepts,
+        facts: cardData.facts,
+      };
+
+      return matchCard;
+    }
+  }
+
+  generateMatchCardDisplayTitle(answers: any) {
+    let titles: string[] = [];
+    let counter = 65;
+    for (let key in answers) {
+      if (answers.hasOwnProperty(key)) {
+        let value = answers[key];
+        //     let items = value.split(',').map((item: string) => item.trim());
+        //     items.forEach((item: any) => {
+        let letter = String.fromCharCode(counter);
+        titles.push(`${letter}. ${key} -- ${value}`);
+        counter++;
+        //     });
+      }
+    }
+    let displayTitle = titles.join(",");
+    return displayTitle;
+  }
+}

package/src/constants/api_constants.ts

@@ -0,0 +1,3 @@
+export function openAiEndPoint(){
+    return 'https://api.openai.com/v1/chat/completions';
+}

package/src/constants/prompts/card_gen_prompt.ts

@@ -24,7 +24,7 @@ json
         {
             "type": "flash" | "mcq" | "cloze" | "match",
             "card_content": { "front": "...", "back": "..." | "prompt": "...", "choices": [ ... ] | "prompt": "...", "options": [ ... ] | "right_choice 1": "...", "left_choice 1": "..." },
-            "card_reference": "source_title#heading",
+            "card_reference": "heading",
             "concepts": ["Concept1", "Concept2", "..."],
             "facts": ["Fact1", "Fact2", "..."]
         }
@@ -36,7 +36,6 @@ json
 •	Each concept and fact must have at least one test card.
 
 Further instructions are provided below.
-
 Concepts are fundamental ideas that form the basis of knowledge in any discipline. They help organize and explain information, making it accessible and relatable.
 
 You are provided with a list of identified concepts. Review this list and the content to determine if any concepts are missing.
@@ -64,7 +63,7 @@ json
 {
     "missing_facts": ["fact1", "fact2", "fact3", "..."]
 }
-    After you have the complete list of concepts and facts, including any missing ones you identified, proceed to generate test cards for each.
+After you have the complete list of concepts and facts, including any missing ones you identified, proceed to generate test cards for each.
 
 	1.	Clarity: Ensure the test content is clear and unambiguous.
 	2.	Specificity: Be specific about what you are asking. Avoid vague or overly broad questions or prompts.
@@ -74,23 +73,29 @@ json
 Test cards must be one of the following types:
 
 1.	Flashcards: Have a front and back. 
+2.  A flashcard consists of two sides: a front and a back. Both the front and back text content must not exceed more than 300 characters in length.
 
-json
+json schema for Flash Cards:
 {
     "type": "flash",
     "card_content": {
-        "front": "<content for the front>",
-        "back": "<content for the back>"
+        "front": "<content for the front of the flashcard>",
+        "back": "<content for the back of the flashcard>"
     },
-    "card_reference": "source_title#heading",
+    "card_reference": "heading",
     "concepts": ["Concept1", "Concept2", "..."],
     "facts": ["Fact1", "Fact2", "..."]
 }
 
-- Each side must not exceed 300 characters.
+
 2. Multiple Choice Questions (MCQ): Provide multiple choices to pick from. One or more should be correct.
+•	Minimum choices required: 2
+•	Maximum choices allowed: 8
+•	Minimum correct choices required: 1
+•	Maximum character length for the prompt: 320
+•	Maximum character length for each choice: 42
 
-json
+json schema for mcqs
 {
     "type": "mcq",
     "card_content": {
@@ -101,46 +106,43 @@ json
             "... up to 8 choices"
         ]
     },
-    "card_reference": "source_title#heading",
+    "card_reference": "heading",
     "concepts": ["Concept1", "Concept2", "..."],
     "facts": ["Fact1", "Fact2", "..."]
 }
 
+3.	Cloze: 
+Fill-in-the-blank style test card. Use double curly braces {{}} to indicate a cloze this is absolute necessagr
 •	Minimum choices required: 2
 •	Maximum choices allowed: 8
 •	Minimum correct choices required: 1
 •	Maximum character length for the prompt: 320
-•	Maximum character length for each choice: 42
-
-3.	Cloze: Fill-in-the-blank style test card. Use double curly braces {{}} to indicate a cloze.
+•	Maximum character length for an individual cloze: 90
 
-json
+json schema for cloze
 {
     "type": "cloze",
     "card_content": {
-        "prompt": "Accidentals in music denote {{c0:notes}} that do not belong to the {{c1:scale}} or {{c2:mode}} indicated by the key signature.",
+        "text": "Accidentals in music denote {{c0:notes}} that do not belong to the {{c1:scale}} or {{c2:mode}} indicated by the key signature.",
         "options": [
             {"option": "notes", "cloze": "c0"},
             {"option": "scale", "cloze": "c1"},
             {"option": "mode", "cloze": "c2"},
-            {"option": "chords", "cloze": "null"},
+            {"option": "chords", "cloze": null},
             "... up to 8 choices"
         ]
     },
-    "card_reference": "source_title#heading",
+    "card_reference": "heading",
     "concepts": ["Concept1", "Concept2", "..."],
     "facts": ["Fact1", "Fact2", "..."]
 }
 
-•	Minimum choices required: 2
-•	Maximum choices allowed: 8
-•	Minimum correct choices required: 1
-•	Maximum character length for the prompt: 320
-•	Maximum character length for an individual cloze: 90
+
 
 4.	Match: Pairing items.
+•	Maximum character length for each item in a pair: 42
 
-json
+json schema for match
 {
     "type": "match",
     "card_content": {
@@ -148,104 +150,11 @@ json
         "right_choice 2": "left_choice 2",
         "... up to 8 total pairs"
     },
-    "card_reference": "source_title#heading",
+    "card_reference": "heading",
     "concepts": ["Concept1", "Concept2", "..."],
     "facts": ["Fact1", "Fact2", "..."]
 }
 
-•	Maximum character length for each item in a pair: 42
-
-
-The schema for each card type is below.
-
-A flashcard consists of two sides: a front and a back. Both the front and back text content must not exceed more than 300 characters in length.
-
-The content schema should be represented in this manner:
-json
-{
-    "front": "<content for the front of the flashcard>",
-    "back": "<content for the back of the flashcard>"
-}
-
-
-The schema for an mcq card is shown below.
-
-json
-{
-    "prompt": "<question text>",
-    "choices": 
-    [
-        {
-            choice: "choice 1",
-            is_correct: true or false
-        },
-        {
-            choice: "choice 2",
-            is_correct: true or false
-        }
-        "... up to 8 choices"
-    ]
-}
-
-Minimum choices required: 2
-Maximum choices allowed: 8
-Minimum correct choices required: 1
-Maximum character length for the prompt: 320
-Maximum character length for each choice: 42
-
-
-For questions of the "type": "cloze", which refers to a fill-in-the-blank style question, the format is outlined below. I have used the sample text here because it is easier to illustrate the schema with an example:
-
-json
-{
-    "prompt": "Accidentals in music denote {{c0:notes}} that do not belong to the {{c1:scale}} or {{c2:mode}} indicated by the key signature."
-    "options": 
-    [
-        {
-            "option: "notes",
-            "cloze": "c0"
-        },
-        {
-            "option: "scale",
-            "cloze": "c1"
-        },
-        {
-            "option: "mode",
-            "cloze": "c2"
-        },
-        {
-            "option: "chords",
-            "cloze": "null"
-        },
-        {
-            "option: "tilda",
-            "cloze": "null"
-        },
-        {
-            "option: "score",
-            "cloze": "null"
-        },
-        "... up to a maximum of 8 choices total"
-    ]
-}
-
-Minimum choices required: 2
-Maximum choices allowed: 8
-Minimum correct choices required: 1
-Maximum character length for the prompt: 320
-Maximum character length for an individual cloze: 90
-
-The schema for match type cards are as follows.
-json
-{
-    "right_choice 1": "left_choice 1",
-    "right_choice 2": "left_choice 2"
-    "right_choice 3": "left_choice 3"
-    "... up to 8 total pairs"
-}
-
-Maximum character length for each item in a pair: 42
-Each test card needs a reference. A reference can either be the entire source or a specific heading in the source. Whenever possible, pick a main heading to direct the user to the most relevant part of the source material. The reference schema is as follows: source_title#main_heading, where #main_heading is optional.
 Once you are done generating the test cards. Go back and evaulate the full list of concepts and fact that include any of the missing concepts or facts along with the list that was provided as the input. 
 
 Are there any concept or fact that don't have a test card yet? If yes, go back and create one.
@@ -266,4 +175,3 @@ export function returnCardGenPrompt(){
   return promptString;
 }
 
-