@yrpri/api 9.0.103 → 9.0.104

package/dist/active-citizen/controllers/recommendations.cjs

@@ -1,280 +0,0 @@
-"use strict";
-var express = require('express');
-var router = express.Router();
-var models = require("../../models/index.cjs");
-var auth = require('../../authorization.cjs');
-var log = require('../utils/logger.cjs');
-var _ = require('lodash');
-var moment = require('moment');
-var getRecommendationFor = require('../engine/recommendations/events_manager.cjs').getRecommendationFor;
-var airbrake = null;
-if (process.env.AIRBRAKE_PROJECT_ID) {
-    airbrake = require('../utils/airbrake.cjs');
-}
-var OVERALL_LIMIT = 7;
-var DATE_OPTIONS = { name: "date", after: moment().add(-1000, 'months').toISOString() };
-//var DATE_OPTIONS_YEAR = { name:"date", after: moment().add(-300, 'months').toISOString() };
-var setupOptions = function (req) {
-    var options = {
-        user_id: req.user ? req.user.id : -1
-    };
-    return options;
-};
-var processRecommendations = function (levelType, req, res, recommendedItemIds, error) {
-    if (error) {
-        log.error("Recommendation Error " + levelType, { err: error, id: req.params.id, userId: req.user ? req.user.id : -1, errorStatus: 500 });
-        if (airbrake) {
-            airbrake.notify(error).then((airbrakeErr) => {
-                if (airbrakeErr.error) {
-                    log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
-                }
-            });
-        }
-        res.send([]);
-    }
-    else {
-        if (recommendedItemIds.length > OVERALL_LIMIT) {
-            recommendedItemIds = _.dropRight(recommendedItemIds, recommendedItemIds.length - OVERALL_LIMIT);
-        }
-        log.info("Recommendations domains status", { recommendedItemIds: recommendedItemIds });
-        models.Post.findAll({
-            where: {
-                id: {
-                    $in: recommendedItemIds
-                }
-            },
-            order: [
-                [{ model: models.Image, as: 'PostHeaderImages' }, 'updated_at', 'asc'],
-                [{ model: models.Video, as: "PostVideos" }, { model: models.Image, as: 'VideoImages' }, 'updated_at', 'asc']
-            ],
-            attributes: ['id', 'name', 'description', 'public_data', 'status', 'content_type', 'official_status', 'counter_endorsements_up', 'cover_media_type',
-                'counter_endorsements_down', 'group_id', 'language', 'counter_points', 'counter_flags', 'location', 'created_at'],
-            include: [
-                {
-                    // Category
-                    model: models.Category,
-                    required: false,
-                    include: [
-                        {
-                            model: models.Image,
-                            required: false,
-                            as: 'CategoryIconImages'
-                        }
-                    ]
-                },
-                // Group
-                {
-                    model: models.Group,
-                    required: true,
-                    attributes: models.Group.defaultAttributesPublic,
-                    where: {
-                        status: {
-                            $in: ['active', 'featured']
-                        }
-                    },
-                    include: [
-                        {
-                            model: models.Category,
-                            required: false
-                        },
-                        {
-                            model: models.Community,
-                            attributes: ['id', 'name', 'theme_id'],
-                            required: false
-                        }
-                    ]
-                },
-                {
-                    model: models.Video,
-                    required: false,
-                    attributes: ['id', 'formats', 'updated_at', 'viewable', 'public_meta'],
-                    as: 'PostVideos',
-                    include: [
-                        {
-                            model: models.Image,
-                            as: 'VideoImages',
-                            attributes: ["formats", 'updated_at'],
-                            required: false
-                        },
-                    ]
-                },
-                // User
-                {
-                    model: models.User,
-                    required: false,
-                    attributes: models.User.defaultAttributesWithSocialMediaPublic
-                },
-                // Image
-                {
-                    model: models.Image,
-                    required: false,
-                    as: 'PostHeaderImages'
-                },
-                // PointRevision
-                {
-                    model: models.PostRevision,
-                    required: false
-                }
-            ]
-        }).then(function (posts) {
-            res.send(posts);
-        }).catch(function (error) {
-            log.error("Recommendation Error " + levelType, { err: error, id: req.params.id, userId: req.user ? req.user.id : -1, errorStatus: 500 });
-            if (airbrake) {
-                airbrake.notify(error).then((airbrakeErr) => {
-                    if (airbrakeErr.error) {
-                        log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
-                    }
-                    res.send([]);
-                });
-            }
-            else {
-                res.send([]);
-            }
-        });
-    }
-};
-var processRecommendationsLight = function (groupId, req, res, recommendedItemIds, error, redisCacheKey) {
-    if (error) {
-        log.error("processRecommendationsLight Error", { err: error, userId: req.user ? req.user.id : -1, errorStatus: 500 });
-        if (airbrake) {
-            airbrake.notify(error).then((airbrakeErr) => {
-                if (airbrakeErr.error) {
-                    log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
-                }
-                res.send({ recommendations: [], groupId: groupId });
-            });
-        }
-        else {
-            res.send({ recommendations: [], groupId: groupId });
-        }
-    }
-    else if (!recommendedItemIds) {
-        log.error("processRecommendationsLight no recommendedItemIds", { userId: req.user ? req.user.id : -1, errorStatus: 500 });
-        res.send({ recommendations: [], groupId: groupId });
-    }
-    else {
-        log.info("processRecommendationsLight for group status");
-        models.Post.findAll({
-            where: {
-                id: {
-                    $in: recommendedItemIds
-                }
-            },
-            attributes: ['id', 'name', 'description'],
-            include: [
-                {
-                    model: models.Group,
-                    required: true,
-                    attributes: models.Group.defaultAttributesPublic,
-                    where: {
-                        id: groupId
-                    }
-                }
-            ]
-        }).then(function (posts) {
-            posts.sort(function (a, b) {
-                return recommendedItemIds.indexOf(a.id) - recommendedItemIds.indexOf(b.id);
-            });
-            const recommendationsInfo = { recommendations: posts, groupId: groupId };
-            if (redisCacheKey) {
-                req.redisClient.setEx(redisCacheKey, process.env.RECOMMENDATIONS_CACHE_TTL ? parseInt(process.env.RECOMMENDATIONS_CACHE_TTL) : 5, JSON.stringify(recommendationsInfo));
-            }
-            res.send(recommendationsInfo);
-        }).catch(function (error) {
-            log.error("processRecommendationsLight Error ", { err: error, userId: req.user ? req.user.id : -1, errorStatus: 500 });
-            if (airbrake) {
-                airbrake.notify(error).then((airbrakeErr) => {
-                    if (airbrakeErr.error) {
-                        log.error("AirBrake Error", { context: 'airbrake', err: airbrakeErr.error, errorStatus: 500 });
-                    }
-                    res.send({ recommendations: [], groupId: groupId });
-                });
-            }
-            else {
-                res.send({ recommendations: [], groupId: groupId });
-            }
-        });
-    }
-};
-router.get('/domains/:id', auth.can('view domain'), function (req, res) {
-    var options = setupOptions(req);
-    options = _.merge(options, {
-        domain_id: req.params.id,
-        limit: OVERALL_LIMIT * 2
-    });
-    getRecommendationFor(req, options.user_id, DATE_OPTIONS, options, function (error, recommendedItemIds) {
-        processRecommendations("domain", req, res, recommendedItemIds, error);
-    }, req.user ? req.user.default_locale : null);
-});
-router.get('/communities/:id', auth.can('view community'), function (req, res) {
-    var options = setupOptions(req);
-    options = _.merge(options, {
-        community_id: req.params.id,
-        limit: OVERALL_LIMIT * 2
-    }, req.user ? req.user.default_locale : null);
-    getRecommendationFor(req, options.user_id, DATE_OPTIONS, options, function (error, recommendedItemIds) {
-        processRecommendations("community", req, res, recommendedItemIds, error);
-    }, req.user ? req.user.default_locale : null);
-});
-router.get('/groups/:id', auth.can('view group'), function (req, res) {
-    var options = setupOptions(req);
-    options = _.merge(options, {
-        group_id: req.params.id,
-        limit: OVERALL_LIMIT * 2
-    });
-    getRecommendationFor(req, options.user_id, DATE_OPTIONS, options, function (error, recommendedItemIds) {
-        processRecommendations("group", req, res, recommendedItemIds, error);
-    }, req.user ? req.user.default_locale : null);
-});
-router.put('/groups/:id/getPostRecommendations', auth.can('view group'), function (req, res) {
-    const redisCacheKey = "cache:getPostRecommendations:" + req.params.id + ":userId:" + (req.user ? req.user.id : "notLoggedIn");
-    req.redisClient.get(redisCacheKey).then(recommendations => {
-        if (recommendations) {
-            res.send(JSON.parse(recommendations));
-        }
-        else {
-            var options = setupOptions(req);
-            options = _.merge(options, {
-                group_id: req.params.id,
-                limit: 100
-            });
-            models.Group.findOne({
-                where: {
-                    id: req.params.id
-                },
-                attributes: [
-                    'id', 'configuration'
-                ]
-            }).then(group => {
-                if (group) {
-                    var dateOptions = null; //DATE_OPTIONS_YEAR;
-                    if (group.configuration && group.configuration.maxDaysBackForRecommendations && group.configuration.maxDaysBackForRecommendations) {
-                        var maxDays = parseInt(group.configuration.maxDaysBackForRecommendations);
-                        dateOptions = { name: "date", after: moment().add(-Math.abs(maxDays), 'days').toISOString() };
-                    }
-                    getRecommendationFor(req, options.user_id, dateOptions, options, function (error, recommendedItemIds) {
-                        if (!error) {
-                            processRecommendationsLight(req.params.id, req, res, recommendedItemIds, error, redisCacheKey);
-                        }
-                        else {
-                            log.error("Error from getRecommendationFor", { error });
-                            res.send({ recommendations: [], groupId: req.params.id });
-                        }
-                    }, req.user ? req.user.default_locale : null);
-                }
-                else {
-                    log.error("Group not found");
-                    res.send({ recommendations: [], groupId: req.params.id });
-                }
-            }).catch(error => {
-                log.error(error);
-                res.send({ recommendations: [], groupId: req.params.id });
-            });
-        }
-    }).catch(error => {
-        log.error(error);
-        res.send({ recommendations: [], groupId: req.params.id });
-    });
-});
-module.exports = router;

