only_ever_generator 0.7.7 → 0.7.9

package/dist/bootstrap/app.d.ts

@@ -0,0 +1,96 @@
+import { OpenAiService } from "../services/open_ai_service";
+import { BaseParamType } from "../types/base_param_type";
+import { SourceTaxonomy } from "../types/source_taxonomy_type";
+export declare class OnlyEverGenerator {
+    api_key: string;
+    openAiService: OpenAiService;
+    parsedContent?: {
+        title: string;
+        headings: string[];
+        content: any[];
+        taxonomy: SourceTaxonomy;
+    };
+    promptForTypology: string;
+    promptForCardGen: string;
+    expectedFields: Array<string>;
+    typologyResponse?: SourceTaxonomy;
+    cardgenResponse: any;
+    summarizeResponse: {};
+    constructor(apiKey: string, model: string, generationContent: BaseParamType);
+    generate(generate_typology?: boolean, generate_card?: boolean): Promise<Array<any>>;
+    shouldTheCardBeGeneratedAfterTypologyResponse(): boolean;
+    generateCard(prompt: string, additionalContent: string, isGapFill: boolean, n?: number): Promise<any>;
+    generateTypology(prompt: string): Promise<any>;
+    generateEmbeddings(typologyResponse: any): Promise<{
+        concepts_facts: {
+            text: string;
+            type: string;
+            embedding: any;
+            reference: string;
+        }[];
+        metadata: {
+            req_time: string;
+            req_type: {
+                type: string;
+            };
+            req_tokens: any;
+            res_tokens: any;
+            model: any;
+            usage: any;
+        };
+    }>;
+    localConsolidation(concepts_facts: {
+        text: string;
+        type: string;
+        reference: string;
+        embedding: number[];
+    }[], sourceId: string): Promise<{
+        globalConceptOps: {
+            id: string;
+            vector: number[];
+            payload: {
+                _sources: string[];
+                text: string;
+            };
+        }[];
+        sourceIds: string[];
+        consolidatedConcepts: any[];
+        sourceTaxonomyOps: {
+            text: string;
+            id: string;
+            embedding: number[];
+            type: string;
+            reference: string;
+        }[];
+    }>;
+    globalConsolidation(concepts_facts: {
+        id: string;
+        text: string;
+        type: string;
+        reference: string;
+        embedding: number[];
+    }[], sourceId: string, threshold: number): Promise<{
+        source_taxonomy: {
+            text: string;
+            type: string;
+            reference: string;
+            id: string;
+        }[];
+        global_updates: {
+            id: string;
+            sourceIdToAdd: string;
+            currentPayload: {
+                _sources: string[];
+                text: string;
+            };
+        }[];
+        global_inserts: {
+            id: string;
+            vector: number[];
+            payload: {
+                _sources: string[];
+                text: string;
+            };
+        }[];
+    }>;
+}

package/dist/bootstrap/app.js

@@ -13,23 +13,22 @@ exports.OnlyEverGenerator = void 0;
 const generate_cards_1 = require("../card_gen/generate_cards");
 const parse_source_content_1 = require("../parse/parse_source_content");
 const open_ai_service_1 = require("../services/open_ai_service");
-// import { returnCardGenPrompt } from "../constants/prompts/card_gen_prompt";
-// import { returnTypologyPrompt } from "../constants/prompts/typology_prompt";
 const generate_typology_1 = require("../typology_gen/generate_typology");
 const generate_args_1 = require("../utils/generate_args");
