autoscholar-cli 1.0.0

package/dist/python/runner.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runPython = runPython;
+exports.checkPythonDeps = checkPythonDeps;
+const child_process_1 = require("child_process");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+function findPython() {
+    const candidates = ['python3', 'python'];
+    for (const cmd of candidates) {
+        try {
+            const { execSync } = require('child_process');
+            const version = execSync(`${cmd} --version 2>&1`, { encoding: 'utf-8' });
+            if (version.includes('Python 3')) {
+                return cmd;
+            }
+        }
+        catch { }
+    }
+    return 'python3';
+}
+async function runPython(code, workingDir, timeoutMs = 120000) {
+    const pythonBin = findPython();
+    const tmpDir = path.join(os.tmpdir(), 'autoscholar-py');
+    if (!fs.existsSync(tmpDir))
+        fs.mkdirSync(tmpDir, { recursive: true });
+    const tmpFile = path.join(tmpDir, `script_${Date.now()}.py`);
+    fs.writeFileSync(tmpFile, code, 'utf-8');
+    return new Promise((resolve) => {
+        const proc = (0, child_process_1.execFile)(pythonBin, [tmpFile], {
+            cwd: workingDir,
+            timeout: timeoutMs,
+            maxBuffer: 50 * 1024 * 1024,
+            env: {
+                ...process.env,
+                MPLBACKEND: 'Agg',
+                PYTHONDONTWRITEBYTECODE: '1',
+                PYTHONUNBUFFERED: '1',
+            },
+        }, (error, stdout, stderr) => {
+            try {
+                fs.unlinkSync(tmpFile);
+            }
+            catch { }
+            if (error) {
+                resolve({
+                    success: false,
+                    output: stdout || '',
+                    error: stderr || error.message || 'Unknown Python error',
+                    exitCode: error.code ? parseInt(String(error.code)) : 1,
+                });
+            }
+            else {
+                resolve({
+                    success: true,
+                    output: stdout || '',
+                    error: stderr || '',
+                    exitCode: 0,
+                });
+            }
+        });
+    });
+}
+async function checkPythonDeps() {
+    const pythonBin = findPython();
+    const required = [
+        'pandas', 'numpy', 'scipy', 'matplotlib', 'seaborn',
+        'statsmodels', 'sklearn',
+    ];
+    const optional = [
+        'arch', 'linearmodels', 'xgboost', 'lightgbm',
+    ];
+    const missing = [];
+    const installed = [];
+    const checkCode = `
+import json
+result = {}
+for pkg in ${JSON.stringify([...required, ...optional])}:
+    try:
+        __import__(pkg)
+        result[pkg] = True
+    except ImportError:
+        result[pkg] = False
+print(json.dumps(result))
+`;
+    const result = await runPython(checkCode, process.cwd(), 15000);
+    if (result.success) {
+        try {
+            const pkgs = JSON.parse(result.output.trim());
+            for (const [pkg, available] of Object.entries(pkgs)) {
+                if (available) {
+                    installed.push(pkg);
+                }
+                else if (required.includes(pkg)) {
+                    missing.push(pkg);
+                }
+            }
+        }
+        catch { }
+    }
+    return {
+        available: missing.length === 0,
+        python: pythonBin,
+        missing,
+        installed,
+    };
+}

package/dist/utils/llm.js

