plasalid 0.2.0

package/dist/cli/setup.js

@@ -0,0 +1,210 @@
+import chalk from "chalk";
+import inquirer from "inquirer";
+import { existsSync, mkdirSync } from "fs";
+import { resolve } from "path";
+import { config, saveConfig, getConfigPath, isConfigured, getPlasalidDir, getDataDir, } from "../config.js";
+import { generateKey } from "../db/encryption.js";
+import { createContextTemplate } from "../ai/context.js";
+import { printLogo } from "./logo.js";
+const DEFAULT_ANTHROPIC_MODEL = "claude-sonnet-4-6";
+const DEFAULT_OPENAI_BASE_URL = "http://localhost:11434/v1";
+function ensureDir(p) {
+    if (!existsSync(p))
+        mkdirSync(p, { recursive: true });
+}
+function readEnvDefaults() {
+    return {
+        anthropicKey: process.env.ANTHROPIC_API_KEY?.trim() || "",
+        userName: process.env.PLASALID_USER_NAME?.trim() || "",
+        openaiBaseURL: process.env.OPENAI_COMPATIBLE_BASE_URL?.trim() || "",
+        openaiKey: process.env.OPENAI_COMPATIBLE_API_KEY?.trim() || "",
+    };
+}
+function printBanner() {
+    console.log("");
+    printLogo();
+    console.log("");
+    console.log("Welcome to Plasalid. Let's get you set up — a few quick questions.");
+    console.log("");
+}
+function printSummary(dataDir) {
+    console.log("");
+    console.log(chalk.green("✓ Plasalid is configured."));
+    console.log(chalk.dim(`Config: ${getConfigPath()}`));
+    console.log(chalk.dim(`Data:   ${dataDir}`));
+    console.log("");
+    console.log("Next steps:");
+    console.log(`  1. Run ${chalk.cyan("plasalid data")} to drop your bank/credit card statments PDFs in.`);
+    console.log(`  2. Run ${chalk.cyan("plasalid scan")} to allow Plasalid to scan them.`);
+    console.log(`  3. Run ${chalk.cyan("plasalid")} to chat with your financial data.`);
+}
+/**
+ * Wraps inquirer's list prompt with a blank line above and below, and inserts
+ * a Separator(" ") row above the first choice so the question and the first
+ * option don't crowd each other. Mirrors `makePromptUser` in `src/cli/ux.ts`.
+ */
+async function listPrompt(opts) {
+    console.log("");
+    const answer = await inquirer.prompt([
+        {
+            type: "list",
+            name: opts.name,
+            message: opts.message,
+            choices: [new inquirer.Separator(" "), ...opts.choices],
+            default: opts.default,
+        },
+    ]);
+    console.log("");
+    return answer[opts.name];
+}
+async function promptUserName(env) {
+    const { userName } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "userName",
+            message: "What should I call you? (Your name)",
+            default: env.userName || (config.userName === "User" ? "" : config.userName),
+        },
+    ]);
+    return String(userName || "").trim();
+}
+async function promptProviderChoice() {
+    return listPrompt({
+        name: "providerChoice",
+        message: "Which AI provider would you like to use?",
+        choices: [
+            { name: "Anthropic (Claude)", value: "anthropic" },
+            {
+                name: "OpenAI compatible (OpenAI, LM Studio, vLLM, Ollama)",
+                value: "openai-compatible",
+            },
+        ],
+        default: "anthropic",
+    });
+}
+async function promptAnthropicCredentials(env) {
+    const { key, model } = await inquirer.prompt([
+        {
+            type: "password",
+            name: "key",
+            message: "Paste your Anthropic API key (https://console.anthropic.com):",
+            mask: "*",
+            default: env.anthropicKey || config.anthropicKey || undefined,
+            validate: (v) => v.startsWith("sk-") ? true : "Enter a key starting with sk-...",
+        },
+        {
+            type: "input",
+            name: "model",
+            message: "Which Claude model?",
+            default: config.providerType === "anthropic" && config.model
+                ? config.model
+                : DEFAULT_ANTHROPIC_MODEL,
+        },
+    ]);
+    return {
+        anthropicKey: key,
+        model: model || DEFAULT_ANTHROPIC_MODEL,
+    };
+}
+async function promptOpenAICompatCredentials(env) {
+    const { baseURL, apiKey, model } = await inquirer.prompt([
+        {
+            type: "input",
+            name: "baseURL",
+            message: "What's the base URL of your OpenAI-compatible server?",
+            default: env.openaiBaseURL ||
+                config.openaiCompatibleBaseURL ||
+                DEFAULT_OPENAI_BASE_URL,
+            validate: (v) => /^https?:\/\//.test(v) || "Must start with http:// or https://",
+        },
+        {
+            type: "password",
+            name: "apiKey",
+            message: "API key (leave blank if your server doesn't need one):",
+            mask: "*",
+            default: env.openaiKey || config.openaiCompatibleKey || undefined,
+        },
+        {
+            type: "input",
+            name: "model",
+            message: "Which model? (e.g. gpt-5, qwen3-coder:480b, deepseek-v3.1:671b)",
+            default: config.providerType === "openai-compatible" && config.model
+                ? config.model
+                : "",
+            validate: (v) => v.trim().length > 0 || "Required",
+        },
+    ]);
+    return {
+        openaiCompatibleBaseURL: baseURL,
+        openaiCompatibleKey: apiKey || "",
+        model: model.trim(),
+    };
+}
+async function promptCredentials(provider, env) {
+    return provider === "openai-compatible"
+        ? promptOpenAICompatCredentials(env)
+        : promptAnthropicCredentials(env);
+}
+async function ensureEncryptionKey() {
+    if (config.dbEncryptionKey) {
+        console.log("");
+        console.log(chalk.dim("Using the encryption key already on file."));
+        return;
+    }
+    const mode = await listPrompt({
+        name: "mode",
+        message: "Encrypt the local database? (recommended)",
+        choices: [
+            { name: "Yes (generate a strong key automatically)", value: "auto" },
+            { name: "Yes (I'll provide my own passphrase)", value: "manual" },
+            { name: "No (store plaintext)", value: "none" },
+        ],
+        default: "auto",
+    });
+    if (mode === "auto") {
+        saveConfig({ dbEncryptionKey: generateKey() });
+        console.log(chalk.dim(`Generated a new DB encryption key and saved it to ${getConfigPath()}.`));
+        return;
+    }
+    if (mode === "manual") {
+        const { key: passphrase } = await inquirer.prompt([
+            {
+                type: "password",
+                name: "key",
+                message: "Choose a passphrase (at least 8 characters):",
+                mask: "*",
+                validate: (v) => v.length >= 8 || "Use at least 8 characters.",
+            },
+        ]);
+        saveConfig({ dbEncryptionKey: passphrase });
+    }
+}
+function finalizeDataDir(userName) {
+    const dataDir = config.dataDir || resolve(getPlasalidDir(), "data");
+    saveConfig({ dataDir });
+    ensureDir(getDataDir());
+    createContextTemplate(userName);
+    return dataDir;
+}
+export async function runSetup() {
+    printBanner();
+    ensureDir(getPlasalidDir());
+    const env = readEnvDefaults();
+    const userName = await promptUserName(env);
+    const provider = await promptProviderChoice();
+    const credentials = await promptCredentials(provider, env);
+    saveConfig({
+        providerType: provider,
+        userName: userName || "User",
+        ...credentials,
+    });
+    await ensureEncryptionKey();
+    const dataDir = finalizeDataDir(userName || "User");
+    printSummary(dataDir);
+}
+export function ensureConfigured() {
+    if (!isConfigured()) {
+        console.error(chalk.red("Plasalid is not configured. Run `plasalid setup` first."));
+        process.exit(1);
+    }
+}

