@tpmjs/official-invoice-terms-extract 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024-2025 TPMJS
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/index.d.ts

@@ -0,0 +1,52 @@
+import * as ai from 'ai';
+
+/**
+ * Invoice Terms Extract Tool for TPMJS
+ * Extracts payment terms, due dates, and late fees from invoice text
+ */
+/**
+ * Input interface for invoice terms extraction
+ */
+interface InvoiceTermsExtractInput {
+    invoiceText: string;
+}
+/**
+ * Late fee structure
+ */
+interface LateFee {
+    type: 'percentage' | 'fixed' | 'daily' | 'monthly';
+    amount: number;
+    currency?: string;
+    description: string;
+}
+/**
+ * Discount terms for early payment
+ */
+interface EarlyPaymentDiscount {
+    discountPercentage: number;
+    paymentDays: number;
+    description: string;
+}
+/**
+ * Output interface for extracted payment terms
+ */
+interface PaymentTerms {
+    netDays: number | null;
+    dueDate: string | null;
+    invoiceDate: string | null;
+    invoiceNumber: string | null;
+    totalAmount: number | null;
+    currency: string | null;
+    lateFee: LateFee | null;
+    earlyPaymentDiscount: EarlyPaymentDiscount | null;
+    paymentMethods: string[];
+    additionalTerms: string[];
+    summary: string;
+}
+/**
+ * Invoice Terms Extract Tool
+ * Extracts payment terms, due dates, and late fees from invoice text
+ */
+declare const invoiceTermsExtractTool: ai.Tool<InvoiceTermsExtractInput, PaymentTerms>;
+
+export { type EarlyPaymentDiscount, type LateFee, type PaymentTerms, invoiceTermsExtractTool as default, invoiceTermsExtractTool };

package/dist/index.js

