npm - nca-ai-cms-astro-plugin - Versions diffs - 1.0.0 - Mend

nca-ai-cms-astro-plugin 1.0.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (73) hide show

package/.claude/settings.local.json +9 -0
package/README.md +87 -0
package/package.json +53 -0
package/src/api/_utils.ts +20 -0
package/src/api/articles/[id]/apply.ts +89 -0
package/src/api/articles/[id]/regenerate-image.ts +49 -0
package/src/api/articles/[id]/regenerate-text.ts +57 -0
package/src/api/articles/[id].ts +53 -0
package/src/api/auth/check.ts +6 -0
package/src/api/auth/login.ts +43 -0
package/src/api/auth/logout.ts +6 -0
package/src/api/generate-content.ts +43 -0
package/src/api/generate-image.ts +33 -0
package/src/api/prompts.ts +45 -0
package/src/api/save-image.ts +38 -0
package/src/api/save.ts +49 -0
package/src/api/scheduler/[id].ts +31 -0
package/src/api/scheduler/generate.ts +94 -0
package/src/api/scheduler/publish.ts +96 -0
package/src/api/scheduler.ts +51 -0
package/src/components/Editor.tsx +115 -0
package/src/components/editor/GenerateTab.tsx +384 -0
package/src/components/editor/PlannerTab.tsx +345 -0
package/src/components/editor/SettingsTab.tsx +185 -0
package/src/components/editor/styles.ts +597 -0
package/src/components/editor/types.ts +49 -0
package/src/components/editor/useTabNavigation.ts +69 -0
package/src/config.d.ts +4 -0
package/src/db/tables.ts +39 -0
package/src/domain/entities/Article.test.ts +138 -0
package/src/domain/entities/Article.ts +90 -0
package/src/domain/entities/ScheduledPost.test.ts +228 -0
package/src/domain/entities/ScheduledPost.ts +152 -0
package/src/domain/entities/Source.test.ts +57 -0
package/src/domain/entities/Source.ts +43 -0
package/src/domain/entities/index.ts +9 -0
package/src/domain/index.ts +16 -0
package/src/domain/value-objects/ArticleFinder.test.ts +104 -0
package/src/domain/value-objects/ArticleFinder.ts +61 -0
package/src/domain/value-objects/SEOMetadata.test.ts +48 -0
package/src/domain/value-objects/SEOMetadata.ts +19 -0
package/src/domain/value-objects/Slug.test.ts +51 -0
package/src/domain/value-objects/Slug.ts +33 -0
package/src/domain/value-objects/index.ts +4 -0
package/src/index.ts +146 -0
package/src/middleware.ts +30 -0
package/src/pages/editor.astro +22 -0
package/src/pages/login.astro +117 -0
package/src/services/ArticleService.test.ts +148 -0
package/src/services/ArticleService.ts +150 -0
package/src/services/AutoPublisher.ts +122 -0
package/src/services/ContentFetcher.ts +89 -0
package/src/services/ContentGenerator.ts +320 -0
package/src/services/FileWriter.test.ts +80 -0
package/src/services/FileWriter.ts +59 -0
package/src/services/ImageConverter.ts +15 -0
package/src/services/ImageGenerator.ts +108 -0
package/src/services/PromptService.ts +84 -0
package/src/services/SchedulerDBAdapter.ts +75 -0
package/src/services/SchedulerService.test.ts +286 -0
package/src/services/SchedulerService.ts +149 -0
package/src/services/index.ts +27 -0
package/src/utils/authUtils.test.ts +60 -0
package/src/utils/authUtils.ts +25 -0
package/src/utils/envUtils.test.ts +40 -0
package/src/utils/envUtils.ts +26 -0
package/src/utils/index.ts +7 -0
package/src/utils/markdown.test.ts +65 -0
package/src/utils/markdown.ts +13 -0
package/src/utils/sanitize.test.ts +180 -0
package/src/utils/sanitize.ts +98 -0
package/tsconfig.json +22 -0
package/vitest.config.ts +14 -0

package/src/pages/login.astro ADDED Viewed

