ray-finance 0.1.0

package/dist/alerts/index.d.ts

@@ -0,0 +1,11 @@
+import type BetterSqlite3 from "libsql";
+type Database = BetterSqlite3.Database;
+export interface Alert {
+    type: string;
+    severity: "info" | "warning" | "critical";
+    message: string;
+    data?: any;
+}
+/** Generate alerts based on current financial data */
+export declare function generateAlerts(db: Database): Alert[];
+export {};

package/dist/alerts/index.js

@@ -0,0 +1,95 @@
+/** Generate alerts based on current financial data */
+export function generateAlerts(db) {
+    const alerts = [];
+    // Large transactions (>$500) in last 24h
+    const large = db
+        .prepare(`SELECT t.name, t.merchant_name, t.amount, t.date, a.name as account_name
+       FROM transactions t JOIN accounts a ON t.account_id = a.account_id
+       WHERE t.date >= date('now', '-1 day') AND t.amount > 500 AND t.pending = 0`)
+        .all();
+    for (const tx of large) {
+        alerts.push({
+            type: "large_transaction",
+            severity: "warning",
+            message: `Large charge: $${tx.amount} at ${tx.merchant_name || tx.name} (${tx.account_name})`,
+            data: tx,
+        });
+    }
+    // Low balances (<$1000) on checking/savings
+    const lowBal = db
+        .prepare(`SELECT name, current_balance, type FROM accounts
+       WHERE type = 'depository' AND current_balance < 1000`)
+        .all();
+    for (const acct of lowBal) {
+        alerts.push({
+            type: "low_balance",
+            severity: acct.current_balance < 500 ? "critical" : "warning",
+            message: `Low balance: ${acct.name} has $${acct.current_balance.toFixed(2)}`,
+            data: acct,
+        });
+    }
+    // Budget overruns (this month)
+    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();
+    for (const b of budgets) {
+        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);
+        if (spent.total > b.monthly_limit) {
+            alerts.push({
+                type: "budget_overrun",
+                severity: "warning",
+                message: `Over budget: ${b.category} — spent $${spent.total.toFixed(2)} of $${b.monthly_limit} limit`,
+                data: { category: b.category, spent: spent.total, limit: b.monthly_limit },
+            });
+        }
+        else if (spent.total > b.monthly_limit * 0.9) {
+            alerts.push({
+                type: "budget_warning",
+                severity: "info",
+                message: `Nearing budget: ${b.category} — $${spent.total.toFixed(2)} of $${b.monthly_limit} (${Math.round((spent.total / b.monthly_limit) * 100)}%)`,
+                data: { category: b.category, spent: spent.total, limit: b.monthly_limit },
+            });
+        }
+    }
+    // Subscription price changes (compare last 2 occurrences of recurring merchants)
+    const recurring = db
+        .prepare(`SELECT merchant_name, amount, date FROM transactions
+       WHERE merchant_name IN (
+         SELECT merchant_name FROM transactions
+         WHERE merchant_name IS NOT NULL AND amount > 0
+         GROUP BY merchant_name HAVING COUNT(*) >= 2
+       )
+       AND amount > 0 AND pending = 0
+       ORDER BY merchant_name, date DESC`)
+        .all();
+    const byMerchant = {};
+    for (const r of recurring) {
+        if (!byMerchant[r.merchant_name])
+            byMerchant[r.merchant_name] = [];
+        if (byMerchant[r.merchant_name].length < 2) {
+            byMerchant[r.merchant_name].push({ amount: r.amount, date: r.date });
+        }
+    }
+    for (const [merchant, charges] of Object.entries(byMerchant)) {
+        if (charges.length === 2) {
+            const diff = Math.abs(charges[0].amount - charges[1].amount);
+            if (diff > 0.5 && diff / charges[1].amount > 0.05) {
+                alerts.push({
+                    type: "price_change",
+                    severity: "info",
+                    message: `Price change: ${merchant} went from $${charges[1].amount} to $${charges[0].amount}`,
+                    data: { merchant, previous: charges[1].amount, current: charges[0].amount },
+                });
+            }
+        }
+    }
+    return alerts;
+}

