nca-ai-cms-astro-plugin 1.0.12 → 1.0.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nca-ai-cms-astro-plugin",
-  "version": "1.0.12",
+  "version": "1.0.14",
   "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/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', 'image-ai'];
+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,21 @@ 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' },
@@ -46,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',
@@ -333,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/components/frontend/DeleteAction.astro

@@ -60,6 +60,7 @@ const { articleId } = Astro.props;
       try {
         const response = await fetch(`/api/articles/${articleId}`, {
           method: 'DELETE',
+          credentials: 'same-origin',
         });
         response.ok
           ? removeCard()

package/src/services/ContentGenerator.test.ts

@@ -0,0 +1,217 @@
+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('uses fallback prompt when settings not configured', async () => {
+      const promptService = makeMockPromptService({
+        branche: '',
+        zielgruppe: '',
+        tonalitaet: '',
+        ctaUrl: '',
+        ctaStyle: '',
+        ctaPrompt: '',
+      });
+      (promptService.validateContentSettings as ReturnType<typeof vi.fn>).mockReturnValue({
+        valid: false,
+        missing: ['branche', 'zielgruppe'],
+      });
+
+      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');
+      // Verify system prompt used generic fallback values
+      const systemInstruction = mockGenerateContent.mock.calls[0]?.[0] ||
+        mockGenerateContent.mock.results[0];
+      expect(mockGenerateContent).toHaveBeenCalled();
+    });
+
+    it('omits CTA section when CTA settings are empty', async () => {
+      const promptService = makeMockPromptService({
+        ctaUrl: '',
+        ctaStyle: '',
+        ctaPrompt: '',
+      });
+      (promptService.validateContentSettings as ReturnType<typeof vi.fn>).mockReturnValue({
+        valid: true,
+        missing: [],
+      });
+
+      const generator = new ContentGenerator({
+        apiKey: 'test-key',
+        promptService,
+      });
+
+      const article = await generator.generateFromKeywords('PHP Testing');
+
+      expect(article.title).toBe('Test Titel');
+      expect(mockGenerateContent).toHaveBeenCalled();
+    });
+
+    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,110 @@ 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');
-      }
+    // Try custom system prompt from DB first
+    const basePrompt = await this.promptService.getPrompt('system_prompt');
+
+    let systemPrompt: string;
+
+    if (!validation.valid) {
+      // Fallback: use available settings where possible, skip what's missing
+      const branche = settings.branche || '';
+      const zielgruppe = settings.zielgruppe || '';
+      const tonalitaet = settings.tonalitaet || '';
+      const minWords = settings.minWortanzahl || '800';
+      const maxWords = settings.maxWortanzahl || '1200';
+
+      systemPrompt = basePrompt
+        ? basePrompt
+        : `Du bist ein erfahrener technischer Content-Writer.${branche ? ` Dein Fachgebiet ist ${branche}.` : ''}
+Deine Aufgabe ist es, eine KOMPLETT NEUE Version eines bestehenden Artikels zu erstellen.
+Der neue Artikel soll das gleiche Thema behandeln, aber mit völlig neuer Struktur, neuen Formulierungen und frischen Perspektiven.
+${zielgruppe ? `\nZielgruppe: ${zielgruppe}` : ''}${tonalitaet ? `\nTonalität: ${tonalitaet}` : ''}
+
+KRITISCH - 100% Originalität:
+- Schreibe einen KOMPLETT EIGENSTÄNDIGEN Artikel — eine völlig neue Version
+- KEINE Sätze, Formulierungen oder Strukturen aus der vorherigen Version ü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
+- Wähle eine andere Gliederung und andere Schwerpunkte als ein typischer Artikel zum Thema
+
+Regeln:
+- Schreibe auf Deutsch
+- Mindestens ${minWords} Wörter, maximal ${maxWords} 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`;
+    } else {
+      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`;
     }
 
-    // Fallback to default with static CTA
-    return `${DEFAULT_SYSTEM_PROMPT}
+    // Only add CTA section when CTA settings are configured
+    const hasCta = settings.ctaUrl && settings.ctaStyle && settings.ctaPrompt;
+    if (hasCta) {
+      return `${systemPrompt}
+
+- WICHTIG: Beende den Artikel mit einem einzigartigen Call-to-Action:
+  - Link: ${settings.ctaUrl}
+  - Stil: ${settings.ctaStyle}
+  ${settings.ctaPrompt}`;
+    }
 
-- WICHTIG: Beende den Artikel mit einem Call-to-Action, der zum Thema passt.
-  Verwende diesen Link: [Kontakt aufnehmen](${DEFAULT_CONTACT_URL})`;
+    return systemPrompt;
   }
 
   private buildUserPrompt(analysis: SourceAnalysis): string {
@@ -309,13 +353,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));
   }
 }

package/src/services/PromptService.test.ts

@@ -7,7 +7,7 @@ vi.mock('astro:db', () => ({
   eq: vi.fn(),
 }));
 
-import { PromptService, ImageSettings } from './PromptService';
+import { PromptService, ImageSettings, ContentSettings } from './PromptService';
 
 describe('PromptService', () => {
   let service: PromptService;
@@ -139,4 +139,155 @@ describe('PromptService', () => {
       expect(result.missing).toEqual([]);
     });
   });
+
+  describe('getContentSettings', () => {
+    it('returns correct structure when settings exist', async () => {
+      vi.spyOn(service, 'getSetting').mockImplementation(async (key: string) => {
+        const map: Record<string, string> = {
+          'content.branche': 'Web-Entwicklung',
+          'content.zielgruppe': 'Entwickler und CTOs',
+          'content.tonalitaet': 'Professionell',
+          'content.blacklist': 'gratis,kostenlos',
+          'content.min_wortanzahl': '800',
+          'content.max_wortanzahl': '1200',
+          'content.stil_regeln': 'Keine Emojis',
+          'content.cta_url': 'https://example.com/kontakt',
+          'content.cta_style': 'Einladend',
+          'content.cta_prompt': 'Generiere einen CTA',
+        };
+        return map[key] ?? null;
+      });
+
+      const settings = await service.getContentSettings();
+
+      expect(settings.branche).toBe('Web-Entwicklung');
+      expect(settings.zielgruppe).toBe('Entwickler und CTOs');
+      expect(settings.tonalitaet).toBe('Professionell');
+      expect(settings.blacklist).toBe('gratis,kostenlos');
+      expect(settings.minWortanzahl).toBe('800');
+      expect(settings.maxWortanzahl).toBe('1200');
+      expect(settings.stilRegeln).toBe('Keine Emojis');
+      expect(settings.ctaUrl).toBe('https://example.com/kontakt');
+      expect(settings.ctaStyle).toBe('Einladend');
+      expect(settings.ctaPrompt).toBe('Generiere einen CTA');
+    });
+
+    it('returns empty strings when settings do not exist', async () => {
+      vi.spyOn(service, 'getSetting').mockResolvedValue(null);
+
+      const settings = await service.getContentSettings();
+
+      expect(settings.branche).toBe('');
+      expect(settings.zielgruppe).toBe('');
+      expect(settings.tonalitaet).toBe('');
+      expect(settings.blacklist).toBe('');
+      expect(settings.minWortanzahl).toBe('');
+      expect(settings.maxWortanzahl).toBe('');
+      expect(settings.stilRegeln).toBe('');
+      expect(settings.ctaUrl).toBe('');
+      expect(settings.ctaStyle).toBe('');
+      expect(settings.ctaPrompt).toBe('');
+    });
+  });
+
+  describe('validateContentSettings', () => {
+    function makeValidContentSettings(): ContentSettings {
+      return {
+        branche: 'Web-Entwicklung',
+        zielgruppe: 'Entwickler',
+        tonalitaet: 'Professionell',
+        blacklist: '',
+        minWortanzahl: '800',
+        maxWortanzahl: '1200',
+        stilRegeln: '',
+        ctaUrl: 'https://example.com',
+        ctaStyle: 'Einladend',
+        ctaPrompt: 'Generiere einen CTA',
+      };
+    }
+
+    it('returns valid:true when all required fields are filled', () => {
+      const result = service.validateContentSettings(makeValidContentSettings());
+
+      expect(result.valid).toBe(true);
+      expect(result.missing).toEqual([]);
+    });
+
+    it('returns valid:false with missing field names when empty', () => {
+      const settings: ContentSettings = {
+        branche: '',
+        zielgruppe: '',
+        tonalitaet: '',
+        blacklist: '',
+        minWortanzahl: '',
+        maxWortanzahl: '',
+        stilRegeln: '',
+        ctaUrl: '',
+        ctaStyle: '',
+        ctaPrompt: '',
+      };
+
+      const result = service.validateContentSettings(settings);
+
+      expect(result.valid).toBe(false);
+      expect(result.missing).toHaveLength(8);
+      expect(result.missing).toContain('branche');
+      expect(result.missing).toContain('zielgruppe');
+      expect(result.missing).toContain('tonalitaet');
+      expect(result.missing).toContain('minWortanzahl');
+      expect(result.missing).toContain('maxWortanzahl');
+      expect(result.missing).toContain('ctaUrl');
+      expect(result.missing).toContain('ctaStyle');
+      expect(result.missing).toContain('ctaPrompt');
+    });
+
+    it('ignores optional fields (blacklist, stilRegeln)', () => {
+      const settings = makeValidContentSettings();
+      settings.blacklist = '';
+      settings.stilRegeln = '';
+
+      const result = service.validateContentSettings(settings);
+
+      expect(result.valid).toBe(true);
+      expect(result.missing).toEqual([]);
+    });
+  });
+
+  describe('getCTAConfig', () => {
+    it('returns empty strings when no settings exist', async () => {
+      vi.spyOn(service, 'getSetting').mockResolvedValue(null);
+
+      const config = await service.getCTAConfig();
+
+      expect(config.url).toBe('');
+      expect(config.style).toBe('');
+      expect(config.prompt).toBe('');
+    });
+  });
+
+  describe('getCoreTags', () => {
+    it('returns empty array when no setting exists', async () => {
+      vi.spyOn(service, 'getSetting').mockResolvedValue(null);
+
+      const tags = await service.getCoreTags();
+
+      expect(tags).toEqual([]);
+    });
+
+    it('parses valid JSON tags', async () => {
+      vi.spyOn(service, 'getSetting').mockResolvedValue('["PHP","Testing"]');
+
+      const tags = await service.getCoreTags();
+
+      expect(tags).toEqual(['PHP', 'Testing']);
+    });
+
+    it('returns empty array for invalid JSON', async () => {
+      vi.spyOn(service, 'getSetting').mockResolvedValue('invalid');
+
+      const tags = await service.getCoreTags();
+
+      expect(tags).toEqual([]);
+    });
+  });
 });

package/src/services/PromptService.ts

@@ -33,6 +33,43 @@ export const REQUIRED_IMAGE_SETTINGS = [
   'image.filenamePrompt',
 ] as const;
 
+export interface ContentSettings {
+  branche: string;
+  zielgruppe: string;
+  tonalitaet: string;
+  blacklist: string;
+  minWortanzahl: string;
+  maxWortanzahl: string;
+  stilRegeln: string;
+  ctaUrl: string;
+  ctaStyle: string;
+  ctaPrompt: string;
+}
+
+export const CONTENT_SETTING_KEYS = [
+  'content.branche',
+  'content.zielgruppe',
+  'content.tonalitaet',
+  'content.blacklist',
+  'content.min_wortanzahl',
+  'content.max_wortanzahl',
+  'content.stil_regeln',
+  'content.cta_url',
+  'content.cta_style',
+  'content.cta_prompt',
+] as const;
+
+export const REQUIRED_CONTENT_SETTINGS = [
+  'content.branche',
+  'content.zielgruppe',
+  'content.tonalitaet',
+  'content.min_wortanzahl',
+  'content.max_wortanzahl',
+  'content.cta_url',
+  'content.cta_style',
+  'content.cta_prompt',
+] as const;
+
 export class PromptService {
   async getPrompt(id: string): Promise<string | null> {
     const result = await db
@@ -109,22 +146,44 @@ export class PromptService {
     return await db.select().from(SiteSettings);
   }
 
+  async getContentSettings(): Promise<ContentSettings> {
+    const results = await Promise.all(
+      CONTENT_SETTING_KEYS.map((key) => this.getSetting(key))
+    );
+    return {
+      branche: results[0] ?? '',
+      zielgruppe: results[1] ?? '',
+      tonalitaet: results[2] ?? '',
+      blacklist: results[3] ?? '',
+      minWortanzahl: results[4] ?? '',
+      maxWortanzahl: results[5] ?? '',
+      stilRegeln: results[6] ?? '',
+      ctaUrl: results[7] ?? '',
+      ctaStyle: results[8] ?? '',
+      ctaPrompt: results[9] ?? '',
+    };
+  }
+
+  validateContentSettings(settings: ContentSettings): { valid: boolean; missing: string[] } {
+    const missing: string[] = [];
+    if (!settings.branche.trim()) missing.push('branche');
+    if (!settings.zielgruppe.trim()) missing.push('zielgruppe');
+    if (!settings.tonalitaet.trim()) missing.push('tonalitaet');
+    if (!settings.minWortanzahl.trim()) missing.push('minWortanzahl');
+    if (!settings.maxWortanzahl.trim()) missing.push('maxWortanzahl');
+    if (!settings.ctaUrl.trim()) missing.push('ctaUrl');
+    if (!settings.ctaStyle.trim()) missing.push('ctaStyle');
+    if (!settings.ctaPrompt.trim()) missing.push('ctaPrompt');
+    return { valid: missing.length === 0, missing };
+  }
+
   async getCTAConfig(): Promise<CTAConfig> {
     const [url, style, prompt] = await Promise.all([
-      this.getSetting('cta_url'),
-      this.getSetting('cta_style'),
-      this.getPrompt('cta_prompt'),
+      this.getSetting('content.cta_url'),
+      this.getSetting('content.cta_style'),
+      this.getSetting('content.cta_prompt'),
     ]);
-
-    return {
-      url:
-        url ??
-        'https://nevercodealone.de/de/landingpages/barrierefreies-webdesign',
-      style:
-        style ??
-        'Professionell, einladend, mit klarem Nutzenversprechen. Deutsche Sprache.',
-      prompt: prompt ?? 'Generiere einen einzigartigen Call-to-Action.',
-    };
+    return { url: url ?? '', style: style ?? '', prompt: prompt ?? '' };
   }
 
   async getImageSettings(): Promise<ImageSettings> {
@@ -175,11 +234,11 @@ export class PromptService {
 
   async getCoreTags(): Promise<string[]> {
     const tags = await this.getSetting('core_tags');
-    if (!tags) return ['Web-Entwicklung', 'Best Practices'];
+    if (!tags) return [];
     try {
       return JSON.parse(tags);
     } catch {
-      return ['Web-Entwicklung', 'Best Practices'];
+      return [];
     }
   }
 }

package/update.md

@@ -1,3 +1,33 @@
+# v1.0.14
+
+## Bugfix: Regenerate text works without content-ai settings
+- `buildSystemPrompt()` no longer throws when content-ai settings are missing
+- Uses fallback prompt that works with whatever settings are available — fills in configured values, skips empty ones
+- Fallback prompt explicitly instructs AI to create a completely new version of the existing article with fresh structure and perspectives
+- CTA section is only appended when all three CTA fields (url, style, prompt) are configured — omitted entirely otherwise
+- Updated tests: replaced "throws when not configured" with fallback behavior verification
+
+## Fix: Delete article fetch credentials
+- Added `credentials: 'same-origin'` to DELETE fetch call in `DeleteAction.astro`
+
+---
+
+# v1.0.13
+
+## ContentGenerator: settings-driven, zero hardcoding
+- Removed all hardcoded prompt strings from `ContentGenerator.ts` (DEFAULT_SYSTEM_PROMPT, DEFAULT_CONTACT_URL, DEFAULT_CORE_TAGS)
+- All content generation parameters now read from `SiteSettings` at runtime via `PromptService.getContentSettings()`
+- New settings: `content.branche`, `content.zielgruppe`, `content.tonalitaet`, `content.blacklist`, `content.min_wortanzahl`, `content.max_wortanzahl`, `content.stil_regeln`, `content.cta_url`, `content.cta_style`, `content.cta_prompt`
+- Added `validateContentSettings()` — blocks generation with clear error message when settings are missing
+- Added blacklist post-generation check with warnings in API response
+- `promptService` is now required (was optional with hardcoded fallbacks)
+- Removed hardcoded fallbacks from `getCTAConfig()` and `getCoreTags()`
+- Settings UI: new Content-KI tab with all content settings fields, CTA fields moved from Website tab
+- Content-KI tab shows both settings form and prompt cards (dual rendering)
+- 17 new tests for ContentGenerator and PromptService content settings
+
+---
+
 # v1.0.12
 
 ## ImageGenerator: settings-driven, zero hardcoding