@respectify/astro 0.1.0

package/src/lib/service.ts

@@ -0,0 +1,184 @@
+import type { RespectifyConfig } from './config';
+import { loadRespectifyConfig } from './config';
+import { RESPECTIFY_API_KEY, RESPECTIFY_EMAIL } from 'astro:env/server';
+import {
+  RespectifyClient,
+  AuthenticationError,
+  PaymentRequiredError,
+  RespectifyError,
+} from '@respectify/client';
+import { getIntegrationOptions } from '../runtime-config';
+import { logger } from './logger';
+import type { RespectifyAnalysisResult } from '../types';
+
+let client: RespectifyClient | null = null;
+const articleIdCache = new Map<string, string>();
+
+function getRespectifyClient(): RespectifyClient {
+  if (!client) {
+    if (!RESPECTIFY_EMAIL || !RESPECTIFY_API_KEY) {
+      throw new Error('Respectify credentials not configured. Set RESPECTIFY_EMAIL and RESPECTIFY_API_KEY.');
+    }
+
+    client = new RespectifyClient({
+      email: RESPECTIFY_EMAIL,
+      apiKey: RESPECTIFY_API_KEY,
+    });
+  }
+
+  return client;
+}
+
+async function getOrInitializeArticleId(postSlug: string): Promise<string> {
+  const cached = articleIdCache.get(postSlug);
+  if (cached) return cached;
+
+  const { getPostUrl } = getIntegrationOptions();
+  const site = import.meta.env.SITE;
+  if (!site) {
+    throw new Error('import.meta.env.SITE must be set in astro.config.ts for Respectify topic initialization.');
+  }
+
+  const postUrl = getPostUrl!(postSlug, site);
+  const respectifyClient = getRespectifyClient();
+
+  const result = await respectifyClient.initTopicFromUrl(postUrl, `Post: ${postSlug}`);
+  articleIdCache.set(postSlug, result.article_id);
+  logger.info('Initialized Respectify topic', { postSlug });
+
+  return result.article_id;
+}
+
+export async function verifyRespectifyCredentials(): Promise<boolean> {
+  try {
+    const respectifyClient = getRespectifyClient();
+    const result = await respectifyClient.checkUserCredentials();
+    return result.active;
+  } catch (error) {
+    logger.error('Respectify credential verification failed', { error });
+    return false;
+  }
+}
+
+export async function analyzeComment(text: string, postSlug?: string): Promise<RespectifyAnalysisResult> {
+  const config: RespectifyConfig = loadRespectifyConfig();
+
+  if (!config.enabled) {
+    return {
+      score: 1,
+      approved: true,
+      feedback: config.feedback.approved,
+    };
+  }
+
+  try {
+    const respectifyClient = getRespectifyClient();
+    let respectifyArticleId: string | undefined;
+
+    if (postSlug) {
+      try {
+        respectifyArticleId = await getOrInitializeArticleId(postSlug);
+      } catch (error) {
+        logger.warn('Could not initialize Respectify article ID; falling back to spam-only check', {
+          postSlug,
+          error,
+        });
+      }
+    }
+
+    const megacallOptions: {
+      comment: string;
+      articleId?: string;
+      includeSpam: boolean;
+      includeCommentScore?: boolean;
+    } = {
+      comment: text,
+      includeSpam: true,
+    };
+
+    if (respectifyArticleId) {
+      megacallOptions.articleId = respectifyArticleId;
+      megacallOptions.includeCommentScore = true;
+    }
+
+    const result = await respectifyClient.megacall(megacallOptions);
+
+    if (result.spam_check?.is_spam) {
+      return {
+        score: 0,
+        approved: false,
+        feedback: 'This comment appears to be spam.',
+        isSpam: true,
+        spamConfidence: result.spam_check.confidence,
+      };
+    }
+
+    let respectfulnessScore = config.thresholds.autoApprove;
+
+    if (result.comment_score) {
+      const toxicityScore = result.comment_score.toxicity_score ?? 0;
+      respectfulnessScore = 1 - toxicityScore;
+    }
+
+    let approved = false;
+    let feedback = '';
+
+    if (respectfulnessScore >= config.thresholds.autoApprove) {
+      approved = true;
+      feedback = config.feedback.approved;
+    } else if (respectfulnessScore < config.thresholds.block && config.moderation.blockDisrespectful) {
+      approved = false;
+      feedback = config.feedback.blocked;
+    } else {
+      approved = config.moderation.allowOverride;
+      feedback = config.feedback.warning;
+    }
+
+    let suggestion: string | undefined;
+    if (result.comment_score) {
+      const suggestions: string[] = [];
+
+      if (result.comment_score.toxicity_explanation) {
+        suggestions.push(result.comment_score.toxicity_explanation);
+      }
+
+      if (result.comment_score.logical_fallacies.length > 0) {
+        suggestions.push(
+          `Logical fallacies detected: ${result.comment_score.logical_fallacies.map((f) => f.fallacy_name).join(', ')}`,
+        );
+      }
+
+      if (result.comment_score.objectionable_phrases.length > 0) {
+        suggestions.push(`Objectionable phrases found: ${result.comment_score.objectionable_phrases.length} issue(s)`);
+      }
+
+      if (suggestions.length > 0) suggestion = suggestions.join(' ');
+    }
+
+    const analysisResult: RespectifyAnalysisResult = {
+      score: respectfulnessScore,
+      approved,
+      feedback,
+    };
+
+    if (suggestion) analysisResult.suggestion = suggestion;
+
+    return analysisResult;
+  } catch (error) {
+    if (error instanceof AuthenticationError) {
+      logger.error('Respectify authentication failed', { error });
+    } else if (error instanceof PaymentRequiredError) {
+      logger.error('Respectify subscription required', { error });
+    } else if (error instanceof RespectifyError) {
+      logger.error('Respectify API error', { statusCode: error.statusCode, message: error.message });
+    } else {
+      logger.error('Respectify analysis failed', { error });
+    }
+
+    return {
+      score: 0,
+      approved: false,
+      feedback: 'Comment analysis service is temporarily unavailable. Please try again later.',
+    };
+  }
+}

