pythx-cli 0.0.4 → 0.0.6

package/dist/cli.js

@@ -1,4 +1,9 @@
 #!/usr/bin/env node
+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";
@@ -444,6 +449,11 @@ 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,
@@ -507,20 +517,106 @@ var posts = pgTable(
   ]
 );
 
+// ../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) {
+function useLiveData(apiUrl2) {
   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;
+    if (!apiUrl2) return;
     try {
-      const res = await fetch(`${apiUrl}/api/compare`, {
+      const res = await fetch(`${apiUrl2}/api/compare`, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
         body: JSON.stringify({
@@ -541,7 +637,22 @@ function useLiveData(apiUrl) {
     } finally {
       setLoading(false);
     }
-  }, [apiUrl]);
+  }, [apiUrl2]);
+  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 = [];
@@ -554,23 +665,38 @@ function useLiveData(apiUrl) {
           allClassified.push(...classified);
         }
         const snapshot = aggregate(allClassified);
-        results.push({
+        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);
     }
-  }, []);
-  const fetchData = apiUrl ? fetchViaApi : fetchDirect;
+  }, [loadFromCache]);
+  const fetchData = apiUrl2 ? fetchViaApi : fetchDirect;
   useEffect2(() => {
     fetchData();
     const interval = setInterval(fetchData, POLL_INTERVAL);
@@ -581,8 +707,8 @@ function useLiveData(apiUrl) {
 
 // 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);
+function App({ apiUrl: apiUrl2 }) {
+  const { data, loading, error, lastUpdated, refresh } = useLiveData(apiUrl2);
   const [activeIndex, setActiveIndex] = useState3(0);
   const [showDetail, setShowDetail] = useState3(true);
   const { exit } = useApp();
@@ -628,31 +754,38 @@ function App({ apiUrl }) {
 
 // src/cli.tsx
 import { jsx as jsx6 } from "react/jsx-runtime";
+var DEFAULT_API_URL = "https://pythx.vercel.app";
 var cli = meow(
   `
   Usage
     $ pythx
 
   Options
-    --api-url  URL of the Pythx web API (default: direct mode, no server needed)
+    --api-url  URL of the Pythx web API (default: ${DEFAULT_API_URL})
+    --direct   Use direct mode (requires HF_API_TOKEN and POSTGRES_URL env vars)
 
   Examples
     $ pythx
     $ pythx --api-url http://localhost:3000
-    $ pythx --api-url https://pythx.vercel.app
+    $ pythx --direct
 `,
   {
     importMeta: import.meta,
     flags: {
       apiUrl: {
         type: "string"
+      },
+      direct: {
+        type: "boolean",
+        default: false
       }
     }
   }
 );
+var apiUrl = cli.flags.direct ? void 0 : cli.flags.apiUrl ?? DEFAULT_API_URL;
 process.stdout.write("\x1B[?1049h");
 process.stdout.write("\x1B[H");
-var instance = render(/* @__PURE__ */ jsx6(App, { apiUrl: cli.flags.apiUrl }), { patchConsole: false });
+var instance = render(/* @__PURE__ */ jsx6(App, { apiUrl }), { patchConsole: false });
 instance.waitUntilExit().then(() => {
   process.stdout.write("\x1B[?1049l");
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pythx-cli",
-  "version": "0.0.4",
+  "version": "0.0.6",
   "description": "Real-time sentiment intelligence terminal for prediction markets",
   "type": "module",
   "bin": {