neuronix-node 0.2.0 → 0.5.0

package/dist/handlers/chat.js

@@ -0,0 +1,336 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleChat = handleChat;
+const inference_js_1 = require("../inference.js");
+// Import all action handlers
+const chart_js_1 = require("./chart.js");
+const invoice_js_1 = require("./invoice.js");
+const expense_js_1 = require("./expense.js");
+const pnl_js_1 = require("./pnl.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");
+// Intent detection patterns — maps user language to handler actions
+const INTENT_PATTERNS = [
+    // Expense report
+    { pattern: /\b(expense report|expense summary|categorize expenses|expense breakdown|spending report)\b/i, action: "expense_report", handler: "expense_report", description: "generating an expense report" },
+    // P&L
+    { pattern: /\b(p&l|profit.?(?:and|&)?.?loss|income statement|net income|profit margin)\b/i, action: "pnl", handler: "pnl", description: "generating a Profit & Loss statement" },
+    // Invoice
+    { pattern: /\b(create invoice|generate invoice|make (?:an )?invoice|send invoice|bill (?:the )?client)\b/i, action: "invoice", handler: "invoice", description: "creating an invoice" },
+    // Chart
+    { pattern: /\b(make (?:a |me )?chart|create (?:a )?(?:chart|graph|plot)|bar chart|pie chart|line chart|visualize|visualization)\b/i, action: "chart", handler: "chart", description: "creating a chart" },
+    // AR Aging
+    { pattern: /\b(ar aging|accounts receivable|who owes|outstanding invoices|overdue invoices|collections|receivables aging)\b/i, action: "ar_aging", handler: "ar_aging", description: "generating an Accounts Receivable aging report" },
+    // AP Aging
+    { pattern: /\b(ap aging|accounts payable|what (?:do )?we owe|outstanding bills|overdue bills|vendor payments|payables aging)\b/i, action: "ap_aging", handler: "ap_aging", description: "generating an Accounts Payable aging report" },
+    // Bank Reconciliation
+    { pattern: /\b(bank rec|reconcil|match.?(?:bank|transactions)|bank statement|reconcile (?:the )?bank)\b/i, action: "bank_reconciliation", handler: "bank_reconciliation", description: "running a bank reconciliation" },
+    // Budget vs Actuals
+    { pattern: /\b(budget vs|budget.?actual|over budget|under budget|budget comparison|budget review|spending vs budget)\b/i, action: "budget_vs_actuals", handler: "budget_vs_actuals", description: "comparing budget vs actuals" },
+    // Payroll
+    { pattern: /\b(run payroll|payroll calc|process payroll|payroll register|employee pay|calculate payroll|pay (?:the )?employees)\b/i, action: "payroll", handler: "payroll", description: "running payroll calculations" },
+    // Sales Tax
+    { pattern: /\b(sales tax|tax collected|tax filing|tax report|tax liability|state tax)\b/i, action: "sales_tax", handler: "sales_tax", description: "calculating sales tax" },
+    // Depreciation
+    { pattern: /\b(depreciation|fixed asset|book value|asset schedule|depreciate)\b/i, action: "depreciation", handler: "depreciation", description: "calculating depreciation" },
+    // Cash Flow
+    { pattern: /\b(cash flow|cash position|cash statement|operating cash|where.?(?:is|did) (?:the |our )?(?:cash|money))\b/i, action: "cash_flow", handler: "cash_flow", description: "generating a cash flow statement" },
+    // Department Spending
+    { pattern: /\b(department spending|spending by department|departmental|team spending|which department|cost center)\b/i, action: "department_spending", handler: "department_spending", description: "generating a department spending report" },
+    // Variance Analysis
+    { pattern: /\b(variance|significant.?difference|budget.?deviation|why.?(?:is|are|did).?(?:we|it).?(?:over|under|different))\b/i, action: "variance_analysis", handler: "variance_analysis", description: "running a variance analysis" },
+    // W-2/1099
+    { pattern: /\b(w-?2|1099|year.?end.?tax|tax.?form|issue.?w2|file.?1099|annual.?tax)\b/i, action: "w2_1099", handler: "w2_1099", description: "compiling W-2 and 1099 data" },
+];
+// Map action names to handler functions
+const ACTION_HANDLERS = {
+    expense_report: expense_js_1.handleExpenseReport,
+    pnl: pnl_js_1.handlePnl,
+    invoice: invoice_js_1.handleInvoice,
+    chart: chart_js_1.handleChart,
+    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,
+};
+/**
+ * Detect what the user wants to do from their message.
+ */
+function detectIntent(messages) {
+    // Check the last user message
+    const lastUser = [...messages].reverse().find(m => m.role === "user");
+    if (!lastUser)
+        return null;
+    const text = lastUser.content;
+    for (const intent of INTENT_PATTERNS) {
+        if (intent.pattern.test(text)) {
+            return { action: intent.action, handler: intent.handler, description: intent.description };
+        }
+    }
+    return null;
+}
+/**
+ * Chat handler — processes conversational messages AND triggers actions.
+ */
+async function handleChat(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const messages = input.messages || [];
+    // Step 1: Detect if the user wants an action
+    const intent = detectIntent(messages);
+    if (intent) {
+        // User wants something done — run the handler
+        const handler = ACTION_HANDLERS[intent.action];
+        if (handler) {
+            try {
+                const actionResult = await handler({
+                    type: intent.action,
+                    input_payload: task.input_payload,
+                });
+                // Build a natural response that includes the action result
+                const responseText = buildActionResponse(intent, actionResult);
+                return {
+                    text: responseText,
+                    content: responseText,
+                    action_taken: intent.action,
+                    action_description: intent.description,
+                    action_result: actionResult,
+                    // Pass through output_csv so it gets saved as a file
+                    output_csv: actionResult.output_csv,
+                    image_base64: actionResult.image_base64,
+                    invoice_html: actionResult.invoice_html,
+                    conversation_id: input.conversation_id,
+                    deployment_id: input.deployment_id,
+                    duration_ms: Date.now() - start,
+                };
+            }
+            catch (err) {
+                const durationMs = Date.now() - start;
+                return {
+                    text: `I tried ${intent.description} but ran into an error: ${err}. Could you check the data and try again?`,
+                    content: `I tried ${intent.description} but ran into an error: ${err}. Could you check the data and try again?`,
+                    action_taken: intent.action,
+                    action_error: String(err),
+                    conversation_id: input.conversation_id,
+                    deployment_id: input.deployment_id,
+                    duration_ms: durationMs,
+                };
+            }
+        }
+    }
+    // Step 2: No action detected — regular conversation
+    // Try LLM for conversational response
+    const modelIds = ["llama3-8b", "mistral-7b", "phi-2", "tinyllama-1.1b"];
+    const loadedModel = modelIds.find((id) => (0, inference_js_1.isModelLoaded)(id));
+    if (!loadedModel) {
+        // No model loaded — provide a helpful static response
+        const helpText = generateHelpResponse(messages);
+        return {
+            text: helpText,
+            content: helpText,
+            conversation_id: input.conversation_id,
+            deployment_id: input.deployment_id,
+            duration_ms: Date.now() - start,
+        };
+    }
+    try {
+        const prompt = formatConversation(messages);
+        const { text, durationMs } = await (0, inference_js_1.runInference)(loadedModel, prompt, input.max_tokens || 512);
+        const cleanedText = cleanResponse(text);
+        // Check for preference updates
+        const memoryUpdates = detectPreferences(messages);
+        let finalText = cleanedText;
+        if (memoryUpdates.length > 0) {
+            finalText += "\n" + memoryUpdates.map(m => `[MEMORY_UPDATE]${m.key}: ${m.value}[/MEMORY_UPDATE]`).join("\n");
+        }
+        return {
+            text: finalText,
+            content: finalText,
+            conversation_id: input.conversation_id,
+            deployment_id: input.deployment_id,
+            model: loadedModel,
+            duration_ms: durationMs,
+        };
+    }
+    catch {
+        const helpText = generateHelpResponse(messages);
+        return {
+            text: helpText,
+            content: helpText,
+            conversation_id: input.conversation_id,
+            deployment_id: input.deployment_id,
+            duration_ms: Date.now() - start,
+        };
+    }
+}
+/**
+ * Build a natural language response after running an action.
+ */
+function buildActionResponse(intent, result) {
+    const summary = result.summary;
+    const parts = [];
+    parts.push(`Done — I've finished ${intent.description}.`);
+    // Add key stats from the result
+    switch (intent.action) {
+        case "expense_report":
+            if (summary)
+                parts.push(`\nTotal expenses: $${summary.total?.toLocaleString() || "N/A"} across ${summary.expense_count || 0} items in ${summary.category_count || 0} categories.`);
+            break;
+        case "pnl":
+            if (summary)
+                parts.push(`\nRevenue: $${summary.revenue_total?.toLocaleString() || "0"} | Expenses: $${summary.expense_total?.toLocaleString() || "0"} | Net Income: $${summary.net_income?.toLocaleString() || "0"} (${summary.margin_pct || 0}% margin)`);
+            break;
+        case "invoice":
+            if (result.total)
+                parts.push(`\nInvoice ${result.invoice_number || ""} for $${result.total?.toLocaleString() || "0"}, due ${result.due_date || "in 30 days"}.`);
+            break;
+        case "ar_aging":
+            if (summary)
+                parts.push(`\nTotal outstanding: $${summary.total_outstanding?.toLocaleString() || "0"} across ${summary.customer_count || 0} customers.`);
+            break;
+        case "ap_aging":
+            if (summary)
+                parts.push(`\nTotal owed: $${summary.total_owed?.toLocaleString() || "0"} across ${summary.vendor_count || 0} vendors.`);
+            break;
+        case "bank_reconciliation":
+            if (summary)
+                parts.push(`\n${summary.reconciled ? "The accounts are reconciled." : `There's a difference of $${summary.difference?.toLocaleString() || "0"} that needs review.`} Matched ${summary.matched_count || 0} transactions.`);
+            break;
+        case "budget_vs_actuals":
+            if (summary)
+                parts.push(`\nBudget: $${summary.total_budget?.toLocaleString() || "0"} | Actual: $${summary.total_actual?.toLocaleString() || "0"} | Variance: ${summary.total_variance >= 0 ? "+" : ""}$${summary.total_variance?.toLocaleString() || "0"} (${summary.total_variance_pct || 0}%)`);
+            break;
+        case "payroll":
+            if (summary)
+                parts.push(`\n${summary.employee_count || 0} employees | Gross: $${summary.total_gross?.toLocaleString() || "0"} | Net: $${summary.total_net?.toLocaleString() || "0"} | Employer cost: $${summary.employer_cost?.toLocaleString() || "0"}`);
+            break;
+        case "sales_tax":
+            if (summary)
+                parts.push(`\nTax collected: $${summary.total_tax?.toLocaleString() || "0"} on $${summary.total_taxable?.toLocaleString() || "0"} taxable sales across ${summary.jurisdictions || 0} jurisdictions.`);
+            break;
+        case "depreciation":
+            if (summary)
+                parts.push(`\n${summary.asset_count || 0} assets | Book value: $${summary.total_book_value?.toLocaleString() || "0"} | This year's depreciation: $${summary.current_year?.toLocaleString() || "0"}`);
+            break;
+        case "cash_flow":
+            if (summary)
+                parts.push(`\nOperating: $${summary.net_operating?.toLocaleString() || "0"} | Investing: $${summary.net_investing?.toLocaleString() || "0"} | Financing: $${summary.net_financing?.toLocaleString() || "0"} | Ending balance: $${summary.ending_balance?.toLocaleString() || "0"}`);
+            break;
+        case "department_spending":
+            if (summary)
+                parts.push(`\n${summary.department_count || 0} departments | Total: $${summary.grand_total?.toLocaleString() || "0"}`);
+            break;
+        case "variance_analysis":
+            if (summary)
+                parts.push(`\n${summary.significant_count || 0} significant variances found. ${summary.favorable_count || 0} favorable, ${summary.unfavorable_count || 0} unfavorable.`);
+            break;
+        case "w2_1099":
+            if (summary)
+                parts.push(`\n${summary.w2_count || 0} W-2s and ${summary.contractor_count || 0} 1099s to issue. Filing deadline: ${summary.filing_deadline || "January 31"}.`);
+            break;
+        case "chart":
+            parts.push(`\nThe chart has been generated.`);
+            break;
+    }
+    if (result.output_csv) {
+        parts.push("\nThe report has been saved to your outputs folder. You can download it from the Files tab.");
+    }
+    parts.push("\nAnything else you need?");
+    return parts.join("");
+}
+/**
+ * Generate a helpful response when no LLM is available.
+ */
+function generateHelpResponse(messages) {
+    const lastUser = [...messages].reverse().find(m => m.role === "user");
+    const userText = lastUser?.content.toLowerCase() || "";
+    if (/help|what can you do|capabilities/.test(userText)) {
+        return `Here's what I can do for you. Just ask in plain English:
+
+• "Run my expense report" — categorize and summarize expenses
+• "Generate a P&L" — Profit & Loss statement
+• "Create an invoice" — generate a formatted invoice
+• "Run payroll" — calculate gross, taxes, deductions, net pay
+• "Show me AR aging" — who owes money and how overdue
+• "Show me AP aging" — what we owe vendors
+• "Reconcile the bank" — match bank vs book transactions
+• "Budget vs actuals" — compare spending to budget
+• "Calculate sales tax" — multi-state tax tracking
+• "Depreciation schedule" — fixed asset depreciation
+• "Cash flow statement" — operating/investing/financing
+• "Department spending" — spending by department
+• "Variance analysis" — find significant budget variances
+• "W-2 and 1099 prep" — year-end tax form compilation
+• "Make a chart" — visualize any data
+
+Just tell me what you need!`;
+    }
+    if (/hi|hello|hey/.test(userText)) {
+        return "Hi! I'm your accounting bot. I can run reports, calculate payroll, reconcile accounts, and more. Just tell me what you need — for example, \"run my expense report\" or \"show me the P&L.\"";
+    }
+    return "I can help with that. Try asking me to run a specific report like \"expense report\", \"P&L\", \"payroll\", or \"AR aging\". Type \"help\" to see everything I can do.";
+}
+function formatConversation(messages) {
+    const parts = [];
+    for (const msg of messages) {
+        if (msg.role === "system")
+            parts.push(`Instructions: ${msg.content}\n`);
+        else if (msg.role === "user")
+            parts.push(`User: ${msg.content}`);
+        else if (msg.role === "assistant")
+            parts.push(`Assistant: ${msg.content}`);
+    }
+    parts.push("Assistant:");
+    return parts.join("\n");
+}
+function cleanResponse(text) {
+    let cleaned = text.trim();
+    const userIdx = cleaned.indexOf("\nUser:");
+    if (userIdx > 0)
+        cleaned = cleaned.slice(0, userIdx).trim();
+    if (cleaned.startsWith("Assistant:"))
+        cleaned = cleaned.slice(10).trim();
+    if (cleaned.length > 2000)
+        cleaned = cleaned.slice(0, 2000) + "...";
+    return cleaned || "I understand. How can I help you?";
+}
+function detectPreferences(messages) {
+    const updates = [];
+    const lastUser = messages.filter(m => m.role === "user").pop();
+    if (!lastUser)
+        return updates;
+    const lower = lastUser.content.toLowerCase();
+    if (/always sort|sort by|order by/.test(lower)) {
+        const match = lower.match(/sort (?:by|expenses by) (\w+)/);
+        if (match)
+            updates.push({ key: "sort_preference", value: match[1] });
+    }
+    if (/always include|i want|i prefer|i like/.test(lower)) {
+        if (/department/.test(lower))
+            updates.push({ key: "include_departments", value: "true" });
+        if (/chart/.test(lower))
+            updates.push({ key: "include_charts", value: "true" });
+    }
+    if (/my company|our company|we are|i work at/.test(lower)) {
+        const match = lower.match(/(?:company is|work at|we are) ([^,.]+)/);
+        if (match)
+            updates.push({ key: "company_name", value: match[1].trim() });
+    }
+    return updates;
+}

package/dist/handlers/department-spending.d.ts

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

package/dist/handlers/department-spending.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDepartmentSpending = handleDepartmentSpending;
+async function handleDepartmentSpending(task) {
+    const start = Date.now();
+    const input = task.input_payload;
+    const period = input.period || "Current Period";
+    const expenses = input.expenses || [
+        { department: "Engineering", category: "Salaries", amount: 85000 },
+        { department: "Engineering", category: "Software", amount: 12000 },
+        { department: "Engineering", category: "Hardware", amount: 8500 },
+        { department: "Marketing", category: "Salaries", amount: 45000 },
+        { department: "Marketing", category: "Advertising", amount: 25000 },
+        { department: "Marketing", category: "Events", amount: 8000 },
+        { department: "Sales", category: "Salaries", amount: 62000 },
+        { department: "Sales", category: "Travel", amount: 15000 },
+        { department: "Sales", category: "Entertainment", amount: 5000 },
+        { department: "Operations", category: "Rent", amount: 8500 },
+        { department: "Operations", category: "Utilities", amount: 2500 },
+        { department: "Operations", category: "Supplies", amount: 1800 },
+        { department: "HR", category: "Salaries", amount: 35000 },
+        { department: "HR", category: "Benefits Admin", amount: 4500 },
+        { department: "HR", category: "Recruiting", amount: 7500 },
+    ];
+    let grandTotal = 0;
+    const byDept = {};
+    for (const exp of expenses) {
+        grandTotal += exp.amount;
+        if (!byDept[exp.department])
+            byDept[exp.department] = { total: 0, categories: {}, count: 0 };
+        byDept[exp.department].total += exp.amount;
+        byDept[exp.department].count += 1;
+        byDept[exp.department].categories[exp.category] = (byDept[exp.department].categories[exp.category] || 0) + exp.amount;
+    }
+    grandTotal = round(grandTotal);
+    const deptSummary = Object.entries(byDept)
+        .sort((a, b) => b[1].total - a[1].total)
+        .map(([name, data]) => ({
+        department: name,
+        total: round(data.total),
+        pct: round((data.total / grandTotal) * 100),
+        count: data.count,
+        categories: Object.entries(data.categories).sort((a, b) => b[1] - a[1]).map(([cat, amt]) => ({ category: cat, amount: round(amt) })),
+    }));
+    const csv = [
+        "DEPARTMENT SPENDING REPORT",
+        `Period: ${period}`,
+        `Generated: ${new Date().toISOString().split("T")[0]}`,
+        `Grand Total: ${fmt(grandTotal)}`,
+        "",
+        "SUMMARY BY DEPARTMENT",
+        "Department,Total Spending,% of Total,Line Items",
+        ...deptSummary.map(d => `${esc(d.department)},${fmt(d.total)},${d.pct}%,${d.count}`),
+        "",
+    ];
+    // Add breakdown for each department
+    for (const dept of deptSummary) {
+        csv.push(`${dept.department.toUpperCase()} BREAKDOWN`);
+        csv.push("Category,Amount,% of Department");
+        for (const cat of dept.categories) {
+            csv.push(`${esc(cat.category)},${fmt(cat.amount)},${round((cat.amount / dept.total) * 100)}%`);
+        }
+        csv.push(`Department Total,${fmt(dept.total)},100%`);
+        csv.push("");
+    }
+    csv.push("GRAND TOTAL");
+    csv.push(`Total All Departments,${fmt(grandTotal)}`);
+    csv.push(`Total Departments,${deptSummary.length}`);
+    csv.push(`Total Line Items,${expenses.length}`);
+    csv.push(`Largest Department,${deptSummary[0]?.department || "N/A"} (${fmt(deptSummary[0]?.total || 0)})`);
+    csv.push(`Smallest Department,${deptSummary[deptSummary.length - 1]?.department || "N/A"} (${fmt(deptSummary[deptSummary.length - 1]?.total || 0)})`);
+    return {
+        text: `Department Spending: ${deptSummary.length} departments | Total: ${fmt(grandTotal)} | Largest: ${deptSummary[0]?.department}`,
+        output_csv: csv.join("\n"),
+        summary: { grand_total: grandTotal, department_count: deptSummary.length },
+        by_department: deptSummary,
+        chart_data: { chart_type: "pie", title: `Spending by Department — ${period}`, labels: deptSummary.map(d => d.department), datasets: [{ label: "Spending", data: deptSummary.map(d => d.total) }] },
+        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/depreciation.d.ts

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

package/dist/handlers/depreciation.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleDepreciation = handleDepreciation;
+async function handleDepreciation(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 assets = input.assets || [
+        { name: "Office Furniture", cost: 15000, salvage_value: 1500, useful_life_years: 7, date_acquired: "2023-06-15", method: "straight-line" },
+        { name: "MacBook Pro Fleet (10)", cost: 35000, salvage_value: 5000, useful_life_years: 3, date_acquired: "2025-01-10", method: "straight-line" },
+        { name: "Server Equipment", cost: 28000, salvage_value: 3000, useful_life_years: 5, date_acquired: "2024-03-01", method: "double-declining" },
+        { name: "Company Vehicle", cost: 42000, salvage_value: 8000, useful_life_years: 5, date_acquired: "2024-09-01", method: "straight-line" },
+        { name: "HVAC System", cost: 18000, salvage_value: 2000, useful_life_years: 10, date_acquired: "2022-01-01", method: "straight-line" },
+    ];
+    let totalCost = 0, totalAccumDep = 0, totalCurrentYearDep = 0;
+    const schedule = assets.map(asset => {
+        const method = asset.method || "straight-line";
+        const depreciable = asset.cost - asset.salvage_value;
+        const acquired = new Date(asset.date_acquired);
+        const monthsOwned = Math.max(0, (asOf.getFullYear() - acquired.getFullYear()) * 12 + (asOf.getMonth() - acquired.getMonth()));
+        const yearsOwned = monthsOwned / 12;
+        let annualDep;
+        let accumDep;
+        let currentYearDep;
+        if (method === "straight-line") {
+            annualDep = round(depreciable / asset.useful_life_years);
+            accumDep = round(Math.min(annualDep * yearsOwned, depreciable));
+            currentYearDep = yearsOwned >= asset.useful_life_years ? 0 : annualDep;
+        }
+        else {
+            // Double declining balance
+            const rate = 2 / asset.useful_life_years;
+            let bookValue = asset.cost;
+            accumDep = 0;
+            currentYearDep = 0;
+            for (let y = 0; y < Math.ceil(yearsOwned); y++) {
+                const dep = Math.min(round(bookValue * rate), bookValue - asset.salvage_value);
+                if (dep <= 0)
+                    break;
+                if (y < Math.floor(yearsOwned)) {
+                    accumDep += dep;
+                    bookValue -= dep;
+                }
+                if (y === Math.floor(yearsOwned)) {
+                    currentYearDep = dep;
+                }
+            }
+            annualDep = round(asset.cost * (2 / asset.useful_life_years));
+            accumDep = round(accumDep);
+        }
+        const bookValue = round(asset.cost - accumDep);
+        const fullyDepreciated = accumDep >= depreciable;
+        const remainingLife = Math.max(0, round(asset.useful_life_years - yearsOwned));
+        totalCost += asset.cost;
+        totalAccumDep += accumDep;
+        totalCurrentYearDep += currentYearDep;
+        return { name: asset.name, cost: asset.cost, salvage: asset.salvage_value, useful_life: asset.useful_life_years, method, date_acquired: asset.date_acquired, annual_depreciation: annualDep, accumulated_depreciation: accumDep, current_year_depreciation: round(currentYearDep), book_value: bookValue, remaining_life: remainingLife, fully_depreciated: fullyDepreciated };
+    });
+    totalCost = round(totalCost);
+    totalAccumDep = round(totalAccumDep);
+    totalCurrentYearDep = round(totalCurrentYearDep);
+    const totalBookValue = round(totalCost - totalAccumDep);
+    const csv = [
+        "DEPRECIATION SCHEDULE",
+        `As of: ${asOf.toISOString().split("T")[0]}`,
+        "",
+        "ASSET DETAIL",
+        "Asset,Cost,Salvage,Useful Life,Method,Date Acquired,Annual Dep,Accum Dep,Book Value,Remaining Life,Status",
+        ...schedule.map(a => `${esc(a.name)},${fmt(a.cost)},${fmt(a.salvage)},${a.useful_life} yr,${a.method},${a.date_acquired},${fmt(a.annual_depreciation)},${fmt(a.accumulated_depreciation)},${fmt(a.book_value)},${a.remaining_life.toFixed(1)} yr,${a.fully_depreciated ? "Fully Depreciated" : "Active"}`),
+        "",
+        "CURRENT YEAR DEPRECIATION EXPENSE",
+        "Asset,Current Year Depreciation",
+        ...schedule.filter(a => a.current_year_depreciation > 0).map(a => `${esc(a.name)},${fmt(a.current_year_depreciation)}`),
+        `Total Current Year,${fmt(totalCurrentYearDep)}`,
+        "",
+        "SUMMARY",
+        `Total Asset Cost,${fmt(totalCost)}`,
+        `Total Accumulated Depreciation,${fmt(totalAccumDep)}`,
+        `Total Book Value,${fmt(totalBookValue)}`,
+        `Current Year Depreciation Expense,${fmt(totalCurrentYearDep)}`,
+        `Active Assets,${schedule.filter(a => !a.fully_depreciated).length}`,
+        `Fully Depreciated Assets,${schedule.filter(a => a.fully_depreciated).length}`,
+    ];
+    return {
+        text: `Depreciation Schedule: ${schedule.length} assets | Book Value: ${fmt(totalBookValue)} | Current Year: ${fmt(totalCurrentYearDep)}`,
+        output_csv: csv.join("\n"),
+        summary: { total_cost: totalCost, total_accum_dep: totalAccumDep, total_book_value: totalBookValue, current_year: totalCurrentYearDep, asset_count: schedule.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; }