pythx-cli 0.0.3 → 0.0.5

package/dist/cli.js

@@ -1,9 +1,761 @@
 #!/usr/bin/env node
-import { jsx as _jsx } from "react/jsx-runtime";
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/cli.tsx
 import { render } from "ink";
 import meow from "meow";
-import { App } from "./app.js";
-const cli = meow(`
+
+// src/app.tsx
+import { useState as useState3 } from "react";
+import { Box as Box5, Text as Text5, useApp, useInput } from "ink";
+import chalk5 from "chalk";
+
+// src/components/header.tsx
+import { useState, useEffect } from "react";
+import { Box, Text } from "ink";
+import chalk from "chalk";
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function Header({ lastUpdated, loading }) {
+  const [secondsAgo, setSecondsAgo] = useState(0);
+  useEffect(() => {
+    if (!lastUpdated) return;
+    setSecondsAgo(Math.round((Date.now() - lastUpdated.getTime()) / 1e3));
+    const interval = setInterval(() => {
+      setSecondsAgo(Math.round((Date.now() - lastUpdated.getTime()) / 1e3));
+    }, 1e3);
+    return () => clearInterval(interval);
+  }, [lastUpdated]);
+  return /* @__PURE__ */ jsxs(
+    Box,
+    {
+      borderStyle: "single",
+      borderColor: "green",
+      paddingX: 1,
+      justifyContent: "space-between",
+      children: [
+        /* @__PURE__ */ jsxs(Text, { children: [
+          chalk.green.bold("PYTHX"),
+          chalk.dim("  \u2591\u2591  "),
+          chalk.white("SENTIMENT TERMINAL")
+        ] }),
+        /* @__PURE__ */ jsx(Text, { children: loading ? chalk.yellow("\u27F3 Loading...") : lastUpdated ? /* @__PURE__ */ jsxs(Fragment, { children: [
+          chalk.green("\u25CF "),
+          chalk.dim(`LIVE \xB7 ${secondsAgo}s ago`)
+        ] }) : chalk.dim("Waiting...") })
+      ]
+    }
+  );
+}
+
+// src/components/entity-row.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import chalk2 from "chalk";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var COL = {
+  name: 15,
+  score: 8,
+  trend: 10,
+  stat: 5
+};
+function formatScore(score) {
+  const prefix = score >= 0 ? "+" : "";
+  return `${prefix}${score.toFixed(2)}`;
+}
+function sparkline(distribution) {
+  const { positive, neutral, negative, total } = distribution;
+  if (total === 0) return chalk2.dim("\u2591".repeat(COL.trend));
+  const posWidth = Math.round(positive / total * COL.trend);
+  const negWidth = Math.round(negative / total * COL.trend);
+  const neuWidth = COL.trend - posWidth - negWidth;
+  return chalk2.green("\u2588".repeat(posWidth)) + chalk2.gray("\u2591".repeat(Math.max(0, neuWidth))) + chalk2.red("\u2588".repeat(negWidth));
+}
+function EntityRow({ analysis, isActive }) {
+  const { entity, snapshot } = analysis;
+  const { distribution } = snapshot;
+  const cursor = isActive ? chalk2.green("\u25B6 ") : "  ";
+  const name = entity.name.length > COL.name ? entity.name.substring(0, COL.name - 1) + "\u2026" : entity.name.padEnd(COL.name);
+  const score = formatScore(snapshot.averageScore).padStart(COL.score);
+  const trend = sparkline(distribution);
+  const pos = String(distribution.positive).padStart(COL.stat);
+  const neu = String(distribution.neutral).padStart(COL.stat);
+  const neg = String(distribution.negative).padStart(COL.stat);
+  const tot = String(distribution.total).padStart(COL.stat);
+  const colorName = isActive ? chalk2.green.bold(name) : chalk2.white(name);
+  const colorScore = snapshot.averageScore > 0.05 ? chalk2.green(score) : snapshot.averageScore < -0.05 ? chalk2.red(score) : chalk2.gray(score);
+  return /* @__PURE__ */ jsx2(Box2, { children: /* @__PURE__ */ jsxs2(Text2, { children: [
+    cursor,
+    colorName,
+    colorScore,
+    "  ",
+    trend,
+    chalk2.green(pos),
+    chalk2.gray(neu),
+    chalk2.red(neg),
+    chalk2.dim(tot)
+  ] }) });
+}
+
+// src/components/detail-panel.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import chalk3 from "chalk";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function formatPost(post) {
+  const { sentiment } = post;
+  const labelMap = {
+    positive: chalk3.green,
+    negative: chalk3.red,
+    neutral: chalk3.gray
+  };
+  const colorFn = labelMap[sentiment.label];
+  const tag = colorFn(
+    `[${sentiment.label.substring(0, 3).toUpperCase()} ${(sentiment.score * 100).toFixed(0)}%]`
+  );
+  const author = post.authorUsername ? chalk3.dim(`@${post.authorUsername}`) : chalk3.dim("@unknown");
+  const text2 = post.text.replace(/\n/g, " ").substring(0, 70).trim();
+  const ellipsis = post.text.length > 70 ? chalk3.dim("...") : "";
+  return `  ${tag} ${author}: "${text2}${ellipsis}"`;
+}
+function DetailPanel({ analysis }) {
+  const { entity, snapshot } = analysis;
+  const scoreColor = snapshot.averageScore > 0.05 ? chalk3.green : snapshot.averageScore < -0.05 ? chalk3.red : chalk3.gray;
+  const allPosts = [
+    ...snapshot.topPositive,
+    ...snapshot.topNegative
+  ].sort((a, b) => b.sentiment.score - a.sentiment.score);
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsxs3(Box3, { justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsxs3(Text3, { children: [
+            chalk3.green("\u25B6"),
+            " ",
+            chalk3.bold(entity.name.toUpperCase()),
+            chalk3.dim(" \u2014 Detail")
+          ] }),
+          /* @__PURE__ */ jsxs3(Text3, { children: [
+            chalk3.dim("avg: "),
+            scoreColor(
+              `${snapshot.averageScore >= 0 ? "+" : ""}${snapshot.averageScore.toFixed(3)}`
+            )
+          ] })
+        ] }),
+        /* @__PURE__ */ jsx3(Box3, { marginTop: 1, flexDirection: "column", children: allPosts.length === 0 ? /* @__PURE__ */ jsx3(Text3, { children: chalk3.dim("  No posts to display") }) : allPosts.slice(0, 8).map((post) => /* @__PURE__ */ jsx3(Text3, { children: formatPost(post) }, post.id)) })
+      ]
+    }
+  );
+}
+
+// src/components/status-bar.tsx
+import { Box as Box4, Text as Text4 } from "ink";
+import chalk4 from "chalk";
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function StatusBar() {
+  return /* @__PURE__ */ jsx4(
+    Box4,
+    {
+      borderStyle: "single",
+      borderColor: "gray",
+      paddingX: 1,
+      justifyContent: "center",
+      children: /* @__PURE__ */ jsxs4(Text4, { children: [
+        chalk4.dim("\u2591 "),
+        chalk4.white("q"),
+        chalk4.dim(":quit  "),
+        chalk4.white("\u2191\u2193"),
+        chalk4.dim(":navigate  "),
+        chalk4.white("enter"),
+        chalk4.dim(":expand  "),
+        chalk4.white("r"),
+        chalk4.dim(":refresh")
+      ] })
+    }
+  );
+}
+
+// src/hooks/use-live-data.ts
+import { useState as useState2, useEffect as useEffect2, useCallback } from "react";
+
+// ../core/src/entities.ts
+var DEFAULT_ENTITIES = [
+  {
+    id: "trump",
+    name: "Trump",
+    type: "person",
+    queries: [{ source: "x", query: "Trump -is:retweet lang:en" }],
+    icon: "user"
+  },
+  {
+    id: "bitcoin",
+    name: "Bitcoin",
+    type: "asset",
+    queries: [
+      {
+        source: "x",
+        query: "(Bitcoin OR BTC OR #Bitcoin) -is:retweet lang:en"
+      }
+    ],
+    icon: "bitcoin"
+  },
+  {
+    id: "ai",
+    name: "Artificial Intelligence",
+    type: "topic",
+    queries: [
+      {
+        source: "x",
+        query: '("artificial intelligence" OR #AI OR "machine learning") -is:retweet lang:en'
+      }
+    ],
+    icon: "brain"
+  }
+];
+
+// ../core/src/providers/x.ts
+var X_API_BASE = "https://api.x.com/2";
+var HTML_ENTITIES = {
+  "&amp;": "&",
+  "&lt;": "<",
+  "&gt;": ">",
+  "&quot;": '"',
+  "&#39;": "'",
+  "&apos;": "'"
+};
+function decodeHtmlEntities(text2) {
+  return text2.replace(
+    /&(?:amp|lt|gt|quot|#39|apos);/g,
+    (match) => HTML_ENTITIES[match] ?? match
+  );
+}
+var XProvider = class {
+  type = "x";
+  async fetchPosts(query, options) {
+    const token = process.env.X_BEARER_TOKEN;
+    if (!token) {
+      throw new Error("X_BEARER_TOKEN environment variable is required");
+    }
+    const params = new URLSearchParams({
+      query,
+      max_results: String(Math.min(Math.max(options.count, 10), 100)),
+      "tweet.fields": "created_at,public_metrics,author_id",
+      expansions: "author_id",
+      "user.fields": "username"
+    });
+    if (options.sinceId) {
+      params.set("since_id", options.sinceId);
+    }
+    const url = `${X_API_BASE}/tweets/search/recent?${params}`;
+    const response = await fetch(url, {
+      headers: {
+        Authorization: `Bearer ${token}`
+      }
+    });
+    if (!response.ok) {
+      const errorText = await response.text();
+      throw new Error(
+        `X API error (${response.status}): ${errorText}`
+      );
+    }
+    const json = await response.json();
+    if (!json.data || json.data.length === 0) {
+      return [];
+    }
+    const userMap = /* @__PURE__ */ new Map();
+    if (json.includes?.users) {
+      for (const user of json.includes.users) {
+        userMap.set(user.id, user.username);
+      }
+    }
+    return json.data.map((tweet) => ({
+      id: tweet.id,
+      source: "x",
+      text: decodeHtmlEntities(tweet.text),
+      authorId: tweet.author_id,
+      authorUsername: userMap.get(tweet.author_id),
+      createdAt: tweet.created_at ?? (/* @__PURE__ */ new Date()).toISOString(),
+      url: `https://x.com/i/status/${tweet.id}`,
+      metrics: {
+        upvotes: tweet.public_metrics?.like_count ?? 0,
+        comments: tweet.public_metrics?.reply_count ?? 0,
+        shares: tweet.public_metrics?.retweet_count ?? 0
+      }
+    }));
+  }
+  getModelId() {
+    return "cardiffnlp/twitter-roberta-base-sentiment-latest";
+  }
+};
+
+// ../core/src/providers/index.ts
+function getProvider(source) {
+  switch (source) {
+    case "x":
+      return new XProvider();
+    default:
+      throw new Error(`Provider not implemented: ${source}`);
+  }
+}
+
+// ../core/src/sentiment/classify.ts
+import { HfInference } from "@huggingface/inference";
+
+// ../core/src/sentiment/models.ts
+var MODEL_LABEL_MAP = {
+  "cardiffnlp/twitter-roberta-base-sentiment-latest": {
+    positive: "positive",
+    negative: "negative",
+    neutral: "neutral"
+  },
+  "nlptown/bert-base-multilingual-uncased-sentiment": {
+    "1 star": "negative",
+    "2 stars": "negative",
+    "3 stars": "neutral",
+    "4 stars": "positive",
+    "5 stars": "positive"
+  },
+  "ProsusAI/finbert": {
+    positive: "positive",
+    negative: "negative",
+    neutral: "neutral"
+  },
+  "distilbert-base-uncased-finetuned-sst-2-english": {
+    POSITIVE: "positive",
+    NEGATIVE: "negative"
+  }
+};
+function normalizeLabel(modelId, rawLabel) {
+  const map = MODEL_LABEL_MAP[modelId];
+  if (map) {
+    const normalized = map[rawLabel];
+    if (normalized) return normalized;
+  }
+  const lower = rawLabel.toLowerCase();
+  if (lower.includes("positive")) return "positive";
+  if (lower.includes("negative")) return "negative";
+  return "neutral";
+}
+
+// ../core/src/sentiment/classify.ts
+var hf = null;
+function getClient() {
+  if (!hf) {
+    const token = process.env.HF_API_TOKEN;
+    if (!token) {
+      throw new Error("HF_API_TOKEN environment variable is required");
+    }
+    hf = new HfInference(token);
+  }
+  return hf;
+}
+async function classifyPost(text2, modelId) {
+  const client = getClient();
+  const results = await client.textClassification({
+    model: modelId,
+    inputs: text2
+  });
+  if (!results || results.length === 0) {
+    return { label: "neutral", score: 0.5 };
+  }
+  const top = results[0];
+  return {
+    label: normalizeLabel(modelId, top.label),
+    score: top.score
+  };
+}
+var BATCH_SIZE = 5;
+async function classifyPosts(posts2, modelId) {
+  const results = [];
+  for (let i = 0; i < posts2.length; i += BATCH_SIZE) {
+    const batch = posts2.slice(i, i + BATCH_SIZE);
+    const classified = await Promise.all(
+      batch.map(async (post) => {
+        const sentiment = await classifyPost(post.text, modelId);
+        return { ...post, sentiment };
+      })
+    );
+    results.push(...classified);
+  }
+  return results;
+}
+
+// ../core/src/aggregator.ts
+function computeDistribution(posts2) {
+  let positive = 0;
+  let negative = 0;
+  let neutral = 0;
+  for (const post of posts2) {
+    switch (post.sentiment.label) {
+      case "positive":
+        positive++;
+        break;
+      case "negative":
+        negative++;
+        break;
+      case "neutral":
+        neutral++;
+        break;
+    }
+  }
+  return { positive, negative, neutral, total: posts2.length };
+}
+function computeAverageScore(posts2) {
+  if (posts2.length === 0) return 0;
+  const sum = posts2.reduce((acc, post) => {
+    if (post.sentiment.label === "positive") return acc + post.sentiment.score;
+    if (post.sentiment.label === "negative") return acc - post.sentiment.score;
+    return acc;
+  }, 0);
+  return sum / posts2.length;
+}
+function aggregate(posts2) {
+  const distribution = computeDistribution(posts2);
+  const averageScore = computeAverageScore(posts2);
+  const topPositive = posts2.filter((p) => p.sentiment.label === "positive").sort((a, b) => b.sentiment.score - a.sentiment.score).slice(0, 5);
+  const topNegative = posts2.filter((p) => p.sentiment.label === "negative").sort((a, b) => b.sentiment.score - a.sentiment.score).slice(0, 5);
+  const sourceGroups = /* @__PURE__ */ new Map();
+  for (const post of posts2) {
+    const group = sourceGroups.get(post.source) ?? [];
+    group.push(post);
+    sourceGroups.set(post.source, group);
+  }
+  const bySource = [];
+  for (const [source, sourcePosts] of sourceGroups) {
+    bySource.push({
+      source,
+      distribution: computeDistribution(sourcePosts),
+      averageScore: computeAverageScore(sourcePosts)
+    });
+  }
+  return {
+    timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+    distribution,
+    bySource,
+    averageScore,
+    topPositive,
+    topNegative
+  };
+}
+
+// ../core/src/db/client.ts
+import { drizzle } from "drizzle-orm/postgres-js";
+import postgres from "postgres";
+
+// ../core/src/db/schema.ts
+var schema_exports = {};
+__export(schema_exports, {
+  posts: () => posts,
+  snapshots: () => snapshots
+});
+import {
+  pgTable,
+  serial,
+  varchar,
+  text,
+  integer,
+  real,
+  timestamp,
+  jsonb,
+  uniqueIndex,
+  index
+} from "drizzle-orm/pg-core";
+var snapshots = pgTable(
+  "snapshots",
+  {
+    id: serial("id").primaryKey(),
+    entityId: varchar("entity_id", { length: 50 }).notNull(),
+    source: varchar("source", { length: 20 }),
+    timestamp: timestamp("timestamp", { withTimezone: true }).notNull().defaultNow(),
+    avgScore: real("avg_score").notNull(),
+    positiveCount: integer("positive_count").notNull(),
+    negativeCount: integer("negative_count").notNull(),
+    neutralCount: integer("neutral_count").notNull(),
+    totalCount: integer("total_count").notNull()
+  },
+  (table) => [
+    index("idx_snapshots_entity_time").on(table.entityId, table.timestamp),
+    index("idx_snapshots_source").on(
+      table.entityId,
+      table.source,
+      table.timestamp
+    )
+  ]
+);
+var posts = pgTable(
+  "posts",
+  {
+    id: serial("id").primaryKey(),
+    externalId: varchar("external_id", { length: 100 }).notNull(),
+    source: varchar("source", { length: 20 }).notNull(),
+    entityId: varchar("entity_id", { length: 50 }).notNull(),
+    text: text("text").notNull(),
+    authorId: varchar("author_id", { length: 100 }),
+    authorUsername: varchar("author_username", { length: 100 }),
+    url: text("url"),
+    createdAt: timestamp("created_at", { withTimezone: true }).notNull(),
+    fetchedAt: timestamp("fetched_at", { withTimezone: true }).notNull().defaultNow(),
+    upvotes: integer("upvotes").default(0),
+    comments: integer("comments").default(0),
+    shares: integer("shares").default(0),
+    sentimentLabel: varchar("sentiment_label", { length: 10 }).notNull(),
+    sentimentConfidence: real("sentiment_confidence").notNull(),
+    modelId: varchar("model_id", { length: 200 }).notNull(),
+    rawResponse: jsonb("raw_response")
+  },
+  (table) => [
+    uniqueIndex("idx_posts_dedup").on(table.externalId, table.source),
+    index("idx_posts_entity_time").on(table.entityId, table.createdAt),
+    index("idx_posts_source").on(table.source, table.createdAt),
+    index("idx_posts_sentiment").on(table.entityId, table.sentimentLabel)
+  ]
+);
+
+// ../core/src/db/client.ts
+var db = null;
+function getDb() {
+  if (db) return db;
+  const connectionString = process.env.POSTGRES_URL;
+  if (!connectionString) {
+    throw new Error("POSTGRES_URL environment variable is required");
+  }
+  const client = postgres(connectionString, { prepare: false });
+  db = drizzle(client, { schema: schema_exports });
+  return db;
+}
+
+// ../core/src/db/store.ts
+import { desc, eq } from "drizzle-orm";
+async function persistAnalysis(entityId, snapshot, posts2, modelId) {
+  const db2 = getDb();
+  await db2.insert(schema_exports.snapshots).values({
+    entityId,
+    source: null,
+    avgScore: snapshot.averageScore,
+    positiveCount: snapshot.distribution.positive,
+    negativeCount: snapshot.distribution.negative,
+    neutralCount: snapshot.distribution.neutral,
+    totalCount: snapshot.distribution.total
+  });
+  for (const breakdown of snapshot.bySource) {
+    await db2.insert(schema_exports.snapshots).values({
+      entityId,
+      source: breakdown.source,
+      avgScore: breakdown.averageScore,
+      positiveCount: breakdown.distribution.positive,
+      negativeCount: breakdown.distribution.negative,
+      neutralCount: breakdown.distribution.neutral,
+      totalCount: breakdown.distribution.total
+    });
+  }
+  if (posts2.length > 0) {
+    await db2.insert(schema_exports.posts).values(
+      posts2.map((post) => ({
+        externalId: post.id,
+        source: post.source,
+        entityId,
+        text: post.text,
+        authorId: post.authorId,
+        authorUsername: post.authorUsername ?? null,
+        url: post.url,
+        createdAt: new Date(post.createdAt),
+        upvotes: post.metrics.upvotes,
+        comments: post.metrics.comments,
+        shares: post.metrics.shares,
+        sentimentLabel: post.sentiment.label,
+        sentimentConfidence: post.sentiment.score,
+        modelId
+      }))
+    ).onConflictDoNothing({ target: [schema_exports.posts.externalId, schema_exports.posts.source] });
+  }
+}
+async function persistEntityAnalysis(analysis, modelId) {
+  await persistAnalysis(
+    analysis.entity.id,
+    analysis.snapshot,
+    analysis.posts,
+    modelId
+  );
+}
+async function loadCachedPosts(entityId, limit = 50) {
+  const db2 = getDb();
+  const rows = await db2.select().from(schema_exports.posts).where(eq(schema_exports.posts.entityId, entityId)).orderBy(desc(schema_exports.posts.createdAt)).limit(limit);
+  return rows.map((row) => ({
+    id: row.externalId,
+    source: row.source,
+    text: row.text,
+    authorId: row.authorId ?? "",
+    authorUsername: row.authorUsername ?? void 0,
+    createdAt: row.createdAt.toISOString(),
+    url: row.url ?? "",
+    metrics: {
+      upvotes: row.upvotes ?? 0,
+      comments: row.comments ?? 0,
+      shares: row.shares ?? 0
+    },
+    sentiment: {
+      label: row.sentimentLabel,
+      score: row.sentimentConfidence
+    }
+  }));
+}
+
+// src/hooks/use-live-data.ts
+var POLL_INTERVAL = 30 * 6e4;
+function useLiveData(apiUrl) {
+  const [data, setData] = useState2([]);
+  const [loading, setLoading] = useState2(true);
+  const [error, setError] = useState2(null);
+  const [lastUpdated, setLastUpdated] = useState2(null);
+  const fetchViaApi = useCallback(async () => {
+    if (!apiUrl) return;
+    try {
+      const res = await fetch(`${apiUrl}/api/compare`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
+          entityIds: DEFAULT_ENTITIES.map((e) => e.id),
+          count: 10
+        })
+      });
+      const json = await res.json();
+      if (json.success && json.data) {
+        setData(json.data);
+        setLastUpdated(/* @__PURE__ */ new Date());
+        setError(null);
+      } else {
+        setError(json.error ?? "API error");
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Fetch failed");
+    } finally {
+      setLoading(false);
+    }
+  }, [apiUrl]);
+  const loadFromCache = useCallback(async () => {
+    const results = [];
+    for (const entity of DEFAULT_ENTITIES) {
+      const cached = await loadCachedPosts(entity.id, 50);
+      if (cached.length === 0) continue;
+      const snapshot = aggregate(cached);
+      results.push({
+        entity,
+        snapshot,
+        posts: cached,
+        fetchedAt: cached[0]?.sentiment ? (/* @__PURE__ */ new Date()).toISOString() : (/* @__PURE__ */ new Date()).toISOString()
+      });
+    }
+    return results;
+  }, []);
+  const fetchDirect = useCallback(async () => {
+    try {
+      const results = [];
+      for (const entity of DEFAULT_ENTITIES) {
+        const allClassified = [];
+        for (const sq of entity.queries) {
+          const provider = getProvider(sq.source);
+          const posts2 = await provider.fetchPosts(sq.query, { count: 10 });
+          const classified = await classifyPosts(posts2, provider.getModelId());
+          allClassified.push(...classified);
+        }
+        const snapshot = aggregate(allClassified);
+        const analysis = {
+          entity,
+          snapshot,
+          posts: allClassified,
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        results.push(analysis);
+        try {
+          await persistEntityAnalysis(analysis, "hf-default");
+        } catch {
+        }
+      }
+      setData(results);
+      setLastUpdated(/* @__PURE__ */ new Date());
+      setError(null);
+    } catch (err) {
+      try {
+        const cached = await loadFromCache();
+        if (cached.length > 0) {
+          setData(cached);
+          setLastUpdated(/* @__PURE__ */ new Date());
+          setError("Live fetch failed \u2014 showing cached data");
+          return;
+        }
+      } catch {
+      }
+      setError(err instanceof Error ? err.message : "Analysis failed");
+    } finally {
+      setLoading(false);
+    }
+  }, [loadFromCache]);
+  const fetchData = apiUrl ? fetchViaApi : fetchDirect;
+  useEffect2(() => {
+    fetchData();
+    const interval = setInterval(fetchData, POLL_INTERVAL);
+    return () => clearInterval(interval);
+  }, [fetchData]);
+  return { data, loading, error, lastUpdated, refresh: fetchData };
+}
+
+// src/app.tsx
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+function App({ apiUrl }) {
+  const { data, loading, error, lastUpdated, refresh } = useLiveData(apiUrl);
+  const [activeIndex, setActiveIndex] = useState3(0);
+  const [showDetail, setShowDetail] = useState3(true);
+  const { exit } = useApp();
+  useInput((input, key) => {
+    if (input === "q") {
+      exit();
+    }
+    if (input === "r") {
+      refresh();
+    }
+    if (key.upArrow) {
+      setActiveIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow) {
+      setActiveIndex((i) => Math.min(data.length - 1, i + 1));
+    }
+    if (key.return) {
+      setShowDetail((s) => !s);
+    }
+  });
+  const activeAnalysis = data[activeIndex];
+  return /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", children: [
+    /* @__PURE__ */ jsx5(Header, { lastUpdated, loading }),
+    error && /* @__PURE__ */ jsx5(Box5, { paddingX: 1, children: /* @__PURE__ */ jsx5(Text5, { children: chalk5.red(`Error: ${error}`) }) }),
+    loading && data.length === 0 ? /* @__PURE__ */ jsx5(Box5, { paddingX: 1, paddingY: 1, children: /* @__PURE__ */ jsx5(Text5, { children: chalk5.yellow("\u27F3 Fetching sentiment data...") }) }) : /* @__PURE__ */ jsxs5(Box5, { flexDirection: "column", paddingX: 1, children: [
+      /* @__PURE__ */ jsx5(Box5, { marginY: 1, children: /* @__PURE__ */ jsx5(Text5, { children: chalk5.dim(
+        "  " + "ENTITY".padEnd(COL.name) + "SCORE".padStart(COL.score) + "  " + "TREND".padEnd(COL.trend) + "POS".padStart(COL.stat) + "NEU".padStart(COL.stat) + "NEG".padStart(COL.stat) + "TOT".padStart(COL.stat)
+      ) }) }),
+      /* @__PURE__ */ jsx5(Box5, { marginBottom: 1, children: /* @__PURE__ */ jsx5(Text5, { children: chalk5.dim("  " + "\u2500".repeat(COL.name + COL.score + 2 + COL.trend + COL.stat * 4)) }) }),
+      data.map((analysis, i) => /* @__PURE__ */ jsx5(
+        EntityRow,
+        {
+          analysis,
+          isActive: i === activeIndex
+        },
+        analysis.entity.id
+      ))
+    ] }),
+    showDetail && activeAnalysis && /* @__PURE__ */ jsx5(DetailPanel, { analysis: activeAnalysis }),
+    /* @__PURE__ */ jsx5(StatusBar, {})
+  ] });
+}
+
+// src/cli.tsx
+import { jsx as jsx6 } from "react/jsx-runtime";
+var cli = meow(
+  `
   Usage
     $ pythx
 
@@ -14,18 +766,19 @@ const cli = meow(`
     $ pythx
     $ pythx --api-url http://localhost:3000
     $ pythx --api-url https://pythx.vercel.app
-`, {
+`,
+  {
     importMeta: import.meta,
     flags: {
-        apiUrl: {
-            type: "string",
-        },
-    },
-});
-// Use alternate screen buffer so re-renders don't scroll the terminal
-process.stdout.write("\x1b[?1049h"); // enter alternate screen
-process.stdout.write("\x1b[H"); // move cursor to top
-const instance = render(_jsx(App, { apiUrl: cli.flags.apiUrl }), { patchConsole: false });
+      apiUrl: {
+        type: "string"
+      }
+    }
+  }
+);
+process.stdout.write("\x1B[?1049h");
+process.stdout.write("\x1B[H");
+var instance = render(/* @__PURE__ */ jsx6(App, { apiUrl: cli.flags.apiUrl }), { patchConsole: false });
 instance.waitUntilExit().then(() => {
-    process.stdout.write("\x1b[?1049l"); // restore main screen on exit
+  process.stdout.write("\x1B[?1049l");
 });