nca-ai-cms-astro-plugin 1.0.11 → 1.0.13

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nca-ai-cms-astro-plugin",
-  "version": "1.0.11",
+  "version": "1.0.13",
   "type": "module",
   "exports": {
     ".": "./src/index.ts",

package/src/api/generate-content.ts

@@ -33,6 +33,7 @@ export const POST: APIRoute = async ({ request }) => {
       filepath: article.filepath,
       tags: article.tags,
       date: article.date.toISOString(),
+      ...(generator.warnings.length > 0 ? { warnings: generator.warnings } : {}),
     });
   } catch (error) {
     console.error('Generation error:', error);

package/src/api/generate-image.ts

@@ -6,6 +6,7 @@ import { jsonResponse, jsonError } from './_utils';
 
 const GenerateImageSchema = z.object({
   input: z.string().min(1, 'Input is required'),
+  category: z.string().optional(),
 });
 
 export const POST: APIRoute = async ({ request }) => {
@@ -15,11 +16,11 @@ export const POST: APIRoute = async ({ request }) => {
     if (!parsed.success) {
       return jsonError(parsed.error.errors[0]?.message ?? 'Invalid request', 400);
     }
-    const { input } = parsed.data;
+    const { input, category } = parsed.data;
 
     const apiKey = getEnvVariable('GOOGLE_GEMINI_API_KEY');
     const generator = new ImageGenerator({ apiKey });
-    const image = await generator.generate(input);
+    const image = await generator.generate(input, category);
 
     return jsonResponse({
       url: image.url,

package/src/components/editor/SettingsTab.tsx

@@ -10,7 +10,7 @@ const SUB_TABS: { key: SettingsSubTab; label: string }[] = [
   { key: 'website', label: 'Website' },
 ];
 
-const SETTINGS_TABS: SettingsSubTab[] = ['homepage', 'website'];
+const SETTINGS_TABS: SettingsSubTab[] = ['homepage', 'website', 'image-ai', 'content-ai'];
 
 const SETTINGS_FIELDS: Record<string, { key: string; label: string; type: 'input' | 'textarea' }[]> = {
   homepage: [
@@ -23,12 +23,29 @@ const SETTINGS_FIELDS: Record<string, { key: string; label: string; type: 'input
     { key: 'core_message', label: 'Kernbotschaft', type: 'textarea' },
   ],
   website: [
-    { key: 'cta_url', label: 'CTA Link', type: 'input' },
-    { key: 'cta_style', label: 'CTA Stil', type: 'input' },
-    { key: 'cta_prompt', label: 'CTA Prompt', type: 'textarea' },
     { key: 'core_tags', label: 'Core Tags (kommagetrennt)', type: 'input' },
     { key: 'brand_guidelines', label: 'Markenrichtlinien', type: 'textarea' },
   ],
+  'content-ai': [
+    { key: 'content.branche', label: 'Branche / Fachgebiet', type: 'input' },
+    { key: 'content.zielgruppe', label: 'Zielgruppe', type: 'textarea' },
+    { key: 'content.tonalitaet', label: 'Tonalitaet / Stil', type: 'textarea' },
+    { key: 'content.blacklist', label: 'Blacklist (kommagetrennt)', type: 'textarea' },
+    { key: 'content.min_wortanzahl', label: 'Minimale Wortanzahl', type: 'input' },
+    { key: 'content.max_wortanzahl', label: 'Maximale Wortanzahl', type: 'input' },
+    { key: 'content.stil_regeln', label: 'Zusaetzliche Stilregeln', type: 'textarea' },
+    { key: 'content.cta_url', label: 'CTA Link-Ziel', type: 'input' },
+    { key: 'content.cta_style', label: 'CTA Stil', type: 'input' },
+    { key: 'content.cta_prompt', label: 'CTA Anweisung', type: 'textarea' },
+  ],
+  'image-ai': [
+    { key: 'image.baseStylePrompt', label: 'Bildstil-Prompt', type: 'textarea' },
+    { key: 'image.constraints', label: 'Bild-Einschraenkungen', type: 'textarea' },
+    { key: 'image.sceneTemplate', label: 'Szenen-Template (mit {title} Platzhalter)', type: 'textarea' },
+    { key: 'image.altTextTemplate', label: 'Alt-Text-Template (mit {title} Platzhalter)', type: 'input' },
+    { key: 'image.filenamePrompt', label: 'Dateiname-Prompt (mit {title} Platzhalter)', type: 'textarea' },
+    { key: 'image.categoryScenes', label: 'Kategorie-Szenen (JSON)', type: 'textarea' },
+  ],
 };
 
 const CATEGORY_GUIDES: Record<SettingsSubTab, { title: string; description: string; example: string }> = {
@@ -38,9 +55,9 @@ const CATEGORY_GUIDES: Record<SettingsSubTab, { title: string; description: stri
     example: '',
   },
   'content-ai': {
-    title: 'Content-KI Prompts',
-    description: 'Steuere hier, wie die KI Blogartikel und Texte generiert. Je praeziser der Prompt, desto besser das Ergebnis. Definiere Schreibstil, SEO-Keywords und inhaltliche Schwerpunkte.',
-    example: 'Beispiel: "Schreibe einen Fachartikel mit 800-1200 Woertern. Verwende die Keywords [KEYWORD] natuerlich im Text. Struktur: Einleitung mit Hook, 3-4 Abschnitte mit H2, Fazit mit CTA. Ton: fachlich aber verstaendlich."',
+    title: 'Content-KI Einstellungen & Prompts',
+    description: 'Konfiguriere Branche, Zielgruppe, Tonalitaet und CTA. Darunter verwaltest du Prompts fuer die Content-Generierung.',
+    example: '',
   },
   'analysis-ai': {
     title: 'Analyse-KI Prompts',
@@ -162,6 +179,18 @@ export function SettingsTab() {
     setError(null);
     setSettingsSaved(false);
     try {
+      if (activeSubTab === 'image-ai') {
+        const templateKeys = ['image.sceneTemplate', 'image.altTextTemplate', 'image.filenamePrompt'];
+        for (const key of templateKeys) {
+          const value = settingsForm[key] ?? '';
+          if (value && !value.includes('{title}')) {
+            const field = (SETTINGS_FIELDS['image-ai'] ?? []).find(f => f.key === key);
+            setError(`Das Feld "${field?.label ?? key}" muss den Platzhalter {title} enthalten.`);
+            setSaving(false);
+            return;
+          }
+        }
+      }
       const fields = SETTINGS_FIELDS[activeSubTab] ?? [];
       for (const field of fields) {
         const value = settingsForm[field.key] ?? '';
@@ -313,7 +342,7 @@ export function SettingsTab() {
       )}
 
       {/* Prompt tabs: Content-KI, Analyse-KI, Bild-KI — prompt cards */}
-      {!loading && !isSettingsTab(activeSubTab) && (
+      {!loading && (!isSettingsTab(activeSubTab) || activeSubTab === 'content-ai') && (
         <>
           {filteredPrompts.length === 0 && !showAddForm && (
             <div style={styles.emptyGuide}>

package/src/db/tables.ts

@@ -1,3 +1,4 @@
+// @ts-nocheck - astro:db types resolved by Astro build pipeline
 import { defineTable, column } from "astro:db";
 
 const SiteSettings = defineTable({

package/src/index.ts

@@ -1,6 +1,7 @@
 import type { AstroIntegration } from 'astro';
 import react from '@astrojs/react';
 import db from '@astrojs/db';
+// @ts-ignore - resolved by Astro build pipeline
 import node from '@astrojs/node';
 
 export interface NcaAiCmsPluginOptions {

package/src/middleware.ts

@@ -1,7 +1,8 @@
+// @ts-ignore - resolved by Astro build pipeline
 import { defineMiddleware } from 'astro:middleware';
 import { isPublicPath, isProtectedPath, isAuthenticated } from './utils/authUtils.js';
 
-export const onRequest = defineMiddleware(async ({ request, cookies, redirect }, next) => {
+export const onRequest = defineMiddleware(async ({ request, cookies, redirect }: any, next: any) => {
   const url = new URL(request.url);
   const { pathname } = url;
 

package/src/services/ContentGenerator.test.ts

@@ -0,0 +1,200 @@
+import { describe, it, expect, beforeEach, vi } from 'vitest';
+
+let callCount = 0;
+const mockGenerateContent = vi.fn().mockImplementation(() => {
+  callCount++;
+  if (callCount % 2 === 1) {
+    // First call: researchKeywords → SourceAnalysis
+    return {
+      response: {
+        text: () =>
+          JSON.stringify({
+            topic: 'PHP Testing',
+            keyPoints: ['Unit Tests sind wichtig'],
+            uniqueInsights: ['PHPUnit 11 hat neue Features'],
+            codeExamples: ['assertEquals()'],
+          }),
+      },
+    };
+  }
+  // Second call: generateContent → article
+  return {
+    response: {
+      text: () =>
+        JSON.stringify({
+          title: 'Test Titel',
+          description: 'Test Beschreibung',
+          content: '# Test\n\nInhalt hier',
+          tags: ['test'],
+        }),
+    },
+  };
+});
+
+vi.mock('@google/generative-ai', () => {
+  return {
+    GoogleGenerativeAI: class {
+      getGenerativeModel() {
+        return { generateContent: mockGenerateContent };
+      }
+    },
+    SchemaType: { OBJECT: 'OBJECT', STRING: 'STRING', ARRAY: 'ARRAY' },
+  };
+});
+
+vi.mock('./ContentFetcher', () => ({
+  ContentFetcher: class {
+    async fetch() {
+      return {
+        title: 'Source Title',
+        url: 'https://example.com',
+        content: 'Source content here',
+      };
+    }
+  },
+}));
+
+import type { ContentSettings } from './PromptService';
+import type { IPromptService } from './ContentGenerator';
+import { ContentGenerator } from './ContentGenerator';
+
+function makeValidContentSettings(): ContentSettings {
+  return {
+    branche: 'Web-Entwicklung',
+    zielgruppe: 'Entwickler und CTOs',
+    tonalitaet: 'Professionell',
+    blacklist: '',
+    minWortanzahl: '800',
+    maxWortanzahl: '1200',
+    stilRegeln: '',
+    ctaUrl: 'https://example.com/kontakt',
+    ctaStyle: 'Einladend',
+    ctaPrompt: 'Generiere einen CTA',
+  };
+}
+
+function makeMockPromptService(overrides: Partial<ContentSettings> = {}): IPromptService {
+  const settings = { ...makeValidContentSettings(), ...overrides };
+  return {
+    getPrompt: vi.fn().mockResolvedValue(null),
+    getCTAConfig: vi.fn().mockResolvedValue({
+      url: settings.ctaUrl,
+      style: settings.ctaStyle,
+      prompt: settings.ctaPrompt,
+    }),
+    getCoreTags: vi.fn().mockResolvedValue([]),
+    getContentSettings: vi.fn().mockResolvedValue(settings),
+    validateContentSettings: vi.fn().mockReturnValue({ valid: true, missing: [] }),
+  };
+}
+
+describe('ContentGenerator', () => {
+  beforeEach(() => {
+    callCount = 0;
+    mockGenerateContent.mockClear();
+  });
+
+  describe('buildSystemPrompt via generateFromKeywords', () => {
+    it('throws when settings not configured', async () => {
+      const promptService = makeMockPromptService();
+      (promptService.validateContentSettings as ReturnType<typeof vi.fn>).mockReturnValue({
+        valid: false,
+        missing: ['branche', 'zielgruppe'],
+      });
+
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService,
+      });
+
+      await expect(generator.generateFromKeywords('test')).rejects.toThrow(
+        'Content-Generierung nicht konfiguriert. Fehlende Settings: branche, zielgruppe'
+      );
+    });
+
+    it('error message lists missing fields', async () => {
+      const promptService = makeMockPromptService();
+      (promptService.validateContentSettings as ReturnType<typeof vi.fn>).mockReturnValue({
+        valid: false,
+        missing: ['ctaUrl', 'ctaStyle', 'ctaPrompt'],
+      });
+
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService,
+      });
+
+      await expect(generator.generateFromKeywords('test')).rejects.toThrow(
+        'ctaUrl, ctaStyle, ctaPrompt'
+      );
+    });
+
+    it('generates content when settings configured', async () => {
+      const promptService = makeMockPromptService();
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService,
+      });
+
+      const article = await generator.generateFromKeywords('PHP Testing');
+
+      expect(article.title).toBe('Test Titel');
+      expect(article.content).toBe('# Test\n\nInhalt hier');
+    });
+
+    it('getCoreTags returns empty array (no hardcoded fallback)', async () => {
+      const promptService = makeMockPromptService();
+      (promptService.getCoreTags as ReturnType<typeof vi.fn>).mockResolvedValue([]);
+
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService,
+      });
+
+      const article = await generator.generateFromKeywords('test');
+
+      expect(article.tags).toEqual(['test']);
+      expect(article.tags).not.toContain('Web-Entwicklung');
+      expect(article.tags).not.toContain('Best Practices');
+    });
+  });
+
+  describe('blacklist check', () => {
+    it('checkBlacklist returns empty when content is clean', () => {
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService: makeMockPromptService(),
+      });
+
+      // Access private method for testing
+      const result = (generator as any).checkBlacklist('Dieser Text ist sauber.', 'gratis,kostenlos');
+
+      expect(result).toEqual([]);
+    });
+
+    it('checkBlacklist detects blacklisted terms', () => {
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService: makeMockPromptService(),
+      });
+
+      const result = (generator as any).checkBlacklist(
+        'Dieses gratis Tool ist kostenlos.',
+        'gratis,kostenlos'
+      );
+
+      expect(result).toEqual(['gratis', 'kostenlos']);
+    });
+
+    it('checkBlacklist returns empty with empty blacklist', () => {
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService: makeMockPromptService(),
+      });
+
+      const result = (generator as any).checkBlacklist('Irgendein Text', '');
+
+      expect(result).toEqual([]);
+    });
+  });
+});

package/src/services/ContentGenerator.ts

@@ -8,6 +8,8 @@ export interface IPromptService {
   getPrompt(id: string): Promise<string | null>;
   getCTAConfig(): Promise<{ url: string; style: string; prompt: string }>;
   getCoreTags(): Promise<string[]>;
+  getContentSettings(): Promise<import('./PromptService').ContentSettings>;
+  validateContentSettings(settings: import('./PromptService').ContentSettings): { valid: boolean; missing: string[] };
 }
 
 export interface GeneratedContent {
@@ -15,12 +17,13 @@ export interface GeneratedContent {
   description: string;
   content: string;
   tags: string[];
+  warnings?: string[];
 }
 
 export interface ContentGeneratorConfig {
   apiKey: string;
   model?: string;
-  promptService?: IPromptService;
+  promptService: IPromptService;
 }
 
 interface SourceAnalysis {
@@ -30,40 +33,6 @@ interface SourceAnalysis {
   codeExamples: string[];
 }
 
-// Fallback values when database is not available
-const DEFAULT_CONTACT_URL =
-  'https://nevercodealone.de/de/kontakt';
-
-const DEFAULT_CORE_TAGS = ['Web-Entwicklung', 'Best Practices'];
-
-const DEFAULT_SYSTEM_PROMPT = `Du bist ein erfahrener technischer Content-Writer für Web-Entwicklung.
-Deine Aufgabe ist es, hochwertige deutsche Fachartikel zu erstellen.
-
-Zielgruppe: Content-Marketing-Professionals und Entwickler
-Tonalität: Professionell, aber zugänglich. Technisch korrekt, nicht übermäßig akademisch.
-
-KRITISCH - 100% Originalität:
-- Schreibe einen KOMPLETT EIGENSTÄNDIGEN Artikel
-- KEINE Sätze, Formulierungen oder Strukturen aus externen Quellen übernehmen
-- KEINE Hinweise auf Quellen, Referenzen oder Inspiration im Text
-- Nutze ausschließlich DEIN Expertenwissen zum jeweiligen Thema
-- Jeder Satz muss NEU formuliert sein - wie von einem Experten geschrieben
-- Der Artikel muss wirken als käme er aus eigener Fachkenntnis
-
-Regeln:
-- Schreibe auf Deutsch
-- Mindestens 800 Wörter
-- Verwende praktische Codebeispiele (eigene Beispiele, nicht kopiert)
-- WICHTIG: Content MUSS mit einer H1-Überschrift (# Titel) beginnen
-- Danach H2 (##) und H3 (###) Hierarchie ohne Sprünge
-- WICHTIG: Nur Markdown, KEINE HTML-Tags wie <p>, <div>, <span> etc.
-
-Titel-Regeln:
-- Das Hauptthema/Keyword MUSS im Titel vorkommen
-- Nutze Zahlen wenn möglich (z.B. "5 Tipps", "3 Fehler")
-- Zeige den Nutzen/Benefit (z.B. "So vermeidest du...", "Warum X wichtig ist")
-- Wecke Neugier oder löse ein Problem`;
-
 export function buildSourceAnalysisSchema() {
   return {
     type: SchemaType.OBJECT as const,
@@ -96,7 +65,12 @@ export class ContentGenerator {
   private client: GoogleGenerativeAI;
   private model: string;
   private fetcher: ContentFetcher;
-  private promptService: IPromptService | undefined;
+  private promptService: IPromptService;
+  private lastWarnings: string[] = [];
+
+  get warnings(): string[] {
+    return this.lastWarnings;
+  }
 
   constructor(config: ContentGeneratorConfig) {
     this.client = new GoogleGenerativeAI(config.apiKey);
@@ -114,6 +88,7 @@ export class ContentGenerator {
 
     // Step 2: Generate article based on analysis
     const generated = await this.generateContent(analysis);
+    this.lastWarnings = generated.warnings ?? [];
 
     const props: ArticleProps = {
       title: generated.title,
@@ -132,6 +107,7 @@ export class ContentGenerator {
 
     // Generate article based on research
     const generated = await this.generateContent(analysis);
+    this.lastWarnings = generated.warnings ?? [];
 
     const props: ArticleProps = {
       title: generated.title,
@@ -258,42 +234,68 @@ Fokussiere auf aktuelle Standards und praktische Anwendbarkeit.`;
       throw new Error(`Failed to parse generated content response: ${text.slice(0, 200)}`);
     }
 
+    const contentSettings = await this.promptService.getContentSettings();
+    const blacklistWarnings = this.checkBlacklist(data.content, contentSettings.blacklist);
+
     return {
       title: data.title,
       description: data.description,
       content: data.content,
       tags: [...new Set([...coreTags, ...data.tags])],
+      ...(blacklistWarnings.length > 0 ? { warnings: blacklistWarnings.map(term => `Blacklist-Begriff gefunden: "${term}"`) } : {}),
     };
   }
 
   private async buildSystemPrompt(): Promise<string> {
-    // Try to load from database
-    if (this.promptService) {
-      try {
-        const [basePrompt, ctaConfig] = await Promise.all([
-          this.promptService.getPrompt('system_prompt'),
-          this.promptService.getCTAConfig(),
-        ]);
-
-        if (basePrompt) {
-          // Add CTA instructions to the system prompt
-          return `${basePrompt}
+    const settings = await this.promptService.getContentSettings();
+    const validation = this.promptService.validateContentSettings(settings);
 
-- WICHTIG: Beende den Artikel mit einem einzigartigen Call-to-Action:
-  - Link: ${ctaConfig.url}
-  - Stil: ${ctaConfig.style}
-  ${ctaConfig.prompt}`;
-        }
-      } catch (error) {
-        console.warn('Failed to load prompts from database, using defaults');
-      }
+    if (!validation.valid) {
+      throw new Error(
+        `Content-Generierung nicht konfiguriert. Fehlende Settings: ${validation.missing.join(', ')}. Bitte unter Einstellungen → Content-KI ausfüllen.`
+      );
     }
 
-    // Fallback to default with static CTA
-    return `${DEFAULT_SYSTEM_PROMPT}
+    // Try custom system prompt from DB first
+    const basePrompt = await this.promptService.getPrompt('system_prompt');
 
-- WICHTIG: Beende den Artikel mit einem Call-to-Action, der zum Thema passt.
-  Verwende diesen Link: [Kontakt aufnehmen](${DEFAULT_CONTACT_URL})`;
+    const systemPrompt = basePrompt
+      ? basePrompt
+      : `Du bist ein erfahrener technischer Content-Writer für ${settings.branche}.
+Deine Aufgabe ist es, hochwertige deutsche Fachartikel zu erstellen.
+
+Zielgruppe: ${settings.zielgruppe}
+Tonalität: ${settings.tonalitaet}
+
+KRITISCH - 100% Originalität:
+- Schreibe einen KOMPLETT EIGENSTÄNDIGEN Artikel
+- KEINE Sätze, Formulierungen oder Strukturen aus externen Quellen übernehmen
+- KEINE Hinweise auf Quellen, Referenzen oder Inspiration im Text
+- Nutze ausschließlich DEIN Expertenwissen zum jeweiligen Thema
+- Jeder Satz muss NEU formuliert sein - wie von einem Experten geschrieben
+- Der Artikel muss wirken als käme er aus eigener Fachkenntnis
+
+Regeln:
+- Schreibe auf Deutsch
+- Mindestens ${settings.minWortanzahl} Wörter, maximal ${settings.maxWortanzahl} Wörter
+- Verwende praktische Codebeispiele (eigene Beispiele, nicht kopiert)
+- WICHTIG: Content MUSS mit einer H1-Überschrift (# Titel) beginnen
+- Danach H2 (##) und H3 (###) Hierarchie ohne Sprünge
+- WICHTIG: Nur Markdown, KEINE HTML-Tags wie <p>, <div>, <span> etc.
+${settings.stilRegeln ? `\nZusätzliche Stilregeln:\n${settings.stilRegeln}` : ''}
+
+Titel-Regeln:
+- Das Hauptthema/Keyword MUSS im Titel vorkommen
+- Nutze Zahlen wenn möglich (z.B. "5 Tipps", "3 Fehler")
+- Zeige den Nutzen/Benefit (z.B. "So vermeidest du...", "Warum X wichtig ist")
+- Wecke Neugier oder löse ein Problem`;
+
+    return `${systemPrompt}
+
+- WICHTIG: Beende den Artikel mit einem einzigartigen Call-to-Action:
+  - Link: ${settings.ctaUrl}
+  - Stil: ${settings.ctaStyle}
+  ${settings.ctaPrompt}`;
   }
 
   private buildUserPrompt(analysis: SourceAnalysis): string {
@@ -309,13 +311,12 @@ Wichtig: Schreibe komplett eigenständig aus deiner Expertise heraus.`;
   }
 
   private async getCoreTags(): Promise<string[]> {
-    if (this.promptService) {
-      try {
-        return await this.promptService.getCoreTags();
-      } catch {
-        // Fall through to default
-      }
-    }
-    return DEFAULT_CORE_TAGS;
+    return await this.promptService.getCoreTags();
+  }
+
+  private checkBlacklist(content: string, blacklist: string): string[] {
+    if (!blacklist.trim()) return [];
+    const terms = blacklist.split(',').map(t => t.trim().toLowerCase()).filter(Boolean);
+    return terms.filter(term => content.toLowerCase().includes(term));
   }
 }