-const calculate_gap_fill_1 = require("../gap_fill/calculate_gap_fill");
-/// OnlyEverGenerator
+const generate_embeddings_1 = require("../embedding_generation/generate_embeddings");
+const local_consolidation_1 = require("../embedding_generation/consolidation/local_consolidation");
+const global_consolidation_1 = require("../embedding_generation/consolidation/global_consolidation");
 class OnlyEverGenerator {
     constructor(apiKey, model, generationContent) {
         this.api_key = "";
         /// these fields will be populated inside the constructor
-        this.parsedContent = {};
+        this.parsedContent = undefined;
         this.promptForTypology = "";
         this.promptForCardGen = "";
+        this.expectedFields = [];
         this.typologyResponse = undefined;
         this.cardgenResponse = undefined;
         this.summarizeResponse = {};
-        this.gapFillResponse = {};
         this.api_key = apiKey;
         this.openAiService = new open_ai_service_1.OpenAiService(apiKey, model !== null && model !== void 0 ? model : "gpt-3.5-turbo-1106");
         const parsedData = new parse_source_content_1.ParseSourceContent(generationContent.content).parseData();
@@ -39,7 +38,6 @@ class OnlyEverGenerator {
             content: parsedData.content,
             taxonomy: parsedData.taxonomy,
         }),
-            // parsedData.type == 'cards' ? this.typologyResponse = parsedData.taxonomy :  this.typologyResponse = null;
             (this.typologyResponse = generationContent.content.taxonomy);
         this.expectedFields = generationContent.content.fields; //returnFields();
         this.promptForTypology = generationContent.prompt.typology;
@@ -47,33 +45,41 @@ class OnlyEverGenerator {
     }
     generate() {
         return __awaiter(this, arguments, void 0, function* (generate_typology = false, generate_card = false) {
+            var _a, _b, _c, _d, _e;
             let args = new generate_args_1.GenerateArgs(generate_card, generate_typology, false);
             const responseToReturn = [];
             const whatNeedsToBeGenerated = args.getWhatNeedsToBeGenerated();
             for (let elem of whatNeedsToBeGenerated)
                 if (elem == "generate_tyopology") {
                     this.typologyResponse = yield this.generateTypology(this.promptForTypology);
+                    const embeddings = yield this.generateEmbeddings(this.typologyResponse);
+                    console.log("Embedding generated");
+                    const localConsolidation = yield this.localConsolidation(embeddings.concepts_facts, this.parsedContent.title);
+                    console.log("Local consolidation done");
+                    this.typologyResponse.concepts_facts =
+                        localConsolidation.sourceTaxonomyOps;
+                    const globalConsolidation = yield this.globalConsolidation(localConsolidation.sourceTaxonomyOps, this.parsedContent.title, 0.8);
+                    console.log("Global consolidation done");
+                    this.typologyResponse.concepts_facts =
+                        globalConsolidation.source_taxonomy;
+                    (_a = this.typologyResponse.metadata) === null || _a === void 0 ? void 0 : _a.push(embeddings.metadata);
                     responseToReturn.push(this.typologyResponse);
                 }
                 else if (elem == "generate_card") {
-                    /// for cards gen to occur, there must be presence of source taxonomy
                     if (this.shouldTheCardBeGeneratedAfterTypologyResponse()) {
                         this.parsedContent.taxonomy = {
-                            concepts: this.typologyResponse.concepts,
-                            facts: this.typologyResponse.facts,
-                            generate_cards: this.typologyResponse.generate_cards,
+                            concepts_facts: (_c = (_b = this.typologyResponse) === null || _b === void 0 ? void 0 : _b.concepts_facts) !== null && _c !== void 0 ? _c : [],
+                            fields: this.expectedFields,
+                            generate_cards: (_e = (_d = this.typologyResponse) === null || _d === void 0 ? void 0 : _d.generate_cards) !== null && _e !== void 0 ? _e : {
+                                state: false,
+                                reason: "",
+                            },
                         };
                         this.cardgenResponse = yield this.generateCard(this.promptForCardGen, JSON.stringify(this.typologyResponse), false);
                         responseToReturn.push(this.cardgenResponse);
-                        /// check if gap fill is required ie coverage determination
-                        if (this.cardgenResponse.status_code == 200) {
-                            this.gapFillResponse = yield this._generationForGapFill(this.typologyResponse, this.cardgenResponse);
-                            responseToReturn.push(this.gapFillResponse);
-                        }
                     }
                 }
             return responseToReturn;
-            // return [typologyPrompt, cardPrompt];
         });
     }
     shouldTheCardBeGeneratedAfterTypologyResponse() {
@@ -85,26 +91,9 @@ class OnlyEverGenerator {
             return false;
         }
     }
-    _generationForGapFill(typologyData, cardGenData) {
-        return __awaiter(this, void 0, void 0, function* () {
-            let gapFill = (0, calculate_gap_fill_1.gapFilling)(typologyData, cardGenData);
-            let response;
-            if (gapFill.remainingConcepts.length !== 0 ||
-                gapFill.remainingFacts.length !== 0) {
-                this.typologyResponse.facts = gapFill.remainingFacts;
-                this.typologyResponse.concepts = gapFill.remainingConcepts;
-                response = yield this.generateCard(this.promptForCardGen +
-                    "Generate cards only suitable for the given remaining concepts and facts" +
-                    JSON.stringify(gapFill), "", true, 1);
-            }
-            return response;
-        });
-    }
     generateCard(prompt_1, additionalContent_1, isGapFill_1) {
         return __awaiter(this, arguments, void 0, function* (prompt, additionalContent, isGapFill, n = 0) {
             let generateCardsResp = yield new generate_cards_1.GenerateCards(this.openAiService).generateCards(prompt !== null && prompt !== void 0 ? prompt : "", JSON.stringify(this.parsedContent) + additionalContent, isGapFill, this.parsedContent.taxonomy, n);
-            // let response =  await this.openAiService?.sendRequest(prompt,this.parsedContent);
-            // response['type'] = 'card_gen';
             return generateCardsResp;
         });
     }
@@ -114,21 +103,26 @@ class OnlyEverGenerator {
             return response;
         });
     }
