llm.js

/**
 * LLM Integration for xboost
 * Multi-provider support via Vercel AI SDK
 *
 * Supported providers:
 * - Anthropic (Claude)
 * - OpenAI (GPT-4, GPT-3.5)
 * - Google (Gemini)
 * - OpenRouter (access to many models)
 * - Ollama (local models)
 * - LM Studio (local models)
 */

import { generateText } from 'ai';
import { createAnthropic } from '@ai-sdk/anthropic';
import { createOpenAI } from '@ai-sdk/openai';
import { createGoogleGenerativeAI } from '@ai-sdk/google';

// Provider configurations
const PROVIDERS = {
  anthropic: {
    name: 'Anthropic (Claude)',
    envKey: ['ANTHROPIC_API_KEY', 'CLAUDE_API_KEY'],
    defaultModel: 'claude-sonnet-4-20250514',
    models: ['claude-sonnet-4-20250514', 'claude-3-5-sonnet-20241022', 'claude-3-haiku-20240307'],
  },
  openai: {
    name: 'OpenAI',
    envKey: ['OPENAI_API_KEY'],
    defaultModel: 'gpt-4o',
    models: ['gpt-4o', 'gpt-4o-mini', 'gpt-4-turbo', 'gpt-3.5-turbo'],
  },
  google: {
    name: 'Google (Gemini)',
    envKey: ['GOOGLE_GENERATIVE_AI_API_KEY', 'GEMINI_API_KEY'],
    defaultModel: 'gemini-2.0-flash',
    models: ['gemini-2.0-flash', 'gemini-1.5-pro', 'gemini-1.5-flash'],
  },
  openrouter: {
    name: 'OpenRouter',
    envKey: ['OPENROUTER_API_KEY'],
    defaultModel: 'anthropic/claude-3.5-sonnet',
    models: ['anthropic/claude-3.5-sonnet', 'openai/gpt-4o', 'google/gemini-pro', 'meta-llama/llama-3.1-70b-instruct'],
  },
  ollama: {
    name: 'Ollama (Local)',
    envKey: [], // No API key needed
    defaultModel: 'llama3.2',
    models: ['llama3.2', 'mistral', 'codellama', 'phi3'],
    baseURL: 'http://localhost:11434/v1',
  },
  lmstudio: {
    name: 'LM Studio (Local)',
    envKey: [], // No API key needed
    defaultModel: 'local-model',
    models: ['local-model'],
    baseURL: 'http://localhost:1234/v1',
  },
};

// Get configured provider and model
function getProviderConfig() {
  // Check for explicit provider setting
  const explicitProvider = process.env.XBOOST_PROVIDER?.toLowerCase();
  const explicitModel = process.env.XBOOST_MODEL;

  // If explicitly set, use that
  if (explicitProvider && PROVIDERS[explicitProvider]) {
    return {
      provider: explicitProvider,
      model: explicitModel || PROVIDERS[explicitProvider].defaultModel,
    };
  }

  // Auto-detect based on available API keys
  for (const [providerId, config] of Object.entries(PROVIDERS)) {
    // Skip local providers in auto-detect (user should explicitly choose)
    if (providerId === 'ollama' || providerId === 'lmstudio') continue;

    for (const envKey of config.envKey) {
      if (process.env[envKey]) {
        return {
          provider: providerId,
          model: explicitModel || config.defaultModel,
          apiKey: process.env[envKey],
        };
      }
    }
  }

  return null;
}

// Create the appropriate provider instance
function createProvider(providerConfig) {
  const { provider, model, apiKey } = providerConfig;
  const config = PROVIDERS[provider];

  switch (provider) {
    case 'anthropic': {
      const anthropic = createAnthropic({ apiKey });
      return anthropic(model);
    }

    case 'openai': {
      const openai = createOpenAI({ apiKey });
      return openai(model);
    }

    case 'google': {
      const google = createGoogleGenerativeAI({ apiKey });
      return google(model);
    }

    case 'openrouter': {
      const openrouter = createOpenAI({
        apiKey,
        baseURL: 'https://openrouter.ai/api/v1',
      });
      return openrouter(model);
    }

    case 'ollama': {
      const ollama = createOpenAI({
        apiKey: 'ollama', // Ollama doesn't need a real key
        baseURL: process.env.OLLAMA_BASE_URL || config.baseURL,
      });
      return ollama(model);
    }

    case 'lmstudio': {
      const lmstudio = createOpenAI({
        apiKey: 'lmstudio', // LM Studio doesn't need a real key
        baseURL: process.env.LMSTUDIO_BASE_URL || config.baseURL,
      });
      return lmstudio(model);
    }

    default:
      throw new Error(`Unknown provider: ${provider}`);
  }
}