@@ -0,0 +1,268 @@
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+function extractNetDays(text) {
+  const normalizedText = text.toLowerCase();
+  const netMatch = normalizedText.match(/net\s+(\d+)(?:\s+days?)?/i);
+  if (netMatch && netMatch[1]) {
+    return Number.parseInt(netMatch[1], 10);
+  }
+  const daysMatch = normalizedText.match(/(?:payment\s+)?(?:due\s+)?(?:in\s+)?(\d+)\s+days/i);
+  if (daysMatch && daysMatch[1]) {
+    return Number.parseInt(daysMatch[1], 10);
+  }
+  if (normalizedText.includes("due on receipt") || normalizedText.includes("payable immediately")) {
+    return 0;
+  }
+  if (normalizedText.includes("end of month") || normalizedText.includes("eom")) {
+    return 30;
+  }
+  return null;
+}
+function extractDueDate(text) {
+  const datePatterns = [
+    /due(?:\s+date)?:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i,
+    /payment\s+due:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i,
+    /due\s+by:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i,
+    /due\s+on:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i
+  ];
+  for (const pattern of datePatterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) {
+      return match[1];
+    }
+  }
+  const writtenDateMatch = text.match(
+    /due\s+(?:date|on|by)?:?\s*(\w+\s+\d{1,2},?\s+\d{4}|\d{1,2}\s+\w+\s+\d{4})/i
+  );
+  if (writtenDateMatch && writtenDateMatch[1]) {
+    return writtenDateMatch[1];
+  }
+  return null;
+}
+function extractInvoiceDate(text) {
+  const datePatterns = [
+    /invoice\s+date:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i,
+    /date:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i,
+    /dated:?\s*(\d{1,2}[\/\-]\d{1,2}[\/\-]\d{2,4})/i
+  ];
+  for (const pattern of datePatterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function extractInvoiceNumber(text) {
+  const patterns = [
+    /invoice\s+(?:number|#|no\.?):?\s*([A-Z0-9\-]+)/i,
+    /invoice:?\s+([A-Z0-9\-]+)/i,
+    /#\s*([A-Z0-9\-]+)/
+  ];
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match && match[1]) {
+      return match[1];
+    }
+  }
+  return null;
+}
+function extractTotalAmount(text) {
+  const patterns = [
+    /(?:total|amount\s+due|balance\s+due):?\s*\$?\s*([\d,]+\.?\d*)/i,
+    /\$\s*([\d,]+\.?\d*)/,
+    /(?:total|amount\s+due|balance\s+due):?\s*([A-Z]{3})\s*([\d,]+\.?\d*)/i
+  ];
+  for (const pattern of patterns) {
+    const match = text.match(pattern);
+    if (match) {
+      const hasCurrencyCode = match[0].match(/[A-Z]{3}/);
+      const currency = hasCurrencyCode && match[1] ? match[1] : "USD";
+      const amountStr = hasCurrencyCode && match[2] ? match[2] : match[1];
+      if (amountStr) {
+        const amount = Number.parseFloat(amountStr.replace(/,/g, ""));
+        if (!isNaN(amount)) {
+          return { amount, currency };
+        }
+      }
+    }
+  }
+  return { amount: null, currency: null };
+}
+function extractLateFee(text) {
+  const normalizedText = text.toLowerCase();
+  const percentageMatch = normalizedText.match(
+    /([\d.]+)%\s*(?:per\s+month|monthly|late\s+fee|interest)/i
+  );
+  if (percentageMatch && percentageMatch[1]) {
+    return {
+      type: "monthly",
+      amount: Number.parseFloat(percentageMatch[1]),
+      description: `${percentageMatch[1]}% per month late fee`
+    };
+  }
+  const dailyMatch = normalizedText.match(/([\d.]+)%\s*(?:per\s+day|daily)/i);
+  if (dailyMatch && dailyMatch[1]) {
+    return {
+      type: "daily",
+      amount: Number.parseFloat(dailyMatch[1]),
+      description: `${dailyMatch[1]}% per day late fee`
+    };
+  }
+  const fixedMatch = text.match(/(?:late\s+fee|fee)(?:\s+of)?\s*\$?\s*([\d.]+)/i);
+  if (fixedMatch && fixedMatch[1]) {
+    return {
+      type: "fixed",
+      amount: Number.parseFloat(fixedMatch[1]),
+      currency: "USD",
+      description: `$${fixedMatch[1]} late fee`
+    };
+  }
+  return null;
+}
+function extractEarlyPaymentDiscount(text) {
+  const discountMatch = text.match(/(\d+)\/(\d+)\s+(?:net|n)\s+\d+/i);
+  if (discountMatch && discountMatch[1] && discountMatch[2]) {
+    return {
+      discountPercentage: Number.parseInt(discountMatch[1], 10),
+      paymentDays: Number.parseInt(discountMatch[2], 10),
+      description: `${discountMatch[1]}% discount if paid within ${discountMatch[2]} days`
+    };
+  }
+  const explicitMatch = text.match(/(\d+)%\s+discount\s+(?:if\s+paid\s+)?within\s+(\d+)\s+days/i);
+  if (explicitMatch && explicitMatch[1] && explicitMatch[2]) {
+    return {
+      discountPercentage: Number.parseInt(explicitMatch[1], 10),
+      paymentDays: Number.parseInt(explicitMatch[2], 10),
+      description: `${explicitMatch[1]}% discount if paid within ${explicitMatch[2]} days`
+    };
+  }
+  return null;
+}
+function extractPaymentMethods(text) {
+  const normalizedText = text.toLowerCase();
+  const methods = [];
+  const paymentPatterns = [
+    { keyword: "check", value: "Check" },
+    { keyword: "wire transfer", value: "Wire Transfer" },
+    { keyword: "ach", value: "ACH" },
+    { keyword: "credit card", value: "Credit Card" },
+    { keyword: "debit card", value: "Debit Card" },
+    { keyword: "paypal", value: "PayPal" },
+    { keyword: "venmo", value: "Venmo" },
+    { keyword: "cash", value: "Cash" },
+    { keyword: "bank transfer", value: "Bank Transfer" },
+    { keyword: "online payment", value: "Online Payment" }
+  ];
+  paymentPatterns.forEach(({ keyword, value }) => {
+    if (normalizedText.includes(keyword)) {
+      methods.push(value);
+    }
+  });
+  return [...new Set(methods)];
+}
+function extractAdditionalTerms(text) {
+  const terms = [];
+  const normalizedText = text.toLowerCase();
+  const termPatterns = [
+    { keyword: "non-refundable", term: "Payment is non-refundable" },
+    { keyword: "prepayment required", term: "Prepayment required" },
+    { keyword: "partial payments", term: "Partial payments accepted" },
+    { keyword: "installment", term: "Installment payments available" },
+    {
+      keyword: "collection costs",
+      term: "Customer responsible for collection costs"
+    },
+    {
+      keyword: "interest charges",
+      term: "Interest charges apply to overdue amounts"
+    }
+  ];
+  termPatterns.forEach(({ keyword, term }) => {
+    if (normalizedText.includes(keyword)) {
+      terms.push(term);
+    }
+  });
+  return terms;
+}
+function extractPaymentTerms(invoiceText) {
+  if (!invoiceText || invoiceText.trim().length === 0) {
+    throw new Error("Invoice text cannot be empty");
+  }
+  const netDays = extractNetDays(invoiceText);
+  const dueDate = extractDueDate(invoiceText);
+  const invoiceDate = extractInvoiceDate(invoiceText);
+  const invoiceNumber = extractInvoiceNumber(invoiceText);
+  const { amount, currency } = extractTotalAmount(invoiceText);
+  const lateFee = extractLateFee(invoiceText);
+  const earlyPaymentDiscount = extractEarlyPaymentDiscount(invoiceText);
+  const paymentMethods = extractPaymentMethods(invoiceText);
+  const additionalTerms = extractAdditionalTerms(invoiceText);
+  let summary = "Extracted payment terms: ";
+  const summaryParts = [];
+  if (netDays !== null) {
+    summaryParts.push(`Net ${netDays} days`);
+  }
+  if (dueDate) {
+    summaryParts.push(`due ${dueDate}`);
+  }
+  if (amount !== null) {
+    summaryParts.push(`total ${currency || "USD"} ${amount.toFixed(2)}`);
+  }
+  if (lateFee) {
+    summaryParts.push(`late fee: ${lateFee.description}`);
+  }
+  if (earlyPaymentDiscount) {
+    summaryParts.push(`discount: ${earlyPaymentDiscount.description}`);
+  }
+  if (paymentMethods.length > 0) {
+    summaryParts.push(`accepted: ${paymentMethods.join(", ")}`);
+  }
+  summary += summaryParts.length > 0 ? summaryParts.join("; ") : "No specific payment terms identified";
+  return {
+    netDays,
+    dueDate,
+    invoiceDate,
+    invoiceNumber,
+    totalAmount: amount,
+    currency,
+    lateFee,
+    earlyPaymentDiscount,
+    paymentMethods,
+    additionalTerms,
+    summary
+  };
+}
+var invoiceTermsExtractTool = tool({
+  description: "Extracts and normalizes payment terms from invoice text or payment terms sections. Identifies net payment days (e.g., Net 30), due dates, invoice dates, invoice numbers, total amounts, currencies, late fee structures (percentage, fixed, daily, monthly), early payment discounts, accepted payment methods, and additional terms. Returns structured payment terms ready for processing or calendar entry.",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      invoiceText: {
+        type: "string",
+        description: "The invoice text or payment terms section to analyze"
+      }
+    },
+    required: ["invoiceText"],
+    additionalProperties: false
+  }),
+  execute: async ({ invoiceText }) => {
+    if (typeof invoiceText !== "string") {
+      throw new Error("Invoice text must be a string");
+    }
+    if (invoiceText.trim().length === 0) {
+      throw new Error("Invoice text cannot be empty");
+    }
+    try {
+      return extractPaymentTerms(invoiceText);
+    } catch (error) {
+      throw new Error(
+        `Failed to extract invoice terms: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+});
+var index_default = invoiceTermsExtractTool;
+
+export { index_default as default, invoiceTermsExtractTool };

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@tpmjs/official-invoice-terms-extract",
+  "version": "0.1.0",
+  "description": "Extracts payment terms, due dates, and late fees from invoice text",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "legal",
+    "invoice",
+    "payment",
+    "terms"
+  ],
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "tsup": "^8.3.5",
+    "typescript": "^5.9.3",
+    "@tpmjs/tsconfig": "0.0.0"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/anthropics/tpmjs.git",
+    "directory": "packages/tools/official/invoice-terms-extract"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "legal",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "name": "invoiceTermsExtractTool",
+        "description": "Extracts payment terms, due dates, and late fees from invoice text",
+        "parameters": [
+          {
+            "name": "invoiceText",
+            "type": "string",
+            "description": "Invoice text or terms section",
+            "required": true
+          }
+        ],
+        "returns": {
+          "type": "PaymentTerms",
+          "description": "Extracted and normalized payment terms"
+        }
+      }
+    ]
+  },
+  "dependencies": {
+    "ai": "6.0.0-beta.124"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}