-    gapFill(factsMaps_1, aiCards_1) {
-        return __awaiter(this, arguments, void 0, function* (factsMaps, aiCards, n = 0) {
-            /// factsmap
-            /// {
-            /// remaining_facts: [],
-            /// remaining_concepts: [],
-            //}
-            /// aicards is data
-            let response;
-            response = yield this.generateCard(this.promptForCardGen +
-                "Generate cards only suitable for the given remaining concepts and facts" +
-                JSON.stringify(factsMaps) +
-                "Exclude generating  cards with content in the following", JSON.stringify(aiCards), true, n);
-            return response;
+    generateEmbeddings(typologyResponse) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const concepts_facts = typologyResponse.concepts_facts;
+            const texts = concepts_facts.map((e) => e.text);
+            const embeddings = yield new generate_embeddings_1.GenerateEmbeddings(this.openAiService).generateEmbeddings(concepts_facts);
+            return embeddings;
+        });
+    }
+    localConsolidation(concepts_facts, sourceId) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const embeddings = new local_consolidation_1.LocalConsolidation().consolidate(concepts_facts, sourceId);
+            return embeddings;
+        });
+    }
+    globalConsolidation(concepts_facts, sourceId, threshold) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const embeddings = yield new global_consolidation_1.GlobalConsolidation().consolidate(concepts_facts, sourceId, threshold !== null && threshold !== void 0 ? threshold : 0.8);
+            return embeddings;
         });
     }
 }
 exports.OnlyEverGenerator = OnlyEverGenerator;
+//# sourceMappingURL=app.js.map

package/dist/bootstrap/app.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"app.js","sourceRoot":"","sources":["../../src/bootstrap/app.ts"],"names":[],"mappings":"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"}

package/dist/card_gen/generate_cards.d.ts

@@ -0,0 +1,7 @@
+import { OpenAiService } from "../services/open_ai_service";
+import { SourceTaxonomy } from "../types/source_taxonomy_type";
+export declare class GenerateCards {
+    openAiService: OpenAiService;
+    constructor(openAiService: OpenAiService);
+    generateCards(prompt: string, parsedContent: string, isGapFill: boolean, taxonomy: SourceTaxonomy, n?: number): Promise<any>;
+}

package/dist/card_gen/generate_cards.js

