plasalid 0.6.9 → 0.7.0

package/dist/cli/ink/ListBrowser.js

@@ -0,0 +1,154 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { memo, useEffect, useMemo, useState } from "react";
+import { Box, Text, useApp, useInput, useStdout } from "ink";
+const HEADER_LINES = 2; // title + rule
+const FOOTER_LINES = 2; // rule + hint
+const SUMMARY_LINES = 1; // optional aggregate footer
+const RESERVED_LINES = HEADER_LINES + FOOTER_LINES + SUMMARY_LINES + 1; // +1 breathing room
+/**
+ * Alternate-screen list browser shell. The type-specific behavior lives in the
+ * `adapter` — this component owns terminal dimensions, the edge-scroll window,
+ * cursor / search / expand state, key dispatch, and the header/footer chrome.
+ *
+ * Render strategy: a memoized `Row` short-circuits when its props (a single
+ * pre-composed string + an optional expanded node) are unchanged. Combined
+ * with the edge-scroll window, most cursor moves only invalidate the two
+ * rows whose `isCursor` flag flipped.
+ */
+export function ListBrowser({ adapter }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [cols, setCols] = useState(() => stdout?.columns ?? 100);
+    const [rows, setRows] = useState(() => stdout?.rows ?? 24);
+    useEffect(() => {
+        if (!stdout)
+            return;
+        const onResize = () => {
+            setCols(stdout.columns ?? 100);
+            setRows(stdout.rows ?? 24);
+        };
+        stdout.on("resize", onResize);
+        return () => { stdout.off("resize", onResize); };
+    }, [stdout]);
+    const [search, setSearch] = useState("");
+    const [searchMode, setSearchMode] = useState(false);
+    const [cursor, setCursor] = useState(0);
+    const [expandedId, setExpandedId] = useState(null);
+    const [scrollOffset, setScrollOffset] = useState(0);
+    const filtered = useMemo(() => {
+        const needle = search.trim().toLowerCase();
+        if (!needle)
+            return adapter.items;
+        return adapter.items.filter(item => adapter.matches(item, needle));
+    }, [adapter, search]);
+    const viewportSize = Math.max(5, rows - RESERVED_LINES);
+    // When a row is expanded, its body steals N lines from the visible list. Shrink
+    // the slice so the total rendered height (header + N collapsed + expanded body
+    // + footer) never exceeds the terminal.
+    const expandedItem = expandedId != null
+        ? filtered.find(item => adapter.getId(item) === expandedId) ?? null
+        : null;
+    const expandedHeight = expandedItem && adapter.getExpandedHeight
+        ? adapter.getExpandedHeight(expandedItem)
+        : 0;
+    const effectiveViewportSize = Math.max(1, viewportSize - expandedHeight);
+    // Keep cursor inside the filtered range when the list shrinks.
+    useEffect(() => {
+        if (cursor > 0 && cursor >= filtered.length) {
+            setCursor(Math.max(0, filtered.length - 1));
+        }
+    }, [filtered.length, cursor]);
+    // Edge-scroll: only nudge the window when the cursor escapes it.
+    useEffect(() => {
+        setScrollOffset(prev => {
+            if (filtered.length === 0)
+                return 0;
+            const maxOffset = Math.max(0, filtered.length - effectiveViewportSize);
+            let next = prev;
+            if (cursor < next)
+                next = cursor;
+            else if (cursor >= next + effectiveViewportSize)
+                next = cursor - effectiveViewportSize + 1;
+            return Math.min(next, maxOffset);
+        });
+    }, [cursor, effectiveViewportSize, filtered.length]);
+    useInput((input, key) => {
+        if (searchMode) {
+            if (key.return || key.escape) {
+                setSearchMode(false);
+                return;
+            }
+            if (key.backspace || key.delete) {
+                setSearch(prev => prev.slice(0, -1));
+                return;
+            }
+            if (input && !key.ctrl && !key.meta)
+                setSearch(prev => prev + input);
+            return;
+        }
+        if (input === "q" || key.escape) {
+            exit();
+            return;
+        }
+        if (input === "/") {
+            setSearchMode(true);
+            return;
+        }
+        const last = Math.max(0, filtered.length - 1);
+        const move = (delta) => {
+            setExpandedId(null);
+            setCursor(c => Math.max(0, Math.min(last, c + delta)));
+        };
+        if (key.upArrow || input === "k") {
+            move(-1);
+            return;
+        }
+        if (key.downArrow || input === "j") {
+            move(1);
+            return;
+        }
+        if (key.pageUp) {
+            move(-viewportSize);
+            return;
+        }
+        if (key.pageDown) {
+            move(viewportSize);
+            return;
+        }
+        if (input === "g") {
+            setExpandedId(null);
+            setCursor(0);
+            return;
+        }
+        if (input === "G") {
+            setExpandedId(null);
+            setCursor(last);
+            return;
+        }
+        if (key.return) {
+            const item = filtered[cursor];
+            if (item) {
+                const id = adapter.getId(item);
+                setExpandedId(prev => prev === id ? null : id);
+            }
+            return;
+        }
+    });
+    const ruleWidth = Math.min(cols, 120);
+    const visibleEnd = Math.min(filtered.length, scrollOffset + effectiveViewportSize);
+    const visible = filtered.slice(scrollOffset, visibleEnd);
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsxs(Text, { children: [_jsx(Text, { bold: true, children: adapter.title }), _jsx(Text, { dimColor: true, children: `  ·  ${filtered.length} results` }), adapter.filterSummary ? _jsx(Text, { dimColor: true, children: `  ·  ${adapter.filterSummary}` }) : null, filtered.length > viewportSize ? (_jsx(Text, { dimColor: true, children: `  ·  ${Math.min(cursor + 1, filtered.length)}/${filtered.length}` })) : null] }), _jsx(Text, { dimColor: true, children: "─".repeat(ruleWidth) }), filtered.length === 0 ? (_jsx(Text, { color: "yellow", children: adapter.emptyMessage ?? "No results match the current filter." })) : (_jsx(Box, { flexDirection: "column", children: visible.map((item, i) => {
+                    const idx = scrollOffset + i;
+                    const isCursor = idx === cursor;
+                    const id = adapter.getId(item);
+                    const isExpanded = expandedId === id;
+                    const rendered = adapter.renderRow(item, { isCursor, isExpanded, cols });
+                    const expandedBody = isExpanded && adapter.renderExpanded
+                        ? adapter.renderExpanded(item)
+                        : null;
+                    return _jsx(Row, { rendered: rendered, expandedBody: expandedBody }, id);
+                }) })), _jsx(Text, { dimColor: true, children: "─".repeat(ruleWidth) }), adapter.summary ? _jsx(Box, { children: adapter.summary }) : null, searchMode ? (_jsxs(Text, { children: [_jsx(Text, { color: "cyan", children: "/ " }), search, _jsx(Text, { color: "cyan", children: "_" }), _jsx(Text, { dimColor: true, children: "  (Enter/Esc to apply)" })] })) : (_jsx(Text, { dimColor: true, children: `↑↓ navigate · Enter expand · / search${search ? `  (filter: "${search}")` : ""}  · q quit` }))] }));
+}
+const Row = memo(function Row({ rendered, expandedBody, }) {
+    return (_jsxs(Box, { flexDirection: "column", children: [_jsx(Text, { children: rendered }), expandedBody] }));
+});

