@tpmjs/official-contract-clause-scan 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,46 @@
+import * as ai from 'ai';
+
+/**
+ * Contract Clause Scan Tool for TPMJS
+ * Scans contract text to identify and categorize key clauses
+ */
+/**
+ * Types of clauses commonly found in contracts
+ */
+type ClauseType = 'termination' | 'liability' | 'intellectual_property' | 'confidentiality' | 'indemnification' | 'payment' | 'jurisdiction' | 'dispute_resolution' | 'force_majeure' | 'assignment' | 'notice' | 'amendment' | 'severability' | 'entire_agreement' | 'warranty' | 'non_compete' | 'auto_renewal' | 'other';
+/**
+ * Represents a single identified clause
+ */
+interface Clause {
+    type: ClauseType;
+    text: string;
+    location: {
+        startIndex: number;
+        endIndex: number;
+        paragraph?: number;
+    };
+    confidence: number;
+    summary: string;
+}
+/**
+ * Input interface for contract clause scanning
+ */
+interface ContractClauseScanInput {
+    contractText: string;
+}
+/**
+ * Output interface for contract clause scan result
+ */
+interface ContractClauses {
+    clauses: Clause[];
+    clauseCount: number;
+    clausesByType: Record<ClauseType, number>;
+    summary: string;
+}
+/**
+ * Contract Clause Scan Tool
+ * Scans contract text to identify and categorize key clauses
+ */
+declare const contractClauseScanTool: ai.Tool<ContractClauseScanInput, ContractClauses>;
+
+export { type Clause, type ContractClauses, contractClauseScanTool, contractClauseScanTool as default };

package/dist/index.js

