plasalid 0.4.1 → 0.5.0

package/dist/ai/tools/review.js

@@ -1,51 +1,48 @@
 import { deleteAccount, findSimilarAccounts, findUnusedAccounts, mergeAccounts, renameAccount, } from "../../db/queries/account_balance.js";
-import { deleteJournalEntry, findCorrelatedEntries, findDuplicateEntries, updateJournalEntry, updateJournalLine, } from "../../db/queries/journal.js";
-import { findRecurrenceCandidates, linkEntryToRecurrence, recordRecurrence, } from "../../db/queries/recurrences.js";
-import { formatCurrencyAmount } from "../../currency.js";
+import { deleteTransaction, findCorrelatedTransactions, findDuplicateTransactions, updateTransaction, updatePosting, } from "../../db/queries/transactions.js";
+import { findRecurrenceCandidates, linkTransactionToRecurrence, recordRecurrence, } from "../../db/queries/recurrences.js";
+import { formatAmount } from "../../currency.js";
 import { sanitizeForPrompt } from "../sanitize.js";
-function formatTHB(amount) {
-    return formatCurrencyAmount(amount, { minimumFractionDigits: 2, maximumFractionDigits: 2 });
-}
 const DEFS = [
     {
-        name: "update_journal_entry",
-        description: "Header-only update: date, description, or source_page. To change amounts, delete the entry and record a new one.",
+        name: "update_transaction",
+        description: "Header-only update: date, description, or source_page. To change amounts, delete the transaction and record a new one.",
         input_schema: {
             type: "object",
             properties: {
-                entry_id: { type: "string" },
+                transaction_id: { type: "string" },
                 date: { type: "string" },
                 description: { type: "string" },
                 source_page: { type: "number" },
             },
-            required: ["entry_id"],
+            required: ["transaction_id"],
         },
     },
     {
-        name: "update_journal_line",
-        description: "Safe single-line edit: re-categorize (account_id) or update memo. Refuses changes to debit/credit/currency — delete and re-record the entry for those.",
+        name: "update_posting",
+        description: "Safe single-posting edit: re-categorize (account_id) or update memo. Refuses changes to debit/credit/currency — delete and re-record the transaction for those.",
         input_schema: {
             type: "object",
             properties: {
-                line_id: { type: "string" },
+                posting_id: { type: "string" },
                 account_id: { type: "string" },
                 memo: { type: "string" },
             },
-            required: ["line_id"],
+            required: ["posting_id"],
         },
     },
     {
-        name: "delete_journal_entry",
-        description: "Delete an entry and (via cascade) all its lines. The primitive for removing duplicates.",
+        name: "delete_transaction",
+        description: "Delete a transaction and (via cascade) all its postings. The primitive for removing duplicates.",
         input_schema: {
             type: "object",
-            properties: { entry_id: { type: "string" } },
-            required: ["entry_id"],
+            properties: { transaction_id: { type: "string" } },
+            required: ["transaction_id"],
         },
     },
     {
         name: "rename_account",
-        description: "Rename an account. Leaves lines and metadata untouched.",
+        description: "Rename an account. Leaves postings and metadata untouched.",
         input_schema: {
             type: "object",
             properties: { account_id: { type: "string" }, name: { type: "string" } },
@@ -54,7 +51,7 @@ const DEFS = [
     },
     {
         name: "merge_accounts",
-        description: "Move every journal line on `from_id` over to `to_id`, then delete the source account. Use to collapse duplicate accounts.",
+        description: "Move every posting on `from_id` over to `to_id`, then delete the source account. Use to collapse duplicate accounts. Refuses if the source still has child accounts.",
         input_schema: {
             type: "object",
             properties: { from_id: { type: "string" }, to_id: { type: "string" } },
@@ -63,7 +60,7 @@ const DEFS = [
     },
     {
         name: "delete_account",
-        description: "Delete an account that has no journal lines. Refuses if any line still references it — merge first.",
+        description: "Delete an account that has no postings and no children. Refuses if any posting or child still references it — merge first.",
         input_schema: {
             type: "object",
             properties: { account_id: { type: "string" } },
@@ -71,8 +68,8 @@ const DEFS = [
         },
     },
     {
-        name: "find_duplicate_entries",
-        description: "Heuristic: groups journal entries by total amount and a configurable date tolerance. Returns groups with two or more candidate dupes.",
+        name: "find_duplicate_transactions",
+        description: "Heuristic: groups transactions by total amount and a configurable date tolerance. Returns groups with two or more candidate dupes.",
         input_schema: {
             type: "object",
             properties: {
@@ -94,18 +91,18 @@ const DEFS = [
     },
     {
         name: "find_unused_accounts",
-        description: "Accounts with zero linked journal lines.",
+        description: "Accounts with zero postings and no children (excludes the five top-level type roots).",
         input_schema: { type: "object", properties: {}, required: [] },
     },
     {
-        name: "find_correlated_entries",
-        description: "Surface pairs of entries that look like the same money movement recorded against different accounts (a transfer recorded once on each statement). Pairs are filtered: same amount + currency, within `tolerance_days` of each other, and the two entries share no account_ids (overlap → duplicate, not correlation).",
+        name: "find_correlated_transactions",
+        description: "Surface pairs of transactions that look like the same money movement recorded against different accounts (a transfer recorded once on each statement). Pairs are filtered: same amount + currency, within `tolerance_days` of each other, and the two transactions share no account_ids (overlap → duplicate, not correlation).",
         input_schema: {
             type: "object",
             properties: {
                 from: { type: "string", description: "ISO date inclusive lower bound (YYYY-MM-DD)." },
                 to: { type: "string", description: "ISO date inclusive upper bound (YYYY-MM-DD)." },
-                tolerance_days: { type: "number", default: 3, description: "Max day gap between paired entries." },
+                tolerance_days: { type: "number", default: 3, description: "Max day gap between paired transactions." },
                 min_amount: { type: "number", default: 0 },
             },
             required: [],
@@ -113,7 +110,7 @@ const DEFS = [
     },
     {
         name: "find_recurrences",
-        description: "Detect candidate recurring transactions by grouping unlinked entries on the same account + amount + side (debit/credit), then classifying cadence (weekly/biweekly/monthly/annually/irregular) from the median gap between consecutive dates. Skips entries already linked to a recurrence.",
+        description: "Detect candidate recurring transactions by grouping unlinked transactions on the same account + amount + side (debit/credit), then classifying cadence (weekly/biweekly/monthly/annually/irregular) from the median gap between consecutive dates. Skips transactions already linked to a recurrence.",
         input_schema: {
             type: "object",
             properties: {
@@ -125,31 +122,31 @@ const DEFS = [
     },
     {
         name: "record_recurrence",
-        description: "Create a recurrences row and link every supplied journal entry to it. Computes first_seen_date, last_seen_date, and next_expected_date from the member entries. Use this after the user confirms a recurrence candidate.",
+        description: "Create a recurrences row and link every supplied transaction to it. Computes first_seen_date, last_seen_date, and next_expected_date from the member transactions. Use this after the user confirms a recurrence candidate.",
         input_schema: {
             type: "object",
             properties: {
                 account_id: { type: "string", description: "The account this recurs on." },
                 description: { type: "string", description: "Human label, e.g. 'Spotify subscription', 'Salary', 'Rent'." },
                 frequency: { type: "string", enum: ["weekly", "biweekly", "monthly", "annually"] },
-                amount_typical: { type: "number", description: "Representative amount (typically the matching amount of the member entries)." },
+                amount_typical: { type: "number", description: "Representative amount (typically the matching amount of the member transactions)." },
                 currency: { type: "string", default: "THB" },
-                entry_ids: { type: "array", items: { type: "string" }, description: "Journal entry ids to link to this recurrence." },
+                transaction_ids: { type: "array", items: { type: "string" }, description: "Transaction ids to link to this recurrence." },
                 notes: { type: "string", description: "Optional context the chat agent can read later." },
             },
-            required: ["account_id", "description", "frequency", "entry_ids"],
+            required: ["account_id", "description", "frequency", "transaction_ids"],
         },
     },
     {
-        name: "link_entry_to_recurrence",
-        description: "Attach a single newly-seen entry to an existing recurrence. Recomputes last_seen_date and next_expected_date on the recurrence.",
+        name: "link_transaction_to_recurrence",
+        description: "Attach a single newly-seen transaction to an existing recurrence. Recomputes last_seen_date and next_expected_date on the recurrence.",
         input_schema: {
             type: "object",
             properties: {
-                entry_id: { type: "string" },
+                transaction_id: { type: "string" },
                 recurrence_id: { type: "string" },
             },
-            required: ["entry_id", "recurrence_id"],
+            required: ["transaction_id", "recurrence_id"],
         },
     },
     {
@@ -163,53 +160,53 @@ const DEFS = [
     },
 ];
 const LABELS = {
-    update_journal_entry: "Updating journal entry",
-    update_journal_line: "Updating journal line",
-    delete_journal_entry: "Deleting journal entry",
+    update_transaction: "Updating transaction",
+    update_posting: "Updating posting",
+    delete_transaction: "Deleting transaction",
     rename_account: "Renaming account",
     merge_accounts: "Merging accounts",
     delete_account: "Deleting account",
-    find_duplicate_entries: "Finding duplicate entries",
+    find_duplicate_transactions: "Finding duplicate transactions",
     find_similar_accounts: "Finding similar accounts",
     find_unused_accounts: "Finding unused accounts",
-    find_correlated_entries: "Finding correlated entries",
+    find_correlated_transactions: "Finding correlated transactions",
     find_recurrences: "Finding recurrences",
     record_recurrence: "Recording recurrence",
-    link_entry_to_recurrence: "Linking entry to recurrence",
+    link_transaction_to_recurrence: "Linking transaction to recurrence",
     mark_review_done: "Finalizing review",
 };
 async function execute(db, name, input, ctx) {
     switch (name) {
-        case "update_journal_entry": {
+        case "update_transaction": {
             if (ctx?.dryRun)
-                return `Would update entry ${input.entry_id}: ${JSON.stringify(input)}`;
-            const changed = updateJournalEntry(db, input.entry_id, {
+                return `Would update transaction ${input.transaction_id}: ${JSON.stringify(input)}`;
+            const changed = updateTransaction(db, input.transaction_id, {
                 date: input.date,
                 description: input.description,
                 source_page: input.source_page,
             });
             return changed === 0
-                ? `Entry ${input.entry_id} not found or no fields to update.`
-                : `Updated entry ${input.entry_id}.`;
+                ? `Transaction ${input.transaction_id} not found or no fields to update.`
+                : `Updated transaction ${input.transaction_id}.`;
         }
-        case "update_journal_line": {
+        case "update_posting": {
             if (ctx?.dryRun)
-                return `Would update line ${input.line_id}: ${JSON.stringify(input)}`;
-            const changed = updateJournalLine(db, input.line_id, {
+                return `Would update posting ${input.posting_id}: ${JSON.stringify(input)}`;
+            const changed = updatePosting(db, input.posting_id, {
                 account_id: input.account_id,
                 memo: input.memo,
             });
             return changed === 0
-                ? `Line ${input.line_id} not found or no fields to update.`
-                : `Updated line ${input.line_id}.`;
+                ? `Posting ${input.posting_id} not found or no fields to update.`
+                : `Updated posting ${input.posting_id}.`;
         }
-        case "delete_journal_entry": {
+        case "delete_transaction": {
             if (ctx?.dryRun)
-                return `Would delete entry ${input.entry_id} (and its lines).`;
-            const changed = deleteJournalEntry(db, input.entry_id);
+                return `Would delete transaction ${input.transaction_id} (and its postings).`;
+            const changed = deleteTransaction(db, input.transaction_id);
             return changed === 0
-                ? `Entry ${input.entry_id} not found.`
-                : `Deleted entry ${input.entry_id} and its lines.`;
+                ? `Transaction ${input.transaction_id} not found.`
+                : `Deleted transaction ${input.transaction_id} and its postings.`;
         }
         case "rename_account": {
             if (ctx?.dryRun)
@@ -224,7 +221,7 @@ async function execute(db, name, input, ctx) {
                 return `Would merge ${input.from_id} → ${input.to_id}.`;
             try {
                 const moved = mergeAccounts(db, input.from_id, input.to_id);
-                return `Merged ${input.from_id} → ${input.to_id}; moved ${moved} line(s).`;
+                return `Merged ${input.from_id} → ${input.to_id}; moved ${moved} posting(s).`;
             }
             catch (err) {
                 return `Could not merge: ${err.message}`;
@@ -241,8 +238,8 @@ async function execute(db, name, input, ctx) {
                 return `Could not delete: ${err.message}`;
             }
         }
-        case "find_duplicate_entries": {
-            const groups = findDuplicateEntries(db, {
+        case "find_duplicate_transactions": {
+            const groups = findDuplicateTransactions(db, {
                 toleranceDays: input.tolerance_days,
                 accountId: input.account_id,
                 minAmount: input.min_amount,
@@ -251,11 +248,11 @@ async function execute(db, name, input, ctx) {
                 return "No candidate duplicate groups found.";
             return groups
                 .map((g, i) => {
-                const header = `Group ${i + 1} — ${formatTHB(g[0].amount)}`;
+                const header = `Group ${i + 1} — ${formatAmount(g[0].amount)}`;
                 const lines = g.map((e, j) => {
                     const accounts = e.account_names.length > 0
                         ? e.account_names.map(n => sanitizeForPrompt(n)).join(", ")
-                        : "(no lines)";
+                        : "(no postings)";
                     return `  ${j + 1}. ${e.date} "${sanitizeForPrompt(e.description)}" — ${accounts}    [${e.id}]`;
                 });
                 return `${header}\n${lines.join("\n")}`;
@@ -276,25 +273,25 @@ async function execute(db, name, input, ctx) {
                 return "No unused accounts.";
             return rows.map(a => `${a.id} | ${sanitizeForPrompt(a.name)} | ${a.type}`).join("\n");
         }
-        case "find_correlated_entries": {
-            const pairs = findCorrelatedEntries(db, {
+        case "find_correlated_transactions": {
+            const pairs = findCorrelatedTransactions(db, {
                 from: input.from,
                 to: input.to,
                 toleranceDays: input.tolerance_days,
                 minAmount: input.min_amount,
             });
             if (pairs.length === 0)
-                return "No correlated entry pairs found.";
+                return "No correlated transaction pairs found.";
             return pairs
                 .map((p, i) => {
                 const accountsA = p.a.account_names.length > 0
                     ? p.a.account_names.map(n => sanitizeForPrompt(n)).join(", ")
-                    : "(no lines)";
+                    : "(no postings)";
                 const accountsB = p.b.account_names.length > 0
                     ? p.b.account_names.map(n => sanitizeForPrompt(n)).join(", ")
-                    : "(no lines)";
+                    : "(no postings)";
                 return [
-                    `Pair ${i + 1} — ${formatTHB(p.amount)} ${p.currency} (gap ${p.day_gap} day${p.day_gap === 1 ? "" : "s"})`,
+                    `Pair ${i + 1} — ${formatAmount(p.amount)} ${p.currency} (gap ${p.day_gap} day${p.day_gap === 1 ? "" : "s"})`,
                     `  A: ${p.a.date} "${sanitizeForPrompt(p.a.description)}" — ${accountsA}    [${p.a.id}]`,
                     `  B: ${p.b.date} "${sanitizeForPrompt(p.b.description)}" — ${accountsB}    [${p.b.id}]`,
                 ].join("\n");
@@ -310,20 +307,20 @@ async function execute(db, name, input, ctx) {
                 return "No recurrence candidates found.";
             return candidates
                 .map((c, i) => {
-                const dates = c.entries.map(e => e.date).join(", ");
-                const ids = c.entries.map(e => e.id).join(", ");
+                const dates = c.transactions.map(e => e.date).join(", ");
+                const ids = c.transactions.map(e => e.id).join(", ");
                 return [
-                    `Candidate ${i + 1} — ${formatTHB(c.amount)} ${c.currency} on ${sanitizeForPrompt(c.account_name)} (${c.side})`,
-                    `  Sightings (${c.entries.length}): ${dates}`,
+                    `Candidate ${i + 1} — ${formatAmount(c.amount)} ${c.currency} on ${sanitizeForPrompt(c.account_name)} (${c.side})`,
+                    `  Sightings (${c.transactions.length}): ${dates}`,
                     `  Median gap: ${c.median_days_between} day(s) → implied ${c.implied_frequency}`,
-                    `  Entry ids: ${ids}`,
+                    `  Transaction ids: ${ids}`,
                 ].join("\n");
             })
                 .join("\n\n");
         }
         case "record_recurrence": {
             if (ctx?.dryRun)
-                return `Would record ${input.frequency} recurrence "${input.description}" linking ${(input.entry_ids || []).length} entries on ${input.account_id}.`;
+                return `Would record ${input.frequency} recurrence "${input.description}" linking ${(input.transaction_ids || []).length} transactions on ${input.account_id}.`;
             try {
                 const id = recordRecurrence(db, {
                     account_id: input.account_id,
@@ -331,21 +328,21 @@ async function execute(db, name, input, ctx) {
                     frequency: input.frequency,
                     amount_typical: input.amount_typical ?? null,
                     currency: input.currency,
-                    entry_ids: input.entry_ids || [],
+                    transaction_ids: input.transaction_ids || [],
                     notes: input.notes ?? null,
                 });
-                return `Recorded recurrence ${id} ("${sanitizeForPrompt(input.description)}", ${input.frequency}); linked ${(input.entry_ids || []).length} entry(ies).`;
+                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}`;
             }
         }
-        case "link_entry_to_recurrence": {
+        case "link_transaction_to_recurrence": {
             if (ctx?.dryRun)
-                return `Would link entry ${input.entry_id} → recurrence ${input.recurrence_id}.`;
+                return `Would link transaction ${input.transaction_id} → recurrence ${input.recurrence_id}.`;
             try {
-                linkEntryToRecurrence(db, input.entry_id, input.recurrence_id);
-                return `Linked entry ${input.entry_id} → recurrence ${input.recurrence_id}.`;
+                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}`;

package/dist/ai/tools/scan.js

@@ -2,7 +2,7 @@ import { sanitizeForPrompt } from "../sanitize.js";
 const DEFS = [
     {
         name: "mark_file_scanned",
-        description: "Call this once the file is fully processed and all journal entries are posted. Summary text is shown to the user.",
+        description: "Call this once the file is fully processed and all transactions are posted. Summary text is shown to the user.",
         input_schema: {
             type: "object",
             properties: {

package/dist/ai/tools/types.d.ts

@@ -1,7 +1,7 @@
 import type Database from "libsql";
 import type { ToolDefinition } from "../provider.js";
 import type { BufferedWriteContext } from "../../scanner/buffer.js";
-export type ToolProfile = "scan" | "chat" | "review";
+export type ToolProfile = "scan" | "chat" | "review" | "record";
 /**
  * Structured highlights the review agent can pass to ask_user. The prompter
  * renders them as a single colored header line above the question (each
@@ -15,7 +15,7 @@ export interface PromptUserFacts {
     accounts?: string[];
 }
 export interface AgentExecutionContext {
-    /** Set during scan so `record_journal_entry` can stamp `source_file_id`. */
+    /** Set during scan so `record_transaction` can stamp `source_file_id`. */
     fileId?: string;
     /** When false, ask_user returns a marker and the caller halts after the run. */
     interactive: boolean;
@@ -26,10 +26,19 @@ export interface AgentExecutionContext {
     /** Called when the model declares the session is done (scan or review). */
     onComplete?: (summary: string) => void;
     /**
-     * Scan-only: when set, journal entries and concerns are queued here instead
-     * of being written directly to the DB. Account writes still hit the DB
-     * eagerly (serialized via account_mutex) so concurrent scan agents share
-     * the same chart of accounts.
+     * Which top-level command this agent serves. Mutating tools branch on this
+     * to decide whether to append an action_log row (currently only "record").
+     */
+    command?: "scan" | "review" | "record";
+    /** Per-invocation id grouping every action_log row from one CLI run. */
+    correlationId?: string;
+    /** The raw user utterance / file path that started this invocation. */
+    userInput?: string;
+    /**
+     * Scan-only: when set, transactions and concerns are queued here instead of
+     * being written directly to the DB. Account and merchant writes still hit
+     * the DB eagerly (serialized via their own mutexes) so concurrent scan
+     * agents share the same chart of accounts and merchant directory.
      */
     buffer?: BufferedWriteContext;
 }

package/dist/cli/commands/accounts.js

@@ -1,19 +1,8 @@
 import chalk from "chalk";
 import { getDb } from "../../db/connection.js";
 import { getAccountBalances } from "../../db/queries/account_balance.js";
-import { formatCurrencyAmount } from "../../currency.js";
-function fmtSigned(n) {
-    const body = formatCurrencyAmount(n, {
-        minimumFractionDigits: 2,
-        maximumFractionDigits: 2,
-    });
-    return n < 0 ? `-${body}` : body;
-}
-// eslint-disable-next-line no-control-regex
-const ANSI_RE = /\x1b\[[0-9;]*m/g;
-function visibleLength(s) {
-    return s.replace(ANSI_RE, "").length;
-}
+import { visibleLength } from "../format.js";
+import { formatSignedAmount } from "../../currency.js";
 const TYPE_TAG = {
     asset: "asset",
     liability: "liab",
@@ -48,20 +37,39 @@ function compactMeta(a) {
 }
 export function showAccounts() {
     const db = getDb();
-    const accounts = [...getAccountBalances(db)].sort((a, b) => {
-        const t = TYPE_RANK[a.type] - TYPE_RANK[b.type];
-        return t !== 0 ? t : a.name.localeCompare(b.name);
-    });
-    if (accounts.length === 0) {
+    const raw = getAccountBalances(db);
+    if (raw.length === 0) {
         console.log(chalk.yellow("No accounts yet. Drop your bank/credit card statements into ~/.plasalid/data/ and run `plasalid scan`."));
         return;
     }
-    const balanceWidth = Math.max(...accounts.map((a) => fmtSigned(a.balance).length));
-    const nameWidth = Math.max(...accounts.map((a) => a.name.length));
+    const byId = new Map(raw.map(a => [a.id, a]));
+    const depthCache = new Map();
+    const depthOf = (id) => {
+        if (depthCache.has(id))
+            return depthCache.get(id);
+        const node = byId.get(id);
+        if (!node || !node.parent_id) {
+            depthCache.set(id, 0);
+            return 0;
+        }
+        const d = depthOf(node.parent_id) + 1;
+        depthCache.set(id, d);
+        return d;
+    };
+    const accounts = [...raw].sort((a, b) => {
+        const t = TYPE_RANK[a.type] - TYPE_RANK[b.type];
+        if (t !== 0)
+            return t;
+        return a.id.localeCompare(b.id);
+    });
+    const balanceWidth = Math.max(...accounts.map((a) => formatSignedAmount(a.balance).length));
+    const nameWidth = Math.max(...accounts.map((a) => a.name.length + depthOf(a.id) * 2));
     for (const a of accounts) {
         const tag = chalk.dim(TYPE_TAG[a.type].padEnd(TYPE_TAG_WIDTH));
-        const name = chalk.bold(a.name) + " ".repeat(nameWidth - a.name.length);
-        const rawBalance = fmtSigned(a.balance);
+        const indent = "  ".repeat(depthOf(a.id));
+        const displayName = indent + a.name;
+        const name = chalk.bold(displayName) + " ".repeat(nameWidth - displayName.length);
+        const rawBalance = formatSignedAmount(a.balance);
         const coloredBalance = a.balance < 0 ? chalk.red(rawBalance) : rawBalance;
         const paddedBalance = " ".repeat(balanceWidth - visibleLength(coloredBalance)) + coloredBalance;
         const meta = compactMeta(a);
@@ -78,9 +86,9 @@ export function showAccounts() {
     const netWorth = assets - liabilities;
     console.log("");
     console.log("  " +
-        chalk.dim(`Assets ${fmtSigned(assets)}`) +
+        chalk.dim(`Assets ${formatSignedAmount(assets)}`) +
         chalk.dim("   ·   ") +
-        chalk.dim(`Liabilities ${fmtSigned(liabilities)}`) +
+        chalk.dim(`Liabilities ${formatSignedAmount(liabilities)}`) +
         chalk.dim("   ·   ") +
-        chalk.bold(`Net worth ${fmtSigned(netWorth)}`));
+        chalk.bold(`Net worth ${formatSignedAmount(netWorth)}`));
 }

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

@@ -0,0 +1,4 @@
+export interface RecordCommandOptions {
+    utterance: string;
+}
+export declare function runRecordCommand(opts: RecordCommandOptions): Promise<void>;

package/dist/cli/commands/record.js

@@ -0,0 +1,119 @@
+import chalk from "chalk";
+import { randomUUID } from "crypto";
+import { getDb } from "../../db/connection.js";
+import { runRecordAgent } from "../../ai/agent.js";
+import { makePromptUser, makeAgentOnProgress, statusSpinner } from "../ux.js";
+import { listActions } from "../../db/queries/action_log.js";
+import { formatAmount } from "../../currency.js";
+export async function runRecordCommand(opts) {
+    const utterance = opts.utterance.trim();
+    if (!utterance) {
+        console.error(chalk.red(`Usage: plasalid record "<what happened>"`));
+        process.exitCode = 1;
+        return;
+    }
+    const db = getDb();
+    const spinner = statusSpinner("Thinking...");
+    const promptUser = makePromptUser(spinner);
+    const onProgress = makeAgentOnProgress(spinner);
+    const correlationId = `cr:${randomUUID()}`;
+    const initialMessages = [
+        { role: "user", content: utterance },
+    ];
+    try {
+        const text = await runRecordAgent({
+            db,
+            initialMessages,
+            prompt: { utterance },
+            agentCtx: {
+                command: "record",
+                correlationId,
+                userInput: utterance,
+                interactive: !!process.stdout.isTTY,
+                promptUser,
+            },
+            onProgress,
+        });
+        spinner.succeed("Done.");
+        if (text) {
+            console.log("");
+            console.log(text);
+        }
+        renderActionSummary(correlationId);
+    }
+    catch (err) {
+        spinner.fail(err?.message ?? "Record failed.");
+        process.exitCode = 1;
+    }
+}
+function renderActionSummary(correlationId) {
+    const actions = listActions(getDb(), { correlationId });
+    if (actions.length === 0)
+        return;
+    console.log("");
+    console.log(chalk.dim(`Logged ${actions.length} action${actions.length === 1 ? "" : "s"} (${correlationId}):`));
+    for (const a of actions) {
+        console.log(chalk.dim(`  · ${describeAction(a)}`));
+    }
+}
+function describeAction(a) {
+    const payload = safeJson(a.payload_json);
+    switch (a.action_type) {
+        case "create_account": {
+            const name = payload?.row?.name ? ` — ${payload.row.name}` : "";
+            return `create_account ${a.target_id}${name}`;
+        }
+        case "update_account_metadata": {
+            const fields = payload?.after && typeof payload.after === "object"
+                ? Object.keys(payload.after).join(", ")
+                : "";
+            return `update_account_metadata ${a.target_id}${fields ? ` — ${fields}` : ""}`;
+        }
+        case "record_transaction": {
+            const date = payload?.transaction?.date ?? "";
+            const desc = payload?.transaction?.description ?? "";
+            const total = totalDebit(payload?.postings);
+            const amount = total != null ? ` ${formatTotal(total, currencyOf(payload?.postings))}` : "";
+            return `record_transaction ${a.target_id} — ${[date, desc].filter(Boolean).join(" ")}${amount}`;
+        }
+        case "adjust_balance": {
+            const before = payload?.before_balance;
+            const after = payload?.after_balance;
+            const currency = currencyOf(payload?.postings);
+            if (typeof before === "number" && typeof after === "number") {
+                return `adjust_balance ${payload?.account_id ?? a.target_id} — ${formatTotal(before, currency)} → ${formatTotal(after, currency)}`;
+            }
+            return `adjust_balance ${a.target_id}`;
+        }
+        case "create_merchant": {
+            const name = payload?.canonical_name ?? "";
+            return `create_merchant ${a.target_id}${name ? ` — ${name}` : ""}`;
+        }
+        case "update_merchant_default": {
+            return `update_merchant_default ${a.target_id} — ${payload?.before ?? "(none)"} → ${payload?.after ?? "(none)"}`;
+        }
+        default:
+            return `${a.action_type} ${a.target_id}`;
+    }
+}
+function safeJson(s) {
+    try {
+        return JSON.parse(s);
+    }
+    catch {
+        return null;
+    }
+}
+function totalDebit(postings) {
+    if (!Array.isArray(postings))
+        return null;
+    return postings.reduce((sum, p) => sum + (Number(p?.debit) || 0), 0);
+}
+function currencyOf(postings) {
+    if (Array.isArray(postings) && postings[0]?.currency)
+        return String(postings[0].currency);
+    return "THB";
+}
+function formatTotal(amount, currency) {
+    return formatAmount(amount, currency);
+}

package/dist/cli/commands/revert.js

@@ -51,7 +51,7 @@ export async function runRevertCommand(regex) {
         console.log(chalk.dim("No scanned files match that regex."));
         return;
     }
-    console.log(chalk.bold(`revert will delete ${matches.length} file(s) and their journal entries:`));
+    console.log(chalk.bold(`revert will delete ${matches.length} file(s) and their transactions:`));
     for (const m of matches) {
         const when = m.scannedAt ? chalk.dim(` (scanned ${m.scannedAt})`) : "";
         console.log(`  • ${m.relPath}${when}`);