plasalid 0.7.9 → 0.8.0

package/dist/cli/setup.js

@@ -6,26 +6,24 @@ import { config, saveConfig, getConfigPath, getPlasalidDir, getDataDir, } from "
 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";
+import { statusSpinner } from "./ux.js";
+const DEFAULT_LOCAL_OPENAI_BASE_URL = "http://localhost:11434/v1";
+const RECOMMENDED_MODEL = {
+    anthropic: "claude-sonnet-4-6",
+    openai: "gpt-5.4-mini",
+    gemini: "gemini-3.5-flash",
+};
 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("");
+    console.log(chalk.dim("Time to power up your engine — wire in an AI, pick a model, seal your vault."));
 }
 function printSummary(dataDir) {
     console.log("");
@@ -42,9 +40,10 @@ function printSummary(dataDir) {
     console.log(chalk.dim(`  Optional: ${chalk.cyan(`plasalid record "..."`)}${chalk.dim(" to record manual/undocumented transaction, balance, or account at any time.")}`));
 }
 /**
- * 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`.
+ * Each helper prints one leading blank line. Inquirer collapses the resolved
+ * prompt to a single line, so each new helper produces exactly one blank row
+ * between adjacent questions. passwordPrompt has no `default` because the
+ * masked-but-pre-filled state confuses "press Enter to keep".
  */
 async function listPrompt(opts) {
     console.log("");
@@ -53,134 +52,187 @@ async function listPrompt(opts) {
             type: "list",
             name: opts.name,
             message: opts.message,
-            choices: [new inquirer.Separator(" "), ...opts.choices],
+            choices: opts.choices,
             default: opts.default,
         },
     ]);
-    console.log("");
     return answer[opts.name];
 }