// Build the system prompt with algorithm knowledge
export function buildSystemPrompt() {
  return `You are an X/Twitter content optimization expert. Your job is to help create engaging posts that perform well with the X algorithm.

## X Algorithm Knowledge (from actual source code)

### Engagement Weights (what the algorithm optimizes for):
- Reply: 11x weight (MOST IMPORTANT - drive conversation!)
- Follow: 10x weight
- Repost/Quote/Share: 4x weight each
- Bookmark: 2x weight
- Like: 1x weight (baseline)
- Negative: Block (-50x), Mute (-30x), Report (-100x)

### Content Multipliers:
- Threads: 1.3x boost
- Quote tweets: 1.2x boost
- Original tweets: 1.0x
- Pure reposts: 0.5x (add commentary!)

### Media Boosts:
- Polls: 1.3x (drive engagement)
- Video: 1.2x
- Multiple images: 1.15x
- Single image: 1.1x
- External links: 0.95x (slight penalty - add value to compensate)

### Timing:
- Posts under 1 hour old: 1.5x recency boost
- Author diversity matters - don't flood

## Your Guidelines:

1. **Prioritize replies over likes** - Write posts that invite discussion, ask questions, share opinions people can respond to

2. **Use proven hooks**:
   - "I spent X hours/days/years..."
   - "Here's what nobody tells you about..."
   - "The biggest mistake I see..."
   - "Unpopular opinion:"
   - "X things I learned from..."

3. **Optimal structure**:
   - Strong hook in first line (this shows in timeline)
   - ~100-280 characters for single posts
   - Break into threads if >200 chars of value
   - End with question or CTA when appropriate

4. **Avoid**:
   - Spammy language (buy now, click here, follow back)
   - Excessive emojis
   - Pure self-promotion without value
   - Engagement bait that feels manipulative

5. **Voice**: Keep the author's authentic voice. Optimize structure and hooks, don't make it sound generic.

When given content to optimize, provide multiple variations with different angles (hot take, question, thread, personal story).`;
}

// Call LLM with unified interface
export async function callLLM(prompt, options = {}) {
  const providerConfig = getProviderConfig();

  if (!providerConfig) {
    return {
      success: false,
      error: `No AI provider configured. Set one of these environment variables:

  Cloud Providers:
    ANTHROPIC_API_KEY     - Claude (recommended)
    OPENAI_API_KEY        - GPT-4
    GOOGLE_GENERATIVE_AI_API_KEY - Gemini
    OPENROUTER_API_KEY    - OpenRouter (many models)

  Local Models:
    XBOOST_PROVIDER=ollama   - Use Ollama
    XBOOST_PROVIDER=lmstudio - Use LM Studio

  Optional:
    XBOOST_MODEL          - Override default model`,
    };
  }

  const { maxTokens = 1024, temperature = 0.7 } = options;

  try {
    const model = createProvider(providerConfig);

    const { text } = await generateText({
      model,
      system: buildSystemPrompt(),
      prompt,
      maxTokens,
      temperature,
    });

    return {
      success: true,
      text,
      provider: providerConfig.provider,
      model: providerConfig.model,
    };
  } catch (error) {
    return {
      success: false,
      error: error.message,
      provider: providerConfig.provider,
    };
  }
}

// Optimize a rough idea/text into engaging posts
export async function optimizeText(text, options = {}) {
  const { context = '' } = options;

  const prompt = `Optimize this content for X/Twitter engagement.

**Original content:**
${text}

${context ? `**Additional context:** ${context}` : ''}

**Task:** Create 3-4 variations optimized for the X algorithm:

1. **Hook version** - Lead with a compelling hook that stops the scroll
2. **Question version** - Frame it to invite replies (remember: replies = 11x weight!)
3. **Thread opener** - If there's enough substance, create a thread-worthy opener with 🧵
4. **Hot take version** - A slightly contrarian or bold angle

For each variation:
- Show the optimized post text (ready to copy-paste)
- Note the key optimization applied
- Keep the author's authentic voice

Format each as:
### [Type]
\`\`\`
[Post text here]
\`\`\`
*Optimization: [what you did]*`;

  return callLLM(prompt);
}

