Youmind X Article

references/environment.md
toolkit/package-lock.json
toolkit/node_modules/

# User data — never publish
config.yaml
.env
output/

node_modules/
dist/
config.yaml
output/
.env
toolkit/package-lock.json

# Obsolete skill-local example.
#
# Canonical config now lives at ~/.youmind/config.yaml
# using shared/config.example.yaml as the template.
# Article skills no longer read this repo-local file.
#
# This skill has no skill-specific override fields beyond the shared config.

youmind:
  api_key: ""
  base_url: "https://youmind.com/openapi/v1"

youmind:
  api_key: "sk-ym-xxxxxxxxxxxxxxxxxxxx"
  base_url: "https://youmind.com/openapi/v1"

{
  "name": "youmind-x-toolkit",
  "version": "1.0.0",
  "description": "YouMind X: Write and publish tweets and threads to X (Twitter)",
  "type": "module",
  "main": "dist/cli.js",
  "bin": {
    "youmind-x": "dist/cli.js"
  },
  "scripts": {
    "build": "tsc",
    "dev": "tsx src/cli.ts",
    "tweet": "tsx src/cli.ts tweet",
    "thread": "tsx src/cli.ts thread",
    "preview": "tsx src/cli.ts preview"
  },
  "dependencies": {
    "commander": "^12.0.0",
    "node-fetch": "^3.3.0",
    "yaml": "^2.3.0"
  },
  "devDependencies": {
    "@types/node": "^22.0.0",
    "tsx": "^4.7.0",
    "typescript": "^5.3.0"
  }
}

#!/usr/bin/env tsx
/**
 * CLI entry point for YouMind X Skill.
 *
 * All publishing flows through YouMind's OpenAPI proxy. The user only needs a
 * YouMind API key locally; their X account is connected once inside YouMind.
 *
 * Usage:
 *   npx tsx src/cli.ts tweet --text "Your tweet here"
 *   npx tsx src/cli.ts tweet --text "Check this out" --image ./cover.png
 *   npx tsx src/cli.ts thread --file article.md
 *   npx tsx src/cli.ts preview --text "Check length" --mode tweet
 *   npx tsx src/cli.ts preview --file article.md --mode thread
 *   npx tsx src/cli.ts validate
 */

import { Command } from 'commander';
import { readFileSync } from 'node:fs';
import { resolve } from 'node:path';

import { deleteXPost, loadXConfig } from './x-api.js';
import {
  previewThread,
  previewTweet,
  publishThread,
  publishTweet,
} from './publisher.js';

const program = new Command();

program
  .name('youmind-x')
  .description('YouMind X: Write and publish tweets and threads via YouMind OpenAPI')
  .version('1.0.0');

program
  .command('tweet')
  .description('Publish a single tweet')
  .option('--text <text>', 'Tweet text content')
  .option('--file <path>', 'Read content from a file')
  .option('--image <pathsOrUrls...>', 'Local image paths or cdn.gooo.ai URLs (max 4)')
  .option('--hashtags <tags>', 'Comma-separated hashtags (max 2)')
  .action(async (opts) => {
    let content = opts.text || '';
    if (opts.file) {
      content = readFileSync(resolve(opts.file), 'utf-8');
    }
    if (!content) {
      console.error('Error: --text or --file required');
      process.exit(1);
    }

    const config = loadXConfig();
    if (!config.apiKey) {
      console.error('[ERROR] youmind.api_key not set. Configure ~/.youmind/config.yaml.');
      process.exit(1);
    }

    const hashtags = opts.hashtags
      ? opts.hashtags.split(',').map((h: string) => h.trim())
      : undefined;

    const result = await publishTweet({
      content,
      mediaUrls: opts.image,
      hashtags,
      config,
    });

    if (result.success) {
      const post = result.posts[0];
      console.log('\nTweet published via YouMind OpenAPI!');
      console.log(`Post ID: ${post.postId}`);
      console.log(`URL:     ${post.url}`);
    } else {
      console.error(`\nPublish failed: ${result.error}`);
    }

    if (result.warnings.length > 0) {
      console.log('\nWarnings:');
      for (const w of result.warnings) console.log(`  - ${w}`);
    }

    console.log(`\nText (${(result.content as string).length} chars):`);
    console.log('---');
    console.log(result.content);
    console.log('---');
  });

program
  .command('thread')
  .description('Publish a sequence of numbered tweets from long-form content')
  .option('--text <text>', 'Thread content')
  .option('--file <path>', 'Read content from a file')
  .option('--image <pathsOrUrls...>', 'Local image paths or cdn.gooo.ai URLs attached to the first tweet only')
  .option('--hashtags <tags>', 'Comma-separated hashtags')
  .option('--no-numbering', 'Disable tweet numbering')
  .action(async (opts) => {
    let content = opts.text || '';
    if (opts.file) {
      content = readFileSync(resolve(opts.file), 'utf-8');
    }
    if (!content) {
      console.error('Error: --text or --file required');
      process.exit(1);
    }

    const config = loadXConfig();
    if (!config.apiKey) {
      console.error('[ERROR] youmind.api_key not set. Configure ~/.youmind/config.yaml.');
      process.exit(1);
    }

    const hashtags = opts.hashtags
      ? opts.hashtags.split(',').map((h: string) => h.trim())
      : undefined;

    const result = await publishThread({
      content,
      mediaUrls: opts.image,
      hashtags,
      addNumbering: opts.numbering !== false,
      config,
    });

    if (result.success) {
      console.log(
        `\nThread published via YouMind OpenAPI (${result.posts.length} tweets)`,
      );
      for (let i = 0; i < result.posts.length; i++) {
        console.log(`  ${i + 1}. ${result.posts[i].url}`);
      }
    } else {
      console.error(`\nPublish failed: ${result.error}`);
      if (result.posts.length > 0) {
        console.log(`Published before failure: ${result.posts.length}`);
        for (let i = 0; i < result.posts.length; i++) {
          console.log(`  ${i + 1}. ${result.posts[i].url}`);
        }
      }
    }

    if (result.warnings.length > 0) {
      console.log('\nWarnings:');
      for (const w of result.warnings) console.log(`  - ${w}`);
    }

    const tweets = Array.isArray(result.content) ? result.content : [String(result.content)];
    console.log(`\nThread preview (${tweets.length} tweets):`);
    for (let i = 0; i < tweets.length; i++) {
      console.log(`\n--- Tweet ${i + 1} ---`);
      console.log(tweets[i]);
    }
  });