package/dist/cli/ux.d.ts

@@ -0,0 +1,38 @@
+import type { ProgressCallback } from "../ai/agent.js";
+/**
+ * Minimal spinner interface so callers don't care whether we're animating in
+ * a TTY or just printing plain lines. The same instance can be `pause()`d and
+ * `resume()`d around an inquirer prompt to keep the terminal sane.
+ */
+export interface SpinnerLike {
+    text: string;
+    succeed(text?: string): void;
+    fail(text?: string): void;
+    info(text?: string): void;
+    stop(): void;
+    /** TTY: clear the spinner line (ora.stop). Non-TTY: no-op. */
+    pause(): void;
+    /** TTY: resume animation with the current `text`. Non-TTY: no-op. */
+    resume(): void;
+}
+/**
+ * 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.
+ */
+export declare function statusSpinner(text: string): SpinnerLike;
+/**
+ * Build an `ask_user`-style prompter bound to the active spinner. Pauses the
+ * spinner around the inquirer call so it doesn't fight for the same terminal
+ * line, pads with blank lines for readability, and always includes a free-text
+ * escape on choice prompts ("Type a different answer…").
+ */
+export declare function makePromptUser(spinner: SpinnerLike): (prompt: string, options?: string[]) => 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.
+ * 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

@@ -0,0 +1,104 @@
+import inquirer from "inquirer";
+import ora from "ora";
+import { TOOL_LABELS } from "../ai/tools/index.js";
+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.
+ */
+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 {
+        text,
+        succeed: (t) => { if (t)
+            console.log(`✓ ${t}`); },
+        fail: (t) => { if (t)
+            console.log(`✗ ${t}`); },
+        info: (t) => { if (t)
+            console.log(`• ${t}`); },
+        stop: () => { },
+        pause: () => { },
+        resume: () => { },
+    };
+}
+/**
+ * Build an `ask_user`-style prompter bound to the active spinner. Pauses the
+ * spinner around the inquirer call so it doesn't fight for the same terminal
+ * line, pads with blank lines for readability, and always includes a free-text
+ * escape on choice prompts ("Type a different answer…").
+ */
+export function makePromptUser(spinner) {
+    const OTHER = "__plasalid_other__";
+    return async (prompt, options) => {
+        spinner.pause();
+        console.log("");
+        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 },
+                ]);
+                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);
+        }
+        finally {
+            console.log("");
+            spinner.resume();
+        }
+    };
+}
+/**
+ * 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.
+ * Optional `subject` (e.g. a file name) is appended in parentheses.
+ */
+export function makeAgentOnProgress(spinner, subject) {
+    const idlePhrase = pickThinking();
+    const subjectPart = subject ? ` (${subject})` : "";
+    return ({ phase, toolName, toolCount, elapsedMs }) => {
+        const elapsed = formatDuration(elapsedMs);
+        const suffix = toolCount > 0 ? ` (${toolCount} tool${toolCount === 1 ? "" : "s"}, ${elapsed})` : "";
+        if (phase === "tool" && toolName) {
+            spinner.text = `${TOOL_LABELS[toolName] ?? toolName}${suffix}`;
+        }
+        else {
+            spinner.text = `${idlePhrase}${subjectPart}${suffix}`;
+        }
+    };
+}

