@jellyos/agent 0.1.4 → 0.1.5

package/dist/tools/NewsSentiment.js

@@ -41,34 +41,61 @@ export function scoreSentiment(text) {
     return hits === 0 ? 0 : Math.max(-1, Math.min(1, score / hits));
 }
 // ── Fetch & parse ────────────────────────────────────────────────────────────
+/**
+ * Proper RSS item extractor — handles CDATA, encoded entities, attributes.
+ * No regex on the whole document; scans block by block.
+ */
+function extractTag(block, tag) {
+    // Try CDATA form first: <tag><![CDATA[...]]></tag>
+    const cdataRe = new RegExp(`<${tag}[^>]*><!\\[CDATA\\[([\\s\\S]*?)\\]\\]>`, "i");
+    const cdataM = block.match(cdataRe);
+    if (cdataM?.[1])
+        return cdataM[1].trim();
+    // Plain text form: <tag ...>content</tag>
+    const plainRe = new RegExp(`<${tag}[^>]*>([^<]*)`, "i");
+    const plainM = block.match(plainRe);
+    if (plainM?.[1]) {
+        return plainM[1]
+            .replace(/&amp;/g, "&")
+            .replace(/&lt;/g, "<")
+            .replace(/&gt;/g, ">")
+            .replace(/&quot;/g, '"')
+            .replace(/&#39;/g, "'")
+            .trim();
+    }
+    return "";
+}
 async function fetchRSS(url, source) {
     try {
         const res = await fetch(url, {
             signal: AbortSignal.timeout(10_000),
-            headers: { "User-Agent": "JellyOS/1.0", "Accept": "application/rss+xml, application/xml, text/xml" },
+            headers: { "User-Agent": "JellyOS/1.0", "Accept": "application/rss+xml, application/xml, text/xml, */*" },
         });
         if (!res.ok)
             return [];
-        const text = await res.text();
-        // Parse RSS items with regex (no XML parser dependency)
+        const xml = await res.text();
+        // Find all <item>...</item> blocks (also handles <entry> for Atom feeds)
+        const TAG_RE = /<(?:item|entry)[^>]*>([\s\S]*?)<\/(?:item|entry)>/gi;
         const items = [];
-        const itemMatches = text.match(/<item[\s\S]*?<\/item>/gi) ?? [];
-        for (const item of itemMatches) {
-            const titleMatch = item.match(/<title[^>]*><!\[CDATA\[(.*?)\]\]><\/title>|<title[^>]*>(.*?)<\/title>/i);
-            const linkMatch = item.match(/<link[^>]*>(.*?)<\/link>/i);
-            const dateMatch = item.match(/<pubDate[^>]*>(.*?)<\/pubDate>/i);
-            const title = titleMatch?.[1] ?? titleMatch?.[2] ?? "";
-            if (!title.trim())
+        let match;
+        while ((match = TAG_RE.exec(xml)) !== null) {
+            const block = match[1] ?? "";
+            const title = extractTag(block, "title");
+            const link = extractTag(block, "link") || extractTag(block, "guid");
+            const pubDate = extractTag(block, "pubDate") || extractTag(block, "updated") || extractTag(block, "published");
+            if (!title)
                 continue;
             items.push({
                 title,
                 source,
-                url: linkMatch?.[1] ?? "",
-                published: dateMatch ? new Date(dateMatch[1]).getTime() : Date.now(),
+                url: link,
+                published: pubDate ? (new Date(pubDate).getTime() || Date.now()) : Date.now(),
                 sentiment: scoreSentiment(title),
             });
+            if (items.length >= 25)
+                break; // cap per feed
         }
-        return items.slice(0, 20);
+        return items;
     }
     catch {
         return [];

package/dist/tools/PriceFeed.d.ts

@@ -43,6 +43,8 @@ export declare class PriceFeed extends EventEmitter {
     /** Add symbols to track. IDs are auto-resolved from the symbol map. */
     track(...symbols: string[]): void;
     fetchAll(): Promise<void>;
+    private fetchBinance;
+    private fetchCoinGecko;
     get(symbol: string): PriceTick | undefined;
     getMultiple(symbols: string[]): PriceTick[];
     getAll(): PriceTick[];

package/dist/tools/PriceFeed.js

@@ -81,37 +81,89 @@ export class PriceFeed extends EventEmitter {
     }
     // ── Fetch ────────────────────────────────────────────────────────────────
     async fetchAll() {
+        // #17: Fan-out to Binance (primary) + CoinGecko (secondary)
+        // Binance: no rate limits on public endpoints, real-time order book prices
+        // CoinGecko: covers long-tail tokens Binance doesn't list, includes market cap
+        const [binanceResult, cgResult] = await Promise.allSettled([
+            this.fetchBinance(),
+            this.fetchCoinGecko(),
+        ]);
+        let updated = false;
+        // Binance wins for price precision on listed pairs
+        if (binanceResult.status === "fulfilled") {
+            for (const tick of binanceResult.value) {
+                this.prices.set(tick.symbol.toLowerCase(), tick);
+                updated = true;
+            }
+        }
+        // CoinGecko fills gaps (market cap data, unlisted tokens)
+        if (cgResult.status === "fulfilled") {
+            for (const tick of cgResult.value) {
+                const key = tick.symbol.toLowerCase();
+                const existing = this.prices.get(key);
+                if (!existing) {
+                    // Token not on Binance — add from CoinGecko
+                    this.prices.set(key, tick);
+                    updated = true;
+                }
+                else if (tick.marketCap > 0) {
+                    // Enrich Binance tick with market cap from CoinGecko
+                    existing.marketCap = tick.marketCap;
+                }
+            }
+        }
+        if (updated)
+            this.emit("prices", [...this.prices.values()]);
+    }
+    async fetchBinance() {
+        // Build list of USDT pairs for tracked symbols
+        const pairs = [...this.tracking]
+            .map(s => s.toUpperCase() + "USDT")
+            .filter(s => !s.startsWith("USDT") && !s.startsWith("DAI")); // skip stablecoins
+        if (!pairs.length)
+            return [];
+        const url = `https://api.binance.com/api/v3/ticker/24hr?symbols=${encodeURIComponent(JSON.stringify(pairs))}`;
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(8_000),
+            headers: { "User-Agent": "JellyOS/1.0" },
+        });
+        if (!res.ok)
+            throw new Error(`Binance ticker HTTP ${res.status}`);
+        const data = await res.json();
+        return data.map(d => ({
+            symbol: d.symbol.replace(/USDT$/, ""),
+            price: parseFloat(d.lastPrice),
+            change24h: parseFloat(d.priceChangePercent),
+            volume24h: parseFloat(d.quoteVolume),
+            marketCap: 0, // Binance doesn't provide market cap — CoinGecko fills this
+            high24h: parseFloat(d.highPrice),
+            low24h: parseFloat(d.lowPrice),
+            source: "binance",
+            timestamp: Date.now(),
+        }));
+    }
+    async fetchCoinGecko() {
         const ids = [...this.tracking]
             .map(s => SYMBOL_TO_ID[s])
-            .filter(Boolean)
+            .filter((id) => Boolean(id))
             .join(",");
         if (!ids)
-            return;
-        try {
-            const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=${ids}&order=market_cap_desc&sparkline=false`, { signal: AbortSignal.timeout(10_000), headers: { "User-Agent": "JellyOS/1.0" } });
-            if (!res.ok)
-                return;
-            const data = (await res.json());
-            for (const coin of data) {
-                const symbol = coin.symbol.toUpperCase();
-                const tick = {
-                    symbol,
-                    price: coin.current_price,
-                    change24h: coin.price_change_percentage_24h ?? 0,
-                    volume24h: coin.total_volume ?? 0,
-                    marketCap: coin.market_cap ?? 0,
-                    high24h: coin.high_24h ?? 0,
-                    low24h: coin.low_24h ?? 0,
-                    source: "coingecko",
-                    timestamp: Date.now(),
-                };
-                this.prices.set(symbol.toLowerCase(), tick);
-            }
-            this.emit("prices", [...this.prices.values()]);
-        }
-        catch {
-            // Silent — will retry next interval
-        }
+            return [];
+        const res = await fetch(`https://api.coingecko.com/api/v3/coins/markets?vs_currency=usd&ids=${ids}&order=market_cap_desc&sparkline=false`, { signal: AbortSignal.timeout(10_000), headers: { "User-Agent": "JellyOS/1.0" } });
+        if (!res.ok)
+            throw new Error(`CoinGecko HTTP ${res.status}`);
+        const data = await res.json();
+        return data.map(coin => ({
+            symbol: coin.symbol.toUpperCase(),
+            price: coin.current_price,
+            change24h: coin.price_change_percentage_24h ?? 0,
+            volume24h: coin.total_volume ?? 0,
+            marketCap: coin.market_cap ?? 0,
+            high24h: coin.high_24h ?? 0,
+            low24h: coin.low_24h ?? 0,
+            source: "coingecko",
+            timestamp: Date.now(),
+        }));
     }
     // ── Query ─────────────────────────────────────────────────────────────────
     get(symbol) {

package/dist/tools/TechnicalAnalysis.d.ts

@@ -5,6 +5,7 @@
  * All calculations are pure math on price arrays — no external API needed.
  * Designed to be exposed as tools the AI can call autonomously.
  */
+import { type Static } from "@sinclair/typebox";
 export interface OHLCV {
     timestamp: number;
     open: number;
@@ -70,4 +71,40 @@ export declare const macdParams: import("@sinclair/typebox").TObject<{
     slow: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
     signal: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
 }>;
+export declare const getCandlesParams: import("@sinclair/typebox").TObject<{
+    symbol: import("@sinclair/typebox").TString;
+    interval: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TString>;
+    limit: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TNumber>;
+    analyze: import("@sinclair/typebox").TOptional<import("@sinclair/typebox").TBoolean>;
+}>;
+export declare function getCandlesTool(_id: string, params: Static<typeof getCandlesParams>): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        symbol?: undefined;
+        interval?: undefined;
+        candleCount?: undefined;
+        latest?: undefined;
+        priceChangePercent?: undefined;
+    };
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    details: {
+        symbol: string;
+        interval: string;
+        candleCount: number;
+        latest: {
+            close: number;
+            high: number;
+            low: number;
+            volume: number;
+        };
+        priceChangePercent: number;
+    };
+}>;
 //# sourceMappingURL=TechnicalAnalysis.d.ts.map

package/dist/tools/TechnicalAnalysis.js

@@ -269,4 +269,89 @@ export const macdParams = Type.Object({
     slow: Type.Optional(Type.Number({ default: 26 })),
     signal: Type.Optional(Type.Number({ default: 9 })),
 });
+// ── Tool: get_candles (#18 — fetch real OHLCV data from Binance) ─────────────
+export const getCandlesParams = Type.Object({
+    symbol: Type.String({ description: "Crypto symbol e.g. BTC, ETH, SOL" }),
+    interval: Type.Optional(Type.String({ description: "Candle interval: 1m 5m 15m 1h 4h 1d (default: 1h)" })),
+    limit: Type.Optional(Type.Number({ description: "Number of candles 1-500 (default: 100)" })),
+    analyze: Type.Optional(Type.Boolean({ description: "Run full TA analysis on fetched candles (default: true)" })),
+});
+export async function getCandlesTool(_id, params) {
+    const symbol = params.symbol.toUpperCase().replace(/USDT$/, "") + "USDT";
+    const interval = params.interval ?? "1h";
+    const limit = Math.min(Math.max(params.limit ?? 100, 10), 500);
+    const analyze = params.analyze !== false;
+    const VALID_INTERVALS = new Set(["1m", "3m", "5m", "15m", "30m", "1h", "2h", "4h", "6h", "8h", "12h", "1d", "3d", "1w", "1M"]);
+    if (!VALID_INTERVALS.has(interval)) {
+        return {
+            content: [{ type: "text", text: `Invalid interval "${interval}". Valid: ${[...VALID_INTERVALS].join(", ")}` }],
+            details: {},
+        };
+    }
+    try {
+        const res = await fetch(`https://api.binance.com/api/v3/klines?symbol=${symbol}&interval=${interval}&limit=${limit}`, { signal: AbortSignal.timeout(12_000), headers: { "User-Agent": "JellyOS/1.0" } });
+        if (!res.ok) {
+            return {
+                content: [{ type: "text", text: `Binance API error ${res.status} for ${symbol}. Check symbol.` }],
+                details: {},
+            };
+        }
+        const raw = await res.json();
+        const candles = raw.map(c => ({
+            timestamp: c[0],
+            open: parseFloat(c[1]),
+            high: parseFloat(c[2]),
+            low: parseFloat(c[3]),
+            close: parseFloat(c[4]),
+            volume: parseFloat(c[5]),
+        }));
+        const latest = candles[candles.length - 1];
+        const oldest = candles[0];
+        const chgPct = ((latest.close - oldest.close) / oldest.close * 100).toFixed(2);
+        const priceStr = latest.close < 1
+            ? `$${latest.close.toFixed(6)}`
+            : `$${latest.close.toLocaleString(undefined, { maximumFractionDigits: 2 })}`;
+        const lines = [
+            `${symbol} | ${interval} | ${candles.length} candles`,
+            `Close: ${priceStr}  Period change: ${parseFloat(chgPct) >= 0 ? "+" : ""}${chgPct}%`,
+            `High: $${latest.high.toLocaleString()}  Low: $${latest.low.toLocaleString()}`,
+            `Volume (last bar): ${latest.volume.toLocaleString()}`,
+        ];
+        if (analyze && candles.length >= 30) {
+            const results = fullAnalysis(candles);
+            const summary = results.find(r => r.indicator === "SUMMARY");
+            lines.push("", "── Technical Analysis ──");
+            for (const r of results) {
+                if (r.indicator === "SUMMARY")
+                    continue;
+                const icon = r.signal === "bullish" ? "🟢" : r.signal === "bearish" ? "🔴" : "⚪";
+                const val = typeof r.value === "number" ? r.value.toFixed(2) : String(r.value);
+                const meta = r.metadata?.condition ? ` (${String(r.metadata.condition)})` : "";
+                lines.push(`  ${icon} ${r.indicator.padEnd(16)} ${val}${meta}`);
+            }
+            if (summary) {
+                const icon = summary.signal === "bullish" ? "🟢" : summary.signal === "bearish" ? "🔴" : "⚪";
+                lines.push("", `${icon} OVERALL: ${String(summary.signal).toUpperCase()} — ${String(summary.metadata?.bullish_indicators ?? 0)} bull / ${String(summary.metadata?.bearish_indicators ?? 0)} bear signals`);
+            }
+        }
+        else if (analyze && candles.length < 30) {
+            lines.push(`(need 30+ candles for TA, got ${candles.length} — increase limit)`);
+        }
+        return {
+            content: [{ type: "text", text: lines.join("\n") }],
+            details: {
+                symbol, interval, candleCount: candles.length,
+                latest: { close: latest.close, high: latest.high, low: latest.low, volume: latest.volume },
+                priceChangePercent: parseFloat(chgPct),
+            },
+        };
+    }
+    catch (e) {
+        const msg = e instanceof Error ? e.message : String(e);
+        return {
+            content: [{ type: "text", text: `Failed to fetch candles for ${symbol}: ${msg}` }],
+            details: {},
+        };
+    }
+}
 //# sourceMappingURL=TechnicalAnalysis.js.map

package/dist/tui/App.d.ts

@@ -1,7 +1,7 @@
 /**
  * App — root Ink component.
- * Wires StatusBar + REPL + AgentRunner, registers built-in tools,
- * starts background feeds, and renders a multi-pane trading terminal.
+ * Multi-pane TUI with context bar, syntax-highlighted tool output,
+ * live side panel with ticker/prices, and command palette triggered via /palette.
  */
 import { Registry } from "../api/Registry.js";
 import type { ModelRegistry } from "../models/ModelRegistry.js";