@@ -0,0 +1,165 @@
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+var CLAUSE_PATTERNS = {
+  termination: {
+    keywords: ["terminat", "cancel", "end this agreement", "cease"],
+    contextKeywords: ["notice", "cause", "convenience"]
+  },
+  liability: {
+    keywords: ["liab", "damages", "loss", "responsible for"],
+    contextKeywords: ["limit", "exclude", "consequential", "incidental"]
+  },
+  intellectual_property: {
+    keywords: ["intellectual property", "copyright", "patent", "trademark", "IP rights"],
+    contextKeywords: ["ownership", "license", "proprietary"]
+  },
+  confidentiality: {
+    keywords: ["confidential", "proprietary information", "non-disclosure"],
+    contextKeywords: ["secret", "disclose", "protect"]
+  },
+  indemnification: {
+    keywords: ["indemnif", "hold harmless", "defend"],
+    contextKeywords: ["claims", "losses", "expenses"]
+  },
+  payment: {
+    keywords: ["payment", "fee", "compensation", "invoice", "price"],
+    contextKeywords: ["due", "terms", "installment"]
+  },
+  jurisdiction: {
+    keywords: ["jurisdiction", "governing law", "venue"],
+    contextKeywords: ["state", "court", "laws of"]
+  },
+  dispute_resolution: {
+    keywords: ["arbitration", "mediation", "dispute resolution"],
+    contextKeywords: ["conflict", "disagreement", "binding"]
+  },
+  force_majeure: {
+    keywords: ["force majeure", "act of god", "beyond reasonable control"],
+    contextKeywords: ["excused", "delay", "natural disaster"]
+  },
+  assignment: {
+    keywords: ["assign", "transfer", "successor"],
+    contextKeywords: ["consent", "bind", "delegate"]
+  },
+  notice: {
+    keywords: ["notice", "notification", "written communication"],
+    contextKeywords: ["address", "email", "registered mail"]
+  },
+  amendment: {
+    keywords: ["amend", "modif", "change this agreement"],
+    contextKeywords: ["writing", "signed", "mutually"]
+  },
+  severability: {
+    keywords: ["severab", "invalid", "unenforceable"],
+    contextKeywords: ["provision", "remainder", "effect"]
+  },
+  entire_agreement: {
+    keywords: ["entire agreement", "integration", "supersede"],
+    contextKeywords: ["previous", "prior", "complete"]
+  },
+  warranty: {
+    keywords: ["warrant", "represent", "guarantee"],
+    contextKeywords: ["assure", "promise", "covenant"]
+  },
+  non_compete: {
+    keywords: ["non-compete", "non compete", "competitive"],
+    contextKeywords: ["restrict", "prohibit", "during term"]
+  },
+  auto_renewal: {
+    keywords: ["auto-renew", "automatic renewal", "renew automatically"],
+    contextKeywords: ["unless", "notice", "term"]
+  },
+  other: {
+    keywords: []
+  }
+};
+function analyzeContract(contractText) {
+  if (!contractText || contractText.trim().length === 0) {
+    throw new Error("Contract text cannot be empty");
+  }
+  const paragraphs = contractText.split(/\n\s*\n/).filter((p) => p.trim().length > 0);
+  const clauses = [];
+  const clausesByType = {};
+  Object.keys(CLAUSE_PATTERNS).forEach((type) => {
+    clausesByType[type] = 0;
+  });
+  paragraphs.forEach((paragraph, paraIndex) => {
+    const paraText = paragraph.trim();
+    const normalizedPara = paraText.toLowerCase();
+    const startIndex = contractText.indexOf(paraText);
+    for (const [type, pattern] of Object.entries(CLAUSE_PATTERNS)) {
+      if (type === "other") continue;
+      const keywordMatches = pattern.keywords.some(
+        (keyword) => normalizedPara.includes(keyword.toLowerCase())
+      );
+      if (keywordMatches) {
+        let confidence = 0.6;
+        if (pattern.contextKeywords) {
+          const contextMatches = pattern.contextKeywords.filter(
+            (keyword) => normalizedPara.includes(keyword.toLowerCase())
+          ).length;
+          confidence += contextMatches / pattern.contextKeywords.length * 0.4;
+        } else {
+          confidence = 0.8;
+        }
+        const sentences = paraText.split(/[.!?]+/);
+        const summary2 = sentences[0]?.trim() || (paraText.length > 150 ? `${paraText.substring(0, 150)}...` : paraText);
+        const clause = {
+          type,
+          text: paraText,
+          location: {
+            startIndex,
+            endIndex: startIndex + paraText.length,
+            paragraph: paraIndex + 1
+          },
+          confidence: Math.min(confidence, 1),
+          summary: summary2
+        };
+        clauses.push(clause);
+        clausesByType[type]++;
+        break;
+      }
+    }
+  });
+  const topClauseTypes = Object.entries(clausesByType).filter(([_, count]) => count > 0).sort(([, a], [, b]) => b - a).slice(0, 5).map(([type]) => type.replace(/_/g, " "));
+  const summary = clauses.length > 0 ? `Found ${clauses.length} clauses across ${paragraphs.length} paragraphs. Primary clause types: ${topClauseTypes.join(", ")}.` : "No standard clauses identified in the provided text.";
+  return {
+    clauses: clauses.sort((a, b) => b.confidence - a.confidence),
+    clauseCount: clauses.length,
+    clausesByType,
+    summary
+  };
+}
+var contractClauseScanTool = tool({
+  description: "Scans contract text to identify and categorize key clauses such as termination, liability, intellectual property, confidentiality, indemnification, payment terms, jurisdiction, dispute resolution, and more. Returns identified clauses with their locations in the document and confidence scores.",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      contractText: {
+        type: "string",
+        description: "The full contract text to analyze for clause identification"
+      }
+    },
+    required: ["contractText"],
+    additionalProperties: false
+  }),
+  execute: async ({ contractText }) => {
+    if (typeof contractText !== "string") {
+      throw new Error("Contract text must be a string");
+    }
+    if (contractText.trim().length === 0) {
+      throw new Error("Contract text cannot be empty");
+    }
+    try {
+      return analyzeContract(contractText);
+    } catch (error) {
+      throw new Error(
+        `Failed to scan contract clauses: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+});
+var index_default = contractClauseScanTool;
+
+export { contractClauseScanTool, index_default as default };

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@tpmjs/official-contract-clause-scan",
+  "version": "0.1.0",
+  "description": "Scans contract text to identify and categorize key clauses (termination, liability, IP, etc.)",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "legal",
+    "contract",
+    "clause",
+    "analysis"
+  ],
+  "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/contract-clause-scan"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "legal",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "name": "contractClauseScanTool",
+        "description": "Scans contract text to identify and categorize key clauses (termination, liability, IP, etc.)",
+        "parameters": [
+          {
+            "name": "contractText",
+            "type": "string",
+            "description": "Contract text to analyze",
+            "required": true
+          }
+        ],
+        "returns": {
+          "type": "ContractClauses",
+          "description": "Identified clauses by category with locations"
+        }
+      }
+    ]
+  },
+  "dependencies": {
+    "ai": "6.0.0-beta.124"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}