Merge pull request #132 from synapsy-ai/vNext

Version 1.9.1

Author: lpeyr

app/[lng]/create/page.tsx

@@ -22,6 +22,7 @@ import {
   getComplexEssayPrompts,
   getModels,
   getPrompt,
+  getPromptComplexAnalysis,
   getStandardGeneration,
   getSystem,
   sendToGpt,
@@ -210,13 +211,121 @@ export default function CreatePage({
       createComplexEssay();
     } else if (type == "ph_complex") {
       createComplexPhiloEssay();
+    } else if (type === "ph_analysis_complex") {
+      createComplexPhiloAnalysis();
     } else if (type.startsWith("ph_analysis_")) {
       createAnalysis();
     } else {
       create();
     }
   }
 
+  async function createComplexPhiloAnalysis() {
+    setInProgress(true);
+    setErrorVis(false);
+    setIsGen(false);
+
+    // 1. Generate the outline
+    const outline = await getStandardGeneration(
+      getSystem("ph_analysis_outline", lng, tone),
+      getPrompt("ph_analysis_outline", lng, textToAnalyse) + "\n" + prompt,
+      s.key,
+      model,
+      {
+        temp: temp,
+        presP: presP,
+        topP: topp,
+        freqP: freqP,
+      },
+    );
+
+    if (outline instanceof OpenAI.APIError) {
+      setErrorMsg(outline);
+      setErrorVis(true);
+      setInProgress(false);
+      return;
+    }
+
+    setIsGen(true);
+    setInProgress(false);
+    setRes("");
+
+    // 2. Generate the intro
+    const intro =
+      (await sendToGptCustom(
+        getSystem("ph_analysis_outline", lng, tone),
+        getPromptComplexAnalysis(
+          textToAnalyse,
+          outline,
+          "ph_analysis_intro",
+          lng,
+        ),
+        s.key,
+        model,
+        {
+          temp: temp,
+          presP: presP,
+          topP: topp,
+          freqP: freqP,
+        },
+        "",
+        { setContent: setRes },
+      )) ?? "";
+
+    if (intro instanceof OpenAI.APIError) {
+      setErrorMsg(intro);
+      setErrorVis(true);
+      setInProgress(false);
+      return;
+    }
+
+    // 3. Generate dev part
+    const p1 = await sendToGptCustom(
+      getSystem("ph_analysis_outline", lng, tone),
+      getPromptComplexAnalysis(textToAnalyse, outline, "ph_analysis_dev", lng),
+      s.key,
+      model,
+      {
+        temp: temp,
+        presP: presP,
+        topP: topp,
+        freqP: freqP,
+      },
+      intro + "\n" || "",
+      { setContent: setRes },
+    );
+
+    // 4. Generate conclusion
+    const ccl = await sendToGptCustom(
+      getSystem("ph_analysis_outline", lng, tone),
+      getPromptComplexAnalysis(
+        textToAnalyse,
+        outline,
+        "ph_analysis_conclusion",
+        lng,
+      ),
+      s.key,
+      model,
+      {
+        temp: temp,
+        presP: presP,
+        topP: topp,
+        freqP: freqP,
+      },
+      intro + "\n" + p1 + "\n" || "",
+      { setContent: setRes },
+    );
+    setRes(intro + p1 + ccl);
+    addToHistory({
+      prompt: textToAnalyse,
+      content: intro + "\n" + p1 + "\n" + ccl ?? "",
+      template: type,
+      date: new Date(),
+    });
+    setIsGen(false);
+    setInProgress(false);
+  }
+
   async function createComplexEssay() {
     setInProgress(true);
     setErrorVis(false);

app/i18n/locales/en/common.json

@@ -93,5 +93,7 @@
   "text-analysis-introduction": "Analysis introduction",
   "text-analysis-conclusion": "Analysis conclusion",
   "text-analysis-basic": "Text analysis (Basic)",
+  "text-analysis-complex": "Text analysis (Complex)",
+  "text-analysis-outline": "Analysis outline",
   "text-analysis-dev": "Analysis development"
 }

app/i18n/locales/fr/common.json

@@ -93,5 +93,7 @@
   "text-analysis-introduction": "Introduction d'analyse",
   "text-analysis-conclusion": "Conclusion d'analyse",
   "text-analysis-basic": "Analyse de texte (Basique)",
+  "text-analysis-complex": "Analyse de texte (Complexe)",
+  "text-analysis-outline": "Plan d'analyse",
   "text-analysis-dev": "Development de l'analyse"
 }

