fix(web): remove redundant prop-types and unblock lint pipeline

apps/web/src/payload/actions/generateField.ts

@@ -0,0 +1,191 @@
+"use server";
+
+import { config } from "../../../content-engine.config";
+import { getPayloadHMR } from "@payloadcms/next/utilities";
+import configPromise from "@payload-config";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import * as os from "node:os";
+
+async function getOrchestrator() {
+  const OPENROUTER_KEY =
+    process.env.OPENROUTER_KEY || process.env.OPENROUTER_API_KEY;
+  const REPLICATE_KEY = process.env.REPLICATE_API_KEY;
+
+  if (!OPENROUTER_KEY) {
+    throw new Error(
+      "Missing OPENROUTER_API_KEY in .env (Required for AI generation)",
+    );
+  }
+
+  const importDynamic = new Function("modulePath", "return import(modulePath)");
+  const { AiBlogPostOrchestrator } = await importDynamic(
+    "@mintel/content-engine",
+  );
+
+  return new AiBlogPostOrchestrator({
+    apiKey: OPENROUTER_KEY,
+    replicateApiKey: REPLICATE_KEY,
+    model: "google/gemini-3-flash-preview",
+  });
+}
+
+export async function generateSlugAction(
+  title: string,
+  draftContent: string,
+  oldSlug?: string,
+  instructions?: string,
+) {
+  try {
+    const orchestrator = await getOrchestrator();
+    const newSlug = await orchestrator.generateSlug(
+      draftContent,
+      title,
+      instructions,
+    );
+
+    if (oldSlug && oldSlug !== newSlug) {
+      const payload = await getPayloadHMR({ config: configPromise });
+      await payload.create({
+        collection: "redirects",
+        data: {
+          from: oldSlug,
+          to: newSlug,
+        },
+      });
+    }
+
+    return { success: true, slug: newSlug };
+  } catch (e: any) {
+    return { success: false, error: e.message };
+  }
+}
+
+export async function generateThumbnailAction(
+  draftContent: string,
+  title?: string,
+  instructions?: string,
+) {
+  try {
+    const payload = await getPayloadHMR({ config: configPromise });
+    const OPENROUTER_KEY =
+      process.env.OPENROUTER_KEY || process.env.OPENROUTER_API_KEY;
+    const REPLICATE_KEY = process.env.REPLICATE_API_KEY;
+
+    if (!OPENROUTER_KEY) {
+      throw new Error("Missing OPENROUTER_API_KEY in .env");
+    }
+    if (!REPLICATE_KEY) {
+      throw new Error(
+        "Missing REPLICATE_API_KEY in .env (Required for Thumbnails)",
+      );
+    }
+
+    const importDynamic = new Function(
+      "modulePath",
+      "return import(modulePath)",
+    );
+    const { AiBlogPostOrchestrator } = await importDynamic(
+      "@mintel/content-engine",
+    );
+    const { ThumbnailGenerator } = await importDynamic(
+      "@mintel/thumbnail-generator",
+    );
+
+    const orchestrator = new AiBlogPostOrchestrator({
+      apiKey: OPENROUTER_KEY,
+      replicateApiKey: REPLICATE_KEY,
+      model: "google/gemini-3-flash-preview",
+    });
+
+    const tg = new ThumbnailGenerator({ replicateApiKey: REPLICATE_KEY });
+
+    const prompt = await orchestrator.generateVisualPrompt(
+      draftContent || title || "Technology",
+      instructions,
+    );
+
+    const tmpPath = path.join(os.tmpdir(), `mintel-thumb-${Date.now()}.png`);
+    await tg.generateImage(prompt, tmpPath);
+
+    const fileData = await fs.readFile(tmpPath);
+    const stat = await fs.stat(tmpPath);
+    const fileName = path.basename(tmpPath);
+
+    const newMedia = await payload.create({
+      collection: "media",
+      data: {
+        alt: title ? `Thumbnail for ${title}` : "AI Generated Thumbnail",
+      },
+      file: {
+        data: fileData,
+        name: fileName,
+        mimetype: "image/png",
+        size: stat.size,
+      },
+    });
+
+    // Cleanup temp file
+    await fs.unlink(tmpPath).catch(() => {});
+
+    return { success: true, mediaId: newMedia.id };
+  } catch (e: any) {
+    return { success: false, error: e.message };
+  }
+}
+export async function generateSingleFieldAction(
+  documentTitle: string,
+  documentContent: string,
+  fieldName: string,
+  fieldDescription: string,
+  instructions?: string,
+) {
+  try {
+    const OPENROUTER_KEY =
+      process.env.OPENROUTER_KEY || process.env.OPENROUTER_API_KEY;
+    if (!OPENROUTER_KEY) throw new Error("Missing OPENROUTER_API_KEY");
+
+    const payload = await getPayloadHMR({ config: configPromise });
+
+    // Fetch context documents from DB
+    const contextDocsData = await payload.find({
+      collection: "context-files",
+      limit: 100,
+    });
+    const projectContext = contextDocsData.docs
+      .map((doc) => `--- ${doc.filename} ---\n${doc.content}`)
+      .join("\n\n");
+
+    const prompt = `You are an expert AI assistant perfectly trained for generating exact data values for CMS components.
+PROJECT STRATEGY & CONTEXT:
+${projectContext}
+
+DOCUMENT TITLE: ${documentTitle}
+DOCUMENT DRAFT:\n${documentContent}\n
+YOUR TASK: Generate the exact value for a specific field named "${fieldName}".
+${fieldDescription ? `FIELD DESCRIPTION / CONSTRAINTS: ${fieldDescription}\n` : ""}
+${instructions ? `EDITOR INSTRUCTIONS for this field: ${instructions}\n` : ""}
+CRITICAL RULES:
+1. Respond ONLY with the requested content value. 
+2. NO markdown wrapping blocks (like \`\`\`mermaid or \`\`\`html) around the output! Just the raw code or text.
+3. If the field implies a diagram or flow, output RAW Mermaid.js code. 
+4. If it's standard text, write professional B2B German. No quotes, no conversational filler.`;
+
+    const res = await fetch("https://openrouter.ai/api/v1/chat/completions", {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${OPENROUTER_KEY}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({
+        model: "google/gemini-3-flash-preview",
+        messages: [{ role: "user", content: prompt }],
+      }),
+    });
+    const data = await res.json();
+    const text = data.choices?.[0]?.message?.content?.trim() || "";
+    return { success: true, text };
+  } catch (e: any) {
+    return { success: false, error: e.message };
+  }
+}