@@ -10,6 +10,7 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.GenerateCards = void 0;
+const logger_1 = require("../logger");
 const parse_card_response_1 = require("../parse/parse_card_response");
 class GenerateCards {
     constructor(openAiService) {
@@ -18,33 +19,40 @@ class GenerateCards {
     generateCards(prompt_1, parsedContent_1, isGapFill_1, taxonomy_1) {
         return __awaiter(this, arguments, void 0, function* (prompt, parsedContent, isGapFill, taxonomy, n = 0) {
             var _a, _b, _c, _d, _e;
-            let response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(prompt, parsedContent));
-            var updatedNumber = n + 1;
-            // console.log("response to card generation ", response);
-            // response["request_type"] = ;
-            response.metadata = {
-                req_time: (_b = response.generated_at) !== null && _b !== void 0 ? _b : new Date(),
-                req_type: {
-                    type: "depth",
-                    n: updatedNumber,
-                    bloom_level: 1,
-                },
-                req_tokens: (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.prompt_tokens,
-                res_tokens: (_d = response.usage_data) === null || _d === void 0 ? void 0 : _d.completion_tokens,
-                prompt_tokens_details: (_e = response.usage_data) === null || _e === void 0 ? void 0 : _e.prompt_tokens_details,
-                model: this.openAiService.model,
-            };
-            if (response.status_code == 200) {
-                response.metadata.status = "completed";
-                let parseCard = new parse_card_response_1.ParseCardResponse().parse(response, isGapFill, taxonomy);
-                return parseCard;
+            try {
+                let response = yield ((_a = this.openAiService) === null || _a === void 0 ? void 0 : _a.sendRequest(prompt, parsedContent));
+                var updatedNumber = n + 1;
+                response.metadata = {
+                    req_time: (_b = response.generated_at) !== null && _b !== void 0 ? _b : new Date(),
+                    req_type: {
+                        type: "depth",
+                        n: updatedNumber,
+                        bloom_level: 1,
+                    },
+                    req_tokens: (_c = response.usage_data) === null || _c === void 0 ? void 0 : _c.prompt_tokens,
+                    res_tokens: (_d = response.usage_data) === null || _d === void 0 ? void 0 : _d.completion_tokens,
+                    prompt_tokens_details: (_e = response.usage_data) === null || _e === void 0 ? void 0 : _e.prompt_tokens_details,
+                    model: this.openAiService.model,
+                };
+                if (response.status_code == 200) {
+                    response.metadata.status = "completed";
+                    let parseCard = new parse_card_response_1.ParseCardResponse().parse(response, isGapFill, taxonomy, 1);
+                    return parseCard;
+                }
+                else {
+                    response.metadata.status = "failed";
+                    response.metadata.err_message = response.message;
+                    return response;
+                }
             }
-            else {
-                response.metadata.status = "failed";
-                response.metadata.err_message = response.message;
-                return response;
+            catch (e) {
+                new logger_1.ErrorLogger({
+                    type: "card_generation",
+                    data: e.message,
+                }).log();
             }
         });
     }
 }
 exports.GenerateCards = GenerateCards;
+//# sourceMappingURL=generate_cards.js.map

package/dist/card_gen/generate_cards.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"generate_cards.js","sourceRoot":"","sources":["../../src/card_gen/generate_cards.ts"],"names":[],"mappings":";;;;;;;;;;;;AAAA,sCAAwC;AACxC,sEAAiE;AAIjE,MAAa,aAAa;IAExB,YAAY,aAA4B;QACtC,IAAI,CAAC,aAAa,GAAG,aAAa,CAAC;IACrC,CAAC;IAEK,aAAa;6DACjB,MAAc,EACd,aAAqB,EACrB,SAAkB,EAClB,QAAwB,EACxB,IAAY,CAAC;;YAEb,IAAI,CAAC;gBACH,IAAI,QAAQ,GAAG,MAAM,CAAA,MAAA,IAAI,CAAC,aAAa,0CAAE,WAAW,CAClD,MAAM,EACN,aAAa,CACd,CAAA,CAAC;gBACF,IAAI,aAAa,GAAG,CAAC,GAAG,CAAC,CAAC;gBAC1B,QAAQ,CAAC,QAAQ,GAAG;oBAClB,QAAQ,EAAE,MAAA,QAAQ,CAAC,YAAY,mCAAI,IAAI,IAAI,EAAE;oBAC7C,QAAQ,EAAE;wBACR,IAAI,EAAE,OAAO;wBACb,CAAC,EAAE,aAAa;wBAChB,WAAW,EAAE,CAAC;qBACf;oBACD,UAAU,EAAE,MAAA,QAAQ,CAAC,UAAU,0CAAE,aAAa;oBAC9C,UAAU,EAAE,MAAA,QAAQ,CAAC,UAAU,0CAAE,iBAAiB;oBAClD,qBAAqB,EAAE,MAAA,QAAQ,CAAC,UAAU,0CAAE,qBAAqB;oBACjE,KAAK,EAAE,IAAI,CAAC,aAAa,CAAC,KAAK;iBAChC,CAAC;gBAEF,IAAI,QAAQ,CAAC,WAAW,IAAI,GAAG,EAAE,CAAC;oBAChC,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,WAAW,CAAC;oBACvC,IAAI,SAAS,GAAG,IAAI,uCAAiB,EAAE,CAAC,KAAK,CAC3C,QAAQ,EACR,SAAS,EACT,QAAQ,EACR,CAAC,CACF,CAAC;oBACF,OAAO,SAAS,CAAC;gBACnB,CAAC;qBAAM,CAAC;oBACN,QAAQ,CAAC,QAAQ,CAAC,MAAM,GAAG,QAAQ,CAAC;oBACpC,QAAQ,CAAC,QAAQ,CAAC,WAAW,GAAG,QAAQ,CAAC,OAAO,CAAC;oBACjD,OAAO,QAAQ,CAAC;gBAClB,CAAC;YACH,CAAC;YAAC,OAAO,CAAM,EAAE,CAAC;gBAChB,IAAI,oBAAW,CAAC;oBACd,IAAI,EAAE,iBAAiB;oBACvB,IAAI,EAAE,CAAC,CAAC,OAAO;iBAChB,CAAC,CAAC,GAAG,EAAE,CAAC;YACX,CAAC;QACH,CAAC;KAAA;CACF;AArDD,sCAqDC"}

package/dist/config.d.ts

@@ -0,0 +1,7 @@
+import "dotenv/config";
+declare const config: {
+    openAIKey: string;
+    qdrantApiKey: string | undefined;
+    qdrantUrl: string | undefined;
+};
+export default config;

package/dist/config.js

@@ -3,5 +3,8 @@ Object.defineProperty(exports, "__esModule", { value: true });
 require("dotenv/config");
 const config = {
     openAIKey: process.env.OPEN_AI_KEY,
+    qdrantApiKey: process.env.QDRANT_API_KEY,
+    qdrantUrl: process.env.QDRANT_URL,
 };
 exports.default = config;
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";;AAAA,yBAAuB;AAEvB,MAAM,MAAM,GAAG;IACb,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,WAAqB;IAC5C,YAAY,EAAE,OAAO,CAAC,GAAG,CAAC,cAAc;IACxC,SAAS,EAAE,OAAO,CAAC,GAAG,CAAC,UAAU;CAClC,CAAC;AAEF,kBAAe,MAAM,CAAC"}

package/dist/constants/api_constants.d.ts

@@ -0,0 +1,2 @@
+export declare function openAiEndPoint(): string;
+export declare function openAiEmbeddingEndPoint(): string;

package/dist/constants/api_constants.js

@@ -1,6 +1,11 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.openAiEndPoint = openAiEndPoint;
+exports.openAiEmbeddingEndPoint = openAiEmbeddingEndPoint;
 function openAiEndPoint() {
     return "https://api.openai.com/v1/chat/completions";
 }
+function openAiEmbeddingEndPoint() {
+    return "https://api.openai.com/v1/embeddings";
+}
+//# sourceMappingURL=api_constants.js.map

package/dist/constants/api_constants.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"api_constants.js","sourceRoot":"","sources":["../../src/constants/api_constants.ts"],"names":[],"mappings":";;AAAA,wCAEC;AAED,0DAEC;AAND,SAAgB,cAAc;IAC5B,OAAO,4CAA4C,CAAC;AACtD,CAAC;AAED,SAAgB,uBAAuB;IACrC,OAAO,sCAAsC,CAAC;AAChD,CAAC"}

package/dist/constants/prompt_data.d.ts

@@ -0,0 +1,4 @@
+export declare function returnPromptData(): {
+    typology: string;
+    card_generation: string;
+};

package/dist/constants/prompt_data.js

@@ -300,3 +300,4 @@ function returnPromptData() {
         card_generation: (0, card_gen_prompt_1.returnCardGenPrompt)(),
     };
 }