@@ -0,0 +1,73 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAnthropicClient = getAnthropicClient;
+exports.callLLM = callLLM;
+exports.callLLMWithTools = callLLMWithTools;
+exports.parseJsonResponse = parseJsonResponse;
+const sdk_1 = __importDefault(require("@anthropic-ai/sdk"));
+let client = null;
+function getAnthropicClient(config) {
+    if (!client) {
+        client = new sdk_1.default({
+            apiKey: config.ANTHROPIC_API_KEY,
+        });
+    }
+    return client;
+}
+async function callLLM(config, system, userMessage, options) {
+    const anthropic = getAnthropicClient(config);
+    const response = await anthropic.messages.create({
+        model: options?.model || 'claude-sonnet-4-20250514',
+        max_tokens: options?.maxTokens || 8192,
+        temperature: options?.temperature ?? 0.3,
+        system,
+        messages: [{ role: 'user', content: userMessage }],
+    });
+    const textBlock = response.content.find((b) => b.type === 'text');
+    return textBlock ? textBlock.text : '';
+}
+async function callLLMWithTools(config, system, messages, tools, options) {
+    const anthropic = getAnthropicClient(config);
+    const response = await anthropic.messages.create({
+        model: options?.model || 'claude-sonnet-4-20250514',
+        max_tokens: options?.maxTokens || 8192,
+        temperature: options?.temperature ?? 0.3,
+        system,
+        messages,
+        tools,
+    });
+    return response;
+}
+function parseJsonResponse(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch { }
+    const codeFenceMatch = text.match(/```(?:json)?\s*\n?([\s\S]*?)\n?\s*```/);
+    if (codeFenceMatch) {
+        try {
+            return JSON.parse(codeFenceMatch[1]);
+        }
+        catch { }
+    }
+    const braceStart = text.indexOf('{');
+    const braceEnd = text.lastIndexOf('}');
+    if (braceStart !== -1 && braceEnd > braceStart) {
+        try {
+            return JSON.parse(text.substring(braceStart, braceEnd + 1));
+        }
+        catch { }
+    }
+    const bracketStart = text.indexOf('[');
+    const bracketEnd = text.lastIndexOf(']');
+    if (bracketStart !== -1 && bracketEnd > bracketStart) {
+        try {
+            return JSON.parse(text.substring(bracketStart, bracketEnd + 1));
+        }
+        catch { }
+    }
+    return null;
+}

package/dist/utils/logger.js

@@ -0,0 +1,83 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Logger = void 0;
+exports.formatDuration = formatDuration;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+class Logger {
+    constructor(projectDir) {
+        this.stream = null;
+        const logsDir = path.join(projectDir, 'logs');
+        if (!fs.existsSync(logsDir)) {
+            fs.mkdirSync(logsDir, { recursive: true });
+        }
+        this.logPath = path.join(logsDir, `run_${new Date().toISOString().replace(/[:.]/g, '-')}.log`);
+        this.stream = fs.createWriteStream(this.logPath, { flags: 'a' });
+    }
+    log(level, message) {
+        const timestamp = new Date().toISOString();
+        const line = `[${timestamp}] [${level}] ${message}\n`;
+        this.stream?.write(line);
+    }
+    info(message) {
+        this.log('INFO', message);
+    }
+    warn(message) {
+        this.log('WARN', message);
+    }
+    error(message) {
+        this.log('ERROR', message);
+    }
+    debug(message) {
+        this.log('DEBUG', message);
+    }
+    close() {
+        this.stream?.end();
+    }
+    getPath() {
+        return this.logPath;
+    }
+}
+exports.Logger = Logger;
+function formatDuration(ms) {
+    if (ms < 1000)
+        return `${ms}ms`;
+    if (ms < 60000)
+        return `${(ms / 1000).toFixed(1)}s`;
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.round((ms % 60000) / 1000);
+    return `${minutes}m ${seconds}s`;
+}

package/dist/utils/project.js

