neuronix-node 0.2.0 → 0.6.0

package/dist/handlers/expense.js

@@ -1,38 +1,82 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleExpenseReport = handleExpenseReport;
+/**
+ * Format a date string to YYYY-MM-DD for proper Excel sorting.
+ */
+function normalizeDate(dateStr) {
+    if (!dateStr)
+        return "";
+    // Already YYYY-MM-DD
+    if (/^\d{4}-\d{2}-\d{2}$/.test(dateStr))
+        return dateStr;
+    // M/D/YYYY or MM/DD/YYYY
+    const match = dateStr.match(/^(\d{1,2})\/(\d{1,2})\/(\d{4})$/);
+    if (match)
+        return `${match[3]}-${match[1].padStart(2, "0")}-${match[2].padStart(2, "0")}`;
+    return dateStr;
+}
+/**
+ * Format a number as currency without trailing spaces.
+ */
+function fmtCurrency(n) {
+    return "$" + n.toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+/**
+ * Detect department from filename for merged file processing.
+ */
+function detectDepartment(fileName) {
+    const lower = fileName.toLowerCase();
+    if (/marketing/.test(lower))
+        return "Marketing";
+    if (/operation/.test(lower))
+        return "Operations";
+    if (/tech/.test(lower))
+        return "Technology";
+    if (/hr|payroll|human/.test(lower))
+        return "HR & Payroll";
+    if (/travel|entertainment/.test(lower))
+        return "Travel & Entertainment";
+    if (/sales/.test(lower))
+        return "Sales";
+    if (/admin/.test(lower))
+        return "Administration";
+    return "General";
+}
 async function handleExpenseReport(task) {
     const start = Date.now();
     const input = task.input_payload;
     const period = input.period || "Current Period";
+    const mergedFrom = input.merged_from || [];
     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" },
     ];
+    // Assign departments from merged file names if available
+    if (mergedFrom.length > 0 && expenses.every((e) => !e.department)) {
+        // Try to detect department from category patterns
+        for (const exp of expenses) {
+            exp.department = detectDepartmentFromCategory(exp.category);
+        }
+    }
+    // Sort by amount descending
+    const sorted = [...expenses].sort((a, b) => b.amount - a.amount);
     // 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: 0, count: 0 };
         }
         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]) => ({
@@ -41,41 +85,110 @@ async function handleExpenseReport(task) {
         count: data.count,
         percentage: Math.round((data.total / total) * 1000) / 10,
     }));
-    // Generate chart data for the frontend
+    // Calculate by department if available
+    const hasDepartments = sorted.some((e) => e.department);
+    const byDepartment = {};
+    if (hasDepartments) {
+        for (const exp of expenses) {
+            const dept = exp.department || "General";
+            if (!byDepartment[dept])
+                byDepartment[dept] = { total: 0, count: 0 };
+            byDepartment[dept].total += exp.amount;
+            byDepartment[dept].count += 1;
+        }
+    }
+    const sortedDepartments = Object.entries(byDepartment)
+        .sort((a, b) => b[1].total - a[1].total)
+        .map(([name, data]) => ({
+        department: name,
+        total: Math.round(data.total * 100) / 100,
+        count: data.count,
+        percentage: Math.round((data.total / total) * 1000) / 10,
+    }));
+    // Chart data
     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),
-            }],
+        datasets: [{ label: "Expenses", data: sortedCategories.map((c) => c.total) }],
     };
     // Summary text
     const summaryLines = [
         `Expense Report: ${period}`,
-        `Total: $${total.toFixed(2)} across ${expenses.length} expenses`,
+        `Total: ${fmtCurrency(total)} across ${expenses.length} expenses in ${sortedCategories.length} categories`,
         ``,
-        `By Category:`,
-        ...sortedCategories.map((c) => `  ${c.category}: $${c.total.toFixed(2)} (${c.percentage}%) — ${c.count} item${c.count > 1 ? "s" : ""}`),
+        `Top Categories:`,
+        ...sortedCategories.slice(0, 10).map((c) => `  ${c.category}: ${fmtCurrency(c.total)} (${c.percentage}%) — ${c.count} items`),
         ``,
-        `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`,
+        `Largest expense: ${sorted[0].description} (${fmtCurrency(sorted[0].amount)})`,
+        `Smallest expense: ${sorted[sorted.length - 1].description} (${fmtCurrency(sorted[sorted.length - 1].amount)})`,
     ];
