pythx-cli 0.0.4 → 0.0.5

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,8 +517,94 @@ 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;
@@ -542,6 +638,21 @@ function useLiveData(apiUrl) {
       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 = [];
@@ -554,22 +665,37 @@ 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);
     }
-  }, []);
+  }, [loadFromCache]);
   const fetchData = apiUrl ? fetchViaApi : fetchDirect;
   useEffect2(() => {
     fetchData();

package/package.json

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