plasalid 0.6.10 → 0.7.1

package/dist/ai/tools/ingest.js

@@ -178,6 +178,32 @@ const ACCOUNT_LABELS = {
     update_account_metadata: "Updating account metadata",
     record_transaction: "Posting transaction",
 };
+/**
+ * Run a write inside an audit-wrapping transaction. When the caller has a
+ * correlation id, the write + action_log insert land atomically; otherwise
+ * it's just the write. The write closure can return an AuditRecord (logged)
+ * or null (no audit row this call — used when an update was a no-op).
+ */
+function writeWithAudit(db, ctx, write) {
+    if (!ctx?.correlationId) {
+        write();
+        return;
+    }
+    const op = db.transaction(() => {
+        const audit = write();
+        if (!audit)
+            return;
+        appendAction(db, {
+            correlation_id: ctx.correlationId,
+            command: ctx.command ?? "record",
+            user_input: ctx.userInput ?? null,
+            action_type: audit.actionType,
+            target_id: audit.targetId,
+            payload: audit.payload,
+        });
+    });
+    op();
+}
 async function accountExecute(db, name, input, ctx) {
     switch (name) {
         case "create_account": {
@@ -186,7 +212,7 @@ async function accountExecute(db, name, input, ctx) {
             }
             return await runAccountExclusive(() => {
                 try {
-                    const create = () => {
+                    writeWithAudit(db, ctx, () => {
                         createAccount(db, {
                             id: input.id,
                             name: input.name,
@@ -200,25 +226,12 @@ async function accountExecute(db, name, input, ctx) {
                             statement_day: input.statement_day ?? null,
                             metadata: input.metadata ?? null,
                         });
-                    };
-                    if (ctx?.correlationId) {
-                        const tx = db.transaction(() => {
-                            create();
-                            const row = findAccountById(db, input.id);
-                            appendAction(db, {
-                                correlation_id: ctx.correlationId,
-                                command: ctx.command ?? "record",
-                                user_input: ctx.userInput ?? null,
-                                action_type: "create_account",
-                                target_id: input.id,
-                                payload: { row },
-                            });
-                        });
-                        tx();
-                    }
-                    else {
-                        create();
-                    }
+                        return {
+                            actionType: "create_account",
+                            targetId: input.id,
+                            payload: { row: findAccountById(db, input.id) },
+                        };
+                    });
                     return `Account created: ${input.id} (${input.name}, ${input.type}).`;
                 }
                 catch (err) {
@@ -233,7 +246,7 @@ async function accountExecute(db, name, input, ctx) {
             return await runAccountExclusive(() => {
                 try {
                     let changed = false;
-                    const apply = () => {
+                    writeWithAudit(db, ctx, () => {
                         const result = updateAccountMetadata(db, input.account_id, {
                             due_day: input.due_day,
                             statement_day: input.statement_day,
@@ -243,30 +256,15 @@ async function accountExecute(db, name, input, ctx) {
                             metadata: input.metadata,
                         });
                         changed = result.changed;
-                        return result;
-                    };
-                    if (ctx?.correlationId) {
-                        const tx = db.transaction(() => {
-                            const result = apply();
-                            if (!result.changed)
-                                return;
-                            appendAction(db, {
-                                correlation_id: ctx.correlationId,
-                                command: ctx.command ?? "record",
-                                user_input: ctx.userInput ?? null,
-                                action_type: "update_account_metadata",
-                                target_id: input.account_id,
-                                payload: { before: result.before, after: result.after },
-                            });
-                        });
-                        tx();
-                    }
-                    else {
-                        apply();
-                    }
-                    return changed
-                        ? `Updated ${input.account_id}.`
-                        : "Nothing to update.";
+                        if (!result.changed)
+                            return null;
+                        return {
+                            actionType: "update_account_metadata",
+                            targetId: input.account_id,
+                            payload: { before: result.before, after: result.after },
+                        };
+                    });
+                    return changed ? `Updated ${input.account_id}.` : "Nothing to update.";
                 }
                 catch (err) {
                     if (String(err.message).includes("not found")) {
@@ -296,38 +294,35 @@ async function accountExecute(db, name, input, ctx) {
                 })),
             };
             try {
-                let transactionId;
                 if (ctx.buffer) {
-                    transactionId = ctx.buffer.appendTransaction(txInput);
+                    const transactionId = ctx.buffer.appendTransaction(txInput);
+                    return `Posted transaction ${transactionId} (${input.date}).`;
                 }
-                else if (ctx.correlationId) {
-                    const validated = validateTransaction(txInput);
-                    const tx = db.transaction(() => {
-                        insertTransactionRows(db, validated);
-                        appendAction(db, {
-                            correlation_id: ctx.correlationId,
-                            command: ctx.command ?? "record",
-                            user_input: ctx.userInput ?? null,
-                            action_type: "record_transaction",
-                            target_id: validated.id,
-                            payload: {
-                                transaction: {
-                                    date: validated.date,
-                                    description: validated.description,
-                                    source_page: validated.source_page ?? null,
-                                    raw_descriptor: validated.raw_descriptor ?? null,
-                                },
-                                postings: validated.postings,
-                            },
-                        });
-                    });
-                    tx();
-                    transactionId = validated.id;
-                }
-                else {
-                    transactionId = recordTransaction(db, txInput);
+                // No-audit path uses recordTransaction (validates + inserts in one go).
+                // Audit path validates ahead so the validated id can be returned without
+                // re-reading from disk after the transaction commits.
+                if (!ctx.correlationId) {
+                    const transactionId = recordTransaction(db, txInput);
+                    return `Posted transaction ${transactionId} (${input.date}).`;
                 }
-                return `Posted transaction ${transactionId} (${input.date}).`;
+                const validated = validateTransaction(txInput);
+                writeWithAudit(db, ctx, () => {
+                    insertTransactionRows(db, validated);
+                    return {
+                        actionType: "record_transaction",
+                        targetId: validated.id,
+                        payload: {
+                            transaction: {
+                                date: validated.date,
+                                description: validated.description,
+                                source_page: validated.source_page ?? null,
+                                raw_descriptor: validated.raw_descriptor ?? null,
+                            },
+                            postings: validated.postings,
+                        },
+                    };
+                });
+                return `Posted transaction ${validated.id} (${input.date}).`;
             }
             catch (err) {
                 return `Could not post transaction: ${err.message}`;
@@ -511,40 +506,22 @@ async function resolveExecute(db, name, input, ctx) {
         return closeUnknown(db, input);
     if (name !== "ask_user")
         return undefined;
-    if (!ctx)
-        return "ask_user is only available inside an agent session.";
-    let id;
-    if (input.unknown_id) {
-        id = String(input.unknown_id);
-        if (!getUnknownTarget(db, id))
-            return `Unknown ${id} not found.`;
+    if (!ctx?.promptUser) {
+        return "ask_user requires an interactive resolve session.";
     }
-    else {
-        id = recordUnknown(db, {
+    const id = input.unknown_id
+        ? String(input.unknown_id)
+        : recordUnknown(db, {
             file_id: ctx.fileId ?? null,
             transaction_id: input.transaction_id ?? null,
             account_id: input.account_id ?? null,
             prompt: input.prompt,
             options: input.options,
         });
-    }
-    if (ctx.interactive && ctx.promptUser) {
-        const answer = await ctx.promptUser(input.prompt, input.options, input.facts);
-        resolveUnknown(db, id, answer);
-        const siblings = Array.isArray(input.related_unknown_ids)
-            ? input.related_unknown_ids
-            : [];
-        let propagated = 0;
-        for (const sibId of siblings) {
-            if (sibId === id)
-                continue;
-            if (resolveUnknown(db, String(sibId), answer))
-                propagated++;
-        }
-        const totalResolved = 1 + propagated;
-        return `User answered: ${sanitizeForPrompt(answer)}${totalResolved > 1 ? ` (applied to ${totalResolved} unknown${totalResolved === 1 ? "" : "s"})` : ""}`;
-    }
-    return `Question recorded for later (${id}). Awaiting user input — do not act on assumptions about this answer.`;
+    if (!getUnknownTarget(db, id))
+        return `Unknown ${id} not found.`;
+    const answer = await ctx.promptUser(input.prompt, input.options, input.facts);
+    return applyAnswerToGroup(db, id, answer, input.related_unknown_ids);
 }
 function closeUnknown(db, input) {
     const primary = String(input.unknown_id ?? "");
@@ -553,18 +530,25 @@ function closeUnknown(db, input) {
         return "close_unknown requires unknown_id and answer.";
     if (!getUnknownTarget(db, primary))
         return `Unknown ${primary} not found.`;
-    resolveUnknown(db, primary, answer);
-    let count = 1;
-    const siblings = Array.isArray(input.related_unknown_ids)
-        ? input.related_unknown_ids
-        : [];
+    return applyAnswerToGroup(db, primary, answer, input.related_unknown_ids);
+}
+function applyAnswerToGroup(db, primaryId, answer, rawSiblings) {
+    resolveUnknown(db, primaryId, answer);
+    const siblings = Array.isArray(rawSiblings) ? rawSiblings.map(String) : [];
+    const resolved = [primaryId];
+    const notFound = [];
     for (const sibId of siblings) {
-        if (sibId === primary)
+        if (sibId === primaryId)
             continue;
-        if (resolveUnknown(db, String(sibId), answer))
-            count++;
+        if (resolveUnknown(db, sibId, answer))
+            resolved.push(sibId);
+        else
+            notFound.push(sibId);
     }
-    return `Closed ${count} unknown${count === 1 ? "" : "s"}.`;
+    const preface = `Resolved ${resolved.length} unknown${resolved.length === 1 ? "" : "s"} with: ${sanitizeForPrompt(answer)}`;
+    if (notFound.length === 0)
+        return preface;
+    return `${preface}. NOT FOUND: ${notFound.join(", ")} — these ids did not exist; do not re-close them.`;
 }
 export const resolveIngestTools = {
     DEFS: RESOLVE_DEFS,

package/dist/ai/tools/resolve.js

@@ -103,15 +103,6 @@ const DEFS = [
             required: ["from_id", "to_id"],
         },
     },
-    {
-        name: "mark_resolve_done",
-        description: "Call once the current unknown's resolution has been applied. The summary is shown to the user. The pipeline will then mark the unknown resolved and move to the next one.",
-        input_schema: {
-            type: "object",
-            properties: { summary: { type: "string" } },
-            required: ["summary"],
-        },
-    },
 ];
 const LABELS = {
     update_transaction: "Updating transaction",
@@ -120,9 +111,8 @@ const LABELS = {
     record_recurrence: "Recording recurrence",
     link_transaction_to_recurrence: "Linking transaction to recurrence",
     merge_accounts: "Merging accounts",
-    mark_resolve_done: "Finalizing unknown",
 };
-async function execute(db, name, input, ctx) {
+async function execute(db, name, input) {
     switch (name) {
         case "update_transaction": {
             const changed = updateTransaction(db, input.transaction_id, {
@@ -150,43 +140,24 @@ async function execute(db, name, input, ctx) {
                 : `Deleted transaction ${input.transaction_id} and its postings.`;
         }
         case "record_recurrence": {
-            try {
-                const id = recordRecurrence(db, {
-                    account_id: input.account_id,
-                    description: input.description,
-                    frequency: input.frequency,
-                    amount_typical: input.amount_typical ?? null,
-                    currency: input.currency,
-                    transaction_ids: input.transaction_ids || [],
-                    notes: input.notes ?? null,
-                });
-                return `Recorded recurrence ${id} ("${sanitizeForPrompt(input.description)}", ${input.frequency}); linked ${(input.transaction_ids || []).length} transaction(s).`;
-            }
-            catch (err) {
-                return `Could not record recurrence: ${err.message}`;
-            }
+            const id = recordRecurrence(db, {
+                account_id: input.account_id,
+                description: input.description,
+                frequency: input.frequency,
+                amount_typical: input.amount_typical ?? null,
+                currency: input.currency,
+                transaction_ids: input.transaction_ids || [],
+                notes: input.notes ?? null,
+            });
+            return `Recorded recurrence ${id} ("${sanitizeForPrompt(input.description)}", ${input.frequency}); linked ${(input.transaction_ids || []).length} transaction(s).`;
         }
         case "link_transaction_to_recurrence": {
-            try {
-                linkTransactionToRecurrence(db, input.transaction_id, input.recurrence_id);
-                return `Linked transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
-            }
-            catch (err) {
-                return `Could not link: ${err.message}`;
-            }
+            linkTransactionToRecurrence(db, input.transaction_id, input.recurrence_id);
+            return `Linked transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
         }
         case "merge_accounts": {
-            try {
-                const moved = mergeAccounts(db, input.from_id, input.to_id);
-                return `Merged ${input.from_id} → ${input.to_id}; moved ${moved} posting(s).`;
-            }
-            catch (err) {
-                return `Could not merge: ${err.message}`;
-            }
-        }
-        case "mark_resolve_done": {
-            ctx?.onComplete?.(input.summary || "");
-            return `Unknown done. Summary: ${sanitizeForPrompt(input.summary || "")}`;
+            const moved = mergeAccounts(db, input.from_id, input.to_id);
+            return `Merged ${input.from_id} → ${input.to_id}; moved ${moved} posting(s).`;
         }
         default:
             return undefined;

package/dist/cli/commands/accounts.d.ts

@@ -1 +1,4 @@
-export declare function showAccounts(): void;
+export interface ShowAccountsOptions {
+    noInteractive?: boolean;
+}
+export declare function showAccounts(opts?: ShowAccountsOptions): Promise<void>;

package/dist/cli/commands/accounts.js

@@ -18,30 +18,33 @@ const TYPE_RANK = {
     expense: 3,
     equity: 4,
 };
-function compactMeta(a) {
-    const meta = [];
-    if (a.bank_name)
-        meta.push(a.bank_name);
-    if (a.due_day)
-        meta.push(`due ${a.due_day}`);
-    if (a.statement_day)
-        meta.push(`stmt ${a.statement_day}`);
-    if (a.points_balance)
-        meta.push(`${a.points_balance.toLocaleString()} pts`);
-    if (a.currency && a.currency !== "THB")
-        meta.push(a.currency);
-    // Subtype only when there's no other signal yet (e.g. "cash", "salary").
-    if (meta.length === 0 && a.subtype)
-        meta.push(a.subtype);
-    return meta;
-}
-export function showAccounts() {
+export async function showAccounts(opts = {}) {
     const db = getDb();
-    const raw = getAccountBalances(db);
-    if (raw.length === 0) {
+    const accounts = getAccountBalances(db);
+    if (accounts.length === 0) {
         console.log(chalk.yellow("No accounts yet. Drop your bank/credit card statements into ~/.plasalid/data/ and run `plasalid scan`."));
         return;
     }
+    const interactive = !opts.noInteractive && Boolean(process.stdout.isTTY) && Boolean(process.stdin.isTTY);
+    if (interactive) {
+        const [{ runBrowser }, { AccountsBrowser }, { createElement }, { listPostings },] = await Promise.all([
+            import("../ink/runBrowser.js"),
+            import("../ink/AccountsBrowser.js"),
+            import("react"),
+            import("../../db/queries/transactions.js"),
+        ]);
+        const recentTransactionsByAccount = new Map();
+        for (const a of accounts) {
+            const rows = listPostings(db, { account_id: a.id, limit: 10 });
+            if (rows.length > 0)
+                recentTransactionsByAccount.set(a.id, rows);
+        }
+        await runBrowser(createElement(AccountsBrowser, { accounts, recentTransactionsByAccount }));
+        return;
+    }
+    printAccountsPlain(accounts);
+}
+function printAccountsPlain(raw) {
     const byId = new Map(raw.map((a) => [a.id, a]));
     const depthCache = new Map();
     const depthOf = (id) => {
@@ -92,3 +95,19 @@ export function showAccounts() {
         chalk.dim("   ·   ") +
         chalk.bold(`Net worth ${formatSignedAmount(netWorth)}`));
 }
+function compactMeta(a) {
+    const meta = [];
+    if (a.bank_name)
+        meta.push(a.bank_name);
+    if (a.due_day)
+        meta.push(`due ${a.due_day}`);
+    if (a.statement_day)
+        meta.push(`stmt ${a.statement_day}`);
+    if (a.points_balance)
+        meta.push(`${a.points_balance.toLocaleString()} pts`);
+    if (a.currency && a.currency !== "THB")
+        meta.push(a.currency);
+    if (meta.length === 0 && a.subtype)
+        meta.push(a.subtype);
+    return meta;
+}

package/dist/cli/commands/scan.js

@@ -11,8 +11,9 @@ export async function runScanCommand(opts) {
             return;
         }
     }
-    const useInk = !!process.stdout.isTTY;
-    const events = useInk ? await buildInkEvents(opts.parallel ?? 3) : buildPlainTextEvents();
+    const events = process.stdout.isTTY
+        ? await inkScanEvents(opts.parallel ?? 3)
+        : plainScanEvents();
     const summary = await runScan({
         regex: opts.regex,
         force: opts.force,
@@ -28,24 +29,50 @@ function logDecryptProgress(e) {
             : chalk.red("✗");
     console.log(`  ${marker} [${e.index + 1}/${e.total}] ${e.fileName} (${e.outcome})`);
 }
-/** Ink-based events (TTY mode) */
-async function buildInkEvents(parallel) {
-    // Lazy-load ink + react so this module stays importable in non-TTY contexts
-    // (and so test environments without React don't choke on the JSX).
-    const { render } = await import("ink");
-    const { createElement } = await import("react");
-    const { ScanDashboard, ScanDashboardController } = await import("../ink/scan_dashboard.js");
-    const controller = new ScanDashboardController();
-    let inkInstance = null;
-    let mountedFiles = 0;
+/**
+ * Hooks every mode shares: the decrypt phase, commit notice, and inspector
+ * summary all render the same way in TTY and non-TTY runs. Each mode-specific
+ * factory below spreads this base and overrides the scan-phase hooks
+ * (`scanStart` / `scanProgress` / `scanEnd`) to render differently.
+ *
+ * Returns `Partial<ScanRunEvents>` because the scan-phase hooks are filled in
+ * by the caller — composition, not inheritance.
+ */
+function baseScanEvents() {
+    let decryptTotal = 0;
     return {
         decryptStart: (count) => {
+            decryptTotal = count;
             if (count > 0)
                 console.log(chalk.dim(`Decrypting ${count} file(s)...`));
         },
         decryptProgress: logDecryptProgress,
         decryptDone: (e) => {
+            if (decryptTotal === 0)
+                return;
             console.log(chalk.dim(`Decrypted ${e.decrypted}, skipped ${e.skipped}, failed ${e.failed}.`));
+        },
+        committing: () => { console.log(chalk.dim("Committing...")); },
+        inspecting: (r) => {
+            if (r.total > 0)
+                console.log(chalk.dim(`Inspectors flagged ${r.total} unknown(s).`));
+        },
+    };
+}
+/** TTY mode: mount the Ink dashboard during the scan phase. */
+async function inkScanEvents(parallel) {
+    // Lazy-load ink + react so this module stays importable in non-TTY contexts.
+    const { render } = await import("ink");
+    const { createElement } = await import("react");
+    const { ScanDashboard, ScanDashboardController } = await import("../ink/scan_dashboard.js");
+    const controller = new ScanDashboardController();
+    let inkInstance = null;
+    let mountedFiles = 0;
+    const base = baseScanEvents();
+    return {
+        ...base,
+        decryptDone: (e) => {
+            base.decryptDone?.(e);
             console.log("");
             mountedFiles = e.decrypted;
             if (e.decrypted > 0) {
@@ -68,33 +95,16 @@ async function buildInkEvents(parallel) {
                 inkInstance = null;
             }
             if (mountedFiles > 0)
-                console.log(chalk.dim("Committing..."));
-        },
-        inspecting: (result) => {
-            if (mountedFiles > 0 && result.total > 0) {
-                console.log(chalk.dim(`Inspectors flagged ${result.total} unknown(s).`));
-            }
+                base.committing?.();
         },
     };
 }
-/** Plain-text progress (non-TTY or fallback) */
-function buildPlainTextEvents() {
-    let decryptTotal = 0;
+/** Non-TTY mode: print one line per file as it progresses. */
+function plainScanEvents() {
     // De-dupe scan-progress chatter: only print when the step text changes per file.
     const lastStepByFile = new Map();
     return {
-        decryptStart: (count) => {
-            decryptTotal = count;
-            if (count > 0)
-                console.log(chalk.dim(`Decrypting ${count} file(s)...`));
-        },
-        decryptProgress: logDecryptProgress,
-        decryptDone: (e) => {
-            if (decryptTotal === 0)
-                return;
-            console.log(chalk.dim(`Decrypted ${e.decrypted}, skipped ${e.skipped}, failed ${e.failed}.`));
-            console.log("");
-        },
+        ...baseScanEvents(),
         scanStart: (e) => {
             console.log(`${chalk.cyan("→")} ${e.fileName} ${chalk.dim("starting...")}`);
         },
@@ -106,20 +116,10 @@ function buildPlainTextEvents() {
         },
         scanEnd: (e) => {
             lastStepByFile.delete(e.fileName);
-            if (e.status === "scanned") {
-                console.log(`${chalk.green("✓")} ${e.fileName} ${chalk.dim(`(${e.transactions} transactions, ${e.unknowns} unknowns)`)}`);
-            }
-            else {
-                console.log(`${chalk.red("✗")} ${e.fileName} ${chalk.dim(`— ${e.error ?? "failed"}`)}`);
-            }
-        },
-        committing: () => {
-            console.log(chalk.dim("Committing..."));
-        },
-        inspecting: (result) => {
-            if (result.total > 0) {
-                console.log(chalk.dim(`Inspectors flagged ${result.total} unknown(s).`));
-            }
+            const line = e.status === "scanned"
+                ? `${chalk.green("✓")} ${e.fileName} ${chalk.dim(`(${e.transactions} transactions, ${e.unknowns} unknowns)`)}`
+                : `${chalk.red("✗")} ${e.fileName} ${chalk.dim(`— ${e.error ?? "failed"}`)}`;
+            console.log(line);
         },
     };
 }