neuronix-node 0.1.0

package/dist/index.js

@@ -0,0 +1,279 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_js_1 = require("./config.js");
+const hardware_js_1 = require("./hardware.js");
+const api_js_1 = require("./api.js");
+const models_js_1 = require("./models.js");
+const inference_js_1 = require("./inference.js");
+const index_js_1 = require("./handlers/index.js");
+const updater_js_1 = require("./updater.js");
+// ── Helpers ──────────────────────────────────────────────────
+function log(msg) {
+    const ts = new Date().toLocaleTimeString();
+    console.log(`  [${ts}]  ${msg}`);
+}
+function banner() {
+    console.log("");
+    console.log("  ╔══════════════════════════════════════════════════╗");
+    console.log("  ║                                                  ║");
+    console.log("  ║       Neuronix GPU Provider Node  v0.1.0         ║");
+    console.log("  ║       Earn by contributing compute               ║");
+    console.log("  ║                                                  ║");
+    console.log("  ╚══════════════════════════════════════════════════╝");
+    console.log("");
+}
+function hardwareTable(hw) {
+    console.log("  ┌─────────────────────────────────────────────────┐");
+    console.log(`  │  Hostname:  ${hw.hostname.padEnd(37)}│`);
+    console.log(`  │  OS:        ${hw.os.slice(0, 37).padEnd(37)}│`);
+    console.log(`  │  CPU:       ${hw.cpuModel.slice(0, 37).padEnd(37)}│`);
+    console.log(`  │  RAM:       ${(Math.round(hw.ramMb / 1024) + " GB").padEnd(37)}│`);
+    console.log(`  │  GPU:       ${hw.gpuModel.slice(0, 37).padEnd(37)}│`);
+    console.log(`  │  VRAM:      ${(hw.gpuVramMb > 0 ? hw.gpuVramMb + " MB" : "N/A (CPU mode)").padEnd(37)}│`);
+    console.log("  └─────────────────────────────────────────────────┘");
+    console.log("");
+}
+// ── Authentication ───────────────────────────────────────────
+async function authenticate(config) {
+    if (config.authToken) {
+        log("Already authenticated.");
+        return;
+    }
+    // Check for email/password in env or prompt
+    const email = process.env.NEURONIX_EMAIL;
+    const password = process.env.NEURONIX_PASSWORD;
+    if (email && password) {
+        log(`Authenticating as ${email}...`);
+        const result = await (0, api_js_1.loginProvider)(config, email, password);
+        config.authToken = result.access_token;
+        config.userId = result.user_id;
+        (0, config_js_1.saveConfig)(config);
+        log("Authenticated successfully.");
+        return;
+    }
+    // Interactive login via readline
+    const readline = await import("readline");
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    const ask = (q) => new Promise((r) => rl.question(q, r));
+    console.log("");
+    console.log("  ── Login to your Neuronix account ──");
+    console.log("  (Create one at https://neuronix-nu.vercel.app/signup)");
+    console.log("");
+    const inputEmail = await ask("  Email: ");
+    const inputPassword = await ask("  Password: ");
+    rl.close();
+    console.log("");
+    log(`Authenticating as ${inputEmail}...`);
+    const result = await (0, api_js_1.loginProvider)(config, inputEmail, inputPassword);
+    config.authToken = result.access_token;
+    config.userId = result.user_id;
+    (0, config_js_1.saveConfig)(config);
+    log("Authenticated successfully.");
+}
+// ── Main ─────────────────────────────────────────────────────
+async function main() {
+    banner();
+    const config = (0, config_js_1.loadConfig)();
+    // Check for updates
+    log("Checking for updates...");
+    try {
+        const updateInfo = await (0, updater_js_1.checkForUpdates)("0.1.0");
+        if (updateInfo.updateAvailable) {
+            console.log("");
+            console.log(`  ⚠  Update available: v${updateInfo.latestVersion}`);
+            console.log(`     ${updateInfo.downloadUrl}`);
+            console.log(`     ${updateInfo.releaseNotes}`);
+            console.log("");
+        }
+        else {
+            log("Up to date.");
+        }
+    }
+    catch {
+        log("Could not check for updates (continuing).");
+    }
+    // Authenticate
+    await authenticate(config);
+    // Detect hardware
+    log("Detecting hardware...");
+    const hw = await (0, hardware_js_1.detectHardware)();
+    hardwareTable(hw);
+    // Show compatible models
+    const compatible = (0, models_js_1.listCompatibleModels)(hw.gpuVramMb);
+    log(`Compatible models: ${compatible.map((m) => m.name).join(", ")}`);
+    // Download and load the best default model
+    const defaultModel = (0, models_js_1.selectModel)("inference", hw.gpuVramMb);
+    log(`Selected model: ${defaultModel.name} (${defaultModel.sizeMb} MB)`);
+    try {
+        const modelPath = await (0, models_js_1.ensureModelDownloaded)(config.modelsDir, defaultModel, (pct) => {
+            process.stdout.write(`\r  Downloading ${defaultModel.name}... ${pct}%`);
+        });
+        if (modelPath.includes("%"))
+            console.log(""); // newline after progress
+        log(`Model ready: ${defaultModel.file}`);
+        log("Loading model into memory...");
+        await (0, inference_js_1.loadModel)(modelPath, defaultModel.id);
+        log("Model loaded. Ready to accept tasks.");
+    }
+    catch (err) {
+        log(`Model setup failed: ${err}`);
+        log("Continuing — will attempt to load models on demand.");
+    }
+    // Register with the network
+    log("Registering with Neuronix network...");
+    try {
+        const reg = await (0, api_js_1.registerNode)(config, hw);
+        config.nodeId = reg.node.id;
+        (0, config_js_1.saveConfig)(config);
+        log(`Registered! Node ID: ${config.nodeId}`);
+    }
+    catch (err) {
+        log(`Registration failed: ${err}`);
+        process.exit(1);
+    }
+    console.log("");
+    console.log("  ════════════════════════════════════════════════════");
+    console.log("  Node is ONLINE and listening for tasks.");
+    console.log("  Press Ctrl+C to stop.");
+    console.log("  ════════════════════════════════════════════════════");
+    console.log("");
+    // Heartbeat loop
+    let consecutiveHeartbeatFailures = 0;
+    const heartbeatLoop = setInterval(async () => {
+        try {
+            await (0, api_js_1.sendHeartbeat)(config, "online");
+            consecutiveHeartbeatFailures = 0;
+        }
+        catch {
+            consecutiveHeartbeatFailures++;
+            if (consecutiveHeartbeatFailures >= 5) {
+                log("Lost connection to network (5 consecutive heartbeat failures). Reconnecting...");
+                try {
+                    await (0, api_js_1.registerNode)(config, hw);
+                    consecutiveHeartbeatFailures = 0;
+                    log("Reconnected.");
+                }
+                catch {
+                    log("Reconnection failed. Retrying next heartbeat.");
+                }
+            }
+        }
+    }, config.heartbeatIntervalMs);
+    // Task polling loop with error recovery
+    let running = true;
+    let tasksCompleted = 0;
+    let tasksFailed = 0;
+    let totalEarned = 0;
+    let consecutivePollErrors = 0;
+    const shutdown = async () => {
+        running = false;
+        clearInterval(heartbeatLoop);
+        log("Shutting down...");
+        (0, inference_js_1.unloadAll)();
+        try {
+            await (0, api_js_1.sendHeartbeat)(config, "offline");
+        }
+        catch { }
+        console.log("");
+        console.log(`  Session: ${tasksCompleted} completed, ${tasksFailed} failed, $${totalEarned.toFixed(4)} earned`);
+        console.log("");
+        process.exit(0);
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+    while (running) {
+        try {
+            const result = await (0, api_js_1.pollTask)(config);
+            consecutivePollErrors = 0;
+            if (result.task) {
+                const task = result.task;
+                log(`Task received: ${task.id.slice(0, 8)}... [${task.type}] model=${task.model || "auto"}`);
+                // Set node to busy
+                await (0, api_js_1.sendHeartbeat)(config, "busy");
+                const taskStart = Date.now();
+                const taskTimeout = (task.timeout_seconds || 120) * 1000;
+                try {
+                    let outputPayload;
+                    let durationMs;
+                    // Check if we have a specialized handler for this task type
+                    if ((0, index_js_1.hasHandler)(task.type)) {
+                        log(`Running ${task.type} handler...`);
+                        const handlerPromise = (0, index_js_1.runHandler)({
+                            type: task.type,
+                            input_payload: task.input_payload,
+                            model: task.model,
+                        });
+                        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Task timed out")), taskTimeout));
+                        const result = await Promise.race([handlerPromise, timeoutPromise]);
+                        durationMs = result.duration_ms;
+                        outputPayload = result;
+                    }
+                    else {
+                        // Default: LLM inference
+                        const requestedModel = task.model || "auto";
+                        let modelId;
+                        if (requestedModel === "auto") {
+                            const best = (0, models_js_1.selectModel)(task.type, hw.gpuVramMb);
+                            modelId = best.id;
+                        }
+                        else {
+                            modelId = requestedModel;
+                        }
+                        if (!(0, inference_js_1.isModelLoaded)(modelId)) {
+                            const modelSpec = (0, models_js_1.selectModel)(task.type, hw.gpuVramMb);
+                            log(`Loading model ${modelSpec.name}...`);
+                            const modelPath = await (0, models_js_1.ensureModelDownloaded)(config.modelsDir, modelSpec, (pct) => {
+                                process.stdout.write(`\r  Downloading... ${pct}%`);
+                            });
+                            console.log("");
+                            await (0, inference_js_1.loadModel)(modelPath, modelSpec.id);
+                            modelId = modelSpec.id;
+                        }
+                        const prompt = task.input_payload.prompt || "Hello";
+                        const maxTokens = task.input_payload.max_tokens || 256;
+                        const inferencePromise = (0, inference_js_1.runInference)(modelId, prompt, maxTokens);
+                        const timeoutPromise = new Promise((_, reject) => setTimeout(() => reject(new Error("Task timed out")), taskTimeout));
+                        const result = await Promise.race([inferencePromise, timeoutPromise]);
+                        durationMs = result.durationMs;
+                        outputPayload = {
+                            text: result.text,
+                            tokens: result.text.split(/\s+/).length,
+                            model: modelId,
+                            duration_ms: durationMs,
+                        };
+                    }
+                    await (0, api_js_1.completeTask)(config, task.id, "completed", outputPayload, durationMs);
+                    tasksCompleted++;
+                    totalEarned += task.cost_usd || 0;
+                    log(`Task ${task.id.slice(0, 8)}... [${task.type}] completed in ${durationMs}ms (+$${(task.cost_usd || 0).toFixed(4)})`);
+                }
+                catch (inferErr) {
+                    const elapsed = Date.now() - taskStart;
+                    tasksFailed++;
+                    log(`Task ${task.id.slice(0, 8)}... failed after ${elapsed}ms: ${inferErr}`);
+                    await (0, api_js_1.completeTask)(config, task.id, "failed", {
+                        error: String(inferErr),
+                        duration_ms: elapsed,
+                    }, elapsed);
+                }
+                // Back to online
+                await (0, api_js_1.sendHeartbeat)(config, "online");
+            }
+        }
+        catch (pollErr) {
+            consecutivePollErrors++;
+            if (consecutivePollErrors >= 10) {
+                log(`Too many poll errors (${consecutivePollErrors}). Waiting 30s before retry.`);
+                await new Promise((r) => setTimeout(r, 30000));
+                consecutivePollErrors = 0;
+            }
+        }
+        // Wait before polling again
+        await new Promise((r) => setTimeout(r, config.pollIntervalMs));
+    }
+}
+main().catch((err) => {
+    console.error("Fatal error:", err);
+    process.exit(1);
+});

package/dist/inference.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Load a model into memory. Caches by model ID to avoid reloading.
+ * Evicts the oldest model if we already have 2 loaded (memory management).
+ */
+export declare function loadModel(modelPath: string, modelId: string): Promise<void>;
+/**
+ * Check if a model is loaded.
+ */
+export declare function isModelLoaded(modelId: string): boolean;
+/**
+ * Run inference with a specific loaded model.
+ */
+export declare function runInference(modelId: string, prompt: string, maxTokens?: number): Promise<{
+    text: string;
+    durationMs: number;
+    modelId: string;
+}>;
+/**
+ * Get list of currently loaded models.
+ */
+export declare function getLoadedModels(): string[];
+/**
+ * Unload all models (for shutdown).
+ */
+export declare function unloadAll(): void;

package/dist/inference.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadModel = loadModel;
+exports.isModelLoaded = isModelLoaded;
+exports.runInference = runInference;
+exports.getLoadedModels = getLoadedModels;
+exports.unloadAll = unloadAll;
+// Cache loaded models so we don't reload on every task
+const modelCache = new Map();
+let llamaInstance = null;
+async function getLlama() {
+    if (!llamaInstance) {
+        const { getLlama } = await import("node-llama-cpp");
+        llamaInstance = await getLlama();
+    }
+    return llamaInstance;
+}
+/**
+ * Load a model into memory. Caches by model ID to avoid reloading.
+ * Evicts the oldest model if we already have 2 loaded (memory management).
+ */
+async function loadModel(modelPath, modelId) {
+    if (modelCache.has(modelId)) {
+        return; // Already loaded
+    }
+    // Evict oldest if cache is full (keep max 2 models loaded)
+    if (modelCache.size >= 2) {
+        const oldest = modelCache.keys().next().value;
+        if (oldest) {
+            modelCache.delete(oldest);
+        }
+    }
+    const llama = await getLlama();
+    const model = await llama.loadModel({ modelPath });
+    const context = await model.createContext();
+    modelCache.set(modelId, { model, context });
+}
+/**
+ * Check if a model is loaded.
+ */
+function isModelLoaded(modelId) {
+    return modelCache.has(modelId);
+}
+/**
+ * Run inference with a specific loaded model.
+ */
+async function runInference(modelId, prompt, maxTokens = 256) {
+    const cached = modelCache.get(modelId);
+    if (!cached) {
+        throw new Error(`Model ${modelId} not loaded. Call loadModel() first.`);
+    }
+    const { LlamaChatSession } = await import("node-llama-cpp");
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    const session = new LlamaChatSession({
+        contextSequence: cached.context.getSequence(),
+    });
+    const start = Date.now();
+    const response = await session.prompt(prompt, { maxTokens });
+    const durationMs = Date.now() - start;
+    return { text: response, durationMs, modelId };
+}
+/**
+ * Get list of currently loaded models.
+ */
+function getLoadedModels() {
+    return Array.from(modelCache.keys());
+}
+/**
+ * Unload all models (for shutdown).
+ */
+function unloadAll() {
+    modelCache.clear();
+}

package/dist/models.d.ts

@@ -0,0 +1,29 @@
+export interface ModelSpec {
+    id: string;
+    name: string;
+    file: string;
+    url: string;
+    sizeMb: number;
+    minVramMb: number;
+    taskTypes: string[];
+    maxTokens: number;
+    priority: number;
+}
+export declare const MODEL_REGISTRY: ModelSpec[];
+/**
+ * Pick the best model for a given task type and available VRAM.
+ * Returns the highest-priority model the hardware can run.
+ */
+export declare function selectModel(taskType: string, vramMb: number): ModelSpec;
+/**
+ * Pick a specific model by ID, or the best available.
+ */
+export declare function getModelById(modelId: string): ModelSpec | undefined;
+/**
+ * List which models this hardware can run.
+ */
+export declare function listCompatibleModels(vramMb: number): ModelSpec[];
+/**
+ * Download a model if not already cached.
+ */
+export declare function ensureModelDownloaded(modelsDir: string, model: ModelSpec, onProgress?: (pct: number) => void): Promise<string>;

package/dist/models.js

@@ -0,0 +1,141 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODEL_REGISTRY = void 0;
+exports.selectModel = selectModel;
+exports.getModelById = getModelById;
+exports.listCompatibleModels = listCompatibleModels;
+exports.ensureModelDownloaded = ensureModelDownloaded;
+const fs_1 = require("fs");
+const path_1 = require("path");
+const https_1 = __importDefault(require("https"));
+const fs_2 = require("fs");
+exports.MODEL_REGISTRY = [
+    {
+        id: "tinyllama-1.1b",
+        name: "TinyLlama 1.1B Chat",
+        file: "tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf",
+        url: "https://huggingface.co/TheBloke/TinyLlama-1.1B-Chat-v1.0-GGUF/resolve/main/tinyllama-1.1b-chat-v1.0.Q4_K_M.gguf",
+        sizeMb: 669,
+        minVramMb: 0,
+        taskTypes: ["inference", "embedding"],
+        maxTokens: 2048,
+        priority: 1,
+    },
+    {
+        id: "phi-2",
+        name: "Phi-2 2.7B",
+        file: "phi-2.Q4_K_M.gguf",
+        url: "https://huggingface.co/TheBloke/phi-2-GGUF/resolve/main/phi-2.Q4_K_M.gguf",
+        sizeMb: 1740,
+        minVramMb: 2048,
+        taskTypes: ["inference", "embedding"],
+        maxTokens: 2048,
+        priority: 2,
+    },
+    {
+        id: "mistral-7b",
+        name: "Mistral 7B Instruct",
+        file: "mistral-7b-instruct-v0.2.Q4_K_M.gguf",
+        url: "https://huggingface.co/TheBloke/Mistral-7B-Instruct-v0.2-GGUF/resolve/main/mistral-7b-instruct-v0.2.Q4_K_M.gguf",
+        sizeMb: 4370,
+        minVramMb: 6144,
+        taskTypes: ["inference", "embedding"],
+        maxTokens: 8192,
+        priority: 3,
+    },
+    {
+        id: "llama3-8b",
+        name: "Llama 3 8B Instruct",
+        file: "Meta-Llama-3-8B-Instruct-Q4_K_M.gguf",
+        url: "https://huggingface.co/QuantFactory/Meta-Llama-3-8B-Instruct-GGUF/resolve/main/Meta-Llama-3-8B-Instruct.Q4_K_M.gguf",
+        sizeMb: 4920,
+        minVramMb: 8192,
+        taskTypes: ["inference", "embedding"],
+        maxTokens: 8192,
+        priority: 4,
+    },
+];
+/**
+ * Pick the best model for a given task type and available VRAM.
+ * Returns the highest-priority model the hardware can run.
+ */
+function selectModel(taskType, vramMb) {
+    const candidates = exports.MODEL_REGISTRY
+        .filter((m) => m.taskTypes.includes(taskType) && m.minVramMb <= vramMb)
+        .sort((a, b) => b.priority - a.priority);
+    if (candidates.length === 0) {
+        // Fall back to CPU-capable model
+        return exports.MODEL_REGISTRY[0];
+    }
+    return candidates[0];
+}
+/**
+ * Pick a specific model by ID, or the best available.
+ */
+function getModelById(modelId) {
+    return exports.MODEL_REGISTRY.find((m) => m.id === modelId);
+}
+/**
+ * List which models this hardware can run.
+ */
+function listCompatibleModels(vramMb) {
+    return exports.MODEL_REGISTRY
+        .filter((m) => m.minVramMb <= vramMb)
+        .sort((a, b) => b.priority - a.priority);
+}
+/**
+ * Download a model if not already cached.
+ */
+async function ensureModelDownloaded(modelsDir, model, onProgress) {
+    const modelPath = (0, path_1.join)(modelsDir, model.file);
+    if ((0, fs_1.existsSync)(modelPath)) {
+        return modelPath;
+    }
+    return new Promise((resolve, reject) => {
+        const download = (url, redirects = 0) => {
+            if (redirects > 5) {
+                reject(new Error("Too many redirects"));
+                return;
+            }
+            https_1.default.get(url, { headers: { "User-Agent": "neuronix-node/0.1.0" } }, (res) => {
+                if (res.statusCode === 301 || res.statusCode === 302) {
+                    const location = res.headers.location;
+                    if (location) {
+                        download(location, redirects + 1);
+                        return;
+                    }
+                }
+                if (res.statusCode !== 200) {
+                    reject(new Error(`Download failed: HTTP ${res.statusCode}`));
+                    return;
+                }
+                const total = parseInt(res.headers["content-length"] || "0", 10);
+                let downloaded = 0;
+                const file = (0, fs_2.createWriteStream)(modelPath);
+                res.on("data", (chunk) => {
+                    downloaded += chunk.length;
+                    if (total > 0 && onProgress) {
+                        onProgress(Math.round((downloaded / total) * 100));
+                    }
+                });
+                res.pipe(file);
+                file.on("finish", () => {
+                    file.close();
+                    resolve(modelPath);
+                });
+                file.on("error", (err) => {
+                    // Clean up partial download
+                    try {
+                        require("fs").unlinkSync(modelPath);
+                    }
+                    catch { }
+                    reject(err);
+                });
+            }).on("error", reject);
+        };
+        download(model.url);
+    });
+}

package/dist/parsers/csv.d.ts

@@ -0,0 +1,24 @@
+/**
+ * CSV Parser — extracts structured data from CSV content.
+ * Detects column types, calculates summaries, identifies patterns.
+ */
+export interface CSVData {
+    headers: string[];
+    rows: string[][];
+    rowCount: number;
+    columnTypes: Record<string, "number" | "date" | "text" | "currency">;
+    summary: {
+        numericColumns: {
+            name: string;
+            sum: number;
+            avg: number;
+            min: number;
+            max: number;
+        }[];
+        dateRange: {
+            min: string;
+            max: string;
+        } | null;
+    };
+}
+export declare function parseCSV(content: string): CSVData;

package/dist/parsers/csv.js

@@ -0,0 +1,94 @@
+"use strict";
+/**
+ * CSV Parser — extracts structured data from CSV content.
+ * Detects column types, calculates summaries, identifies patterns.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseCSV = parseCSV;
+function parseCSV(content) {
+    const lines = content.trim().split(/\r?\n/);
+    if (lines.length < 2) {
+        return { headers: [], rows: [], rowCount: 0, columnTypes: {}, summary: { numericColumns: [], dateRange: null } };
+    }
+    const headers = parseLine(lines[0]);
+    const rows = lines.slice(1).map(parseLine);
+    // Detect column types
+    const columnTypes = {};
+    for (let col = 0; col < headers.length; col++) {
+        const values = rows.map((r) => r[col] || "").filter((v) => v.length > 0);
+        columnTypes[headers[col]] = detectColumnType(values);
+    }
+    // Calculate numeric summaries
+    const numericColumns = [];
+    for (let col = 0; col < headers.length; col++) {
+        const type = columnTypes[headers[col]];
+        if (type === "number" || type === "currency") {
+            const nums = rows
+                .map((r) => parseFloat((r[col] || "").replace(/[$,]/g, "")))
+                .filter((n) => !isNaN(n));
+            if (nums.length > 0) {
+                numericColumns.push({
+                    name: headers[col],
+                    sum: round(nums.reduce((a, b) => a + b, 0)),
+                    avg: round(nums.reduce((a, b) => a + b, 0) / nums.length),
+                    min: round(Math.min(...nums)),
+                    max: round(Math.max(...nums)),
+                });
+            }
+        }
+    }
+    // Detect date range
+    let dateRange = null;
+    for (let col = 0; col < headers.length; col++) {
+        if (columnTypes[headers[col]] === "date") {
+            const dates = rows
+                .map((r) => r[col] || "")
+                .filter((v) => v.length > 0)
+                .sort();
+            if (dates.length > 0) {
+                dateRange = { min: dates[0], max: dates[dates.length - 1] };
+            }
+            break;
+        }
+    }
+    return { headers, rows, rowCount: rows.length, columnTypes, summary: { numericColumns, dateRange } };
+}
+function parseLine(line) {
+    const result = [];
+    let current = "";
+    let inQuotes = false;
+    for (let i = 0; i < line.length; i++) {
+        const ch = line[i];
+        if (ch === '"') {
+            inQuotes = !inQuotes;
+        }
+        else if (ch === "," && !inQuotes) {
+            result.push(current.trim());
+            current = "";
+        }
+        else {
+            current += ch;
+        }
+    }
+    result.push(current.trim());
+    return result;
+}
+function detectColumnType(values) {
+    const sample = values.slice(0, 20);
+    // Currency: starts with $ or has $ in it
+    if (sample.filter((v) => /^\$[\d,.]+$/.test(v) || /^-?\$[\d,.]+$/.test(v)).length > sample.length * 0.7) {
+        return "currency";
+    }
+    // Number
+    if (sample.filter((v) => /^-?[\d,.]+$/.test(v.replace(/[$,]/g, ""))).length > sample.length * 0.7) {
+        return "number";
+    }
+    // Date
+    if (sample.filter((v) => /\d{4}[-/]\d{1,2}[-/]\d{1,2}/.test(v) || /\d{1,2}[-/]\d{1,2}[-/]\d{2,4}/.test(v)).length > sample.length * 0.7) {
+        return "date";
+    }
+    return "text";
+}
+function round(n) {
+    return Math.round(n * 100) / 100;
+}

package/dist/parsers/index.d.ts

@@ -0,0 +1,17 @@
+/**
+ * File parser registry.
+ * Detects file type and extracts structured data.
+ */
+import { parseCSV, type CSVData } from "./csv.js";
+export interface ParsedFile {
+    type: string;
+    fileName: string;
+    data: CSVData | Record<string, unknown>;
+    suggestedActions: string[];
+}
+/**
+ * Parse file content based on its type.
+ * Returns structured data + suggested actions the bot can take.
+ */
+export declare function parseFile(fileName: string, fileType: string, content: string | Buffer): ParsedFile;
+export { parseCSV, type CSVData };