package/dist/config.d.ts

@@ -0,0 +1,21 @@
+import "dotenv/config";
+export interface PlasalidConfig {
+    anthropicKey: string;
+    model: string;
+    providerType: "anthropic" | "openai-compatible";
+    openaiCompatibleKey: string;
+    openaiCompatibleBaseURL: string;
+    displayLocale: string;
+    displayCurrency: string;
+    dbPath: string;
+    dbEncryptionKey: string;
+    dataDir: string;
+    userName: string;
+    thinkingBudget: number;
+}
+export declare function getPlasalidDir(): string;
+export declare function getConfigPath(): string;
+export declare function getDataDir(): string;
+export declare const config: PlasalidConfig;
+export declare function isConfigured(): boolean;
+export declare function saveConfig(partial: Partial<PlasalidConfig>): void;

package/dist/config.js

@@ -0,0 +1,66 @@
+import "dotenv/config";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { resolve } from "path";
+import { homedir } from "os";
+const PLASALID_DIR = resolve(homedir(), ".plasalid");
+export function getPlasalidDir() {
+    return PLASALID_DIR;
+}
+export function getConfigPath() {
+    return resolve(PLASALID_DIR, "config.json");
+}
+export function getDataDir() {
+    return config.dataDir;
+}
+function loadFileConfig() {
+    const configPath = getConfigPath();
+    if (!existsSync(configPath))
+        return {};
+    try {
+        return JSON.parse(readFileSync(configPath, "utf-8"));
+    }
+    catch {
+        return {};
+    }
+}
+function buildConfig() {
+    const file = loadFileConfig();
+    // Precedence: env > file > default. Env is checked first so a shell-exported
+    // override always wins over whatever is in ~/.plasalid/config.json.
+    return {
+        anthropicKey: process.env.ANTHROPIC_API_KEY || file.anthropicKey || "",
+        model: process.env.PLASALID_MODEL || file.model || "claude-sonnet-4-6",
+        providerType: process.env.PLASALID_PROVIDER ||
+            file.providerType ||
+            "anthropic",
+        openaiCompatibleKey: process.env.OPENAI_COMPATIBLE_API_KEY || file.openaiCompatibleKey || "",
+        openaiCompatibleBaseURL: process.env.OPENAI_COMPATIBLE_BASE_URL || file.openaiCompatibleBaseURL || "",
+        displayLocale: file.displayLocale || "th-TH",
+        displayCurrency: file.displayCurrency || "THB",
+        dbPath: process.env.PLASALID_DB_PATH || file.dbPath || resolve(PLASALID_DIR, "db.sqlite"),
+        dbEncryptionKey: process.env.PLASALID_DB_ENCRYPTION_KEY || file.dbEncryptionKey || "",
+        dataDir: process.env.PLASALID_DATA_DIR || file.dataDir || resolve(PLASALID_DIR, "data"),
+        userName: file.userName || "User",
+        thinkingBudget: file.thinkingBudget ?? 8000,
+    };
+}
+export const config = buildConfig();
+export function isConfigured() {
+    if (config.providerType === "openai-compatible") {
+        return !!config.openaiCompatibleBaseURL;
+    }
+    return !!config.anthropicKey;
+}
+export function saveConfig(partial) {
+    const configPath = getConfigPath();
+    if (!existsSync(PLASALID_DIR))
+        mkdirSync(PLASALID_DIR, { recursive: true });
+    const existing = loadFileConfig();
+    const merged = { ...existing, ...partial };
+    writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", { mode: 0o600 });
+    try {
+        chmodSync(configPath, 0o600);
+    }
+    catch { }
+    Object.assign(config, merged);
+}