package/src/routes/comments.ts

@@ -0,0 +1,44 @@
+import type { APIContext } from 'astro';
+import { db, Comment as CommentTable, eq, and, asc } from 'astro:db';
+
+export const prerender = false;
+
+export async function GET(context: APIContext): Promise<Response> {
+  const slug = context.url.searchParams.get('slug');
+
+  if (!slug) {
+    return new Response(JSON.stringify({ error: 'Missing slug parameter' }), {
+      status: 400,
+      headers: { 'Content-Type': 'application/json' },
+    });
+  }
+
+  try {
+    const comments = await db
+      .select({
+        id: CommentTable.id,
+        author: CommentTable.author,
+        content: CommentTable.content,
+        createdAt: CommentTable.createdAt,
+      })
+      .from(CommentTable)
+      .where(and(eq(CommentTable.postSlug, slug), eq(CommentTable.approved, true)))
+      .orderBy(asc(CommentTable.createdAt));
+
+    return new Response(JSON.stringify({ comments }), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  } catch {
+    return new Response(JSON.stringify({ comments: [] }), {
+      status: 200,
+      headers: {
+        'Content-Type': 'application/json',
+        'Cache-Control': 'no-store',
+      },
+    });
+  }
+}

package/src/runtime-config.ts

@@ -0,0 +1,25 @@
+import type { RespectifyIntegrationOptions } from './types';
+
+const defaults: Required<Pick<RespectifyIntegrationOptions, 'configPath' | 'commentsApiPath' | 'showBranding'>> &
+  Pick<RespectifyIntegrationOptions, 'getPostUrl' | 'rateLimit'> = {
+  configPath: './respectify.config.json',
+  commentsApiPath: '/api/respectify/comments',
+  showBranding: true,
+  getPostUrl: (slug, site) => `${site.replace(/\/$/, '')}/posts/${slug}/`,
+  rateLimit: { windowMs: 5 * 60 * 1000, maxRequests: 10 },
+};
+
+let options: typeof defaults = { ...defaults };
+
+export function setIntegrationOptions(userOptions: RespectifyIntegrationOptions = {}): void {
+  options = {
+    ...defaults,
+    ...userOptions,
+    getPostUrl: userOptions.getPostUrl ?? defaults.getPostUrl,
+    rateLimit: userOptions.rateLimit ?? defaults.rateLimit,
+  };
+}
+
+export function getIntegrationOptions(): typeof defaults {
+  return options;
+}

package/src/schema.ts

@@ -0,0 +1,22 @@
+import { defineTable, column, NOW } from 'astro:db';
+
+/** Astro DB table definition for Respectify comments. Merge into your db/config.ts. */
+export const RespectifyComment = defineTable({
+  columns: {
+    id: column.number({ primaryKey: true }),
+    postSlug: column.text(),
+    author: column.text(),
+    email: column.text({ optional: true }),
+    content: column.text(),
+    createdAt: column.date({ default: NOW }),
+    approved: column.boolean({ default: false }),
+    parentId: column.number({ optional: true }),
+  },
+  indexes: [
+    { on: ['postSlug'], unique: false },
+    { on: ['approved'], unique: false },
+  ],
+});
+
+/** Alias for backwards compatibility with existing schemas */
+export const Comment = RespectifyComment;

package/src/types.ts

@@ -0,0 +1,28 @@
+export interface RespectifyIntegrationOptions {
+  /** Path to respectify.config.json (default: ./respectify.config.json) */
+  configPath?: string;
+
+  /** Build the canonical URL for a post — used to initialize Respectify topics */
+  getPostUrl?: (slug: string, site: string) => string;
+
+  /** API route path for fetching comments (default: /api/respectify/comments) */
+  commentsApiPath?: string;
+
+  /** Show Powered by Respectify branding (default: true) */
+  showBranding?: boolean;
+
+  /** Rate limit for comment submissions per IP */
+  rateLimit?: {
+    windowMs: number;
+    maxRequests: number;
+  };
+}
+
+export interface RespectifyAnalysisResult {
+  score: number;
+  approved: boolean;
+  feedback: string;
+  suggestion?: string;
+  isSpam?: boolean;
+  spamConfidence?: number;
+}