package/dist/cli/ink/TransactionsBrowser.d.ts

@@ -0,0 +1,6 @@
+import { type PostingRow } from "../../db/queries/transactions.js";
+export interface TransactionsBrowserProps {
+    postings: PostingRow[];
+    filterSummary: string;
+}
+export declare function TransactionsBrowser({ postings, filterSummary }: TransactionsBrowserProps): import("react/jsx-runtime").JSX.Element;

package/dist/cli/ink/TransactionsBrowser.js

@@ -0,0 +1,87 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { memo, useMemo } from "react";
+import { Box, Text } from "ink";
+import chalk from "chalk";
+import { formatAmount } from "../../currency.js";
+import { truncateMiddle, padRight } from "../helper.js";
+import { ListBrowser } from "./ListBrowser.js";
+import { groupByTransaction, } from "../../db/queries/transactions.js";
+const RECURRING_MARKER = "[R]";
+const DATE_WIDTH = 10;
+const MIN_DESC_WIDTH = 12;
+export function TransactionsBrowser({ postings, filterSummary }) {
+    const items = useMemo(() => groupByTransaction(postings), [postings]);
+    const adapter = useMemo(() => ({
+        title: "Transactions",
+        filterSummary,
+        items,
+        getId: g => g.transaction_id,
+        renderRow: (g, ctx) => renderTransactionRow(g, ctx.isCursor, ctx.isExpanded, ctx.cols),
+        renderExpanded: g => _jsx(PostingsView, { group: g }),
+        getExpandedHeight: g => g.postings.length,
+        matches: groupMatches,
+        emptyMessage: "No transactions match the current filter.",
+    }), [items, filterSummary]);
+    return _jsx(ListBrowser, { adapter: adapter });
+}
+function renderTransactionRow(g, isCursor, isExpanded, cols) {
+    const totals = transactionTotals(g);
+    const amountRaw = formatAmount(totals.amount, totals.currency);
+    const recurringRaw = g.recurrence_id ? RECURRING_MARKER : "";
+    // Layout: "M DDDDDDDDDD  <desc><merchant>  <amount><recurring>"
+    // Fixed widths sum to: marker(1) + space + date(10) + 2 + 2 + amount + (recurring ? 2 + len : 0)
+    const fixedWidth = 1 + 1 + DATE_WIDTH + 2 + 2 + amountRaw.length + (recurringRaw ? 2 + RECURRING_MARKER.length : 0);
+    const available = Math.max(MIN_DESC_WIDTH, cols - fixedWidth - 2);
+    const merchantRaw = g.merchant ? `  · ${g.merchant}` : "";
+    let description;
+    let merchantText;
+    if ((g.description.length + merchantRaw.length) <= available) {
+        description = g.description;
+        merchantText = merchantRaw;
+    }
+    else if (merchantRaw && merchantRaw.length > available / 2) {
+        description = truncateMiddle(g.description, available);
+        merchantText = "";
+    }
+    else {
+        description = truncateMiddle(g.description, Math.max(MIN_DESC_WIDTH, available - merchantRaw.length));
+        merchantText = merchantRaw;
+    }
+    const marker = isExpanded ? "▾" : isCursor ? "▸" : " ";
+    const date = chalk.dim(g.date);
+    const desc = isCursor ? chalk.cyan.bold(description) : description;
+    const merchant = merchantText ? chalk.green(merchantText) : "";
+    const amount = isCursor ? chalk.cyan(amountRaw) : amountRaw;
+    const recurring = recurringRaw ? chalk.dim(`  ${recurringRaw}`) : "";
+    return `${marker} ${date}  ${desc}${merchant}  ${amount}${recurring}`;
+}
+const PostingsView = memo(function PostingsView({ group }) {
+    const accountWidth = Math.max(...group.postings.map(p => (p.account_name ?? p.account_id).length));
+    return (_jsx(Box, { flexDirection: "column", marginLeft: 6, children: group.postings.map(p => {
+            const side = p.debit > 0 ? "DR" : "CR";
+            const amount = p.debit > 0 ? p.debit : p.credit;
+            const color = p.debit > 0 ? chalk.cyan : chalk.magenta;
+            const account = padRight(p.account_name ?? p.account_id, accountWidth);
+            const memo = p.memo ? chalk.dim(`    ${p.memo}`) : "";
+            return (_jsx(Text, { children: `${account}  ${color(`${side} ${formatAmount(amount, p.currency)}`)}${memo}` }, p.id));
+        }) }));
+});
+function transactionTotals(g) {
+    let amount = 0;
+    for (const p of g.postings)
+        amount += p.debit;
+    return { amount, currency: g.postings[0]?.currency ?? "THB" };
+}
+function groupMatches(g, needle) {
+    if (g.description.toLowerCase().includes(needle))
+        return true;
+    if (g.merchant && g.merchant.toLowerCase().includes(needle))
+        return true;
+    for (const p of g.postings) {
+        if (p.memo && p.memo.toLowerCase().includes(needle))
+            return true;
+        if (p.account_name && p.account_name.toLowerCase().includes(needle))
+            return true;
+    }
+    return false;
+}

