nca-ai-cms-astro-plugin 1.0.0

package/src/domain/entities/Source.ts

@@ -0,0 +1,43 @@
+export class Source {
+  readonly url: string;
+  readonly domain: string;
+
+  constructor(url: string) {
+    if (!Source.isValidUrl(url)) {
+      throw new Error(`Invalid URL: ${url}`);
+    }
+
+    if (!url.startsWith('https://')) {
+      throw new Error('Only HTTPS URLs are allowed');
+    }
+
+    this.url = url;
+    this.domain = Source.extractDomain(url);
+  }
+
+  static isValidUrl(url: string): boolean {
+    try {
+      new URL(url);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static extractDomain(url: string): string {
+    const parsed = new URL(url);
+    return parsed.hostname;
+  }
+
+  isMDN(): boolean {
+    return this.domain === 'developer.mozilla.org';
+  }
+
+  isW3C(): boolean {
+    return this.domain.includes('w3.org');
+  }
+
+  toString(): string {
+    return this.url;
+  }
+}

package/src/domain/entities/index.ts

@@ -0,0 +1,9 @@
+export { Article, type ArticleProps } from './Article';
+export { Source } from './Source';
+export {
+  ScheduledPost,
+  type ScheduledPostStatus,
+  type ScheduledPostInputType,
+  type ScheduledPostProps,
+  type ScheduledPostDBRow,
+} from './ScheduledPost';

package/src/domain/index.ts

@@ -0,0 +1,16 @@
+export {
+  Slug,
+  SEOMetadata,
+  ArticleFinder,
+  type ArticleLocation,
+} from './value-objects';
+export {
+  Article,
+  type ArticleProps,
+  Source,
+  ScheduledPost,
+  type ScheduledPostStatus,
+  type ScheduledPostInputType,
+  type ScheduledPostProps,
+  type ScheduledPostDBRow,
+} from './entities';

package/src/domain/value-objects/ArticleFinder.test.ts

@@ -0,0 +1,104 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { ArticleFinder } from './ArticleFinder';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+
+describe('ArticleFinder', () => {
+  let tempDir: string;
+  let finder: ArticleFinder;
+
+  beforeEach(async () => {
+    tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'article-finder-test-'));
+    finder = new ArticleFinder(tempDir);
+  });
+
+  afterEach(async () => {
+    await fs.rm(tempDir, { recursive: true, force: true });
+  });
+
+  describe('findBySlug', () => {
+    it('finds article folder by slug', async () => {
+      // Setup: create article folder structure
+      const articleFolder = path.join(tempDir, '2026', '01', 'my-article-slug');
+      await fs.mkdir(articleFolder, { recursive: true });
+      await fs.writeFile(
+        path.join(articleFolder, 'index.md'),
+        '---\ntitle: Test\n---\nContent'
+      );
+
+      const result = await finder.findBySlug('my-article-slug');
+
+      expect(result).not.toBeNull();
+      expect(result?.folderPath).toBe(articleFolder);
+      expect(result?.indexPath).toBe(path.join(articleFolder, 'index.md'));
+    });
+
+    it('returns null for non-existent slug', async () => {
+      const result = await finder.findBySlug('does-not-exist');
+      expect(result).toBeNull();
+    });
+
+    it('finds article in any year/month folder', async () => {
+      // Create article in different year/month
+      const articleFolder = path.join(tempDir, '2025', '06', 'summer-article');
+      await fs.mkdir(articleFolder, { recursive: true });
+      await fs.writeFile(
+        path.join(articleFolder, 'index.md'),
+        '---\ntitle: Summer\n---'
+      );
+
+      const result = await finder.findBySlug('summer-article');
+
+      expect(result).not.toBeNull();
+      expect(result?.folderPath).toBe(articleFolder);
+    });
+
+    it('returns first match when multiple articles have similar slugs', async () => {
+      // Create two articles with similar names
+      const folder1 = path.join(tempDir, '2026', '01', 'test-article');
+      const folder2 = path.join(tempDir, '2025', '12', 'test-article');
+      await fs.mkdir(folder1, { recursive: true });
+      await fs.mkdir(folder2, { recursive: true });
+      await fs.writeFile(
+        path.join(folder1, 'index.md'),
+        '---\ntitle: Test 1\n---'
+      );
+      await fs.writeFile(
+        path.join(folder2, 'index.md'),
+        '---\ntitle: Test 2\n---'
+      );
+
+      const result = await finder.findBySlug('test-article');
+
+      expect(result).not.toBeNull();
+      // Should find one of them (order depends on filesystem)
+      expect(result?.folderPath).toContain('test-article');
+    });
+
+    it('ignores folders without index.md', async () => {
+      // Create folder without index.md
+      const emptyFolder = path.join(tempDir, '2026', '01', 'empty-folder');
+      await fs.mkdir(emptyFolder, { recursive: true });
+
+      const result = await finder.findBySlug('empty-folder');
+
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('getArticlePath', () => {
+    it('returns full article ID from folder path', async () => {
+      const articleFolder = path.join(tempDir, '2026', '01', 'test-slug');
+      await fs.mkdir(articleFolder, { recursive: true });
+      await fs.writeFile(
+        path.join(articleFolder, 'index.md'),
+        '---\ntitle: Test\n---'
+      );
+
+      const result = await finder.findBySlug('test-slug');
+
+      expect(result?.articleId).toBe('2026/01/test-slug');
+    });
+  });
+});

package/src/domain/value-objects/ArticleFinder.ts

@@ -0,0 +1,61 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+
+export interface ArticleLocation {
+  folderPath: string;
+  indexPath: string;
+  articleId: string;
+}
+
+export class ArticleFinder {
+  constructor(private readonly basePath: string) {}
+
+  async findBySlug(slug: string): Promise<ArticleLocation | null> {
+    try {
+      const years = await this.getDirectories(this.basePath);
+
+      for (const year of years) {
+        const yearPath = path.join(this.basePath, year);
+        const months = await this.getDirectories(yearPath);
+
+        for (const month of months) {
+          const monthPath = path.join(yearPath, month);
+          const articles = await this.getDirectories(monthPath);
+
+          for (const article of articles) {
+            if (article === slug) {
+              const folderPath = path.join(monthPath, article);
+              const indexPath = path.join(folderPath, 'index.md');
+
+              // Verify index.md exists
+              try {
+                await fs.access(indexPath);
+                return {
+                  folderPath,
+                  indexPath,
+                  articleId: `${year}/${month}/${article}`,
+                };
+              } catch {
+                // index.md doesn't exist, skip this folder
+                continue;
+              }
+            }
+          }
+        }
+      }
+
+      return null;
+    } catch {
+      return null;
+    }
+  }
+
+  private async getDirectories(dirPath: string): Promise<string[]> {
+    try {
+      const entries = await fs.readdir(dirPath, { withFileTypes: true });
+      return entries.filter((e) => e.isDirectory()).map((e) => e.name);
+    } catch {
+      return [];
+    }
+  }
+}

package/src/domain/value-objects/SEOMetadata.test.ts

@@ -0,0 +1,48 @@
+import { describe, it, expect } from 'vitest';
+import { SEOMetadata } from './SEOMetadata';
+
+describe('SEOMetadata', () => {
+  it('creates valid metadata', () => {
+    const meta = new SEOMetadata('Test Title', 'Test description');
+    expect(meta.title).toBe('Test Title');
+    expect(meta.description).toBe('Test description');
+  });
+
+  it('truncates title over 60 characters with ellipsis', () => {
+    const longTitle = 'A'.repeat(70);
+    const meta = new SEOMetadata(longTitle, 'desc');
+    expect(meta.title.length).toBe(60);
+    expect(meta.title.endsWith('...')).toBe(true);
+  });
+
+  it('truncates description over 155 characters with ellipsis', () => {
+    const longDesc = 'A'.repeat(200);
+    const meta = new SEOMetadata('title', longDesc);
+    expect(meta.description.length).toBe(155);
+    expect(meta.description.endsWith('...')).toBe(true);
+  });
+
+  it('accepts exactly 60 character title', () => {
+    const title = 'A'.repeat(60);
+    const meta = new SEOMetadata(title, 'desc');
+    expect(meta.title.length).toBe(60);
+    expect(meta.title).not.toContain('...');
+  });
+
+  it('accepts exactly 155 character description', () => {
+    const desc = 'A'.repeat(155);
+    const meta = new SEOMetadata('title', desc);
+    expect(meta.description.length).toBe(155);
+    expect(meta.description).not.toContain('...');
+  });
+
+  it('preserves short title without modification', () => {
+    const meta = new SEOMetadata('Short', 'desc');
+    expect(meta.title).toBe('Short');
+  });
+
+  it('preserves short description without modification', () => {
+    const meta = new SEOMetadata('title', 'Short');
+    expect(meta.description).toBe('Short');
+  });
+});

package/src/domain/value-objects/SEOMetadata.ts

@@ -0,0 +1,19 @@
+export class SEOMetadata {
+  readonly title: string;
+  readonly description: string;
+
+  static readonly MAX_TITLE_LENGTH = 60;
+  static readonly MAX_DESCRIPTION_LENGTH = 155;
+
+  constructor(title: string, description: string) {
+    this.title =
+      title.length > SEOMetadata.MAX_TITLE_LENGTH
+        ? title.slice(0, SEOMetadata.MAX_TITLE_LENGTH - 3) + '...'
+        : title;
+
+    this.description =
+      description.length > SEOMetadata.MAX_DESCRIPTION_LENGTH
+        ? description.slice(0, SEOMetadata.MAX_DESCRIPTION_LENGTH - 3) + '...'
+        : description;
+  }
+}

package/src/domain/value-objects/Slug.test.ts

@@ -0,0 +1,51 @@
+import { describe, it, expect } from 'vitest';
+import { Slug } from './Slug';
+
+describe('Slug', () => {
+  it('generates lowercase slug from title', () => {
+    const slug = new Slug('HTML Accessibility');
+    expect(slug.toString()).toBe('html-accessibility');
+  });
+
+  it('handles German umlauts', () => {
+    const slug = new Slug('Barrierefreiheit für Anfänger');
+    expect(slug.toString()).toBe('barrierefreiheit-fuer-anfaenger');
+  });
+
+  it('handles special characters', () => {
+    const slug = new Slug('Forms & Inputs: A Guide!');
+    expect(slug.toString()).toBe('forms-inputs-a-guide');
+  });
+
+  it('removes multiple consecutive hyphens', () => {
+    const slug = new Slug('Test   Multiple   Spaces');
+    expect(slug.toString()).toBe('test-multiple-spaces');
+  });
+
+  it('trims hyphens from start and end', () => {
+    const slug = new Slug('---Title---');
+    expect(slug.toString()).toBe('title');
+  });
+
+  it('handles German ß correctly', () => {
+    const slug = new Slug('Größe und Maße');
+    expect(slug.toString()).toBe('groesse-und-masse');
+  });
+
+  it('compares slugs for equality', () => {
+    const slug1 = new Slug('Test Title');
+    const slug2 = new Slug('test-title');
+    expect(slug1.equals(slug2)).toBe(true);
+  });
+
+  it('returns false for unequal slugs', () => {
+    const slug1 = new Slug('First Title');
+    const slug2 = new Slug('Second Title');
+    expect(slug1.equals(slug2)).toBe(false);
+  });
+
+  it('handles NFD normalization for accented characters', () => {
+    const slug = new Slug('Café Résumé');
+    expect(slug.toString()).toBe('cafe-resume');
+  });
+});

package/src/domain/value-objects/Slug.ts

@@ -0,0 +1,33 @@
+export class Slug {
+  private readonly value: string;
+
+  constructor(input: string) {
+    this.value = Slug.generate(input);
+  }
+
+  static generate(input: string): string {
+    return (
+      input
+        .toLowerCase()
+        // Handle German special characters BEFORE normalization
+        .replace(/ä/g, 'ae')
+        .replace(/ö/g, 'oe')
+        .replace(/ü/g, 'ue')
+        .replace(/ß/g, 'ss')
+        // Now normalize and remove remaining diacritics
+        .normalize('NFD')
+        .replace(/[\u0300-\u036f]/g, '')
+        .replace(/[^a-z0-9]+/g, '-') // Replace non-alphanumeric with hyphens
+        .replace(/^-+|-+$/g, '') // Trim hyphens from start/end
+        .replace(/-+/g, '-')
+    ); // Replace multiple hyphens with single
+  }
+
+  toString(): string {
+    return this.value;
+  }
+
+  equals(other: Slug): boolean {
+    return this.value === other.value;
+  }
+}

package/src/domain/value-objects/index.ts

@@ -0,0 +1,4 @@
+export { Slug } from './Slug';
+export { SEOMetadata } from './SEOMetadata';
+export { ArticleFinder } from './ArticleFinder';
+export type { ArticleLocation } from './ArticleFinder';

package/src/index.ts

@@ -0,0 +1,146 @@
+import type { AstroIntegration } from 'astro';
+import { SiteSettings, Prompts, ScheduledPosts } from './db/tables.js';
+
+export interface NcaAiCmsPluginOptions {
+  contentPath?: string;
+  autoPublish?: boolean;
+}
+
+export default function ncaAiCms(
+  options: NcaAiCmsPluginOptions = {}
+): AstroIntegration {
+  const contentPath = options.contentPath ?? 'nca-ai-cms-content';
+  const autoPublish = options.autoPublish ?? process.env.NODE_ENV === 'production';
+
+  return {
+    name: 'nca-ai-cms-astro-plugin',
+    hooks: {
+      'astro:db:setup'({ extendDb }: { extendDb: (config: { tables: Record<string, unknown> }) => void }) {
+        extendDb({
+          tables: { SiteSettings, Prompts, ScheduledPosts },
+        });
+      },
+
+      'astro:config:setup'({ injectRoute, updateConfig, addMiddleware }) {
+        addMiddleware({
+          entrypoint: 'nca-ai-cms-astro-plugin/middleware.ts',
+          order: 'pre',
+        });
+
+        // Virtual module for config sharing
+        updateConfig({
+          vite: {
+            plugins: [
+              {
+                name: 'nca-ai-cms-virtual-config',
+                resolveId(id) {
+                  if (id === 'virtual:nca-ai-cms/config') {
+                    return '\0virtual:nca-ai-cms/config';
+                  }
+                },
+                load(id) {
+                  if (id === '\0virtual:nca-ai-cms/config') {
+                    return `export const contentPath = ${JSON.stringify(contentPath)};\nexport const autoPublish = ${JSON.stringify(autoPublish)};`;
+                  }
+                },
+              },
+            ],
+          },
+        });
+
+        // Inject API routes
+        injectRoute({
+          pattern: '/api/generate-content',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/generate-content.ts',
+        });
+        injectRoute({
+          pattern: '/api/generate-image',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/generate-image.ts',
+        });
+        injectRoute({
+          pattern: '/api/save',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/save.ts',
+        });
+        injectRoute({
+          pattern: '/api/save-image',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/save-image.ts',
+        });
+        injectRoute({
+          pattern: '/api/prompts',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/prompts.ts',
+        });
+        injectRoute({
+          pattern: '/api/scheduler',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/scheduler.ts',
+        });
+        injectRoute({
+          pattern: '/api/scheduler/generate',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/scheduler/generate.ts',
+        });
+        injectRoute({
+          pattern: '/api/scheduler/publish',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/scheduler/publish.ts',
+        });
+        injectRoute({
+          pattern: '/api/scheduler/[id]',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/scheduler/[id].ts',
+        });
+        injectRoute({
+          pattern: '/api/articles/[id]',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/articles/[id].ts',
+        });
+        injectRoute({
+          pattern: '/api/articles/[id]/apply',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/articles/[id]/apply.ts',
+        });
+        injectRoute({
+          pattern: '/api/articles/[id]/regenerate-text',
+          entrypoint:
+            'nca-ai-cms-astro-plugin/api/articles/[id]/regenerate-text.ts',
+        });
+        injectRoute({
+          pattern: '/api/articles/[id]/regenerate-image',
+          entrypoint:
+            'nca-ai-cms-astro-plugin/api/articles/[id]/regenerate-image.ts',
+        });
+
+        // Inject auth routes
+        injectRoute({
+          pattern: '/api/auth/login',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/auth/login.ts',
+        });
+        injectRoute({
+          pattern: '/api/auth/logout',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/auth/logout.ts',
+        });
+        injectRoute({
+          pattern: '/api/auth/check',
+          entrypoint: 'nca-ai-cms-astro-plugin/api/auth/check.ts',
+        });
+
+        // Inject pages
+        injectRoute({
+          pattern: '/login',
+          entrypoint: 'nca-ai-cms-astro-plugin/pages/login.astro',
+        });
+        injectRoute({
+          pattern: '/editor',
+          entrypoint: 'nca-ai-cms-astro-plugin/pages/editor.astro',
+        });
+      },
+
+      'astro:server:start'() {
+        if (autoPublish) {
+          import('./services/AutoPublisher.js').then(
+            ({ startAutoPublisher }) => {
+              startAutoPublisher(contentPath);
+            }
+          ).catch((err) => {
+            console.error('[nca-ai-cms] AutoPublisher failed to start:', err);
+          });
+        }
+      },
+    },
+  };
+}
+

package/src/middleware.ts

@@ -0,0 +1,30 @@
+import { defineMiddleware } from 'astro:middleware';
+import { isPublicPath, isProtectedPath, isAuthenticated } from './utils/authUtils.js';
+
+export const onRequest = defineMiddleware(async ({ request, cookies, redirect }, next) => {
+  const url = new URL(request.url);
+  const { pathname } = url;
+
+  if (isPublicPath(pathname)) {
+    return next();
+  }
+
+  if (!isProtectedPath(pathname)) {
+    return next();
+  }
+
+  const authCookie = cookies.get('editor-auth')?.value;
+
+  if (isAuthenticated(authCookie)) {
+    return next();
+  }
+
+  if (pathname.startsWith('/api/')) {
+    return new Response(JSON.stringify({ error: 'Unauthorized' }), {
+      status: 401,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  return redirect('/login', 302);
+});

package/src/pages/editor.astro

@@ -0,0 +1,22 @@
+---
+import Editor from '../components/Editor';
+---
+<html lang="de">
+<head>
+  <meta charset="UTF-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+  <title>Content Editor</title>
+  <style>
+    body { margin: 0; padding: 2rem; background: var(--color-bg, #0a0a0b); color: var(--color-text, #faf9f7); font-family: system-ui, sans-serif; }
+    .container { max-width: 1400px; margin: 0 auto; }
+    h1 { font-size: 2rem; margin-bottom: 2rem; }
+    @keyframes spin { to { transform: rotate(360deg); } }
+  </style>
+</head>
+<body>
+  <div class="container">
+    <h1>Content Editor</h1>
+    <Editor client:load />
+  </div>
+</body>
+</html>