v1.7.1: FxTwitter Article enrichment — read+analyze auto-resolve Article bodies

Closes the Article-blindness gap surfaced when analyzing
@longevityboris's 2056280764447113305 ("Two species.", 204K imp, 17 likes,
1 profile click): xmaster previously saw only the t.co wrapper and
preflight was scoring an empty string. Now it scores the full 6,387-char
Article body.

## What changed

- New `src/providers/fxtwitter.rs` — soft-dependency client for
  api.fxtwitter.com. Returns `Article { id, title, body, body_chars,
  cover_image_url }` flattened from Draft.js blocks (header-two → "## ",
  unordered-list-item → "- ", blockquote → "> ", etc.). 2.5s timeout,
  graceful degradation on any failure.

- `xmaster read <id>`: when the tweet text looks like a single t.co URL,
  auto-fetches the Article body via FxTwitter and surfaces it in the
  output as an optional `article` field. Skips when
  `settings.disable_fxtwitter = true`.

- `xmaster analyze <id_or_url>`: auto-detects tweet IDs (15-25 digit
  numeric) and X URLs (`x.com/.../status/<id>`), fetches the tweet,
  resolves Article bodies through FxTwitter, then runs preflight on the
  actual content. Free-form text input still works unchanged. No new
  flag — pure friction reduction.

- `Settings.disable_fxtwitter: bool` (default false) — opt-out for users
  who want strict-v2-API-only behavior. Set via
  `xmaster config set settings.disable_fxtwitter true`.

- preflight.rs hashtag counter — fixed false positive on markdown
  header prefixes from flattened Article bodies. Now counts `#X` only
  where X is alphanumeric AND previous char isn't `#`, so `## Heading`
  doesn't trigger excessive_hashtags but `#rust #cli` still does.

## Verified live on Boris's "Two species." Article (id 2056280764447113305)

Before v1.7.1:
  `xmaster read 2056280764447113305` → text: "https://t.co/MAoQl3DbpC"
  (article body invisible)

After v1.7.1:
  `xmaster read 2056280764447113305` → article: {
    id: "2056263966406451201",
    title: "Two species.",
    body_chars: 6373,
    body: "AI is making most people dumber..." (full 6,373-char body)
  }

  `xmaster analyze 2056280764447113305` → scores the full Article (D, 45)
  with real findings: weak_hook_no_weight ("Two species." carries no
  number/named-entity/status-verb), long_form_too_long (6,387 > 5,000),
  negative_sentiment.

## Why FxTwitter, not the private GraphQL