package/dist/currency.d.ts

@@ -0,0 +1,6 @@
+export declare function getDisplayLocale(): string;
+export declare function getDisplayCurrency(): string;
+export declare function formatCurrencyAmount(amount: number, options?: {
+    minimumFractionDigits?: number;
+    maximumFractionDigits?: number;
+}): string;

package/dist/currency.js

@@ -0,0 +1,19 @@
+import { config } from "./config.js";
+const DEFAULT_LOCALE = "th-TH";
+const DEFAULT_CURRENCY = "THB";
+export function getDisplayLocale() {
+    return config.displayLocale || DEFAULT_LOCALE;
+}
+export function getDisplayCurrency() {
+    return config.displayCurrency || DEFAULT_CURRENCY;
+}
+export function formatCurrencyAmount(amount, options = {}) {
+    const locale = getDisplayLocale();
+    const currency = getDisplayCurrency();
+    return new Intl.NumberFormat(locale, {
+        style: "currency",
+        currency,
+        minimumFractionDigits: options.minimumFractionDigits,
+        maximumFractionDigits: options.maximumFractionDigits,
+    }).format(Math.abs(amount));
+}

package/dist/db/connection.d.ts

@@ -0,0 +1,5 @@
+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

@@ -0,0 +1,45 @@
+import Database from "libsql";
+import { config } from "../config.js";
+import { migrate } from "./schema.js";
+import { dirname } from "path";
+import { mkdirSync, existsSync, chmodSync } from "fs";
+let singleDb = null;
+function openDb(dbPath, encryptionKey) {
+    const dir = dirname(dbPath);
+    if (!existsSync(dir))
+        mkdirSync(dir, { recursive: true });
+    const opts = {};
+    if (encryptionKey) {
+        opts.encryptionCipher = "aes256cbc";
+        opts.encryptionKey = encryptionKey;
+    }
+    const db = new Database(dbPath, opts);
+    // Verify the database is accessible
+    try {
+        db.pragma("journal_mode = WAL");
+    }
+    catch (err) {
+        db.close();
+        throw new Error("Failed to open database. Wrong encryption key or corrupt database file. " +
+            "If you changed your encryption key, restore from backup or delete ~/.plasalid/db.sqlite to start fresh.");
+    }
+    db.pragma("foreign_keys = ON");
+    migrate(db);
+    try {
+        chmodSync(dbPath, 0o600);
+    }
+    catch { }
+    return db;
+}
+/** Get the single DB instance */
+export function getDb() {
+    if (!singleDb) {
+        singleDb = openDb(config.dbPath, config.dbEncryptionKey || undefined);
+    }
+    return singleDb;
+}
+/** Close all connections (for graceful shutdown) */
+export function closeAll() {
+    singleDb?.close();
+    singleDb = null;
+}

