ray-finance 0.1.0

package/dist/queries/index.d.ts

@@ -0,0 +1,163 @@
+import type BetterSqlite3 from "libsql";
+type Database = BetterSqlite3.Database;
+export interface BudgetStatus {
+    category: string;
+    budget: number;
+    spent: number;
+    remaining: number;
+    pct_used: number;
+    over_budget: boolean;
+}
+export interface GoalStatus {
+    name: string;
+    target: number;
+    current: number;
+    remaining: number;
+    progress_pct: number;
+    target_date: string | null;
+    monthly_needed: number;
+}
+export interface TransactionFilters {
+    startDate?: string;
+    endDate?: string;
+    category?: string;
+    merchant?: string;
+    minAmount?: number;
+    maxAmount?: number;
+    limit?: number;
+}
+export declare function getNetWorth(db: Database): {
+    net_worth: number;
+    assets: number;
+    liabilities: number;
+    home_value: number;
+    home_equity: number;
+    investments: number;
+    cash: number;
+    credit_debt: number;
+    mortgage: number;
+    prev_net_worth: number | null;
+};
+export declare function getAccountBalances(db: Database): {
+    name: string;
+    balance: number;
+    type: string;
+}[];
+export declare function getBudgetStatuses(db: Database): BudgetStatus[];
+export declare function getGoals(db: Database): GoalStatus[];
+export declare function getCashFlowThisMonth(db: Database): {
+    income: number;
+    expenses: number;
+    net: number;
+};
+export declare function getRecentSpending(db: Database): {
+    category: string;
+    total: number;
+}[];
+export declare function getRecentTransactions(db: Database, limit?: number): {
+    name: string;
+    amount: number;
+    category: string;
+    date: string;
+    pending: number;
+}[];
+export declare function getTransactionsFiltered(db: Database, filters: TransactionFilters): {
+    transaction_id: string;
+    name: string;
+    merchant_name: string | null;
+    amount: number;
+    category: string;
+    date: string;
+    pending: number;
+}[];
+export declare function getIncome(db: Database, startDate: string, endDate: string): {
+    source: string;
+    total: number;
+    count: number;
+}[];
+export declare function searchTransactions(db: Database, query: string, limit?: number): {
+    transaction_id: string;
+    name: string;
+    merchant_name: string | null;
+    amount: number;
+    category: string;
+    date: string;
+}[];
+export declare function getCashFlow(db: Database, startDate: string, endDate: string): {
+    income: number;
+    expenses: number;
+    net: number;
+    savingsRate: number;
+    monthly: {
+        month: string;
+        income: number;
+        expenses: number;
+        net: number;
+    }[];
+};
+export declare function forecastBalance(db: Database, accountId?: string, months?: number): {
+    currentBalance: number;
+    projections: {
+        month: string;
+        projected: number;
+    }[];
+    avgMonthlyInflow: number;
+    avgMonthlyOutflow: number;
+};
+export declare function getPortfolio(db: Database): {
+    totalValue: number;
+    totalCostBasis: number;
+    totalGainLoss: number;
+    holdings: {
+        account: string;
+        security: string;
+        ticker: string;
+        quantity: number;
+        value: number;
+        costBasis: number;
+        gainLoss: number;
+    }[];
+};
+export declare function getInvestmentPerformance(db: Database): {
+    totalReturn: number;
+    totalReturnPct: number;
+    holdings: {
+        security: string;
+        ticker: string;
+        value: number;
+        costBasis: number;
+        returnPct: number;
+    }[];
+};
+export declare function getDebts(db: Database): {
+    totalDebt: number;
+    debts: {
+        name: string;
+        balance: number;
+        rate: number;
+        minPayment: number;
+        type: string;
+        nextDue: string | null;
+    }[];
+};
+export declare function compareSpending(db: Database, period1Start: string, period1End: string, period2Start: string, period2End: string): {
+    period1Total: number;
+    period2Total: number;
+    difference: number;
+    pctChange: number;
+    categories: {
+        category: string;
+        period1: number;
+        period2: number;
+        diff: number;
+    }[];
+};
+export declare function getNetWorthTrend(db: Database, limit?: number): {
+    date: string;
+    net_worth: number;
+    assets: number;
+    liabilities: number;
+}[];
+export declare function formatMoney(n: number): string;
+export declare function categoryLabel(cat: string): string;
+export {};

package/dist/queries/index.js