// Generate posts from a URL/link
export async function optimizeFromUrl(url, urlContent, options = {}) {
  const prompt = `Create engaging X/Twitter posts about this content.

**URL:** ${url}

**Content summary:**
${urlContent}

**Task:** Generate 4 different posts sharing this link, optimized for the X algorithm:

1. **Value-add post** - Share the key insight + your take (remember: external links get 0.95x, so add value!)
2. **Question post** - Frame it to drive discussion (replies = 11x!)
3. **Contrarian/hot take** - A bold perspective on this content
4. **Thread opener** - If there's enough substance for a thread with 🧵

For each:
- The post should work standalone (people should want to engage even before clicking)
- Include the URL naturally
- Add a hook that makes people stop scrolling

Format each as:
### [Type]
\`\`\`
[Post text here - include ${url} where appropriate]
\`\`\`
*Hook used: [the technique]*
*Expected engagement driver: [reply/share/click]*`;

  return callLLM(prompt);
}

// Generate smart replies to a tweet
export async function generateReplies(tweetText, tweetAuthor, options = {}) {
  const prompt = `Generate smart reply options for this tweet.

**Original tweet by @${tweetAuthor}:**
"${tweetText}"

**Task:** Create 4 reply options that could perform well:

1. **Add value** - Share additional insight or information
2. **Ask smart question** - Genuine curiosity that drives thread
3. **Share experience** - Relate with a personal angle
4. **Friendly challenge** - Respectful different perspective (controversial drives engagement, but stay constructive)

For each reply:
- Keep it concise (replies should be punchy)
- Make it genuine, not sycophantic
- Aim to start a conversation, not end it

Format:
### [Type]
\`\`\`
[Reply text]
\`\`\`
*Why this works: [brief explanation]*`;

  return callLLM(prompt);
}

// Generate a full thread from content
export async function generateThread(topic, content, options = {}) {
  const { maxTweets = 7 } = options;

  const prompt = `Create an engaging Twitter/X thread about this topic.

**Topic:** ${topic}

**Source content/ideas:**
${content}

**Task:** Create a ${maxTweets}-tweet thread optimized for the X algorithm.

Thread structure:
1. **Tweet 1 (Hook)** - Must stop the scroll. Use a proven hook pattern. End with 🧵
2. **Tweets 2-${maxTweets - 1}** - Each tweet should:
   - Deliver ONE clear point
   - Be valuable standalone (people might see just one)
   - Flow logically from previous
   - Be under 280 characters
3. **Final tweet** - Call to action or question to drive replies

Remember:
- Threads get 1.3x algorithm boost
- Each tweet in thread should be self-contained value
- Questions throughout drive replies (11x weight!)

Format:
### Tweet 1/X (Hook)
\`\`\`
[text]
\`\`\`

### Tweet 2/X
\`\`\`
[text]
\`\`\`

[continue for all tweets]`;

  return callLLM(prompt, { maxTokens: 2000 });
}

// Analyze and improve an existing post
export async function improvePost(originalPost, metrics = {}) {
  const prompt = `Analyze and improve this X/Twitter post.

**Original post:**
"${originalPost}"

${Object.keys(metrics).length > 0 ? `**Current metrics:** ${JSON.stringify(metrics)}` : ''}

**Task:**
1. Analyze what's working and what's not (based on X algorithm knowledge)
2. Provide 2 improved versions

Analysis should cover:
- Hook strength (does first line stop scroll?)
- Reply potential (will people respond?)
- Length optimization
- Missing elements (question? CTA? hook?)

Format:
### Analysis
[Your analysis]

### Improved Version 1 (Minor tweaks)
\`\`\`
[Optimized post]
\`\`\`
*Changes: [what you changed and why]*

### Improved Version 2 (Reimagined)
\`\`\`
[More significantly reworked version]
\`\`\`
*Changes: [what you changed and why]*`;

  return callLLM(prompt);
}

// Check if LLM is available
export async function checkLLMAvailable() {
  return getProviderConfig() !== null;
}

// Get current provider info
export function getProviderInfo() {
  const config = getProviderConfig();
  if (!config) return null;

  return {
    provider: config.provider,
    name: PROVIDERS[config.provider].name,
    model: config.model,
  };
}

// List available providers
export function listProviders() {
  return Object.entries(PROVIDERS).map(([id, config]) => ({
    id,
    name: config.name,
    models: config.models,
    envKeys: config.envKey,
    isLocal: id === 'ollama' || id === 'lmstudio',
  }));
}

export default {
  buildSystemPrompt,
  callLLM,
  optimizeText,
  optimizeFromUrl,
  generateReplies,
  generateThread,
  improvePost,
  checkLLMAvailable,
  getProviderInfo,
  listProviders,
  PROVIDERS,
};