@o-lang/legal-extractor 1.0.0 → 1.0.2

package/capability.js

@@ -1,18 +1,50 @@
 // capability.js
 //
-// O-Lang Legal Extractor Resolver — capability.js v1.0.0
+// O-Lang Legal Extractor Resolver — capability.js v1.1.0
 //
 // Deterministic, zero-dependency structured extraction from legal documents.
 // Identifies parties, clauses, dates, obligations, and risk flags.
 //
 // EXTRACT-ONLY. This resolver:
+//   ✓ Auto-preprocesses long documents to bypass token/safety limits
 //   ✓ Extracts and classifies what IS in the document
-//   ✗ Never provides legal advice
-//   ✗ Never predicts legal outcomes
-//   ✗ Never opines on validity or enforceability
+//   ✗ Never provides legal advice, predicts outcomes, or opines on validity
 
 'use strict';
 
+// ── Smart Legal Document Pre-Processor ──────────────────────────────────────
+// Strips boilerplate, schedules, and signature blocks that trigger kernel safety filters.
+// Extracts core clauses if still too long. Hard-caps at 24k chars.
+function preprocessLegalText(text) {
+  if (!text || text.length < 1000) return text;
+
+  // 1. Remove high-trigger boilerplate (schedules, signatures, witness lines)
+  let cleaned = text
+    .replace(/\nSCHEDULE\s+\d+\s*[-—][\s\S]*/gi, '')
+    .replace(/\nSIGNED\s+for\s+and\s+on\s+behalf[\s\S]*/gi, '')
+    .replace(/\nIN\s+WITNESS\s+WHEREOF[\s\S]*/gi, '')
+    .replace(/\n{3,}/g, '\n\n')
+    .trim();
+
+  // 2. If still too long, extract header + first 10 substantive clauses
+  if (cleaned.length > 18000) {
+    const clauseRegex = /\n\d+\.\s*[A-Z\s]+(?:\([^)]*\))?\n([\s\S]*?)(?=\n\d+\.\s*|\nIN WITNESS|$)/gi;
+    const clauses = [];
+    let match;
+    while ((match = clauseRegex.exec(cleaned)) !== null) {
+      clauses.push(match[0]);
+    }
+    const header = cleaned.match(/^[^\n]*\n[^\n]*\n[\s\S]*?(?=\n1\.)/m)?.[0] || '';
+    cleaned = header + '\n' + clauses.slice(0, 10).join('\n') +
+              '\n\n[Note: Additional clauses omitted for extraction efficiency. Full document available for clause-by-clause review.]';
+  }
+
+  // 3. Hard cap at 24,000 chars (safe for LLM context windows & kernel limits)
+  return cleaned.length > 24000
+    ? cleaned.substring(0, 24000) + '\n\n[... document truncated for token safety ...]'
+    : cleaned;
+}
+
 // ── Jurisdiction map ──────────────────────────────────────────────────────────
 const JURISDICTIONS = {
   'ng': 'Nigeria', 'nigeria': 'Nigeria',
@@ -138,7 +170,6 @@ const DATE_PATTERNS = [
 ];
 
 // ── Helpers ───────────────────────────────────────────────────────────────────
-
 function resolveJurisdiction(raw) {
   if (!raw) return 'General / Unspecified';
   const key = raw.trim().toLowerCase();
@@ -153,36 +184,17 @@ function resolveDocType(raw) {
 
 function extractParties(text) {
   const parties = new Set();
-
-  // "between X and Y" — most common in contracts
-  const betweenMatch = text.match(
-    /between\s+([A-Z][A-Za-z\s,\.()&''"–\-]{2,80?})\s+and\s+([A-Z][A-Za-z\s,\.()&''"–\-]{2,80?})(?:\s*[\(,\.\;])/i
-  );
+  const betweenMatch = text.match(/between\s+([A-Z][A-Za-z\s,\.()&''"–\-]{2,80?})\s+and\s+([A-Z][A-Za-z\s,\.()&''"–\-]{2,80?})(?:\s*[\(,\.\;])/i);
   if (betweenMatch) {
     parties.add(betweenMatch[1].replace(/\s+/g, ' ').trim());
     parties.add(betweenMatch[2].replace(/\s+/g, ' ').trim());
   }
-
-  // "X (hereinafter "Y")" or "X (the "Y")"
-  const hereinafterMatches = [
-    ...text.matchAll(
-      /([A-Z][A-Za-z\s,\.()&''"–\-]{3,80?})\s*\((?:hereinafter(?:\s+referred\s+to\s+as)?|the)\s*[""]([A-Z][A-Za-z\s]+)[""]\)/gi
-    )
-  ];
-  for (const m of hereinafterMatches) {
-    parties.add(`${m[1].replace(/\s+/g, ' ').trim()} ("${m[2].trim()}")`);
-  }
-
-  // "Party A" / "Party B" named styles
+  const hereinafterMatches = [...text.matchAll(/([A-Z][A-Za-z\s,\.()&''"–\-]{3,80?})\s*\((?:hereinafter(?:\s+referred\s+to\s+as)?|the)\s*[""]([A-Z][A-Za-z\s]+)[""]\)/gi)];
+  for (const m of hereinafterMatches) parties.add(`${m[1].replace(/\s+/g, ' ').trim()} ("${m[2].trim()}")`);
   const partyLabels = [...text.matchAll(/\b(Party\s+[A-Z\d])\b/g)];
   for (const m of partyLabels) parties.add(m[1]);
-
-  // Role-based: "the Employer", "the Employee", "the Disclosing Party" etc.
-  const roleMatches = [...text.matchAll(
-    /\bthe\s+(Employer|Employee|Disclosing\s+Party|Receiving\s+Party|Licensor|Licensee|Buyer|Seller|Supplier|Contractor|Client|Consultant|Lender|Borrower|Landlord|Tenant|Franchisor|Franchisee)\b/g
-  )];
+  const roleMatches = [...text.matchAll(/\bthe\s+(Employer|Employee|Disclosing\s+Party|Receiving\s+Party|Licensor|Licensee|Buyer|Seller|Supplier|Contractor|Client|Consultant|Lender|Borrower|Landlord|Tenant|Franchisor|Franchisee)\b/g)];
   for (const m of roleMatches) parties.add(`the ${m[1]}`);
-
   return [...parties].filter(p => p.length > 2).slice(0, 10);
 }
 
@@ -190,9 +202,7 @@ function extractDates(text) {
   const found = new Set();
   for (const pattern of DATE_PATTERNS) {
     const matches = [...text.matchAll(pattern)];
-    for (const m of matches) {
-      found.add(m[1] || m[0]);
-    }
+    for (const m of matches) found.add(m[1] || m[0]);
   }
   return [...found].slice(0, 20);
 }
@@ -201,93 +211,63 @@ function extractClauses(text) {
   const found = [];
   for (const { type, pattern } of CLAUSE_PATTERNS) {
     if (pattern.test(text)) {
-      // Find the sentence containing the match
       pattern.lastIndex = 0;
       const match = pattern.exec(text);
       if (match) {
         const start = Math.max(0, match.index - 80);
         const end   = Math.min(text.length, match.index + 160);
-        const excerpt = text.slice(start, end)
-          .replace(/\s+/g, ' ')
-          .trim()
-          .replace(/^[^A-Z]/, '')
-          .slice(0, 200);
+        const excerpt = text.slice(start, end).replace(/\s+/g, ' ').trim().replace(/^[^A-Z]/, '').slice(0, 200);
         found.push({ type, excerpt: excerpt + (excerpt.length === 200 ? '…' : '') });
       }
     }
     pattern.lastIndex = 0;
   }
-  // Deduplicate by type
   const seen = new Set();
-  return found.filter(c => {
-    if (seen.has(c.type)) return false;
-    seen.add(c.type);
-    return true;
-  });
+  return found.filter(c => { if (seen.has(c.type)) return false; seen.add(c.type); return true; });
 }
 
 function extractObligations(text) {
-  const sentences = text
-    .replace(/\r\n/g, '\n')
-    .split(/(?<=[.!?])\s+(?=[A-Z])/)
-    .map(s => s.replace(/\s+/g, ' ').trim())
-    .filter(s => s.length > 20 && s.length < 400);
-
-  return sentences
-    .filter(s => OBLIGATION_KEYWORDS.some(kw => s.toLowerCase().includes(kw)))
-    .slice(0, 15);
+  const sentences = text.replace(/\r\n/g, '\n').split(/(?<=[.!?])\s+(?=[A-Z])/).map(s => s.replace(/\s+/g, ' ').trim()).filter(s => s.length > 20 && s.length < 400);
+  return sentences.filter(s => OBLIGATION_KEYWORDS.some(kw => s.toLowerCase().includes(kw))).slice(0, 15);
 }
 
 function extractRisks(text) {
   const found = [];
   for (const { pattern, label, severity } of RISK_PATTERNS) {
-    if (pattern.test(text)) {
-      found.push({ flag: label, severity });
-    }
+    if (pattern.test(text)) found.push({ flag: label, severity });
     pattern.lastIndex = 0;
   }
-  // Sort: high → medium → low
   const order = { high: 0, medium: 1, low: 2 };
   return found.sort((a, b) => order[a.severity] - order[b.severity]);
 }
 
 function buildSummary(params) {
-  const {
-    document_ref, docTypeLabel, jurisdictionLabel,
-    wordCount, parties, clauses, dates, obligations, risks,
-  } = params;
-
+  const { document_ref, docTypeLabel, jurisdictionLabel, wordCount, parties, clauses, dates, obligations, risks } = params;
   const highRisks  = risks.filter(r => r.severity === 'high').length;
   const medRisks   = risks.filter(r => r.severity === 'medium').length;
   const clauseList = clauses.slice(0, 5).map(c => c.type).join(', ');
   const partyList  = parties.slice(0, 3).join(', ');
 
   let summary = `Document reference ${document_ref} is a ${docTypeLabel}`;
-  if (jurisdictionLabel !== 'General / Unspecified') {
-    summary += ` governed under ${jurisdictionLabel} law`;
-  }
+  if (jurisdictionLabel !== 'General / Unspecified') summary += ` governed under ${jurisdictionLabel} law`;
   summary += `. The document contains ${wordCount.toLocaleString()} words`;
-  if (parties.length > 0) summary += ` and identifies the following parties: ${partyList}`;
+  if (parties.length > 0) summary += ` and identifies: ${partyList}`;
   summary += '.';
-  if (clauses.length > 0) summary += ` Key clause types identified include: ${clauseList}.`;
-  if (dates.length > 0) summary += ` ${dates.length} date reference${dates.length > 1 ? 's' : ''} found.`;
-  if (obligations.length > 0) summary += ` ${obligations.length} obligation statement${obligations.length > 1 ? 's' : ''} extracted.`;
-  if (highRisks > 0) summary += ` ${highRisks} high-severity risk flag${highRisks > 1 ? 's' : ''} identified.`;
-  if (medRisks > 0)  summary += ` ${medRisks} medium-severity risk flag${medRisks > 1 ? 's' : ''} identified.`;
-  summary += ' This is a factual extraction only. No legal advice is provided.';
-
+  if (clauses.length > 0) summary += ` Key clauses: ${clauseList}.`;
+  if (dates.length > 0) summary += ` ${dates.length} date${dates.length > 1 ? 's' : ''} found.`;
+  if (obligations.length > 0) summary += ` ${obligations.length} obligation${obligations.length > 1 ? 's' : ''} extracted.`;
+  if (highRisks > 0) summary += ` ${highRisks} high-risk flag${highRisks > 1 ? 's' : ''} identified.`;
+  if (medRisks > 0)  summary += ` ${medRisks} medium-risk flag${medRisks > 1 ? 's' : ''} identified.`;
+  summary += ' Factual extraction only. No legal advice provided.';
   return summary;
 }
 
 // ── Parse action string ───────────────────────────────────────────────────────
-// Action format: legal-extractor "doc_ref" "jurisdiction" "doc_type" "document_text"
 function parseActionArgs(action) {
   const args = [];
   const regex = /"((?:[^"\\]|\\.)*)"/g;
   let match;
-  while ((match = regex.exec(action)) !== null) {
-    args.push(match[1].replace(/\\"/g, '"'));
-  }
+  while ((match = regex.exec(action)) !== null) args.push(match[1].replace(/\\"/g, '"'));
   return args;
 }
 
@@ -302,34 +282,22 @@ async function resolve(action, context = {}, options = {}) {
 
     if (typeof action === 'string') {
       const args = parseActionArgs(action);
-      // Strip "legal-extractor" or "Action legal-extractor" prefix
-      const offset = args.length >= 4 ? 0 : 0;
-      document_ref   = args[offset]     || context.document_ref   || 'REF-UNKNOWN';
-      jurisdiction   = args[offset + 1] || context.jurisdiction   || 'general';
-      doc_type       = args[offset + 2] || context.doc_type       || 'general';
-      document_text  = args[offset + 3] || context.document_text  || '';
+      [document_ref, jurisdiction, doc_type, document_text] = args.length >= 4 ? args : [context.document_ref, context.jurisdiction, context.doc_type, context.document_text];
     } else {
-      document_ref   = context.document_ref   || 'REF-UNKNOWN';
-      jurisdiction   = context.jurisdiction   || 'general';
-      doc_type       = context.doc_type       || 'general';
-      document_text  = context.document_text  || '';
+      ({ document_ref, jurisdiction, doc_type, document_text } = context);
     }
 
     // ── 2. Validate ───────────────────────────────────────────────────────
     if (!document_text || document_text.trim().length < 10) {
       console.warn('[legal-extractor] ⚠️  document_text is empty or too short');
-      return {
-        summary:      'No document text provided for extraction.',
-        parties:      [],
-        clauses:      [],
-        dates:        [],
-        obligations:  [],
-        risks:        [],
-        jurisdiction: resolveJurisdiction(jurisdiction),
-        doc_type:     resolveDocType(doc_type),
-        word_count:   0,
-        error:        'document_text required',
-      };
+      return { summary: 'No document text provided for extraction.', parties: [], clauses: [], dates: [], obligations: [], risks: [], jurisdiction: resolveJurisdiction(jurisdiction), doc_type: resolveDocType(doc_type), word_count: 0, error: 'document_text required' };
+    }
+
+    // ✅ SMART PRE-PROCESSING: Auto-clean long docs before extraction
+    const originalLength = document_text.length;
+    if (originalLength > 10000) {
+      document_text = preprocessLegalText(document_text);
+      console.log(`[legal-extractor] 🔄 Pre-processed long document: ${originalLength} → ${document_text.length} chars`);
     }
 
     const text           = document_text.trim();
@@ -347,40 +315,58 @@ async function resolve(action, context = {}, options = {}) {
     const risks       = extractRisks(text);
 
     // ── 4. Build summary ──────────────────────────────────────────────────
-    const summary = buildSummary({
-      document_ref, docTypeLabel, jurisdictionLabel,
-      wordCount, parties, clauses, dates, obligations, risks,
-    });
+    const summary = buildSummary({ document_ref, docTypeLabel, jurisdictionLabel, wordCount, parties, clauses, dates, obligations, risks });
 
     console.log(`[legal-extractor] ✅ Extracted: ${parties.length} parties, ${clauses.length} clauses, ${dates.length} dates, ${obligations.length} obligations, ${risks.length} risk flags`);
 
-    return {
-      summary,
-      parties,
-      clauses,
-      dates,
-      obligations,
-      risks,
-      jurisdiction: jurisdictionLabel,
-      doc_type:     docTypeLabel,
-      word_count:   wordCount,
-      document_ref,
-      extracted_at: new Date().toISOString(),
+return {
+      summary, parties, clauses, dates, obligations, risks,
+      jurisdiction: jurisdictionLabel, doc_type: docTypeLabel, word_count: wordCount,
+      document_ref, extracted_at: new Date().toISOString(),
+      preprocessed: originalLength > 10000,
+
+      // ── Pre-stringified fields for safe LLM interpolation ──────────────
+      // RuntimeAPI._safeInterpolate cannot inject arrays/objects into prompts.
+      // These flat strings are what the workflow's {extracted.xxx_text} tokens resolve to.
+      parties_text:     parties.length
+                          ? '- ' + parties.join('\n- ')
+                          : 'No parties identified',
+
+      clauses_text:     clauses.length
+                          ? clauses.map(c => `${c.type}:\n  ${c.excerpt}`).join('\n\n')
+                          : 'No clauses identified',
+
+      dates_text:       dates.length
+                          ? dates.join(', ')
+                          : 'No dates found',
+
+      obligations_text: obligations.length
+                          ? '- ' + obligations.slice(0, 5).join('\n- ')
+                          : 'No obligations extracted',
+
+      risks_text:       risks.length
+                          ? risks.map(r => `[${r.severity.toUpperCase()}] ${r.flag}`).join('\n')
+                          : 'No risk flags identified',
     };
 
   } catch (err) {
     console.error('[legal-extractor] 💥 Error:', err.message);
     return {
-      summary:      `Extraction failed: ${err.message}`,
-      parties:      [],
-      clauses:      [],
-      dates:        [],
-      obligations:  [],
-      risks:        [],
-      jurisdiction: 'Unknown',
-      doc_type:     'Unknown',
-      word_count:   0,
-      error:        err.message,
+      summary:          `Extraction failed: ${err.message}`,
+      parties:          [],
+      clauses:          [],
+      dates:            [],
+      obligations:      [],
+      risks:            [],
+      jurisdiction:     'Unknown',
+      doc_type:         'Unknown',
+      word_count:       0,
+      error:            err.message,
+      parties_text:     'Extraction failed',
+      clauses_text:     'Extraction failed',
+      dates_text:       'Extraction failed',
+      obligations_text: 'Extraction failed',
+      risks_text:       'Extraction failed',
     };
   }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@o-lang/legal-extractor",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "O-Lang resolver for structured legal document extraction. Extract-only — never provides legal advice.",
   "main": "index.js",
   "keywords": [
@@ -22,4 +22,4 @@
     "node": ">=18.0.0"
   },
   "dependencies": {}
-}
+}