@@ -0,0 +1,117 @@
+---
+const authCookie = Astro.cookies.get('editor-auth')?.value;
+if (authCookie) {
+  return Astro.redirect('/editor', 302);
+}
+---
+<html lang="de">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Login - Content Editor</title>
+  <style>
+    * { box-sizing: border-box; margin: 0; padding: 0; }
+    body {
+      background: #0a0a0b;
+      color: #faf9f7;
+      font-family: system-ui, sans-serif;
+      display: flex;
+      align-items: center;
+      justify-content: center;
+      min-height: 100vh;
+    }
+    .login-card {
+      background: #1a1a1d;
+      border: 1px solid #2a2a2d;
+      border-radius: 12px;
+      padding: 2.5rem;
+      width: 100%;
+      max-width: 400px;
+    }
+    h1 { font-size: 1.5rem; margin-bottom: 1.5rem; text-align: center; }
+    label { display: block; margin-bottom: 0.5rem; font-size: 0.875rem; color: #aaa; }
+    input {
+      width: 100%;
+      padding: 0.75rem;
+      margin-bottom: 1rem;
+      background: #0a0a0b;
+      border: 1px solid #333;
+      border-radius: 6px;
+      color: #faf9f7;
+      font-size: 1rem;
+    }
+    input:focus { outline: none; border-color: #666; }
+    button {
+      width: 100%;
+      padding: 0.75rem;
+      background: #faf9f7;
+      color: #0a0a0b;
+      border: none;
+      border-radius: 6px;
+      font-size: 1rem;
+      font-weight: 600;
+      cursor: pointer;
+    }
+    button:hover { background: #e0e0e0; }
+    button:disabled { opacity: 0.5; cursor: not-allowed; }
+    .error {
+      background: #3a1a1a;
+      border: 1px solid #662222;
+      color: #ff6b6b;
+      padding: 0.75rem;
+      border-radius: 6px;
+      margin-bottom: 1rem;
+      font-size: 0.875rem;
+      display: none;
+    }
+  </style>
+</head>
+<body>
+  <div class="login-card">
+    <h1>Content Editor</h1>
+    <div id="error" class="error"></div>
+    <form id="login-form">
+      <label for="username">Benutzername</label>
+      <input type="text" id="username" name="username" required autocomplete="username" />
+      <label for="password">Passwort</label>
+      <input type="password" id="password" name="password" required autocomplete="current-password" />
+      <button type="submit">Anmelden</button>
+    </form>
+  </div>
+  <script>
+    const form = document.getElementById('login-form') as HTMLFormElement;
+    const errorEl = document.getElementById('error') as HTMLDivElement;
+    form.addEventListener('submit', async (e) => {
+      e.preventDefault();
+      errorEl.style.display = 'none';
+      const username = (document.getElementById('username') as HTMLInputElement).value;
+      const password = (document.getElementById('password') as HTMLInputElement).value;
+      const button = form.querySelector('button') as HTMLButtonElement;
+      button.disabled = true;
+      try {
+        const res = await fetch('/api/auth/login', {
+          method: 'POST',
+          headers: { 'Content-Type': 'application/json' },
+          body: JSON.stringify({ username, password }),
+        });
+        if (res.ok) {
+          window.location.href = '/editor';
+        } else {
+          const data = await res.json();
+          errorEl.textContent = data.error || 'Anmeldung fehlgeschlagen';
+          errorEl.style.display = 'block';
+        }
+      } catch {
+        errorEl.textContent = 'Netzwerkfehler';
+        errorEl.style.display = 'block';
+      } finally {
+        button.disabled = false;
+      }
+    });
+  </script>
+</body>
+</html>

package/src/services/ArticleService.test.ts ADDED Viewed

@@ -0,0 +1,148 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ArticleService, ArticleNotFoundError } from './ArticleService';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+describe('ArticleService', () => {
+  let tempDir: string;
+  let service: ArticleService;
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'article-service-test-'));
+    service = new ArticleService(tempDir);
+  });
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+  async function createTestArticle(
+    slug: string,
+    year = '2026',
+    month = '01'
+  ): Promise<string> {
+    const folderPath = path.join(tempDir, year, month, slug);
+    await fs.mkdir(folderPath, { recursive: true });
+    await fs.writeFile(
+      path.join(folderPath, 'index.md'),
+      `---
+title: "Test Article"
+description: "Test description"
+date: "${year}-${month}-15"
+tags: ["Test"]
+image: "./hero.webp"
+imageAlt: "Test image"
+---
+# Test Article
+Content here.
+`
+    );
+    // Create a dummy image file
+    await fs.writeFile(path.join(folderPath, 'hero.webp'), 'fake-image-data');
+    return folderPath;
+  }
+  describe('delete', () => {
+    it('removes article folder recursively', async () => {
+      const folderPath = await createTestArticle('test-article');
+      // Verify folder exists
+      const existsBefore = await fs
+        .access(folderPath)
+        .then(() => true)
+        .catch(() => false);
+      expect(existsBefore).toBe(true);
+      await service.delete('test-article');
+      // Verify folder no longer exists
+      const existsAfter = await fs
+        .access(folderPath)
+        .then(() => true)
+        .catch(() => false);
+      expect(existsAfter).toBe(false);
+    });
+    it('throws ArticleNotFoundError for invalid slug', async () => {
+      await expect(service.delete('non-existent-article')).rejects.toThrow(
+        ArticleNotFoundError
+      );
+    });
+    it('removes both index.md and hero.webp', async () => {
+      const folderPath = await createTestArticle('full-article');
+      await service.delete('full-article');
+      // Article folder should no longer exist
+      const articleExists = await fs
+        .access(folderPath)
+        .then(() => true)
+        .catch(() => false);
+      expect(articleExists).toBe(false);
+    });
+  });
+  describe('read', () => {
+    it('reads article metadata from frontmatter', async () => {
+      await createTestArticle('readable-article');
+      const article = await service.read('readable-article');
+      expect(article).not.toBeNull();
+      expect(article?.title).toBe('Test Article');
+      expect(article?.description).toBe('Test description');
+      expect(article?.tags).toContain('Test');
+    });
+    it('returns null for non-existent article', async () => {
+      const article = await service.read('does-not-exist');
+      expect(article).toBeNull();
+    });
+    it('includes article ID in result', async () => {
+      await createTestArticle('id-test', '2025', '06');
+      const article = await service.read('id-test');
+      expect(article?.articleId).toBe('2025/06/id-test');
+    });
+  });
+  describe('updateContent', () => {
+    it('updates article content preserving frontmatter fields', async () => {
+      await createTestArticle('update-test');
+      await service.updateContent('update-test', {
+        content: '# Updated Title\n\nNew content here.',
+      });
+      const article = await service.read('update-test');
+      expect(article?.title).toBe('Test Article'); // Title preserved
+      expect(article?.content).toContain('New content here.');
+    });
+    it('can update title and description', async () => {
+      await createTestArticle('metadata-update');
+      await service.updateContent('metadata-update', {
+        title: 'New Title',
+        description: 'New description',
+        content: '# New Title\n\nContent.',
+      });
+      const article = await service.read('metadata-update');
+      expect(article?.title).toBe('New Title');
+      expect(article?.description).toBe('New description');
+    });
+    it('throws ArticleNotFoundError for invalid slug', async () => {
+      await expect(
+        service.updateContent('invalid', { content: 'test' })
+      ).rejects.toThrow(ArticleNotFoundError);
+    });
+  });
+});

