@tpmjs/official-tos-readability 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,50 @@
+import * as ai from 'ai';
+
+/**
+ * ToS Readability Tool for TPMJS
+ * Analyzes Terms of Service for readability, complexity, and consumer-friendliness
+ */
+/**
+ * Input interface for ToS readability analysis
+ */
+interface TOSReadabilityInput {
+    tosText: string;
+}
+/**
+ * Represents a problematic section in the ToS
+ */
+interface ProblematicSection {
+    text: string;
+    issue: string;
+    severity: 'low' | 'medium' | 'high';
+    suggestion: string;
+}
+/**
+ * Readability metrics for the ToS
+ */
+interface ReadabilityMetrics {
+    fleschReadingEase: number;
+    fleschKincaidGrade: number;
+    averageSentenceLength: number;
+    averageWordLength: number;
+    complexWordPercentage: number;
+}
+/**
+ * Output interface for ToS analysis
+ */
+interface TOSAnalysis {
+    metrics: ReadabilityMetrics;
+    overallScore: number;
+    readabilityLevel: 'excellent' | 'good' | 'fair' | 'poor' | 'very poor';
+    estimatedReadingTimeMinutes: number;
+    problematicSections: ProblematicSection[];
+    recommendations: string[];
+    summary: string;
+}
+/**
+ * ToS Readability Tool
+ * Analyzes Terms of Service for readability, complexity, and consumer-friendliness
+ */
+declare const tosReadabilityTool: ai.Tool<TOSReadabilityInput, TOSAnalysis>;
+
+export { type ProblematicSection, type ReadabilityMetrics, type TOSAnalysis, tosReadabilityTool as default, tosReadabilityTool };

package/dist/index.js