program
  .command('preview')
  .description('Preview formatted content without publishing')
  .option('--text <text>', 'Content text')
  .option('--file <path>', 'Read content from a file')
  .option('--mode <mode>', 'tweet or thread', 'tweet')
  .option('--hashtags <tags>', 'Comma-separated hashtags')
  .option('--no-numbering', 'Disable thread numbering')
  .action((opts) => {
    let content = opts.text || '';
    if (opts.file) {
      content = readFileSync(resolve(opts.file), 'utf-8');
    }
    if (!content) {
      console.error('Error: --text or --file required');
      process.exit(1);
    }

    const hashtags = opts.hashtags
      ? opts.hashtags.split(',').map((h: string) => h.trim())
      : undefined;

    if (opts.mode === 'thread') {
      const result = previewThread(content, {
        hashtags,
        addNumbering: opts.numbering !== false,
      });
      console.log(`Thread preview: ${result.totalTweets} tweets\n`);
      for (let i = 0; i < result.tweets.length; i++) {
        console.log(`--- Tweet ${i + 1} ---`);
        console.log(result.tweets[i]);
        console.log('');
      }
      if (result.warnings.length > 0) {
        console.log('Warnings:');
        for (const w of result.warnings) console.log(`  - ${w}`);
      }
    } else {
      const result = previewTweet(content, { hashtags });
      console.log(`Character count: ${result.charCount}/280`);
      if (result.warnings.length > 0) {
        console.log('\nWarnings:');
        for (const w of result.warnings) console.log(`  - ${w}`);
      }
      console.log('\n--- Preview ---');
      console.log(result.text);
      console.log('--- End ---');
    }
  });

program
  .command('validate')
  .description('Validate YouMind credentials from ~/.youmind config')
  .action(() => {
    const config = loadXConfig();

    if (!config.apiKey) {
      console.error('[ERROR] youmind.api_key not set. Configure ~/.youmind/config.yaml.');
      console.error(
        'Get a key: https://youmind.com/settings/api-keys?utm_source=youmind-x-article',
      );
      process.exit(1);
    }

    console.log('YouMind API key is configured.');
    console.log(`Base URL: ${config.baseUrl}`);
    console.log(
      'X account connection is validated on the first publish call; ' +
        'if your X account is not connected in YouMind yet, publishing will return a clear error with a connect URL.',
    );
  });

program
  .command('delete')
  .description('Delete a tweet by ID')
  .argument('<postId>', 'Tweet ID')
  .option('-y, --yes', 'Skip confirmation prompt')
  .action(async (postId: string, opts) => {
    const config = loadXConfig();
    if (!config.apiKey) {
      console.error('[ERROR] youmind.api_key not set. Configure ~/.youmind/config.yaml.');
      process.exit(1);
    }
    if (!opts.yes) {
      console.error(`Refusing to delete ${postId} without --yes. Re-run with -y to confirm.`);
      process.exit(1);
    }

    try {
      const result = await deleteXPost(config, postId);
      if (!result.ok) {
        console.error(`Delete returned ok=false for ${result.postId}.`);
        process.exit(1);
      }
      console.log(`Deleted tweet ${result.postId}.`);
    } catch (err) {
      console.error(`Delete failed: ${(err as Error).message}`);
      process.exit(1);
    }
  });

program.parse();