+    // ── Build clean CSV output ────────────────────────────────
+    const csvLines = [];
+    const hasDept = hasDepartments;
+    const itemHeaders = hasDept
+        ? "Date,Department,Description,Category,Amount"
+        : "Date,Description,Category,Amount";
+    // Report header
+    csvLines.push("EXPENSE REPORT");
+    csvLines.push(`Period: ${period}`);
+    csvLines.push(`Generated: ${new Date().toISOString().split("T")[0]}`);
+    if (mergedFrom.length > 0) {
+        csvLines.push(`Sources: ${mergedFrom.length} files merged`);
+    }
+    csvLines.push(`Total Items: ${expenses.length}`);
+    csvLines.push(`Grand Total: ${fmtCurrency(total)}`);
+    csvLines.push("");
+    // Section 1: All expenses sorted by amount
+    csvLines.push("DETAILED EXPENSES (sorted by amount)");
+    csvLines.push(itemHeaders);
+    for (const exp of sorted) {
+        const date = normalizeDate(exp.date);
+        const desc = csvEscape(exp.description);
+        const cat = csvEscape(exp.category);
+        const amt = fmtCurrency(exp.amount);
+        if (hasDept) {
+            csvLines.push(`${date},${csvEscape(exp.department || "General")},${desc},${cat},${amt}`);
+        }
+        else {
+            csvLines.push(`${date},${desc},${cat},${amt}`);
+        }
+    }
+    // Subtotal row
+    if (hasDept) {
+        csvLines.push(`,,,,`);
+        csvLines.push(`,,,SUBTOTAL,${fmtCurrency(total)}`);
+    }
+    else {
+        csvLines.push(`,,,`);
+        csvLines.push(`,,SUBTOTAL,${fmtCurrency(total)}`);
+    }
+    csvLines.push("");
+    // Section 2: Summary by category
+    csvLines.push("SUMMARY BY CATEGORY");
+    csvLines.push("Category,Amount,% of Total,Item Count");
+    for (const c of sortedCategories) {
+        csvLines.push(`${csvEscape(c.category)},${fmtCurrency(c.total)},${c.percentage}%,${c.count}`);
+    }
+    csvLines.push("");
+    // Section 3: Summary by department (if merged)
+    if (hasDept && sortedDepartments.length > 0) {
+        csvLines.push("SUMMARY BY DEPARTMENT");
+        csvLines.push("Department,Amount,% of Total,Item Count");
+        for (const d of sortedDepartments) {
+            csvLines.push(`${csvEscape(d.department)},${fmtCurrency(d.total)},${d.percentage}%,${d.count}`);
+        }
+        csvLines.push("");
+    }
+    // Grand total
+    csvLines.push("GRAND TOTAL");
+    csvLines.push(`Total Expenses,${fmtCurrency(total)}`);
+    csvLines.push(`Total Items,${expenses.length}`);
+    csvLines.push(`Total Categories,${sortedCategories.length}`);
+    if (hasDept)
+        csvLines.push(`Total Departments,${sortedDepartments.length}`);
+    csvLines.push(`Largest Expense,${csvEscape(sorted[0].description)} (${fmtCurrency(sorted[0].amount)})`);
+    csvLines.push(`Average Expense,${fmtCurrency(Math.round((total / expenses.length) * 100) / 100)}`);
     const durationMs = Date.now() - start;
     return {
         text: summaryLines.join("\n"),
@@ -86,10 +199,12 @@ async function handleExpenseReport(task) {
             expense_count: expenses.length,
             category_count: sortedCategories.length,
             largest_category: sortedCategories[0]?.category,
-            largest_expense: expenses.sort((a, b) => b.amount - a.amount)[0],
+            largest_expense: sorted[0],
+            average_expense: Math.round((total / expenses.length) * 100) / 100,
         },
         by_category: sortedCategories,
-        expenses,
+        by_department: sortedDepartments.length > 0 ? sortedDepartments : undefined,
+        expenses: sorted,
         chart_data: chartData,
         duration_ms: durationMs,
     };
@@ -100,3 +215,19 @@ function csvEscape(value) {
     }
     return value;
 }
+function detectDepartmentFromCategory(category) {
+    const lower = category.toLowerCase();
+    if (/payroll|benefits|recruiting|onboarding|training|employee|hr|insurance|safety/.test(lower))
+        return "HR & Payroll";
+    if (/digital|marketing|pr|creative|print|email|influencer|affiliate|content|seo|advertising/.test(lower))
+        return "Marketing";
+    if (/cloud|software|hardware|ai|infrastructure|security/.test(lower))
+        return "Technology";
+    if (/rent|utilities|maintenance|office supplies|equipment|furniture/.test(lower))
+        return "Operations";
+    if (/airfare|lodging|hotel|transport|conference|entertainment|team meal/.test(lower))
+        return "Travel & Entertainment";
+    if (/consulting/.test(lower))
+        return "Consulting";
+    return "General";
+}

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

@@ -1,7 +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.
+ * Receives a file's content, parses it, determines the best handler,
+ * converts CSV data into the right format, and routes it.
  */
 export declare function handleFileProcess(task: TaskInput): Promise<TaskOutput>;