@hasna/microservices 0.0.7 → 0.0.8

package/microservices/microservice-social/src/lib/sentiment.ts

@@ -0,0 +1,256 @@
+/**
+ * Sentiment analysis for social media mentions.
+ * Uses OpenAI (gpt-4o-mini) or Anthropic (claude-haiku) to classify text sentiment,
+ * extract emotional keywords, and generate aggregated sentiment reports.
+ */
+
+import { getDatabase } from "../db/database.js";
+import { getMention, type Mention } from "./mentions.js";
+import {
+  callOpenAI,
+  callAnthropic,
+  getDefaultAIProvider,
+  type AIProvider,
+} from "./content-ai.js";
+
+// ---- Types ----
+
+export type SentimentLabel = "positive" | "neutral" | "negative";
+
+export interface SentimentResult {
+  sentiment: SentimentLabel;
+  score: number;
+  keywords: string[];
+}
+
+export interface SentimentReport {
+  positive_pct: number;
+  neutral_pct: number;
+  negative_pct: number;
+  total_analyzed: number;
+  trending_keywords: string[];
+  most_positive: { id: string; content: string; sentiment: string } | null;
+  most_negative: { id: string; content: string; sentiment: string } | null;
+}
+
+// ---- Prompt Builders (exported for testing) ----
+
+export function buildSentimentPrompt(text: string): string {
+  return `Analyze the sentiment of the following text.
+
+Return ONLY valid JSON with these fields:
+- "sentiment": one of "positive", "neutral", or "negative"
+- "score": a number between 0 and 1 where 0 is most negative, 0.5 is neutral, 1 is most positive
+- "keywords": array of key emotional or sentiment-bearing words from the text (max 5)
+
+Text: ${text}`;
+}
+
+export function buildBatchSentimentPrompt(texts: string[]): string {
+  const numbered = texts.map((t, i) => `${i + 1}. ${t}`).join("\n");
+  return `Analyze the sentiment of each of the following texts.
+
+Return ONLY a valid JSON array where each element has:
+- "sentiment": one of "positive", "neutral", or "negative"
+- "score": a number between 0 and 1 where 0 is most negative, 0.5 is neutral, 1 is most positive
+- "keywords": array of key emotional or sentiment-bearing words (max 5 per text)
+
+The array must have exactly ${texts.length} elements, one per text, in order.
+
+Texts:
+${numbered}`;
+}
+
+// ---- JSON Parser ----
+
+function parseJSON<T>(raw: string, fallback: T): T {
+  const cleaned = raw.replace(/```json\n?/g, "").replace(/```\n?/g, "").trim();
+  try {
+    return JSON.parse(cleaned) as T;
+  } catch {
+    return fallback;
+  }
+}
+
+function validateSentimentResult(result: SentimentResult): SentimentResult {
+  const validSentiments: SentimentLabel[] = ["positive", "neutral", "negative"];
+  if (!validSentiments.includes(result.sentiment)) {
+    result.sentiment = "neutral";
+  }
+  if (typeof result.score !== "number" || result.score < 0 || result.score > 1) {
+    result.score = 0.5;
+  }
+  if (!Array.isArray(result.keywords)) {
+    result.keywords = [];
+  }
+  return result;
+}
+
+// ---- Core Functions ----
+
+export async function analyzeSentiment(
+  text: string,
+  provider?: AIProvider
+): Promise<SentimentResult> {
+  const resolved = provider ?? getDefaultAIProvider();
+  if (!resolved) {
+    throw new Error("No AI API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY.");
+  }
+
+  const prompt = buildSentimentPrompt(text);
+  const raw = resolved === "openai"
+    ? await callOpenAI(prompt, 200)
+    : await callAnthropic(prompt, 200);
+
+  const fallback: SentimentResult = { sentiment: "neutral", score: 0.5, keywords: [] };
+  const result = parseJSON<SentimentResult>(raw, fallback);
+  return validateSentimentResult(result);
+}
+
+export async function analyzeBatch(
+  texts: string[],
+  provider?: AIProvider
+): Promise<SentimentResult[]> {
+  if (texts.length === 0) return [];
+
+  const resolved = provider ?? getDefaultAIProvider();
+  if (!resolved) {
+    throw new Error("No AI API key found. Set OPENAI_API_KEY or ANTHROPIC_API_KEY.");
+  }
+
+  const prompt = buildBatchSentimentPrompt(texts);
+  const maxTokens = Math.min(texts.length * 150, 4000);
+  const raw = resolved === "openai"
+    ? await callOpenAI(prompt, maxTokens)
+    : await callAnthropic(prompt, maxTokens);
+
+  const fallback: SentimentResult[] = texts.map(() => ({
+    sentiment: "neutral" as SentimentLabel,
+    score: 0.5,
+    keywords: [],
+  }));
+
+  const results = parseJSON<SentimentResult[]>(raw, fallback);
+  if (!Array.isArray(results) || results.length !== texts.length) {
+    return fallback;
+  }
+
+  return results.map(validateSentimentResult);
+}
+
+export function getSentimentReport(
+  accountId: string,
+  days?: number
+): SentimentReport {
+  const db = getDatabase();
+
+  let dateFilter = "";
+  const params: unknown[] = [accountId];
+
+  if (days && days > 0) {
+    dateFilter = " AND fetched_at >= datetime('now', ?)";
+    params.push(`-${days} days`);
+  }
+
+  // Get all mentions with sentiment for this account
+  const rows = db
+    .prepare(
+      `SELECT id, content, sentiment FROM mentions
+       WHERE account_id = ? AND sentiment IS NOT NULL${dateFilter}
+       ORDER BY fetched_at DESC`
+    )
+    .all(...params) as { id: string; content: string | null; sentiment: string }[];
+
+  const total_analyzed = rows.length;
+
+  if (total_analyzed === 0) {
+    return {
+      positive_pct: 0,
+      neutral_pct: 0,
+      negative_pct: 0,
+      total_analyzed: 0,
+      trending_keywords: [],
+      most_positive: null,
+      most_negative: null,
+    };
+  }
+
+  let positive = 0;
+  let neutral = 0;
+  let negative = 0;
+  let most_positive: { id: string; content: string; sentiment: string } | null = null;
+  let most_negative: { id: string; content: string; sentiment: string } | null = null;
+
+  for (const row of rows) {
+    const s = row.sentiment.toLowerCase();
+    if (s === "positive") {
+      positive++;
+      if (!most_positive) {
+        most_positive = { id: row.id, content: row.content || "", sentiment: row.sentiment };
+      }
+    } else if (s === "negative") {
+      negative++;
+      if (!most_negative) {
+        most_negative = { id: row.id, content: row.content || "", sentiment: row.sentiment };
+      }
+    } else {
+      neutral++;
+    }
+  }
+
+  // Trending keywords: parse sentiment field for keywords if stored as JSON,
+  // otherwise just aggregate the sentiment labels
+  const keywordCounts: Record<string, number> = {};
+  for (const row of rows) {
+    // Try to parse sentiment as JSON (might contain keywords)
+    try {
+      const parsed = JSON.parse(row.sentiment);
+      if (parsed && Array.isArray(parsed.keywords)) {
+        for (const kw of parsed.keywords) {
+          const key = String(kw).toLowerCase();
+          keywordCounts[key] = (keywordCounts[key] || 0) + 1;
+        }
+      }
+    } catch {
+      // sentiment is a plain string label, skip keyword extraction
+    }
+  }
+
+  const trending_keywords = Object.entries(keywordCounts)
+    .sort((a, b) => b[1] - a[1])
+    .slice(0, 10)
+    .map(([kw]) => kw);
+
+  return {
+    positive_pct: Math.round((positive / total_analyzed) * 100),
+    neutral_pct: Math.round((neutral / total_analyzed) * 100),
+    negative_pct: Math.round((negative / total_analyzed) * 100),
+    total_analyzed,
+    trending_keywords,
+    most_positive,
+    most_negative,
+  };
+}
+
+export async function autoAnalyzeMention(
+  mentionId: string,
+  provider?: AIProvider
+): Promise<SentimentResult | null> {
+  const mention = getMention(mentionId);
+  if (!mention) {
+    throw new Error(`Mention '${mentionId}' not found.`);
+  }
+
+  if (!mention.content) {
+    throw new Error(`Mention '${mentionId}' has no content to analyze.`);
+  }
+
+  const result = await analyzeSentiment(mention.content, provider);
+
+  // Store the sentiment result as JSON in the mention's sentiment field
+  const db = getDatabase();
+  const sentimentData = JSON.stringify(result);
+  db.prepare("UPDATE mentions SET sentiment = ? WHERE id = ?").run(sentimentData, mentionId);
+
+  return result;
+}

