nca-ai-cms-astro-plugin 1.0.0

package/src/api/save.ts

@@ -0,0 +1,49 @@
+import type { APIRoute } from 'astro';
+import { z } from 'zod';
+import { Article } from '../domain/entities/Article';
+import { FileWriter } from '../services/FileWriter';
+import { contentPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from './_utils';
+
+const SaveArticleSchema = z.object({
+  title: z.string().min(1),
+  description: z.string().min(1),
+  content: z.string().min(1),
+  date: z.string().optional(),
+  tags: z.array(z.string()).optional(),
+  imageAlt: z.string().optional(),
+});
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const body = await request.json();
+    const parsed = SaveArticleSchema.safeParse(body);
+    if (!parsed.success) {
+      return jsonError(parsed.error.errors[0]?.message ?? 'Invalid request', 400);
+    }
+    const data = parsed.data;
+
+    const article = new Article({
+      title: data.title,
+      description: data.description,
+      content: data.content,
+      date: new Date(data.date || Date.now()),
+      tags: data.tags || [],
+      image: './hero.webp',
+      imageAlt: data.imageAlt,
+      contentPath,
+    });
+
+    const writer = new FileWriter();
+    const result = await writer.write(article);
+
+    return jsonResponse({
+      success: true,
+      filepath: result.filepath,
+      folderPath: article.folderPath,
+    });
+  } catch (error) {
+    console.error('Save error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/scheduler/[id].ts

@@ -0,0 +1,31 @@
+import type { APIRoute } from 'astro';
+import { SchedulerService } from '../../services/SchedulerService';
+import { AstroSchedulerDBAdapter } from '../../services/SchedulerDBAdapter';
+import { jsonResponse, jsonError } from '../_utils';
+
+function getService(): SchedulerService {
+  return new SchedulerService(new AstroSchedulerDBAdapter());
+}
+
+export const DELETE: APIRoute = async ({ params }) => {
+  try {
+    const id = params.id;
+    if (!id) {
+      return jsonError('id is required', 400);
+    }
+
+    const service = getService();
+    await service.delete(id);
+
+    return jsonResponse({ success: true });
+  } catch (error) {
+    console.error('Scheduler delete error:', error);
+    const status =
+      error instanceof Error && error.message.includes('not found')
+        ? 404
+        : error instanceof Error && error.message.includes('Cannot delete')
+          ? 403
+          : 500;
+    return jsonError(error, status);
+  }
+};

package/src/api/scheduler/generate.ts

@@ -0,0 +1,94 @@
+import type { APIRoute } from 'astro';
+import { SchedulerService } from '../../services/SchedulerService';
+import { AstroSchedulerDBAdapter } from '../../services/SchedulerDBAdapter';
+import { ContentGenerator } from '../../services/ContentGenerator';
+import { ImageGenerator } from '../../services/ImageGenerator';
+import { PromptService } from '../../services/PromptService';
+import { getEnvVariable } from '../../utils/envUtils';
+import { jsonResponse, jsonError } from '../_utils';
+
+function getService(): SchedulerService {
+  return new SchedulerService(new AstroSchedulerDBAdapter());
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const { id, mode = 'all' } = await request.json();
+
+    if (!id) {
+      return jsonError('id is required', 400);
+    }
+
+    const service = getService();
+    const post = await service.getById(id);
+
+    if (!post.canGenerate()) {
+      return jsonError(
+        `Cannot generate: post is in status "${post.status}"`,
+        400
+      );
+    }
+
+    const apiKey = getEnvVariable('GOOGLE_GEMINI_API_KEY');
+
+    if (mode === 'text' || mode === 'all') {
+      const promptService = new PromptService();
+      const contentGenerator = new ContentGenerator({ apiKey, promptService });
+
+      const article =
+        post.inputType === 'url'
+          ? await contentGenerator.generateFromUrl(post.input)
+          : await contentGenerator.generateFromKeywords(post.input);
+
+      if (mode === 'text') {
+        await service.updateText(id, {
+          title: article.title,
+          description: article.description,
+          content: article.content,
+          tags: article.tags,
+        });
+      } else {
+        // mode === 'all': generate image too
+        let imageData: string | undefined;
+        let imageAlt: string | undefined;
+        try {
+          const imageGenerator = new ImageGenerator({ apiKey });
+          const image = await imageGenerator.generate(article.title);
+          imageData = image.base64;
+          imageAlt = image.alt;
+        } catch (error) {
+          console.warn(
+            'Image generation failed, continuing without image:',
+            error
+          );
+        }
+
+        await service.markGenerated(id, {
+          title: article.title,
+          description: article.description,
+          content: article.content,
+          tags: article.tags,
+          imageData,
+          imageAlt,
+        });
+      }
+    } else if (mode === 'image') {
+      // Use existing title or fallback to input
+      const title = post.generatedTitle || post.input;
+      const imageGenerator = new ImageGenerator({ apiKey });
+      const image = await imageGenerator.generate(title);
+
+      await service.updateImage(id, {
+        imageData: image.base64 || '',
+        imageAlt: image.alt,
+      });
+    }
+
+    const updated = await service.getById(id);
+
+    return jsonResponse({ post: updated });
+  } catch (error) {
+    console.error('Scheduler generate error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/scheduler/publish.ts

@@ -0,0 +1,96 @@
+import type { APIRoute } from 'astro';
+import { SchedulerService } from '../../services/SchedulerService';
+import { AstroSchedulerDBAdapter } from '../../services/SchedulerDBAdapter';
+import { Article } from '../../domain/entities/Article';
+import { FileWriter } from '../../services/FileWriter';
+import * as path from 'path';
+import { convertToWebP } from '../../services/ImageConverter';
+import { contentPath } from 'virtual:nca-ai-cms/config';
+import { jsonResponse, jsonError } from '../_utils';
+
+function getService(): SchedulerService {
+  return new SchedulerService(new AstroSchedulerDBAdapter());
+}
+
+async function publishPost(
+  service: SchedulerService,
+  postId: string
+): Promise<{ id: string; publishedPath: string }> {
+  const post = await service.getById(postId);
+
+  if (!post.canPublish()) {
+    throw new Error(`Cannot publish: post is in status "${post.status}"`);
+  }
+
+  if (!post.generatedTitle || !post.generatedContent) {
+    throw new Error('Cannot publish: missing generated content');
+  }
+
+  // Create article with the scheduled date (not today)
+  const articleProps = {
+    title: post.generatedTitle,
+    description: post.generatedDescription || '',
+    content: post.generatedContent,
+    date: post.scheduledDate,
+    tags: post.parsedTags,
+    image: './hero.webp',
+    ...(post.generatedImageAlt ? { imageAlt: post.generatedImageAlt } : {}),
+    contentPath,
+  };
+  const article = new Article(articleProps);
+
+  // Write article to filesystem
+  const writer = new FileWriter();
+  await writer.write(article);
+
+  // Write image if available
+  if (post.generatedImageData) {
+    const imagePath = path.join(process.cwd(), article.folderPath, 'hero.webp');
+    await convertToWebP(post.generatedImageData, imagePath);
+  }
+
+  // Mark as published in DB
+  await service.markPublished(post.id, article.folderPath);
+
+  return { id: post.id, publishedPath: article.folderPath };
+}
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const data = await request.json();
+    const service = getService();
+
+    // Auto-publish all due posts
+    if (data.mode === 'auto') {
+      const duePosts = await service.getDuePosts();
+      const results: { id: string; publishedPath: string }[] = [];
+      const failed: { id: string; error: string }[] = [];
+
+      for (const post of duePosts) {
+        try {
+          const result = await publishPost(service, post.id);
+          results.push(result);
+        } catch (error) {
+          const message =
+            error instanceof Error ? error.message : String(error);
+          console.error(`Failed to auto-publish ${post.id}:`, error);
+          failed.push({ id: post.id, error: message });
+        }
+      }
+
+      return jsonResponse({ published: results, failed });
+    }
+
+    // Publish single post
+    if (!data.id) {
+      return jsonError('id or mode:"auto" is required', 400);
+    }
+
+    const result = await publishPost(service, data.id);
+
+    return jsonResponse({ success: true, ...result });
+  } catch (error) {
+    console.error('Scheduler publish error:', error);
+    return jsonError(error);
+  }
+};

package/src/api/scheduler.ts

@@ -0,0 +1,51 @@
+import type { APIRoute } from 'astro';
+import { z } from 'zod';
+import { SchedulerService } from '../services/SchedulerService';
+import { AstroSchedulerDBAdapter } from '../services/SchedulerDBAdapter';
+import { jsonResponse, jsonError } from './_utils';
+
+const CreateScheduledPostSchema = z.object({
+  input: z.string().min(1, 'input is required'),
+  scheduledDate: z.string().min(1, 'scheduledDate is required'),
+});
+
+function getService(): SchedulerService {
+  return new SchedulerService(new AstroSchedulerDBAdapter());
+}
+
+export const GET: APIRoute = async () => {
+  try {
+    const service = getService();
+    const posts = await service.list();
+    return jsonResponse({ posts });
+  } catch (error) {
+    console.error('Scheduler list error:', error);
+    return jsonError(error);
+  }
+};
+
+export const POST: APIRoute = async ({ request }) => {
+  try {
+    const body = await request.json();
+    const parsed = CreateScheduledPostSchema.safeParse(body);
+    if (!parsed.success) {
+      return jsonError(parsed.error.errors[0]?.message ?? 'Invalid request', 400);
+    }
+    const data = parsed.data;
+
+    const service = getService();
+    const post = await service.create({
+      input: data.input,
+      scheduledDate: new Date(data.scheduledDate),
+    });
+
+    return jsonResponse({ post }, 201);
+  } catch (error) {
+    console.error('Scheduler create error:', error);
+    const status =
+      error instanceof Error && error.message.includes('already scheduled')
+        ? 409
+        : 500;
+    return jsonError(error, status);
+  }
+};

package/src/components/Editor.tsx

@@ -0,0 +1,115 @@
+import { useState } from 'react';
+import type { TabType } from './editor/types';
+import { styles } from './editor/styles';
+import { useTabNavigation } from './editor/useTabNavigation';
+import {
+  GenerateTabProvider,
+  GenerateTabControls,
+  GenerateTabPreview,
+} from './editor/GenerateTab';
+import { SettingsTab } from './editor/SettingsTab';
+import { PlannerTab } from './editor/PlannerTab';
+
+const TABS: { key: TabType; label: string }[] = [
+  { key: 'generate', label: 'Generieren' },
+  { key: 'planner', label: 'Planer' },
+  { key: 'settings', label: 'Einstellungen' },
+];
+
+export default function Editor() {
+  const [activeTab, setActiveTab] = useState<TabType>('generate');
+
+  const tabIndex = TABS.findIndex((t) => t.key === activeTab);
+  const { handleTabKeyDown, tabListRef } = useTabNavigation({
+    tabCount: TABS.length,
+    activeIndex: tabIndex,
+    onActivate: (index) => { const tab = TABS[index]; if (tab) setActiveTab(tab.key); },
+  });
+
+  const isFullWidth = activeTab !== 'generate';
+
+  const handleLogout = async () => {
+    await fetch('/api/auth/logout', { method: 'POST' });
+    window.location.href = '/login';
+  };
+
+  return (
+    <div style={styles.container}>
+      <div style={styles.headerRow}>
+        <div
+          ref={tabListRef}
+          role="tablist"
+          aria-label="Editor-Tabs"
+          style={styles.tabNav}
+        >
+          {TABS.map((tab) => (
+            <button
+              key={tab.key}
+              type="button"
+              role="tab"
+              aria-selected={activeTab === tab.key}
+              aria-controls={`panel-${tab.key}`}
+              id={`tab-${tab.key}`}
+              tabIndex={activeTab === tab.key ? 0 : -1}
+              style={
+                activeTab === tab.key ? styles.tabActive : styles.tab
+              }
+              onClick={() => setActiveTab(tab.key)}
+              onKeyDown={handleTabKeyDown}
+            >
+              {tab.label}
+            </button>
+          ))}
+        </div>
+        <button
+          type="button"
+          style={styles.logoutButton}
+          onClick={handleLogout}
+        >
+          Abmelden
+        </button>
+      </div>
+
+      {activeTab === 'generate' && (
+        <GenerateTabProvider>
+          <div
+            id="panel-generate"
+            role="tabpanel"
+            aria-labelledby="tab-generate"
+            style={{
+              display: 'grid',
+              gridTemplateColumns: '380px 1fr',
+              gap: '1.5rem',
+              alignItems: 'start',
+            }}
+          >
+            <GenerateTabControls />
+            <GenerateTabPreview />
+          </div>
+        </GenerateTabProvider>
+      )}
+
+      {activeTab === 'planner' && (
+        <div
+          id="panel-planner"
+          role="tabpanel"
+          aria-labelledby="tab-planner"
+          style={isFullWidth ? styles.panelFullWidth : undefined}
+        >
+          <PlannerTab />
+        </div>
+      )}
+
+      {activeTab === 'settings' && (
+        <div
+          id="panel-settings"
+          role="tabpanel"
+          aria-labelledby="tab-settings"
+          style={isFullWidth ? styles.panelFullWidth : undefined}
+        >
+          <SettingsTab />
+        </div>
+      )}
+    </div>
+  );
+}