package/dist/active-citizen/engine/allOurIdeas/aiHelper.js

@@ -1,204 +0,0 @@
-import { OpenAI } from "openai";
-export class AiHelper {
-    constructor(wsClientSocket = undefined) {
-        this.modelName = "gpt-4o";
-        this.maxTokens = 2048;
-        this.temperature = 0.7;
-        this.cacheExpireTime = 60 * 60;
-        this.moderationSystemPrompt = (instructions) => `The user will provide you with a question and an answer.
-Your job is to moderate the answer if it passes automated moderation or not.
-Moderation instructions:
-${instructions}
-
-Only output: PASSES or FAILS`;
-        this.moderationUserPrompt = (question, answer) => `
-  Question: ${question}
-  Answer: ${answer}
-  `;
-        this.getModerationResponse = async (instructions, question, answerToModerate) => {
-            const messages = [
-                {
-                    role: "system",
-                    content: this.moderationSystemPrompt(instructions),
-                },
-                {
-                    role: "user",
-                    content: this.moderationUserPrompt(question, answerToModerate),
-                },
-            ];
-            console.log(JSON.stringify(messages, null, 2));
-            const response = await this.openaiClient.chat.completions.create({
-                model: this.modelName,
-                messages,
-                max_tokens: 5,
-                temperature: 0,
-            });
-            if (response &&
-                response.choices &&
-                response.choices[0] &&
-                response.choices[0].message &&
-                response.choices[0].message.content) {
-                console.log("Moderation response:", response.choices[0].message.content);
-                return ["PASSES", "PASS"].includes(response.choices[0].message.content.toUpperCase())
-                    ? true
-                    : false;
-            }
-            else {
-                return false;
-            }
-        };
-        this.openaiClient = new OpenAI({
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-        this.wsClientSocket = wsClientSocket;
-    }
-    async streamChatCompletions(messages) {
-        const stream = await this.openaiClient.chat.completions.create({
-            model: this.modelName,
-            messages,
-            max_tokens: this.maxTokens,
-            temperature: this.temperature,
-            stream: true,
-        });
-        await this.streamWebSocketResponses(stream);
-    }
-    sendToClient(sender, message, type = "stream") {
-        this.wsClientSocket?.send(JSON.stringify({
-            sender,
-            type: type,
-            message,
-        }));
-    }
-    async streamWebSocketResponses(stream) {
-        return new Promise(async (resolve, reject) => {
-            this.sendToClient("bot", "", "start");
-            try {
-                let botMessage = "";
-                for await (const part of stream) {
-                    this.sendToClient("bot", part.choices[0].delta.content);
-                    botMessage += part.choices[0].delta.content;
-                }
-                if (this.redisClient && this.cacheKeyForFullResponse) {
-                    this.redisClient.set(this.cacheKeyForFullResponse, botMessage, "EX", this.cacheExpireTime);
-                }
-            }
-            catch (error) {
-                console.error(error);
-                this.sendToClient("bot", "There has been an error, please retry", "error");
-                reject();
-            }
-            finally {
-                this.sendToClient("bot", "", "end");
-            }
-            resolve();
-        });
-    }
-    async getAnswerIdeas(question, previousIdeas, firstMessage) {
-        try {
-            const moderationResponse = await this.openaiClient.moderations.create({
-                input: question,
-            });
-            console.log("Moderation response:", moderationResponse);
-            const flagged = moderationResponse.results[0].flagged;
-            console.log("Flagged:", flagged);
-            if (flagged) {
-                console.error("Flagged:", question);
-                return null;
-            }
-            else {
-                let firstMessageWithPreviousIdeasTemplate = "";
-                let previewIdeasText = "";
-                if (previousIdeas && previousIdeas.length > 0) {
-                    previewIdeasText = `Previous answer ideas:\n${JSON.stringify(previousIdeas, null, 2)}\n\n`;
-                    if (firstMessage) {
-                        firstMessageWithPreviousIdeasTemplate =
-                            "For your answers please follow the tone of voice, prose, style, and length of the Previous answer ideas\n";
-                    }
-                }
-                const messages = [
-                    {
-                        role: "system",
-                        content: `You are a highly competent AI that is able to generate clear answer ideas for questions.
-                      Genereate up to 10 high quality answer ideas.
-                      Never use numbers at the start of each line.
-                      Always output the ideas in the same language the user is asking the question.
-                      Never use a dash or quote or anything similar at the start of each line, just start with the text.
-                      Never output more than 30 words per idea.
-                      \n${firstMessageWithPreviousIdeasTemplate}`,
-                    },
-                    {
-                        role: "user",
-                        content: `What are some possible answers to the question: ${question}\n\n${previewIdeasText}Answers:\n`,
-                    },
-                ];
-                await this.streamChatCompletions(messages);
-            }
-        }
-        catch (error) {
-            console.error("Error in getAnswerIdeas:", error);
-            this.sendToClient("bot", "There has been an error, please retry", "error");
-            return null;
-        }
-    }
-    async getAiAnalysis(questionId, contextPrompt, answers, cacheKeyForFullResponse, redisClient, locale, topOrBottomIdeasText, typeOfAnalysisText) {
-        this.redisClient = redisClient;
-        this.cacheKeyForFullResponse = cacheKeyForFullResponse;
-        const basePrePrompt = `You are a highly competent text and ideas analysis AI.
-        Instructions:
-        If an answer sounds implausible as an answer to the question, then include a short observation about it in your analysis.
-        Keep your output short, under 300 words.
-        The answers have been rated by the public using a pairwise voting method, so the user is always selecting one to win or one to lose.
-        Generally, do not include the number of wins and losses in your answers.
-        If there are very few wins or losses, under 10 for most of the ideas, then always output a disclaimer to that end, in a separate second paragraph.
-        Don't output Idea 1, Idea 2 in your answer.
-        Be creative and think step by step.
-
-        Output:
-        If the prompt asks for a table always output a markdown table.
-        Always output in a clear markdown format.
-        Always start with the type of analysis and if those are top or bottom ideas.
-
-        Example output:
-
-        ## Points for the most popular answers
-
-        <Your dynamic markdown output>
-
-
-    `;
-        const answersText = answers
-            .map((answer) => `${answer.data.content} (Won: ${answer.wins}, Lost: ${answer.losses})`)
-            .join("\n");
-        try {
-            const moderationResponse = await this.openaiClient.moderations.create({
-                input: answersText,
-            });
-            const flagged = moderationResponse.results[0].flagged;
-            if (flagged) {
-                console.error("Flagged:", answersText);
-                return;
-            }
-            else {
-                const messages = [
-                    {
-                        role: "system",
-                        content: `${basePrePrompt}\n${contextPrompt}`,
-                    },
-                    {
-                        role: "user",
-                        content: `The question: ${questionId}
-              ${topOrBottomIdeasText}
-              Type of analysis: ${typeOfAnalysisText}
-              Language to output: ${locale}
-              Answers to analyse:\n${answersText}`,
-                    },
-                ];
-                this.streamChatCompletions(messages);
-            }
-        }
-        catch (error) {
-            console.error("Error in getAiAnalysis:", error);
-            this.sendToClient("bot", "There has been an error, please retry", "error");
-        }
-    }
-}

package/dist/active-citizen/engine/allOurIdeas/explainAnswersAssistant.js

@@ -1,66 +0,0 @@
-import { OpenAI } from "openai";
-import { YpBaseChatBot } from "../../llms/baseChatBot.js";
-import ioredis from "ioredis";
-import { v4 as uuidv4 } from "uuid";
-const tlsOptions = process.env.REDIS_MEMORY_URL?.startsWith("rediss://")
-    ? { rejectUnauthorized: false }
-    : undefined;
-export class ExplainAnswersAssistant extends YpBaseChatBot {
-    constructor(wsClientId, wsClients, languageName) {
-        const redisConnection = new ioredis.default(process.env.REDIS_MEMORY_URL ||
-            process.env.REDIS_URL ||
-            "redis://localhost:6379", {
-            tls: tlsOptions,
-        });
-        super(wsClientId, wsClients, redisConnection, `${YpBaseChatBot.redisMemoryKeyPrefix}-${uuidv4()}-explain-answers-assistant`);
-        this.modelName = "gpt-4o";
-        this.maxTokens = 4000;
-        this.temperature = 0.8;
-        this.explainConversation = async (chatLog) => {
-            this.setChatLog(chatLog);
-            let messages = chatLog.map((message) => {
-                return {
-                    role: message.sender,
-                    content: message.message,
-                };
-            });
-            const systemMessage = {
-                role: "system",
-                content: this.renderSystemPrompt(),
-            };
-            messages.unshift(systemMessage);
-            const stream = await this.openaiClient.chat.completions.create({
-                model: this.llmModel,
-                messages,
-                max_tokens: this.maxTokens,
-                temperature: this.temperature,
-                stream: true,
-            });
-            this.streamWebSocketResponses(stream);
-        };
-        this.languageName = languageName;
-        this.openaiClient = new OpenAI({
-            apiKey: process.env.OPENAI_API_KEY,
-        });
-    }
-    renderSystemPrompt() {
-        return `The user is doing pairwise voting on two answers at the time, to a question, the user needs help deciding what to vote on.
-
-Instructions:
-Use a relevant emoji for the first and second answers.
-Use thumbs emojis for pros and thumb down emjoi for cons
-Use summary emoji for summary.
-Use simple and upbeat language.
-Ask the user clarifying questions if needed.
-Always answers in the language the user asks for.
-
-Output:
-* Each answer
--- One short paragraph, max three sentences, explanation in a very simple language
--- The top pro and con
--- If this is likely to be a root cause of the problem set out in the question
-* Never offer the user your opinion as we don't want to influence the user, they must make their own decision.
-* Always output in this language: ${this.languageName}
-`;
-    }
-}

package/dist/active-citizen/engine/allOurIdeas/iconGenerator.js

@@ -1,38 +0,0 @@
-import path from "path";
-import fs from "fs";
-import { v4 as uuidv4 } from "uuid";
-import axios from "axios";
-import models from "../../../models/index.cjs";
-import { CollectionImageGenerator } from "../../llms/imageGeneration/collectionImageGenerator.js";
-const dbModels = models;
-const Image = dbModels.Image;
-export class AoiIconGenerator extends CollectionImageGenerator {
-    async createCollectionImage(workPackage) {
-        // 1. Generate the image and record using the base implementation.
-        const { imageId, imageUrl } = await super.createCollectionImage(workPackage);
-        // 2. Now process the image for the icon:
-        // Download the generated image to a temporary location.
-        const tempIconPath = path.join("/tmp", `${uuidv4()}-icon.png`);
-        await this.imageProcessorService.downloadImage(imageUrl, tempIconPath, axios);
-        if (!fs.existsSync(tempIconPath)) {
-            throw new Error("Failed to download the generated image for icon processing.");
-        }
-        // Resize the downloaded image to 400x400 pixels.
-        const resizedIconPath = await this.imageProcessorService.resizeImage(tempIconPath, 400, 400);
-        // Define a new S3 path for the icon image.
-        const iconS3ImagePath = `ypGenAi/${workPackage.collectionType}/${workPackage.collectionId}/${uuidv4()}-icon.png`;
-        // Upload the resized icon to S3.
-        await this.s3Service.uploadImageToS3(process.env.S3_BUCKET, resizedIconPath, iconS3ImagePath);
-        // Construct a public URL for the icon image.
-        const newIconUrl = process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN
-            ? `https://${process.env.CLOUDFLARE_IMAGE_PROXY_DOMAIN}/${iconS3ImagePath}`
-            : `https://${process.env.S3_BUCKET}.s3.amazonaws.com/${iconS3ImagePath}`;
-        // Optionally, update the DB record with the new icon URL.
-        const imageRecord = await Image.findOne({ where: { id: imageId } });
-        if (imageRecord) {
-            imageRecord.formats = JSON.stringify([newIconUrl]);
-            await imageRecord.save();
-        }
-        return { imageId, imageUrl: newIconUrl };
-    }
-}