@vespermcp/mcp-server 1.2.21 → 1.2.24

package/build/metadata/hackernews-source.js

@@ -0,0 +1,123 @@
+import { rateLimitedFetch } from "./rate-limiter.js";
+import { CircuitBreaker } from "./circuit-breaker.js";
+import { estimateQualityScore } from "./quality.js";
+export class HackerNewsSource {
+    cache;
+    breaker = new CircuitBreaker("hackernews", {
+        failureThreshold: 5,
+        openDurationMs: 30_000,
+        halfOpenSuccessesToClose: 2,
+    });
+    constructor(cache) {
+        this.cache = cache;
+    }
+    async discover(query, limit = 20) {
+        const out = await this.discoverWithTelemetry(query, limit);
+        return out.results;
+    }
+    async discoverWithTelemetry(query, limit = 20) {
+        const start = Date.now();
+        const cleanQuery = String(query || "").trim();
+        if (!cleanQuery)
+            return { results: [], cacheHit: false, latencyMs: Date.now() - start };
+        const perPage = Math.max(1, Math.min(100, Number(limit || 20)));
+        const cacheKey = `webcore:hackernews:discover:${cleanQuery.toLowerCase()}:hitsPerPage=${perPage}`;
+        const cached = await this.cache?.getJson(cacheKey);
+        if (cached)
+            return { results: cached, cacheHit: true, latencyMs: Date.now() - start };
+        if (!this.breaker.canAttempt()) {
+            throw new Error("Hacker News connector is temporarily unavailable (circuit open).");
+        }
+        const url = new URL("https://hn.algolia.com/api/v1/search");
+        url.searchParams.set("query", cleanQuery);
+        url.searchParams.set("hitsPerPage", String(perPage));
+        url.searchParams.set("page", "0");
+        const response = await rateLimitedFetch(url.toString(), {
+            headers: {
+                "Accept": "application/json",
+                "User-Agent": "vesper/2.0 (phase1-hackernews-connector)",
+            },
+        }, { maxRetries: 5, initialDelay: 750, maxDelay: 15000 }).catch((e) => {
+            this.breaker.onFailure();
+            throw e;
+        });
+        const data = await response.json().catch((e) => {
+            this.breaker.onFailure();
+            throw new Error(`Hacker News JSON parse failed: ${e?.message || String(e)}`);
+        });
+        const hits = Array.isArray(data?.hits) ? data.hits : [];
+        const result = hits.slice(0, perPage).map((h) => this.toDatasetMetadata(h));
+        this.breaker.onSuccess();
+        await this.cache?.setJson(cacheKey, result, 7200); // 2h
+        return { results: result, cacheHit: false, latencyMs: Date.now() - start };
+    }
+    toDatasetMetadata(hit) {
+        const objectID = String(hit.objectID ?? "").trim();
+        const title = String(hit.title || "").trim() || `HN item ${objectID}`;
+        const createdAt = hit.created_at ? String(hit.created_at) : new Date().toISOString();
+        const author = hit.author ? String(hit.author).trim() : "";
+        const points = Number(hit.points || 0);
+        const comments = Number(hit.num_comments || 0);
+        const storyText = String(hit.story_text || "").trim();
+        const qualityWarnings = [];
+        if (!storyText)
+            qualityWarnings.push("Missing story text in Hacker News response");
+        const abstractLength = (storyText || title).length;
+        const authorsPresent = !!author;
+        const datePresent = !!createdAt;
+        const contentDepth = abstractLength;
+        const quality01 = estimateQualityScore({
+            abstractLength,
+            authorsPresent,
+            datePresent,
+            contentDepth,
+        });
+        const itemUrl = hit.url ? String(hit.url) : (objectID ? `https://news.ycombinator.com/item?id=${objectID}` : "");
+        return {
+            id: objectID || title,
+            source: "hackernews",
+            name: title,
+            description: storyText || title,
+            authors: author ? [author] : undefined,
+            downloads: comments,
+            likes: points,
+            stars: points,
+            tags: author ? ["hackernews", `author:${author}`] : ["hackernews"],
+            last_updated: createdAt,
+            task: "thread",
+            languages: [],
+            domain: "tech",
+            splits: [],
+            license: {
+                id: "unknown",
+                category: "unknown",
+                usage_restrictions: [],
+                warnings: [],
+            },
+            quality_score: Math.round(quality01 * 100),
+            quality_warnings: qualityWarnings,
+            download_url: itemUrl,
+            format: "TEXT",
+            total_examples: 1,
+            total_size_bytes: undefined,
+            total_size_mb: undefined,
+            columns: [
+                { name: "title", type: "string" },
+                { name: "text", type: "string" },
+            ],
+            is_structured: true,
+            has_target_column: false,
+            is_safe_source: true,
+            has_personal_data: false,
+            is_paywalled: false,
+            is_scraped_web_data: false,
+            uses_https: true,
+            has_train_split: false,
+            has_test_split: false,
+            has_validation_split: false,
+            description_length: (storyText || title).length,
+            has_readme: false,
+            metadata_url: itemUrl,
+        };
+    }
+}

