@hasna/microservices 0.0.15 → 0.0.17

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

@@ -1,256 +0,0 @@
-/**
- * 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

@@ -1,291 +0,0 @@
-/**
- * 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",
-  });
-}