@@ -0,0 +1,200 @@
+import { tool, jsonSchema } from 'ai';
+
+// src/index.ts
+function calculateFleschReadingEase(totalSentences, totalWords, totalSyllables) {
+  if (totalSentences === 0 || totalWords === 0) return 0;
+  const avgSentenceLength = totalWords / totalSentences;
+  const avgSyllablesPerWord = totalSyllables / totalWords;
+  return 206.835 - 1.015 * avgSentenceLength - 84.6 * avgSyllablesPerWord;
+}
+function calculateFleschKincaidGrade(totalSentences, totalWords, totalSyllables) {
+  if (totalSentences === 0 || totalWords === 0) return 0;
+  const avgSentenceLength = totalWords / totalSentences;
+  const avgSyllablesPerWord = totalSyllables / totalWords;
+  return 0.39 * avgSentenceLength + 11.8 * avgSyllablesPerWord - 15.59;
+}
+function countSyllables(word) {
+  word = word.toLowerCase().trim();
+  if (word.length <= 3) return 1;
+  word = word.replace(/(?:[^laeiouy]es|ed|[^laeiouy]e)$/, "");
+  word = word.replace(/^y/, "");
+  const matches = word.match(/[aeiouy]{1,2}/g);
+  return matches ? matches.length : 1;
+}
+function isComplexWord(word) {
+  return countSyllables(word) >= 3;
+}
+function identifyProblematicSections(text) {
+  const sections = [];
+  const sentences = text.match(/[^.!?]+[.!?]+/g) || [];
+  sentences.forEach((sentence) => {
+    const words = sentence.trim().split(/\s+/).filter((w) => w.length > 0);
+    if (words.length > 40) {
+      sections.push({
+        text: sentence.trim().substring(0, 200) + (sentence.length > 200 ? "..." : ""),
+        issue: "Excessively long sentence",
+        severity: "high",
+        suggestion: "Break this sentence into multiple shorter sentences for better clarity"
+      });
+    }
+  });
+  const problematicPatterns = [
+    {
+      pattern: /\b(notwithstanding|aforementioned|hereinafter|thereof|wherein)\b/gi,
+      issue: "Legal jargon",
+      severity: "medium",
+      suggestion: "Replace legal jargon with plain language"
+    },
+    {
+      pattern: /\b(may|might|could)\s+(?:be\s+)?(?:deemed|considered|interpreted)/gi,
+      issue: "Vague or ambiguous language",
+      severity: "high",
+      suggestion: "Use clear, definitive language instead of vague terms"
+    },
+    {
+      pattern: /\b(?:we|company)\s+(?:reserve|retain)\s+the\s+right\s+to\s+(?:change|modify|alter)/gi,
+      issue: "Unilateral modification clause",
+      severity: "high",
+      suggestion: "Specify conditions and notice requirements for changes"
+    },
+    {
+      pattern: /\b(?:you\s+agree\s+to\s+waive|waiver\s+of)/gi,
+      issue: "Rights waiver",
+      severity: "high",
+      suggestion: "Clearly explain what rights are being waived and why"
+    }
+  ];
+  problematicPatterns.forEach(({ pattern, issue, severity, suggestion }) => {
+    const matches = text.match(pattern);
+    if (matches) {
+      const context = text.substring(
+        Math.max(0, text.indexOf(matches[0]) - 50),
+        Math.min(text.length, text.indexOf(matches[0]) + 150)
+      );
+      sections.push({
+        text: context,
+        issue,
+        severity,
+        suggestion
+      });
+    }
+  });
+  return sections.slice(0, 10);
+}
+function analyzeToS(tosText) {
+  if (!tosText || tosText.trim().length === 0) {
+    throw new Error("ToS text cannot be empty");
+  }
+  const cleanText = tosText.replace(/\s+/g, " ").trim();
+  const sentences = cleanText.match(/[^.!?]+[.!?]+/g) || [cleanText];
+  const totalSentences = sentences.length;
+  const words = cleanText.split(/\s+/).filter((w) => w.length > 0);
+  const totalWords = words.length;
+  let totalSyllables = 0;
+  let complexWords = 0;
+  words.forEach((word) => {
+    const syllableCount = countSyllables(word);
+    totalSyllables += syllableCount;
+    if (isComplexWord(word)) {
+      complexWords++;
+    }
+  });
+  const fleschReadingEase = calculateFleschReadingEase(totalSentences, totalWords, totalSyllables);
+  const fleschKincaidGrade = calculateFleschKincaidGrade(
+    totalSentences,
+    totalWords,
+    totalSyllables
+  );
+  const averageSentenceLength = totalWords / totalSentences;
+  const averageWordLength = words.reduce((sum, word) => sum + word.length, 0) / totalWords;
+  const complexWordPercentage = complexWords / totalWords * 100;
+  let readabilityLevel;
+  if (fleschReadingEase >= 70) readabilityLevel = "excellent";
+  else if (fleschReadingEase >= 60) readabilityLevel = "good";
+  else if (fleschReadingEase >= 50) readabilityLevel = "fair";
+  else if (fleschReadingEase >= 30) readabilityLevel = "poor";
+  else readabilityLevel = "very poor";
+  const overallScore = Math.max(
+    0,
+    Math.min(100, (fleschReadingEase + (100 - fleschKincaidGrade * 5)) / 2)
+  );
+  const estimatedReadingTimeMinutes = Math.ceil(totalWords / 200);
+  const problematicSections = identifyProblematicSections(cleanText);
+  const recommendations = [];
+  if (fleschKincaidGrade > 12) {
+    recommendations.push(
+      "Simplify language to reduce the required reading grade level (currently college-level)"
+    );
+  }
+  if (averageSentenceLength > 25) {
+    recommendations.push(
+      "Reduce sentence length for better readability (current average: " + Math.round(averageSentenceLength) + " words)"
+    );
+  }
+  if (complexWordPercentage > 20) {
+    recommendations.push(
+      "Reduce use of complex words (currently " + complexWordPercentage.toFixed(1) + "% of text)"
+    );
+  }
+  if (problematicSections.length > 0) {
+    recommendations.push(
+      "Address " + problematicSections.length + " identified problematic sections"
+    );
+  }
+  if (totalWords > 5e3) {
+    recommendations.push(
+      "Consider condensing the document (currently " + totalWords + " words, " + estimatedReadingTimeMinutes + " min read)"
+    );
+  }
+  if (recommendations.length === 0) {
+    recommendations.push("ToS is generally well-written and consumer-friendly");
+  }
+  const summary = `This Terms of Service document has a Flesch Reading Ease score of ${fleschReadingEase.toFixed(1)} (${readabilityLevel}) and requires a ${fleschKincaidGrade.toFixed(1)} grade reading level. The document contains ${totalWords} words with an estimated reading time of ${estimatedReadingTimeMinutes} minutes. ${problematicSections.length} potentially problematic sections were identified.`;
+  return {
+    metrics: {
+      fleschReadingEase: Math.round(fleschReadingEase * 10) / 10,
+      fleschKincaidGrade: Math.round(fleschKincaidGrade * 10) / 10,
+      averageSentenceLength: Math.round(averageSentenceLength * 10) / 10,
+      averageWordLength: Math.round(averageWordLength * 10) / 10,
+      complexWordPercentage: Math.round(complexWordPercentage * 10) / 10
+    },
+    overallScore: Math.round(overallScore),
+    readabilityLevel,
+    estimatedReadingTimeMinutes,
+    problematicSections,
+    recommendations,
+    summary
+  };
+}
+var tosReadabilityTool = tool({
+  description: "Analyzes Terms of Service documents for readability, complexity, and consumer-friendliness. Calculates Flesch Reading Ease score, Flesch-Kincaid Grade Level, and other readability metrics. Identifies problematic sections such as legal jargon, vague language, unilateral modification clauses, and rights waivers. Returns detailed analysis with recommendations for improving clarity and accessibility.",
+  inputSchema: jsonSchema({
+    type: "object",
+    properties: {
+      tosText: {
+        type: "string",
+        description: "The full Terms of Service text to analyze"
+      }
+    },
+    required: ["tosText"],
+    additionalProperties: false
+  }),
+  execute: async ({ tosText }) => {
+    if (typeof tosText !== "string") {
+      throw new Error("ToS text must be a string");
+    }
+    if (tosText.trim().length === 0) {
+      throw new Error("ToS text cannot be empty");
+    }
+    try {
+      return analyzeToS(tosText);
+    } catch (error) {
+      throw new Error(
+        `Failed to analyze ToS readability: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+});
+var index_default = tosReadabilityTool;
+
+export { index_default as default, tosReadabilityTool };

package/package.json

@@ -0,0 +1,70 @@
+{
+  "name": "@tpmjs/official-tos-readability",
+  "version": "0.1.0",
+  "description": "Analyzes Terms of Service for readability, complexity, and consumer-friendliness",
+  "type": "module",
+  "keywords": [
+    "tpmjs",
+    "legal",
+    "tos",
+    "readability",
+    "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/tos-readability"
+  },
+  "homepage": "https://tpmjs.com",
+  "license": "MIT",
+  "tpmjs": {
+    "category": "legal",
+    "frameworks": [
+      "vercel-ai"
+    ],
+    "tools": [
+      {
+        "name": "tosReadabilityTool",
+        "description": "Analyzes Terms of Service for readability, complexity, and consumer-friendliness",
+        "parameters": [
+          {
+            "name": "tosText",
+            "type": "string",
+            "description": "Terms of Service text",
+            "required": true
+          }
+        ],
+        "returns": {
+          "type": "TOSAnalysis",
+          "description": "Readability analysis with scores and recommendations"
+        }
+      }
+    ]
+  },
+  "dependencies": {
+    "ai": "6.0.0-beta.124"
+  },
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsup --watch",
+    "type-check": "tsc --noEmit",
+    "clean": "rm -rf dist .turbo"
+  }
+}