package/build/metadata/quality.js

@@ -46,3 +46,30 @@ export function calculateQualityScore(data) {
         score += 2;
     return Math.min(100, score);
 }
+/**
+ * Phase 1 Web Core quality estimator (document-first).
+ *
+ * Returns a score in the range [0.3, 1.0] (never 0) using weighted signals:
+ * - abstract length (text richness)
+ * - authors presence (provenance)
+ * - date presence (freshness / completeness)
+ * - content depth (optional full text / README length)
+ */
+export function estimateQualityScore(input) {
+    const abstractLen = Math.max(0, Number(input.abstractLength || 0));
+    const contentDepth = Math.max(0, Number(input.contentDepth || 0));
+    // Logistic-ish squashing: near-1 once abstract is moderately long.
+    const abstractScore = 1 / (1 + Math.exp(-(abstractLen - 200) / 120));
+    const depthScore = 1 / (1 + Math.exp(-(contentDepth - 1200) / 500));
+    const authorsScore = input.authorsPresent ? 1 : 0;
+    const dateScore = input.datePresent ? 1 : 0;
+    // Base is intentionally high so that for complete records the score clusters near 1.0.
+    const base = 0.3;
+    const score = base +
+        0.25 * abstractScore +
+        0.25 * depthScore +
+        0.1 * authorsScore +
+        0.1 * dateScore;
+    // Clamp to [0.3, 1.0]
+    return Math.max(0.3, Math.min(1.0, score));
+}

package/build/metadata/scraper.js

@@ -3,22 +3,29 @@ import { categorizeLicense } from "./license.js";
 import { calculateQualityScore } from "./quality.js";
 import { classifyDomain } from "./domain.js";
 import { retryWithBackoff, delayBetweenRequests } from "./rate-limiter.js";
