neuronix-node 0.1.0

package/README.md

@@ -0,0 +1,60 @@
+# Neuronix Node
+
+Earn money by contributing your GPU to the Neuronix decentralized compute network.
+
+## Quick Start
+
+```bash
+npx neuronix-node
+```
+
+That's it. The node will:
+1. Detect your hardware (GPU, CPU, RAM)
+2. Prompt you to log in with your Neuronix account
+3. Download the best AI model for your hardware
+4. Connect to the network and start earning
+
+## Requirements
+
+- **Node.js 18+** — [Download here](https://nodejs.org)
+- **8 GB RAM** minimum (16 GB recommended)
+- **5 GB free disk space** for AI models
+- **GPU optional** — runs in CPU mode without one, but earns more with a GPU
+
+## Supported GPUs
+
+| GPU | VRAM | Model Used | Earnings Tier |
+|-----|------|-----------|---------------|
+| No GPU (CPU) | — | TinyLlama 1.1B | Basic |
+| GTX 1060 / RX 580 | 2-4 GB | Phi-2 2.7B | Mid |
+| RTX 3060 / RX 6700 | 6 GB | Mistral 7B | High |
+| RTX 4070+ / RX 7900 | 8+ GB | Llama 3 8B | Premium |
+
+## Environment Variables
+
+Skip the interactive login by setting:
+
+```bash
+export NEURONIX_EMAIL="you@company.com"
+export NEURONIX_PASSWORD="your-password"
+npx neuronix-node
+```
+
+## Global Install
+
+```bash
+npm install -g neuronix-node
+neuronix-node
+```
+
+## Configuration
+
+Config is stored at `~/.neuronix/config.json`. Models are cached at `~/.neuronix/models/`.
+
+## Sign Up
+
+Create a free account at [neuronix-nu.vercel.app/signup](https://neuronix-nu.vercel.app/signup)
+
+## License
+
+MIT

package/dist/api.d.ts

@@ -0,0 +1,31 @@
+import type { NodeConfig } from "./config.js";
+import type { HardwareInfo } from "./hardware.js";
+interface RegisterResponse {
+    success: boolean;
+    node: {
+        id: string;
+        node_key: string;
+        status: string;
+    };
+}
+interface PollResponse {
+    task: {
+        id: string;
+        type: string;
+        model: string;
+        input_payload: Record<string, unknown>;
+        cost_usd: number;
+        timeout_seconds: number;
+    } | null;
+    message?: string;
+}
+interface LoginResponse {
+    access_token: string;
+    user_id: string;
+}
+export declare function loginProvider(config: NodeConfig, email: string, password: string): Promise<LoginResponse>;
+export declare function registerNode(config: NodeConfig, hw: HardwareInfo): Promise<RegisterResponse>;
+export declare function sendHeartbeat(config: NodeConfig, status?: string): Promise<void>;
+export declare function pollTask(config: NodeConfig): Promise<PollResponse>;
+export declare function completeTask(config: NodeConfig, taskId: string, status: "completed" | "failed", outputPayload: Record<string, unknown>, durationMs: number): Promise<void>;
+export {};

package/dist/api.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loginProvider = loginProvider;
+exports.registerNode = registerNode;
+exports.sendHeartbeat = sendHeartbeat;
+exports.pollTask = pollTask;
+exports.completeTask = completeTask;
+async function apiCall(config, path, body) {
+    const headers = { "Content-Type": "application/json" };
+    if (config.authToken) {
+        headers["Authorization"] = `Bearer ${config.authToken}`;
+    }
+    const res = await fetch(`${config.apiUrl}/api/node${path}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+async function loginProvider(config, email, password) {
+    const res = await fetch(`${config.apiUrl}/api/node/auth`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ email, password }),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`Login failed: ${text}`);
+    }
+    return res.json();
+}
+async function registerNode(config, hw) {
+    return apiCall(config, "/register", {
+        node_key: config.nodeKey,
+        user_id: config.userId || undefined,
+        hostname: hw.hostname,
+        os: hw.os,
+        gpu_model: hw.gpuModel,
+        gpu_vram_mb: hw.gpuVramMb,
+        cpu_model: hw.cpuModel,
+        ram_mb: hw.ramMb,
+        version: "0.1.0",
+    });
+}
+async function sendHeartbeat(config, status = "online") {
+    await apiCall(config, "/heartbeat", {
+        node_key: config.nodeKey,
+        status,
+    });
+}
+async function pollTask(config) {
+    return apiCall(config, "/poll", {
+        node_id: config.nodeId,
+    });
+}
+async function completeTask(config, taskId, status, outputPayload, durationMs) {
+    await apiCall(config, "/complete", {
+        task_id: taskId,
+        node_id: config.nodeId,
+        status,
+        output_payload: outputPayload,
+        duration_ms: durationMs,
+    });
+}

package/dist/config.d.ts

@@ -0,0 +1,15 @@
+declare const CONFIG_DIR: string;
+declare const MODELS_DIR: string;
+export interface NodeConfig {
+    nodeKey: string;
+    nodeId: string | null;
+    userId: string | null;
+    authToken: string | null;
+    apiUrl: string;
+    modelsDir: string;
+    pollIntervalMs: number;
+    heartbeatIntervalMs: number;
+}
+export declare function loadConfig(): NodeConfig;
+export declare function saveConfig(config: NodeConfig): void;
+export { CONFIG_DIR, MODELS_DIR };

package/dist/config.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MODELS_DIR = exports.CONFIG_DIR = void 0;
+exports.loadConfig = loadConfig;
+exports.saveConfig = saveConfig;
+const crypto_1 = require("crypto");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const os_1 = require("os");
+const CONFIG_DIR = (0, path_1.join)((0, os_1.homedir)(), ".neuronix");
+exports.CONFIG_DIR = CONFIG_DIR;
+const CONFIG_FILE = (0, path_1.join)(CONFIG_DIR, "config.json");
+const MODELS_DIR = (0, path_1.join)(CONFIG_DIR, "models");
+exports.MODELS_DIR = MODELS_DIR;
+const DEFAULT_CONFIG = {
+    nodeKey: "",
+    nodeId: null,
+    userId: null,
+    authToken: null,
+    apiUrl: "https://neuronix-nu.vercel.app",
+    modelsDir: MODELS_DIR,
+    pollIntervalMs: 5000,
+    heartbeatIntervalMs: 30000,
+};
+function loadConfig() {
+    if (!(0, fs_1.existsSync)(CONFIG_DIR)) {
+        (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    }
+    if (!(0, fs_1.existsSync)(MODELS_DIR)) {
+        (0, fs_1.mkdirSync)(MODELS_DIR, { recursive: true });
+    }
+    if ((0, fs_1.existsSync)(CONFIG_FILE)) {
+        const raw = (0, fs_1.readFileSync)(CONFIG_FILE, "utf-8");
+        return { ...DEFAULT_CONFIG, ...JSON.parse(raw) };
+    }
+    const config = {
+        ...DEFAULT_CONFIG,
+        nodeKey: `node_${(0, crypto_1.randomUUID)().replace(/-/g, "").slice(0, 16)}`,
+    };
+    saveConfig(config);
+    return config;
+}
+function saveConfig(config) {
+    if (!(0, fs_1.existsSync)(CONFIG_DIR)) {
+        (0, fs_1.mkdirSync)(CONFIG_DIR, { recursive: true });
+    }
+    (0, fs_1.writeFileSync)(CONFIG_FILE, JSON.stringify(config, null, 2));
+}

package/dist/handlers/chart.d.ts

@@ -0,0 +1,2 @@
+import type { TaskInput, TaskOutput } from "./index.js";
+export declare function handleChart(task: TaskInput): Promise<TaskOutput>;

package/dist/handlers/chart.js

@@ -0,0 +1,121 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleChart = handleChart;
+const DEFAULT_COLORS = [
+    "#0066FF", "#10b981", "#f59e0b", "#8b5cf6", "#ec4899",
+    "#06b6d4", "#84cc16", "#f97316", "#6366f1", "#14b8a6",
+];
+/**
+ * Parse a natural language prompt into chart parameters.
+ * Extracts numbers, chart type hints, and uses the prompt as the title.
+ */
+function parsePrompt(prompt) {
+    const lower = prompt.toLowerCase();
+    const result = {};
+    // Detect chart type from prompt
+    if (/pie/.test(lower))
+        result.chart_type = "pie";
+    else if (/doughnut|donut/.test(lower))
+        result.chart_type = "doughnut";
+    else if (/line/.test(lower))
+        result.chart_type = "line";
+    else
+        result.chart_type = "bar";
+    // Extract numbers from prompt
+    const numbers = prompt.match(/\d+(?:\.\d+)?/g);
+    if (numbers && numbers.length > 0) {
+        const data = numbers.map(Number);
+        result.datasets = [{ label: "Values", data }];
+        // Generate labels (Day 1, Day 2... or Item 1, Item 2...)
+        const labelPrefix = /daily|day/i.test(lower) ? "Day" :
+            /month/i.test(lower) ? "Month" :
+                /week/i.test(lower) ? "Week" :
+                    /quarter|q[1-4]/i.test(lower) ? "Q" : "Item";
+        result.labels = data.map((_, i) => `${labelPrefix} ${i + 1}`);
+    }
+    // Use prompt as title (clean it up)
+    result.title = prompt.replace(/^(make|create|generate|show|draw)\s+(me\s+)?(a\s+)?/i, "").slice(0, 80);
+    return result;
+}
+async function handleChart(task) {
+    const start = Date.now();
+    const raw = task.input_payload;
+    // If there's a prompt, parse it for chart parameters
+    const parsed = raw.prompt ? parsePrompt(raw.prompt) : {};
+    const input = { ...parsed, ...raw }; // explicit params override parsed ones
+    // But keep parsed values if raw doesn't have them
+    if (!raw.chart_type && parsed.chart_type)
+        input.chart_type = parsed.chart_type;
+    if (!raw.labels && parsed.labels)
+        input.labels = parsed.labels;
+    if (!raw.datasets && parsed.datasets)
+        input.datasets = parsed.datasets;
+    if (!raw.title && parsed.title)
+        input.title = parsed.title;
+    const chartType = input.chart_type || "bar";
+    const title = input.title || "Chart";
+    const labels = input.labels || ["Jan", "Feb", "Mar", "Apr", "May", "Jun"];
+    const width = input.width || 800;
+    const height = input.height || 400;
+    // Default dataset if none provided
+    const datasets = input.datasets || [{
+            label: "Data",
+            data: [12, 19, 3, 5, 2, 3],
+        }];
+    // Assign colors if not provided
+    const coloredDatasets = datasets.map((ds, i) => ({
+        ...ds,
+        backgroundColor: ds.backgroundColor || (chartType === "pie" || chartType === "doughnut"
+            ? DEFAULT_COLORS.slice(0, labels.length)
+            : DEFAULT_COLORS[i % DEFAULT_COLORS.length]),
+        borderColor: ds.borderColor || (chartType === "line" ? DEFAULT_COLORS[i % DEFAULT_COLORS.length] : undefined),
+        borderWidth: chartType === "line" ? 2 : 1,
+        fill: chartType === "line" ? false : undefined,
+    }));
+    // Dynamic import for chartjs-node-canvas (ESM)
+    const { ChartJSNodeCanvas } = await import("chartjs-node-canvas");
+    const chartCanvas = new ChartJSNodeCanvas({ width, height, backgroundColour: "#0a0a0f" });
+    const config = {
+        type: chartType,
+        data: {
+            labels,
+            datasets: coloredDatasets,
+        },
+        options: {
+            responsive: false,
+            plugins: {
+                title: {
+                    display: true,
+                    text: title,
+                    color: "#ffffff",
+                    font: { size: 16, weight: "bold" },
+                },
+                legend: {
+                    labels: { color: "#9ca3af" },
+                },
+            },
+            scales: chartType === "pie" || chartType === "doughnut" ? {} : {
+                x: {
+                    ticks: { color: "#6b7280" },
+                    grid: { color: "rgba(255,255,255,0.06)" },
+                },
+                y: {
+                    ticks: { color: "#6b7280" },
+                    grid: { color: "rgba(255,255,255,0.06)" },
+                },
+            },
+        },
+    };
+    const imageBuffer = await chartCanvas.renderToBuffer(config);
+    const base64 = imageBuffer.toString("base64");
+    const durationMs = Date.now() - start;
+    return {
+        image_base64: base64,
+        image_format: "png",
+        chart_type: chartType,
+        title,
+        width,
+        height,
+        duration_ms: durationMs,
+    };
+}

package/dist/handlers/expense.d.ts

@@ -0,0 +1,2 @@
+import type { TaskInput, TaskOutput } from "./index.js";
+export declare function handleExpenseReport(task: TaskInput): Promise<TaskOutput>;

package/dist/handlers/expense.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleExpenseReport = handleExpenseReport;
+async function handleExpenseReport(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.period || "Current Period";
+    const expenses = input.expenses || [
+        { description: "Office Supplies", amount: 245.50, category: "Operations", date: "2026-03-01" },
+        { description: "Software Subscriptions", amount: 890.00, category: "Technology", date: "2026-03-05" },
+        { description: "Team Lunch", amount: 156.75, category: "Meals", date: "2026-03-08" },
+        { description: "Cloud Hosting", amount: 432.00, category: "Technology", date: "2026-03-10" },
+        { description: "Marketing Ads", amount: 1200.00, category: "Marketing", date: "2026-03-12" },
+        { description: "Travel - Client Meeting", amount: 387.25, category: "Travel", date: "2026-03-15" },
+        { description: "Printer Ink", amount: 89.99, category: "Operations", date: "2026-03-18" },
+        { description: "Conference Tickets", amount: 599.00, category: "Education", date: "2026-03-20" },
+    ];
+    // Calculate totals by category
+    const byCategory = {};
+    let total = 0;
+    for (const exp of expenses) {
+        total += exp.amount;
+        if (!byCategory[exp.category]) {
+            byCategory[exp.category] = { total: 0, count: 0, items: [] };
+        }
+        byCategory[exp.category].total += exp.amount;
+        byCategory[exp.category].count += 1;
+        byCategory[exp.category].items.push(exp);
+    }
+    // Round totals
+    total = Math.round(total * 100) / 100;
+    for (const cat of Object.keys(byCategory)) {
+        byCategory[cat].total = Math.round(byCategory[cat].total * 100) / 100;
+    }
+    // Sort categories by total descending
+    const sortedCategories = Object.entries(byCategory)
+        .sort((a, b) => b[1].total - a[1].total)
+        .map(([name, data]) => ({
+        category: name,
+        total: data.total,
+        count: data.count,
+        percentage: Math.round((data.total / total) * 1000) / 10,
+    }));
+    // Generate chart data for the frontend
+    const chartData = {
+        chart_type: "doughnut",
+        title: `Expenses by Category — ${period}`,
+        labels: sortedCategories.map((c) => c.category),
+        datasets: [{
+                label: "Expenses",
+                data: sortedCategories.map((c) => c.total),
+            }],
+    };
+    // Summary text
+    const summaryLines = [
+        `Expense Report: ${period}`,
+        `Total: $${total.toFixed(2)} across ${expenses.length} expenses`,
+        ``,
+        `By Category:`,
+        ...sortedCategories.map((c) => `  ${c.category}: $${c.total.toFixed(2)} (${c.percentage}%) — ${c.count} item${c.count > 1 ? "s" : ""}`),
+        ``,
+        `Largest expense: ${expenses.sort((a, b) => b.amount - a.amount)[0].description} ($${expenses.sort((a, b) => b.amount - a.amount)[0].amount.toFixed(2)})`,
+    ];
+    // Generate CSV output
+    const csvLines = [
+        "EXPENSE REPORT",
+        `Period,${period}`,
+        "",
+        "EXPENSES BY ITEM",
+        "Date,Description,Amount,Category",
+        ...expenses.map((e) => `${e.date || ""},${csvEscape(e.description)},$${e.amount.toFixed(2)},${csvEscape(e.category)}`),
+        "",
+        "SUMMARY BY CATEGORY",
+        "Category,Total,% of Total,Item Count",
+        ...sortedCategories.map((c) => `${csvEscape(c.category)},$${c.total.toFixed(2)},${c.percentage}%,${c.count}`),
+        "",
+        `TOTAL,,$${total.toFixed(2)},${expenses.length} items`,
+    ];
+    const durationMs = Date.now() - start;
+    return {
+        text: summaryLines.join("\n"),
+        output_csv: csvLines.join("\n"),
+        summary: {
+            period,
+            total,
+            expense_count: expenses.length,
+            category_count: sortedCategories.length,
+            largest_category: sortedCategories[0]?.category,
+            largest_expense: expenses.sort((a, b) => b.amount - a.amount)[0],
+        },
+        by_category: sortedCategories,
+        expenses,
+        chart_data: chartData,
+        duration_ms: durationMs,
+    };
+}
+function csvEscape(value) {
+    if (value.includes(",") || value.includes('"') || value.includes("\n")) {
+        return `"${value.replace(/"/g, '""')}"`;
+    }
+    return value;
+}

