neuronix-node 0.2.0 → 0.6.0

package/dist/handlers/ap-aging.d.ts

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

package/dist/handlers/ap-aging.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleAPAging = handleAPAging;
+async function handleAPAging(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const asOf = input.as_of_date ? new Date(input.as_of_date) : new Date();
+    const bills = input.bills || [
+        { vendor: "Office Depot", bill_number: "BL-100", amount: 2340, date_received: "2026-02-01", date_due: "2026-03-03", amount_paid: 0 },
+        { vendor: "AWS", bill_number: "BL-101", amount: 4680, date_received: "2026-03-01", date_due: "2026-03-31", amount_paid: 0 },
+        { vendor: "Landlord LLC", bill_number: "BL-102", amount: 8500, date_received: "2026-03-01", date_due: "2026-04-01", amount_paid: 0 },
+        { vendor: "Insurance Co", bill_number: "BL-088", amount: 1250, date_received: "2025-12-15", date_due: "2026-01-15", amount_paid: 0 },
+        { vendor: "Marketing Agency", bill_number: "BL-095", amount: 5000, date_received: "2026-01-10", date_due: "2026-02-09", amount_paid: 2500 },
+    ];
+    const buckets = { current: [], days30: [], days60: [], days90: [], over90: [] };
+    let totalOwed = 0;
+    for (const bill of bills) {
+        const outstanding = bill.amount - (bill.amount_paid || 0);
+        if (outstanding <= 0)
+            continue;
+        const dueDate = new Date(bill.date_due);
+        const daysOverdue = Math.floor((asOf.getTime() - dueDate.getTime()) / 86400000);
+        const entry = { ...bill, outstanding, days_overdue: Math.max(daysOverdue, 0) };
+        totalOwed += outstanding;
+        if (daysOverdue <= 0)
+            buckets.current.push(entry);
+        else if (daysOverdue <= 30)
+            buckets.days30.push(entry);
+        else if (daysOverdue <= 60)
+            buckets.days60.push(entry);
+        else if (daysOverdue <= 90)
+            buckets.days90.push(entry);
+        else
+            buckets.over90.push(entry);
+    }
+    const bt = {
+        current: round(buckets.current.reduce((s, i) => s + i.outstanding, 0)),
+        days_1_30: round(buckets.days30.reduce((s, i) => s + i.outstanding, 0)),
+        days_31_60: round(buckets.days60.reduce((s, i) => s + i.outstanding, 0)),
+        days_61_90: round(buckets.days90.reduce((s, i) => s + i.outstanding, 0)),
+        over_90: round(buckets.over90.reduce((s, i) => s + i.outstanding, 0)),
+    };
+    const byVendor = {};
+    for (const b of [...buckets.over90, ...buckets.days90, ...buckets.days60, ...buckets.days30, ...buckets.current]) {
+        if (!byVendor[b.vendor])
+            byVendor[b.vendor] = { total: 0, bills: 0, oldest_days: 0 };
+        byVendor[b.vendor].total += b.outstanding;
+        byVendor[b.vendor].bills += 1;
+        byVendor[b.vendor].oldest_days = Math.max(byVendor[b.vendor].oldest_days, b.days_overdue);
+    }
+    const vendorSummary = Object.entries(byVendor).sort((a, b) => b[1].total - a[1].total).map(([n, d]) => ({ vendor: n, ...d, total: round(d.total) }));
+    const csv = [
+        "ACCOUNTS PAYABLE AGING REPORT",
+        `As of: ${asOf.toISOString().split("T")[0]}`,
+        `Total Owed: ${fmt(totalOwed)}`,
+        "",
+        "AGING SUMMARY",
+        "Bucket,Amount,% of Total,Bill Count",
+        `Current (not due),${fmt(bt.current)},${pct(bt.current, totalOwed)}%,${buckets.current.length}`,
+        `1-30 Days Overdue,${fmt(bt.days_1_30)},${pct(bt.days_1_30, totalOwed)}%,${buckets.days30.length}`,
+        `31-60 Days Overdue,${fmt(bt.days_31_60)},${pct(bt.days_31_60, totalOwed)}%,${buckets.days60.length}`,
+        `61-90 Days Overdue,${fmt(bt.days_61_90)},${pct(bt.days_61_90, totalOwed)}%,${buckets.days90.length}`,
+        `Over 90 Days,${fmt(bt.over_90)},${pct(bt.over_90, totalOwed)}%,${buckets.over90.length}`,
+        "",
+        "BY VENDOR",
+        "Vendor,Total Owed,Bills,Oldest Overdue (days)",
+        ...vendorSummary.map(v => `${esc(v.vendor)},${fmt(v.total)},${v.bills},${v.oldest_days}`),
+        "",
+        "DETAIL — ALL OUTSTANDING BILLS",
+        "Vendor,Bill #,Amount,Paid,Outstanding,Date Received,Date Due,Days Overdue",
+        ...[...buckets.over90, ...buckets.days90, ...buckets.days60, ...buckets.days30, ...buckets.current]
+            .map(b => `${esc(b.vendor)},${b.bill_number || ""},${fmt(b.amount)},${fmt(b.amount_paid || 0)},${fmt(b.outstanding)},${b.date_received},${b.date_due},${b.days_overdue}`),
+        "",
+        "GRAND TOTAL",
+        `Total Owed,${fmt(totalOwed)}`,
+        `Total Bills,${bills.filter(b => (b.amount - (b.amount_paid || 0)) > 0).length}`,
+        `Total Vendors,${vendorSummary.length}`,
+    ];
+    return {
+        text: `AP Aging Report as of ${asOf.toISOString().split("T")[0]}\nTotal Owed: ${fmt(totalOwed)}`,
+        output_csv: csv.join("\n"),
+        summary: { total_owed: totalOwed, buckets: bt, vendor_count: vendorSummary.length },
+        by_vendor: vendorSummary,
+        chart_data: { chart_type: "bar", title: "AP Aging Buckets", labels: ["Current", "1-30", "31-60", "61-90", "90+"], datasets: [{ label: "Owed", data: [bt.current, bt.days_1_30, bt.days_31_60, bt.days_61_90, bt.over_90] }] },
+        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 pct(n, t) { return t > 0 ? (Math.round((n / t) * 1000) / 10).toString() : "0"; }
+function esc(v) { return v.includes(",") ? `"${v}"` : v; }

package/dist/handlers/ar-aging.d.ts

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

package/dist/handlers/ar-aging.js

@@ -0,0 +1,101 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleARAging = handleARAging;
+async function handleARAging(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const asOf = input.as_of_date ? new Date(input.as_of_date) : new Date();
+    const invoices = input.invoices || [
+        { customer: "Acme Corp", invoice_number: "INV-001", amount: 5000, date_issued: "2026-01-15", date_due: "2026-02-14", amount_paid: 0 },
+        { customer: "Acme Corp", invoice_number: "INV-012", amount: 3200, date_issued: "2026-02-20", date_due: "2026-03-22", amount_paid: 0 },
+        { customer: "TechStart Inc", invoice_number: "INV-003", amount: 12000, date_issued: "2026-03-01", date_due: "2026-03-31", amount_paid: 6000 },
+        { customer: "GlobalTrade LLC", invoice_number: "INV-007", amount: 8500, date_issued: "2025-11-10", date_due: "2025-12-10", amount_paid: 0 },
+        { customer: "Smith & Co", invoice_number: "INV-009", amount: 1500, date_issued: "2026-03-15", date_due: "2026-04-14", amount_paid: 0 },
+    ];
+    // Calculate aging buckets
+    const buckets = { current: [], days30: [], days60: [], days90: [], over90: [] };
+    let totalOutstanding = 0;
+    for (const inv of invoices) {
+        const outstanding = inv.amount - (inv.amount_paid || 0);
+        if (outstanding <= 0)
+            continue;
+        const dueDate = new Date(inv.date_due);
+        const daysOverdue = Math.floor((asOf.getTime() - dueDate.getTime()) / 86400000);
+        const entry = { ...inv, outstanding, days_overdue: Math.max(daysOverdue, 0) };
+        totalOutstanding += outstanding;
+        if (daysOverdue <= 0)
+            buckets.current.push(entry);
+        else if (daysOverdue <= 30)
+            buckets.days30.push(entry);
+        else if (daysOverdue <= 60)
+            buckets.days60.push(entry);
+        else if (daysOverdue <= 90)
+            buckets.days90.push(entry);
+        else
+            buckets.over90.push(entry);
+    }
+    const bucketTotals = {
+        current: round(buckets.current.reduce((s, i) => s + i.outstanding, 0)),
+        days_1_30: round(buckets.days30.reduce((s, i) => s + i.outstanding, 0)),
+        days_31_60: round(buckets.days60.reduce((s, i) => s + i.outstanding, 0)),
+        days_61_90: round(buckets.days90.reduce((s, i) => s + i.outstanding, 0)),
+        over_90: round(buckets.over90.reduce((s, i) => s + i.outstanding, 0)),
+    };
+    // By customer summary
+    const byCustomer = {};
+    for (const inv of [...buckets.current, ...buckets.days30, ...buckets.days60, ...buckets.days90, ...buckets.over90]) {
+        if (!byCustomer[inv.customer])
+            byCustomer[inv.customer] = { total: 0, invoices: 0, oldest_days: 0 };
+        byCustomer[inv.customer].total += inv.outstanding;
+        byCustomer[inv.customer].invoices += 1;
+        byCustomer[inv.customer].oldest_days = Math.max(byCustomer[inv.customer].oldest_days, inv.days_overdue);
+    }
+    const customerSummary = Object.entries(byCustomer)
+        .sort((a, b) => b[1].total - a[1].total)
+        .map(([name, data]) => ({ customer: name, ...data, total: round(data.total) }));
+    // CSV output
+    const csv = [
+        "ACCOUNTS RECEIVABLE AGING REPORT",
+        `As of: ${asOf.toISOString().split("T")[0]}`,
+        `Total Outstanding: ${fmt(totalOutstanding)}`,
+        "",
+        "AGING SUMMARY",
+        "Bucket,Amount,% of Total,Invoice Count",
+        `Current (not due),${fmt(bucketTotals.current)},${pct(bucketTotals.current, totalOutstanding)}%,${buckets.current.length}`,
+        `1-30 Days,${fmt(bucketTotals.days_1_30)},${pct(bucketTotals.days_1_30, totalOutstanding)}%,${buckets.days30.length}`,
+        `31-60 Days,${fmt(bucketTotals.days_31_60)},${pct(bucketTotals.days_31_60, totalOutstanding)}%,${buckets.days60.length}`,
+        `61-90 Days,${fmt(bucketTotals.days_61_90)},${pct(bucketTotals.days_61_90, totalOutstanding)}%,${buckets.days90.length}`,
+        `Over 90 Days,${fmt(bucketTotals.over_90)},${pct(bucketTotals.over_90, totalOutstanding)}%,${buckets.over90.length}`,
+        "",
+        "BY CUSTOMER",
+        "Customer,Outstanding,Invoices,Oldest Overdue (days)",
+        ...customerSummary.map(c => `${esc(c.customer)},${fmt(c.total)},${c.invoices},${c.oldest_days}`),
+        "",
+        "DETAIL — ALL OUTSTANDING INVOICES",
+        "Customer,Invoice #,Amount,Paid,Outstanding,Date Issued,Date Due,Days Overdue",
+        ...[...buckets.over90, ...buckets.days90, ...buckets.days60, ...buckets.days30, ...buckets.current]
+            .map(i => `${esc(i.customer)},${i.invoice_number || ""},${fmt(i.amount)},${fmt(i.amount_paid || 0)},${fmt(i.outstanding)},${i.date_issued},${i.date_due},${i.days_overdue}`),
+        "",
+        "GRAND TOTAL",
+        `Total Outstanding,${fmt(totalOutstanding)}`,
+        `Total Invoices,${invoices.filter(i => (i.amount - (i.amount_paid || 0)) > 0).length}`,
+        `Total Customers,${customerSummary.length}`,
+    ];
+    return {
+        text: `AR Aging Report as of ${asOf.toISOString().split("T")[0]}\nTotal Outstanding: ${fmt(totalOutstanding)}\nCurrent: ${fmt(bucketTotals.current)} | 1-30: ${fmt(bucketTotals.days_1_30)} | 31-60: ${fmt(bucketTotals.days_31_60)} | 61-90: ${fmt(bucketTotals.days_61_90)} | 90+: ${fmt(bucketTotals.over_90)}`,
+        output_csv: csv.join("\n"),
+        summary: { total_outstanding: totalOutstanding, buckets: bucketTotals, customer_count: customerSummary.length },
+        by_customer: customerSummary,
+        chart_data: {
+            chart_type: "bar",
+            title: "AR Aging Buckets",
+            labels: ["Current", "1-30 Days", "31-60 Days", "61-90 Days", "90+ Days"],
+            datasets: [{ label: "Outstanding", data: [bucketTotals.current, bucketTotals.days_1_30, bucketTotals.days_31_60, bucketTotals.days_61_90, bucketTotals.over_90] }],
+        },
+        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 pct(n, total) { return total > 0 ? (Math.round((n / total) * 1000) / 10).toString() : "0"; }
+function esc(v) { return v.includes(",") ? `"${v}"` : v; }

package/dist/handlers/bank-reconciliation.d.ts

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

package/dist/handlers/bank-reconciliation.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBankReconciliation = handleBankReconciliation;
+async function handleBankReconciliation(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const bankTxns = input.bank_transactions || [];
+    const bookTxns = input.book_transactions || [];
+    const bankBal = input.bank_balance || 0;
+    const bookBal = input.book_balance || 0;
+    // Match transactions by amount and approximate date
+    const matched = [];
+    const unmatchedBank = [];
+    const unmatchedBook = [];
+    const usedBook = new Set();
+    for (const bt of bankTxns) {
+        let found = false;
+        for (let i = 0; i < bookTxns.length; i++) {
+            if (usedBook.has(i))
+                continue;
+            const bk = bookTxns[i];
+            if (Math.abs(bt.amount) === Math.abs(bk.amount) && bt.type === bk.type) {
+                const daysDiff = Math.abs(new Date(bt.date).getTime() - new Date(bk.date).getTime()) / 86400000;
+                if (daysDiff <= 5) {
+                    matched.push({ bank: bt, book: bk });
+                    usedBook.add(i);
+                    found = true;
+                    break;
+                }
+            }
+        }
+        if (!found)
+            unmatchedBank.push(bt);
+    }
+    for (let i = 0; i < bookTxns.length; i++) {
+        if (!usedBook.has(i))
+            unmatchedBook.push(bookTxns[i]);
+    }
+    const outstandingDeposits = unmatchedBook.filter(t => t.type === "credit");
+    const outstandingChecks = unmatchedBook.filter(t => t.type === "debit");
+    const bankOnlyItems = unmatchedBank;
+    const depositTotal = round(outstandingDeposits.reduce((s, t) => s + Math.abs(t.amount), 0));
+    const checkTotal = round(outstandingChecks.reduce((s, t) => s + Math.abs(t.amount), 0));
+    const bankOnlyTotal = round(bankOnlyItems.reduce((s, t) => s + (t.type === "credit" ? t.amount : -t.amount), 0));
+    const adjustedBankBal = round(bankBal + depositTotal - checkTotal);
+    const adjustedBookBal = round(bookBal + bankOnlyTotal);
+    const difference = round(adjustedBankBal - adjustedBookBal);
+    const csv = [
+        "BANK RECONCILIATION",
+        `Date: ${new Date().toISOString().split("T")[0]}`,
+        "",
+        "RECONCILIATION SUMMARY",
+        `Bank Statement Balance,${fmt(bankBal)}`,
+        `Add: Outstanding Deposits,${fmt(depositTotal)}`,
+        `Less: Outstanding Checks,${fmt(checkTotal)}`,
+        `Adjusted Bank Balance,${fmt(adjustedBankBal)}`,
+        "",
+        `Book Balance,${fmt(bookBal)}`,
+        `Add/Less: Bank-Only Items,${fmt(bankOnlyTotal)}`,
+        `Adjusted Book Balance,${fmt(adjustedBookBal)}`,
+        "",
+        `DIFFERENCE,${fmt(difference)}`,
+        `Status,${Math.abs(difference) < 0.01 ? "RECONCILED ✓" : "UNRECONCILED — review needed"}`,
+        "",
+        `MATCHED TRANSACTIONS (${matched.length})`,
+        "Date,Description,Amount,Type",
+        ...matched.map(m => `${m.bank.date},${esc(m.bank.description)},${fmt(Math.abs(m.bank.amount))},${m.bank.type}`),
+        "",
+        `OUTSTANDING DEPOSITS — In Books Not Yet in Bank (${outstandingDeposits.length})`,
+        "Date,Description,Amount",
+        ...outstandingDeposits.map(t => `${t.date},${esc(t.description)},${fmt(Math.abs(t.amount))}`),
+        "",
+        `OUTSTANDING CHECKS — In Books Not Yet Cleared (${outstandingChecks.length})`,
+        "Date,Description,Amount",
+        ...outstandingChecks.map(t => `${t.date},${esc(t.description)},${fmt(Math.abs(t.amount))}`),
+        "",
+        `BANK-ONLY ITEMS — In Bank Not in Books (${bankOnlyItems.length})`,
+        "Date,Description,Amount,Type",
+        ...bankOnlyItems.map(t => `${t.date},${esc(t.description)},${fmt(Math.abs(t.amount))},${t.type}`),
+        "",
+        "TOTALS",
+        `Matched Transactions,${matched.length}`,
+        `Outstanding Deposits,${outstandingDeposits.length}`,
+        `Outstanding Checks,${outstandingChecks.length}`,
+        `Bank-Only Items,${bankOnlyItems.length}`,
+    ];
+    return {
+        text: `Bank Reconciliation: ${Math.abs(difference) < 0.01 ? "RECONCILED ✓" : `UNRECONCILED — difference of ${fmt(difference)}`}\nMatched: ${matched.length} | Unmatched Bank: ${unmatchedBank.length} | Unmatched Book: ${unmatchedBook.length}`,
+        output_csv: csv.join("\n"),
+        summary: { bank_balance: bankBal, book_balance: bookBal, adjusted_bank: adjustedBankBal, adjusted_book: adjustedBookBal, difference, reconciled: Math.abs(difference) < 0.01, matched_count: matched.length },
+        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/budget-vs-actuals.d.ts

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

package/dist/handlers/budget-vs-actuals.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleBudgetVsActuals = handleBudgetVsActuals;
+async function handleBudgetVsActuals(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.period || "Current Period";
+    const lines = input.lines || [
+        { category: "Salaries", budget: 70000, actual: 72800 },
+        { category: "Rent", budget: 8500, actual: 8500 },
+        { category: "Marketing", budget: 15000, actual: 18200 },
+        { category: "Technology", budget: 10000, actual: 12400 },
+        { category: "Travel", budget: 5000, actual: 7200 },
+        { category: "Office Supplies", budget: 2000, actual: 1650 },
+        { category: "Insurance", budget: 3000, actual: 3000 },
+        { category: "Utilities", budget: 2500, actual: 2180 },
+    ];
+    let totalBudget = 0, totalActual = 0;
+    const analyzed = lines.map(l => {
+        const variance = round(l.actual - l.budget);
+        const variancePct = l.budget > 0 ? round((variance / l.budget) * 100) : 0;
+        const status = Math.abs(variancePct) <= 5 ? "On Track" : variance > 0 ? "Over Budget" : "Under Budget";
+        totalBudget += l.budget;
+        totalActual += l.actual;
+        return { ...l, variance, variance_pct: variancePct, status };
+    });
+    totalBudget = round(totalBudget);
+    totalActual = round(totalActual);
+    const totalVariance = round(totalActual - totalBudget);
+    const totalVariancePct = totalBudget > 0 ? round((totalVariance / totalBudget) * 100) : 0;
+    const overBudget = analyzed.filter(l => l.variance > 0).sort((a, b) => b.variance - a.variance);
+    const underBudget = analyzed.filter(l => l.variance < 0).sort((a, b) => a.variance - b.variance);
+    const csv = [
+        "BUDGET VS ACTUALS REPORT",
+        `Period: ${period}`,
+        `Generated: ${new Date().toISOString().split("T")[0]}`,
+        "",
+        "DETAILED COMPARISON",
+        "Category,Budget,Actual,Variance ($),Variance (%),Status",
+        ...analyzed.map(l => `${esc(l.category)},${fmt(l.budget)},${fmt(l.actual)},${l.variance >= 0 ? "+" : ""}${fmt(l.variance)},${l.variance_pct >= 0 ? "+" : ""}${l.variance_pct}%,${l.status}`),
+        "",
+        `TOTAL,${fmt(totalBudget)},${fmt(totalActual)},${totalVariance >= 0 ? "+" : ""}${fmt(totalVariance)},${totalVariancePct >= 0 ? "+" : ""}${totalVariancePct}%,${Math.abs(totalVariancePct) <= 5 ? "On Track" : totalVariance > 0 ? "Over Budget" : "Under Budget"}`,
+        "",
+        "OVER BUDGET ITEMS",
+        "Category,Over By,% Over",
+        ...overBudget.map(l => `${esc(l.category)},${fmt(l.variance)},+${l.variance_pct}%`),
+        "",
+        "UNDER BUDGET ITEMS",
+        "Category,Under By,% Under",
+        ...underBudget.map(l => `${esc(l.category)},${fmt(Math.abs(l.variance))},${l.variance_pct}%`),
+        "",
+        "SUMMARY",
+        `Total Budget,${fmt(totalBudget)}`,
+        `Total Actual,${fmt(totalActual)}`,
+        `Net Variance,${totalVariance >= 0 ? "+" : ""}${fmt(totalVariance)} (${totalVariancePct >= 0 ? "+" : ""}${totalVariancePct}%)`,
+        `Categories Over Budget,${overBudget.length}`,
+        `Categories Under Budget,${underBudget.length}`,
+        `Categories On Track,${analyzed.filter(l => l.status === "On Track").length}`,
+    ];
+    return {
+        text: `Budget vs Actuals: ${period}\nBudget: ${fmt(totalBudget)} | Actual: ${fmt(totalActual)} | Variance: ${totalVariance >= 0 ? "+" : ""}${fmt(totalVariance)} (${totalVariancePct}%)`,
+        output_csv: csv.join("\n"),
+        summary: { total_budget: totalBudget, total_actual: totalActual, total_variance: totalVariance, total_variance_pct: totalVariancePct },
+        chart_data: { chart_type: "bar", title: `Budget vs Actuals — ${period}`, labels: analyzed.map(l => l.category), datasets: [{ label: "Budget", data: analyzed.map(l => l.budget) }, { label: "Actual", data: analyzed.map(l => l.actual) }] },
+        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/cash-flow.d.ts

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

package/dist/handlers/cash-flow.js

@@ -0,0 +1,87 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleCashFlow = handleCashFlow;
+async function handleCashFlow(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.period || "Current Period";
+    const beginBal = input.beginning_balance || 50000;
+    const opIn = input.operating_inflows || [
+        { description: "Customer Collections", amount: 125000, category: "Revenue" },
+        { description: "Interest Income", amount: 320, category: "Interest" },
+        { description: "Tax Refund", amount: 2800, category: "Tax" },
+    ];
+    const opOut = input.operating_outflows || [
+        { description: "Supplier Payments", amount: 45000, category: "COGS" },
+        { description: "Payroll", amount: 68500, category: "Payroll" },
+        { description: "Rent", amount: 8500, category: "Overhead" },
+        { description: "Utilities", amount: 1800, category: "Overhead" },
+        { description: "Insurance", amount: 3200, category: "Insurance" },
+        { description: "Marketing", amount: 12000, category: "Marketing" },
+        { description: "Income Tax Payments", amount: 8500, category: "Tax" },
+    ];
+    const investing = input.investing || [
+        { description: "Equipment Purchase", amount: -15000, category: "CapEx" },
+        { description: "Software License (3yr)", amount: -4500, category: "CapEx" },
+    ];
+    const financing = input.financing || [
+        { description: "Loan Repayment", amount: -5000, category: "Debt" },
+        { description: "Owner Distribution", amount: -10000, category: "Distribution" },
+    ];
+    const totalOpIn = round(opIn.reduce((s, i) => s + i.amount, 0));
+    const totalOpOut = round(opOut.reduce((s, i) => s + i.amount, 0));
+    const netOperating = round(totalOpIn - totalOpOut);
+    const netInvesting = round(investing.reduce((s, i) => s + i.amount, 0));
+    const netFinancing = round(financing.reduce((s, i) => s + i.amount, 0));
+    const netChange = round(netOperating + netInvesting + netFinancing);
+    const endingBal = round(beginBal + netChange);
+    const csv = [
+        "CASH FLOW STATEMENT",
+        `Period: ${period}`,
+        `Generated: ${new Date().toISOString().split("T")[0]}`,
+        "",
+        "OPERATING ACTIVITIES",
+        "Cash Inflows:",
+        "Description,Amount,Category",
+        ...opIn.map(i => `${esc(i.description)},${fmt(i.amount)},${i.category}`),
+        `Total Cash Inflows,${fmt(totalOpIn)},`,
+        "",
+        "Cash Outflows:",
+        "Description,Amount,Category",
+        ...opOut.map(i => `${esc(i.description)},${fmt(i.amount)},${i.category}`),
+        `Total Cash Outflows,${fmt(totalOpOut)},`,
+        "",
+        `Net Cash from Operations,${fmt(netOperating)},`,
+        "",
+        "INVESTING ACTIVITIES",
+        "Description,Amount,Category",
+        ...investing.map(i => `${esc(i.description)},${fmt(i.amount)},${i.category}`),
+        `Net Cash from Investing,${fmt(netInvesting)},`,
+        "",
+        "FINANCING ACTIVITIES",
+        "Description,Amount,Category",
+        ...financing.map(i => `${esc(i.description)},${fmt(i.amount)},${i.category}`),
+        `Net Cash from Financing,${fmt(netFinancing)},`,
+        "",
+        "CASH POSITION",
+        `Beginning Balance,${fmt(beginBal)}`,
+        `Net Change in Cash,${fmt(netChange)}`,
+        `Ending Balance,${fmt(endingBal)}`,
+        "",
+        "SUMMARY",
+        `Operating,${fmt(netOperating)},${netOperating >= 0 ? "Positive" : "Negative"}`,
+        `Investing,${fmt(netInvesting)},${netInvesting >= 0 ? "Positive" : "Negative"}`,
+        `Financing,${fmt(netFinancing)},${netFinancing >= 0 ? "Positive" : "Negative"}`,
+        `Net Change,${fmt(netChange)},${netChange >= 0 ? "Cash Increased" : "Cash Decreased"}`,
+    ];
+    return {
+        text: `Cash Flow: Operating ${fmt(netOperating)} | Investing ${fmt(netInvesting)} | Financing ${fmt(netFinancing)} | Net ${fmt(netChange)} | Ending ${fmt(endingBal)}`,
+        output_csv: csv.join("\n"),
+        summary: { beginning_balance: beginBal, net_operating: netOperating, net_investing: netInvesting, net_financing: netFinancing, net_change: netChange, ending_balance: endingBal },
+        chart_data: { chart_type: "bar", title: `Cash Flow — ${period}`, labels: ["Operating", "Investing", "Financing", "Net Change"], datasets: [{ label: "Cash Flow", data: [netOperating, netInvesting, netFinancing, netChange] }] },
+        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/chat.d.ts

@@ -0,0 +1,5 @@
+import type { TaskInput, TaskOutput } from "./index.js";
+/**
+ * Chat handler — processes conversational messages AND triggers actions.
+ */
+export declare function handleChat(task: TaskInput): Promise<TaskOutput>;