package/microservices/microservice-social/src/lib/threads.ts

@@ -0,0 +1,291 @@
+/**
+ * Thread and carousel support for social media posts.
+ *
+ * Threads: multiple posts linked by thread_id, ordered by thread_position.
+ * Carousels: a single post with multiple media_urls (Instagram/LinkedIn format).
+ */
+
+import {
+  createPost,
+  getAccount,
+  getPost,
+  updatePost,
+  getThreadPosts,
+  deleteThreadPosts,
+  checkPlatformLimit,
+  PLATFORM_LIMITS,
+  type Post,
+  type Platform,
+} from "../db/social.js";
+
+// ---- Types ----
+
+export interface CreateThreadOptions {
+  scheduledAt?: string;
+  tags?: string[];
+}
+
+export interface ThreadResult {
+  threadId: string;
+  posts: Post[];
+}
+
+export interface PublishThreadResult {
+  threadId: string;
+  posts: Post[];
+  platformPostIds: string[];
+}
+
+// ---- Thread Operations ----
+
+/**
+ * Create a thread of posts linked by a shared thread_id.
+ * Each post is validated against the platform's character limit.
+ */
+export function createThread(
+  contents: string[],
+  accountId: string,
+  options?: CreateThreadOptions
+): ThreadResult {
+  if (contents.length === 0) {
+    throw new Error("Thread must have at least one post.");
+  }
+
+  const account = getAccount(accountId);
+  if (!account) {
+    throw new Error(`Account '${accountId}' not found.`);
+  }
+
+  const limit = PLATFORM_LIMITS[account.platform];
+  for (let i = 0; i < contents.length; i++) {
+    if (contents[i].length > limit) {
+      throw new Error(
+        `Post ${i + 1} (${contents[i].length} chars) exceeds ${account.platform} limit (${limit} chars).`
+      );
+    }
+  }
+
+  const threadId = crypto.randomUUID();
+  const posts: Post[] = [];
+
+  for (let i = 0; i < contents.length; i++) {
+    const post = createPost({
+      account_id: accountId,
+      content: contents[i],
+      status: options?.scheduledAt ? "scheduled" : "draft",
+      scheduled_at: options?.scheduledAt,
+      tags: options?.tags,
+      thread_id: threadId,
+      thread_position: i,
+    });
+    posts.push(post);
+  }
+
+  return { threadId, posts };
+}
+
+/**
+ * Get all posts in a thread, ordered by position.
+ */
+export function getThread(threadId: string): Post[] {
+  const posts = getThreadPosts(threadId);
+  if (posts.length === 0) {
+    throw new Error(`Thread '${threadId}' not found.`);
+  }
+  return posts;
+}
+
+/**
+ * Publish a thread sequentially via platform APIs.
+ *
+ * - X: POST /2/tweets chaining each reply to the previous tweet
+ * - Meta: POST /{page-id}/feed for first post, then POST /{post-id}/comments for rest
+ *
+ * Each post gets its platform_post_id stored.
+ */
+export async function publishThread(threadId: string): Promise<PublishThreadResult> {
+  const posts = getThreadPosts(threadId);
+  if (posts.length === 0) {
+    throw new Error(`Thread '${threadId}' not found.`);
+  }
+
+  const firstPost = posts[0];
+  const account = getAccount(firstPost.account_id);
+  if (!account) {
+    throw new Error(`Account '${firstPost.account_id}' not found.`);
+  }
+
+  const platformPostIds: string[] = [];
+  const updatedPosts: Post[] = [];
+
+  if (account.platform === "x") {
+    // X: chain tweets using reply.in_reply_to_tweet_id
+    const { XPublisher } = await import("./publisher.js");
+    const publisher = new XPublisher();
+
+    let previousTweetId: string | null = null;
+
+    for (const post of posts) {
+      const body: Record<string, unknown> = { text: post.content };
+      if (previousTweetId) {
+        body.reply = { in_reply_to_tweet_id: previousTweetId };
+      }
+
+      // Use the publisher's publishPost for the first, then raw fetch for replies
+      const res = await fetch("https://api.twitter.com/2/tweets", {
+        method: "POST",
+        headers: {
+          Authorization: `Bearer ${process.env.X_BEARER_TOKEN || process.env.X_ACCESS_TOKEN || ""}`,
+          "Content-Type": "application/json",
+        },
+        body: JSON.stringify(body),
+      });
+
+      if (!res.ok) {
+        const text = await res.text();
+        // Mark remaining posts as failed
+        for (const remaining of posts.filter((p) => !platformPostIds.includes(p.platform_post_id || ""))) {
+          if (!platformPostIds.some((pid) => pid === remaining.platform_post_id)) {
+            updatePost(remaining.id, { status: "failed" });
+          }
+        }
+        throw new Error(`X API error ${res.status}: ${text}`);
+      }
+
+      const data = (await res.json()) as { data: { id: string } };
+      const tweetId = data.data.id;
+      previousTweetId = tweetId;
+      platformPostIds.push(tweetId);
+
+      const updated = updatePost(post.id, {
+        status: "published",
+        published_at: new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, ""),
+        platform_post_id: tweetId,
+      });
+      updatedPosts.push(updated!);
+    }
+  } else if (account.platform === "instagram" || account.platform === "linkedin") {
+    // Meta-style: first post to feed, rest as comments
+    const accessToken = process.env.META_ACCESS_TOKEN || "";
+    const pageId = process.env.META_PAGE_ID || account.handle;
+    const baseUrl = "https://graph.facebook.com/v22.0";
+
+    // First post
+    const firstRes = await fetch(
+      `${baseUrl}/${pageId}/feed?access_token=${encodeURIComponent(accessToken)}`,
+      {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ message: posts[0].content }),
+      }
+    );
+
+    if (!firstRes.ok) {
+      const text = await firstRes.text();
+      throw new Error(`Meta API error ${firstRes.status}: ${text}`);
+    }
+
+    const firstData = (await firstRes.json()) as { id: string };
+    platformPostIds.push(firstData.id);
+    const firstUpdated = updatePost(posts[0].id, {
+      status: "published",
+      published_at: new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, ""),
+      platform_post_id: firstData.id,
+    });
+    updatedPosts.push(firstUpdated!);
+
+    // Rest as comments on the first post
+    for (let i = 1; i < posts.length; i++) {
+      const commentRes = await fetch(
+        `${baseUrl}/${firstData.id}/comments?access_token=${encodeURIComponent(accessToken)}`,
+        {
+          method: "POST",
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ message: posts[i].content }),
+        }
+      );
+
+      if (!commentRes.ok) {
+        const text = await commentRes.text();
+        throw new Error(`Meta API error ${commentRes.status}: ${text}`);
+      }
+
+      const commentData = (await commentRes.json()) as { id: string };
+      platformPostIds.push(commentData.id);
+
+      const updated = updatePost(posts[i].id, {
+        status: "published",
+        published_at: new Date().toISOString().replace("T", " ").replace(/\.\d+Z$/, ""),
+        platform_post_id: commentData.id,
+      });
+      updatedPosts.push(updated!);
+    }
+  } else {
+    // For unsupported platforms, publish each post individually via the generic publisher
+    const { publishToApi } = await import("./publisher.js");
+
+    for (const post of posts) {
+      try {
+        const updated = await publishToApi(post.id);
+        platformPostIds.push(updated.platform_post_id || "");
+        updatedPosts.push(updated);
+      } catch (err) {
+        throw err;
+      }
+    }
+  }
+
+  return { threadId, posts: updatedPosts, platformPostIds };
+}
+
+/**
+ * Delete an entire thread and all its posts.
+ */
+export function deleteThread(threadId: string): number {
+  const posts = getThreadPosts(threadId);
+  if (posts.length === 0) {
+    throw new Error(`Thread '${threadId}' not found.`);
+  }
+  return deleteThreadPosts(threadId);
+}
+
+// ---- Carousel ----
+
+/**
+ * Create a carousel post — a single post with multiple media_urls.
+ * Used for Instagram/LinkedIn carousel format.
+ */
+export function createCarousel(
+  images: string[],
+  captions: string[],
+  accountId: string
+): Post {
+  if (images.length === 0) {
+    throw new Error("Carousel must have at least one image.");
+  }
+
+  const account = getAccount(accountId);
+  if (!account) {
+    throw new Error(`Account '${accountId}' not found.`);
+  }
+
+  // Use the first caption or combine all captions as the post content
+  const content = captions.length > 0 ? captions.join("\n\n") : "";
+
+  // Validate content length against platform limit
+  if (content.length > 0) {
+    const limit = PLATFORM_LIMITS[account.platform];
+    if (content.length > limit) {
+      throw new Error(
+        `Carousel caption (${content.length} chars) exceeds ${account.platform} limit (${limit} chars).`
+      );
+    }
+  }
+
+  return createPost({
+    account_id: accountId,
+    content,
+    media_urls: images,
+    status: "draft",
+  });
+}