+//# sourceMappingURL=prompt_data.js.map

package/dist/constants/prompt_data.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prompt_data.js","sourceRoot":"","sources":["../../src/constants/prompt_data.ts"],"names":[],"mappings":";;AAuSA,4CAKC;AA5SD,+DAAgE;AAChE,+DAAiE;AAEjE,MAAM,UAAU,GAAQ;IACtB,QAAQ,EAAE;QACR,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;SAuBD;QACL,MAAM,EAAE;;;;;;;;;;;;;;;;;;;;;SAqBH;QACL,QAAQ,EAAE;;;;;;;;;;;;;;;;SAgBL;QACL,KAAK,EAAE;;;;;;;;;;SAUF;QACL,QAAQ,EAAE;;;;;;;;;;;SAWL;QACL,SAAS,EAAE;;;;;;;;;;;;SAYN;KACN;IACD,eAAe,EAAE;QACf,IAAI,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAwCD;QACL,QAAQ,EAAE;;;;;;;;;;;;;;;;SAgBL;QACL,KAAK,EAAE;;;;;;;;;;SAUF;QACL,QAAQ,EAAE;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;SAsGL;QACL,SAAS,EAAE,gUAAgU;QAC3U,aAAa,EAAE;;;;;;;;;;;;0VAYuU;KACvV;CACF,CAAC;AAEF,SAAgB,gBAAgB;IAC9B,OAAO;QACL,QAAQ,EAAE,IAAA,sCAAoB,GAAE;QAChC,eAAe,EAAE,IAAA,qCAAmB,GAAE;KACvC,CAAC;AACJ,CAAC"}