import { existsSync, readFileSync } from 'node:fs';
import { dirname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';
import { parse as parseYaml } from 'yaml';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const SKILL_CONFIG_NAME = 'youmind-x-article';

export const DEFAULT_YOUMIND_OPENAPI_BASE_URL = 'https://youmind.com/openapi/v1';
export const YOUMIND_CONFIG_ERROR_HINT =
  `Set youmind.api_key in ~/.youmind/config.yaml. Optional skill overrides live in ~/.youmind/config/${SKILL_CONFIG_NAME}.yaml.`;

function getHomeDir(): string {
  return process.env.HOME || process.env.USERPROFILE || '';
}

function loadYamlFile(path: string): Record<string, unknown> {
  if (!path || !existsSync(path)) {
    return {};
  }
  return (parseYaml(readFileSync(path, 'utf-8')) ?? {}) as Record<string, unknown>;
}

function isPlainObject(value: unknown): value is Record<string, unknown> {
  return typeof value === 'object' && value !== null && !Array.isArray(value);
}

function hasConfiguredValue(value: unknown): boolean {
  if (value === undefined || value === null) {
    return false;
  }
  if (typeof value === 'string') {
    return value.trim().length > 0;
  }
  return true;
}

function mergeWithFallback(
  primary: Record<string, unknown>,
  fallback: Record<string, unknown>,
): Record<string, unknown> {
  const result: Record<string, unknown> = { ...primary };

  for (const [key, fallbackValue] of Object.entries(fallback)) {
    const currentValue = result[key];

    if (isPlainObject(currentValue) && isPlainObject(fallbackValue)) {
      result[key] = mergeWithFallback(currentValue, fallbackValue);
      continue;
    }

    if (!hasConfiguredValue(currentValue) && hasConfiguredValue(fallbackValue)) {
      result[key] = fallbackValue;
    }
  }

  return result;
}

function loadSharedConfig(): Record<string, unknown> {
  const home = getHomeDir();
  if (!home) {
    return {};
  }
  return loadYamlFile(resolve(home, '.youmind', 'config.yaml'));
}

function loadSkillOverrideConfig(): Record<string, unknown> {
  const home = getHomeDir();
  if (!home) {
    return {};
  }
  return loadYamlFile(resolve(home, '.youmind', 'config', `${SKILL_CONFIG_NAME}.yaml`));
}

export function normalizeBaseUrl(value: string | undefined): string {
  if (!value) return '';
  const trimmed = value.replace(/\/+$/, '');
  if (trimmed.endsWith('/openapi/v1')) return trimmed;
  if (trimmed.endsWith('/openapi')) return `${trimmed}/v1`;
  return `${trimmed}/openapi/v1`;
}

function getImageYouMindConfig(raw: Record<string, unknown>): Record<string, unknown> {
  const image = raw.image;
  if (!isPlainObject(image)) {
    return {};
  }
  const providers = image.providers;
  if (!isPlainObject(providers)) {
    return {};
  }
  const youmind = providers.youmind;
  return isPlainObject(youmind) ? youmind : {};
}

export function loadLayeredConfig(): Record<string, unknown> {
  return mergeWithFallback(loadSkillOverrideConfig(), loadSharedConfig());
}

export function loadYouMindConfig(): {
  apiKey: string;
  baseUrl: string;
  raw: Record<string, unknown>;
} {
  const raw = loadLayeredConfig();
  const youmind = isPlainObject(raw.youmind) ? raw.youmind : {};
  const imageYouMind = getImageYouMindConfig(raw);
  const apiKey =
    (typeof youmind.api_key === 'string' && youmind.api_key) ||
    (typeof imageYouMind.api_key === 'string' && imageYouMind.api_key) ||
    '';
  const configuredBaseUrl =
    typeof youmind.base_url === 'string' ? normalizeBaseUrl(youmind.base_url) : '';

  return {
    raw,
    apiKey,
    baseUrl: configuredBaseUrl || DEFAULT_YOUMIND_OPENAPI_BASE_URL,
  };
}

/**
 * X (Twitter) content adaptation module.
 *
 * Handles:
 * - Single tweet: 280 character limit (URLs = 23 chars)
 * - Thread splitting algorithm with smart paragraph boundaries
 * - Tweet numbering (1/N format)
 * - Hashtag management (1-2 max)
 * - Long-form article support (25K chars, X Premium)
 */

// ---------------------------------------------------------------------------
// Constants
// ---------------------------------------------------------------------------

const TWEET_CHAR_LIMIT = 280;
const URL_CHAR_COUNT = 23; // X counts all URLs as 23 chars
const THREAD_NUMBER_OVERHEAD = 6; // " (1/N)" at the end, max 6 chars for small threads
const LONG_FORM_LIMIT = 25_000;

// ---------------------------------------------------------------------------
// Types
// ---------------------------------------------------------------------------

export interface SingleTweetResult {
  text: string;
  charCount: number;
  wasTruncated: boolean;
  warnings: string[];
}

export interface ThreadResult {
  tweets: string[];
  totalTweets: number;
  totalChars: number;
  warnings: string[];
}

export interface AdaptOptions {
  /** Maximum chars per tweet (default: 280) */
  maxChars?: number;
  /** Hashtags to include (1-2 recommended) */
  hashtags?: string[];
  /** Whether to add thread numbering */
  addNumbering?: boolean;
  /** Force long-form article mode (X Premium, 25K chars) */
  longForm?: boolean;
}

// ---------------------------------------------------------------------------
// URL handling
// ---------------------------------------------------------------------------

const URL_REGEX = /https?:\/\/[^\s)]+/g;

/**
 * Calculate the "weighted" character count where URLs count as 23 chars.
 */
export function weightedCharCount(text: string): number {
  const urls = text.match(URL_REGEX) || [];
  let count = text.length;
  for (const url of urls) {
    // Each URL is counted as 23 chars regardless of length
    count = count - url.length + URL_CHAR_COUNT;
  }
  return count;
}

// ---------------------------------------------------------------------------
// Single tweet adaptation
// ---------------------------------------------------------------------------

/**
 * Adapt content for a single tweet (280 chars).
 */
export function adaptSingleTweet(
  content: string,
  options: AdaptOptions = {},
): SingleTweetResult {
  const maxChars = options.maxChars ?? TWEET_CHAR_LIMIT;
  const warnings: string[] = [];

  // Strip Markdown formatting
  let text = stripMarkdown(content).trim();

  // Add hashtags
  if (options.hashtags?.length) {
    const hashtagStr = options.hashtags
      .slice(0, 2) // Max 2 hashtags on X
      .map((h) => (h.startsWith('#') ? h : `#${h}`))
      .join(' ');
    text = text + '\n\n' + hashtagStr;
  }

  // Check length
  let wasTruncated = false;
  const weighted = weightedCharCount(text);

  if (weighted > maxChars) {
    wasTruncated = true;
    text = truncateToLimit(text, maxChars);
    warnings.push(
      `Tweet truncated from ${weighted} to ${weightedCharCount(text)} chars (limit: ${maxChars}).`,
    );
  }

  return {
    text,
    charCount: weightedCharCount(text),
    wasTruncated,
    warnings,
  };
}