package/dist/cli/ink/hooks/useFooterText.js

@@ -2,17 +2,36 @@ import { useEffect, useMemo, useState } from "react";
 import chalk from "chalk";
 const HINTS = [
     "try: what's my net worth?",
-    "try: am I spending more than I earn?",
-    "try: how much did I save last month?",
-    "try: where did my money go last month?",
-    "try: biggest expense this month?",
-    "try: top spending categories this month?",
-    "try: total credit card debt?",
-    "try: next bill due?",
-    "try: list my subscriptions",
-    "try: how much liquid cash do I have?",
-    "try: net worth trend this year?",
-    "try: open unknowns from last scan?",
+    "try: how many months of runway do I have?",
+    "try: which debt costs me the most?",
+    "try: when am I credit card free?",
+    "try: what's my savings rate?",
+    "try: how far am I from retiring?",
+    "try: any unused subscriptions?",
+    "try: fixed vs variable spend?",
+    "try: biggest category jump this week?",
+    "try: what changed this month?",
+    "try: gaining ground or losing it?",
+    "try: which account drives my net worth?",
+    "try: top 5 shopping this month?",
+    "try: how much went to food this month?",
+    "try: average daily burn rate?",
+    "try: how much cash did I withdraw?",
+    "try: how big should my emergency fund be?",
+    "try: any duplicate charges?",
+    "try: total spent this year?",
+    "try: biggest one-off purchase this year?",
+    "try: where can I cut expense easily?",
+    "try: idle cash sitting anywhere?",
+    "try: any account untouched in 6 months?",
+    "try: checking vs savings split?",
+    "try: transfers between my accounts?",
+    "try: which account grew the most?",
+    "try: total debt right now?",
+    "try: how much went to interest last month?",
+    "try: any debt growing instead of shrinking?",
+    "try: avalanche or snowball — what's faster?",
+    "try: am I paying more than the minimum?",
 ];
 export function useFooterText(db) {
     const [tick, setTick] = useState(0);

package/dist/cli/ink/runBrowser.d.ts

@@ -0,0 +1,7 @@
+import type { ReactElement } from "react";
+/**
+ * Mount an Ink browser in the terminal's alternate-screen buffer so frame
+ * swaps are atomic (no visible clear-and-rewrite cycle, no scrollback
+ * pollution). Restores the original buffer on exit, error, or Ctrl-C.
+ */
+export declare function runBrowser(node: ReactElement): Promise<void>;

package/dist/cli/ink/runBrowser.js

@@ -0,0 +1,24 @@
+import { render } from "ink";
+const ENTER_ALT_SCREEN = "\x1b[?1049h\x1b[?25l"; // enter alternate buffer, hide cursor
+const LEAVE_ALT_SCREEN = "\x1b[?25h\x1b[?1049l"; // show cursor, leave alternate buffer
+/**
+ * Mount an Ink browser in the terminal's alternate-screen buffer so frame
+ * swaps are atomic (no visible clear-and-rewrite cycle, no scrollback
+ * pollution). Restores the original buffer on exit, error, or Ctrl-C.
+ */
+export async function runBrowser(node) {
+    process.stdout.write(ENTER_ALT_SCREEN);
+    const restore = () => { process.stdout.write(LEAVE_ALT_SCREEN); };
+    const onSig = () => { restore(); process.exit(130); };
+    process.once("SIGINT", onSig);
+    process.once("SIGTERM", onSig);
+    try {
+        const instance = render(node);
+        await instance.waitUntilExit();
+    }
+    finally {
+        process.removeListener("SIGINT", onSig);
+        process.removeListener("SIGTERM", onSig);
+        restore();
+    }
+}

package/dist/cli/ux.d.ts

@@ -18,8 +18,7 @@ export interface SpinnerLike {
 }
 /**
  * One blank line above every spinner so output doesn't crowd whatever printed
- * before. TTY uses ora; non-TTY (cron, piped output) prints the leading text
- * once and turns succeed/fail/info into prefixed plain lines.
+ * before. TTY uses ora; non-TTY (cron, piped output) prints lines as it goes.
  */
 export declare function statusSpinner(text: string): SpinnerLike;
 /**
@@ -31,9 +30,9 @@ export declare function statusSpinner(text: string): SpinnerLike;
 export declare function makePromptUser(spinner: SpinnerLike): (prompt: string, options?: string[], facts?: PromptUserFacts) => Promise<string>;
 /**
  * Standard agent-progress → spinner-text bridge.
- * - `phase: "tool"` maps the tool name through `TOOL_LABELS`.
- * - `phase: "responding"` picks a stable thinking phrase per session and shows
- *   the elapsed time + tool count.
+ * - `tool` maps the tool name through `TOOL_LABELS`.
+ * - `responding` picks a stable thinking phrase per session and shows the
+ *   elapsed time + tool count.
  * Optional `subject` (e.g. a file name) is appended in parentheses.
  */
 export declare function makeAgentOnProgress(spinner: SpinnerLike, subject?: string): ProgressCallback;

package/dist/cli/ux.js

@@ -6,33 +6,57 @@ import { pickThinking } from "../ai/thinking.js";
 import { formatDuration } from "./format.js";
 /**
  * One blank line above every spinner so output doesn't crowd whatever printed
- * before. TTY uses ora; non-TTY (cron, piped output) prints the leading text
- * once and turns succeed/fail/info into prefixed plain lines.
+ * before. TTY uses ora; non-TTY (cron, piped output) prints lines as it goes.
  */
 export function statusSpinner(text) {
     console.log("");
-    if (process.stdout.isTTY) {
-        const spinner = ora({ text }).start();
-        return {
-            get text() { return spinner.text; },
-            set text(t) { spinner.text = t; },
-            succeed: (t) => { spinner.succeed(t); },
-            fail: (t) => { spinner.fail(t); },
-            info: (t) => { spinner.info(t); },
-            stop: () => { spinner.stop(); },
-            pause: () => { spinner.stop(); },
-            resume: () => { spinner.start(); },
-        };
-    }
-    console.log(text);
+    return process.stdout.isTTY ? oraSpinner(text) : plainSpinner(text);
+}
+function oraSpinner(text) {
+    const s = ora({ text }).start();
+    return {
+        get text() {
+            return s.text;
+        },
+        set text(t) {
+            s.text = t;
+        },
+        succeed: (t) => {
+            s.succeed(t);
+        },
+        fail: (t) => {
+            s.fail(t);
+        },
+        info: (t) => {
+            s.info(t);
+        },
+        stop: () => {
+            s.stop();
+        },
+        pause: () => {
+            s.stop();
+        },
+        resume: () => {
+            s.start();
+        },
+    };
+}
+function plainSpinner(initial) {
+    console.log(initial);
     return {
-        text,
-        succeed: (t) => { if (t)
-            console.log(`✓ ${t}`); },
-        fail: (t) => { if (t)
-            console.log(`✗ ${t}`); },
-        info: (t) => { if (t)
-            console.log(`• ${t}`); },
+        text: initial,
+        succeed: (t) => {
+            if (t)
+                console.log(`✓ ${t}`);
+        },
+        fail: (t) => {
+            if (t)
+                console.log(`✗ ${t}`);
+        },
+        info: (t) => {
+            if (t)
+                console.log(`• ${t}`);
+        },
         stop: () => { },
         pause: () => { },
         resume: () => { },
@@ -45,50 +69,14 @@ export function statusSpinner(text) {
  * escape on choice prompts ("Type a different answer…").
  */
 export function makePromptUser(spinner) {
-    const OTHER = "__plasalid_other__";
     return async (prompt, options, facts) => {
         spinner.pause();
         console.log("");
-        const factsLine = facts ? formatFacts(facts) : null;
-        if (factsLine)
-            console.log(factsLine);
+        printFacts(facts);
         try {
-            if (options && options.length > 0) {
-                const choices = [
-                    // A blank-ish separator gives breathing room between the question
-                    // line and the first choice — inquirer renders separators inline,
-                    // and rejects truly-empty strings, so we use a single space.
-                    new inquirer.Separator(" "),
-                    ...options.map(o => ({ name: o, value: o })),
-                    new inquirer.Separator(),
-                    { name: "Type a different answer…", value: OTHER },
-                ];
-                const { choice } = await inquirer.prompt([
-                    {
-                        type: "list",
-                        name: "choice",
-                        message: prompt,
-                        choices,
-                        // Stop the cursor at the top/bottom instead of wrapping forever —
-                        // the wrap-around default makes the list feel infinite.
-                        loop: false,
-                        // Show every choice without paginating. Floor of 10 keeps the
-                        // prompt height predictable for small option sets.
-                        pageSize: Math.max(choices.length, 10),
-                    },
-                ]);
-                if (choice === OTHER) {
-                    const { freeform } = await inquirer.prompt([
-                        { type: "input", name: "freeform", message: "Your answer:" },
-                    ]);
-                    return String(freeform).trim();
-                }
-                return String(choice);
-            }
-            const { answer } = await inquirer.prompt([
-                { type: "input", name: "answer", message: prompt },
-            ]);
-            return String(answer);
+            return options?.length
+                ? await askList(prompt, options)
+                : await askInput(prompt);
         }
         finally {
             console.log("");
@@ -96,11 +84,44 @@ export function makePromptUser(spinner) {
         }
     };
 }
+function printFacts(facts) {
+    const line = facts ? formatFacts(facts) : null;
+    if (line)
+        console.log(line);
+}
+const OTHER_SENTINEL = "__plasalid_other__";
+async function askList(prompt, options) {
+    const choices = [
+        new inquirer.Separator(" "),
+        ...options.map((o) => ({ name: o, value: o })),
+        new inquirer.Separator(),
+        { name: "Type a different answer…", value: OTHER_SENTINEL },
+    ];
+    const { choice } = await inquirer.prompt([
+        {
+            type: "list",
+            name: "choice",
+            message: prompt,
+            choices,
+            loop: false,
+            pageSize: Math.max(choices.length, 10),
+        },
+    ]);
+    return choice === OTHER_SENTINEL
+        ? await askInput("Your answer:")
+        : String(choice);
+}
+async function askInput(prompt) {
+    const { answer } = await inquirer.prompt([
+        { type: "input", name: "answer", message: prompt },
+    ]);
+    return String(answer).trim();
+}
 /**
  * Standard agent-progress → spinner-text bridge.
- * - `phase: "tool"` maps the tool name through `TOOL_LABELS`.
- * - `phase: "responding"` picks a stable thinking phrase per session and shows
- *   the elapsed time + tool count.
+ * - `tool` maps the tool name through `TOOL_LABELS`.
+ * - `responding` picks a stable thinking phrase per session and shows the
+ *   elapsed time + tool count.
  * Optional `subject` (e.g. a file name) is appended in parentheses.
  */
 export function makeAgentOnProgress(spinner, subject) {

package/dist/db/connection.d.ts

@@ -1,5 +1,3 @@
 import Database from "libsql";
 /** Get the single DB instance */
 export declare function getDb(): Database.Database;
-/** Close all connections (for graceful shutdown) */
-export declare function closeAll(): void;

package/dist/db/connection.js

@@ -38,8 +38,3 @@ export function getDb() {
     }
     return singleDb;
 }
-/** Close all connections (for graceful shutdown) */
-export function closeAll() {
-    singleDb?.close();
-    singleDb = null;
-}

package/dist/db/queries/files.d.ts

@@ -0,0 +1,11 @@
+import type Database from "libsql";
+export interface ScannedFileTotals {
+    scanned: number;
+    pending: number;
+    failed: number;
+}
+/**
+ * Bucket the `scanned_files` table by its `status` enum. Missing buckets are
+ * filled with 0 so callers can render a stable shape without null checks.
+ */
+export declare function countScannedFiles(db: Database.Database): ScannedFileTotals;

package/dist/db/queries/files.js

@@ -0,0 +1,16 @@
+/**
+ * Bucket the `scanned_files` table by its `status` enum. Missing buckets are
+ * filled with 0 so callers can render a stable shape without null checks.
+ */
+export function countScannedFiles(db) {
+    const rows = db
+        .prepare(`SELECT status, COUNT(*) AS n FROM scanned_files GROUP BY status`)
+        .all();
+    const totals = { scanned: 0, pending: 0, failed: 0 };
+    for (const row of rows) {
+        if (row.status === "scanned" || row.status === "pending" || row.status === "failed") {
+            totals[row.status] = row.n;
+        }
+    }
+    return totals;
+}

package/dist/db/queries/recurrences.d.ts

@@ -31,3 +31,10 @@ export interface RecordRecurrenceInput {
 }
 export declare function recordRecurrence(db: Database.Database, input: RecordRecurrenceInput): string;
 export declare function linkTransactionToRecurrence(db: Database.Database, transactionId: string, recurrenceId: string): void;
+export interface RecurringSummary {
+    count: number;
+    /** Sum of every recurrence's amount_typical normalized to a monthly cadence.
+     *  Excludes rows whose amount is null (system can't estimate without one). */
+    monthly_estimate: number;
+}
+export declare function getRecurringSummary(db: Database.Database): RecurringSummary;

package/dist/db/queries/recurrences.js

@@ -126,3 +126,24 @@ function addDays(dateIso, days) {
     const next = new Date(t + days * 86_400_000);
     return next.toISOString().slice(0, 10);
 }
+const MONTHLY_MULTIPLIER = {
+    weekly: 52 / 12,
+    biweekly: 26 / 12,
+    monthly: 1,
+    annually: 1 / 12,
+};
+export function getRecurringSummary(db) {
+    const rows = db
+        .prepare(`SELECT frequency, amount_typical FROM recurrences`)
+        .all();
+    let monthly = 0;
+    for (const r of rows) {
+        if (r.amount_typical == null)
+            continue;
+        const mult = MONTHLY_MULTIPLIER[r.frequency];
+        if (mult == null)
+            continue;
+        monthly += r.amount_typical * mult;
+    }
+    return { count: rows.length, monthly_estimate: Math.round(monthly * 100) / 100 };
+}