package/dist/auth/anthropic.d.ts

@@ -0,0 +1,7 @@
+export interface OAuthCredentials {
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+export declare function loginAnthropic(): Promise<OAuthCredentials>;
+export declare function refreshAnthropicToken(refreshToken: string): Promise<OAuthCredentials>;

package/dist/auth/anthropic.js

@@ -0,0 +1,85 @@
+import { randomBytes } from "crypto";
+import { generatePKCE } from "./pkce.js";
+const CLIENT_ID = "9d1d2024-a989-4a4d-9e10-c9c3f5b1ef96";
+const AUTH_URL = "https://console.anthropic.com/oauth/authorize";
+const TOKEN_URL = "https://console.anthropic.com/v1/oauth/token";
+const REDIRECT_URI = "https://console.anthropic.com/oauth/return";
+const SCOPES = "user:inference";
+export async function loginAnthropic() {
+    const inquirer = (await import("inquirer")).default;
+    const open = (await import("open")).default;
+    const { verifier, challenge } = generatePKCE();
+    const state = randomBytes(16).toString("hex");
+    const params = new URLSearchParams({
+        response_type: "code",
+        client_id: CLIENT_ID,
+        redirect_uri: REDIRECT_URI,
+        scope: SCOPES,
+        state,
+        code_challenge: challenge,
+        code_challenge_method: "S256",
+    });
+    const authUrl = `${AUTH_URL}?${params}`;
+    console.log("\nOpening browser for Anthropic login...");
+    console.log("If the browser doesn't open, visit this URL:\n");
+    console.log(`  ${authUrl}\n`);
+    await open(authUrl);
+    const { callback } = await inquirer.prompt([{
+            type: "input",
+            name: "callback",
+            message: "Paste the code from the callback page:",
+            validate: (v) => v.length > 0 || "Required",
+        }]);
+    // Parse "code#state" or just "code"
+    const [code, returnedState] = callback.includes("#")
+        ? callback.split("#")
+        : [callback, undefined];
+    if (returnedState && returnedState !== state) {
+        throw new Error("OAuth state mismatch — possible CSRF attack. Try again.");
+    }
+    return exchangeCode(code.trim(), verifier);
+}
+async function exchangeCode(code, verifier) {
+    const res = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "authorization_code",
+            client_id: CLIENT_ID,
+            code,
+            redirect_uri: REDIRECT_URI,
+            code_verifier: verifier,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Token exchange failed (${res.status}): ${body}`);
+    }
+    const data = await res.json();
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token,
+        expiresAt: Date.now() + data.expires_in * 1000,
+    };
+}
+export async function refreshAnthropicToken(refreshToken) {
+    const res = await fetch(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            client_id: CLIENT_ID,
+            refresh_token: refreshToken,
+        }),
+    });
+    if (!res.ok) {
+        const body = await res.text();
+        throw new Error(`Token refresh failed (${res.status}): ${body}`);
+    }
+    const data = await res.json();
+    return {
+        accessToken: data.access_token,
+        refreshToken: data.refresh_token ?? refreshToken,
+        expiresAt: Date.now() + data.expires_in * 1000,
+    };
+}

package/dist/auth/pkce.d.ts

@@ -0,0 +1,5 @@
+export interface PKCEChallenge {
+    verifier: string;
+    challenge: string;
+}
+export declare function generatePKCE(): PKCEChallenge;

package/dist/auth/pkce.js

@@ -0,0 +1,10 @@
+import { randomBytes, createHash } from "crypto";
+export function generatePKCE() {
+    const verifier = randomBytes(32)
+        .toString("base64url")
+        .slice(0, 43);
+    const challenge = createHash("sha256")
+        .update(verifier)
+        .digest("base64url");
+    return { verifier, challenge };
+}

package/dist/auth/store.d.ts

@@ -0,0 +1,12 @@
+import { type OAuthCredentials } from "./anthropic.js";
+export interface AuthData {
+    provider: "anthropic";
+    accessToken: string;
+    refreshToken: string;
+    expiresAt: number;
+}
+export declare function saveAuth(creds: OAuthCredentials): void;
+export declare function loadAuth(): AuthData | null;
+export declare function clearAuth(): void;
+export declare function getActiveApiKey(): Promise<string>;
+export declare function hasOAuthAuth(): boolean;

package/dist/auth/store.js

@@ -0,0 +1,51 @@
+import { readFileSync, writeFileSync, existsSync, mkdirSync, unlinkSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+import { config } from "../config.js";
+import { refreshAnthropicToken } from "./anthropic.js";
+const RAY_DIR = resolve(homedir(), ".ray");
+const AUTH_PATH = resolve(RAY_DIR, "auth.json");
+export function saveAuth(creds) {
+    if (!existsSync(RAY_DIR))
+        mkdirSync(RAY_DIR, { recursive: true });
+    const data = {
+        provider: "anthropic",
+        accessToken: creds.accessToken,
+        refreshToken: creds.refreshToken,
+        expiresAt: creds.expiresAt,
+    };
+    writeFileSync(AUTH_PATH, JSON.stringify(data, null, 2) + "\n", { mode: 0o600 });
+}
+export function loadAuth() {
+    if (!existsSync(AUTH_PATH))
+        return null;
+    try {
+        return JSON.parse(readFileSync(AUTH_PATH, "utf-8"));
+    }
+    catch {
+        return null;
+    }
+}
+export function clearAuth() {
+    if (existsSync(AUTH_PATH))
+        unlinkSync(AUTH_PATH);
+}
+const REFRESH_BUFFER_MS = 5 * 60 * 1000; // refresh 5 min before expiry
+export async function getActiveApiKey() {
+    const auth = loadAuth();
+    if (!auth) {
+        // Fall back to config API key
+        return config.anthropicKey;
+    }
+    // Check if token is still fresh
+    if (auth.expiresAt - Date.now() > REFRESH_BUFFER_MS) {
+        return auth.accessToken;
+    }
+    // Refresh the token
+    const refreshed = await refreshAnthropicToken(auth.refreshToken);
+    saveAuth(refreshed);
+    return refreshed.accessToken;
+}
+export function hasOAuthAuth() {
+    return loadAuth() !== null;
+}

package/dist/cli/backup.d.ts

@@ -0,0 +1,2 @@
+export declare function runExport(outputPath?: string): void;
+export declare function runImport(inputPath: string): void;

package/dist/cli/backup.js

@@ -0,0 +1,94 @@
+import { writeFileSync, readFileSync, existsSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+import chalk from "chalk";
+import { getDb } from "../db/connection.js";
+import { readContext, writeContext } from "../ai/context.js";
+export function runExport(outputPath) {
+    const db = getDb();
+    const dest = outputPath || resolve(homedir(), ".ray", "backup.json");
+    const backup = {
+        version: 1,
+        exported_at: new Date().toISOString(),
+        context: readContext(),
+        memories: db.prepare("SELECT content, category FROM memories").all(),
+        goals: db.prepare("SELECT name, target_amount, current_amount, deadline, status FROM goals").all(),
+        budgets: db.prepare("SELECT category, monthly_limit, period FROM budgets").all(),
+        recat_rules: db.prepare("SELECT match_field, match_pattern, target_category, target_subcategory, label FROM recategorization_rules").all(),
+        settings: db.prepare("SELECT key, value FROM settings").all(),
+        milestones: db.prepare("SELECT name, target_date, monthly_savings, description FROM milestones").all(),
+    };
+    writeFileSync(dest, JSON.stringify(backup, null, 2) + "\n", { mode: 0o600 });
+    console.log(chalk.green(`\nBackup saved to ${dest}`));
+    console.log(chalk.dim(`  ${backup.memories.length} memories, ${backup.goals.length} goals, ${backup.budgets.length} budgets, ${backup.recat_rules.length} rules`));
+    console.log(chalk.dim(`  Context: ${backup.context.length} chars`));
+    console.log(chalk.dim(`\nThis file does NOT contain secrets, transactions, or account credentials.`));
+    console.log(chalk.dim(`After restoring, re-link accounts with 'ray link' and sync with 'ray sync'.\n`));
+}
+export function runImport(inputPath) {
+    if (!existsSync(inputPath)) {
+        console.error(chalk.red(`File not found: ${inputPath}`));
+        process.exit(1);
+    }
+    let backup;
+    try {
+        backup = JSON.parse(readFileSync(inputPath, "utf-8"));
+    }
+    catch {
+        console.error(chalk.red("Invalid backup file."));
+        process.exit(1);
+    }
+    if (!backup.version || backup.version !== 1) {
+        console.error(chalk.red("Unsupported backup version."));
+        process.exit(1);
+    }
+    const db = getDb();
+    // Restore context.md
+    if (backup.context) {
+        writeContext(backup.context);
+    }
+    // Restore memories (skip exact duplicates)
+    const insertMemory = db.prepare("INSERT INTO memories (content, category) SELECT ?, ? WHERE NOT EXISTS (SELECT 1 FROM memories WHERE content = ? AND category = ?)");
+    for (const m of backup.memories) {
+        insertMemory.run(m.content, m.category, m.content, m.category);
+    }
+    // Restore goals (skip if name already exists)
+    const existingGoal = db.prepare("SELECT 1 FROM goals WHERE name = ?");
+    const insertGoal = db.prepare("INSERT INTO goals (name, target_amount, current_amount, deadline, status) VALUES (?, ?, ?, ?, ?)");
+    for (const g of backup.goals) {
+        if (!existingGoal.get(g.name)) {
+            insertGoal.run(g.name, g.target_amount, g.current_amount, g.deadline, g.status);
+        }
+    }
+    // Restore budgets
+    const insertBudget = db.prepare("INSERT INTO budgets (category, monthly_limit, period) VALUES (?, ?, ?) ON CONFLICT(category, period) DO UPDATE SET monthly_limit = excluded.monthly_limit");
+    for (const b of backup.budgets) {
+        insertBudget.run(b.category, b.monthly_limit, b.period);
+    }
+    // Restore recat rules (skip exact duplicates)
+    const existingRule = db.prepare("SELECT 1 FROM recategorization_rules WHERE match_field = ? AND match_pattern = ? AND target_category = ?");
+    const insertRule = db.prepare("INSERT INTO recategorization_rules (match_field, match_pattern, target_category, target_subcategory, label) VALUES (?, ?, ?, ?, ?)");
+    for (const r of backup.recat_rules) {
+        if (!existingRule.get(r.match_field, r.match_pattern, r.target_category)) {
+            insertRule.run(r.match_field, r.match_pattern, r.target_category, r.target_subcategory, r.label);
+        }
+    }
+    // Restore settings
+    const insertSetting = db.prepare("INSERT INTO settings (key, value) VALUES (?, ?) ON CONFLICT(key) DO UPDATE SET value = excluded.value");
+    for (const s of backup.settings) {
+        insertSetting.run(s.key, s.value);
+    }
+    // Restore milestones (skip if name already exists)
+    const existingMilestone = db.prepare("SELECT 1 FROM milestones WHERE name = ?");
+    const insertMilestone = db.prepare("INSERT INTO milestones (name, target_date, monthly_savings, description) VALUES (?, ?, ?, ?)");
+    for (const m of backup.milestones) {
+        if (!existingMilestone.get(m.name)) {
+            insertMilestone.run(m.name, m.target_date, m.monthly_savings, m.description);
+        }
+    }
+    console.log(chalk.green(`\nBackup restored from ${inputPath}`));
+    console.log(chalk.dim(`  ${backup.memories.length} memories, ${backup.goals.length} goals, ${backup.budgets.length} budgets, ${backup.recat_rules.length} rules`));
+    console.log(chalk.dim(`\nNext steps:`));
+    console.log(chalk.dim(`  1. Run 'ray link' to re-connect your bank accounts`));
+    console.log(chalk.dim(`  2. Run 'ray sync' to pull transactions\n`));
+}

package/dist/cli/chat.d.ts

@@ -0,0 +1 @@
+export declare function startChat(): Promise<void>;

package/dist/cli/chat.js

@@ -0,0 +1,203 @@
+import chalk from "chalk";
+import { getDb } from "../db/connection.js";
+import { handleMessage } from "../ai/agent.js";
+import { config } from "../config.js";
+import { isContextEmpty } from "../ai/context.js";
+import { cliBriefing } from "../ai/insights.js";
+import { banner, formatResponse } from "./format.js";
+/** Raw-mode line reader that renders content below the cursor while waiting for input */
+function rawReadLine(prompt, belowLines) {
+    return new Promise((resolve) => {
+        let buf = "";
+        const out = process.stdout;
+        // Render: prompt on current line, then content below, then restore cursor
+        out.write(prompt);
+        if (belowLines.length > 0) {
+            // Save cursor, render below, restore
+            out.write("\x1b[s");
+            out.write("\n" + belowLines.join("\n"));
+            out.write("\x1b[u");
+        }
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.setEncoding("utf8");
+        const cleanup = () => {
+            process.stdin.setRawMode(false);
+            process.stdin.removeListener("data", onData);
+            process.stdin.pause();
+        };
+        const onData = (chunk) => {
+            for (let i = 0; i < chunk.length; i++) {
+                const code = chunk.charCodeAt(i);
+                // Ctrl+C / Ctrl+D
+                if (code === 3 || code === 4) {
+                    cleanup();
+                    out.write("\n");
+                    resolve("\x03");
+                    return;
+                }
+                // Enter
+                if (code === 13) {
+                    cleanup();
+                    // Move past the below-content lines, then newline
+                    for (let j = 0; j < belowLines.length; j++)
+                        out.write("\x1b[1B");
+                    out.write("\n");
+                    resolve(buf);
+                    return;
+                }
+                // Backspace
+                if (code === 127 || code === 8) {
+                    if (buf.length > 0) {
+                        buf = buf.slice(0, -1);
+                        out.write("\b \b");
+                    }
+                    continue;
+                }
+                // Skip escape sequences (arrow keys etc.)
+                if (code === 27) {
+                    if (i + 1 < chunk.length && chunk[i + 1] === "[") {
+                        i += 2;
+                        while (i < chunk.length && chunk.charCodeAt(i) < 64)
+                            i++;
+                    }
+                    continue;
+                }
+                // Printable characters
+                if (code >= 32) {
+                    buf += chunk[i];
+                    out.write(chunk[i]);
+                }
+            }
+        };
+        process.stdin.on("data", onData);
+    });
+}
+export async function startChat() {
+    const ora = (await import("ora")).default;
+    const db = getDb();
+    // Show logo + briefing
+    console.log("");
+    console.log(banner());
+    console.log("");
+    const briefing = cliBriefing(db);
+    if (briefing) {
+        const now = new Date();
+        const timeStr = now.toLocaleDateString("en-US", { weekday: "long", month: "short", day: "numeric" }).toLowerCase();
+        console.log(chalk.dim(`  ${timeStr}`));
+        console.log("");
+        console.log(briefing);
+    }
+    else {
+        console.log(chalk.bold(`ray`) + chalk.dim(` — ${config.userName}`));
+    }
+    console.log("");
+    // Require at least one linked account
+    const hasAccounts = db.prepare("SELECT COUNT(*) as count FROM accounts").get();
+    if (hasAccounts.count === 0) {
+        if (!config.plaidClientId || !config.plaidSecret) {
+            console.log(chalk.yellow("No accounts linked. Add Plaid credentials via 'ray setup', then run 'ray link'.\n"));
+            return;
+        }
+        console.log(chalk.yellow("No accounts linked yet. Let's connect one first.\n"));
+        const { runLink } = await import("./commands.js");
+        await runLink();
+        // Re-check after linking
+        const recheck = db.prepare("SELECT COUNT(*) as count FROM accounts").get();
+        if (recheck.count === 0) {
+            console.log(chalk.red("\nNo accounts linked. Run 'ray link' when you're ready.\n"));
+            return;
+        }
+    }
+    // Auto-trigger onboarding for new users
+    if (isContextEmpty()) {
+        console.log(chalk.cyan("Welcome! Let me review your accounts and help set up your financial profile.\n"));
+        const spinner = ora({ text: "Reviewing your accounts...", color: "cyan", discardStdin: false }).start();
+        try {
+            const response = await handleMessage(db, "I just connected my financial accounts. Help me set up my financial profile.");
+            spinner.stop();
+            console.log(`\n${response}\n`);
+        }
+        catch (err) {
+            spinner.stop();
+            console.error(chalk.red("Error during onboarding: " + err.message));
+        }
+    }
+    const shutdown = () => {
+        console.log(chalk.dim("\nGoodbye!"));
+        process.exit(0);
+    };
+    const hints = [
+        "try: how am i doing this month?",
+        "try: where's my money going?",
+        "try: what bills are coming up?",
+        "try: help me save more",
+        "try: am i on track for my goals?",
+        "try: any unusual spending lately?",
+        "try: what should i focus on?",
+        "try: compare this month to last month",
+        "try: set a budget for dining out",
+        "try: how much did i spend on groceries?",
+    ];
+    let hintIdx = Math.floor(Math.random() * hints.length);
+    const getFooterText = () => {
+        const lastSync = db.prepare(`SELECT MAX(updated_at) as ts FROM accounts`).get();
+        let syncStr = "";
+        if (lastSync.ts) {
+            const diffMs = Date.now() - new Date(lastSync.ts + "Z").getTime();
+            const mins = Math.floor(diffMs / 60000);
+            if (mins < 1)
+                syncStr = "synced just now";
+            else if (mins < 60)
+                syncStr = `synced ${mins}m ago`;
+            else if (mins < 1440)
+                syncStr = `synced ${Math.floor(mins / 60)}h ago`;
+            else
+                syncStr = `synced ${Math.floor(mins / 1440)}d ago`;
+        }
+        const parts = ["ray"];
+        if (syncStr)
+            parts.push(syncStr);
+        parts.push(hints[hintIdx]);
+        hintIdx = (hintIdx + 1) % hints.length;
+        return parts.join("  ·  ");
+    };
+    while (true) {
+        const cols = process.stdout.columns || 80;
+        const rule = chalk.dim("─".repeat(cols));
+        const footerText = chalk.dim(`  ${getFooterText()}`);
+        // Ensure room below for top rule + prompt + bottom rule + footer (3 lines below start)
+        process.stdout.write("\n\n\n");
+        process.stdout.write("\x1b[3A\r");
+        // Print top rule, then prompt with bottom rule + footer rendered below
+        console.log(rule);
+        const input = await rawReadLine(chalk.dim("❯ "), [rule, footerText]);
+        const trimmed = input.trim();
+        if (!trimmed)
+            continue;
+        // Replace prompt frame with gray-background user message
+        // Move up 4 lines (footer, bottom rule, prompt, top rule) and clear them
+        process.stdout.write("\x1b[4A\r");
+        for (let i = 0; i < 4; i++)
+            process.stdout.write("\x1b[2K\x1b[1B");
+        process.stdout.write("\x1b[4A\r");
+        // Print user message with gray background, padded to full width
+        const msgText = `❯ ${trimmed}`;
+        const pad = Math.max(0, cols - msgText.length);
+        console.log(chalk.bgGray.white(msgText + " ".repeat(pad)));
+        if (trimmed === "\x03" || trimmed === "/quit" || trimmed === "/exit" || trimmed === "/q") {
+            shutdown();
+            break;
+        }
+        const spinner = ora({ text: "Thinking...", color: "cyan", discardStdin: false }).start();
+        try {
+            const response = await handleMessage(db, trimmed);
+            spinner.stop();
+            console.log(`\n${formatResponse(response)}\n`);
+        }
+        catch (err) {
+            spinner.stop();
+            console.error(chalk.red("Error: " + err.message));
+        }
+    }
+}

package/dist/cli/commands.d.ts

@@ -0,0 +1,13 @@
+export declare function runSync(): Promise<void>;
+export declare function runLink(): Promise<void>;
+export declare function showStatus(): void;
+export declare function showTransactions(options?: {
+    limit?: number;
+    category?: string;
+    merchant?: string;
+}): void;
+export declare function showSpending(period?: string): Promise<void>;
+export declare function showBudgets(): void;
+export declare function showGoals(): void;
+export declare function showScore(): void;
+export declare function showAlerts(): void;