// ---------------------------------------------------------------------------
// Thread splitting
// ---------------------------------------------------------------------------

/**
 * Split long-form content into a thread of tweets.
 *
 * Algorithm:
 * 1. Split on paragraph boundaries
 * 2. Each tweet <= 280 chars (including numbering)
 * 3. First tweet = hook, last = CTA/summary
 * 4. Each tweet should make sense standalone
 */
export function splitIntoThread(
  content: string,
  options: AdaptOptions = {},
): ThreadResult {
  const maxChars = options.maxChars ?? TWEET_CHAR_LIMIT;
  const addNumbering = options.addNumbering !== false;
  const warnings: string[] = [];

  // Strip Markdown
  let text = stripMarkdown(content).trim();

  // Split into paragraphs
  const paragraphs = text.split(/\n\n+/).filter((p) => p.trim().length > 0);

  if (paragraphs.length === 0) {
    return { tweets: [], totalTweets: 0, totalChars: 0, warnings: ['Empty content.'] };
  }

  // Estimate total tweets for numbering overhead
  const estimatedTweets = Math.max(
    Math.ceil(text.length / (maxChars - THREAD_NUMBER_OVERHEAD - 2)),
    paragraphs.length,
  );
  const numberingLen = addNumbering
    ? ` (${estimatedTweets}/${estimatedTweets})`.length
    : 0;
  const effectiveMax = maxChars - numberingLen;

  // Build tweets by fitting paragraphs
  const tweets: string[] = [];
  let currentTweet = '';

  for (const para of paragraphs) {
    const trimmedPara = para.trim();

    if (weightedCharCount(trimmedPara) > effectiveMax) {
      // Paragraph too long -- split by sentences
      if (currentTweet) {
        tweets.push(currentTweet.trim());
        currentTweet = '';
      }

      const sentences = splitSentences(trimmedPara);
      for (const sentence of sentences) {
        const candidate = currentTweet
          ? currentTweet + ' ' + sentence
          : sentence;

        if (weightedCharCount(candidate) <= effectiveMax) {
          currentTweet = candidate;
        } else {
          if (currentTweet) {
            tweets.push(currentTweet.trim());
          }
          // If a single sentence exceeds limit, force-truncate
          if (weightedCharCount(sentence) > effectiveMax) {
            tweets.push(truncateToLimit(sentence, effectiveMax));
            currentTweet = '';
            warnings.push('A sentence exceeded the character limit and was truncated.');
          } else {
            currentTweet = sentence;
          }
        }
      }
    } else {
      // Try to fit paragraph into current tweet
      const candidate = currentTweet
        ? currentTweet + '\n\n' + trimmedPara
        : trimmedPara;

      if (weightedCharCount(candidate) <= effectiveMax) {
        currentTweet = candidate;
      } else {
        // Current tweet is full, start new one
        if (currentTweet) {
          tweets.push(currentTweet.trim());
        }
        currentTweet = trimmedPara;
      }
    }
  }

  // Don't forget the last tweet
  if (currentTweet.trim()) {
    tweets.push(currentTweet.trim());
  }

  // Add hashtags to the last tweet if they fit
  if (options.hashtags?.length && tweets.length > 0) {
    const hashtagStr = options.hashtags
      .slice(0, 2)
      .map((h) => (h.startsWith('#') ? h : `#${h}`))
      .join(' ');
    const lastIdx = tweets.length - 1;
    const candidate = tweets[lastIdx] + '\n\n' + hashtagStr;
    if (weightedCharCount(candidate) + numberingLen <= maxChars) {
      tweets[lastIdx] = candidate;
    } else {
      // Add as separate final tweet
      tweets.push(hashtagStr);
    }
  }

  // Add numbering
  const total = tweets.length;
  if (addNumbering && total > 1) {
    for (let i = 0; i < total; i++) {
      tweets[i] = `${tweets[i]}\n\n${i + 1}/${total}`;
    }
  }

  // Validate all tweets are within limit
  for (let i = 0; i < tweets.length; i++) {
    const wc = weightedCharCount(tweets[i]);
    if (wc > maxChars) {
      warnings.push(`Tweet ${i + 1} is ${wc} chars (limit: ${maxChars}). May need manual editing.`);
    }
  }

  const totalChars = tweets.reduce((sum, t) => sum + weightedCharCount(t), 0);

  return {
    tweets,
    totalTweets: tweets.length,
    totalChars,
    warnings,
  };
}

// ---------------------------------------------------------------------------
// Long-form article (X Premium)
// ---------------------------------------------------------------------------

/**
 * Adapt for X long-form article (Premium feature, 25K chars).
 */
export function adaptLongForm(
  content: string,
  options: AdaptOptions = {},
): { text: string; charCount: number; wasTruncated: boolean; warnings: string[] } {
  const maxChars = LONG_FORM_LIMIT;
  const warnings: string[] = [];

  // Long-form supports Markdown, so keep it
  let text = content.trim();

  // Add hashtags
  if (options.hashtags?.length) {
    const hashtagStr = options.hashtags
      .map((h) => (h.startsWith('#') ? h : `#${h}`))
      .join(' ');
    text = text + '\n\n' + hashtagStr;
  }

  let wasTruncated = false;
  if (text.length > maxChars) {
    wasTruncated = true;
    text = text.slice(0, maxChars - 3) + '...';
    warnings.push(`Content truncated to ${maxChars} characters (X Premium long-form limit).`);
  }

  return {
    text,
    charCount: text.length,
    wasTruncated,
    warnings,
  };
}