@@ -0,0 +1,411 @@
+export function getNetWorth(db) {
+    const home = db
+        .prepare(`SELECT current_balance as value FROM accounts WHERE type = 'other' AND subtype = 'property' LIMIT 1`)
+        .get();
+    const mortgage = db
+        .prepare(`SELECT current_balance as value FROM accounts WHERE type = 'loan' AND subtype = 'mortgage' LIMIT 1`)
+        .get();
+    const investments = db
+        .prepare(`SELECT COALESCE(SUM(current_balance), 0) as total FROM accounts WHERE type = 'investment'`)
+        .get();
+    const cash = db
+        .prepare(`SELECT COALESCE(SUM(current_balance), 0) as total FROM accounts WHERE type = 'depository'`)
+        .get();
+    const credit = db
+        .prepare(`SELECT COALESCE(SUM(current_balance), 0) as total FROM accounts WHERE type = 'credit'`)
+        .get();
+    const assets = db
+        .prepare(`SELECT COALESCE(SUM(current_balance), 0) as total FROM accounts WHERE type IN ('depository', 'investment', 'other')`)
+        .get();
+    const liabilities = db
+        .prepare(`SELECT COALESCE(SUM(current_balance), 0) as total FROM accounts WHERE type IN ('credit', 'loan')`)
+        .get();
+    // Previous day's net worth
+    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString().slice(0, 10);
+    const prev = db
+        .prepare(`SELECT net_worth FROM net_worth_history WHERE date <= ? ORDER BY date DESC LIMIT 1`)
+        .get(yesterday);
+    const homeVal = home?.value || 0;
+    const mortgageVal = mortgage?.value || 0;
+    return {
+        net_worth: assets.total - liabilities.total,
+        assets: assets.total,
+        liabilities: liabilities.total,
+        home_value: homeVal,
+        home_equity: homeVal - mortgageVal,
+        investments: investments.total,
+        cash: cash.total,
+        credit_debt: credit.total,
+        mortgage: mortgageVal,
+        prev_net_worth: prev?.net_worth ?? null,
+    };
+}
+export function getAccountBalances(db) {
+    return db
+        .prepare(`SELECT name, current_balance as balance, type FROM accounts
+       WHERE type IN ('depository', 'credit') ORDER BY type, current_balance DESC`)
+        .all();
+}
+export function getBudgetStatuses(db) {
+    const now = new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1)
+        .toISOString()
+        .slice(0, 10);
+    const today = now.toISOString().slice(0, 10);
+    const budgets = db
+        .prepare(`SELECT category, monthly_limit FROM budgets`)
+        .all();
+    return budgets.map((b) => {
+        const spent = db
+            .prepare(`SELECT COALESCE(SUM(amount), 0) as total FROM transactions
+         WHERE category = ? AND date BETWEEN ? AND ? AND amount > 0 AND pending = 0`)
+            .get(b.category, monthStart, today);
+        const remaining = b.monthly_limit - spent.total;
+        return {
+            category: b.category,
+            budget: b.monthly_limit,
+            spent: Math.round(spent.total * 100) / 100,
+            remaining: Math.round(remaining * 100) / 100,
+            pct_used: Math.round((spent.total / b.monthly_limit) * 100),
+            over_budget: spent.total > b.monthly_limit,
+        };
+    });
+}
+export function getGoals(db) {
+    const goals = db.prepare(`SELECT * FROM goals`).all();
+    const now = new Date();
+    return goals.map((g) => {
+        const remaining = g.target_amount - g.current_amount;
+        const progress = Math.round((g.current_amount / g.target_amount) * 1000) / 10;
+        let monthsLeft = 1;
+        if (g.target_date) {
+            const target = new Date(g.target_date);
+            monthsLeft = Math.max(1, (target.getFullYear() - now.getFullYear()) * 12 +
+                (target.getMonth() - now.getMonth()));
+        }
+        return {
+            name: g.name,
+            target: g.target_amount,
+            current: g.current_amount,
+            remaining,
+            progress_pct: progress,
+            target_date: g.target_date,
+            monthly_needed: Math.round((remaining / monthsLeft) * 100) / 100,
+        };
+    });
+}
+export function getCashFlowThisMonth(db) {
+    const now = new Date();
+    const monthStart = new Date(now.getFullYear(), now.getMonth(), 1)
+        .toISOString()
+        .slice(0, 10);
+    const today = now.toISOString().slice(0, 10);
+    const income = db
+        .prepare(`SELECT COALESCE(SUM(ABS(amount)), 0) as total FROM transactions
+       WHERE amount < 0 AND date BETWEEN ? AND ? AND pending = 0
+       AND category NOT IN ('TRANSFER_IN')`)
+        .get(monthStart, today);
+    const expenses = db
+        .prepare(`SELECT COALESCE(SUM(amount), 0) as total FROM transactions
+       WHERE amount > 0 AND date BETWEEN ? AND ? AND pending = 0
+       AND category NOT IN ('TRANSFER_OUT')`)
+        .get(monthStart, today);
+    return {
+        income: Math.round(income.total * 100) / 100,
+        expenses: Math.round(expenses.total * 100) / 100,
+        net: Math.round((income.total - expenses.total) * 100) / 100,
+    };
+}
+export function getRecentSpending(db) {
+    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000)
+        .toISOString()
+        .slice(0, 10);
+    const today = new Date().toISOString().slice(0, 10);
+    return db
+        .prepare(`SELECT category, SUM(amount) as total FROM transactions
+       WHERE amount > 0 AND date IN (?, ?)
+       AND category NOT IN ('TRANSFER_OUT', 'TRANSFER_IN', 'LOAN_PAYMENTS', 'LOAN_PAYMENTS_CAR_PAYMENT', 'LOAN_PAYMENTS_PERSONAL_LOAN_PAYMENT')
+       GROUP BY category ORDER BY total DESC`)
+        .all(yesterday, today);
+}
+export function getRecentTransactions(db, limit = 10) {
+    const yesterday = new Date(Date.now() - 24 * 60 * 60 * 1000)
+        .toISOString()
+        .slice(0, 10);
+    const today = new Date().toISOString().slice(0, 10);
+    return db
+        .prepare(`SELECT name, amount, category, date, pending FROM transactions
+       WHERE amount > 0 AND date IN (?, ?)
+       AND category NOT IN ('TRANSFER_OUT', 'TRANSFER_IN', 'LOAN_PAYMENTS', 'LOAN_PAYMENTS_CAR_PAYMENT', 'LOAN_PAYMENTS_PERSONAL_LOAN_PAYMENT', 'RENT_AND_UTILITIES_RENT')
+       ORDER BY amount DESC LIMIT ?`)
+        .all(yesterday, today, limit);
+}
+export function getTransactionsFiltered(db, filters) {
+    const conditions = [];
+    const params = [];
+    if (filters.startDate) {
+        conditions.push(`date >= ?`);
+        params.push(filters.startDate);
+    }
+    if (filters.endDate) {
+        conditions.push(`date <= ?`);
+        params.push(filters.endDate);
+    }
+    if (filters.category) {
+        conditions.push(`(category = ? OR subcategory = ?)`);
+        params.push(filters.category, filters.category);
+    }
+    if (filters.merchant) {
+        conditions.push(`(merchant_name LIKE ? OR name LIKE ?)`);
+        params.push(`%${filters.merchant}%`, `%${filters.merchant}%`);
+    }
+    if (filters.minAmount !== undefined) {
+        conditions.push(`amount >= ?`);
+        params.push(filters.minAmount);
+    }
+    if (filters.maxAmount !== undefined) {
+        conditions.push(`amount <= ?`);
+        params.push(filters.maxAmount);
+    }
+    const where = conditions.length > 0 ? `WHERE ${conditions.join(" AND ")}` : "";
+    const limit = filters.limit || 50;
+    return db
+        .prepare(`SELECT transaction_id, name, merchant_name, amount, category, date, pending
+       FROM transactions ${where}
+       ORDER BY date DESC, amount DESC LIMIT ?`)
+        .all(...params, limit);
+}
+// --- Income ---
+export function getIncome(db, startDate, endDate) {
+    return db.prepare(`SELECT COALESCE(merchant_name, name) as source, SUM(ABS(amount)) as total, COUNT(*) as count
+     FROM transactions
+     WHERE amount < 0 AND date BETWEEN ? AND ? AND pending = 0
+     AND category NOT IN ('TRANSFER_IN')
+     GROUP BY source ORDER BY total DESC`).all(startDate, endDate);
+}
+// --- Full-text search ---
+export function searchTransactions(db, query, limit = 30) {
+    return db.prepare(`SELECT transaction_id, name, merchant_name, amount, category, date
+     FROM transactions
+     WHERE (name LIKE ? OR merchant_name LIKE ? OR category LIKE ?)
+     ORDER BY date DESC LIMIT ?`).all(`%${query}%`, `%${query}%`, `%${query}%`, limit);
+}
+// --- Cash flow analysis ---
+export function getCashFlow(db, startDate, endDate) {
+    const income = db.prepare(`SELECT COALESCE(SUM(ABS(amount)), 0) as total FROM transactions
+     WHERE amount < 0 AND date BETWEEN ? AND ? AND pending = 0
+     AND category NOT IN ('TRANSFER_IN')`).get(startDate, endDate);
+    const expenses = db.prepare(`SELECT COALESCE(SUM(amount), 0) as total FROM transactions
+     WHERE amount > 0 AND date BETWEEN ? AND ? AND pending = 0
+     AND category NOT IN ('TRANSFER_OUT')`).get(startDate, endDate);
+    const net = income.total - expenses.total;
+    const savingsRate = income.total > 0 ? (net / income.total) * 100 : 0;
+    // Monthly breakdown
+    const rows = db.prepare(`SELECT strftime('%Y-%m', date) as month,
+       SUM(CASE WHEN amount < 0 AND category NOT IN ('TRANSFER_IN') THEN ABS(amount) ELSE 0 END) as income,
+       SUM(CASE WHEN amount > 0 AND category NOT IN ('TRANSFER_OUT') THEN amount ELSE 0 END) as expenses
+     FROM transactions
+     WHERE date BETWEEN ? AND ? AND pending = 0
+     GROUP BY month ORDER BY month`).all(startDate, endDate);
+    return {
+        income: Math.round(income.total * 100) / 100,
+        expenses: Math.round(expenses.total * 100) / 100,
+        net: Math.round(net * 100) / 100,
+        savingsRate: Math.round(savingsRate * 10) / 10,
+        monthly: rows.map(r => ({ ...r, net: Math.round((r.income - r.expenses) * 100) / 100 })),
+    };
+}
+// --- Balance forecast ---
+export function forecastBalance(db, accountId, months = 6) {
+    // Get current balance
+    let balanceQuery = `SELECT COALESCE(SUM(current_balance), 0) as total FROM accounts WHERE type = 'depository'`;
+    const balanceParams = [];
+    if (accountId) {
+        balanceQuery = `SELECT current_balance as total FROM accounts WHERE account_id = ?`;
+        balanceParams.push(accountId);
+    }
+    const bal = db.prepare(balanceQuery).get(...balanceParams);
+    // Calculate 3-month average flows
+    const threeMonthsAgo = new Date();
+    threeMonthsAgo.setMonth(threeMonthsAgo.getMonth() - 3);
+    const startDate = threeMonthsAgo.toISOString().slice(0, 10);
+    const today = new Date().toISOString().slice(0, 10);
+    let flowCondition = "";
+    const flowParams = [startDate, today];
+    if (accountId) {
+        flowCondition = " AND account_id = ?";
+        flowParams.push(accountId);
+    }
+    const inflow = db.prepare(`SELECT COALESCE(SUM(ABS(amount)), 0) as total FROM transactions
+     WHERE amount < 0 AND date BETWEEN ? AND ? AND pending = 0${flowCondition}`).get(...flowParams);
+    const outflow = db.prepare(`SELECT COALESCE(SUM(amount), 0) as total FROM transactions
+     WHERE amount > 0 AND date BETWEEN ? AND ? AND pending = 0${flowCondition}`).get(...flowParams);
+    const avgInflow = inflow.total / 3;
+    const avgOutflow = outflow.total / 3;
+    const monthlyNet = avgInflow - avgOutflow;
+    const projections = [];
+    let running = bal.total;
+    for (let i = 1; i <= months; i++) {
+        const d = new Date();
+        d.setMonth(d.getMonth() + i);
+        running += monthlyNet;
+        projections.push({
+            month: d.toISOString().slice(0, 7),
+            projected: Math.round(running * 100) / 100,
+        });
+    }
+    return {
+        currentBalance: bal.total,
+        projections,
+        avgMonthlyInflow: Math.round(avgInflow * 100) / 100,
+        avgMonthlyOutflow: Math.round(avgOutflow * 100) / 100,
+    };
+}
+// --- Portfolio ---
+export function getPortfolio(db) {
+    const rows = db.prepare(`SELECT a.name as account, s.name as security, s.ticker,
+       h.quantity, h.value, h.cost_basis,
+       (h.value - COALESCE(h.cost_basis, h.value)) as gain_loss
+     FROM holdings h
+     JOIN accounts a ON h.account_id = a.account_id
+     LEFT JOIN securities s ON h.security_id = s.security_id
+     ORDER BY h.value DESC`).all();
+    const totalValue = rows.reduce((s, r) => s + (r.value || 0), 0);
+    const totalCostBasis = rows.reduce((s, r) => s + (r.cost_basis || 0), 0);
+    return {
+        totalValue: Math.round(totalValue * 100) / 100,
+        totalCostBasis: Math.round(totalCostBasis * 100) / 100,
+        totalGainLoss: Math.round((totalValue - totalCostBasis) * 100) / 100,
+        holdings: rows.map((r) => ({
+            account: r.account,
+            security: r.security || "Unknown",
+            ticker: r.ticker || "",
+            quantity: r.quantity,
+            value: r.value || 0,
+            costBasis: r.cost_basis || 0,
+            gainLoss: r.gain_loss || 0,
+        })),
+    };
+}
+// --- Investment performance ---
+export function getInvestmentPerformance(db) {
+    const rows = db.prepare(`SELECT s.name as security, s.ticker,
+       h.value, h.cost_basis
+     FROM holdings h
+     LEFT JOIN securities s ON h.security_id = s.security_id
+     WHERE h.value IS NOT NULL
+     ORDER BY h.value DESC`).all();
+    const totalValue = rows.reduce((s, r) => s + (r.value || 0), 0);
+    const totalCost = rows.reduce((s, r) => s + (r.cost_basis || r.value || 0), 0);
+    const totalReturn = totalValue - totalCost;
+    const totalReturnPct = totalCost > 0 ? (totalReturn / totalCost) * 100 : 0;
+    return {
+        totalReturn: Math.round(totalReturn * 100) / 100,
+        totalReturnPct: Math.round(totalReturnPct * 10) / 10,
+        holdings: rows.map((r) => {
+            const cost = r.cost_basis || r.value || 0;
+            const ret = (r.value || 0) - cost;
+            return {
+                security: r.security || "Unknown",
+                ticker: r.ticker || "",
+                value: r.value || 0,
+                costBasis: cost,
+                returnPct: cost > 0 ? Math.round((ret / cost) * 1000) / 10 : 0,
+            };
+        }),
+    };
+}
+// --- Debts ---
+export function getDebts(db) {
+    // Try liabilities table first
+    const liabilities = db.prepare(`SELECT a.name, l.current_balance as balance, l.interest_rate as rate,
+       l.minimum_payment as min_payment, l.type, l.next_payment_due as next_due
+     FROM liabilities l
+     JOIN accounts a ON l.account_id = a.account_id
+     WHERE l.current_balance > 0
+     ORDER BY l.interest_rate DESC`).all();
+    if (liabilities.length > 0) {
+        const totalDebt = liabilities.reduce((s, r) => s + (r.balance || 0), 0);
+        return {
+            totalDebt,
+            debts: liabilities.map((r) => ({
+                name: r.name,
+                balance: r.balance || 0,
+                rate: r.rate || 0,
+                minPayment: r.min_payment || 0,
+                type: r.type || "unknown",
+                nextDue: r.next_due || null,
+            })),
+        };
+    }
+    // Fallback: credit accounts
+    const credits = db.prepare(`SELECT name, current_balance as balance, type FROM accounts
+     WHERE type IN ('credit', 'loan') AND current_balance > 0
+     ORDER BY current_balance DESC`).all();
+    const totalDebt = credits.reduce((s, r) => s + (r.balance || 0), 0);
+    return {
+        totalDebt,
+        debts: credits.map((r) => ({
+            name: r.name,
+            balance: r.balance || 0,
+            rate: 0,
+            minPayment: 0,
+            type: r.type,
+            nextDue: null,
+        })),
+    };
+}
+// --- Spending comparison ---
+export function compareSpending(db, period1Start, period1End, period2Start, period2End) {
+    const getByCategory = (start, end) => {
+        return db.prepare(`SELECT category, SUM(amount) as total FROM transactions
+       WHERE amount > 0 AND date BETWEEN ? AND ? AND pending = 0
+       AND category NOT IN ('TRANSFER_OUT', 'TRANSFER_IN', 'LOAN_PAYMENTS')
+       GROUP BY category`).all(start, end);
+    };
+    const p1 = getByCategory(period1Start, period1End);
+    const p2 = getByCategory(period2Start, period2End);
+    const p1Map = new Map(p1.map(r => [r.category, r.total]));
+    const p2Map = new Map(p2.map(r => [r.category, r.total]));
+    const allCats = new Set([...p1Map.keys(), ...p2Map.keys()]);
+    const categories = [...allCats].map(cat => ({
+        category: cat,
+        period1: Math.round((p1Map.get(cat) || 0) * 100) / 100,
+        period2: Math.round((p2Map.get(cat) || 0) * 100) / 100,
+        diff: Math.round(((p2Map.get(cat) || 0) - (p1Map.get(cat) || 0)) * 100) / 100,
+    })).sort((a, b) => Math.abs(b.diff) - Math.abs(a.diff));
+    const period1Total = p1.reduce((s, r) => s + r.total, 0);
+    const period2Total = p2.reduce((s, r) => s + r.total, 0);
+    const difference = period2Total - period1Total;
+    return {
+        period1Total: Math.round(period1Total * 100) / 100,
+        period2Total: Math.round(period2Total * 100) / 100,
+        difference: Math.round(difference * 100) / 100,
+        pctChange: period1Total > 0 ? Math.round((difference / period1Total) * 1000) / 10 : 0,
+        categories,
+    };
+}
+// --- Net worth trend ---
+export function getNetWorthTrend(db, limit = 30) {
+    return db.prepare(`SELECT date, net_worth, total_assets as assets, total_liabilities as liabilities
+     FROM net_worth_history ORDER BY date DESC LIMIT ?`).all(limit).reverse();
+}
+export function formatMoney(n) {
+    return "$" + Math.abs(n).toLocaleString("en-US", { minimumFractionDigits: 2, maximumFractionDigits: 2 });
+}
+export function categoryLabel(cat) {
+    const labels = {
+        FOOD_AND_DRINK: "Food & Drink",
+        GENERAL_MERCHANDISE: "Shopping",
+        PERSONAL_CARE: "Personal Care",
+        ENTERTAINMENT: "Entertainment",
+        TRANSPORTATION: "Transportation",
+        GENERAL_SERVICES: "Services",
+        RENT_AND_UTILITIES: "Rent & Utilities",
+        LOAN_PAYMENTS: "Loan Payments",
+        GOVERNMENT_AND_NON_PROFIT: "Gov/Nonprofit",
+        MEDICAL: "Medical",
+        BANK_FEES: "Bank Fees",
+    };
+    return labels[cat] || cat;
+}

