neuronix-node 0.2.0 → 0.6.0

package/dist/handlers/payroll.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handlePayroll = handlePayroll;
+async function handlePayroll(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.pay_period || "Bi-Weekly";
+    const fedRate = input.federal_tax_rate || 0.22;
+    const stateRate = input.state_tax_rate || 0.05;
+    const ficaRate = input.fica_rate || 0.062;
+    const medicareRate = input.medicare_rate || 0.0145;
+    const periodsPerYear = period === "Weekly" ? 52 : period === "Bi-Weekly" ? 26 : period === "Semi-Monthly" ? 24 : 12;
+    const employees = input.employees || [
+        { name: "John Smith", type: "salary", rate: 85000, deductions: [{ name: "Health Insurance", amount: 250 }, { name: "401k (6%)", amount: 196.15 }] },
+        { name: "Jane Doe", type: "salary", rate: 72000, deductions: [{ name: "Health Insurance", amount: 250 }, { name: "401k (4%)", amount: 110.77 }] },
+        { name: "Bob Wilson", type: "hourly", rate: 28.50, hours: 80, deductions: [{ name: "Health Insurance", amount: 180 }] },
+        { name: "Alice Chen", type: "salary", rate: 95000, deductions: [{ name: "Health Insurance", amount: 250 }, { name: "401k (8%)", amount: 292.31 }, { name: "HSA", amount: 100 }] },
+        { name: "Mike Torres", type: "hourly", rate: 22.00, hours: 84, deductions: [{ name: "Health Insurance", amount: 180 }] },
+    ];
+    let totalGross = 0, totalFed = 0, totalState = 0, totalFica = 0, totalMedicare = 0, totalDeductions = 0, totalNet = 0, totalEmployerFica = 0, totalEmployerMedicare = 0;
+    const payStubs = employees.map(emp => {
+        const gross = emp.type === "salary" ? round(emp.rate / periodsPerYear) : round((emp.rate) * (emp.hours || 80));
+        const overtimeHours = emp.type === "hourly" && (emp.hours || 0) > 80 ? (emp.hours || 0) - 80 : 0;
+        const overtimePay = emp.type === "hourly" ? round(overtimeHours * emp.rate * 0.5) : 0;
+        const totalGrossPay = round(gross + overtimePay);
+        const fedTax = round(totalGrossPay * fedRate);
+        const stateTax = round(totalGrossPay * stateRate);
+        const ficaTax = round(totalGrossPay * ficaRate);
+        const medicareTax = round(totalGrossPay * medicareRate);
+        const totalTax = round(fedTax + stateTax + ficaTax + medicareTax);
+        const deductionTotal = round((emp.deductions || []).reduce((s, d) => s + d.amount, 0));
+        const netPay = round(totalGrossPay - totalTax - deductionTotal);
+        const employerFica = ficaTax;
+        const employerMedicare = medicareTax;
+        totalGross += totalGrossPay;
+        totalFed += fedTax;
+        totalState += stateTax;
+        totalFica += ficaTax;
+        totalMedicare += medicareTax;
+        totalDeductions += deductionTotal;
+        totalNet += netPay;
+        totalEmployerFica += employerFica;
+        totalEmployerMedicare += employerMedicare;
+        return {
+            name: emp.name, type: emp.type, hours: emp.hours, rate: emp.rate,
+            gross: totalGrossPay, overtime_pay: overtimePay,
+            federal_tax: fedTax, state_tax: stateTax, fica: ficaTax, medicare: medicareTax,
+            total_tax: totalTax, deductions: emp.deductions || [], deduction_total: deductionTotal,
+            net_pay: netPay, employer_fica: employerFica, employer_medicare: employerMedicare,
+        };
+    });
+    totalGross = round(totalGross);
+    totalNet = round(totalNet);
+    totalDeductions = round(totalDeductions);
+    const totalTaxes = round(totalFed + totalState + totalFica + totalMedicare);
+    const totalEmployerCost = round(totalGross + totalEmployerFica + totalEmployerMedicare);
+    const csv = [
+        "PAYROLL REGISTER",
+        `Pay Period: ${period}`,
+        `Date: ${new Date().toISOString().split("T")[0]}`,
+        `Employees: ${employees.length}`,
+        "",
+        "EMPLOYEE DETAIL",
+        "Name,Type,Rate,Hours,Gross Pay,Federal Tax,State Tax,FICA,Medicare,Deductions,Net Pay",
+        ...payStubs.map(p => `${esc(p.name)},${p.type},${p.type === "salary" ? fmt(p.rate) + "/yr" : fmt(p.rate) + "/hr"},${p.hours || "N/A"},${fmt(p.gross)},${fmt(p.federal_tax)},${fmt(p.state_tax)},${fmt(p.fica)},${fmt(p.medicare)},${fmt(p.deduction_total)},${fmt(p.net_pay)}`),
+        "",
+        `TOTALS,,,,${fmt(totalGross)},${fmt(totalFed)},${fmt(round(totalState))},${fmt(round(totalFica))},${fmt(round(totalMedicare))},${fmt(totalDeductions)},${fmt(totalNet)}`,
+        "",
+        "DEDUCTION DETAIL",
+        "Employee,Deduction,Amount",
+        ...payStubs.flatMap(p => p.deductions.map(d => `${esc(p.name)},${esc(d.name)},${fmt(d.amount)}`)),
+        "",
+        "TAX SUMMARY",
+        `Federal Income Tax,${fmt(round(totalFed))}`,
+        `State Income Tax,${fmt(round(totalState))}`,
+        `Employee FICA (Social Security),${fmt(round(totalFica))}`,
+        `Employee Medicare,${fmt(round(totalMedicare))}`,
+        `Total Employee Taxes,${fmt(totalTaxes)}`,
+        "",
+        "EMPLOYER OBLIGATIONS",
+        `Employer FICA Match,${fmt(round(totalEmployerFica))}`,
+        `Employer Medicare Match,${fmt(round(totalEmployerMedicare))}`,
+        `Total Employer Taxes,${fmt(round(totalEmployerFica + totalEmployerMedicare))}`,
+        "",
+        "GRAND TOTALS",
+        `Total Gross Pay,${fmt(totalGross)}`,
+        `Total Deductions,${fmt(totalDeductions)}`,
+        `Total Taxes (Employee),${fmt(totalTaxes)}`,
+        `Total Net Pay,${fmt(totalNet)}`,
+        `Total Employer Cost,${fmt(totalEmployerCost)}`,
+    ];
+    return {
+        text: `Payroll: ${employees.length} employees | Gross: ${fmt(totalGross)} | Net: ${fmt(totalNet)} | Employer Cost: ${fmt(totalEmployerCost)}`,
+        output_csv: csv.join("\n"),
+        summary: { employee_count: employees.length, total_gross: totalGross, total_net: totalNet, total_taxes: totalTaxes, total_deductions: totalDeductions, employer_cost: totalEmployerCost },
+        duration_ms: Date.now() - start,
+    };
+}
+function round(n) { return Math.round(n * 100) / 100; }
+function fmt(n) { return "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }); }
+function esc(v) { return v.includes(",") ? `"${v}"` : v; }

package/dist/handlers/sales-tax.d.ts

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

package/dist/handlers/sales-tax.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleSalesTax = handleSalesTax;
+async function handleSalesTax(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.period || "Current Period";
+    const transactions = input.transactions || [
+        { date: "2026-03-01", description: "Product Sale - Widget A", amount: 1200, tax_rate: 0.0725, state: "CA", taxable: true },
+        { date: "2026-03-03", description: "Consulting Service", amount: 5000, tax_rate: 0, state: "CA", taxable: false },
+        { date: "2026-03-05", description: "Product Sale - Widget B", amount: 850, tax_rate: 0.0725, state: "CA", taxable: true },
+        { date: "2026-03-08", description: "Product Sale - Online (TX)", amount: 2300, tax_rate: 0.0625, state: "TX", taxable: true },
+        { date: "2026-03-12", description: "SaaS Subscription", amount: 499, tax_rate: 0, taxable: false },
+        { date: "2026-03-15", description: "Product Sale - Widget C", amount: 3400, tax_rate: 0.0725, state: "CA", taxable: true },
+        { date: "2026-03-20", description: "Product Sale - Online (NY)", amount: 1800, tax_rate: 0.08, state: "NY", taxable: true },
+    ];
+    let totalSales = 0, totalTaxable = 0, totalExempt = 0, totalTaxCollected = 0;
+    const byState = {};
+    for (const txn of transactions) {
+        totalSales += txn.amount;
+        if (txn.taxable !== false && txn.tax_rate > 0) {
+            const tax = round(txn.amount * txn.tax_rate);
+            totalTaxable += txn.amount;
+            totalTaxCollected += tax;
+            const st = txn.state || "Unknown";
+            if (!byState[st])
+                byState[st] = { sales: 0, taxable: 0, tax: 0, rate: txn.tax_rate, count: 0 };
+            byState[st].sales += txn.amount;
+            byState[st].taxable += txn.amount;
+            byState[st].tax += tax;
+            byState[st].count += 1;
+        }
+        else {
+            totalExempt += txn.amount;
+        }
+    }
+    totalSales = round(totalSales);
+    totalTaxable = round(totalTaxable);
+    totalExempt = round(totalExempt);
+    totalTaxCollected = round(totalTaxCollected);
+    const stateSummary = Object.entries(byState).sort((a, b) => b[1].tax - a[1].tax).map(([st, d]) => ({
+        state: st, sales: round(d.sales), taxable: round(d.taxable), tax_collected: round(d.tax), rate: d.rate, transactions: d.count,
+    }));
+    const csv = [
+        "SALES TAX REPORT",
+        `Period: ${period}`,
+        `Generated: ${new Date().toISOString().split("T")[0]}`,
+        "",
+        "SUMMARY",
+        `Total Sales,${fmt(totalSales)}`,
+        `Taxable Sales,${fmt(totalTaxable)}`,
+        `Exempt Sales,${fmt(totalExempt)}`,
+        `Total Tax Collected,${fmt(totalTaxCollected)}`,
+        `Effective Tax Rate,${totalTaxable > 0 ? round((totalTaxCollected / totalTaxable) * 100) : 0}%`,
+        "",
+        "BY STATE/JURISDICTION",
+        "State,Taxable Sales,Tax Rate,Tax Collected,Transactions",
+        ...stateSummary.map(s => `${s.state},${fmt(s.taxable)},${(s.rate * 100).toFixed(2)}%,${fmt(s.tax_collected)},${s.transactions}`),
+        "",
+        "TRANSACTION DETAIL",
+        "Date,Description,Amount,Taxable,Tax Rate,Tax Amount,State",
+        ...transactions.map(t => {
+            const tax = (t.taxable !== false && t.tax_rate > 0) ? round(t.amount * t.tax_rate) : 0;
+            return `${t.date},${esc(t.description)},${fmt(t.amount)},${t.taxable !== false && t.tax_rate > 0 ? "Yes" : "No"},${(t.tax_rate * 100).toFixed(2)}%,${fmt(tax)},${t.state || ""}`;
+        }),
+        "",
+        "TAX LIABILITY",
+        `Total Tax Owed,${fmt(totalTaxCollected)}`,
+        `Filing Deadline,${getNextQuarterEnd()}`,
+    ];
+    return {
+        text: `Sales Tax: ${fmt(totalTaxCollected)} collected on ${fmt(totalTaxable)} taxable sales (${stateSummary.length} jurisdictions)`,
+        output_csv: csv.join("\n"),
+        summary: { total_sales: totalSales, total_taxable: totalTaxable, total_exempt: totalExempt, total_tax: totalTaxCollected, jurisdictions: stateSummary.length },
+        by_state: stateSummary,
+        duration_ms: Date.now() - start,
+    };
+}
+function getNextQuarterEnd() {
+    const now = new Date();
+    const m = now.getMonth();
+    const q = m < 3 ? 0 : m < 6 ? 1 : m < 9 ? 2 : 3;
+    const deadlines = ["04-30", "07-31", "10-31", "01-31"];
+    const year = q === 3 ? now.getFullYear() + 1 : now.getFullYear();
+    return `${year}-${deadlines[q]}`;
+}
+function round(n) { return Math.round(n * 100) / 100; }
+function fmt(n) { return "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }); }
+function esc(v) { return v.includes(",") ? `"${v}"` : v; }

package/dist/handlers/variance-analysis.d.ts

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

package/dist/handlers/variance-analysis.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleVarianceAnalysis = handleVarianceAnalysis;
+async function handleVarianceAnalysis(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.period || "Current Period";
+    const threshold = input.threshold_pct || 10;
+    const lines = input.lines || [
+        { item: "Product Revenue", budget: 120000, actual: 115000, category: "Revenue" },
+        { item: "Service Revenue", budget: 80000, actual: 92000, category: "Revenue" },
+        { item: "Cost of Goods Sold", budget: 48000, actual: 52000, category: "COGS" },
+        { item: "Salaries", budget: 70000, actual: 72800, category: "OpEx" },
+        { item: "Marketing", budget: 15000, actual: 22000, category: "OpEx" },
+        { item: "Rent", budget: 8500, actual: 8500, category: "OpEx" },
+        { item: "Technology", budget: 10000, actual: 14200, category: "OpEx" },
+        { item: "Travel", budget: 5000, actual: 8900, category: "OpEx" },
+        { item: "Office Supplies", budget: 2000, actual: 1650, category: "OpEx" },
+        { item: "Insurance", budget: 3200, actual: 3200, category: "OpEx" },
+    ];
+    const analyzed = lines.map(l => {
+        const variance = round(l.actual - l.budget);
+        const variancePct = l.budget !== 0 ? round((variance / Math.abs(l.budget)) * 100) : 0;
+        const favorable = l.category === "Revenue" ? variance >= 0 : variance <= 0;
+        const significant = Math.abs(variancePct) >= threshold;
+        return { ...l, variance, variance_pct: variancePct, favorable, significant };
+    });
+    const significant = analyzed.filter(l => l.significant);
+    const favorableItems = analyzed.filter(l => l.favorable && l.variance !== 0);
+    const unfavorableItems = analyzed.filter(l => !l.favorable && l.variance !== 0);
+    const totalBudget = round(lines.reduce((s, l) => s + l.budget, 0));
+    const totalActual = round(lines.reduce((s, l) => s + l.actual, 0));
+    const totalVariance = round(totalActual - totalBudget);
+    const csv = [
+        "VARIANCE ANALYSIS REPORT",
+        `Period: ${period}`,
+        `Generated: ${new Date().toISOString().split("T")[0]}`,
+        `Significance Threshold: ${threshold}%`,
+        "",
+        "DETAILED ANALYSIS",
+        "Item,Category,Budget,Actual,Variance ($),Variance (%),Favorable?,Significant?",
+        ...analyzed.map(l => `${esc(l.item)},${l.category || ""},${fmt(l.budget)},${fmt(l.actual)},${l.variance >= 0 ? "+" : ""}${fmt(l.variance)},${l.variance_pct >= 0 ? "+" : ""}${l.variance_pct}%,${l.favorable ? "Yes" : "No"},${l.significant ? "YES" : "No"}`),
+        "",
+        "SIGNIFICANT VARIANCES (>${threshold}%)",
+        "Item,Variance ($),Variance (%),Impact",
+        ...significant.sort((a, b) => Math.abs(b.variance_pct) - Math.abs(a.variance_pct)).map(l => `${esc(l.item)},${l.variance >= 0 ? "+" : ""}${fmt(l.variance)},${l.variance_pct >= 0 ? "+" : ""}${l.variance_pct}%,${l.favorable ? "Favorable" : "Unfavorable"}`),
+        "",
+        "FAVORABLE VARIANCES",
+        "Item,Amount Saved/Gained",
+        ...favorableItems.map(l => `${esc(l.item)},${fmt(Math.abs(l.variance))}`),
+        "",
+        "UNFAVORABLE VARIANCES",
+        "Item,Amount Over/Under",
+        ...unfavorableItems.map(l => `${esc(l.item)},${fmt(Math.abs(l.variance))}`),
+        "",
+        "SUMMARY",
+        `Total Budget,${fmt(totalBudget)}`,
+        `Total Actual,${fmt(totalActual)}`,
+        `Net Variance,${totalVariance >= 0 ? "+" : ""}${fmt(totalVariance)}`,
+        `Significant Variances,${significant.length} of ${analyzed.length} items`,
+        `Favorable Items,${favorableItems.length}`,
+        `Unfavorable Items,${unfavorableItems.length}`,
+    ];
+    return {
+        text: `Variance Analysis: ${significant.length} significant variances (>${threshold}%) | Net: ${totalVariance >= 0 ? "+" : ""}${fmt(totalVariance)}`,
+        output_csv: csv.join("\n"),
+        summary: { total_budget: totalBudget, total_actual: totalActual, total_variance: totalVariance, significant_count: significant.length, favorable_count: favorableItems.length, unfavorable_count: unfavorableItems.length },
+        duration_ms: Date.now() - start,
+    };
+}
+function round(n) { return Math.round(n * 100) / 100; }
+function fmt(n) { return "$" + Math.abs(n).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }); }
+function esc(v) { return v.includes(",") ? `"${v}"` : v; }