package/src/services/ArticleService.ts ADDED Viewed

@@ -0,0 +1,150 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import matter from 'gray-matter';
+import { ArticleFinder } from '../domain/value-objects/ArticleFinder';
+export class ArticleNotFoundError extends Error {
+  constructor(slug: string) {
+    super(`Article not found: ${slug}`);
+    this.name = 'ArticleNotFoundError';
+  }
+}
+export interface ArticleData {
+  articleId: string;
+  title: string;
+  description: string;
+  date: Date;
+  createdAt?: Date;
+  tags: string[];
+  image?: string;
+  imageAlt?: string;
+  content: string;
+  folderPath: string;
+}
+export interface UpdateContentOptions {
+  title?: string;
+  description?: string;
+  content?: string;
+}
+export class ArticleService {
+  private readonly finder: ArticleFinder;
+  private readonly basePath: string;
+  constructor(basePath: string = 'nca-ai-cms-content') {
+    this.finder = new ArticleFinder(basePath);
+    this.basePath = basePath;
+  }
+  async list(): Promise<ArticleData[]> {
+    const articles: ArticleData[] = [];
+    const fullBasePath = path.join(process.cwd(), this.basePath);
+    try {
+      const years = await fs.readdir(fullBasePath);
+      for (const year of years) {
+        const yearPath = path.join(fullBasePath, year);
+        const yearStat = await fs.stat(yearPath).catch(() => null);
+        if (!yearStat?.isDirectory()) continue;
+        const months = await fs.readdir(yearPath);
+        for (const month of months) {
+          const monthPath = path.join(yearPath, month);
+          const monthStat = await fs.stat(monthPath).catch(() => null);
+          if (!monthStat?.isDirectory()) continue;
+          const slugs = await fs.readdir(monthPath);
+          for (const slug of slugs) {
+            const slugPath = path.join(monthPath, slug);
+            const slugStat = await fs.stat(slugPath).catch(() => null);
+            if (!slugStat?.isDirectory()) continue;
+            const article = await this.read(slug);
+            if (article) articles.push(article);
+          }
+        }
+      }
+    } catch {
+      // Return empty array if base path doesn't exist
+    }
+    return articles;
+  }
+  async delete(slug: string): Promise<void> {
+    const location = await this.finder.findBySlug(slug);
+    if (!location) {
+      throw new ArticleNotFoundError(slug);
+    }
+    await fs.rm(location.folderPath, { recursive: true, force: true });
+  }
+  async read(slug: string): Promise<ArticleData | null> {
+    const location = await this.finder.findBySlug(slug);
+    if (!location) {
+      return null;
+    }
+    try {
+      const fileContent = await fs.readFile(location.indexPath, 'utf-8');
+      const { data, content } = matter(fileContent);
+      const result: ArticleData = {
+        articleId: location.articleId,
+        title: data.title,
+        description: data.description,
+        date: new Date(data.date),
+        tags: data.tags || [],
+        image: data.image,
+        imageAlt: data.imageAlt,
+        content: content.trim(),
+        folderPath: location.folderPath,
+      };
+      if (data.createdAt) {
+        result.createdAt = new Date(data.createdAt);
+      }
+      return result;
+    } catch {
+      return null;
+    }
+  }
+  async updateContent(
+    slug: string,
+    options: UpdateContentOptions
+  ): Promise<void> {
+    const location = await this.finder.findBySlug(slug);
+    if (!location) {
+      throw new ArticleNotFoundError(slug);
+    }
+    const fileContent = await fs.readFile(location.indexPath, 'utf-8');
+    const { data, content } = matter(fileContent);
+    // Update frontmatter fields if provided
+    const updatedData = {
+      ...data,
+      ...(options.title && { title: options.title }),
+      ...(options.description && { description: options.description }),
+    };
+    // Use new content or keep existing
+    const updatedContent = options.content ?? content;
+    // Rebuild the file with frontmatter
+    const newFileContent = matter.stringify(updatedContent, updatedData);
+    await fs.writeFile(location.indexPath, newFileContent, 'utf-8');
+  }
+}

