nca-ai-cms-astro-plugin 1.0.0

package/src/services/ContentGenerator.ts

@@ -0,0 +1,320 @@
+import { GoogleGenerativeAI, SchemaType } from '@google/generative-ai';
+import { Source } from '../domain/entities/Source';
+import { Article, type ArticleProps } from '../domain/entities/Article';
+import { ContentFetcher, type FetchedContent } from './ContentFetcher';
+
+// PromptService interface for dependency injection (avoids astro:db import in tests)
+export interface IPromptService {
+  getPrompt(id: string): Promise<string | null>;
+  getCTAConfig(): Promise<{ url: string; style: string; prompt: string }>;
+  getCoreTags(): Promise<string[]>;
+}
+
+export interface GeneratedContent {
+  title: string;
+  description: string;
+  content: string;
+  tags: string[];
+}
+
+export interface ContentGeneratorConfig {
+  apiKey: string;
+  model?: string;
+  promptService?: IPromptService;
+}
+
+interface SourceAnalysis {
+  topic: string;
+  keyPoints: string[];
+  uniqueInsights: string[];
+  codeExamples: string[];
+}
+
+// Fallback values when database is not available
+const DEFAULT_CONTACT_URL =
+  'https://nevercodealone.de/de/landingpages/barrierefreies-webdesign';
+
+const DEFAULT_CORE_TAGS = ['Semantik', 'HTML', 'Barrierefrei'];
+
+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 Frontend-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 zur Barrierefreiheit
+- 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.
+- WICHTIG: Integriere die Keywords "Semantik", "HTML" und "Barrierefrei" natürlich in den Text
+
+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,
+    properties: {
+      topic: {
+        type: SchemaType.STRING,
+        description: 'Das Hauptthema in 2-5 Wörtern',
+      },
+      keyPoints: {
+        type: SchemaType.ARRAY,
+        items: { type: SchemaType.STRING },
+        description: 'Die wichtigsten Kernaussagen/Fakten',
+      },
+      uniqueInsights: {
+        type: SchemaType.ARRAY,
+        items: { type: SchemaType.STRING },
+        description: 'Besondere/einzigartige Erkenntnisse oder Tipps',
+      },
+      codeExamples: {
+        type: SchemaType.ARRAY,
+        items: { type: SchemaType.STRING },
+        description: 'Wichtige Code-Beispiele oder Patterns',
+      },
+    },
+    required: ['topic', 'keyPoints', 'uniqueInsights', 'codeExamples'],
+  } satisfies import('@google/generative-ai').Schema;
+}
+
+export class ContentGenerator {
+  private client: GoogleGenerativeAI;
+  private model: string;
+  private fetcher: ContentFetcher;
+  private promptService: IPromptService | undefined;
+
+  constructor(config: ContentGeneratorConfig) {
+    this.client = new GoogleGenerativeAI(config.apiKey);
+    this.model = config.model || 'gemini-2.5-flash';
+    this.fetcher = new ContentFetcher();
+    this.promptService = config.promptService;
+  }
+
+  async generateFromUrl(sourceUrl: string): Promise<Article> {
+    const source = new Source(sourceUrl);
+    const fetchedContent = await this.fetcher.fetch(source);
+
+    // Step 1: Analyze source to detect topic and extract insights
+    const analysis = await this.analyzeSource(fetchedContent);
+
+    // Step 2: Generate article based on analysis
+    const generated = await this.generateContent(analysis);
+
+    const props: ArticleProps = {
+      title: generated.title,
+      description: generated.description,
+      content: generated.content,
+      date: new Date(),
+      tags: generated.tags,
+    };
+
+    return new Article(props);
+  }
+
+  async generateFromKeywords(keywords: string): Promise<Article> {
+    // Research the keywords using AI
+    const analysis = await this.researchKeywords(keywords);
+
+    // Generate article based on research
+    const generated = await this.generateContent(analysis);
+
+    const props: ArticleProps = {
+      title: generated.title,
+      description: generated.description,
+      content: generated.content,
+      date: new Date(),
+      tags: generated.tags,
+    };
+
+    return new Article(props);
+  }
+
+  private async analyzeSource(
+    fetched: FetchedContent
+  ): Promise<SourceAnalysis> {
+    const model = this.client.getGenerativeModel({
+      model: this.model,
+      generationConfig: {
+        responseMimeType: 'application/json',
+        responseSchema: buildSourceAnalysisSchema(),
+      },
+    });
+
+    const prompt = `Analysiere diesen Web-Artikel und extrahiere die wichtigsten Informationen.
+
+Titel: ${fetched.title}
+URL: ${fetched.url}
+
+Inhalt:
+${fetched.content.slice(0, 12000)}
+
+Identifiziere:
+1. Das Hauptthema (fokussiert auf Web-Entwicklung/Barrierefreiheit)
+2. Die wichtigsten Kernaussagen
+3. Besondere Erkenntnisse oder einzigartige Tipps
+4. Relevante Code-Beispiele oder Patterns`;
+
+    const result = await model.generateContent(prompt);
+    const text = result.response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error(`Failed to parse source analysis response: ${text.slice(0, 200)}`);
+    }
+  }
+
+  private async researchKeywords(keywords: string): Promise<SourceAnalysis> {
+    const model = this.client.getGenerativeModel({
+      model: this.model,
+      generationConfig: {
+        responseMimeType: 'application/json',
+        responseSchema: buildSourceAnalysisSchema(),
+      },
+    });
+
+    const prompt = `Du bist ein Experte für Web-Accessibility und barrierefreie Webentwicklung.
+
+Recherchiere zum Thema: "${keywords}"
+
+Nutze dein Fachwissen um:
+1. Das Hauptthema klar zu definieren (Bezug zu Barrierefreiheit/Web-Accessibility)
+2. Die wichtigsten Fakten, Best Practices und WCAG-Richtlinien zusammenzufassen
+3. Weniger bekannte aber wichtige Tipps und Erkenntnisse zu identifizieren
+4. Praktische Code-Beispiele oder Patterns vorzuschlagen
+
+Fokussiere auf aktuelle Standards und praktische Anwendbarkeit.`;
+
+    const result = await model.generateContent(prompt);
+    const text = result.response.text();
+    try {
+      return JSON.parse(text);
+    } catch {
+      throw new Error(`Failed to parse keyword research response: ${text.slice(0, 200)}`);
+    }
+  }
+
+  private async generateContent(
+    analysis: SourceAnalysis
+  ): Promise<GeneratedContent> {
+    const systemPrompt = await this.buildSystemPrompt();
+    const userPrompt = this.buildUserPrompt(analysis);
+    const coreTags = await this.getCoreTags();
+
+    const model = this.client.getGenerativeModel({
+      model: this.model,
+      systemInstruction: systemPrompt,
+      generationConfig: {
+        responseMimeType: 'application/json',
+        responseSchema: {
+          type: SchemaType.OBJECT,
+          properties: {
+            title: {
+              type: SchemaType.STRING,
+              description: 'SEO-optimierter Titel, max 60 Zeichen',
+            },
+            description: {
+              type: SchemaType.STRING,
+              description: 'Meta-Description, max 155 Zeichen',
+            },
+            tags: {
+              type: SchemaType.ARRAY,
+              items: { type: SchemaType.STRING },
+              description: 'Relevante Tags für den Artikel',
+            },
+            content: {
+              type: SchemaType.STRING,
+              description:
+                'Vollständiger Markdown-Inhalt. MUSS mit H1 (# Titel) beginnen, dann H2/H3 Hierarchie. Keine HTML-Tags.',
+            },
+          },
+          required: ['title', 'description', 'tags', 'content'],
+        },
+      },
+    });
+
+    const result = await model.generateContent(userPrompt);
+    const text = result.response.text();
+    let data: { title: string; description: string; content: string; tags: string[] };
+    try {
+      data = JSON.parse(text);
+    } catch {
+      throw new Error(`Failed to parse generated content response: ${text.slice(0, 200)}`);
+    }
+
+    return {
+      title: data.title,
+      description: data.description,
+      content: data.content,
+      tags: [...new Set([...coreTags, ...data.tags])],
+    };
+  }
+
+  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}
+
+- 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');
+      }
+    }
+
+    // Fallback to default with static CTA
+    return `${DEFAULT_SYSTEM_PROMPT}
+
+- WICHTIG: Beende den Artikel mit einem Call-to-Action, der zum Thema passt.
+  Verwende diesen Link: [Kontakt aufnehmen](${DEFAULT_CONTACT_URL})`;
+  }
+
+  private buildUserPrompt(analysis: SourceAnalysis): string {
+    return `Schreibe als Accessibility-Experte einen deutschen Fachartikel zum Thema: ${analysis.topic}
+
+Behandle diese Aspekte aus deinem Fachwissen:
+${analysis.keyPoints.map((p) => `- ${p}`).join('\n')}
+${analysis.uniqueInsights.map((p) => `- ${p}`).join('\n')}
+
+${analysis.codeExamples.length > 0 ? `Zeige praktische Code-Beispiele für:\n${analysis.codeExamples.map((c) => `- ${c}`).join('\n')}` : ''}
+
+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;
+  }
+}

package/src/services/FileWriter.test.ts

@@ -0,0 +1,80 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { FileWriter } from './FileWriter';
+import { Article } from '../domain/entities/Article';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('FileWriter', () => {
+  let tempDir: string;
+  let fileWriter: FileWriter;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'filewriter-test-'));
+    fileWriter = new FileWriter(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  const createTestArticle = (overrides = {}) =>
+    new Article({
+      title: 'Test Article',
+      description: 'Test description',
+      content: '# Test\n\nContent here',
+      date: new Date('2025-12-07'),
+      tags: ['test'],
+      ...overrides,
+    });
+
+  it('creates article folder with index.md', async () => {
+    const article = createTestArticle();
+    const result = await fileWriter.write(article);
+
+    expect(result.created).toBe(true);
+    expect(result.filepath).toContain('/index.md');
+
+    const content = await fs.readFile(result.filepath, 'utf-8');
+    expect(content).toContain('title: "Test Article"');
+  });
+
+  it('creates nested year/month/slug folder structure', async () => {
+    const article = createTestArticle();
+    await fileWriter.write(article);
+
+    const expectedFolder = path.join(
+      tempDir,
+      'nca-ai-cms-content/2025/12/test-article'
+    );
+    const stats = await fs.stat(expectedFolder);
+    expect(stats.isDirectory()).toBe(true);
+
+    const indexPath = path.join(expectedFolder, 'index.md');
+    const indexStats = await fs.stat(indexPath);
+    expect(indexStats.isFile()).toBe(true);
+  });
+
+  it('includes image path in frontmatter when provided', async () => {
+    const article = createTestArticle({
+      image: './hero.webp',
+      imageAlt: 'Test image alt',
+    });
+
+    const result = await fileWriter.write(article);
+    const content = await fs.readFile(result.filepath, 'utf-8');
+
+    expect(content).toContain('image: "./hero.webp"');
+    expect(content).toContain('imageAlt: "Test image alt"');
+  });
+
+  it('handles duplicate articles by appending counter', async () => {
+    const article = createTestArticle();
+
+    const result1 = await fileWriter.write(article);
+    const result2 = await fileWriter.write(article);
+
+    expect(result1.filepath).toContain('/index.md');
+    expect(result2.filepath).toContain('/index-2.md');
+  });
+});

package/src/services/FileWriter.ts

@@ -0,0 +1,59 @@
+import { Article } from '../domain/entities/Article';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export interface WriteResult {
+  filepath: string;
+  created: boolean;
+}
+
+export class FileWriter {
+  private basePath: string;
+
+  constructor(basePath: string = process.cwd()) {
+    this.basePath = basePath;
+  }
+
+  async write(article: Article): Promise<WriteResult> {
+    const filepath = path.join(this.basePath, article.filepath);
+    const dir = path.dirname(filepath);
+
+    // Create directory if it doesn't exist
+    await fs.mkdir(dir, { recursive: true });
+
+    // Check if file already exists
+    const exists = await this.fileExists(filepath);
+    if (exists) {
+      const newPath = await this.getUniqueFilepath(filepath);
+      await fs.writeFile(newPath, article.toMarkdown(), 'utf-8');
+      return { filepath: newPath, created: true };
+    }
+
+    await fs.writeFile(filepath, article.toMarkdown(), 'utf-8');
+    return { filepath, created: true };
+  }
+
+  private async fileExists(filepath: string): Promise<boolean> {
+    try {
+      await fs.access(filepath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  private async getUniqueFilepath(filepath: string): Promise<string> {
+    const ext = path.extname(filepath);
+    const base = filepath.slice(0, -ext.length);
+
+    let counter = 2;
+    let newPath = `${base}-${counter}${ext}`;
+
+    while (await this.fileExists(newPath)) {
+      counter++;
+      newPath = `${base}-${counter}${ext}`;
+    }
+
+    return newPath;
+  }
+}

package/src/services/ImageConverter.ts

@@ -0,0 +1,15 @@
+import sharp from 'sharp';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export async function convertToWebP(
+  base64: string,
+  outputPath: string
+): Promise<void> {
+  const buffer = Buffer.from(base64, 'base64');
+  const webpBuffer = await sharp(buffer)
+    .webp({ quality: 85, effort: 6 })
+    .toBuffer();
+  await fs.mkdir(path.dirname(outputPath), { recursive: true });
+  await fs.writeFile(outputPath, webpBuffer);
+}

package/src/services/ImageGenerator.ts

@@ -0,0 +1,108 @@
+import { GoogleGenAI, PersonGeneration } from '@google/genai';
+import { GoogleGenerativeAI } from '@google/generative-ai';
+import { Slug } from '../domain/value-objects/Slug';
+
+export interface GeneratedImage {
+  url: string;
+  alt: string;
+  filepath: string;
+  base64?: string;
+}
+
+export interface ImageGeneratorConfig {
+  apiKey: string;
+  model?: string;
+}
+
+export class ImageGenerator {
+  private client: GoogleGenAI;
+  private textClient: GoogleGenerativeAI;
+  private model: string;
+
+  constructor(config: ImageGeneratorConfig) {
+    this.client = new GoogleGenAI({ apiKey: config.apiKey });
+    this.textClient = new GoogleGenerativeAI(config.apiKey);
+    this.model = config.model || 'imagen-4.0-generate-001';
+  }
+
+  async generate(title: string): Promise<GeneratedImage> {
+    const prompt = this.buildPrompt(title);
+    const filename = await this.generateSeoFilename(title);
+    const filepath = `dist/client/images/${filename}.webp`;
+
+    try {
+      const response = await this.client.models.generateImages({
+        model: this.model,
+        prompt: prompt,
+        config: {
+          numberOfImages: 1,
+          aspectRatio: '16:9',
+          personGeneration: PersonGeneration.DONT_ALLOW,
+        },
+      });
+
+      if (!response.generatedImages || response.generatedImages.length === 0) {
+        throw new Error('No image generated');
+      }
+
+      const imageData = response.generatedImages[0];
+      if (!imageData) {
+        throw new Error('No image data in response');
+      }
+      const base64 = imageData.image?.imageBytes;
+
+      if (!base64) {
+        throw new Error('No image data received');
+      }
+
+      return {
+        url: `data:image/png;base64,${base64}`,
+        alt: this.generateAlt(title),
+        filepath,
+        base64,
+      };
+    } catch (error) {
+      console.error('Image generation error:', error);
+      throw new Error(
+        `Image generation failed: ${error instanceof Error ? error.message : 'Unknown error'}`
+      );
+    }
+  }
+
+  private buildPrompt(title: string): string {
+    return `Blog header image about "${title}" for a web accessibility article. Minimal Precisionism style inspired by Charles Sheeler: clean geometric shapes, sharp focus, smooth surfaces, no people. IMPORTANT: absolutely no text, no letters, no words, no typography, no labels, no captions anywhere in the image.`;
+  }
+
+  private generateAlt(title: string): string {
+    return `Illustration zum Thema ${title} - Barrierefreiheit im Web`;
+  }
+
+  private async generateSeoFilename(title: string): Promise<string> {
+    const model = this.textClient.getGenerativeModel({
+      model: 'gemini-2.0-flash',
+    });
+
+    const prompt = `Generate a single SEO-optimized filename for an image about web accessibility article titled "${title}".
+Requirements:
+- German and English keywords mixed
+- Lowercase, words separated by hyphens
+- Max 5-6 words
+- No file extension
+- Focus on: barrierefreiheit, accessibility, web, and the topic
+- Return ONLY the filename, nothing else
+
+Example for topic "Forms": barrierefreiheit-formulare-accessible-forms`;
+
+    try {
+      const result = await model.generateContent(prompt);
+      const filename = result.response
+        .text()
+        .trim()
+        .toLowerCase()
+        .replace(/[^a-z0-9-]/g, '');
+      return filename || Slug.generate(`barrierefreiheit-${title}`);
+    } catch {
+      return Slug.generate(`barrierefreiheit-${title}-accessibility`);
+    }
+  }
+}

package/src/services/PromptService.ts

@@ -0,0 +1,84 @@
+import { db, Prompts, SiteSettings, eq } from 'astro:db';
+
+export interface CTAConfig {
+  url: string;
+  style: string;
+  prompt: string;
+}
+
+export class PromptService {
+  async getPrompt(id: string): Promise<string | null> {
+    const result = await db
+      .select()
+      .from(Prompts)
+      .where(eq(Prompts.id, id))
+      .get();
+    return result?.promptText ?? null;
+  }
+
+  async updatePrompt(id: string, text: string): Promise<void> {
+    await db
+      .update(Prompts)
+      .set({ promptText: text, updatedAt: new Date() })
+      .where(eq(Prompts.id, id));
+  }
+
+  async getAllPrompts(): Promise<
+    Array<{
+      id: string;
+      name: string;
+      category: string;
+      promptText: string;
+    }>
+  > {
+    return await db.select().from(Prompts);
+  }
+
+  async getSetting(key: string): Promise<string | null> {
+    const result = await db
+      .select()
+      .from(SiteSettings)
+      .where(eq(SiteSettings.key, key))
+      .get();
+    return result?.value ?? null;
+  }
+
+  async updateSetting(key: string, value: string): Promise<void> {
+    await db
+      .update(SiteSettings)
+      .set({ value, updatedAt: new Date() })
+      .where(eq(SiteSettings.key, key));
+  }
+
+  async getAllSettings(): Promise<Array<{ key: string; value: string }>> {
+    return await db.select().from(SiteSettings);
+  }
+
+  async getCTAConfig(): Promise<CTAConfig> {
+    const [url, style, prompt] = await Promise.all([
+      this.getSetting('cta_url'),
+      this.getSetting('cta_style'),
+      this.getPrompt('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.',
+    };
+  }
+
+  async getCoreTags(): Promise<string[]> {
+    const tags = await this.getSetting('core_tags');
+    if (!tags) return ['Semantik', 'HTML', 'Barrierefrei'];
+    try {
+      return JSON.parse(tags);
+    } catch {
+      return ['Semantik', 'HTML', 'Barrierefrei'];
+    }
+  }
+}