package/dist/db/encryption.d.ts

@@ -0,0 +1,11 @@
+/** Generate a 32-byte hex string suitable for use as a libsql encryption key. */
+export declare function generateKey(): string;
+/**
+ * Encrypt a secret (e.g. PDF password) at the application layer using AES-256-GCM.
+ * Key is derived from the DB encryption key via scrypt. When `dbKey` is empty
+ * (user opted out of DB encryption), this is a passthrough.
+ *
+ * Output format: `gcm:<iv-hex>:<tag-hex>:<ciphertext-hex>`
+ */
+export declare function encryptSecret(plaintext: string, dbKey: string): string;
+export declare function decryptSecret(ciphertext: string, dbKey: string): string;

package/dist/db/encryption.js

@@ -0,0 +1,45 @@
+import { createCipheriv, createDecipheriv, randomBytes, scryptSync } from "crypto";
+const SECRET_KEY_SALT = "plasalid-secret-v1";
+const FORMAT_PREFIX = "gcm:";
+/** Generate a 32-byte hex string suitable for use as a libsql encryption key. */
+export function generateKey() {
+    return randomBytes(32).toString("hex");
+}
+function deriveSecretKey(dbKey) {
+    return scryptSync(dbKey, SECRET_KEY_SALT, 32);
+}
+/**
+ * Encrypt a secret (e.g. PDF password) at the application layer using AES-256-GCM.
+ * Key is derived from the DB encryption key via scrypt. When `dbKey` is empty
+ * (user opted out of DB encryption), this is a passthrough.
+ *
+ * Output format: `gcm:<iv-hex>:<tag-hex>:<ciphertext-hex>`
+ */
+export function encryptSecret(plaintext, dbKey) {
+    if (!dbKey)
+        return plaintext;
+    const key = deriveSecretKey(dbKey);
+    const iv = randomBytes(12);
+    const cipher = createCipheriv("aes-256-gcm", key, iv);
+    const ct = Buffer.concat([cipher.update(plaintext, "utf8"), cipher.final()]);
+    const tag = cipher.getAuthTag();
+    return `${FORMAT_PREFIX}${iv.toString("hex")}:${tag.toString("hex")}:${ct.toString("hex")}`;
+}
+export function decryptSecret(ciphertext, dbKey) {
+    if (!dbKey || !ciphertext.startsWith(FORMAT_PREFIX))
+        return ciphertext;
+    const rest = ciphertext.slice(FORMAT_PREFIX.length);
+    const parts = rest.split(":");
+    if (parts.length !== 3) {
+        throw new Error("Malformed encrypted secret.");
+    }
+    const [ivHex, tagHex, ctHex] = parts;
+    const key = deriveSecretKey(dbKey);
+    const decipher = createDecipheriv("aes-256-gcm", key, Buffer.from(ivHex, "hex"));
+    decipher.setAuthTag(Buffer.from(tagHex, "hex"));
+    const pt = Buffer.concat([
+        decipher.update(Buffer.from(ctHex, "hex")),
+        decipher.final(),
+    ]);
+    return pt.toString("utf8");
+}

