@blockrun/franklin 3.2.4 → 3.3.1

package/dist/tools/webfetch.js

@@ -9,27 +9,30 @@ const MAX_BODY_BYTES = 256 * 1024; // 256KB
 const CACHE_TTL_MS = 15 * 60 * 1000;
 const MAX_CACHE_ENTRIES = 50;
 const fetchCache = new Map();
-function getCached(url) {
-    const entry = fetchCache.get(url);
+function cacheKey(url, maxLength) {
+    return `${url}::${maxLength}`;
+}
+function getCached(key) {
+    const entry = fetchCache.get(key);
     if (!entry)
         return null;
     if (Date.now() > entry.expiresAt) {
-        fetchCache.delete(url);
+        fetchCache.delete(key);
         return null;
     }
     return entry.output;
 }
-function setCached(url, output) {
+function setCached(key, output) {
     // Evict oldest entry if at capacity
     if (fetchCache.size >= MAX_CACHE_ENTRIES) {
         const firstKey = fetchCache.keys().next().value;
         if (firstKey)
             fetchCache.delete(firstKey);
     }
-    fetchCache.set(url, { output, expiresAt: Date.now() + CACHE_TTL_MS });
+    fetchCache.set(key, { output, expiresAt: Date.now() + CACHE_TTL_MS });
 }
 // ─── Execute ────────────────────────────────────────────────────────────────
-async function execute(input, _ctx) {
+async function execute(input, ctx) {
     const { url, max_length } = input;
     if (!url) {
         return { output: 'Error: url is required', isError: true };
@@ -45,13 +48,17 @@ async function execute(input, _ctx) {
     if (!['http:', 'https:'].includes(parsed.protocol)) {
         return { output: `Error: only http/https URLs are supported`, isError: true };
     }
+    const maxLen = Math.min(max_length ?? MAX_BODY_BYTES, MAX_BODY_BYTES);
+    const key = cacheKey(url, maxLen);
     // Check cache first
-    const cached = getCached(url);
+    const cached = getCached(key);
     if (cached) {
         return { output: cached + '\n\n(cached)' };
     }
     const controller = new AbortController();
     const timeout = setTimeout(() => controller.abort(), 30_000);
+    const onAbort = () => controller.abort();
+    ctx.abortSignal.addEventListener('abort', onAbort, { once: true });
     try {
         const response = await fetch(url, {
             signal: controller.signal,
@@ -68,7 +75,6 @@ async function execute(input, _ctx) {
             };
         }
         const contentType = response.headers.get('content-type') || '';
-        const maxLen = Math.min(max_length ?? MAX_BODY_BYTES, MAX_BODY_BYTES);
         // Read body with size limit
         const reader = response.body?.getReader();
         if (!reader) {
@@ -106,11 +112,14 @@ async function execute(input, _ctx) {
             output += '\n\n... (content truncated)';
         }
         // Cache successful responses
-        setCached(url, output);
+        setCached(key, output);
         return { output };
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
+        if (ctx.abortSignal.aborted) {
+            return { output: `Error: request aborted for ${url}`, isError: true };
+        }
         if (msg.includes('abort')) {
             return { output: `Error: request timed out after 30s for ${url}`, isError: true };
         }
@@ -118,6 +127,7 @@ async function execute(input, _ctx) {
     }
     finally {
         clearTimeout(timeout);
+        ctx.abortSignal.removeEventListener('abort', onAbort);
     }
 }
 function stripHtml(html) {

package/dist/tools/write.js

@@ -4,6 +4,7 @@
 import fs from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { partiallyReadFiles } from './read.js';
 function withTrailingSep(value) {
     return value.endsWith(path.sep) ? value : value + path.sep;
 }
@@ -84,6 +85,7 @@ async function execute(input, ctx) {
         fs.mkdirSync(parentDir, { recursive: true });
         const existed = fs.existsSync(resolved);
         fs.writeFileSync(resolved, content, 'utf-8');
+        partiallyReadFiles.delete(resolved);
         const lineCount = content.split('\n').length;
         const byteCount = Buffer.byteLength(content, 'utf-8');
         const sizeStr = byteCount >= 1024 ? `${(byteCount / 1024).toFixed(1)}KB` : `${byteCount}B`;

package/dist/trading/config.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Typed config for Franklin's trading subsystem.
+ * Stored at ~/.blockrun/trading-config.json. Default written on first run.
+ */
+export interface TradingConfig {
+    version: 1;
+    watchlist: string[];
+    signals: {
+        rsi_oversold: number;
+        rsi_overbought: number;
+    };
+    model_tier: 'free' | 'cheap' | 'premium';
+}
+export declare const CONFIG_PATH: string;
+/**
+ * Load config from disk. If missing, write defaults and return them.
+ * Returns the parsed config or throws on malformed JSON.
+ */
+export declare function loadTradingConfig(): TradingConfig;
+/**
+ * Persist config back to disk.
+ */
+export declare function saveTradingConfig(cfg: TradingConfig): void;

package/dist/trading/config.js

@@ -0,0 +1,45 @@
+/**
+ * Typed config for Franklin's trading subsystem.
+ * Stored at ~/.blockrun/trading-config.json. Default written on first run.
+ */
+import path from 'node:path';
+import fs from 'node:fs';
+import os from 'node:os';
+export const CONFIG_PATH = path.join(os.homedir(), '.blockrun', 'trading-config.json');
+const DEFAULT_CONFIG = {
+    version: 1,
+    watchlist: ['BTC', 'ETH', 'SOL'],
+    signals: {
+        rsi_oversold: 30,
+        rsi_overbought: 70,
+    },
+    model_tier: 'cheap',
+};
+/**
+ * Load config from disk. If missing, write defaults and return them.
+ * Returns the parsed config or throws on malformed JSON.
+ */
+export function loadTradingConfig() {
+    const dir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    if (!fs.existsSync(CONFIG_PATH)) {
+        fs.writeFileSync(CONFIG_PATH, JSON.stringify(DEFAULT_CONFIG, null, 2));
+        return { ...DEFAULT_CONFIG };
+    }
+    const raw = fs.readFileSync(CONFIG_PATH, 'utf8');
+    const parsed = JSON.parse(raw);
+    if (parsed.version !== 1) {
+        throw new Error(`Unsupported trading config version ${parsed.version} (expected 1)`);
+    }
+    return parsed;
+}
+/**
+ * Persist config back to disk.
+ */
+export function saveTradingConfig(cfg) {
+    const dir = path.dirname(CONFIG_PATH);
+    if (!fs.existsSync(dir))
+        fs.mkdirSync(dir, { recursive: true });
+    fs.writeFileSync(CONFIG_PATH, JSON.stringify(cfg, null, 2));
+}

package/dist/trading/data.d.ts

@@ -0,0 +1,30 @@
+export interface PriceData {
+    price: number;
+    change24h: number;
+    volume24h: number;
+    marketCap: number;
+}
+export interface OHLCVData {
+    closes: number[];
+    timestamps: number[];
+}
+export interface TrendingCoin {
+    id: string;
+    name: string;
+    symbol: string;
+    marketCapRank: number | null;
+}
+export interface MarketCoin {
+    id: string;
+    symbol: string;
+    name: string;
+    price: number;
+    change24h: number;
+    marketCap: number;
+    volume24h: number;
+}
+export declare function resolveId(ticker: string): string;
+export declare function getPrice(ticker: string): Promise<PriceData | string>;
+export declare function getOHLCV(ticker: string, days?: number): Promise<OHLCVData | string>;
+export declare function getTrending(): Promise<TrendingCoin[] | string>;
+export declare function getMarketOverview(): Promise<MarketCoin[] | string>;

package/dist/trading/data.js

@@ -0,0 +1,112 @@
+const BASE = "https://api.coingecko.com/api/v3";
+const UA = "franklin/3.3.0 (trading)";
+const TIMEOUT = 10_000;
+const TICKER_MAP = {
+    BTC: "bitcoin", ETH: "ethereum", SOL: "solana", BNB: "binancecoin", XRP: "ripple",
+    ADA: "cardano", DOGE: "dogecoin", AVAX: "avalanche-2", DOT: "polkadot", MATIC: "matic-network",
+    LINK: "chainlink", UNI: "uniswap", ATOM: "cosmos", LTC: "litecoin", NEAR: "near",
+    APT: "aptos", ARB: "arbitrum", OP: "optimism", SUI: "sui", SEI: "sei-network",
+    FIL: "filecoin", AAVE: "aave", MKR: "maker", SNX: "synthetix-network-token",
+    COMP: "compound-governance-token", INJ: "injective-protocol", TIA: "celestia",
+    PEPE: "pepe", WIF: "dogwifcoin", RENDER: "render-token",
+};
+const cache = new Map();
+function cached(key, ttlMs, fn) {
+    const hit = cache.get(key);
+    if (hit && hit.expiry > Date.now())
+        return Promise.resolve(hit.data);
+    return fn().then(data => {
+        cache.set(key, { data, expiry: Date.now() + ttlMs });
+        return data;
+    });
+}
+const TTL_PRICE = 5 * 60_000;
+const TTL_OHLCV = 60 * 60_000;
+const TTL_TRENDING = 15 * 60_000;
+// Fetch helper
+async function geckofetch(path) {
+    const ctrl = new AbortController();
+    const timer = setTimeout(() => ctrl.abort(), TIMEOUT);
+    try {
+        const res = await fetch(`${BASE}${path}`, {
+            headers: { "User-Agent": UA },
+            signal: ctrl.signal,
+        });
+        if (res.status === 429)
+            return "rate-limited: CoinGecko 429 — retry later";
+        if (!res.ok)
+            return `CoinGecko error ${res.status}`;
+        return await res.json();
+    }
+    catch (e) {
+        if (e instanceof DOMException && e.name === "AbortError")
+            return "request timed out";
+        return String(e);
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export function resolveId(ticker) {
+    return TICKER_MAP[ticker.toUpperCase()] ?? ticker.toLowerCase();
+}
+export async function getPrice(ticker) {
+    const id = resolveId(ticker);
+    return cached(`price:${id}`, TTL_PRICE, async () => {
+        const raw = await geckofetch(`/simple/price?ids=${id}&vs_currencies=usd&include_24hr_change=true&include_market_cap=true&include_24hr_vol=true`);
+        if (typeof raw === "string")
+            return raw;
+        const d = raw[id];
+        if (!d)
+            return `no data for ${ticker}`;
+        return {
+            price: d.usd,
+            change24h: d.usd_24h_change,
+            volume24h: d.usd_24h_vol,
+            marketCap: d.usd_market_cap,
+        };
+    });
+}
+export async function getOHLCV(ticker, days = 30) {
+    const id = resolveId(ticker);
+    return cached(`ohlcv:${id}:${days}`, TTL_OHLCV, async () => {
+        const raw = await geckofetch(`/coins/${id}/market_chart?vs_currency=usd&days=${days}&interval=daily`);
+        if (typeof raw === "string")
+            return raw;
+        const prices = raw.prices;
+        return {
+            timestamps: prices.map(p => p[0]),
+            closes: prices.map(p => p[1]),
+        };
+    });
+}
+export async function getTrending() {
+    return cached("trending", TTL_TRENDING, async () => {
+        const raw = await geckofetch("/search/trending");
+        if (typeof raw === "string")
+            return raw;
+        const coins = raw.coins;
+        return coins.map(c => ({
+            id: c.item.id,
+            name: c.item.name,
+            symbol: c.item.symbol,
+            marketCapRank: c.item.market_cap_rank,
+        }));
+    });
+}
+export async function getMarketOverview() {
+    return cached("markets", TTL_TRENDING, async () => {
+        const raw = await geckofetch("/coins/markets?vs_currency=usd&order=market_cap_desc&per_page=20&page=1");
+        if (typeof raw === "string")
+            return raw;
+        return raw.map(c => ({
+            id: c.id,
+            symbol: c.symbol,
+            name: c.name,
+            price: c.current_price,
+            change24h: c.price_change_percentage_24h,
+            marketCap: c.market_cap,
+            volume24h: c.total_volume,
+        }));
+    });
+}

package/dist/trading/metrics.d.ts

@@ -0,0 +1,29 @@
+export interface RSIResult {
+    value: number;
+    values: number[];
+    interpretation: 'oversold' | 'neutral' | 'overbought';
+}
+export interface MACDResult {
+    macd: number;
+    signal: number;
+    histogram: number;
+    trend: 'bullish' | 'bearish' | 'neutral';
+}
+export interface BollingerResult {
+    upper: number;
+    middle: number;
+    lower: number;
+    bandwidth: number;
+    position: 'above' | 'within' | 'below';
+}
+export interface VolatilityResult {
+    daily: number;
+    annualized: number;
+    interpretation: 'low' | 'medium' | 'high';
+}
+export declare function sma(data: number[], period: number): number;
+export declare function ema(closes: number[], period: number): number[];
+export declare function rsi(closes: number[], period?: number): RSIResult;
+export declare function macd(closes: number[], fast?: number, slow?: number, signal?: number): MACDResult;
+export declare function bollingerBands(closes: number[], period?: number, stdDev?: number): BollingerResult;
+export declare function volatility(closes: number[], period?: number): VolatilityResult;

package/dist/trading/metrics.js

@@ -0,0 +1,105 @@
+export function sma(data, period) {
+    if (data.length < period)
+        return NaN;
+    const slice = data.slice(data.length - period);
+    return slice.reduce((sum, v) => sum + v, 0) / period;
+}
+export function ema(closes, period) {
+    const result = new Array(closes.length).fill(NaN);
+    if (closes.length < period)
+        return result;
+    let sum = 0;
+    for (let i = 0; i < period; i++)
+        sum += closes[i];
+    result[period - 1] = sum / period;
+    const k = 2 / (period + 1);
+    for (let i = period; i < closes.length; i++) {
+        result[i] = closes[i] * k + result[i - 1] * (1 - k);
+    }
+    return result;
+}
+export function rsi(closes, period = 14) {
+    const values = new Array(closes.length).fill(NaN);
+    if (closes.length < period + 1) {
+        return { value: NaN, values, interpretation: 'neutral' };
+    }
+    const gains = [];
+    const losses = [];
+    for (let i = 1; i < closes.length; i++) {
+        const diff = closes[i] - closes[i - 1];
+        gains.push(diff > 0 ? diff : 0);
+        losses.push(diff < 0 ? -diff : 0);
+    }
+    let avgGain = gains.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    let avgLoss = losses.slice(0, period).reduce((s, v) => s + v, 0) / period;
+    const computeRSI = (ag, al) => al === 0 ? 100 : 100 - 100 / (1 + ag / al);
+    values[period] = computeRSI(avgGain, avgLoss);
+    for (let i = period; i < gains.length; i++) {
+        avgGain = (avgGain * (period - 1) + gains[i]) / period;
+        avgLoss = (avgLoss * (period - 1) + losses[i]) / period;
+        values[i + 1] = computeRSI(avgGain, avgLoss);
+    }
+    const latest = values[values.length - 1];
+    const interpretation = latest < 30 ? 'oversold' : latest > 70 ? 'overbought' : 'neutral';
+    return { value: latest, values, interpretation };
+}
+export function macd(closes, fast = 12, slow = 26, signal = 9) {
+    const emaFast = ema(closes, fast);
+    const emaSlow = ema(closes, slow);
+    const macdLine = closes.map((_, i) => isNaN(emaFast[i]) || isNaN(emaSlow[i]) ? NaN : emaFast[i] - emaSlow[i]);
+    const validMacd = macdLine.filter((v) => !isNaN(v));
+    const signalLine = ema(validMacd, signal);
+    const padded = new Array(macdLine.length - validMacd.length)
+        .fill(NaN)
+        .concat(signalLine);
+    const histogram = macdLine.map((v, i) => isNaN(v) || isNaN(padded[i]) ? NaN : v - padded[i]);
+    const last = macdLine[macdLine.length - 1];
+    const lastSignal = padded[padded.length - 1];
+    const lastHist = histogram[histogram.length - 1];
+    const prevHist = histogram[histogram.length - 2];
+    let trend = 'neutral';
+    if (!isNaN(lastHist) && !isNaN(prevHist)) {
+        if (lastHist > 0 && lastHist > prevHist)
+            trend = 'bullish';
+        else if (lastHist < 0 && lastHist < prevHist)
+            trend = 'bearish';
+    }
+    return { macd: last, signal: lastSignal, histogram: lastHist, trend };
+}
+export function bollingerBands(closes, period = 20, stdDev = 2) {
+    if (closes.length < period) {
+        return {
+            upper: NaN,
+            middle: NaN,
+            lower: NaN,
+            bandwidth: NaN,
+            position: 'within',
+        };
+    }
+    const slice = closes.slice(closes.length - period);
+    const middle = slice.reduce((s, v) => s + v, 0) / period;
+    const variance = slice.reduce((s, v) => s + (v - middle) ** 2, 0) / period;
+    const sigma = Math.sqrt(variance);
+    const upper = middle + stdDev * sigma;
+    const lower = middle - stdDev * sigma;
+    const bandwidth = (upper - lower) / middle;
+    const price = closes[closes.length - 1];
+    const position = price > upper ? 'above' : price < lower ? 'below' : 'within';
+    return { upper, middle, lower, bandwidth, position };
+}
+export function volatility(closes, period = 14) {
+    if (closes.length < period + 1) {
+        return { daily: NaN, annualized: NaN, interpretation: 'medium' };
+    }
+    const returns = [];
+    const start = closes.length - period - 1;
+    for (let i = start + 1; i < closes.length; i++) {
+        returns.push(Math.log(closes[i] / closes[i - 1]));
+    }
+    const mean = returns.reduce((s, v) => s + v, 0) / returns.length;
+    const variance = returns.reduce((s, v) => s + (v - mean) ** 2, 0) / (returns.length - 1);
+    const daily = Math.sqrt(variance);
+    const annualized = daily * Math.sqrt(365);
+    const interpretation = annualized < 0.3 ? 'low' : annualized > 0.8 ? 'high' : 'medium';
+    return { daily, annualized, interpretation };
+}