package/dist/constants/prompts/card_gen_prompt.d.ts

@@ -0,0 +1 @@
+export declare function returnCardGenPrompt(): string;

package/dist/constants/prompts/card_gen_prompt.js

@@ -165,3 +165,4 @@ Only stop generating test questions once you believe there is sufficient testing
 function returnCardGenPrompt() {
     return promptString;
 }
+//# sourceMappingURL=card_gen_prompt.js.map

package/dist/constants/prompts/card_gen_prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"card_gen_prompt.js","sourceRoot":"","sources":["../../../src/constants/prompts/card_gen_prompt.ts"],"names":[],"mappings":";;AAiKA,kDAEC;AAnKD,MAAM,YAAY,GAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAgK5B,CAAC;AACF,SAAgB,mBAAmB;IACjC,OAAO,YAAY,CAAC;AACtB,CAAC"}

package/dist/constants/prompts/typology_prompt.d.ts

@@ -0,0 +1 @@
+export declare function returnTypologyPrompt(): string;

package/dist/constants/prompts/typology_prompt.js

@@ -136,3 +136,4 @@ json
 function returnTypologyPrompt() {
     return typologyPromptString;
 }
+//# sourceMappingURL=typology_prompt.js.map

package/dist/constants/prompts/typology_prompt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"typology_prompt.js","sourceRoot":"","sources":["../../../src/constants/prompts/typology_prompt.ts"],"names":[],"mappings":";;AAyIA,oDAEC;AA3ID,MAAM,oBAAoB,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CAmI5B,CAAC;AAMF,SAAgB,oBAAoB;IAChC,OAAO,oBAAoB,CAAC;AAChC,CAAC"}

package/dist/constants/source_data.d.ts