package/dist/handlers/w2-1099.d.ts

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

package/dist/handlers/w2-1099.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleW21099 = handleW21099;
+async function handleW21099(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const taxYear = input.tax_year || "2025";
+    const company = input.company_name || "Company Name";
+    const employees = input.employees || [
+        { name: "John Smith", ssn_last4: "1234", wages: 85000, federal_tax_withheld: 14280, state_tax_withheld: 4250, social_security_wages: 85000, social_security_tax: 5270, medicare_wages: 85000, medicare_tax: 1232.50, state: "CA" },
+        { name: "Jane Doe", ssn_last4: "5678", wages: 72000, federal_tax_withheld: 11520, state_tax_withheld: 3600, social_security_wages: 72000, social_security_tax: 4464, medicare_wages: 72000, medicare_tax: 1044, state: "CA" },
+        { name: "Alice Chen", ssn_last4: "9012", wages: 95000, federal_tax_withheld: 17100, state_tax_withheld: 4750, social_security_wages: 95000, social_security_tax: 5890, medicare_wages: 95000, medicare_tax: 1377.50, state: "CA" },
+    ];
+    const contractors = input.contractors || [
+        { name: "Bob's Web Design", tin_last4: "4321", total_paid: 15000, type: "NEC" },
+        { name: "Marketing Maven LLC", tin_last4: "8765", total_paid: 28000, type: "NEC" },
+        { name: "Office Cleaning Pro", tin_last4: "2468", total_paid: 9600, type: "NEC" },
+    ];
+    const totalWages = round(employees.reduce((s, e) => s + e.wages, 0));
+    const totalFedWithheld = round(employees.reduce((s, e) => s + e.federal_tax_withheld, 0));
+    const totalStateWithheld = round(employees.reduce((s, e) => s + e.state_tax_withheld, 0));
+    const totalSSWithheld = round(employees.reduce((s, e) => s + e.social_security_tax, 0));
+    const totalMedicareWithheld = round(employees.reduce((s, e) => s + e.medicare_tax, 0));
+    const totalContractorPaid = round(contractors.reduce((s, c) => s + c.total_paid, 0));
+    const contractors1099 = contractors.filter(c => c.total_paid >= 600);
+    const csv = [
+        `W-2 AND 1099 COMPILATION — TAX YEAR ${taxYear}`,
+        `Company: ${company}`,
+        `Generated: ${new Date().toISOString().split("T")[0]}`,
+        `Filing Deadline: ${parseInt(taxYear) + 1}-01-31`,
+        "",
+        "W-2 EMPLOYEE SUMMARY",
+        "Employee,SSN (last 4),Gross Wages,Federal Tax,State Tax,SS Tax,Medicare Tax,State",
+        ...employees.map(e => `${esc(e.name)},***-**-${e.ssn_last4},${fmt(e.wages)},${fmt(e.federal_tax_withheld)},${fmt(e.state_tax_withheld)},${fmt(e.social_security_tax)},${fmt(e.medicare_tax)},${e.state || ""}`),
+        "",
+        "W-2 TOTALS",
+        `Total Wages,${fmt(totalWages)}`,
+        `Total Federal Tax Withheld,${fmt(totalFedWithheld)}`,
+        `Total State Tax Withheld,${fmt(totalStateWithheld)}`,
+        `Total Social Security Tax,${fmt(totalSSWithheld)}`,
+        `Total Medicare Tax,${fmt(totalMedicareWithheld)}`,
+        `Total W-2s to Issue,${employees.length}`,
+        "",
+        "1099-NEC CONTRACTOR SUMMARY",
+        "Contractor,TIN (last 4),Total Paid,Form Required?,Type",
+        ...contractors.map(c => `${esc(c.name)},***-**-${c.tin_last4},${fmt(c.total_paid)},${c.total_paid >= 600 ? "YES" : "No (under $600)"},${c.type || "NEC"}`),
+        "",
+        "1099 TOTALS",
+        `Total Paid to Contractors,${fmt(totalContractorPaid)}`,
+        `1099s Required (>=$600),${contractors1099.length}`,
+        `Contractors Under $600 Threshold,${contractors.length - contractors1099.length}`,
+        "",
+        "FILING CHECKLIST",
+        `Task,Status`,
+        `Verify all employee SSNs,Pending`,
+        `Verify all contractor TINs,Pending`,
+        `Review wage and tax totals,Pending`,
+        `Print/e-file W-2s,Pending`,
+        `Print/e-file 1099s,Pending`,
+        `Mail copies to employees by ${parseInt(taxYear) + 1}-01-31,Pending`,
+        `Mail copies to contractors by ${parseInt(taxYear) + 1}-01-31,Pending`,
+        `File W-3 transmittal with SSA,Pending`,
+        `File 1096 transmittal with IRS,Pending`,
+        "",
+        "EMPLOYER TAX OBLIGATIONS",
+        `Employer SS Match (6.2%),${fmt(totalSSWithheld)}`,
+        `Employer Medicare Match (1.45%),${fmt(totalMedicareWithheld)}`,
+        `Total Employer Tax,${fmt(round(totalSSWithheld + totalMedicareWithheld))}`,
+    ];
+    return {
+        text: `W-2/1099 Compilation: ${employees.length} W-2s + ${contractors1099.length} 1099s | Total Wages: ${fmt(totalWages)} | Contractor Payments: ${fmt(totalContractorPaid)}`,
+        output_csv: csv.join("\n"),
+        summary: {
+            tax_year: taxYear,
+            w2_count: employees.length,
+            total_wages: totalWages,
+            total_fed_withheld: totalFedWithheld,
+            contractor_count: contractors1099.length,
+            total_contractor_paid: totalContractorPaid,
+            filing_deadline: `${parseInt(taxYear) + 1}-01-31`,
+        },
+        duration_ms: Date.now() - start,
+    };
+}
+function round(n) { return Math.round(n * 100) / 100; }
+function fmt(n) { return "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 }); }
+function esc(v) { return v.includes(",") ? `"${v}"` : v; }

package/dist/parsers/index.d.ts

@@ -1,6 +1,6 @@
 /**
  * File parser registry.
- * Detects file type and extracts structured data.
+ * Detects file type, extracts structured data, and determines the best handler.
  */
 import { parseCSV, type CSVData } from "./csv.js";
 export interface ParsedFile {
@@ -10,8 +10,7 @@ export interface ParsedFile {
     suggestedActions: string[];
 }
 /**
- * Parse file content based on its type.
- * Returns structured data + suggested actions the bot can take.
+ * Parse file content and intelligently detect what kind of financial data it contains.
  */
 export declare function parseFile(fileName: string, fileType: string, content: string | Buffer): ParsedFile;
 export { parseCSV, type CSVData };

package/dist/parsers/index.js

@@ -1,7 +1,7 @@
 "use strict";
 /**
  * File parser registry.
- * Detects file type and extracts structured data.
+ * Detects file type, extracts structured data, and determines the best handler.
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.parseCSV = void 0;
@@ -9,8 +9,7 @@ exports.parseFile = parseFile;
 const csv_js_1 = require("./csv.js");
 Object.defineProperty(exports, "parseCSV", { enumerable: true, get: function () { return csv_js_1.parseCSV; } });
 /**
- * Parse file content based on its type.
- * Returns structured data + suggested actions the bot can take.
+ * Parse file content and intelligently detect what kind of financial data it contains.
  */
 function parseFile(fileName, fileType, content) {
     const lower = fileName.toLowerCase();
@@ -18,33 +17,16 @@ function parseFile(fileName, fileType, content) {
     if (fileType === "csv" || lower.endsWith(".csv")) {
         const text = typeof content === "string" ? content : content.toString("utf-8");
         const data = (0, csv_js_1.parseCSV)(text);
-        const suggestedActions = [];
-        // Detect what kind of CSV this is based on headers
-        const headersLower = data.headers.map((h) => h.toLowerCase());
-        if (headersLower.some((h) => /amount|cost|price|total|expense|debit|credit/.test(h))) {
-            suggestedActions.push("expense_report", "chart");
-        }
-        if (headersLower.some((h) => /revenue|income|sales/.test(h)) && headersLower.some((h) => /expense|cost/.test(h))) {
-            suggestedActions.push("pnl");
-        }
-        if (headersLower.some((h) => /invoice|bill|vendor|supplier/.test(h))) {
-            suggestedActions.push("invoice");
-        }
-        if (headersLower.some((h) => /quantity|stock|inventory|sku/.test(h))) {
-            suggestedActions.push("inventory_report");
-        }
-        if (data.summary.numericColumns.length > 0) {
-            suggestedActions.push("chart", "summary");
-        }
+        const suggestedActions = detectCSVType(data, lower);
         return { type: "csv", fileName, data, suggestedActions };
     }
-    // Excel files (basic detection — full parsing requires xlsx library on the node)
+    // Excel files
     if (fileType === "excel" || lower.endsWith(".xlsx") || lower.endsWith(".xls")) {
         return {
             type: "excel",
             fileName,
             data: { message: "Excel file detected. Will be parsed by the processing node." },
-            suggestedActions: ["chart", "expense_report", "summary"],
+            suggestedActions: detectFromFileName(lower),
         };
     }
     // PDF files
@@ -53,47 +35,174 @@ function parseFile(fileName, fileType, content) {
             type: "pdf",
             fileName,
             data: { message: "PDF file detected. Will be parsed by the processing node." },
-            suggestedActions: detectPDFActions(lower),
+            suggestedActions: detectFromFileName(lower),
         };
     }
     // Text files
     if (fileType === "text" || lower.endsWith(".txt")) {
         const text = typeof content === "string" ? content : content.toString("utf-8");
-        return {
-            type: "text",
-            fileName,
-            data: { content: text, length: text.length },
-            suggestedActions: ["summary"],
-        };
+        return { type: "text", fileName, data: { content: text, length: text.length }, suggestedActions: ["summary"] };
     }
     // JSON files
     if (fileType === "json" || lower.endsWith(".json")) {
         const text = typeof content === "string" ? content : content.toString("utf-8");
         try {
             const parsed = JSON.parse(text);
-            return {
-                type: "json",
-                fileName,
-                data: { content: parsed, keys: Object.keys(parsed) },
-                suggestedActions: ["summary", "chart"],
-            };
+            return { type: "json", fileName, data: { content: parsed, keys: Object.keys(parsed) }, suggestedActions: ["summary", "chart"] };
         }
         catch {
             return { type: "json", fileName, data: { error: "Invalid JSON" }, suggestedActions: [] };
         }
     }
-    // Unknown
-    return {
-        type: "unknown",
-        fileName,
-        data: { message: `Unrecognized file type: ${fileType}` },
-        suggestedActions: [],
-    };
+    return { type: "unknown", fileName, data: { message: `Unrecognized file type: ${fileType}` }, suggestedActions: [] };
 }
-function detectPDFActions(fileName) {
+/**
+ * Intelligently detect the type of CSV data based on headers, column types, and file name.
+ * This is the core detection logic — order matters.
+ */
+function detectCSVType(data, fileName) {
+    const headers = data.headers.map(h => h.toLowerCase());
+    const actions = [];
+    // ─── BANK STATEMENT detection ──────────────────────────
+    // Key signals: has debit/credit type column, reference numbers, deposit/withdrawal descriptions
+    const hasTypeCol = headers.some(h => /^type$/.test(h));
+    const hasRefCol = headers.some(h => /reference|ref|check|confirmation/.test(h));
+    const hasDebitCreditValues = data.rows.some(r => {
+        const typeIdx = headers.findIndex(h => /^type$/.test(h));
+        if (typeIdx >= 0) {
+            const val = (r[typeIdx] || "").toLowerCase();
+            return val === "debit" || val === "credit";
+        }
+        return false;
+    });
+    const hasDepositDescriptions = data.rows.some(r => {
+        const descIdx = headers.findIndex(h => /description/.test(h));
+        return descIdx >= 0 && /deposit|withdrawal|transfer|ach|wire|fee|interest/i.test(r[descIdx] || "");
+    });
+    if ((hasTypeCol && hasDebitCreditValues) || (hasRefCol && hasDepositDescriptions) || /bank|statement|reconcil/i.test(fileName)) {
+        actions.push("bank_reconciliation");
+        return actions;
+    }
+    // ─── INVOICE / AR detection ────────────────────────────
+    // Key signals: customer column, invoice number, due date, status (paid/unpaid/overdue)
+    const hasCustomerCol = headers.some(h => /customer|client|bill.?to/.test(h));
+    const hasInvoiceNumCol = headers.some(h => /invoice.?(?:number|no|num|#)|inv.?(?:no|num|#)/.test(h));
+    const hasDueDateCol = headers.some(h => /due.?date|payment.?due/.test(h));
+    const hasStatusCol = headers.some(h => /status/.test(h));
+    const hasStatusValues = data.rows.some(r => {
+        const statusIdx = headers.findIndex(h => /status/.test(h));
+        return statusIdx >= 0 && /paid|unpaid|overdue|outstanding|pending/i.test(r[statusIdx] || "");
+    });
+    if ((hasCustomerCol && hasInvoiceNumCol) || (hasInvoiceNumCol && hasDueDateCol) || (hasStatusValues && hasCustomerCol) || /invoice/i.test(fileName)) {
+        actions.push("ar_aging");
+        return actions;
+    }
+    // ─── AP / BILLS detection ──────────────────────────────
+    const hasVendorCol = headers.some(h => /vendor|supplier|payee/.test(h));
+    const hasBillNumCol = headers.some(h => /bill.?(?:number|no|num|#)/.test(h));
+    if ((hasVendorCol && hasBillNumCol) || (hasVendorCol && hasDueDateCol) || /bill|payable/i.test(fileName)) {
+        actions.push("ap_aging");
+        return actions;
+    }
+    // ─── PAYROLL detection ─────────────────────────────────
+    // Key signals: employee name, rate/salary, hours, department, type (salary/hourly)
+    const hasEmployeeCol = headers.some(h => /employee|name/.test(h));
+    const hasRateCol = headers.some(h => /rate|salary|wage|pay/.test(h));
+    const hasHoursCol = headers.some(h => /hours/.test(h));
+    const hasTypePayroll = data.rows.some(r => {
+        const typeIdx = headers.findIndex(h => /^type$/.test(h));
+        return typeIdx >= 0 && /salary|hourly/i.test(r[typeIdx] || "");
+    });
+    if ((hasEmployeeCol && hasRateCol) || (hasEmployeeCol && hasHoursCol) || hasTypePayroll || /payroll|employee|salary|wage/i.test(fileName)) {
+        actions.push("payroll");
+        return actions;
+    }
+    // ─── BUDGET VS ACTUALS detection ───────────────────────
+    const hasBudgetCol = headers.some(h => /budget/.test(h));
+    const hasActualCol = headers.some(h => /actual/.test(h));
+    if (hasBudgetCol && hasActualCol) {
+        actions.push("budget_vs_actuals");
+        return actions;
+    }
+    if (/budget/i.test(fileName) && (hasBudgetCol || hasActualCol)) {
+        actions.push("budget_vs_actuals");
+        return actions;
+    }
+    // ─── P&L detection ─────────────────────────────────────
+    const hasRevenueData = headers.some(h => /revenue|income|sales/.test(h)) || data.rows.some(r => /revenue|income|sales/i.test(r.join(" ")));
+    const hasExpenseData = headers.some(h => /expense|cost/.test(h)) || data.rows.some(r => /expense|cost of goods/i.test(r.join(" ")));
+    if (hasRevenueData && hasExpenseData) {
+        actions.push("pnl");
+        return actions;
+    }
+    if (/p&l|pnl|profit.?loss|income.?statement/i.test(fileName)) {
+        actions.push("pnl");
+        return actions;
+    }
+    // ─── SALES TAX detection ───────────────────────────────
+    const hasTaxRateCol = headers.some(h => /tax.?rate/.test(h));
+    const hasTaxableCol = headers.some(h => /taxable/.test(h));
+    const hasStateCol = headers.some(h => /^state$/.test(h));
+    if (hasTaxRateCol || (hasTaxableCol && hasStateCol) || /sales.?tax|tax.?report/i.test(fileName)) {
+        actions.push("sales_tax");
+        return actions;
+    }
+    // ─── DEPRECIATION / ASSET detection ────────────────────
+    const hasUsefulLifeCol = headers.some(h => /useful.?life|lifespan/.test(h));
+    const hasSalvageCol = headers.some(h => /salvage|residual/.test(h));
+    const hasAcquiredCol = headers.some(h => /acquired|purchase.?date/.test(h));
+    if (hasUsefulLifeCol || hasSalvageCol || /deprec|asset|equipment/i.test(fileName)) {
+        actions.push("depreciation");
+        return actions;
+    }
+    // ─── DEPARTMENT SPENDING detection ─────────────────────
+    const hasDepartmentCol = headers.some(h => /department|dept|team|division|cost.?center/.test(h));
+    const hasCategoryCol = headers.some(h => /category|type|class/.test(h));
+    const hasAmountCol = headers.some(h => /amount|cost|price|total/.test(h));
+    if (hasDepartmentCol && hasAmountCol) {
+        actions.push("department_spending");
+        return actions;
+    }
+    // ─── EXPENSE REPORT detection (catch-all for financial data) ──
+    if (hasAmountCol && hasCategoryCol) {
+        actions.push("expense_report");
+        return actions;
+    }
+    if (hasAmountCol && headers.some(h => /description|desc|memo/.test(h))) {
+        actions.push("expense_report");
+        return actions;
+    }
+    if (/expense|spending|receipt/i.test(fileName)) {
+        actions.push("expense_report");
+        return actions;
+    }
+    // ─── GENERIC fallback ─────────────────────────────────
+    if (data.summary.numericColumns.length > 0) {
+        actions.push("chart");
+    }
+    return actions;
+}
+/**
+ * Detect file type from file name alone (for PDFs, Excel, etc. where we can't read headers)
+ */
+function detectFromFileName(fileName) {
     if (/invoice/i.test(fileName))
-        return ["invoice", "expense_report"];
-    if (/receipt/i.test(fileName))
+        return ["ar_aging"];
+    if (/bill|payable/i.test(fileName))
+        return ["ap_aging"];
+    if (/bank|statement|reconcil/i.test(fileName))
+        return ["bank_reconciliation"];
+    if (/payroll|employee|salary/i.test(fileName))
+        return ["payroll"];
+    if (/budget/i.test(fileName))
+        return ["budget_vs_actuals"];
+    if (/p&l|pnl|profit/i.test(fileName))
+        return ["pnl"];
+    if (/tax/i.test(fileName))
+        return ["sales_tax"];
+    if (/deprec|asset/i.test(fileName))
+        return ["depreciation"];
+    if (/expense|receipt|spending/i.test(fileName))
         return ["expense_report"];
     if (/report|statement/i.test(fileName))
         return ["summary", "chart"];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "neuronix-node",
-  "version": "0.2.0",
+  "version": "0.6.0",
   "description": "Neuronix GPU Provider Node — earn by contributing compute to the Neuronix network",
   "main": "dist/index.js",
   "bin": {