Skip to content
SlashClone
DiscoverUse in ClaudeSubmit a link
Sign in
Made by@dealdesk

Contract redline summary

@dealdesk/contract-redline-summary

Compare two versions of a contract (or one redline with insert and delete markup) clause by clause. Lists every change sorted by risk topic (liability, indemnity, termination, renewal, IP, data, payment) with the numbers that moved, then explains each in plain English with a suggested response. Not legal advice.

SkillRevOpsv1.0.0 (latest)Tested
Use in Claude Save Like Clone Comment
Activity
New: be the first to try it
  1. 1#!/usr/bin/env node
  2. 2// contract-redline-summary: compare two versions of a contract clause by clause,
  3. 3// tag each change by risk topic, and pull out changed numbers (days, amounts,
  4. 4// percentages, months). Node 22, built-ins only. Not legal advice.
  5. 5//
  6. 6// Usage:
  7. 7// node scripts/clause-diff.mjs <original.txt> <revised.txt> [--out out] [--name redline]
  8. 8// node scripts/clause-diff.mjs --markup <redline.md> [--out out] [--name redline]
  9. 9// (markup: {++added++} {--removed--}, or [+added+] [-removed-])
  10. 10
  11. 11import { readFileSync, writeFileSync, mkdirSync } from "node:fs";
  12. 12import { join } from "node:path";
  13. 13
  14. 14function fail(msg) {
  15. 15 console.error(`contract-redline-summary: ${msg}`);
  16. 16 process.exit(1);
  17. 17}
  18. 18
  19. 19const args = process.argv.slice(2);
  20. 20const opts = { out: "out", name: "redline", markup: null };
  21. 21const pos = [];
  22. 22for (let i = 0; i < args.length; i++) {
  23. 23 if (args[i] === "--out") opts.out = args[++i];
  24. 24 else if (args[i] === "--name") opts.name = args[++i];
  25. 25 else if (args[i] === "--markup") opts.markup = args[++i];
  26. 26 else if (args[i] === "--help" || args[i] === "-h") {
  27. 27 console.log("Usage: node scripts/clause-diff.mjs <original.txt> <revised.txt> [--out out] [--name redline]\n node scripts/clause-diff.mjs --markup <redline.md> [--out out]");
  28. 28 process.exit(0);
  29. 29 } else pos.push(args[i]);
  30. 30}
  31. 31const read = (p) => {
  32. 32 try {
  33. 33 return readFileSync(p, "utf8").replace(/\r\n?/g, "\n");
  34. 34 } catch {
  35. 35 fail(`cannot read ${p}`);
  36. 36 }
  37. 37};
  38. 38
  39. 39let oldText;
  40. 40let newText;
  41. 41if (opts.markup) {
  42. 42 const t = read(opts.markup);
  43. 43 const ins = /\{\+\+([\s\S]*?)\+\+\}|\[\+([\s\S]*?)\+\]/g;
  44. 44 const del = /\{--([\s\S]*?)--\}|\[-([\s\S]*?)-\]/g;
  45. 45 oldText = t.replace(ins, "").replace(del, (_, a, b) => a ?? b);
  46. 46 newText = t.replace(del, "").replace(ins, (_, a, b) => a ?? b);
  47. 47 if (oldText === newText) fail("no {++added++} or {--removed--} markup found in the redline file");
  48. 48} else {
  49. 49 if (pos.length !== 2) fail("give the original and the revised file, or --markup <file>. Try --help.");
  50. 50 oldText = read(pos[0]);
  51. 51 newText = read(pos[1]);
  52. 52}
  53. 53
  54. 54// ---------- split into clauses ----------
  55. 55const HEADING = /^\s*(?:#{1,6}\s*)?(?:(?:section|article|clause)\s+)?(\d+(?:\.\d+)*)[.)]?\s+(\S.*)$/i;
  56. 56function clauses(text) {
  57. 57 const lines = text.split("\n");
  58. 58 const numbered = lines.filter((l) => HEADING.test(l)).length;
  59. 59 const out = [];
  60. 60 if (numbered >= 2) {
  61. 61 let cur = null;
  62. 62 for (const line of lines) {
  63. 63 const m = line.match(HEADING);
  64. 64 if (m) {
  65. 65 if (cur) out.push(cur);
  66. 66 cur = { key: m[1], title: m[2].trim(), body: [line] };
  67. 67 } else if (cur) cur.body.push(line);
  68. 68 else if (line.trim()) {
  69. 69 cur = { key: "preamble", title: "Preamble", body: [line] };
  70. 70 }
  71. 71 }
  72. 72 if (cur) out.push(cur);
  73. 73 } else {
  74. 74 text
  75. 75 .split(/\n\s*\n/)
  76. 76 .map((p) => p.trim())
  77. 77 .filter(Boolean)
  78. 78 .forEach((p, i) => out.push({ key: `para-${i + 1}`, title: p.split(/\s+/).slice(0, 8).join(" "), body: [p] }));
  79. 79 }
  80. 80 return out.map((c, i) => {
  81. 81 const text = c.body.join("\n").trim();
  82. 82 return { ...c, index: i, text, norm: text.replace(/\s+/g, " ").trim() };
  83. 83 });
  84. 84}
  85. 85const A = clauses(oldText);
  86. 86const B = clauses(newText);
  87. 87
  88. 88// ---------- align ----------
  89. 89const words = (s) => new Set(s.toLowerCase().match(/[a-z0-9]+/g) || []);
  90. 90function jaccard(a, b) {
  91. 91 const x = words(a);
  92. 92 const y = words(b);
  93. 93 let inter = 0;
  94. 94 for (const w of x) if (y.has(w)) inter++;
  95. 95 return inter / (x.size + y.size - inter || 1);
  96. 96}
  97. 97const pairs = [];
  98. 98const usedB = new Set();
  99. 99const usedA = new Set();
  100. 100const numberedMode = A.some((c) => /^\d/.test(c.key)) && B.some((c) => /^\d/.test(c.key));
  101. 101// 1. identical text anywhere
  102. 102for (const a of A) {
  103. 103 const b = B.find((x) => !usedB.has(x.index) && x.norm === a.norm);
  104. 104 if (b) {
  105. 105 pairs.push({ a, b });
  106. 106 usedA.add(a.index);
  107. 107 usedB.add(b.index);
  108. 108 }
  109. 109}
  110. 110// 2. same clause number with similar text (numbered contracts)
  111. 111if (numberedMode)
  112. 112 for (const a of A) {
  113. 113 if (usedA.has(a.index)) continue;
  114. 114 const sameTitle = (x) => x.title.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim() === a.title.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
  115. 115 const b = B.find((x) => !usedB.has(x.index) && x.key === a.key && (sameTitle(x) || jaccard(a.norm, x.norm) >= 0.3));
  116. 116 if (b) {
  117. 117 pairs.push({ a, b });
  118. 118 usedA.add(a.index);
  119. 119 usedB.add(b.index);
  120. 120 }
  121. 121 }
  122. 122// 3. best similar text
  123. 123for (const a of A) {
  124. 124 if (usedA.has(a.index)) continue;
  125. 125 let best = null;
  126. 126 let score = 0.5;
  127. 127 for (const b of B) {
  128. 128 if (usedB.has(b.index)) continue;
  129. 129 const s = jaccard(a.norm, b.norm);
  130. 130 if (s > score) {
  131. 131 score = s;
  132. 132 best = b;
  133. 133 }
  134. 134 }
  135. 135 if (best) {
  136. 136 pairs.push({ a, b: best });
  137. 137 usedA.add(a.index);
  138. 138 usedB.add(best.index);
  139. 139 }
  140. 140}
  141. 141
  142. 142// ---------- word diff ----------
  143. 143const tokens = (s) => s.match(/[$€£]?\d[\d,.]*%?|[A-Za-z]+(?:['-][A-Za-z]+)*|[^\sA-Za-z0-9]/g) || [];
  144. 144const meaningful = (snip) => /[A-Za-z0-9]/.test(snip);
  145. 145function diff(a, b) {
  146. 146 const x = tokens(a);
  147. 147 const y = tokens(b);
  148. 148 if (x.length * y.length > 4e6) return { added: [b], removed: [a] };
  149. 149 const dp = Array.from({ length: x.length + 1 }, () => new Uint32Array(y.length + 1));
  150. 150 for (let i = x.length - 1; i >= 0; i--)
  151. 151 for (let j = y.length - 1; j >= 0; j--) dp[i][j] = x[i] === y[j] ? dp[i + 1][j + 1] + 1 : Math.max(dp[i + 1][j], dp[i][j + 1]);
  152. 152 const added = [];
  153. 153 const removed = [];
  154. 154 let i = 0;
  155. 155 let j = 0;
  156. 156 let curA = [];
  157. 157 let curR = [];
  158. 158 const flush = () => {
  159. 159 const join = (t) => t.join(" ").replace(/\s+([.,;:!?)%])/g, "$1").replace(/([($])\s+/g, "$1");
  160. 160 if (curA.length) added.push(join(curA));
  161. 161 if (curR.length) removed.push(join(curR));
  162. 162 curA = [];
  163. 163 curR = [];
  164. 164 };
  165. 165 while (i < x.length || j < y.length) {
  166. 166 if (i < x.length && j < y.length && x[i] === y[j]) {
  167. 167 flush();
  168. 168 i++;
  169. 169 j++;
  170. 170 } else if (j < y.length && (i >= x.length || dp[i][j + 1] >= dp[i + 1][j])) curA.push(y[j++]);
  171. 171 else curR.push(x[i++]);
  172. 172 }
  173. 173 flush();
  174. 174 return { added: added.filter(meaningful), removed: removed.filter(meaningful) };
  175. 175}
  176. 176
  177. 177// ---------- risk ----------
  178. 178const TOPICS = [
  179. 179 ["high", "limitation of liability", /limitation of liability|aggregate liability|liability (?:is |shall be |will be )?(?:capped|limited)|consequential|indirect damages|uncapped|unlimited liability/i],
  180. 180 ["high", "indemnification", /indemnif|hold harmless|defend\b/i],
  181. 181 ["high", "termination", /terminat/i],
  182. 182 ["high", "renewal", /renew/i],
  183. 183 ["high", "intellectual property", /intellectual property|ownership|work product|license grant|derivative/i],
  184. 184 ["high", "exclusivity or MFN", /exclusiv|most favou?red|non-compete|non-solicit/i],
  185. 185 ["high", "data protection and security", /personal data|data protection|security incident|breach notification|subprocessor|privacy/i],
  186. 186 ["high", "governing law and disputes", /governing law|jurisdiction|venue|arbitrat/i],
  187. 187 ["high", "assignment", /\bassign|change of control/i],
  188. 188 ["high", "audit rights", /\baudit/i],
  189. 189 ["medium", "payment terms", /payment|invoice|\bfees?\b|net \d+|late charge|interest/i],
  190. 190 ["medium", "price changes", /increase|uplift|\bcpi\b|price adjust/i],
  191. 191 ["medium", "service levels", /service level|uptime|availability|service credit/i],
  192. 192 ["medium", "warranty", /warrant/i],
  193. 193 ["medium", "confidentiality", /confidential/i],
  194. 194 ["medium", "insurance", /insurance/i],
  195. 195 ["medium", "notice", /\bnotice\b/i],
  196. 196 ["medium", "acceptance", /accept/i],
  197. 197];
  198. 198const RANK = { high: 0, medium: 1, low: 2 };
  199. 199const NUM = /(?:[$€£]\s?)?\d[\d,]*(?:\.\d+)?\s?(?:%|percent|days?|months?|years?|x|times)?/gi;
  200. 200function classify(changedText, context) {
  201. 201 const hits = TOPICS.filter(([, , re]) => re.test(changedText) || re.test(context));
  202. 202 const level = hits.length ? hits.reduce((lv, h) => (RANK[h[0]] < RANK[lv] ? h[0] : lv), "low") : "low";
  203. 203 return { level, topics: [...new Set(hits.map((h) => h[1]))] };
  204. 204}
  205. 205const stripHeading = (s) => s.replace(/^\s*(?:#{1,6}\s*)?(?:(?:section|article|clause)\s+)?\d+(?:\.\d+)*[.)]?\s+/i, "");
  206. 206const nums = (arr) => [...new Set(arr.join(" ").match(NUM) || [])].map((s) => s.trim()).filter((s) => /\d/.test(s));
  207. 207
  208. 208const changes = [];
  209. 209for (const { a, b } of pairs) {
  210. 210 if (a.norm === b.norm) {
  211. 211 if (numberedMode && a.key !== b.key)
  212. 212 changes.push({ type: "renumbered", clause: b.key, was: a.key, title: b.title, added: [], removed: [], numbers: { before: [], after: [] }, risk: "low", topics: [] });
  213. 213 continue;
  214. 214 }
  215. 215 const d = diff(a.norm, b.norm);
  216. 216 const c = classify([...d.added, ...d.removed].join(" "), b.title + " " + a.title);
  217. 217 const before = nums(d.removed);
  218. 218 const after = nums(d.added);
  219. 219 changes.push({ type: "changed", clause: b.key, was: a.key !== b.key ? a.key : undefined, title: b.title, added: d.added, removed: d.removed, numbers: { before, after }, risk: c.level, topics: c.topics, position: b.index });
  220. 220}
  221. 221for (const b of B)
  222. 222 if (!usedB.has(b.index)) {
  223. 223 const c = classify(b.norm, b.title);
  224. 224 changes.push({ type: "added", clause: b.key, title: b.title, added: [b.norm], removed: [], numbers: { before: [], after: nums([stripHeading(b.norm)]) }, risk: c.level === "low" ? "medium" : c.level, topics: c.topics, position: b.index });
  225. 225 }
  226. 226for (const a of A)
  227. 227 if (!usedA.has(a.index)) {
  228. 228 const c = classify(a.norm, a.title);
  229. 229 changes.push({ type: "removed", clause: a.key, title: a.title, added: [], removed: [a.norm], numbers: { before: nums([stripHeading(a.norm)]), after: [] }, risk: c.level === "low" ? "medium" : c.level, topics: c.topics, position: a.index });
  230. 230 }
  231. 231changes.sort((x, y) => RANK[x.risk] - RANK[y.risk] || (x.position ?? 0) - (y.position ?? 0));
  232. 232for (const c of changes) delete c.position;
  233. 233
  234. 234const count = (f) => changes.filter(f).length;
  235. 235const summary = {
  236. 236 clauses_original: A.length,
  237. 237 clauses_revised: B.length,
  238. 238 changed: count((c) => c.type === "changed"),
  239. 239 added: count((c) => c.type === "added"),
  240. 240 removed: count((c) => c.type === "removed"),
  241. 241 renumbered: count((c) => c.type === "renumbered"),
  242. 242 high: count((c) => c.risk === "high"),
  243. 243 medium: count((c) => c.risk === "medium"),
  244. 244 low: count((c) => c.risk === "low"),
  245. 245};
  246. 246
  247. 247const clip = (s, n = 240) => (s.length > n ? s.slice(0, n - 3) + "..." : s);
  248. 248const md = [`# Redline summary`, ""];
  249. 249md.push(`${summary.high} high, ${summary.medium} medium, ${summary.low} low risk changes. ${summary.changed} changed, ${summary.added} added, ${summary.removed} removed, ${summary.renumbered} renumbered.`, "");
  250. 250md.push("Risk tags come from keywords. They show where to look, not whether a change is good or bad. Not legal advice.", "");
  251. 251for (const level of ["high", "medium", "low"]) {
  252. 252 const list = changes.filter((c) => c.risk === level);
  253. 253 if (!list.length) continue;
  254. 254 md.push(`## ${level[0].toUpperCase() + level.slice(1)} risk`, "");
  255. 255 for (const c of list) {
  256. 256 md.push(`### ${c.clause} ${c.title} (${c.type}${c.was ? `, was ${c.was}` : ""})`, "");
  257. 257 if (c.topics.length) md.push(`Topics: ${c.topics.join(", ")}`, "");
  258. 258 if (c.numbers.before.length || c.numbers.after.length) md.push(`Numbers: ${c.numbers.before.join(", ") || "none"} -> ${c.numbers.after.join(", ") || "none"}`, "");
  259. 259 for (const r of c.removed) md.push(`- Removed: "${clip(r)}"`);
  260. 260 for (const ad of c.added) md.push(`- Added: "${clip(ad)}"`);
  261. 261 md.push("");
  262. 262 }
  263. 263}
  264. 264
  265. 265mkdirSync(opts.out, { recursive: true });
  266. 266writeFileSync(join(opts.out, `${opts.name}.json`), JSON.stringify({ summary, changes }, null, 2) + "\n");
  267. 267writeFileSync(join(opts.out, `${opts.name}.md`), md.join("\n"));
  268. 268console.log(`${changes.length} change(s): ${summary.high} high, ${summary.medium} medium, ${summary.low} low. Wrote ${join(opts.out, opts.name)}.{md,json}`);
Sign in to comment on a line