package/dist/scoring/index.d.ts

@@ -0,0 +1,53 @@
+import type BetterSqlite3 from "libsql";
+type Database = BetterSqlite3.Database;
+export interface DailyScore {
+    date: string;
+    score: number;
+    restaurant_count: number;
+    shopping_count: number;
+    food_spend: number;
+    total_spend: number;
+    zero_spend: boolean;
+    no_restaurant_streak: number;
+    no_shopping_streak: number;
+    on_pace_streak: number;
+}
+export interface Achievement {
+    key: string;
+    name: string;
+    description: string;
+    unlocked_at: string;
+}
+/**
+ * Calculate and store the daily score for a given date (defaults to yesterday).
+ * Should run during daily sync, after transactions are updated.
+ */
+export declare function calculateDailyScore(db: Database, dateStr?: string): DailyScore;
+/**
+ * Check and unlock any new achievements. Returns newly unlocked ones.
+ */
+export declare function checkAchievements(db: Database): Achievement[];
+/**
+ * Get monthly savings compared to the earliest full month of transaction data (dynamic baseline).
+ * If no full month exists yet, returns { saved: 0, ... }.
+ */
+export declare function getMonthlySavings(db: Database): {
+    saved: number;
+    baselinePace: number;
+    currentPace: number;
+    daysCompared: number;
+    baselineMonth: string | null;
+};
+/**
+ * Get latest score + streaks for display.
+ */
+export declare function getLatestScore(db: Database): DailyScore | null;
+/**
+ * Get all unlocked achievements.
+ */
+export declare function getAchievements(db: Database): Achievement[];
+/**
+ * Get average score for current month.
+ */
+export declare function getMonthAvgScore(db: Database): number | null;
+export {};