apps/web/src/payload/actions/optimizePost.ts

@@ -0,0 +1,88 @@
+"use server";
+
+import { config } from "../../../content-engine.config";
+import { revalidatePath } from "next/cache";
+import { parseMarkdownToLexical } from "../utils/lexicalParser";
+import { getPayloadHMR } from "@payloadcms/next/utilities";
+import configPromise from "@payload-config";
+
+export async function optimizePostText(
+  draftContent: string,
+  instructions?: string,
+) {
+  try {
+    const payload = await getPayloadHMR({ config: configPromise });
+    const globalAiSettings = await payload.findGlobal({ slug: "ai-settings" });
+    const customSources =
+      globalAiSettings?.customSources?.map((s: any) => s.sourceName) || [];
+
+    const OPENROUTER_KEY =
+      process.env.OPENROUTER_KEY || process.env.OPENROUTER_API_KEY;
+    const REPLICATE_KEY = process.env.REPLICATE_API_KEY;
+
+    if (!OPENROUTER_KEY) {
+      throw new Error(
+        "OPENROUTER_KEY or OPENROUTER_API_KEY not found in environment.",
+      );
+    }
+
+    const importDynamic = new Function(
+      "modulePath",
+      "return import(modulePath)",
+    );
+    const { AiBlogPostOrchestrator } = await importDynamic(
+      "@mintel/content-engine",
+    );
+
+    const orchestrator = new AiBlogPostOrchestrator({
+      apiKey: OPENROUTER_KEY,
+      replicateApiKey: REPLICATE_KEY,
+      model: "google/gemini-3-flash-preview",
+    });
+
+    // Fetch context documents purely from DB
+    const contextDocsData = await payload.find({
+      collection: "context-files",
+      limit: 100,
+    });
+    const projectContext = contextDocsData.docs.map((doc) => doc.content);
+
+    const optimizedMarkdown = await orchestrator.optimizeDocument({
+      content: draftContent,
+      projectContext,
+      availableComponents: config.components,
+      instructions,
+      internalLinks: [],
+      customSources,
+    });
+
+    // The orchestrator currently returns Markdown + JSX tags.
+    // We convert this mixed string into a basic Lexical AST map.
+
+    if (!optimizedMarkdown || typeof optimizedMarkdown !== "string") {
+      throw new Error("AI returned invalid markup.");
+    }
+
+    const blocks = parseMarkdownToLexical(optimizedMarkdown);
+
+    return {
+      success: true,
+      lexicalAST: {
+        root: {
+          type: "root",
+          format: "",
+          indent: 0,
+          version: 1,
+          children: blocks,
+          direction: "ltr",
+        },
+      },
+    };
+  } catch (error: any) {
+    console.error("Failed to optimize post:", error);
+    return {
+      success: false,
+      error: error.message || "An unknown error occurred during optimization.",
+    };
+  }
+}