- v2 API doesn't expose Article bodies (only t.co + entities.urls)
- Private GraphQL `ArticleEntityGet`-style endpoints rotate operation IDs
  every X deploy (xmaster's `article draft` path already feels this pain)
- FxTwitter (community service powering Discord/Telegram unfurls) returns
  the Article body as Draft.js blocks via `api.fxtwitter.com/i/status/<id>`
  with no auth, sub-second response, MIT-licensed, actively maintained
- Soft dep: timeout 2.5s, opt-out flag, falls back to v2 response on any
  failure — never blocks the user

## Tests

99 unit (+2 for the hashtag-markdown fix) + 29 integration pass; clippy
-D warnings clean. Two new fxtwitter.rs unit tests for block flattening
and wrapper detection.

Author: longevityboris

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "xmaster"
-version = "1.7.0"
+version = "1.7.1"
 edition = "2021"
 description = "Enterprise-grade X/Twitter CLI — post, reply, like, retweet, DM, search, and more"
 license = "MIT"

Cargo.toml

@@ -178,6 +178,19 @@ pub async fn execute(
     goal: Option<&str>,
     reply_to: Option<&str>,
 ) -> Result<(), XmasterError> {
+    // Auto-detect: if the input is a tweet ID or X URL, fetch the actual
+    // content. For Article wrappers (text = single t.co), enrich via
+    // FxTwitter and analyze the Article body instead of the t.co link.
+    // Friction-free: agents don't need a separate command to score a post.
+    let resolved_text = if let Some(id) = parse_tweet_reference(text) {
+        match resolve_post_content(&app, &id).await {
+            Ok(content) => content,
+            Err(_) => text.to_string(), // fall back to raw text on failure
+        }
+    } else {
+        text.to_string()
+    };
+
     let premium = app.config.account.premium;
     let voice = if app.config.style.voice.is_empty() { None } else { Some(app.config.style.voice.clone()) };
     let mode = reply_to.map(|_| PostMode::Reply);
@@ -188,8 +201,56 @@ pub async fn execute(
         author_voice: voice,
         ..Default::default()
     };
-    let result = preflight::analyze(text, &ctx);
+    let result = preflight::analyze(&resolved_text, &ctx);
     let display = AnalyzeDisplay { result, premium };
     output::render(format, &display, None);
     Ok(())
 }
+
+/// Detects whether the input refers to a tweet (numeric ID or X URL).
+/// Returns the bare tweet ID if so. None for free-form text.
+fn parse_tweet_reference(input: &str) -> Option<String> {
+    let trimmed = input.trim();
+    // URL form: https://x.com/<user>/status/<id> or twitter.com variant
+    if let Some(idx) = trimmed.find("/status/") {
+        let tail = &trimmed[idx + "/status/".len()..];
+        let id: String = tail.chars().take_while(|c| c.is_ascii_digit()).collect();
+        if id.len() >= 15 {
+            return Some(id);
+        }
+    }
+    // Numeric ID form (X tweet IDs are 18-19 digits today; allow 15+)
+    if trimmed.len() >= 15
+        && trimmed.len() <= 25
+        && trimmed.chars().all(|c| c.is_ascii_digit())
+    {
+        return Some(trimmed.to_string());
+    }
+    None
+}
+
+/// Fetch a post by ID. If the body is an Article wrapper, enrich with
+/// FxTwitter so preflight scores the actual Article content, not the t.co.
+async fn resolve_post_content(
+    app: &Arc<AppContext>,
+    tweet_id: &str,
+) -> Result<String, XmasterError> {
+    let api = crate::providers::xapi::XApi::new(app.clone());
+    let tweet = api.get_tweet(tweet_id).await?;
+    if !app.config.settings.disable_fxtwitter
+        && crate::providers::fxtwitter::text_looks_like_article_wrapper(&tweet.text)
+    {
+        if let Ok(Some(article)) = crate::providers::fxtwitter::fetch_article(&tweet.id).await {
+            // Title + body — gives preflight everything it needs to score the
+            // long-form correctly (hook strength, payoff density, POV, etc.).
+            let mut combined = String::new();
+            if !article.title.is_empty() {
+                combined.push_str(&article.title);
+                combined.push_str("\n\n");
+            }
+            combined.push_str(&article.body);
+            return Ok(combined);
+        }
+    }
+    Ok(tweet.text)
+}

src/commands/analyze.rs

@@ -3,6 +3,7 @@ use crate::context::AppContext;
 use crate::errors::XmasterError;
 use crate::intel::store::IntelStore;
 use crate::output::{self, OutputFormat, Tableable};
+use crate::providers::fxtwitter::{self, Article};
 use crate::providers::xapi::XApi;
 use serde::Serialize;
 use std::sync::Arc;
@@ -21,6 +22,10 @@ struct PostDisplay {
     date: Option<String>,
     #[serde(skip_serializing_if = "Vec::is_empty")]
     media_urls: Vec<String>,
+    /// X Article body, surfaced via FxTwitter when the tweet text is just a
+    /// t.co wrapper for an Article. `None` for regular tweets.
+    #[serde(skip_serializing_if = "Option::is_none")]
+    article: Option<Article>,
 }
 
 impl Tableable for PostDisplay {
@@ -41,6 +46,14 @@ impl Tableable for PostDisplay {
         for url in &self.media_urls {
             table.add_row(vec!["Media", url]);
         }
+        if let Some(ref art) = self.article {
+            table.add_row(vec!["Article ID", &art.id]);
+            table.add_row(vec!["Article Title", &art.title]);
+            table.add_row(vec![
+                "Article Body".to_string(),
+                format!("{} chars\n\n{}", art.body_chars, &art.body),
+            ]);
+        }
         table
     }
 }
@@ -57,6 +70,17 @@ pub async fn execute(
         let _ = store.record_discovered_post("read", &tweet);
     }
 
+    // Article enrichment: if the tweet text looks like a t.co Article wrapper,
+    // try FxTwitter (no auth, ~2.5s timeout, graceful degradation). Skip when
+    // disabled in config.
+    let article = if !ctx.config.settings.disable_fxtwitter
+        && fxtwitter::text_looks_like_article_wrapper(&tweet.text)
+    {
+        fxtwitter::fetch_article(&tweet.id).await.ok().flatten()
+    } else {
+        None
+    };
+
     let metrics = tweet.public_metrics.as_ref();
     let display = PostDisplay {
         id: tweet.id,
@@ -72,6 +96,7 @@ pub async fn execute(
         bookmarks: metrics.map(|m| m.bookmark_count).unwrap_or(0),
         date: tweet.created_at,
         media_urls: tweet.media_urls,
+        article,
     };
     output::render(format, &display, None);
     Ok(())

src/commands/read_post.rs

@@ -103,12 +103,21 @@ pub struct Keys {
 pub struct Settings {
     #[serde(default = "default_timeout")]
     pub timeout: u64,
+    /// Disable FxTwitter Article-enrichment fallback. Default false (enabled).
+    /// FxTwitter is the third-party service xmaster uses to read X Article
+    /// bodies — the public v2 API doesn't expose them. Set true to opt out;
+    /// `xmaster read`/`metrics`/`timeline` will still work but won't surface
+    /// Article content.
+    /// Set via: xmaster config set settings.disable_fxtwitter true
+    #[serde(default)]
+    pub disable_fxtwitter: bool,
 }
 
 impl Default for Settings {
     fn default() -> Self {
         Self {
             timeout: default_timeout(),
+            disable_fxtwitter: false,
         }
     }
 }

src/config.rs

@@ -1001,7 +1001,28 @@ fn extract_features(text: &str) -> FeatureVector {
     let has_link = text.contains("http://") || text.contains("https://");
     let link_position = if has_link { Some("body".into()) } else { None };
 
-    let hashtag_count = text.matches('#').count();
+    // Count real X hashtags only: `#` followed by alphanumeric (not space,
+    // not another `#`). Skips markdown `## ` header prefixes that surface in
+    // long-form / Article bodies fetched via FxTwitter.
+    let hashtag_count = {
+        let chars: Vec<char> = text.chars().collect();
+        let mut count = 0;
+        for (i, &c) in chars.iter().enumerate() {
+            if c != '#' {
+                continue;
+            }
+            // Previous char must NOT be `#` (skip ## / ### markdown)
+            if i > 0 && chars[i - 1] == '#' {
+                continue;
+            }
+            // Next char must be alphanumeric and NOT `#` (real hashtag)
+            match chars.get(i + 1) {
+                Some(&next) if next.is_alphanumeric() => count += 1,
+                _ => {}
+            }
+        }
+        count
+    };
     let has_question = text.contains('?');
     let has_numbers = text.chars().any(|c| c.is_ascii_digit());
     let starts_with_i = text.starts_with("I ") || text.starts_with("I'");
@@ -1769,4 +1790,29 @@ mod tests {
         // Sanity: at least one issue fires
         assert!(!result.issues.is_empty());
     }
+
+    #[test]
+    fn hashtag_count_ignores_markdown_headers() {
+        // v1.7.1 fix: long-form Article bodies surfaced by FxTwitter use
+        // markdown header prefixes (## / ### ) for header-two/three blocks.
+        // The hashtag check must NOT count these as real X hashtags.
+        let text = "## Introduction\n\nSome words here.\n\n### Subsection\n\nMore content.";
+        let result = analyze(text, &default_ctx());
+        assert!(
+            !result.issues.iter().any(|i| i.code == "excessive_hashtags"),
+            "markdown headers should not trigger excessive_hashtags; got: {:?}",
+            result.issues.iter().map(|i| &i.code).collect::<Vec<_>>()
+        );
+    }
+
+    #[test]
+    fn hashtag_count_still_catches_real_hashtags() {
+        let text = "Loving #rust #programming #cli #dev — all the fun";
+        let result = analyze(text, &default_ctx());
+        assert!(
+            result.issues.iter().any(|i| i.code == "excessive_hashtags"),
+            "real hashtags should still trigger; got: {:?}",
+            result.issues.iter().map(|i| &i.code).collect::<Vec<_>>()
+        );
+    }
 }