package/src/services/AutoPublisher.ts ADDED Viewed

@@ -0,0 +1,122 @@
+import { SchedulerService } from './SchedulerService';
+import { AstroSchedulerDBAdapter } from './SchedulerDBAdapter';
+import { Article } from '../domain/entities/Article';
+import { FileWriter } from './FileWriter';
+import { convertToWebP } from './ImageConverter';
+import * as path from 'path';
+const INTERVAL_MS = 60 * 60 * 1000; // 60 minutes
+let intervalId: ReturnType<typeof setInterval> | null = null;
+let isRunning = false;
+async function publishDuePosts(
+  contentPath: string = 'nca-ai-cms-content'
+): Promise<void> {
+  if (isRunning) return;
+  isRunning = true;
+  try {
+    const service = new SchedulerService(new AstroSchedulerDBAdapter());
+    const duePosts = await service.getDuePosts();
+    if (duePosts.length === 0) {
+      return;
+    }
+    console.log(`[AutoPublisher] Found ${duePosts.length} due post(s)`);
+    let published = 0;
+    let failed = 0;
+    for (const post of duePosts) {
+      try {
+        if (!post.generatedTitle || !post.generatedContent) {
+          console.warn(
+            `[AutoPublisher] Skipping ${post.id}: missing generated content`
+          );
+          failed++;
+          continue;
+        }
+        const articleProps = {
+          title: post.generatedTitle,
+          description: post.generatedDescription || '',
+          content: post.generatedContent,
+          date: post.scheduledDate,
+          tags: post.parsedTags,
+          image: './hero.webp',
+          contentPath,
+          ...(post.generatedImageAlt
+            ? { imageAlt: post.generatedImageAlt }
+            : {}),
+        };
+        const article = new Article(articleProps);
+        const writer = new FileWriter();
+        await writer.write(article);
+        if (post.generatedImageData) {
+          const imagePath = path.join(
+            process.cwd(),
+            article.folderPath,
+            'hero.webp'
+          );
+          await convertToWebP(post.generatedImageData, imagePath);
+        }
+        await service.markPublished(post.id, article.folderPath);
+        published++;
+        console.log(
+          `[AutoPublisher] Published ${post.id} -> ${article.folderPath}`
+        );
+      } catch (error) {
+        failed++;
+        console.error(
+          `[AutoPublisher] Failed to publish ${post.id}:`,
+          error
+        );
+      }
+    }
+    console.log(
+      `[AutoPublisher] Done: ${published} published, ${failed} failed`
+    );
+  } catch (error) {
+    console.error('[AutoPublisher] Error checking due posts:', error);
+  } finally {
+    isRunning = false;
+  }
+}
+let configuredContentPath = 'nca-ai-cms-content';
+export function startAutoPublisher(
+  contentPath: string = 'nca-ai-cms-content'
+): void {
+  if (intervalId) return;
+  configuredContentPath = contentPath;
+  console.log(
+    `[AutoPublisher] Starting (interval: ${INTERVAL_MS / 1000 / 60} minutes)`
+  );
+  // Run once on startup after a short delay to let the DB initialize
+  setTimeout(() => {
+    publishDuePosts(configuredContentPath);
+  }, 10_000);
+  intervalId = setInterval(
+    () => publishDuePosts(configuredContentPath),
+    INTERVAL_MS
+  );
+}
+export function stopAutoPublisher(): void {
+  if (intervalId) {
+    clearInterval(intervalId);
+    intervalId = null;
+    console.log('[AutoPublisher] Stopped');
+  }
+}

