plasalid 0.7.1 → 0.7.3

package/dist/ai/tools/account-mutex.js

@@ -0,0 +1,16 @@
+/**
+ * Process-wide serialization for write operations that race when multiple scan
+ * agents run in parallel. Each in-flight `create_account` / `update_account_metadata`
+ * is held inside `runExclusive` so the SQLite write + the subsequent read-back
+ * by another agent's `list_accounts` are consistent.
+ *
+ * Single tail-promise queue: cheap, deterministic, no extra deps.
+ */
+let tail = Promise.resolve();
+export function runExclusive(fn) {
+    const next = tail.then(() => fn());
+    // Swallow rejection so a thrown callback doesn't poison the queue for the
+    // next caller. The caller still sees the rejection through `next`.
+    tail = next.catch(() => undefined);
+    return next;
+}

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

@@ -0,0 +1,2 @@
+import type { ToolModule } from "./types.js";
+export declare const clarifyTools: ToolModule;

package/dist/ai/tools/clarify.js

@@ -0,0 +1,169 @@
+import { deleteTransaction, updateTransaction, updatePosting, } from "../../db/queries/transactions.js";
+import { mergeAccounts } from "../../db/queries/account-balance.js";
+import { linkTransactionToRecurrence, recordRecurrence, } from "../../db/queries/recurrences.js";
+import { sanitizeForPrompt } from "../sanitize.js";
+const DEFS = [
+    {
+        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: {
+                transaction_id: { type: "string" },
+                date: { type: "string" },
+                description: { type: "string" },
+                source_page: { type: "number" },
+            },
+            required: ["transaction_id"],
+        },
+    },
+    {
+        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: {
+                posting_id: { type: "string" },
+                account_id: { type: "string" },
+                memo: { type: "string" },
+            },
+            required: ["posting_id"],
+        },
+    },
+    {
+        name: "delete_transaction",
+        description: "Delete a transaction and (via cascade) all its postings. The primitive for removing duplicates.",
+        input_schema: {
+            type: "object",
+            properties: { transaction_id: { type: "string" } },
+            required: ["transaction_id"],
+        },
+    },
+    {
+        name: "record_recurrence",
+        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 question.",
+        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 transactions).",
+                },
+                currency: { type: "string", default: "THB" },
+                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", "transaction_ids"],
+        },
+    },
+    {
+        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: {
+                transaction_id: { type: "string" },
+                recurrence_id: { type: "string" },
+            },
+            required: ["transaction_id", "recurrence_id"],
+        },
+    },
+    {
+        name: "merge_accounts",
+        description: "Move every posting on `from_id` over to `to_id`, then delete the source account. Use to apply a similar_accounts question's 'Merge A into B' resolution. Refuses if the source still has child accounts.",
+        input_schema: {
+            type: "object",
+            properties: { from_id: { type: "string" }, to_id: { type: "string" } },
+            required: ["from_id", "to_id"],
+        },
+    },
+];
+const LABELS = {
+    update_transaction: "Updating transaction",
+    update_posting: "Updating posting",
+    delete_transaction: "Deleting transaction",
+    record_recurrence: "Recording recurrence",
+    link_transaction_to_recurrence: "Linking transaction to recurrence",
+    merge_accounts: "Merging accounts",
+};
+async function execute(db, name, input, _ctx) {
+    switch (name) {
+        case "update_transaction": {
+            const changed = updateTransaction(db, input.transaction_id, {
+                date: input.date,
+                description: input.description,
+                source_page: input.source_page,
+            });
+            return changed === 0
+                ? `Transaction ${input.transaction_id} not found or no fields to update.`
+                : `Updated transaction ${input.transaction_id}.`;
+        }
+        case "update_posting": {
+            const changed = updatePosting(db, input.posting_id, {
+                account_id: input.account_id,
+                memo: input.memo,
+            });
+            return changed === 0
+                ? `Posting ${input.posting_id} not found or no fields to update.`
+                : `Updated posting ${input.posting_id}.`;
+        }
+        case "delete_transaction": {
+            const changed = deleteTransaction(db, input.transaction_id);
+            return changed === 0
+                ? `Transaction ${input.transaction_id} not found.`
+                : `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}`;
+            }
+        }
+        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}`;
+            }
+        }
+        case "merge_accounts": {
+            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;
+    }
+}
+export const clarifyTools = { DEFS, LABELS, execute };

package/dist/ai/tools/index.js

@@ -1,27 +1,19 @@
 import { commonTools } from "./common.js";
 import { readTools } from "./read.js";
-import { accountIngestTools, scanUnknownTools, resolveIngestTools } from "./ingest.js";
+import { accountIngestTools, scanQuestionTools, clarifyIngestTools } from "./ingest.js";
 import { scanTools } from "./scan.js";
-import { resolveTools } from "./resolve.js";
+import { clarifyTools } from "./clarify.js";
 import { recordTools } from "./record.js";
 import { merchantTools } from "./merchants.js";
 /**
  * Profile composition. Each profile is the union of one or more tool modules;
  * the dispatcher iterates every module on each tool call so we never need a
  * central switch.
- *
- * `accountIngestTools` (create_account / update_account_metadata /
- * record_transaction) ships with scan, resolve, and record — they're the
- * shared write primitives. `scanUnknownTools` (note_unknown) is scan-only;
- * record uses `clarify` from `recordTools` for transient prompts, resolve uses
- * `ask_user` from `resolveIngestTools` for resolve-in-place clarifications.
- * `merchantTools` ships with scan, resolve, and record so any write profile can
- * upsert / look up / re-cache merchants alongside the posting flow.
  */
 const PROFILES = {
-    scan: [commonTools, accountIngestTools, scanUnknownTools, scanTools, merchantTools],
+    scan: [commonTools, accountIngestTools, scanQuestionTools, scanTools, merchantTools],
     chat: [commonTools, readTools],
-    resolve: [commonTools, readTools, accountIngestTools, resolveIngestTools, resolveTools, merchantTools],
+    clarify: [commonTools, readTools, accountIngestTools, clarifyIngestTools, clarifyTools, merchantTools],
     record: [commonTools, readTools, accountIngestTools, recordTools, merchantTools],
 };
 export function getToolDefinitions(profile) {
@@ -31,10 +23,10 @@ const MODULES = [
     commonTools,
     readTools,
     accountIngestTools,
-    scanUnknownTools,
-    resolveIngestTools,
+    scanQuestionTools,
+    clarifyIngestTools,
     scanTools,
-    resolveTools,
+    clarifyTools,
     recordTools,
     merchantTools,
 ];
@@ -56,10 +48,10 @@ export const TOOL_LABELS = {
     ...commonTools.LABELS,
     ...readTools.LABELS,
     ...accountIngestTools.LABELS,
-    ...scanUnknownTools.LABELS,
-    ...resolveIngestTools.LABELS,
+    ...scanQuestionTools.LABELS,
+    ...clarifyIngestTools.LABELS,
     ...scanTools.LABELS,
-    ...resolveTools.LABELS,
+    ...clarifyTools.LABELS,
     ...recordTools.LABELS,
     ...merchantTools.LABELS,
 };

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

@@ -1,4 +1,4 @@
 import type { ToolModule } from "./types.js";
 export declare const accountIngestTools: ToolModule;
-export declare const scanUnknownTools: ToolModule;
-export declare const resolveIngestTools: ToolModule;
+export declare const scanQuestionTools: ToolModule;
+export declare const clarifyIngestTools: ToolModule;