@@ -0,0 +1,171 @@
+export declare function returnFields(): string[];
+export declare function returnSourceData(): {
+    type: string;
+    title: string;
+    headings: string[];
+    content: ({
+        block_type: string;
+        img_src: string;
+        img_caption: string;
+        content?: undefined;
+        heading_level?: undefined;
+        children?: undefined;
+    } | {
+        block_type: string;
+        content: string;
+        img_src?: undefined;
+        img_caption?: undefined;
+        heading_level?: undefined;
+        children?: undefined;
+    } | {
+        block_type: string;
+        content: string;
+        heading_level: number;
+        children: ({
+            block_type: string;
+            img_src: string;
+            img_caption: string;
+            content?: undefined;
+            heading_level?: undefined;
+            children?: undefined;
+        } | {
+            block_type: string;
+            content: string;
+            img_src?: undefined;
+            img_caption?: undefined;
+            heading_level?: undefined;
+            children?: undefined;
+        } | {
+            block_type: string;
+            content: {
+                block_type: string;
+                list_type: string;
+                marker: string;
+                content: string;
+            }[];
+            img_src?: undefined;
+            img_caption?: undefined;
+            heading_level?: undefined;
+            children?: undefined;
+        } | {
+            block_type: string;
+            content: string;
+            heading_level: number;
+            children: {
+                block_type: string;
+                content: string;
+                heading_level: number;
+                children: {
+                    block_type: string;
+                    content: string;
+                }[];
+            }[];
+            img_src?: undefined;
+            img_caption?: undefined;
+        })[];
+        img_src?: undefined;
+        img_caption?: undefined;
+    } | {
+        block_type: string;
+        content: string;
+        heading_level: number;
+        children: ({
+            block_type: string;
+            content: string;
+            heading_level?: undefined;
+            children?: undefined;
+        } | {
+            block_type: string;
+            content: {
+                block_type: string;
+                list_type: string;
+                marker: string;
+                content: string;
+            }[];
+            heading_level?: undefined;
+            children?: undefined;
+        } | {
+            block_type: string;
+            content: string;
+            heading_level: number;
+            children: ({
+                block_type: string;
+                img_src: string;
+                img_caption: string;
+                content?: undefined;
+            } | {
+                block_type: string;
+                content: string;
+                img_src?: undefined;
+                img_caption?: undefined;
+            })[];
+        })[];
+        img_src?: undefined;
+        img_caption?: undefined;
+    })[];
+    fields: string[];
+};
+export declare function returnHeadings(): string[];
+export declare function returnCardResponse(): {
+    status_code: number;
+    metadata: {};
+    usage_data: {
+        prompt_tokens: number;
+        completion_tokens: number;
+        total_tokens: number;
+    };
+    generated_content: {
+        test_cards: ({
+            type: string;
+            card_content: {
+                prompt: string;
+                choices: {
+                    choice: string;
+                    is_correct: boolean;
+                }[];
+                options?: undefined;
+            };
+            concepts: {
+                concept_text: string;
+                reference: string;
+            }[];
+            facts: {
+                fact_text: string;
+                reference: string;
+            }[];
+            bloom_level: number;
+        } | {
+            type: string;
+            card_content: {
+                prompt: string;
+                options: {
+                    option: string;
+                    cloze: string;
+                }[];
+                choices?: undefined;
+            };
+            concepts: {
+                concept_text: string;
+                reference: string;
+            }[];
+            facts: {
+                fact_text: string;
+                reference: string;
+            }[];
+            bloom_level: number;
+        } | {
+            type: string;
+            card_content: {
+                left_item: string;
+                right_item: string[];
+            }[];
+            concepts: {
+                concept_text: string;
+                reference: string;
+            }[];
+            facts: never[];
+            bloom_level: number;
+        })[];
+    };
+    generated_at: string;
+};

package/dist/constants/source_data.js

@@ -609,7 +609,7 @@ const sourceContent = {
     headings: headings,
     content: sourceString,
     fields: returnFields(),
-    taxonomy: {},
+    // taxonomy: null,
 };
 function returnSourceData() {
     return sourceContent;
@@ -971,3 +971,4 @@ let cardResponse = {
     },
     generated_at: "2024-09-11T08:26:12.000Z",
 };
+//# sourceMappingURL=source_data.js.map