package/src/services/ContentFetcher.ts ADDED Viewed

@@ -0,0 +1,89 @@
+import TurndownService from 'turndown';
+import { Source } from '../domain/entities/Source';
+export type FetchedContent = {
+  title: string;
+  content: string;
+  url: string;
+};
+export class ContentFetcher {
+  private turndown: TurndownService;
+  constructor() {
+    this.turndown = new TurndownService({
+      headingStyle: 'atx',
+      codeBlockStyle: 'fenced',
+      bulletListMarker: '-',
+    });
+    // Remove unwanted elements
+    this.turndown.remove([
+      'script',
+      'style',
+      'nav',
+      'footer',
+      'aside',
+      'noscript',
+    ]);
+  }
+  async fetch(source: Source): Promise<FetchedContent> {
+    const response = await fetch(source.url, {
+      headers: {
+        'User-Agent':
+          'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36',
+        Accept:
+          'text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8',
+        'Accept-Language': 'de-DE,de;q=0.9,en;q=0.8',
+      },
+    });
+    if (!response.ok) {
+      throw new Error(`Failed to fetch ${source.url}: ${response.status}`);
+    }
+    const html = await response.text();
+    const title = this.extractTitle(html);
+    const content = this.htmlToMarkdown(html);
+    return {
+      title,
+      content,
+      url: source.url,
+    };
+  }
+  private extractTitle(html: string): string {
+    // Try og:title first, then title tag
+    const ogMatch = html.match(
+      /<meta[^>]*property="og:title"[^>]*content="([^"]+)"/i
+    );
+    if (ogMatch?.[1]) return ogMatch[1].trim();
+    const titleMatch = html.match(/<title[^>]*>([^<]+)<\/title>/i);
+    return titleMatch?.[1]?.trim() ?? 'Untitled';
+  }
+  private htmlToMarkdown(html: string): string {
+    // Extract main content area first
+    let content = html;
+    const mainMatch =
+      content.match(/<main[^>]*>([\s\S]*?)<\/main>/i) ||
+      content.match(/<article[^>]*>([\s\S]*?)<\/article>/i) ||
+      content.match(
+        /<div[^>]*class="[^"]*(?:content|article|post|entry)[^"]*"[^>]*>([\s\S]*?)<\/div>/i
+      );
+    if (mainMatch?.[1]) {
+      content = mainMatch[1];
+    }
+    // Convert to markdown using turndown
+    const markdown = this.turndown.turndown(content);
+    // Normalize whitespace
+    return markdown.replace(/\n{3,}/g, '\n\n').trim();
+  }
+}