-async function promptUserName(env) {
-    const { userName } = await inquirer.prompt([
+async function inputPrompt(opts) {
+    console.log("");
+    const answer = await inquirer.prompt([
         {
             type: "input",
-            name: "userName",
-            message: "What should I call you? (Your name)",
-            default: env.userName || (config.userName === "User" ? "" : config.userName),
+            name: opts.name,
+            message: opts.message,
+            default: opts.default,
+            validate: opts.validate,
+        },
+    ]);
+    return String(answer[opts.name] ?? "").trim();
+}
+async function passwordPrompt(opts) {
+    console.log("");
+    const answer = await inquirer.prompt([
+        {
+            type: "password",
+            name: opts.name,
+            message: opts.message,
+            mask: "*",
+            validate: opts.validate,
         },
     ]);
-    return String(userName || "").trim();
+    return String(answer[opts.name] ?? "");
+}
+function savedModelFor(vendor) {
+    switch (vendor) {
+        case "anthropic":
+            return config.anthropicModel;
+        case "openai":
+            return config.openaiModel;
+        case "gemini":
+            return config.geminiModel;
+        case "openai-compat":
+            return config.openaiCompatModel;
+    }
+}
+async function promptUserName() {
+    return inputPrompt({
+        name: "userName",
+        message: "What should I call you? (Your name)",
+    });
 }
 async function promptProviderChoice() {
     return listPrompt({
-        name: "providerChoice",
+        name: "vendor",
         message: "Which AI provider would you like to use?",
         choices: [
-            { name: "Anthropic (Claude)", value: "anthropic" },
+            { name: "Anthropic", value: "anthropic" },
+            { name: "OpenAI", value: "openai" },
+            { name: "Google Gemini", value: "gemini" },
             {
-                name: "OpenAI compatible (OpenAI, LM Studio, vLLM, Ollama)",
-                value: "openai-compatible",
+                name: "OpenAI Compatible (LM Studio, vLLM, Ollama, other)",
+                value: "openai-compat",
             },
         ],
         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,
-    };
+/**
+ * Model default: the value previously saved for this vendor, else its
+ * recommended flagship. openai-compat has none, so it starts blank and the
+ * required-non-empty validator catches blank submissions.
+ */
+async function promptModelInput(vendor) {
+    const carriedOver = savedModelFor(vendor);
+    const recommended = vendor === "openai-compat" ? "" : RECOMMENDED_MODEL[vendor];
+    const defaultValue = carriedOver || recommended;
+    return inputPrompt({
+        name: "model",
+        message: "Which AI model?",
+        default: defaultValue || undefined,
+        validate: (v) => v.trim().length > 0 || "Required",
+    });
 }
-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",
+/**
+ * Empty submit silently keeps the existing key when one is on file. Otherwise
+ * the validator rejects empty (or accepts empty when `optional`, e.g. local
+ * servers that need no auth).
+ */
+async function promptApiKey(opts) {
+    const hasExisting = opts.existing.length > 0;
+    const fresh = await passwordPrompt({
+        name: "key",
+        message: `${opts.label}:`,
+        validate: (v) => {
+            if (v === "" && (hasExisting || opts.optional))
+                return true;
+            if (opts.prefix && !v.startsWith(opts.prefix)) {
+                return `Enter a key starting with ${opts.prefix}...`;
+            }
+            if (v.length === 0)
+                return "Required";
+            return true;
         },
-    ]);
+    });
+    return fresh === "" && hasExisting ? opts.existing : fresh;
+}
+async function promptAnthropicCredentials() {
+    const anthropicKey = await promptApiKey({
+        label: "Paste your Anthropic API key (https://console.anthropic.com)",
+        existing: config.anthropicKey,
+        prefix: "sk-",
+    });
+    const anthropicModel = await promptModelInput("anthropic");
+    return { providerType: "anthropic", anthropicKey, anthropicModel };
+}
+async function promptOpenAICredentials() {
+    const openaiKey = await promptApiKey({
+        label: "Paste your OpenAI API key (https://platform.openai.com/api-keys)",
+        existing: config.openaiKey,
+        prefix: "sk-",
+    });
+    const openaiModel = await promptModelInput("openai");
+    return { providerType: "openai", openaiKey, openaiModel };
+}
+async function promptGeminiCredentials() {
+    const geminiKey = await promptApiKey({
+        label: "Paste your Google AI Studio API key (https://aistudio.google.com/apikey)",
+        existing: config.geminiKey,
+    });
+    const geminiModel = await promptModelInput("gemini");
+    return { providerType: "gemini", geminiKey, geminiModel };
+}
+async function promptOpenAICompatCredentials() {
+    const baseURLDefault = config.providerType === "openai-compat" && config.openaiCompatBaseURL
+        ? config.openaiCompatBaseURL
+        : DEFAULT_LOCAL_OPENAI_BASE_URL;
+    const openaiCompatBaseURL = await inputPrompt({
+        name: "baseURL",
+        message: "What's the base URL of your LLM server?",
+        default: baseURLDefault,
+        validate: (v) => /^https?:\/\//.test(v) || "Must start with http:// or https://",
+    });
+    const openaiCompatKey = await promptApiKey({
+        label: "Paste your LLM server API key",
+        existing: config.openaiCompatKey,
+        optional: true,
+    });
+    const openaiCompatModel = await promptModelInput("openai-compat");
     return {
-        openaiCompatibleBaseURL: baseURL,
-        openaiCompatibleKey: apiKey || "",
-        model: model.trim(),
+        providerType: "openai-compat",
+        openaiCompatBaseURL,
+        openaiCompatKey,
+        openaiCompatModel,
     };
 }
-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;
+async function promptCredentials(vendor) {
+    switch (vendor) {
+        case "anthropic":
+            return promptAnthropicCredentials();
+        case "openai":
+            return promptOpenAICredentials();
+        case "gemini":
+            return promptGeminiCredentials();
+        case "openai-compat":
+            return promptOpenAICompatCredentials();
     }
-    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") {
+}
+/**
+ * Encryption key is auto-generated. The work is microseconds,
+ * but the banner just told the user to "seal your vault" — hold the spinner
+ * so the step is visible.
+ */
+async function sealVault() {
+    const spinner = statusSpinner("Sealing your vault…");
+    const start = Date.now();
+    if (!config.dbEncryptionKey) {
         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 });
     }
+    const remaining = 600 - (Date.now() - start);
+    if (remaining > 0)
+        await new Promise((r) => setTimeout(r, remaining));
+    spinner.succeed("Vault sealed.");
 }
 function finalizeDataDir(userName) {
     const dataDir = config.dataDir || resolve(getPlasalidDir(), "data");
@@ -192,16 +244,14 @@ function finalizeDataDir(userName) {
 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);
+    const userName = await promptUserName();
+    const vendor = await promptProviderChoice();
+    const credentials = await promptCredentials(vendor);
     saveConfig({
-        providerType: provider,
         userName: userName || "User",
         ...credentials,
     });
-    await ensureEncryptionKey();
+    await sealVault();
     const dataDir = finalizeDataDir(userName || "User");
     printSummary(dataDir);
 }

package/dist/config.d.ts

@@ -1,10 +1,15 @@
 import "dotenv/config";
 export interface PlasalidConfig {
+    providerType: "anthropic" | "openai" | "gemini" | "openai-compat";
     anthropicKey: string;
-    model: string;
-    providerType: "anthropic" | "openai-compatible";
-    openaiCompatibleKey: string;
-    openaiCompatibleBaseURL: string;
+    anthropicModel: string;
+    openaiKey: string;
+    openaiModel: string;
+    geminiKey: string;
+    geminiModel: string;
+    openaiCompatKey: string;
+    openaiCompatBaseURL: string;
+    openaiCompatModel: string;
     displayLocale: string;
     displayCurrency: string;
     dbPath: string;
@@ -18,4 +23,5 @@ export declare function getConfigPath(): string;
 export declare function getDataDir(): string;
 export declare const config: PlasalidConfig;
 export declare function isConfigured(): boolean;
+export declare function getActiveModel(): string;
 export declare function saveConfig(partial: Partial<PlasalidConfig>): void;

package/dist/config.js

@@ -1,5 +1,5 @@
 import "dotenv/config";
-import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, chmodSync, } from "fs";
 import { resolve } from "path";
 import { homedir } from "os";
 const PLASALID_DIR = resolve(homedir(), ".plasalid");
@@ -28,28 +28,55 @@ function buildConfig() {
     // 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 || "",
+        anthropicKey: process.env.ANTHROPIC_API_KEY || file.anthropicKey || "",
+        anthropicModel: process.env.ANTHROPIC_MODEL || file.anthropicModel || "claude-sonnet-4-6",
+        openaiKey: process.env.OPENAI_API_KEY || file.openaiKey || "",
+        openaiModel: process.env.OPENAI_MODEL || file.openaiModel || "gpt-5.4-mini",
+        openaiCompatKey: process.env.OPENAI_COMPAT_API_KEY || file.openaiCompatKey || "",
+        openaiCompatBaseURL: process.env.OPENAI_COMPAT_BASE_URL || file.openaiCompatBaseURL || "",
+        openaiCompatModel: process.env.OPENAI_COMPAT_MODEL || file.openaiCompatModel || "",
+        geminiKey: process.env.GEMINI_API_KEY || file.geminiKey || "",
+        geminiModel: process.env.GEMINI_MODEL || file.geminiModel || "gemini-3.5-flash",
         displayLocale: file.displayLocale || "th-TH",
         displayCurrency: file.displayCurrency || "THB",
-        dbPath: process.env.PLASALID_DB_PATH || file.dbPath || resolve(PLASALID_DIR, "db.sqlite"),
+        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"),
+        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;
+    switch (config.providerType) {
+        case "anthropic":
+            return !!config.anthropicKey;
+        case "openai":
+            return !!config.openaiKey;
+        case "gemini":
+            return !!config.geminiKey;
+        case "openai-compat":
+            return !!config.openaiCompatBaseURL;
+    }
+}
+export function getActiveModel() {
+    switch (config.providerType) {
+        case "anthropic":
+            return config.anthropicModel;
+        case "openai":
+            return config.openaiModel;
+        case "gemini":
+            return config.geminiModel;
+        case "openai-compat":
+            return config.openaiCompatModel;
     }
-    return !!config.anthropicKey;
 }
 export function saveConfig(partial) {
     const configPath = getConfigPath();
@@ -57,7 +84,9 @@ export function saveConfig(partial) {
         mkdirSync(PLASALID_DIR, { recursive: true });
     const existing = loadFileConfig();
     const merged = { ...existing, ...partial };
-    writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", { mode: 0o600 });
+    writeFileSync(configPath, JSON.stringify(merged, null, 2) + "\n", {
+        mode: 0o600,
+    });
     try {
         chmodSync(configPath, 0o600);
     }

package/dist/scanner/pdf/pdf.d.ts

@@ -1,4 +1,5 @@
-import type { DocumentBlock } from "../../ai/provider.js";
+import type { DocumentBlock, ImageBlock, Provider } from "../../ai/provider.js";
+import type { Chunk } from "../engine.js";
 export interface LoadedFile {
     bytes: Buffer;
     hash: string;
@@ -13,5 +14,5 @@ export interface LoadedFile {
  * recognize the same file across re-scans regardless of unlock state.
  */
 export declare function readPdf(path: string): LoadedFile;
-/** Build an Anthropic-compatible document content block from PDF bytes. */
 export declare function buildDocumentBlock(bytes: Buffer, fileName: string, mime?: string): DocumentBlock;
+export declare function buildScanAttachment(chunk: Chunk, provider: Provider): Promise<DocumentBlock | ImageBlock>;

package/dist/scanner/pdf/pdf.js

@@ -1,6 +1,7 @@
 import { readFileSync, statSync } from "fs";
 import { createHash } from "crypto";
 import { basename, extname } from "path";
+import { rasterizePage } from "./rasterize.js";
 const MIME_BY_EXT = {
     ".pdf": "application/pdf",
 };
@@ -26,7 +27,6 @@ export function readPdf(path) {
     const hash = createHash("sha256").update(bytes).digest("hex");
     return { bytes, hash, mime, fileName: basename(path) };
 }
-/** Build an Anthropic-compatible document content block from PDF bytes. */
 export function buildDocumentBlock(bytes, fileName, mime = "application/pdf") {
     return {
         type: "document",
@@ -34,3 +34,13 @@ export function buildDocumentBlock(bytes, fileName, mime = "application/pdf") {
         title: fileName,
     };
 }
+export async function buildScanAttachment(chunk, provider) {
+    if (provider.acceptsDocuments) {
+        return buildDocumentBlock(chunk.bytes, chunk.fileName, chunk.mime);
+    }
+    const { bytes, mime } = await rasterizePage(chunk.bytes);
+    return {
+        type: "image",
+        source: { type: "base64", media_type: mime, data: bytes.toString("base64") },
+    };
+}

package/dist/scanner/pdf/rasterize.d.ts

@@ -0,0 +1,6 @@
+export declare function rasterizePage(pdfBytes: Buffer, opts?: {
+    dpi?: number;
+}): Promise<{
+    bytes: Buffer;
+    mime: "image/png";
+}>;

package/dist/scanner/pdf/rasterize.js

@@ -0,0 +1,36 @@
+let mupdfPromise = null;
+function getMupdf() {
+    if (!mupdfPromise)
+        mupdfPromise = import("mupdf");
+    return mupdfPromise;
+}
+/**
+ * 150 DPI keeps statement numerals readable to a VL model without blowing
+ * up the token bill on a dense page.
+ */
+const DEFAULT_DPI = 150;
+export async function rasterizePage(pdfBytes, opts = {}) {
+    const mupdf = await getMupdf();
+    const dpi = opts.dpi ?? DEFAULT_DPI;
+    const scale = dpi / 72;
+    const doc = mupdf.Document.openDocument(pdfBytes, "application/pdf");
+    try {
+        const page = doc.loadPage(0);
+        try {
+            const pixmap = page.toPixmap(mupdf.Matrix.scale(scale, scale), mupdf.ColorSpace.DeviceRGB, false);
+            try {
+                const png = pixmap.asPNG();
+                return { bytes: Buffer.from(png), mime: "image/png" };
+            }
+            finally {
+                pixmap.destroy();
+            }
+        }
+        finally {
+            page.destroy();
+        }
+    }
+    finally {
+        doc.destroy();
+    }
+}

package/dist/scanner/worker.js

@@ -1,7 +1,8 @@
 import { randomUUID } from "crypto";
 import { runScanAgent } from "../ai/agent.js";
+import { getProvider } from "../ai/providers/index.js";
 import { recordQuestion } from "../db/queries/questions.js";
-import { buildDocumentBlock } from "./pdf/pdf.js";
+import { buildScanAttachment } from "./pdf/pdf.js";
 import { tryExecute } from "./result.js";
 /**
  * Process one chunk: run the LLM scan agent over a single-page PDF blob with
@@ -13,13 +14,14 @@ import { tryExecute } from "./result.js";
 export async function runScanWorker(deps, hooks) {
     const workerId = `cw:${randomUUID()}`;
     hooks.onWorkerStart?.(workerId, deps.chunk);
+    const attachment = await buildScanAttachment(deps.chunk, getProvider());
     const outcome = await tryExecute(() => runScanAgent({
         db: deps.db,
         initialMessages: [
             {
                 role: "user",
                 content: [
-                    buildDocumentBlock(deps.chunk.bytes, deps.chunk.fileName, deps.chunk.mime),
+                    attachment,
                     { type: "text", text: buildChunkPrompt(deps.chunk) },
                 ],
             },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "plasalid",
-  "version": "0.7.9",
+  "version": "0.8.0",
   "description": "Plasalid — The Harness Layer for Personal Finance",
   "keywords": [
     "finance",
@@ -41,6 +41,7 @@
   },
   "dependencies": {
     "@anthropic-ai/sdk": "^0.74.0",
+    "@google/genai": "^2.6.0",
     "chalk": "^5.3.0",
     "commander": "^13.0.0",
     "dotenv": "^16.4.0",