package/dist/handlers/file-processor.d.ts

@@ -0,0 +1,7 @@
+import type { TaskInput, TaskOutput } from "./index.js";
+/**
+ * File processor handler.
+ * Receives a file's content, parses it, determines what to do,
+ * then routes to the appropriate specialized handler.
+ */
+export declare function handleFileProcess(task: TaskInput): Promise<TaskOutput>;

package/dist/handlers/file-processor.js

@@ -0,0 +1,168 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFileProcess = handleFileProcess;
+const index_js_1 = require("../parsers/index.js");
+const chart_js_1 = require("./chart.js");
+const expense_js_1 = require("./expense.js");
+const pnl_js_1 = require("./pnl.js");
+const invoice_js_1 = require("./invoice.js");
+/**
+ * File processor handler.
+ * Receives a file's content, parses it, determines what to do,
+ * then routes to the appropriate specialized handler.
+ */
+async function handleFileProcess(task) {
+    const start = Date.now();
+    const payload = task.input_payload;
+    const fileName = payload.file_name || "unknown";
+    const fileType = payload.file_type || "unknown";
+    const content = payload.file_content || "";
+    // Parse the file
+    const parsed = (0, index_js_1.parseFile)(fileName, fileType, content);
+    // If there are suggested actions, auto-execute the best one
+    if (parsed.suggestedActions.length > 0) {
+        const bestAction = parsed.suggestedActions[0];
+        // Build input from parsed data
+        if (bestAction === "expense_report" && parsed.type === "csv") {
+            const csvData = parsed.data;
+            const expenses = csvToExpenses(csvData);
+            if (expenses.length > 0) {
+                const result = await (0, expense_js_1.handleExpenseReport)({
+                    type: "expense_report",
+                    input_payload: { expenses },
+                });
+                return {
+                    ...result,
+                    parsed_file: { type: parsed.type, rows: csvData.rowCount, columns: csvData.headers.length },
+                    auto_action: bestAction,
+                    duration_ms: Date.now() - start,
+                };
+            }
+        }
+        if (bestAction === "chart" && parsed.type === "csv") {
+            const csvData = parsed.data;
+            const chartInput = csvToChart(csvData, fileName);
+            if (chartInput) {
+                const result = await (0, chart_js_1.handleChart)({
+                    type: "chart",
+                    input_payload: chartInput,
+                });
+                return {
+                    ...result,
+                    parsed_file: { type: parsed.type, rows: csvData.rowCount, columns: csvData.headers.length },
+                    auto_action: bestAction,
+                    duration_ms: Date.now() - start,
+                };
+            }
+        }
+        if (bestAction === "pnl" && parsed.type === "csv") {
+            const csvData = parsed.data;
+            const pnlInput = csvToPnl(csvData);
+            if (pnlInput) {
+                const result = await (0, pnl_js_1.handlePnl)({
+                    type: "pnl",
+                    input_payload: pnlInput,
+                });
+                return {
+                    ...result,
+                    parsed_file: { type: parsed.type, rows: csvData.rowCount, columns: csvData.headers.length },
+                    auto_action: bestAction,
+                    duration_ms: Date.now() - start,
+                };
+            }
+        }
+        if (bestAction === "invoice") {
+            const result = await (0, invoice_js_1.handleInvoice)({
+                type: "invoice",
+                input_payload: {},
+            });
+            return {
+                ...result,
+                parsed_file: { type: parsed.type },
+                auto_action: bestAction,
+                duration_ms: Date.now() - start,
+            };
+        }
+    }
+    // Default: return parsed summary
+    const durationMs = Date.now() - start;
+    return {
+        text: `Parsed "${fileName}" (${fileType}).\n\n${JSON.stringify(parsed.data, null, 2)}`,
+        parsed_file: parsed,
+        suggested_actions: parsed.suggestedActions,
+        duration_ms: durationMs,
+    };
+}
+/**
+ * Convert CSV data into expense objects for the expense handler.
+ */
+function csvToExpenses(csv) {
+    const headersLower = csv.headers.map((h) => h.toLowerCase());
+    // Find relevant columns
+    const descCol = headersLower.findIndex((h) => /description|name|item|memo/.test(h));
+    const amountCol = headersLower.findIndex((h) => /amount|cost|price|total|debit/.test(h));
+    const categoryCol = headersLower.findIndex((h) => /category|type|class|department/.test(h));
+    const dateCol = headersLower.findIndex((h) => /date/.test(h));
+    if (amountCol === -1)
+        return [];
+    return csv.rows.map((row) => ({
+        description: descCol >= 0 ? row[descCol] : "Item",
+        amount: parseFloat((row[amountCol] || "0").replace(/[$,]/g, "")) || 0,
+        category: categoryCol >= 0 ? row[categoryCol] : "Uncategorized",
+        date: dateCol >= 0 ? row[dateCol] : undefined,
+    })).filter((e) => e.amount > 0);
+}
+/**
+ * Convert CSV data into chart parameters.
+ */
+function csvToChart(csv, fileName) {
+    if (csv.summary.numericColumns.length === 0)
+        return null;
+    const headersLower = csv.headers.map((h) => h.toLowerCase());
+    const labelCol = headersLower.findIndex((h) => /name|description|category|date|month|item|label/.test(h));
+    const numCol = csv.headers.findIndex((h) => csv.columnTypes[h] === "number" || csv.columnTypes[h] === "currency");
+    if (numCol === -1)
+        return null;
+    const labels = labelCol >= 0
+        ? csv.rows.map((r) => r[labelCol]).slice(0, 20)
+        : csv.rows.map((_, i) => `Row ${i + 1}`).slice(0, 20);
+    const data = csv.rows
+        .map((r) => parseFloat((r[numCol] || "0").replace(/[$,]/g, "")))
+        .filter((n) => !isNaN(n))
+        .slice(0, 20);
+    return {
+        chart_type: data.length > 8 ? "line" : "bar",
+        title: fileName.replace(/\.[^.]+$/, "").replace(/[_-]/g, " "),
+        labels,
+        datasets: [{ label: csv.headers[numCol], data }],
+    };
+}
+/**
+ * Convert CSV data into P&L parameters.
+ */
+function csvToPnl(csv) {
+    const headersLower = csv.headers.map((h) => h.toLowerCase());
+    const descCol = headersLower.findIndex((h) => /description|name|item/.test(h));
+    const amountCol = headersLower.findIndex((h) => /amount|total/.test(h));
+    const typeCol = headersLower.findIndex((h) => /type|category/.test(h));
+    if (amountCol === -1)
+        return null;
+    const revenue = [];
+    const expenses = [];
+    for (const row of csv.rows) {
+        const desc = descCol >= 0 ? row[descCol] : "Item";
+        const amount = Math.abs(parseFloat((row[amountCol] || "0").replace(/[$,]/g, "")));
+        const type = typeCol >= 0 ? row[typeCol].toLowerCase() : "";
+        if (amount === 0)
+            continue;
+        if (/revenue|income|sale/i.test(type) || /revenue|income|sale/i.test(desc)) {
+            revenue.push({ description: desc, amount });
+        }
+        else {
+            expenses.push({ description: desc, amount, category: type || "General" });
+        }
+    }
+    if (revenue.length === 0 && expenses.length === 0)
+        return null;
+    return { revenue, expenses };
+}

package/dist/handlers/index.d.ts

@@ -0,0 +1,20 @@
+export interface TaskInput {
+    type: string;
+    input_payload: Record<string, unknown>;
+    model?: string;
+}
+export interface TaskOutput {
+    [key: string]: unknown;
+    duration_ms: number;
+}
+export type TaskHandler = (input: TaskInput) => Promise<TaskOutput>;
+declare const handlers: Record<string, TaskHandler>;
+/**
+ * Check if we have a specialized handler for this task type.
+ */
+export declare function hasHandler(type: string): boolean;
+/**
+ * Run the specialized handler for a task type.
+ */
+export declare function runHandler(task: TaskInput): Promise<TaskOutput>;
+export { handlers };