paisa-mcp 0.0.3 → 0.0.4

package/dist/index.js

@@ -42597,8 +42597,7 @@ function registerGoalTools(server, client) {
       startDate: exports_external.string().optional().describe("[emi] YYYY-MM-DD"),
       endDate: exports_external.string().optional().describe("[emi] YYYY-MM-DD last payment date"),
       totalMonths: exports_external.number().optional().describe("[emi] Tenure in months"),
-      paidMonths: exports_external.number().optional().describe("[emi] Months already paid"),
-      monthlyContribution: exports_external.string().optional().describe("[sinking_fund] Monthly contribution (optional)")
+      paidMonths: exports_external.number().optional().describe("[emi] Months already paid")
     }
   }, async ({ type, ...fields }) => {
     const require2 = (keys) => {
@@ -43279,6 +43278,7 @@ var MERCHANT_ALIASES = [
   ["LivPure", ["livpure smart homes", "livpure"]],
   ["HundredX", ["hundredx school", "hundredx"]]
 ];
+var GATEWAY_PREFIX = /^(paytm|payu|razorpay|cashfree|billdesk|easebuzz|rbl|pyu)\*/i;
 var aliasIndex = [];
 for (const [canonical, aliases] of MERCHANT_ALIASES) {
   for (const alias of aliases) {
@@ -43286,6 +43286,24 @@ for (const [canonical, aliases] of MERCHANT_ALIASES) {
   }
 }
 aliasIndex.sort((a, b) => b.alias.length - a.alias.length);
+function resolveAlias(name) {
+  let lower = name.toLowerCase();
+  const gwMatch = lower.match(GATEWAY_PREFIX);
+  if (gwMatch) {
+    lower = lower.slice(gwMatch[0].length).trim();
+  }
+  for (const { alias, canonical } of aliasIndex) {
+    if (alias.length <= 4) {
+      const re = new RegExp(`\\b${alias}\\b`);
+      if (re.test(lower))
+        return canonical;
+    } else {
+      if (lower.includes(alias))
+        return canonical;
+    }
+  }
+  return null;
+}
 // ../../node_modules/.bun/fuzzball@2.2.3/node_modules/fuzzball/dist/esm/fuzzball.esm.min.js
 var e;
 var t = typeof globalThis != "undefined" ? globalThis : typeof window != "undefined" ? window : typeof global != "undefined" ? global : typeof self != "undefined" ? self : {};
@@ -45000,9 +45018,152 @@ var Yo = Ro.process_and_sort;
 var ea = Ro.unique_tokens;
 var ta = Ro.dedupe;
 
+// ../reconciliation/src/normalise.ts
+var CORPORATE_SUFFIXES = /\b(PRIVATE|PVT\.?|LIMITED|LTD\.?)\s*\w*/gi;
+function normaliseName(name) {
+  return name.replace(CORPORATE_SUFFIXES, "").replace(/[^\w\s]/g, " ").replace(/\s+/g, " ").trim().toLowerCase();
+}
+
 // ../reconciliation/src/entity.ts
+var FUZZBALL_THRESHOLD = 92;
 var _aliasReCache = new Map;
+function getAliasRegex(lower) {
+  let re2 = _aliasReCache.get(lower);
+  if (!re2) {
+    const escaped = lower.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    re2 = new RegExp(`\\b${escaped}\\b`);
+    _aliasReCache.set(lower, re2);
+  }
+  return re2;
+}
 var _normCache = new WeakMap;
+function cachedNormaliseName(opt) {
+  let cached2 = _normCache.get(opt);
+  if (cached2 === undefined) {
+    cached2 = normaliseName(opt.name);
+    _normCache.set(opt, cached2);
+  }
+  return cached2;
+}
+function matchUserAlias(normalisedName, aliases) {
+  const sorted = [...aliases].sort((a2, b2) => b2.pattern.length - a2.pattern.length);
+  for (const alias of sorted) {
+    const lower = alias.pattern.toLowerCase();
+    if (lower.length <= 4) {
+      if (getAliasRegex(lower).test(normalisedName))
+        return alias;
+    } else if (normalisedName.includes(lower)) {
+      return alias;
+    }
+  }
+  return null;
+}
+function fuzzMatch(normalisedName, options) {
+  let best = null;
+  for (const opt of options) {
+    const candidate = cachedNormaliseName(opt);
+    if (!candidate)
+      continue;
+    const score = Math.max(Fo(normalisedName, candidate), Bo(normalisedName, candidate));
+    if (score >= FUZZBALL_THRESHOLD && (!best || score > best.score)) {
+      best = { row: opt, score };
+    }
+  }
+  return best?.row ?? null;
+}
+function resolveMerchant(normalisedName, ctx) {
+  const canonical = resolveAlias(normalisedName);
+  if (canonical) {
+    const normCanonical = normaliseName(canonical);
+    const match = ctx.globalMerchants.find((m2) => cachedNormaliseName(m2) === normCanonical);
+    if (match)
+      return { type: "merchant", merchantId: match.id };
+  }
+  const userAlias = matchUserAlias(normalisedName, ctx.userMerchantAliases);
+  if (userAlias)
+    return { type: "merchant", merchantId: userAlias.merchantId };
+  const fuzzMerchant = fuzzMatch(normalisedName, [...ctx.globalMerchants, ...ctx.localMerchants]);
+  if (fuzzMerchant)
+    return { type: "merchant", merchantId: fuzzMerchant.id };
+  return null;
+}
+function resolvePerson(normalisedName, ctx) {
+  const userAlias = matchUserAlias(normalisedName, ctx.userPersonAliases);
+  if (userAlias)
+    return { type: "person", personId: userAlias.personId };
+  const fuzzPerson = fuzzMatch(normalisedName, ctx.persons);
+  if (fuzzPerson)
+    return { type: "person", personId: fuzzPerson.id };
+  return null;
+}
+function resolveEntity(name, hint, ctx) {
+  const normalised = normaliseName(name);
+  if (!normalised)
+    return null;
+  if (hint === "person") {
+    return resolvePerson(normalised, ctx) ?? resolveMerchant(normalised, ctx) ?? null;
+  }
+  if (hint === "merchant") {
+    return resolveMerchant(normalised, ctx) ?? null;
+  }
+  return resolveMerchant(normalised, ctx) ?? resolvePerson(normalised, ctx) ?? null;
+}
+
+// ../reconciliation/src/categorize.ts
+function autoCategorizeFromDescriptions(ctx) {
+  const resolveCtx = {
+    globalMerchants: ctx.globalMerchants,
+    localMerchants: ctx.localMerchants,
+    persons: ctx.persons,
+    userMerchantAliases: ctx.bag.merchantAliases,
+    userPersonAliases: ctx.bag.personAliases
+  };
+  const groups = new Map;
+  let unresolvedCount = 0;
+  let totalAffected = 0;
+  for (const row of ctx.rows) {
+    if (row.isTransfer || row.isIgnored)
+      continue;
+    let entity = null;
+    if (row.merchantId)
+      entity = { type: "merchant", merchantId: row.merchantId };
+    else if (row.personId)
+      entity = { type: "person", personId: row.personId };
+    else
+      entity = resolveEntity(row.description, "unknown", resolveCtx);
+    if (!entity) {
+      unresolvedCount += 1;
+      continue;
+    }
+    const rule = entityRule(entity, ctx.bag);
+    if (row.categoryId && rule && rule.categoryId === row.categoryId)
+      continue;
+    const needsLink = !row.merchantId && !row.personId;
+    const needsCategory = !row.categoryId && rule != null;
+    if (!needsLink && !needsCategory)
+      continue;
+    const key = entityKey(entity);
+    const existing = groups.get(key);
+    const suggestion = existing ?? {
+      entity,
+      source: rule ? "category-rule" : "alias-only",
+      categoryId: rule?.categoryId ?? null,
+      transactionIds: []
+    };
+    suggestion.transactionIds.push(row.id);
+    groups.set(key, suggestion);
+    totalAffected += 1;
+  }
+  return { suggestions: Array.from(groups.values()), totalAffected, unresolvedCount };
+}
+function entityKey(e2) {
+  return e2.type === "merchant" ? `m:${e2.merchantId}` : `p:${e2.personId}`;
+}
+function entityRule(e2, bag) {
+  if (e2.type === "merchant")
+    return bag.merchantRules[e2.merchantId] ?? null;
+  return bag.personRules[e2.personId] ?? null;
+}
 // ../reconciliation/src/settlement.ts
 var SETTLEMENT_PATTERNS = [
   /\bCRED\b.*\bPAYMENT\b/i,
@@ -45080,6 +45241,45 @@ function settlementEnrichedData(description, type, source) {
   return out;
 }
 // src/tools/transactions.ts
+async function runRescan(client) {
+  const learningRes = await client.get("/api/household-learning");
+  const bag = learningRes.data?.bag ?? {
+    merchantAliases: [],
+    personAliases: [],
+    merchantRules: {},
+    personRules: {}
+  };
+  const merchantsRes = await client.get("/api/merchants");
+  const allMerchants = merchantsRes.data ?? [];
+  const globalMerchants = allMerchants.filter((m2) => !m2.householdId && m2.cleanName).map((m2) => ({ id: m2.id, name: m2.cleanName }));
+  const localMerchants = allMerchants.filter((m2) => m2.householdId && m2.cleanName).map((m2) => ({ id: m2.id, name: m2.cleanName }));
+  const personsRes = await client.get("/api/persons");
+  const persons = (personsRes.data ?? []).filter((p2) => p2.name);
+  const allRows = [];
+  let offset = 0;
+  const limit = 500;
+  while (true) {
+    const res = await client.get("/api/transactions", { limit, offset });
+    const rows = res.data ?? [];
+    allRows.push(...rows);
+    if (!res.hasMore || rows.length === 0)
+      break;
+    offset += limit;
+  }
+  const plan = autoCategorizeFromDescriptions({ rows: allRows, bag, globalMerchants, localMerchants, persons });
+  const links = plan.suggestions.filter((s2) => s2.categoryId).flatMap((s2) => s2.transactionIds.map((txId) => ({
+    transactionId: txId,
+    ...s2.entity.type === "merchant" ? { merchantId: s2.entity.merchantId } : { personId: s2.entity.personId },
+    categoryId: s2.categoryId
+  })));
+  if (links.length > 0) {
+    const CHUNK = 500;
+    for (let i2 = 0;i2 < links.length; i2 += CHUNK) {
+      await client.post("/api/transactions/bulk-link-entity", { links: links.slice(i2, i2 + CHUNK) });
+    }
+  }
+  return { linked: links.length, unresolved: plan.unresolvedCount };
+}
 function registerTransactionTools(server, client, crypto3) {
   server.registerTool("get_transactions", {
     description: "Search and filter transactions. Returns paginated results with merchant and category details.",
@@ -45204,7 +45404,15 @@ function registerTransactionTools(server, client, crypto3) {
       granularity,
       transactions: rows
     });
-    return { content: [{ type: "text", text: JSON.stringify(data) }] };
+    const rescan = await runRescan(client);
+    return {
+      content: [
+        {
+          type: "text",
+          text: JSON.stringify({ import: data, rescan })
+        }
+      ]
+    };
   });
   server.registerTool("delete_transactions", {
     description: "Hard-delete transactions. This is PERMANENT and cannot be undone. " + "Provide exactly one of: `id` (single transaction), `ids` (a list of transactions), " + "or `filters` (deletes all matching transactions). Returns the number of deleted transactions " + "for the bulk paths.",
@@ -45233,6 +45441,13 @@ function registerTransactionTools(server, client, crypto3) {
     const data = await client.delete("/api/transactions/bulk", body);
     return { content: [{ type: "text", text: JSON.stringify(data) }] };
   });
+  server.registerTool("rescan_transactions", {
+    description: "Apply the household's saved learning rules (merchant aliases + category rules) to all uncategorized transactions. " + "Equivalent to the browser's auto-categorize flow. Run this after importing statements via MCP to populate merchants and categories.",
+    inputSchema: {}
+  }, async () => {
+    const result = await runRescan(client);
+    return { content: [{ type: "text", text: JSON.stringify(result) }] };
+  });
   server.registerTool("get_settlement_candidates", {
     description: "Find bank debit transactions that look like bill payments for a specific credit card account. " + "Call this after importing a CC statement to identify which existing bank debits should be marked " + "as transfers (to avoid double-counting expenses). Returns transactions with their account name, " + "date, amount, and description.",
     inputSchema: {
@@ -45336,5 +45551,5 @@ main().catch((err) => {
   process.exit(1);
 });
 
-//# debugId=8AA3117ABFC4C20064756E2164756E21
+//# debugId=E58A7271779D454264756E2164756E21
 //# sourceMappingURL=index.js.map