// ---------------------------------------------------------------------------
// Helpers
// ---------------------------------------------------------------------------

/** Strip Markdown syntax to plain text. */
function stripMarkdown(md: string): string {
  let text = md;

  // Remove headers
  text = text.replace(/^#{1,6}\s+/gm, '');

  // Bold/italic -> plain
  text = text.replace(/\*\*(.+?)\*\*/g, '$1');
  text = text.replace(/__(.+?)__/g, '$1');
  text = text.replace(/(?<!\*)\*(?!\*)(.+?)(?<!\*)\*(?!\*)/g, '$1');
  text = text.replace(/(?<!_)_(?!_)(.+?)(?<!_)_(?!_)/g, '$1');

  // Inline code
  text = text.replace(/`([^`]+)`/g, '$1');

  // Code blocks
  text = text.replace(/```[\s\S]*?```/g, '');

  // Links: [text](url) -> text url
  text = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, '$1 $2');

  // Images
  text = text.replace(/!\[([^\]]*)\]\([^)]+\)/g, '');

  // Horizontal rules
  text = text.replace(/^[-*_]{3,}$/gm, '');

  // Blockquotes
  text = text.replace(/^>\s?/gm, '');

  // List markers
  text = text.replace(/^[\s]*[-*]\s+/gm, '- ');
  text = text.replace(/^[\s]*(\d+)\.\s+/gm, '$1. ');

  // Collapse extra whitespace
  text = text.replace(/\n{3,}/g, '\n\n');

  return text.trim();
}

/** Split text into sentences. */
function splitSentences(text: string): string[] {
  // Split on sentence-ending punctuation followed by space
  const parts = text.split(/(?<=[.!?])\s+/);
  return parts.filter((s) => s.trim().length > 0);
}

/** Truncate text to fit within a character limit (weighted). */
function truncateToLimit(text: string, limit: number): string {
  if (weightedCharCount(text) <= limit) return text;

  // Try truncating at sentence boundary
  const sentences = splitSentences(text);
  let result = '';
  for (const sentence of sentences) {
    const candidate = result ? result + ' ' + sentence : sentence;
    if (weightedCharCount(candidate) <= limit - 1) {
      result = candidate;
    } else {
      break;
    }
  }

  if (result) return result;

  // Hard truncate
  let truncated = text;
  while (weightedCharCount(truncated + '...') > limit && truncated.length > 0) {
    // Remove last word
    const lastSpace = truncated.lastIndexOf(' ');
    if (lastSpace > 0) {
      truncated = truncated.slice(0, lastSpace);
    } else {
      truncated = truncated.slice(0, truncated.length - 1);
    }
  }

  return truncated + '...';
}

/**
 * X (Twitter) publishing orchestrator via YouMind OpenAPI.
 *
 * Content adaptation (280-char clamp + thread splitting) lives here. The
 * actual HTTP call is `createXPost` from `./x-api.js`. Threads are built
 * natively by chaining each tweet as a reply to the previous one (via
 * `replyToPostId`), so X renders the sequence as a proper thread.
 */

import { existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from 'node:fs';
import { basename, dirname, extname, resolve } from 'node:path';
import { fileURLToPath } from 'node:url';

import {
  adaptSingleTweet,
  splitIntoThread,
  type AdaptOptions,
} from './content-adapter.js';
import {
  createXPost,
  loadXConfig,
  uploadXMedia,
  type XConfig,
  type XPost,
} from './x-api.js';

const __filename = fileURLToPath(import.meta.url);
const __dirname = dirname(__filename);
const PROJECT_DIR = resolve(__dirname, '../..');

export interface PublishTweetOptions {
  /** Raw text or Markdown content */
  content: string;
  /** Optional local image paths or cdn.gooo.ai URLs. Max 4. */
  mediaUrls?: string[];
  /** Custom hashtags (1-2 recommended) */
  hashtags?: string[];
  /** X config override */
  config?: XConfig;
}

export interface PublishThreadOptions {
  /** Raw text or Markdown content to split into a thread */
  content: string;
  /** Optional local image paths or cdn.gooo.ai URLs attached to the first tweet only. Max 4. */
  mediaUrls?: string[];
  /** Custom hashtags (added to last tweet) */
  hashtags?: string[];
  /** Add numbering (default: true) */
  addNumbering?: boolean;
  /** X config override */
  config?: XConfig;
}

export interface PublishResult {
  success: boolean;
  type: 'tweet' | 'thread';
  posts: XPost[];
  content: string | string[];
  warnings: string[];
  error?: string;
}

const MIME_BY_EXTENSION = new Map<string, string>([
  ['.jpg', 'image/jpeg'],
  ['.jpeg', 'image/jpeg'],
  ['.png', 'image/png'],
  ['.gif', 'image/gif'],
  ['.webp', 'image/webp'],
]);

async function prepareMedia(
  inputs: string[] | undefined,
  config: XConfig,
): Promise<{ mediaUrls?: string[]; mediaIds?: string[] }> {
  if (!inputs?.length) {
    return {};
  }

  const mediaUrls: string[] = [];
  const mediaIds: string[] = [];

  for (const input of inputs) {
    const remoteUrl = parseAnyRemoteUrl(input);
    if (remoteUrl) {
      if (remoteUrl.hostname === 'cdn.gooo.ai') {
        mediaUrls.push(input);
      }
      continue;
    }

    const localPath = resolve(input);
    if (!existsSync(localPath)) {
      throw new Error(`Local image not found: ${localPath}`);
    }
    if (!statSync(localPath).isFile()) {
      throw new Error(`Local image is not a file: ${localPath}`);
    }

    const filename = basename(localPath);
    const contentType = inferMimeType(filename);
    if (!contentType) {
      throw new Error(
        `Unsupported local image type for X upload: ${filename} (allowed: jpg, jpeg, png, gif, webp)`,
      );
    }

    const uploaded = await uploadXMedia(config, {
      filename,
      contentBase64: readFileSync(localPath).toString('base64'),
      contentType,
    });
    mediaIds.push(uploaded.mediaId);
  }

  return {
    mediaUrls: mediaUrls.length > 0 ? mediaUrls : undefined,
    mediaIds: mediaIds.length > 0 ? mediaIds : undefined,
  };
}

function parseAnyRemoteUrl(input: string): URL | null {
  try {
    return new URL(input);
  } catch {
    return null;
  }
}

function collectRemoteWarnings(inputs: string[] | undefined, warnings: string[]): void {
  if (!inputs?.length) return;
  for (const input of inputs) {
    try {
      const parsed = new URL(input);
      if (parsed.hostname !== 'cdn.gooo.ai') {
        warnings.push(
          `Skipped media URL not under cdn.gooo.ai: ${input} (use a local file path or upload to YouMind CDN first)`,
        );
      }
    } catch {
      // 本地路径由 prepareMedia 继续处理，不在这里报 warning
    }
  }
}

function inferMimeType(filename: string): string | undefined {
  return MIME_BY_EXTENSION.get(extname(filename).toLowerCase());
}

export async function publishTweet(
  options: PublishTweetOptions,
): Promise<PublishResult> {
  const config = options.config ?? loadXConfig();

  if (!config.apiKey) {
    return {
      success: false,
      type: 'tweet',
      posts: [],
      content: options.content,
      warnings: [],
      error: 'youmind.api_key not set. Configure ~/.youmind/config.yaml.',
    };
  }

  const adapted = adaptSingleTweet(options.content, { hashtags: options.hashtags });
  collectRemoteWarnings(options.mediaUrls, adapted.warnings);

  try {
    const media = await prepareMedia(options.mediaUrls, config);
    const post = await createXPost(config, {
      text: adapted.text,
      mediaUrls: media.mediaUrls,
      mediaIds: media.mediaIds,
    });
    saveOutput('tweet', { postId: post.postId, text: adapted.text, url: post.url });
    return {
      success: true,
      type: 'tweet',
      posts: [post],
      content: adapted.text,
      warnings: adapted.warnings,
    };
  } catch (err) {
    return {
      success: false,
      type: 'tweet',
      posts: [],
      content: adapted.text,
      warnings: adapted.warnings,
      error: (err as Error).message,
    };
  }
}

export async function publishThread(
  options: PublishThreadOptions,
): Promise<PublishResult> {
  const config = options.config ?? loadXConfig();

  if (!config.apiKey) {
    return {
      success: false,
      type: 'thread',
      posts: [],
      content: [],
      warnings: [],
      error: 'youmind.api_key not set. Configure ~/.youmind/config.yaml.',
    };
  }

  const thread = splitIntoThread(options.content, {
    hashtags: options.hashtags,
    addNumbering: options.addNumbering,
  });

  if (thread.tweets.length === 0) {
    return {
      success: false,
      type: 'thread',
      posts: [],
      content: [],
      warnings: ['No content to post.'],
      error: 'Empty content',
    };
  }

  if (thread.tweets.length === 1) {
    const result = await publishTweet({
      content: thread.tweets[0],
      mediaUrls: options.mediaUrls,
      config,
    });
    return {
      ...result,
      type: 'thread',
      content: [typeof result.content === 'string' ? result.content : thread.tweets[0]],
    };
  }

  const warnings = [...thread.warnings];
  collectRemoteWarnings(options.mediaUrls, warnings);
  const posts: XPost[] = [];

  try {
    const firstTweetMedia = await prepareMedia(options.mediaUrls, config);

    // Chain each tweet to the previous one so X renders the sequence as a
    // native thread instead of independent standalone tweets.
    let previousPostId: string | undefined;
    for (let i = 0; i < thread.tweets.length; i++) {
      try {
        const post = await createXPost(config, {
          text: thread.tweets[i],
          mediaUrls: i === 0 ? firstTweetMedia.mediaUrls : undefined,
          mediaIds: i === 0 ? firstTweetMedia.mediaIds : undefined,
          replyToPostId: previousPostId,
        });
        posts.push(post);
        previousPostId = post.postId;
        console.log(`Thread ${i + 1}/${thread.tweets.length}: ${post.postId}`);
      } catch (err) {
        return {
          success: false,
          type: 'thread',
          posts,
          content: thread.tweets,
          warnings,
          error: `Tweet ${i + 1}/${thread.tweets.length} failed: ${(err as Error).message}`,
        };
      }
    }
  } catch (err) {
    return {
      success: false,
      type: 'thread',
      posts,
      content: thread.tweets,
      warnings,
      error: (err as Error).message,
    };
  }

  saveOutput('thread', {
    postIds: posts.map((p) => p.postId),
    tweets: thread.tweets,
    urls: posts.map((p) => p.url),
    warnings,
  });

  return {
    success: true,
    type: 'thread',
    posts,
    content: thread.tweets,
    warnings,
  };
}

export function previewTweet(
  content: string,
  options: AdaptOptions = {},
): { text: string; charCount: number; warnings: string[] } {
  const adapted = adaptSingleTweet(content, options);
  return {
    text: adapted.text,
    charCount: adapted.charCount,
    warnings: adapted.warnings,
  };
}

export function previewThread(
  content: string,
  options: AdaptOptions = {},
): { tweets: string[]; totalTweets: number; warnings: string[] } {
  const thread = splitIntoThread(content, options);
  return {
    tweets: thread.tweets,
    totalTweets: thread.totalTweets,
    warnings: thread.warnings,
  };
}

function saveOutput(type: string, data: Record<string, unknown>): void {
  try {
    const outputDir = resolve(PROJECT_DIR, 'output');
    if (!existsSync(outputDir)) {
      mkdirSync(outputDir, { recursive: true });
    }
    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
    const outputPath = resolve(outputDir, `x-${type}-${timestamp}.json`);
    writeFileSync(
      outputPath,
      JSON.stringify({ ...data, timestamp: new Date().toISOString() }, null, 2),
    );
  } catch {
    // Non-critical, ignore
  }
}

/**
 * X (Twitter) client via YouMind OpenAPI (aggregated publishing endpoints).
 *
 * 后端统一在 6 个 resource 端点（/publishing/{connections,posts,media,engagement,taxonomy,insights}），
 * body = { platform, action, [actionKey]: payload }，platform=x 通过 discriminated union 区分。
 * 所有响应统一为 { platform, data }，本层自动解嵌套返回 data。
 * 旧 op 名（createPost / uploadMedia / deletePost）经 buildPublishingRequest 映射到对应端点与 action。
 */

import { loadYouMindConfig, YOUMIND_CONFIG_ERROR_HINT } from './config.js';

export interface XConfig {
  apiKey: string;
  baseUrl: string;
}

export interface CreateXPostOptions {
  text: string;
  /** Optional image URLs — must be publicly reachable https URLs under cdn.gooo.ai. Max 4. */
  mediaUrls?: string[];
  /** Optional pre-uploaded X media IDs returned by uploadXMedia. Max 4. */
  mediaIds?: string[];
  /**
   * Optional tweet ID this post replies to. Used to build threads — publish the first tweet,
   * then pass its `postId` here for each subsequent tweet so X renders the chain natively.
   */
  replyToPostId?: string;
}

export interface XPost {
  postId: string;
  text: string;
  url: string;
}

export interface DeleteXPostResult {
  ok: boolean;
  postId: string;
}

export interface UploadXMediaOptions {
  filename: string;
  contentBase64: string;
  contentType?: string;
}

export interface UploadedXMedia {
  mediaId: string;
}

interface OpenApiErrorDetail {
  connectUrl?: string;
  upgradeUrl?: string;
  hint?: string;
}

interface OpenApiErrorResponse {
  message?: string;
  code?: string;
  detail?: OpenApiErrorDetail;
}

export function loadXConfig(): XConfig {
  const { apiKey, baseUrl } = loadYouMindConfig();
  return {
    apiKey,
    baseUrl,
  };
}

async function postJson<T = unknown>(
  endpoint: string,
  body: Record<string, unknown> = {},
  config?: XConfig,
): Promise<T> {
  const cfg = config ?? loadXConfig();
  if (!cfg.apiKey) {
    throw new Error(`YouMind API key not configured. ${YOUMIND_CONFIG_ERROR_HINT}`);
  }

  const response = await fetch(`${cfg.baseUrl}${endpoint}`, {
    method: 'POST',
    headers: {
      'Content-Type': 'application/json',
      'x-api-key': cfg.apiKey,
      'x-use-camel-case': 'true',
    },
    body: JSON.stringify(body),
    signal: AbortSignal.timeout(30_000),
  });

  if (!response.ok) {
    const text = await response.text().catch(() => '');
    const parsed = parseOpenApiError(text);
    throw new Error(
      `YouMind X API ${endpoint} failed (${response.status})` +
        `: ${formatOpenApiError(parsed, text)}`,
    );
  }

  return response.json() as Promise<T>;
}

// ─── 6-endpoint adapter: 后端把 26 个 publishing op 合并成 6 个 resource 端点 ───
// 每个端点 body = { platform, action, [actionKey]: <payload> }；insights 无 action（payload 平铺）。
const PUBLISHING_OP_MAP: Record<
  string,
  { route: string; action: string | null; key: string | null }
> = {
  // connections
  listConnections: { route: 'connections', action: 'list', key: 'list' },
  validateConnection: { route: 'connections', action: 'validate', key: null },
  disconnect: { route: 'connections', action: 'disconnect', key: 'disconnect' },
  authenticate: { route: 'connections', action: 'authenticate', key: 'authenticate' },
  getCredentials: { route: 'connections', action: 'getCredentials', key: null },
  // posts
  createPost: { route: 'posts', action: 'create', key: 'create' },
  updatePost: { route: 'posts', action: 'update', key: 'update' },
  getPost: { route: 'posts', action: 'get', key: 'get' },
  listPosts: { route: 'posts', action: 'list', key: 'list' },
  deletePost: { route: 'posts', action: 'delete', key: 'delete' },
  transitionPostState: { route: 'posts', action: 'transition', key: 'transition' },
  getPublishJob: { route: 'posts', action: 'getJob', key: 'getJob' },
  manageQueue: { route: 'posts', action: 'manageQueue', key: 'manageQueue' },
  // media
  uploadMedia: { route: 'media', action: 'upload', key: 'upload' },
  listMedia: { route: 'media', action: 'list', key: 'list' },
  deleteMedia: { route: 'media', action: 'delete', key: 'delete' },
  // engagement
  listEngagement: { route: 'engagement', action: 'list', key: 'list' },
  upsertEngagement: { route: 'engagement', action: 'upsert', key: 'upsert' },
  deleteEngagement: { route: 'engagement', action: 'delete', key: 'delete' },
  listSocial: { route: 'engagement', action: 'listSocial', key: 'listSocial' },
  setSocialAction: { route: 'engagement', action: 'setSocialAction', key: 'setSocialAction' },
  // taxonomy
  listTaxonomy: { route: 'taxonomy', action: 'list', key: 'list' },
  upsertTaxonomy: { route: 'taxonomy', action: 'upsert', key: 'upsert' },
  deleteTaxonomy: { route: 'taxonomy', action: 'delete', key: 'delete' },
  attachPostToTaxonomy: { route: 'taxonomy', action: 'attachPost', key: 'attachPost' },
  // insights（单操作，无 action 区分符）
  getInsights: { route: 'insights', action: null, key: null },
};

// 把旧的 { platform, ...payload } 调用重塑成新的 6-端点 body：{ platform, action, [key]: rest }。
function buildPublishingRequest(
  op: string,
  payload: Record<string, unknown>,
): { route: string; body: Record<string, unknown> } {
  const mapping = PUBLISHING_OP_MAP[op];
  if (!mapping) {
    throw new Error('Unknown publishing op: ' + op);
  }
  const { platform, ...rest } = payload;
  if (mapping.action === null) {
    // insights：scope / postId / dateRange 平铺，无 action
    return { route: mapping.route, body: { platform, ...rest } };
  }
  if (mapping.key === null) {
    // validate / getCredentials：仅需 platform + action，无 sub-payload
    return { route: mapping.route, body: { platform, action: mapping.action } };
  }
  return { route: mapping.route, body: { platform, action: mapping.action, [mapping.key]: rest } };
}

// 聚合层调用：包一层自动从 { platform, data } 解出 data，对外保持旧接口形状
async function callPublishing<T = unknown>(
  op: string,
  payload: Record<string, unknown>,
  config?: XConfig,
): Promise<T> {
  const { route, body } = buildPublishingRequest(op, payload);
  const wrapped = await postJson<{ platform: string; data: T }>(
    `/publishing/${route}`,
    body,
    config,
  );
  return wrapped.data;
}

function parseOpenApiError(text: string): OpenApiErrorResponse | null {
  try {
    return JSON.parse(text) as OpenApiErrorResponse;
  } catch {
    return null;
  }
}

function formatOpenApiError(parsed: OpenApiErrorResponse | null, rawText: string): string {
  if (!parsed) {
    return rawText.slice(0, 300);
  }

  const parts = [parsed.message, parsed.code, parsed.detail?.hint].filter(
    (value): value is string => typeof value === 'string' && value.length > 0,
  );

  if (parsed.detail?.connectUrl) {
    parts.push(`Connect X: ${parsed.detail.connectUrl}`);
  }

  if (parsed.detail?.upgradeUrl) {
    parts.push(`Upgrade plan: ${parsed.detail.upgradeUrl}`);
  }

  return parts.join(' | ') || rawText.slice(0, 300);
}

function normalizePost(raw: Record<string, unknown>): XPost {
  return {
    postId: String(raw.postId ?? raw.post_id ?? ''),
    text: String(raw.text ?? ''),
    url: String(raw.url ?? ''),
  };
}

/**
 * Publish a single tweet via the YouMind proxy.
 *
 * `options.mediaUrls` must be publicly reachable https URLs under cdn.gooo.ai
 * — the YouMind backend enforces this allowlist to avoid SSRF. Non-cdn URLs
 * will be rejected with `X_MEDIA_HOST_NOT_ALLOWED`.
 *
 * `options.replyToPostId` chains this tweet as a reply to an existing one.
 * That is how threads are built: publish the first tweet, then for each
 * subsequent tweet in the sequence pass the previous tweet's `postId` here.
 */
export async function createXPost(
  config: XConfig,
  options: CreateXPostOptions,
): Promise<XPost> {
  const post: Record<string, unknown> = {
    content: { format: 'plain', body: options.text },
  };
  if (options.mediaUrls?.length) post.mediaUrls = options.mediaUrls;
  if (options.mediaIds?.length) post.mediaIds = options.mediaIds;
  if (options.replyToPostId) post.replyToPostId = options.replyToPostId;
  const data = await callPublishing<Record<string, unknown>>(
    'createPost',
    { platform: 'x', post },
    config,
  );
  return normalizePost(data);
}

export async function uploadXMedia(
  config: XConfig,
  options: UploadXMediaOptions,
): Promise<UploadedXMedia> {
  const media: Record<string, unknown> = {
    kind: 'image',
    filename: options.filename,
    source: { base64: options.contentBase64 },
  };
  if (options.contentType) media.contentType = options.contentType;
  const data = await callPublishing<Record<string, unknown>>(
    'uploadMedia',
    { platform: 'x', media },
    config,
  );
  return { mediaId: String(data.mediaId ?? data.media_id ?? '') };
}

export async function deleteXPost(
  config: XConfig,
  postId: string,
): Promise<DeleteXPostResult> {
  const data = await callPublishing<Record<string, unknown>>(
    'deletePost',
    { platform: 'x', postId },
    config,
  );
  return {
    ok: Boolean(data.ok ?? true),
    postId: String(data.postId ?? data.post_id ?? postId),
  };
}