neuronix-node 0.2.0 → 0.5.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.js

@@ -29,7 +29,7 @@ async function handleFileProcess(task) {
             if (expenses.length > 0) {
                 const result = await (0, expense_js_1.handleExpenseReport)({
                     type: "expense_report",
-                    input_payload: { expenses },
+                    input_payload: { expenses, merged_from: payload.merged_from },
                 });
                 return {
                     ...result,

package/dist/handlers/index.d.ts

@@ -9,12 +9,6 @@ export interface TaskOutput {
 }
 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 };

package/dist/handlers/index.js

@@ -9,24 +9,44 @@ const expense_js_1 = require("./expense.js");
 const pnl_js_1 = require("./pnl.js");
 const smart_route_js_1 = require("./smart-route.js");
 const file_processor_js_1 = require("./file-processor.js");
+const chat_js_1 = require("./chat.js");
+const ar_aging_js_1 = require("./ar-aging.js");
+const ap_aging_js_1 = require("./ap-aging.js");
+const bank_reconciliation_js_1 = require("./bank-reconciliation.js");
+const budget_vs_actuals_js_1 = require("./budget-vs-actuals.js");
+const payroll_js_1 = require("./payroll.js");
+const sales_tax_js_1 = require("./sales-tax.js");
+const depreciation_js_1 = require("./depreciation.js");
+const cash_flow_js_1 = require("./cash-flow.js");
+const department_spending_js_1 = require("./department-spending.js");
+const variance_analysis_js_1 = require("./variance-analysis.js");
+const w2_1099_js_1 = require("./w2-1099.js");
 const handlers = {
+    // Original handlers
     chart: chart_js_1.handleChart,
     invoice: invoice_js_1.handleInvoice,
     expense_report: expense_js_1.handleExpenseReport,
     pnl: pnl_js_1.handlePnl,
     smart_route: smart_route_js_1.handleSmartRoute,
     process_file: file_processor_js_1.handleFileProcess,
+    chat: chat_js_1.handleChat,
+    // Tier 1 accounting handlers
+    ar_aging: ar_aging_js_1.handleARAging,
+    ap_aging: ap_aging_js_1.handleAPAging,
+    bank_reconciliation: bank_reconciliation_js_1.handleBankReconciliation,
+    budget_vs_actuals: budget_vs_actuals_js_1.handleBudgetVsActuals,
+    payroll: payroll_js_1.handlePayroll,
+    sales_tax: sales_tax_js_1.handleSalesTax,
+    depreciation: depreciation_js_1.handleDepreciation,
+    cash_flow: cash_flow_js_1.handleCashFlow,
+    department_spending: department_spending_js_1.handleDepartmentSpending,
+    variance_analysis: variance_analysis_js_1.handleVarianceAnalysis,
+    w2_1099: w2_1099_js_1.handleW21099,
 };
 exports.handlers = handlers;
-/**
- * Check if we have a specialized handler for this task type.
- */
 function hasHandler(type) {
     return type in handlers;
 }
-/**
- * Run the specialized handler for a task type.
- */
 async function runHandler(task) {
     const handler = handlers[task.type];
     if (!handler) {

package/dist/handlers/payroll.d.ts

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

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>;