@@ -0,0 +1,100 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.generateProjectId = generateProjectId;
+exports.createProject = createProject;
+exports.updateProject = updateProject;
+exports.getProjectDir = getProjectDir;
+exports.saveProjectFile = saveProjectFile;
+exports.saveProjectBuffer = saveProjectBuffer;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const loader_1 = require("../config/loader");
+function generateProjectId() {
+    const now = new Date();
+    const date = now.toISOString().slice(0, 10).replace(/-/g, '');
+    const rand = Math.random().toString(36).substring(2, 8);
+    return `AS-${date}-${rand}`;
+}
+function createProject(topic, assets, method, hf) {
+    const id = generateProjectId();
+    const dir = path.join((0, loader_1.getProjectsDir)(), id);
+    fs.mkdirSync(path.join(dir, 'data'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'code'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'output', 'figures'), { recursive: true });
+    fs.mkdirSync(path.join(dir, 'logs'), { recursive: true });
+    const meta = {
+        id,
+        topic,
+        assets,
+        method,
+        status: 'planning',
+        createdAt: new Date().toISOString(),
+        updatedAt: new Date().toISOString(),
+        highFrequency: hf,
+    };
+    fs.writeFileSync(path.join(dir, 'meta.json'), JSON.stringify(meta, null, 2));
+    return { meta, dir };
+}
+function updateProject(projectId, updates) {
+    const dir = path.join((0, loader_1.getProjectsDir)(), projectId);
+    const metaPath = path.join(dir, 'meta.json');
+    if (!fs.existsSync(metaPath))
+        return;
+    const meta = JSON.parse(fs.readFileSync(metaPath, 'utf-8'));
+    const updated = { ...meta, ...updates, updatedAt: new Date().toISOString() };
+    fs.writeFileSync(metaPath, JSON.stringify(updated, null, 2));
+}
+function getProjectDir(projectId) {
+    return path.join((0, loader_1.getProjectsDir)(), projectId);
+}
+function saveProjectFile(projectId, subPath, content) {
+    const filePath = path.join((0, loader_1.getProjectsDir)(), projectId, subPath);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content, 'utf-8');
+    return filePath;
+}
+function saveProjectBuffer(projectId, subPath, content) {
+    const filePath = path.join((0, loader_1.getProjectsDir)(), projectId, subPath);
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(filePath, content);
+    return filePath;
+}

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "autoscholar-cli",
+  "version": "1.0.0",
+  "description": "Autonomous scientific research agent — a quant researcher + economist + data scientist living inside your terminal",
+  "main": "dist/index.js",
+  "bin": {
+    "autoscholar": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "dev": "ts-node src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "research",
+    "academic",
+    "econometrics",
+    "finance",
+    "ai",
+    "autonomous",
+    "cli",
+    "paper-generation",
+    "garch",
+    "literature-review"
+  ],
+  "author": "AutoScholar",
+  "license": "MIT",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.37.0",
+    "axios": "^1.7.0",
+    "boxen": "^5.1.2",
+    "chalk": "^4.1.2",
+    "cli-table3": "^0.6.5",
+    "commander": "^12.1.0",
+    "dotenv": "^16.4.5",
+    "figlet": "^1.7.0",
+    "gradient-string": "^2.0.2",
+    "inquirer": "^8.2.6",
+    "marked": "^12.0.0",
+    "marked-terminal": "^7.0.0",
+    "nanoid": "^3.3.7",
+    "ora": "^5.4.1",
+    "xml2js": "^0.6.2"
+  },
+  "devDependencies": {
+    "@types/figlet": "^1.5.8",
+    "@types/inquirer": "^8.2.10",
+    "@types/node": "^20.14.0",
+    "@types/xml2js": "^0.4.14",
+    "typescript": "^5.5.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/**/*.js",
+    "python",
+    "templates",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/python/analysis/garch_template.py

@@ -0,0 +1,131 @@
+"""
+GARCH / DCC-GARCH Analysis Template
+Used by Fisher agent for volatility modeling
+"""
+import matplotlib
+matplotlib.use('Agg')
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+import seaborn as sns
+import json
+import os
+import warnings
+warnings.filterwarnings('ignore')
+
+sns.set_theme(style='whitegrid', font_scale=1.2)
+
+
+def run_garch_analysis(data_path, output_dir, target_col=None, date_col='date'):
+    """
+    Run GARCH(1,1) analysis on a time series.
+
+    Args:
+        data_path: Path to CSV file
+        output_dir: Directory to save figures
+        target_col: Column to analyze (auto-detected if None)
+        date_col: Date column name
+    """
+    figures_dir = os.path.join(output_dir, 'figures')
+    os.makedirs(figures_dir, exist_ok=True)
+
+    df = pd.read_csv(data_path, parse_dates=[date_col] if date_col else False)
+    numeric_cols = df.select_dtypes(include=[np.number]).columns.tolist()
+
+    if target_col is None:
+        # Auto-detect: prefer 'close', 'adjusted_close', 'value'
+        for candidate in ['close', 'adjusted_close', 'adj_close', 'value', 'price']:
+            if candidate in [c.lower() for c in df.columns]:
+                target_col = [c for c in df.columns if c.lower() == candidate][0]
+                break
+        if target_col is None and numeric_cols:
+            target_col = numeric_cols[0]
+
+    if target_col is None:
+        return {"error": "No suitable column found"}
+
+    # Calculate returns
+    df['returns'] = df[target_col].pct_change().dropna()
+    df = df.dropna(subset=['returns'])
+    returns = df['returns'] * 100  # Scale to percentage
+
+    results = {"models": [], "figures": [], "diagnostics": []}
+
+    try:
+        from arch import arch_model
+
+        # Fit GARCH(1,1)
+        model = arch_model(returns, vol='Garch', p=1, q=1, dist='normal')
+        res = model.fit(disp='off')
+
+        results["models"].append({
+            "name": "GARCH(1,1)",
+            "type": "volatility",
+            "coefficients": {
+                "omega": float(res.params.get('omega', 0)),
+                "alpha[1]": float(res.params.get('alpha[1]', 0)),
+                "beta[1]": float(res.params.get('beta[1]', 0)),
+            },
+            "standardErrors": {k: float(v) for k, v in res.std_err.items()},
+            "pValues": {k: float(v) for k, v in res.pvalues.items()},
+            "diagnostics": [
+                f"Log-likelihood: {res.loglikelihood:.2f}",
+                f"AIC: {res.aic:.2f}",
+                f"BIC: {res.bic:.2f}",
+            ],
+            "significant": True,
+        })
+
+        # Conditional volatility
+        cond_vol = res.conditional_volatility
+
+        # Figure 1: Returns and conditional volatility
+        fig, axes = plt.subplots(2, 1, figsize=(14, 10), sharex=True)
+        axes[0].plot(range(len(returns)), returns, linewidth=0.5, alpha=0.8)
+        axes[0].set_title(f'Returns of {target_col}')
+        axes[0].set_ylabel('Returns (%)')
+        axes[1].plot(range(len(cond_vol)), cond_vol, color='red', linewidth=0.8)
+        axes[1].set_title('GARCH(1,1) Conditional Volatility')
+        axes[1].set_ylabel('Volatility (%)')
+        axes[1].set_xlabel('Observation')
+        plt.tight_layout()
+        plt.savefig(os.path.join(figures_dir, 'garch_volatility.png'), dpi=300, bbox_inches='tight')
+        plt.close()
+        results["figures"].append({"filename": "garch_volatility.png", "caption": "Returns and GARCH(1,1) conditional volatility"})
+
+        # Figure 2: News impact curve
+        fig, ax = plt.subplots(figsize=(10, 6))
+        shocks = np.linspace(-3, 3, 100)
+        omega = res.params.get('omega', 0.01)
+        alpha = res.params.get('alpha[1]', 0.1)
+        beta = res.params.get('beta[1]', 0.85)
+        avg_vol = cond_vol.mean()
+        impact = omega + alpha * (shocks * avg_vol) ** 2 + beta * avg_vol ** 2
+        ax.plot(shocks, np.sqrt(impact), linewidth=2)
+        ax.set_title('News Impact Curve')
+        ax.set_xlabel('Standardized Shock')
+        ax.set_ylabel('Next Period Volatility')
+        ax.axvline(x=0, color='gray', linestyle='--', alpha=0.5)
+        plt.tight_layout()
+        plt.savefig(os.path.join(figures_dir, 'news_impact.png'), dpi=300, bbox_inches='tight')
+        plt.close()
+        results["figures"].append({"filename": "news_impact.png", "caption": "GARCH news impact curve showing asymmetric volatility response"})
+
+        results["diagnostics"].extend([
+            f"Persistence (alpha+beta): {(alpha + beta):.4f}",
+            f"Half-life: {np.log(2) / np.log(alpha + beta):.1f} periods" if alpha + beta < 1 else "Non-stationary",
+            f"Unconditional variance: {omega / (1 - alpha - beta):.4f}" if alpha + beta < 1 else "Infinite",
+        ])
+
+    except ImportError:
+        results["diagnostics"].append("arch package not available — skipping GARCH estimation")
+
+    return results
+
+
+if __name__ == "__main__":
+    import sys
+    data_path = sys.argv[1] if len(sys.argv) > 1 else "data.csv"
+    output_dir = sys.argv[2] if len(sys.argv) > 2 else "output"
+    result = run_garch_analysis(data_path, output_dir)
+    print(json.dumps(result, indent=2))

package/python/clients/eodhd_client.py

@@ -0,0 +1,78 @@
+"""
+EODHD (End of Day Historical Data) Python Client
+Pre-loaded in AutoScholar Python execution environment
+"""
+import os
+import requests
+import pandas as pd
+from datetime import datetime
+
+class EODHDClient:
+    BASE_URL = "https://eodhd.com/api"
+
+    def __init__(self, api_key=None):
+        self.api_key = api_key or os.environ.get("EODHD_API_KEY", "")
+
+    def _normalize(self, ticker):
+        if "." not in ticker:
+            return f"{ticker}.US"
+        return ticker
+
+    def get_eod_df(self, ticker, from_date=None, to_date=None, period="d"):
+        """Get end-of-day historical data as DataFrame"""
+        normalized = self._normalize(ticker)
+        params = {"api_token": self.api_key, "fmt": "json", "period": period}
+        if from_date: params["from"] = from_date
+        if to_date: params["to"] = to_date
+        resp = requests.get(f"{self.BASE_URL}/eod/{normalized}", params=params, timeout=30)
+        resp.raise_for_status()
+        df = pd.DataFrame(resp.json())
+        if len(df) > 0:
+            df["date"] = pd.to_datetime(df["date"])
+        return df
+
+    def get_intraday_df(self, ticker, interval="5m", from_date=None, to_date=None):
+        """Get intraday data as DataFrame"""
+        normalized = self._normalize(ticker)
+        params = {"api_token": self.api_key, "fmt": "json", "interval": interval}
+        if from_date:
+            params["from"] = int(datetime.strptime(from_date, "%Y-%m-%d").timestamp())
+        if to_date:
+            params["to"] = int(datetime.strptime(to_date, "%Y-%m-%d").timestamp())
+        resp = requests.get(f"{self.BASE_URL}/intraday/{normalized}", params=params, timeout=30)
+        resp.raise_for_status()
+        df = pd.DataFrame(resp.json())
+        if len(df) > 0 and "datetime" in df.columns:
+            df["datetime"] = pd.to_datetime(df["datetime"])
+        return df
+
+    def get_options_df(self, ticker):
+        """Get options chain as DataFrame"""
+        normalized = self._normalize(ticker)
+        resp = requests.get(f"{self.BASE_URL}/options/{normalized}",
+                          params={"api_token": self.api_key, "fmt": "json"}, timeout=30)
+        resp.raise_for_status()
+        data = resp.json()
+        if isinstance(data, dict) and "data" in data:
+            rows = []
+            for exp in data["data"]:
+                exp_date = exp.get("expirationDate", "")
+                for opt_type in ["CALL", "PUT"]:
+                    for opt in exp.get("options", {}).get(opt_type, []):
+                        opt["expirationDate"] = exp_date
+                        opt["optionType"] = opt_type
+                        rows.append(opt)
+            return pd.DataFrame(rows)
+        return pd.DataFrame()
+
+    def get_live_quote(self, ticker):
+        """Get real-time quote"""
+        normalized = self._normalize(ticker)
+        resp = requests.get(f"{self.BASE_URL}/real-time/{normalized}",
+                          params={"api_token": self.api_key, "fmt": "json"}, timeout=10)
+        resp.raise_for_status()
+        return resp.json()
+
+
+# Pre-instantiate
+eodhd = EODHDClient()