strapi-llm-translator 0.9.0

package/dist/server/index.mjs

@@ -0,0 +1,393 @@
+import { OpenAI } from "openai";
+const bootstrap = ({ strapi: strapi2 }) => {
+};
+const destroy = ({ strapi: strapi2 }) => {
+};
+const register = ({ strapi: strapi2 }) => {
+};
+const config = {
+  default: {
+    llmApiKey: process.env.LLM_TRANSLATOR_LLM_API_KEY,
+    llmEndpoint: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL || "https://api.openai.com/v1/chat/completions",
+    llmModel: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL || "gpt-4o"
+  },
+  validator() {
+    const {
+      LLM_TRANSLATOR_LLM_API_KEY,
+      STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL,
+      STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL
+    } = process.env;
+    if (!LLM_TRANSLATOR_LLM_API_KEY) {
+      throw new Error("LLM_TRANSLATOR_LLM_API_KEY is required");
+    }
+    if (!STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL) {
+      console.info(
+        "STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL is not set, using default: https://api.openai.com/v1/chat/completions"
+      );
+    } else {
+      console.info(
+        `STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL is set to: ${STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL}`
+      );
+    }
+    if (!STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL) {
+      console.info("STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL is not set, using default: gpt-4o");
+    } else {
+      console.info(
+        `STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL is set to: ${STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL}`
+      );
+    }
+  }
+};
+const contentTypes = {};
+const controllers$1 = ({ strapi: strapi2 }) => ({
+  // Genertate translations
+  async generate(ctx) {
+    try {
+      const { fields, components, targetLanguage, contentType } = ctx.request.body;
+      const result = await strapi2.plugin("strapi-llm-translator").service("llm-service").generateWithLLM(contentType, fields, components, {
+        targetLanguage
+      });
+      ctx.status = result.meta.status;
+      ctx.body = result;
+    } catch (error) {
+      console.error("Error in generate controller:", error);
+      ctx.status = 500;
+      ctx.body = {
+        meta: {
+          ok: false,
+          status: 500,
+          message: "Internal server error"
+        }
+      };
+    }
+  },
+  // Get the configuration
+  async getConfig(ctx) {
+    const pluginStore = strapi2.store({
+      environment: strapi2.config.environment,
+      type: "plugin",
+      name: "strapi-llm-translator"
+      // replace with your plugin name
+    });
+    const config2 = await pluginStore.get({ key: "configuration" });
+    ctx.body = config2 || {};
+  },
+  // Save the configuration
+  async setConfig(ctx) {
+    const { body } = ctx.request;
+    const pluginStore = strapi2.store({
+      environment: strapi2.config.environment,
+      type: "plugin",
+      name: "strapi-llm-translator"
+      // replace with your plugin name
+    });
+    await pluginStore.set({
+      key: "configuration",
+      value: { ...body }
+    });
+    ctx.body = await pluginStore.get({ key: "configuration" });
+  }
+});
+const controllers = {
+  admin: controllers$1
+};
+const middlewares = {};
+const policies = {};
+const adminRoutes = [
+  {
+    method: "POST",
+    path: "/generate",
+    handler: "admin.generate",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "GET",
+    path: "/config",
+    handler: "admin.getConfig",
+    config: {
+      policies: []
+    }
+  },
+  {
+    method: "POST",
+    path: "/config",
+    handler: "admin.setConfig",
+    config: {
+      policies: []
+    }
+  }
+];
+const routes = {
+  admin: {
+    type: "admin",
+    routes: adminRoutes
+  }
+};
+const DEFAULT_SYSTEM_PROMPT = "You are a professional translator. Your task is to translate the provided content accurately while preserving the original meaning and tone.";
+const SYSTEM_PROMPT_APPENDIX = `The user asks you to translate the text to a specific language, the language is provided via short code like "en", "fr", "de", etc.`;
+const openai = new OpenAI({
+  baseURL: process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_BASE_URL,
+  apiKey: process.env.LLM_TRANSLATOR_LLM_API_KEY
+});
+const model = process.env.STRAPI_ADMIN_LLM_TRANSLATOR_LLM_MODEL;
+const isTranslatableField = (contentType, key, value) => {
+  if (typeof value !== "string") {
+    return false;
+  }
+  const fieldSchema = contentType?.attributes?.[key];
+  if (!fieldSchema) {
+    return false;
+  }
+  const isStringOrText = ["string", "text"].includes(fieldSchema.type);
+  const isNotUID = fieldSchema.type !== "uid";
+  const isLocalizable = fieldSchema.pluginOptions?.i18n?.localized !== false;
+  return isStringOrText && isNotUID && isLocalizable;
+};
+const extractTranslatableFields = (contentType, fields, components = {}) => {
+  const translatableFields = [];
+  Object.entries(fields).forEach(([key, value]) => {
+    if (isTranslatableField(contentType, key, value)) {
+      translatableFields.push({
+        path: [key],
+        value,
+        originalPath: [key]
+      });
+    }
+  });
+  if (fields.blocks && Array.isArray(fields.blocks)) {
+    fields.blocks.forEach((block, blockIndex) => {
+      if (block.__component && components[block.__component]) {
+        const componentSchema = components[block.__component];
+        Object.entries(componentSchema.attributes).forEach(([fieldName, schema]) => {
+          if (block[fieldName] && typeof block[fieldName] === "string" && ["string", "text", "richtext"].includes(schema.type)) {
+            translatableFields.push({
+              path: ["blocks", String(blockIndex), fieldName],
+              value: block[fieldName],
+              originalPath: ["blocks", String(blockIndex), fieldName]
+            });
+          }
+        });
+      }
+    });
+  }
+  return translatableFields;
+};
+const prepareTranslationPayload = (fields) => {
+  const payload = {};
+  fields.forEach((field) => {
+    let current = payload;
+    field.path.forEach((part, index2) => {
+      if (index2 === field.path.length - 1) {
+        current[part] = field.value;
+      } else {
+        current[part] = current[part] || {};
+        current = current[part];
+      }
+    });
+  });
+  return payload;
+};
+const mergeTranslatedContent = (originalData, translatedData, translatableFields) => {
+  const result = JSON.parse(JSON.stringify(originalData));
+  translatableFields.forEach((field) => {
+    let translatedValue = translatedData;
+    for (const part of field.path) {
+      translatedValue = translatedValue?.[part];
+      if (translatedValue === void 0) break;
+    }
+    if (translatedValue !== void 0) {
+      let current = result;
+      field.originalPath.forEach((part, index2) => {
+        if (index2 === field.originalPath.length - 1) {
+          current[part] = translatedValue;
+        } else {
+          current = current[part];
+        }
+      });
+    }
+  });
+  return result;
+};
+const generateSlug = async (data, field, contentTypeUID) => {
+  const uidService = strapi.service("plugin::content-manager.uid");
+  const slug = await uidService.generateUIDField({
+    contentTypeUID,
+    field,
+    data
+  });
+  return slug;
+};
+const findUIDFields = (contentType) => {
+  const uidFields = [];
+  Object.entries(contentType.attributes || {}).forEach(([fieldName, schema]) => {
+    if (schema.type === "uid" && schema.targetField) {
+      uidFields.push({
+        fieldName,
+        targetField: schema.targetField
+      });
+    }
+  });
+  return uidFields;
+};
+const generateUIDsForTranslatedFields = async (uidFields, translatedData, contentTypeUID, mergedContent) => {
+  const translatedUIDs = {};
+  for (const { fieldName, targetField } of uidFields) {
+    if (translatedData[targetField] !== void 0) {
+      try {
+        const newUID = await generateSlug(
+          {
+            ...mergedContent,
+            [targetField]: translatedData[targetField]
+          },
+          fieldName,
+          contentTypeUID
+        );
+        translatedUIDs[fieldName] = newUID;
+      } catch (error) {
+        console.error(`Failed to generate UID for field ${fieldName}:`, error);
+      }
+    }
+  }
+  return translatedUIDs;
+};
+const llmService = ({ strapi: strapi2 }) => ({
+  async generateWithLLM(contentType, fields, components, config2) {
+    try {
+      const userConfig = await getUserConfig();
+      const translatableFields = extractTranslatableFields(contentType, fields, components);
+      const translationPayload = prepareTranslationPayload(translatableFields);
+      const prompt = buildPrompt(translationPayload, config2.targetLanguage);
+      const systemPrompt = await buildSystemPrompt(userConfig);
+      const response = await callLLMProvider(prompt, systemPrompt, model, userConfig);
+      const translatedData = parseLLMResponse(response);
+      const mergedContent = mergeTranslatedContent(fields, translatedData, translatableFields);
+      const uidFields = findUIDFields(contentType);
+      const translatedUIDs = await generateUIDsForTranslatedFields(
+        uidFields,
+        translatedData,
+        contentType.uid,
+        mergedContent
+      );
+      return {
+        data: {
+          ...mergedContent,
+          ...translatedUIDs
+        },
+        meta: {
+          ok: true,
+          status: 200,
+          message: "Translation completed successfully"
+        }
+      };
+    } catch (error) {
+      strapi2.log.error("LLM translation error:", error);
+      return {
+        data: fields,
+        // Return original fields in case of error
+        meta: {
+          ok: false,
+          status: 500,
+          message: error instanceof Error ? error.message : "Translation failed"
+        }
+      };
+    }
+  }
+});
+const buildPrompt = (fields, targetLanguage) => {
+  return `You are translating content from a CMS. Please translate the following JSON data to ${targetLanguage}.
+
+IMPORTANT RULES:
+1. Preserve all JSON structure and keys exactly as provided
+2. Only translate string values
+3. Maintain any markdown formatting within the text
+4. Keep HTML tags intact if present
+5. Preserve any special characters or placeholders
+6. Return ONLY the translated JSON object
+7. Do not add any explanations or comments
+8. Ensure professional and culturally appropriate translations
+
+SOURCE JSON:
+${JSON.stringify(fields, null, 2)}`;
+};
+const getUserConfig = async () => {
+  const pluginStore = strapi.store({
+    environment: strapi.config.environment,
+    type: "plugin",
+    name: "strapi-llm-translator"
+  });
+  const config2 = await pluginStore.get({ key: "configuration" });
+  return config2;
+};
+const buildSystemPrompt = async (config2) => {
+  return `${config2.systemPrompt || DEFAULT_SYSTEM_PROMPT} ${SYSTEM_PROMPT_APPENDIX}`;
+};
+const callLLMProvider = async (prompt, systemPrompt, model2, config2) => {
+  const response = await openai.chat.completions.create({
+    model: model2,
+    messages: [
+      {
+        role: "system",
+        content: systemPrompt
+      },
+      {
+        role: "user",
+        content: prompt
+      }
+    ],
+    temperature: config2.temperature
+  });
+  return response;
+};
+const parseLLMResponse = (response) => {
+  try {
+    const content = response.choices[0]?.message?.content;
+    if (!content) throw new Error("No content in response");
+    const cleanContent = content.replace(/^```json\s*\n/, "").replace(/^```\s*\n/, "").replace(/\n\s*```$/, "").replace(/\u200B/g, "").replace(/[\u2018\u2019]/g, "'").replace(/[\u201C\u201D]/g, '"').trim();
+    try {
+      const parsed = JSON.parse(cleanContent);
+      if (typeof parsed === "object" && parsed !== null) {
+        return parsed;
+      }
+      throw new Error("Invalid response format - not an object");
+    } catch (parseError) {
+      const openBraces = (cleanContent.match(/{/g) || []).length;
+      const closeBraces = (cleanContent.match(/}/g) || []).length;
+      if (openBraces > closeBraces) {
+        const missingBraces = openBraces - closeBraces;
+        const fixedContent = cleanContent + "}".repeat(missingBraces);
+        try {
+          const parsed = JSON.parse(fixedContent);
+          if (typeof parsed === "object" && parsed !== null) {
+            return parsed;
+          }
+        } catch (secondError) {
+          console.error("Second parse attempt failed:", secondError);
+        }
+      }
+      throw new Error(`JSON parsing failed: ${parseError.message}`);
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    throw new Error(`Translation failed: ${errorMessage}`);
+  }
+};
+const services = {
+  "llm-service": llmService
+};
+const index = {
+  register,
+  bootstrap,
+  destroy,
+  config,
+  controllers,
+  routes,
+  services,
+  contentTypes,
+  policies,
+  middlewares
+};
+export {
+  index as default
+};

package/dist/server/src/bootstrap.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const bootstrap: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default bootstrap;

package/dist/server/src/config/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const DEFAULT_SYSTEM_PROMPT = "You are a professional translator. Your task is to translate the provided content accurately while preserving the original meaning and tone.";
+export declare const SYSTEM_PROMPT_APPENDIX = "The user asks you to translate the text to a specific language, the language is provided via short code like \"en\", \"fr\", \"de\", etc.";

package/dist/server/src/config/index.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    default: {
+        llmApiKey: string;
+        llmEndpoint: string;
+        llmModel: string;
+    };
+    validator(): void;
+};
+export default _default;

package/dist/server/src/content-types/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/controllers/admin.controller.d.ts

@@ -0,0 +1,11 @@
+import { RequestContext, StrapiContext, GenerateRequestBody } from 'src/types';
+declare const controllers: ({ strapi }: StrapiContext) => {
+    generate(ctx: RequestContext & {
+        request: {
+            body: GenerateRequestBody;
+        };
+    }): Promise<void>;
+    getConfig(ctx: RequestContext): Promise<void>;
+    setConfig(ctx: RequestContext): Promise<void>;
+};
+export default controllers;

package/dist/server/src/controllers/index.d.ts

@@ -0,0 +1,23 @@
+/// <reference types="koa" />
+declare const _default: {
+    admin: ({ strapi }: import("../types").StrapiContext) => {
+        generate(ctx: Omit<import("koa").Context, "body" | "query" | "request"> & {
+            body: object;
+            query: object;
+            params: object;
+            request: Omit<import("koa").Request, "body"> & {
+                body: object;
+            };
+            state: {
+                user?: import("../types").AdminUser;
+            };
+        } & {
+            request: {
+                body: import("../types").GenerateRequestBody;
+            };
+        }): Promise<void>;
+        getConfig(ctx: import("../types").RequestContext): Promise<void>;
+        setConfig(ctx: import("../types").RequestContext): Promise<void>;
+    };
+};
+export default _default;

package/dist/server/src/destroy.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const destroy: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default destroy;

package/dist/server/src/index.d.ts

@@ -0,0 +1,63 @@
+/// <reference types="koa" />
+declare const _default: {
+    register: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    bootstrap: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    destroy: ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => void;
+    config: {
+        default: {
+            llmApiKey: string;
+            llmEndpoint: string;
+            llmModel: string;
+        };
+        validator(): void;
+    };
+    controllers: {
+        admin: ({ strapi }: import("./types").StrapiContext) => {
+            generate(ctx: Omit<import("koa").Context, "body" | "query" | "request"> & {
+                body: object;
+                query: object;
+                params: object;
+                request: Omit<import("koa").Request, "body"> & {
+                    body: object;
+                };
+                state: {
+                    user?: import("./types").AdminUser;
+                };
+            } & {
+                request: {
+                    body: import("./types").GenerateRequestBody;
+                };
+            }): Promise<void>;
+            getConfig(ctx: import("./types").RequestContext): Promise<void>;
+            setConfig(ctx: import("./types").RequestContext): Promise<void>;
+        };
+    };
+    routes: {
+        admin: {
+            type: string;
+            routes: {
+                method: string;
+                path: string;
+                handler: string;
+                config: {
+                    policies: any[];
+                };
+            }[];
+        };
+    };
+    services: {
+        'llm-service': ({ strapi }: {
+            strapi: import("@strapi/types/dist/core").Strapi;
+        }) => import("./types").LLMServiceType;
+    };
+    contentTypes: {};
+    policies: {};
+    middlewares: {};
+};
+export default _default;

package/dist/server/src/middlewares/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/policies/index.d.ts

@@ -0,0 +1,2 @@
+declare const _default: {};
+export default _default;

package/dist/server/src/register.d.ts

@@ -0,0 +1,5 @@
+import type { Core } from '@strapi/strapi';
+declare const register: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => void;
+export default register;

package/dist/server/src/routes/admin.d.ts

@@ -0,0 +1,9 @@
+declare const _default: {
+    method: string;
+    path: string;
+    handler: string;
+    config: {
+        policies: any[];
+    };
+}[];
+export default _default;

package/dist/server/src/routes/index.d.ts

@@ -0,0 +1,14 @@
+declare const routes: {
+    admin: {
+        type: string;
+        routes: {
+            method: string;
+            path: string;
+            handler: string;
+            config: {
+                policies: any[];
+            };
+        }[];
+    };
+};
+export default routes;

package/dist/server/src/services/index.d.ts

@@ -0,0 +1,6 @@
+declare const _default: {
+    'llm-service': ({ strapi }: {
+        strapi: import("@strapi/types/dist/core").Strapi;
+    }) => import("../types").LLMServiceType;
+};
+export default _default;

package/dist/server/src/services/llm-service.d.ts

@@ -0,0 +1,6 @@
+import type { Core } from '@strapi/strapi';
+import { LLMServiceType } from '../../src/types';
+declare const llmService: ({ strapi }: {
+    strapi: Core.Strapi;
+}) => LLMServiceType;
+export default llmService;

package/dist/server/src/types/controllers.d.ts

@@ -0,0 +1,22 @@
+import { Context } from 'koa';
+export type AdminUser = {
+    id: string | number;
+    email: string;
+    username: string;
+    avatar?: string;
+};
+export type RequestContext<Body = object, PathParams = object, QueryParams = object> = Omit<Context, 'body' | 'query' | 'request'> & {
+    body: Body;
+    query: QueryParams;
+    params: PathParams;
+    request: Omit<Context['request'], 'body'> & {
+        body: Body;
+    };
+    state: {
+        user?: AdminUser;
+    };
+};
+export interface PluginConfig {
+    systemPrompt: string;
+    temperature: number;
+}

package/dist/server/src/types/index.d.ts

@@ -0,0 +1,41 @@
+import type { Core } from '@strapi/strapi';
+export * from './controllers';
+export type CoreStrapi = Omit<Core.Strapi, 'query' | 'plugin'> & {
+    plugin: (pluginName: string) => Omit<Core.Plugin, 'contentTypes'> & {
+        contentTypes: Record<string, Core.Plugin['contentTypes'][string] & {
+            uid: string;
+        }>;
+    };
+};
+export type StrapiContext = {
+    readonly strapi: CoreStrapi;
+};
+export interface TranslationResponse {
+    data: Record<string, any>;
+    meta: {
+        ok: boolean;
+        status: number;
+        message?: string;
+    };
+}
+export interface TranslationConfig {
+    targetLanguage: string;
+}
+export interface LLMServiceType {
+    generateWithLLM(contentType: Record<string, any>, fields: Record<string, any>, components: Record<string, any>, config: TranslationConfig): Promise<Record<string, any>>;
+}
+export interface GenerateRequestBody {
+    contentType: string;
+    fields: any;
+    components: any;
+    targetLanguage: string;
+}
+export interface TranslatableField {
+    path: string[];
+    value: string;
+    originalPath: string[];
+}
+export interface UIDField {
+    fieldName: string;
+    targetField: string;
+}