components/generation-item.tsx

@@ -80,6 +80,10 @@ export function GenerationItem(props: {
         return t("text-analysis-basic");
       case "ph_analysis_dev":
         return t("text-analysis-dev");
+      case "ph_analysis_outline":
+        return t("text-analysis-outline");
+      case "ph_analysis_complex":
+        return t("text-analysis-complex");
       case "table":
         return t("table");
       default:

lib/ai-completions.ts

@@ -148,6 +148,13 @@ export function getSystem(
         ? ""
         : " Use the following tone: " + tone;
     }
+    if (template === "ph_analysis_outline") {
+      return "You are an expert who writes philosophy text analysis similar to those required for a high school diploma in the United States." +
+        tone ===
+        "tones-none"
+        ? ""
+        : " Use the following tone: " + tone;
+    }
     if (template === "table")
       return "You are an expert who creates HTML Tables. You help organize data in HTML tables. You ONLY give the code for the HTML Table (body ONLY,no head, no scripts) on a single line." +
         tone ===
@@ -197,6 +204,13 @@ export function getSystem(
         ? ""
         : " Utilise le ton suivant : " + tone;
     }
+    if (template === "ph_analysis_outline") {
+      return "Tu es un expert qui fait des explications de texte type bac de philosophie." +
+        tone ===
+        "tones-none"
+        ? ""
+        : " Utilise le ton suivant : " + tone;
+    }
     if (template === "table")
       return "Tu es un expert qui crée des tableaux HTML. Tu aides à organiser les données dans les tableaux HTML. Tu donnes UNIQUEMENT le code du tableau en HTML  (body SEULEMENT, pas de head, pas de scripts) en une seule ligne." +
         tone ===
@@ -266,7 +280,9 @@ export function getPrompt(
       case "ph_analysis_basic":
         return `Write the text analysis with Introduction, Development and Conclusion. Use the provided structures. Introduction structure: introduction, presentation of the text's theme, problematic (on the one hand, on the other, therefore), presentation of the author's thesis, announcement of the text's plan, using the author's arguments for each part. Development structure: The explanation is linear, i.e. the assignment must follow the order of the text. Each part corresponds to a part of the extract, and within the part, the various particular explanations (of terms, of sentences in themselves) follow one another as in the text. - For each part, start by giving the main idea. - For each sentence, give its function (premise, explanation, example...) and content, expressed in your own words. An explanation may follow if the sentence is very complex. - Explain the philosophical terms in the sentence, giving definitions, and explain underlying references (you may wish to mention other authors). End with a concrete example illustrating the author's idea. Conclusion structure: recall the most the most important elements of the development, clearly explaining how the development showed how the author demonstrated his thesis. Text: [[${prompt}]]`;
       case "ph_analysis_dev":
-        return `Write the text explanation using sentences, no list. The explanation is linear, i.e. the assignment must follow the order of the text. Each part corresponds to a part of the extract, and within the part, the various specific explanations (of terms, of sentences in themselves) follow one another as in the text. Start from the broadest to the most precise: - For each part, start by giving the main idea. - For each sentence, give its function (premise, explanation, example...) and content expressed in your own words. An explanation may follow if the sentence is very complex. - Explain the philosophical terms in the sentence by giving definitions, and make explicit any implied meaning or underlying references (you may wish to mention other authors). - End with a concrete example illustrating the author's idea. Texte : [[${prompt}]]`;
+        return `Write the text explanation using sentences, no list. The explanation is linear, i.e. the assignment must follow the order of the text. Each part corresponds to a part of the extract, and within the part, the various specific explanations (of terms, of sentences in themselves) follow one another as in the text. Start from the broadest to the most precise: - For each part, start by giving the main idea. - For each sentence, give its function (premise, explanation, example...) and content expressed in your own words. An explanation may follow if the sentence is very complex. - Explain the philosophical terms in the sentence by giving definitions, and make explicit any implied meaning or underlying references (you may wish to mention other authors). - End with a concrete example illustrating the author's idea. Text: [[${prompt}]]`;
+      case "ph_analysis_outline":
+        return `Write the outline of the text explanation. The explanation is linear, i.e. the assignment must follow the order of the text. Each part corresponds to a part of the extract, and within the part, the various specific explanations (of terms, of sentences in themselves) follow one another as in the text. Start from the broadest to the most precise: - For each part, start by giving the main idea. - For each sentence, give its function (premise, explanation, example...) and content expressed in your own words. An explanation may follow if the sentence is very complex. - Explain the philosophical terms in the sentence by giving definitions, and make explicit any implied meaning or underlying references (you may wish to mention other authors). - End with a concrete example illustrating the author's idea. Text: [[${prompt}]]`;
 
       case "table":
         return `Give ONLY the corresponding HTML Table about (no other text): ${prompt}`;
@@ -309,6 +325,8 @@ export function getPrompt(
         return `Rédige l'explication de texte avec Introduction, développement et conclusion. Utilise les structures proposées. Structure de l'introduction : introduction, présentation du thème du texte, problématique (d'une part, d'autre part, donc), présentation de la thèse de l'auteur, annonce du plan du texte, utilisation des arguments de l'auteur pour chaque partie. Structure du développement : L'explication est linéaire, c'est-à-dire que le devoir doit suivre l'ordre du texte. Chaque partie correspond à une partie de l'extrait, et à l'intérieur de la partie, les différentes explications particulières (de termes, de phrases en elles-mêmes) se succèdent comme dans le texte. - Pour chaque partie, commencez par donner l'idée principale. - Pour chaque phrase, donnez sa fonction (prémisse, explication, exemple...) et son contenu, exprimés avec vos propres mots. Une explication peut suivre si la phrase est très complexe. - Expliquez les termes philosophiques de la phrase, en donnant des définitions, et expliquez les références sous-jacentes (vous pouvez éventuellement mentionner d'autres auteurs). Terminez par un exemple concret illustrant l'idée de l'auteur. Structure de la conclusion : rappeler les éléments les plus importants du développement, en expliquant clairement comment le développement a montré comment l'auteur a démontré sa thèse. Texte : [[${prompt}]]`;
       case "ph_analysis_dev":
         return `Rédige le developpement l'explication de texte avec des phrases, pas de listes. L'explication est linéaire, c'est-à-dire que le devoir doit suivre l'ordre du texte. Chaque partie correspond à une partie de l'extrait, et à l'intérieur de la partie, les différentes explications particulières (des termes, des phrases en elles-mêmes) se succèdent comme dans le texte. Partez du plus large pour aller vers le plus précis : - Pour chaque partie, commencez par en donner l'idée principale. - Pour chaque phrase, donnez-en la fonction (postulat, explication, exemple...) et le contenu exprimé avec vos mots. Peut suivre une explication si la phrase est très complexe. - Expliquez les termes philosophiques de la phrase en donnant des définitions, et explicitez les sous-entendus, les références sous-jacentes (vous pouvez alors mentionner d'autres auteurs). - Terminez par un exemple concret illustrant l'idée de l'auteur. Texte : [[${prompt}]]`;
+      case "ph_analysis_outline":
+        return `Rédige le plan du developpement de l'explication de texte. L'explication est linéaire, c'est-à-dire que le devoir doit suivre l'ordre du texte. Chaque partie correspond à une partie de l'extrait, et à l'intérieur de la partie, les différentes explications particulières (des termes, des phrases en elles-mêmes) se succèdent comme dans le texte. Partez du plus large pour aller vers le plus précis : - Pour chaque partie, commencez par en donner l'idée principale. - Pour chaque phrase, donnez-en la fonction (postulat, explication, exemple...) et le contenu exprimé avec vos mots. Peut suivre une explication si la phrase est très complexe. - Expliquez les termes philosophiques de la phrase en donnant des définitions, et explicitez les sous-entendus, les références sous-jacentes (vous pouvez alors mentionner d'autres auteurs). - Terminez par un exemple concret illustrant l'idée de l'auteur. Texte : [[${prompt}]]`;
 
       case "table":
         return `Donne SEULEMENT le tableau HTML correspondant au sujet suivant (pas d'autre texte) : ${prompt}`;
@@ -364,3 +382,31 @@ export interface OpenAiOptions {
   presP: number;
   temp: number;
 }
+
+export function getPromptComplexAnalysis(
+  text: string,
+  outline: string,
+  template: string,
+  lng: "fr" | "en",
+): string {
+  if (lng === "en") {
+    switch (template) {
+      case "ph_analysis_intro":
+        return `Write ONLY the introduction of the text analysis using the following structure: introduction, presentation of the text's theme, problematic (on the one hand, on the other, therefore [question]), quick presentation of the author's thesis, announcement of the text's plan, using the provided outline. OUTLINE=[[${outline}]]\nTEXT=[[${text}]]`;
+      case "ph_analysis_dev":
+        return `Write the text explanation development (note that the intro and conclusion were previously written using the provided OUTLINE) using sentences, no list, don't show the different parts letters and numbers. The explanation is linear, i.e. the assignment must follow the order of the text. Each part corresponds to a part of the extract, and within the part, the various specific explanations (of terms, of sentences in themselves) follow one another as in the text. Start from the broadest to the most precise: - For each part, start by giving the main idea. - For each sentence, give its function (premise, explanation, example...) and content expressed in your own words. An explanation may follow if the sentence is very complex. - Explain the philosophical terms in the sentence by giving definitions, and make explicit any implied meaning or underlying references (you may wish to mention other authors). - End with a concrete example illustrating the author's idea. TEXT=[[${text}]]\nOUTLINE=[[${outline}]]`;
+      case "ph_analysis_conclusion":
+        return `Write ONLY the conclusion of the text analysis (which was based on the provided OUTLINE), recall the most the most important elements of the development, clearly explaining how the development showed how the author demonstrated his thesis. OUTLINE=[[${outline}]]\nTEXT=[[${text}]]`;
+    }
+  } else {
+    switch (template) {
+      case "ph_analysis_intro":
+        return `Rédiger UNIQUEMENT l'introduction de l'analyse de texte selon la structure suivante (pas de développement) : amorce, présentation du thème du texte, problématique (paragraphe avec : d'une part, d'autre part, donc [question]), présentation très rapide en une phrase de la thèse de l'auteur, annonce du plan du texte, en utilisant le plan fourni. PLAN=[[${outline}]]\nTEXTE=[[${text}]]`;
+      case "ph_analysis_dev":
+        return `Rédiger UNIQUEMENT le développement de l'explication de texte (notez que l'introduction et la conclusion ont été rédigées au préalable à l'aide du schéma fourni) en utilisant des phrases, pas de liste, ne montrez pas les différentes parties sous forme de lettres et de chiffres. L'explication est linéaire, c'est-à-dire que le travail doit suivre l'ordre du texte. Chaque partie correspond à une partie de l'extrait, et à l'intérieur de la partie, les différentes explications spécifiques (des termes, des phrases en elles-mêmes) se succèdent comme dans le texte. Partez du plus large au plus précis : - Pour chaque partie, commencez par donner l'idée principale. - Pour chaque phrase, donnez sa fonction (prémisse, explication, exemple...) et son contenu exprimé avec vos propres mots. Une explication peut suivre si la phrase est très complexe. - Expliquez les termes philosophiques de la phrase en donnant des définitions, et explicitez les sous-entendus ou les références sous-jacentes (vous pouvez citer d'autres auteurs). - Terminez par un exemple concret illustrant l'idée de l'auteur. TEXTE=[[${text}]]\nPLAN=[[${outline}]]`;
+      case "ph_analysis_conclusion":
+        return `Rédiger UNIQUEMENT la conclusion de l'analyse du texte (qui était basée sur le PLAN fourni), en rappelant les éléments les plus importants du développement, en expliquant clairement comment le développement a montré comment l'auteur a démontré sa thèse. PLAN=[[${outline}]]\nTEXTE=[[${text}]]`;
+    }
+  }
+  return "";
+}

lib/formats.ts

@@ -33,10 +33,12 @@ const formats = [
   {
     category: "text-philosophy",
     options: [
+      { text: "text-analysis-outline", val: "ph_analysis_outline" },
       { text: "text-analysis-introduction", val: "ph_analysis_intro" },
       { text: "text-analysis-dev", val: "ph_analysis_dev" },
       { text: "text-analysis-conclusion", val: "ph_analysis_conclusion" },
       { text: "text-analysis-basic", val: "ph_analysis_basic" },
+      { text: "text-analysis-complex", val: "ph_analysis_complex" },
     ],
   },
 ];

lib/version.ts

@@ -1 +1 @@
-export const version = "1.9.0";
+export const version = "1.9.1";

package-lock.json

@@ -1,6 +1,6 @@
 {
   "name": "write",
-  "version": "1.9.0",
+  "version": "1.9.1",
   "private": true,
   "scripts": {
     "dev": "next dev",