ansemedge 1.0.0

package/README.md

@@ -0,0 +1,82 @@
+# AnsemEdge SDK
+
+Official Node/Browser SDK for AnsemEdge — Programmable Market Intelligence. Ingest real-time sentiment scoring, coin mentions, and emerging narrative shifts parsed directly from @blknoiz06's commentary on the Solana ecosystem.
+
+Visit [ansemedge.xyz](https://ansemedge.xyz) to manage API credentials and view gating tiers.
+
+## Installation
+
+Install via npm:
+
+```bash
+npm install ansemedge
+```
+
+## Getting Started
+
+Initialize the client with your developer API key:
+
+```javascript
+import { AnsemEdge } from "ansemedge";
+
+const edge = new AnsemEdge({
+  apiKey: "ae_live_your_api_key_here"
+});
+```
+
+## Usage Examples
+
+### 1. Fetch Ecosystem Sentiment Index
+
+Get the normalized real-time sentiment index aggregated across active feeds.
+
+```javascript
+try {
+  const data = await edge.getSentiment("24h");
+  console.log(`Sentiment: ${data.sentimentIndex} (${data.label})`);
+  console.log(`Confidence Score: ${data.confidenceScore}`);
+} catch (error) {
+  console.error("Failed to query sentiment:", error.message);
+}
+```
+
+### 2. Retrieve Automated Signals
+
+Fetch high-conviction automated signals computed by NLP extraction models.
+
+```javascript
+const signals = await edge.getSignals(10, 0.90);
+signals.forEach(signal => {
+  console.log(`Asset: $${signal.tokenSymbol} | Sentiment: ${signal.sentimentScore}`);
+  console.log(`Summary: ${signal.summary}`);
+});
+```
+
+### 3. Stream Real-Time Updates via WebSockets
+
+Subscribe to the low-latency streaming pipeline to receive structured events instantly.
+
+```javascript
+// Connect and listen for real-time updates
+edge.subscribe((payload) => {
+  console.log("Stream update parsed:", payload);
+});
+
+// To disconnect/cleanup:
+// edge.close();
+```
+
+## API Methods
+
+* `getSentiment(window?)`: Normalized ecosystem index [−1, +1].
+* `getSignals(limit?, confidence?)`: Structured automated trading signals.
+* `getTopics()`: Active narrative clusters with trend scores.
+* `getSummary()`: Daily briefing document outlining catalyst events.
+* `getMarket()`: Platform overview, convictions, and monitored channels status.
+* `subscribe(callback)`: Open a WebSockets pipeline to listen to active scrape feeds.
+* `unsubscribe(callback)`: Unregister listener and tear down sockets when inactive.
+* `close()`: Shut down all active client feeds.
+
+## License
+
+MIT License.

package/dist/index.d.ts

@@ -0,0 +1,90 @@
+export interface SDKConfig {
+    apiKey: string;
+    baseUrl?: string;
+    wsUrl?: string;
+}
+export interface SentimentData {
+    sentimentIndex: number;
+    label: string;
+    confidenceScore: number;
+    sourceCount: number;
+    volume24h: string;
+    updatedAt: string;
+}
+export interface SignalData {
+    id: string;
+    tokenSymbol: string;
+    sentimentScore: number;
+    confidenceScore: number;
+    summary: string;
+    timestamp: string;
+}
+export interface TopicData {
+    name: string;
+    trendScore: number;
+    mentionsCount: number;
+    velocity: string;
+}
+export interface SummaryData {
+    summary: string;
+    topTokens: string[];
+    narrativesDetected: string[];
+    generatedAt: string;
+}
+export interface MarketData {
+    status: string;
+    overallConviction: number;
+    trendingToken: string;
+    topNarrative: string;
+    monitoredChannels: string[];
+    indexUpdateFrequency: string;
+}
+export declare class AnsemEdge {
+    private apiKey;
+    private baseUrl;
+    private wsUrl;
+    private ws;
+    private wsListeners;
+    private reconnectAttempts;
+    private maxReconnectAttempts;
+    private reconnectInterval;
+    constructor(config: SDKConfig);
+    private request;
+    /**
+     * Fetch normalized real-time sentiment index.
+     * @param window Timeframe window filter (e.g., '1h', '24h', '7d')
+     */
+    getSentiment(window?: string): Promise<SentimentData>;
+    /**
+     * Retrieve high-conviction automated trading signals.
+     * @param limit Max items to return
+     * @param confidence Min confidence threshold filter [0-1]
+     */
+    getSignals(limit?: number, confidence?: number): Promise<SignalData[]>;
+    /**
+     * Retrieve monitored narrative clusters and density shifts.
+     */
+    getTopics(): Promise<TopicData[]>;
+    /**
+     * Fetch automated daily catalyst briefs and sentiment summaries.
+     */
+    getSummary(): Promise<SummaryData>;
+    /**
+     * Fetch high level status metrics for the platform.
+     */
+    getMarket(): Promise<MarketData>;
+    /**
+     * Connect to the real-time sentiment WebSockets stream.
+     * @param onMessage Callback function executed on incoming feed payloads
+     */
+    subscribe(onMessage: (data: any) => void): void;
+    private connectWS;
+    /**
+     * Remove a message listener subscription.
+     */
+    unsubscribe(onMessage: (data: any) => void): void;
+    /**
+     * Close all active connection channels.
+     */
+    close(): void;
+}

package/dist/index.js

@@ -0,0 +1,162 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnsemEdge = void 0;
+const ws_1 = __importDefault(require("ws"));
+class AnsemEdge {
+    constructor(config) {
+        this.ws = null;
+        this.wsListeners = new Set();
+        this.reconnectAttempts = 0;
+        this.maxReconnectAttempts = 5;
+        this.reconnectInterval = 3000;
+        if (!config.apiKey) {
+            throw new Error("[AnsemEdge SDK] API key is required.");
+        }
+        this.apiKey = config.apiKey;
+        this.baseUrl = (config.baseUrl ?? "https://ansemedge.xyz").replace(/\/$/, "");
+        this.wsUrl = config.wsUrl ?? "wss://ansemedge.xyz";
+    }
+    async request(endpoint, params = {}) {
+        const url = new URL(`${this.baseUrl}${endpoint}`);
+        Object.keys(params).forEach(key => {
+            if (params[key] !== undefined && params[key] !== null) {
+                url.searchParams.append(key, String(params[key]));
+            }
+        });
+        const response = await fetch(url.toString(), {
+            method: "GET",
+            headers: {
+                "Authorization": `Bearer ${this.apiKey}`,
+                "Content-Type": "application/json",
+            },
+        });
+        if (!response.ok) {
+            if (response.status === 401) {
+                throw new Error("[AnsemEdge SDK] Unauthorized: Invalid API key.");
+            }
+            if (response.status === 403) {
+                throw new Error("[AnsemEdge SDK] Gated: Insufficient $EDGE token balance.");
+            }
+            if (response.status === 429) {
+                throw new Error("[AnsemEdge SDK] Rate Limit Exceeded: Upgrade your token balance tiers.");
+            }
+            throw new Error(`[AnsemEdge SDK] HTTP Error ${response.status}: ${response.statusText}`);
+        }
+        const payload = await response.json();
+        return payload.data ?? payload;
+    }
+    /**
+     * Fetch normalized real-time sentiment index.
+     * @param window Timeframe window filter (e.g., '1h', '24h', '7d')
+     */
+    async getSentiment(window) {
+        return this.request("/api/sentiment", { window });
+    }
+    /**
+     * Retrieve high-conviction automated trading signals.
+     * @param limit Max items to return
+     * @param confidence Min confidence threshold filter [0-1]
+     */
+    async getSignals(limit, confidence) {
+        return this.request("/api/signals", { limit, confidence });
+    }
+    /**
+     * Retrieve monitored narrative clusters and density shifts.
+     */
+    async getTopics() {
+        return this.request("/api/topics");
+    }
+    /**
+     * Fetch automated daily catalyst briefs and sentiment summaries.
+     */
+    async getSummary() {
+        return this.request("/api/summary");
+    }
+    /**
+     * Fetch high level status metrics for the platform.
+     */
+    async getMarket() {
+        return this.request("/api/market");
+    }
+    /**
+     * Connect to the real-time sentiment WebSockets stream.
+     * @param onMessage Callback function executed on incoming feed payloads
+     */
+    subscribe(onMessage) {
+        this.wsListeners.add(onMessage);
+        if (this.ws) {
+            return;
+        }
+        this.connectWS();
+    }
+    connectWS() {
+        const isBrowser = typeof window !== "undefined" && typeof window.WebSocket !== "undefined";
+        const WSClass = isBrowser ? window.WebSocket : ws_1.default;
+        if (!WSClass) {
+            console.warn("[AnsemEdge SDK] WebSocket class is not available in this environment.");
+            return;
+        }
+        const socketUrl = `${this.wsUrl}?apiKey=${this.apiKey}`;
+        this.ws = new WSClass(socketUrl);
+        this.ws.onopen = () => {
+            this.reconnectAttempts = 0;
+            console.log("[AnsemEdge SDK] Live WebSocket feed stream active.");
+        };
+        this.ws.onmessage = (event) => {
+            try {
+                const payload = JSON.parse(event.data);
+                this.wsListeners.forEach(listener => {
+                    try {
+                        listener(payload);
+                    }
+                    catch (err) {
+                        console.error("[AnsemEdge SDK] Error in message listener callback:", err);
+                    }
+                });
+            }
+            catch (err) {
+                // Handle raw message text if not JSON
+                this.wsListeners.forEach(listener => listener(event.data));
+            }
+        };
+        this.ws.onerror = (err) => {
+            console.error("[AnsemEdge SDK] WebSocket stream error:", err);
+        };
+        this.ws.onclose = () => {
+            this.ws = null;
+            if (this.reconnectAttempts < this.maxReconnectAttempts) {
+                this.reconnectAttempts++;
+                const delay = this.reconnectInterval * this.reconnectAttempts;
+                console.log(`[AnsemEdge SDK] Connection closed. Reconnecting in ${delay}ms...`);
+                setTimeout(() => this.connectWS(), delay);
+            }
+            else {
+                console.error("[AnsemEdge SDK] Max WebSocket reconnection attempts reached.");
+            }
+        };
+    }
+    /**
+     * Remove a message listener subscription.
+     */
+    unsubscribe(onMessage) {
+        this.wsListeners.delete(onMessage);
+        if (this.wsListeners.size === 0 && this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+    /**
+     * Close all active connection channels.
+     */
+    close() {
+        this.wsListeners.clear();
+        if (this.ws) {
+            this.ws.close();
+            this.ws = null;
+        }
+    }
+}
+exports.AnsemEdge = AnsemEdge;

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "ansemedge",
+  "version": "1.0.0",
+  "description": "Official SDK for AnsemEdge — Programmable Market Intelligence.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsc"
+  },
+  "keywords": [
+    "solana",
+    "ansem",
+    "sentiment",
+    "trading",
+    "intelligence",
+    "api",
+    "sdk"
+  ],
+  "author": "AnsemEdge",
+  "license": "MIT",
+  "homepage": "https://ansemedge.xyz",
+  "dependencies": {
+    "ws": "^8.18.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.3.3",
+    "@types/node": "^20.11.24",
+    "@types/ws": "^8.5.10"
+  }
+}