package/dist/db/helpers.d.ts

@@ -0,0 +1,16 @@
+export declare function resolvePeriod(period: string): {
+    start: string;
+    end: string;
+};
+export declare function shiftDays(date: Date, days: number): Date;
+export declare function simulatePayoff(balance: number, annualRate: number, monthlyPayment: number): {
+    months: number;
+    totalInterest: number;
+    schedule: {
+        month: number;
+        payment: number;
+        principal: number;
+        interest: number;
+        remaining: number;
+    }[];
+};

package/dist/db/helpers.js

@@ -0,0 +1,45 @@
+export function resolvePeriod(period) {
+    const now = new Date();
+    const y = now.getFullYear();
+    const m = now.getMonth();
+    switch (period) {
+        case "this_month":
+            return { start: new Date(y, m, 1).toISOString().slice(0, 10), end: now.toISOString().slice(0, 10) };
+        case "last_month":
+            return { start: new Date(y, m - 1, 1).toISOString().slice(0, 10), end: new Date(y, m, 0).toISOString().slice(0, 10) };
+        case "this_year":
+            return { start: new Date(y, 0, 1).toISOString().slice(0, 10), end: now.toISOString().slice(0, 10) };
+        case "last_30":
+            return { start: shiftDays(now, -30).toISOString().slice(0, 10), end: now.toISOString().slice(0, 10) };
+        case "last_90":
+            return { start: shiftDays(now, -90).toISOString().slice(0, 10), end: now.toISOString().slice(0, 10) };
+        default: {
+            const parts = period.split(":");
+            if (parts.length === 2)
+                return { start: parts[0], end: parts[1] };
+            throw new Error(`Unknown period: ${period}. Use this_month, last_month, this_year, last_30, last_90, or START:END`);
+        }
+    }
+}
+export function shiftDays(date, days) {
+    const d = new Date(date);
+    d.setDate(d.getDate() + days);
+    return d;
+}
+export function simulatePayoff(balance, annualRate, monthlyPayment) {
+    const monthlyRate = annualRate / 100 / 12;
+    let remaining = balance;
+    let totalInterest = 0;
+    const schedule = [];
+    let month = 0;
+    while (remaining > 0.01 && month < 600) {
+        month++;
+        const interest = remaining * monthlyRate;
+        const payment = Math.min(monthlyPayment, remaining + interest);
+        const principal = payment - interest;
+        remaining -= principal;
+        totalInterest += interest;
+        schedule.push({ month, payment: Math.round(payment * 100) / 100, principal: Math.round(principal * 100) / 100, interest: Math.round(interest * 100) / 100, remaining: Math.round(Math.max(0, remaining) * 100) / 100 });
+    }
+    return { months: month, totalInterest: Math.round(totalInterest * 100) / 100, schedule };
+}