+import { analyzeDatasetQuery, buildIntentSearchQuery, buildHuggingFaceFilterTags, scoreDatasetAgainstIntent, shouldExcludeByLanguage } from "../search/query-intent.js";
 export class HuggingFaceScraper {
     /**
      * Bulk discovery: Fetch many datasets quickly without deep details.
      * Hits the 25k target in minutes.
      */
-    async scrapeBulk(limit = 1000, query) {
+    async scrapeBulk(limit = 1000, queryOrIntent) {
+        const intent = typeof queryOrIntent === "string"
+            ? await analyzeDatasetQuery(queryOrIntent)
+            : queryOrIntent;
+        const query = typeof queryOrIntent === "string" ? queryOrIntent : intent?.searchQuery;
+        const hfQuery = intent ? buildIntentSearchQuery(intent) : query;
         const filterMsg = query ? `, query: ${query}` : "";
         console.error(`[Bulk Scraper] Fetching datasets (target limit: ${limit}${filterMsg})...`);
         const results = [];
         let processed = 0;
         try {
             const hfToken = process.env.HF_TOKEN || process.env.HUGGINGFACE_TOKEN;
+            const hfFilterTags = intent ? buildHuggingFaceFilterTags(intent) : [];
             for await (const ds of listDatasets({
                 limit: limit,
                 additionalFields: ["description", "tags", "downloadsAllTime", "createdAt"],
-                search: { query: query },
+                search: { query: hfQuery, tags: hfFilterTags.length > 0 ? hfFilterTags : undefined },
                 ...(hfToken ? { accessToken: hfToken } : {})
             })) {
                 if (results.length >= limit)
@@ -78,6 +85,9 @@ export class HuggingFaceScraper {
                     has_readme: false,
                     is_incomplete: true // Flag for Phase 2
                 };
+                // Hard language exclusion
+                if (intent && shouldExcludeByLanguage(metadata, intent))
+                    continue;
                 results.push(metadata);
             }
         }
@@ -86,8 +96,12 @@ export class HuggingFaceScraper {
         }
         return results;
     }
-    async scrape(limit = 100, applyMVPFilters = true, query // Use as general search query
-    ) {
+    async scrape(limit = 100, applyMVPFilters = true, queryOrIntent) {
+        const intent = typeof queryOrIntent === "string"
+            ? await analyzeDatasetQuery(queryOrIntent)
+            : queryOrIntent;
+        const query = typeof queryOrIntent === "string" ? queryOrIntent : intent?.searchQuery;
+        const hfQuery = intent ? buildIntentSearchQuery(intent) : query;
         const filterMsg = query ? `, query: ${query}` : "";
         console.error(`Fetching datasets (target limit: ${limit}, MVP filters: ${applyMVPFilters}${filterMsg})...`);
         const results = [];
@@ -110,10 +124,11 @@ export class HuggingFaceScraper {
             }
             // Add delay between batches to avoid rate limits
             const BATCH_DELAY = hfToken ? 500 : 2000;
+            const hfFilterTags = intent ? buildHuggingFaceFilterTags(intent) : [];
             for await (const ds of listDatasets({
                 limit: fetchLimit,
                 additionalFields: ["description", "tags"],
-                search: { query: query },
+                search: { query: hfQuery, tags: hfFilterTags.length > 0 ? hfFilterTags : undefined },
                 ...(hfToken ? { accessToken: hfToken } : {})
             })) {
                 if (results.length >= limit)
@@ -150,18 +165,61 @@ export class HuggingFaceScraper {
                             initialDelay: 2000, // Start with 2 seconds for HF API
                             maxDelay: 30000 // Max 30 seconds
                         });
-                        const splits = fullInfo.splits?.map((s) => ({
+                        const cardData = fullInfo.cardData || {};
+                        // Extract splits from cardData.dataset_info (where HF actually stores them)
+                        // cardData.dataset_info can be an object (single config) or array (multi-config)
+                        let rawSplits = [];
+                        const datasetInfoField = cardData.dataset_info;
+                        if (datasetInfoField) {
+                            const configs = Array.isArray(datasetInfoField) ? datasetInfoField : [datasetInfoField];
+                            for (const config of configs) {
+                                if (config?.splits && Array.isArray(config.splits)) {
+                                    rawSplits = rawSplits.concat(config.splits);
+                                }
+                            }
+                        }
+                        // Fallback: try top-level splits from the SDK (rarely populated)
+                        if (rawSplits.length === 0 && fullInfo.splits) {
+                            rawSplits = fullInfo.splits;
+                        }
+                        const splits = rawSplits.map((s) => ({
                             name: s.name,
-                            num_examples: s.numExamples || 0,
-                            size_bytes: s.sizeBytes
-                        })) || [];
-                        const totalExamples = splits.reduce((sum, s) => sum + (s.num_examples || 0), 0);
+                            num_examples: s.num_examples || s.numExamples || 0,
+                            size_bytes: s.num_bytes || s.sizeBytes || 0
+                        }));
+                        let totalExamples = splits.reduce((sum, s) => sum + (s.num_examples || 0), 0);
                         const totalSizeBytes = splits.reduce((sum, s) => sum + (s.size_bytes || 0), 0);
+                        // Fallback: estimate from size_categories when splits give 0
+                        if (totalExamples === 0) {
+                            const sizeCategories = cardData.size_categories;
+                            if (Array.isArray(sizeCategories) && sizeCategories.length > 0) {
+                                const cat = sizeCategories[0];
+                                const rangeMatch = cat.match(/([\d.]+[KMB]?)\s*<\s*n\s*<\s*([\d.]+[KMB]?)/i);
+                                if (rangeMatch) {
+                                    const parseHumanNum = (s) => {
+                                        const m = s.match(/^([\d.]+)([KMB])?$/i);
+                                        if (!m)
+                                            return 0;
+                                        const base = parseFloat(m[1]);
+                                        const suffix = (m[2] || '').toUpperCase();
+                                        if (suffix === 'K')
+                                            return base * 1000;
+                                        if (suffix === 'M')
+                                            return base * 1_000_000;
+                                        if (suffix === 'B')
+                                            return base * 1_000_000_000;
+                                        return base;
+                                    };
+                                    const lo = parseHumanNum(rangeMatch[1]);
+                                    const hi = parseHumanNum(rangeMatch[2]);
+                                    totalExamples = Math.round((lo + hi) / 2);
+                                }
+                            }
+                        }
                         const totalSizeMB = totalSizeBytes ? Math.round(totalSizeBytes / (1024 * 1024) * 100) / 100 : undefined;
                         const hasValidationSplit = splits.some((s) => s.name === "validation" || s.name === "val");
                         const licenseTag = tags.find(t => t.startsWith("license:"));
                         const licenseId = licenseTag ? licenseTag.replace("license:", "") : fullInfo.license;
-                        const cardData = fullInfo.cardData || {};
                         const licenseUrl = cardData.license?.[0]?.link || cardData.license_link;
                         const license = categorizeLicense(licenseId, licenseUrl);
                         if (license.category === "restricted") {
@@ -247,7 +305,16 @@ export class HuggingFaceScraper {
                             description_length: description.length,
                             has_readme: !!(cardData.readme || cardData.readme_content)
                         };
-                        results.push(metadata);
+                        // Hard language exclusion — drop bilingual/multilingual for single-language queries
+                        if (intent && shouldExcludeByLanguage(metadata, intent)) {
+                            // skip — do not push
+                        }
+                        else {
+                            if (intent) {
+                                metadata.intent_score = scoreDatasetAgainstIntent(metadata, intent);
+                            }
+                            results.push(metadata);
+                        }
                     }
                     catch (e) {
                         // Track all errors for user feedback
@@ -297,8 +364,12 @@ export class HuggingFaceScraper {
         if (otherErrors > 0) {
             console.error(`[HF Scraper] ⚠️ ${otherErrors} datasets skipped due to errors`);
         }
-        // Sort by downloads descending
-        return results.sort((a, b) => b.downloads - a.downloads);
+        return results.sort((a, b) => {
+            const intentDelta = Number(b.intent_score || 0) - Number(a.intent_score || 0);
+            if (intentDelta !== 0)
+                return intentDelta;
+            return b.downloads - a.downloads;
+        });
     }
     extractTask(tags) {
         const taskTags = [

package/build/metadata/semantic-scholar-source.js

@@ -0,0 +1,138 @@
+import { rateLimitedFetch } from "./rate-limiter.js";
+import { CircuitBreaker } from "./circuit-breaker.js";
+import { estimateQualityScore } from "./quality.js";
+export class SemanticScholarSource {
+    cache;
+    breaker = new CircuitBreaker("semantic_scholar", {
+        failureThreshold: 5,
+        openDurationMs: 30_000,
+        halfOpenSuccessesToClose: 2,
+    });
+    constructor(cache) {
+        this.cache = cache;
+    }
+    async discover(query, limit = 20) {
+        const out = await this.discoverWithTelemetry(query, limit);
+        return out.results;
+    }
+    async discoverWithTelemetry(query, limit = 20) {
+        const start = Date.now();
+        const cleanQuery = String(query || "").trim();
+        if (!cleanQuery)
+            return { results: [], cacheHit: false, latencyMs: Date.now() - start };
+        const perPage = Math.max(1, Math.min(100, Number(limit || 20)));
+        const cacheKey = `webcore:semantic_scholar:discover:${cleanQuery.toLowerCase()}:limit=${perPage}`;
+        const cached = await this.cache?.getJson(cacheKey);
+        if (cached)
+            return { results: cached, cacheHit: true, latencyMs: Date.now() - start };
+        if (!this.breaker.canAttempt()) {
+            throw new Error("Semantic Scholar connector is temporarily unavailable (circuit open).");
+        }
+        const url = new URL("https://api.semanticscholar.org/graph/v1/paper/search");
+        url.searchParams.set("query", cleanQuery);
+        url.searchParams.set("limit", String(perPage));
+        url.searchParams.set("fields", [
+            "paperId",
+            "title",
+            "abstract",
+            "url",
+            "venue",
+            "year",
+            "citationCount",
+            "authors",
+            "publicationTypes",
+            "openAccessPdf",
+        ].join(","));
+        const response = await rateLimitedFetch(url.toString(), {
+            headers: {
+                "Accept": "application/json",
+                "User-Agent": "vesper/2.0 (phase1-semantic-scholar-connector)",
+            },
+        }, { maxRetries: 5, initialDelay: 1000, maxDelay: 20000 }).catch((e) => {
+            this.breaker.onFailure();
+            throw e;
+        });
+        const data = await response.json().catch((e) => {
+            this.breaker.onFailure();
+            throw new Error(`Semantic Scholar JSON parse failed: ${e?.message || String(e)}`);
+        });
+        const papers = Array.isArray(data?.data) ? data.data : [];
+        const result = papers.map((p) => this.toDatasetMetadata(p)).filter(Boolean);
+        this.breaker.onSuccess();
+        await this.cache?.setJson(cacheKey, result, 86400); // 24h
+        return { results: result, cacheHit: false, latencyMs: Date.now() - start };
+    }
+    toDatasetMetadata(paper) {
+        const paperId = String(paper.paperId || paper.externalIds?.DOI || "").trim();
+        const title = String(paper.title || "").trim();
+        const abstract = String(paper.abstract || "").trim();
+        const url = String(paper.url || "").trim();
+        const authors = Array.isArray(paper.authors) ? paper.authors.map((a) => String(a.name || "").trim()).filter(Boolean) : [];
+        const tags = [
+            ...(Array.isArray(paper.publicationTypes) ? paper.publicationTypes.filter(Boolean).map(String) : []),
+            ...(paper.venue ? [String(paper.venue)] : []),
+        ];
+        const citationCount = Number(paper.citationCount || 0);
+        const qualityWarnings = [];
+        if (!abstract)
+            qualityWarnings.push("Missing abstract from Semantic Scholar response");
+        const abstractLength = (abstract || title).length;
+        const authorsPresent = authors.length > 0;
+        const datePresent = paper.year !== undefined && paper.year !== null;
+        const contentDepth = abstractLength;
+        const quality01 = estimateQualityScore({
+            abstractLength,
+            authorsPresent,
+            datePresent,
+            contentDepth,
+        });
+        const openAccessPdfUrl = paper.openAccessPdf?.url ? String(paper.openAccessPdf.url).trim() : undefined;
+        const downloadUrl = openAccessPdfUrl || url || (paperId ? `https://www.semanticscholar.org/paper/${paperId}` : "");
+        return {
+            id: paperId || url || title,
+            source: "semantic_scholar",
+            name: title || "Untitled",
+            description: abstract || title,
+            authors,
+            downloads: 0,
+            likes: citationCount,
+            stars: citationCount,
+            tags,
+            last_updated: new Date().toISOString(),
+            task: "research-paper",
+            languages: [],
+            domain: "research",
+            splits: [],
+            license: {
+                id: "unknown",
+                category: "unknown",
+                usage_restrictions: [],
+                warnings: [],
+            },
+            quality_score: Math.round(quality01 * 100),
+            quality_warnings: qualityWarnings,
+            download_url: downloadUrl,
+            format: "PDF",
+            total_examples: 1,
+            total_size_bytes: undefined,
+            total_size_mb: undefined,
+            columns: [
+                { name: "title", type: "string" },
+                { name: "abstract", type: "string" },
+            ],
+            is_structured: true,
+            has_target_column: false,
+            is_safe_source: true,
+            has_personal_data: false,
+            is_paywalled: false,
+            is_scraped_web_data: false,
+            uses_https: true,
+            has_train_split: false,
+            has_test_split: false,
+            has_validation_split: false,
+            description_length: (abstract || title).length,
+            has_readme: false,
+            metadata_url: url || (paperId ? `https://www.semanticscholar.org/paper/${paperId}` : ""),
+        };
+    }
+}

package/build/python/asset_downloader_engine.py

@@ -26,6 +26,7 @@ def _print(payload: Dict[str, Any]) -> None:
 async def _run_download(args: argparse.Namespace) -> Dict[str, Any]:
     payload = json.loads(args.payload)
     output_root = payload.get("output_root") or str(Path.home() / ".vesper" / "data" / "assets")
+    output_dir = payload.get("output_dir")
     workers = int(payload.get("workers") or 8)
     recipes_dir = payload.get("recipes_dir")
 
@@ -43,6 +44,7 @@ async def _run_download(args: argparse.Namespace) -> Dict[str, Any]:
         kaggle_ref=payload.get("kaggle_ref"),
         urls=payload.get("urls"),
         output_format=payload.get("output_format", "webdataset"),
+        output_dir=str(output_dir) if output_dir else None,
         max_items=payload.get("max_items"),
         image_column=payload.get("image_column"),
     )

package/build/python/convert_engine.py

@@ -0,0 +1,92 @@
+"""
+Convert a dataset file between formats (CSV, Parquet, JSON, JSONL).
+Usage: convert_engine.py <input_path> <output_path>
+Outputs JSON: {"ok": true, "output_path": "...", "rows": N, "columns": N} or {"ok": false, "error": "..."}
+"""
+import sys
+import json
+import os
+
+try:
+    import polars as pl
+except Exception:
+    print(json.dumps({"ok": False, "error": "polars is required. Install with: pip install polars"}))
+    sys.exit(1)
+
+
+def _load(src: str) -> pl.DataFrame:
+    ext = os.path.splitext(src)[1].lower()
+    if ext == ".csv":
+        return pl.read_csv(src, ignore_errors=True, infer_schema_length=10000)
+    if ext in (".tsv", ".tab"):
+        return pl.read_csv(src, separator="\t", ignore_errors=True, infer_schema_length=10000)
+    if ext in (".parquet", ".pq"):
+        return pl.read_parquet(src)
+    if ext in (".feather", ".ftr", ".arrow", ".ipc"):
+        return pl.read_ipc(src)
+    if ext in (".jsonl", ".ndjson"):
+        return pl.read_ndjson(src)
+    if ext == ".json":
+        raw = open(src, "r", encoding="utf-8").read().strip()
+        if raw.startswith("["):
+            return pl.read_json(src)
+        if "\n" in raw and raw.split("\n")[0].strip().startswith("{"):
+            return pl.read_ndjson(src)
+        obj = json.loads(raw)
+        if isinstance(obj, dict):
+            for key in ("data", "rows", "items", "records", "results", "entries", "samples"):
+                if key in obj and isinstance(obj[key], list):
+                    return pl.DataFrame(obj[key])
+            for v in obj.values():
+                if isinstance(v, list) and len(v) > 0 and isinstance(v[0], dict):
+                    return pl.DataFrame(v)
+        return pl.read_json(src)
+    # Fallback: try csv
+    return pl.read_csv(src, ignore_errors=True, infer_schema_length=10000)
+
+
+def _write(df: pl.DataFrame, dst: str) -> None:
+    ext = os.path.splitext(dst)[1].lower()
+    os.makedirs(os.path.dirname(dst) or ".", exist_ok=True)
+    if ext in (".parquet", ".pq"):
+        df.write_parquet(dst)
+    elif ext == ".csv":
+        df.write_csv(dst)
+    elif ext == ".json":
+        df.write_json(dst, row_oriented=True)
+    elif ext in (".jsonl", ".ndjson"):
+        df.write_ndjson(dst)
+    else:
+        raise ValueError(f"Unsupported output format: {ext}")
+
+
+def main():
+    if len(sys.argv) < 3:
+        print(json.dumps({"ok": False, "error": "Usage: convert_engine.py <input> <output>"}))
+        sys.exit(1)
+
+    input_path = sys.argv[1]
+    output_path = sys.argv[2]
+
+    if not os.path.exists(input_path):
+        print(json.dumps({"ok": False, "error": f"File not found: {input_path}"}))
+        sys.exit(1)
+
+    try:
+        df = _load(input_path)
+        _write(df, output_path)
+        size_mb = round(os.path.getsize(output_path) / (1024 * 1024), 2)
+        print(json.dumps({
+            "ok": True,
+            "output_path": output_path,
+            "rows": df.height,
+            "columns": df.width,
+            "size_mb": size_mb,
+        }))
+    except Exception as e:
+        print(json.dumps({"ok": False, "error": str(e)}))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

package/build/python/export_engine.py

@@ -50,6 +50,51 @@ def _load(file_path: str, options: dict) -> pl.DataFrame:
         df = pl.read_ipc(file_path)
     elif ext == ".jsonl":
         df = pl.read_ndjson(file_path)
+    elif ext == ".json":
+        # Auto-detect: array-of-objects vs NDJSON vs nested structures
+        try:
+            import json as _json
+            with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
+                raw_text = fh.read(512)  # peek
+            stripped = raw_text.lstrip()
+            if stripped.startswith("["):
+                # Array of objects — standard JSON
+                with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
+                    data = _json.load(fh)
+                if isinstance(data, list) and len(data) > 0:
+                    df = pl.DataFrame(data)
+                else:
+                    raise ValueError("JSON file is empty or not an array of objects")
+            elif stripped.startswith("{"):
+                # Could be NDJSON or a single object wrapping rows
+                try:
+                    df = pl.read_ndjson(file_path)
+                except Exception:
+                    with open(file_path, "r", encoding="utf-8", errors="ignore") as fh:
+                        data = _json.load(fh)
+                    # Try common wrapper patterns: {"data": [...]}, {"rows": [...]}, etc.
+                    rows = None
+                    if isinstance(data, dict):
+                        for key in ("data", "rows", "records", "items", "results", "entries"):
+                            if key in data and isinstance(data[key], list):
+                                rows = data[key]
+                                break
+                        if rows is None:
+                            # Last resort: try to use the dict values
+                            rows = [data]
+                    if rows and len(rows) > 0:
+                        df = pl.DataFrame(rows)
+                    else:
+                        raise ValueError("Could not parse JSON structure into tabular data")
+            else:
+                raise ValueError("JSON file does not start with [ or {")
+        except pl.exceptions.ComputeError as ce:
+            raise ValueError(f"Failed to parse JSON: {ce}")
+    elif ext == ".xlsx":
+        try:
+            df = pl.read_excel(file_path)
+        except Exception as e:
+            raise ValueError(f"Failed to read Excel file: {e}")
     else:
         raise ValueError(f"Unsupported input format: {ext}")