@semiont/api-client 0.2.28-build.37 → 0.2.28-build.40

package/dist/index.js

@@ -1138,23 +1138,6 @@ function getTargetSelector(target) {
 function hasTargetSelector(target) {
   return typeof target !== "string" && target.selector !== void 0;
 }
-function getEntityTypes(annotation) {
-  if (Array.isArray(annotation.body)) {
-    const entityTags = [];
-    for (const item of annotation.body) {
-      if (typeof item === "object" && item !== null && "type" in item && "value" in item && "purpose" in item) {
-        const itemType = item.type;
-        const itemValue = item.value;
-        const itemPurpose = item.purpose;
-        if (itemType === "TextualBody" && itemPurpose === "tagging" && typeof itemValue === "string" && itemValue.length > 0) {
-          entityTags.push(itemValue);
-        }
-      }
-    }
-    return entityTags;
-  }
-  return [];
-}
 function isHighlight(annotation) {
   return annotation.motivation === "highlighting";
 }
@@ -1178,24 +1161,6 @@ function getCommentText(annotation) {
   }
   return void 0;
 }
-function getTagCategory(annotation) {
-  if (!isTag(annotation)) return void 0;
-  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
-  const taggingBody = bodies.find((b) => b && "purpose" in b && b.purpose === "tagging");
-  if (taggingBody && "value" in taggingBody) {
-    return taggingBody.value;
-  }
-  return void 0;
-}
-function getTagSchemaId(annotation) {
-  if (!isTag(annotation)) return void 0;
-  const bodies = Array.isArray(annotation.body) ? annotation.body : [annotation.body];
-  const classifyingBody = bodies.find((b) => b && "purpose" in b && b.purpose === "classifying");
-  if (classifyingBody && "value" in classifyingBody) {
-    return classifyingBody.value;
-  }
-  return void 0;
-}
 function isStubReference(annotation) {
   return isReference(annotation) && !isBodyResolved(annotation.body);
 }
@@ -1537,6 +1502,60 @@ function getResourceCreationDetails(event) {
   return null;
 }
 
+// src/utils/fuzzy-anchor.ts
+function findTextWithContext(content, exact, prefix, suffix) {
+  if (!exact) return null;
+  const occurrences = [];
+  let index = content.indexOf(exact);
+  while (index !== -1) {
+    occurrences.push(index);
+    index = content.indexOf(exact, index + 1);
+  }
+  if (occurrences.length === 0) {
+    console.warn(`[FuzzyAnchor] Text not found: "${exact.substring(0, 50)}..."`);
+    return null;
+  }
+  if (occurrences.length === 1) {
+    const pos2 = occurrences[0];
+    return { start: pos2, end: pos2 + exact.length };
+  }
+  if (prefix || suffix) {
+    for (const pos2 of occurrences) {
+      const actualPrefixStart = Math.max(0, pos2 - (prefix?.length || 0));
+      const actualPrefix = content.substring(actualPrefixStart, pos2);
+      const actualSuffixEnd = Math.min(content.length, pos2 + exact.length + (suffix?.length || 0));
+      const actualSuffix = content.substring(pos2 + exact.length, actualSuffixEnd);
+      const prefixMatch = !prefix || actualPrefix.endsWith(prefix);
+      const suffixMatch = !suffix || actualSuffix.startsWith(suffix);
+      if (prefixMatch && suffixMatch) {
+        return { start: pos2, end: pos2 + exact.length };
+      }
+    }
+    console.warn(
+      `[FuzzyAnchor] Multiple matches found but none match prefix/suffix exactly. Exact: "${exact.substring(0, 30)}...", Prefix: "${prefix?.substring(0, 20) || "none"}", Suffix: "${suffix?.substring(0, 20) || "none"}"`
+    );
+    for (const pos2 of occurrences) {
+      const actualPrefix = content.substring(Math.max(0, pos2 - (prefix?.length || 0)), pos2);
+      const actualSuffix = content.substring(pos2 + exact.length, pos2 + exact.length + (suffix?.length || 0));
+      const fuzzyPrefixMatch = !prefix || actualPrefix.includes(prefix.trim());
+      const fuzzySuffixMatch = !suffix || actualSuffix.includes(suffix.trim());
+      if (fuzzyPrefixMatch && fuzzySuffixMatch) {
+        console.warn(`[FuzzyAnchor] Using fuzzy match at position ${pos2}`);
+        return { start: pos2, end: pos2 + exact.length };
+      }
+    }
+  }
+  console.warn(
+    `[FuzzyAnchor] Multiple matches but no context match. Using first occurrence. Exact: "${exact.substring(0, 30)}..."`
+  );
+  const pos = occurrences[0];
+  return { start: pos, end: pos + exact.length };
+}
+function verifyPosition(content, position, expectedExact) {
+  const actualText = content.substring(position.start, position.end);
+  return actualText === expectedExact;
+}
+
 // src/utils/locales.ts
 var LOCALES = [
   { code: "ar", nativeName: "\u0627\u0644\u0639\u0631\u0628\u064A\u0629", englishName: "Arabic" },
@@ -1617,6 +1636,330 @@ function getChecksum(resource) {
 function getLanguage(resource) {
   return getPrimaryRepresentation(resource)?.language;
 }
+function getStorageUri(resource) {
+  return getPrimaryRepresentation(resource)?.storageUri;
+}
+function getCreator(resource) {
+  if (!resource?.wasAttributedTo) return void 0;
+  return Array.isArray(resource.wasAttributedTo) ? resource.wasAttributedTo[0] : resource.wasAttributedTo;
+}
+function getDerivedFrom(resource) {
+  if (!resource?.wasDerivedFrom) return void 0;
+  return Array.isArray(resource.wasDerivedFrom) ? resource.wasDerivedFrom[0] : resource.wasDerivedFrom;
+}
+function isArchived(resource) {
+  return resource?.archived === true;
+}
+function getResourceEntityTypes(resource) {
+  return resource?.entityTypes || [];
+}
+function isDraft(resource) {
+  return resource?.isDraft === true;
+}
+function getNodeEncoding(charset) {
+  const normalized = charset.toLowerCase().replace(/[-_]/g, "");
+  const charsetMap = {
+    "utf8": "utf8",
+    "iso88591": "latin1",
+    "latin1": "latin1",
+    "ascii": "ascii",
+    "usascii": "ascii",
+    "utf16le": "utf16le",
+    "ucs2": "ucs2",
+    "binary": "binary",
+    "windows1252": "latin1",
+    // Windows-1252 is a superset of Latin-1
+    "cp1252": "latin1"
+  };
+  return charsetMap[normalized] || "utf8";
+}
+function decodeRepresentation(buffer, mediaType) {
+  const charsetMatch = mediaType.match(/charset=([^\s;]+)/i);
+  const charset = (charsetMatch?.[1] || "utf-8").toLowerCase();
+  const encoding = getNodeEncoding(charset);
+  return buffer.toString(encoding);
+}
+
+// src/utils/svg-utils.ts
+function createRectangleSvg(start, end) {
+  const x = Math.min(start.x, end.x);
+  const y = Math.min(start.y, end.y);
+  const width = Math.abs(end.x - start.x);
+  const height = Math.abs(end.y - start.y);
+  return `<svg xmlns="http://www.w3.org/2000/svg"><rect x="${x}" y="${y}" width="${width}" height="${height}"/></svg>`;
+}
+function createPolygonSvg(points) {
+  if (points.length < 3) {
+    throw new Error("Polygon requires at least 3 points");
+  }
+  const pointsStr = points.map((p) => `${p.x},${p.y}`).join(" ");
+  return `<svg xmlns="http://www.w3.org/2000/svg"><polygon points="${pointsStr}"/></svg>`;
+}
+function createCircleSvg(center, radius) {
+  if (radius <= 0) {
+    throw new Error("Circle radius must be positive");
+  }
+  return `<svg xmlns="http://www.w3.org/2000/svg"><circle cx="${center.x}" cy="${center.y}" r="${radius}"/></svg>`;
+}
+function parseSvgSelector(svg) {
+  const rectMatch = svg.match(/<rect\s+([^>]+)\/>/);
+  if (rectMatch && rectMatch[1]) {
+    const attrs = rectMatch[1];
+    const x = parseFloat(attrs.match(/x="([^"]+)"/)?.[1] || "0");
+    const y = parseFloat(attrs.match(/y="([^"]+)"/)?.[1] || "0");
+    const width = parseFloat(attrs.match(/width="([^"]+)"/)?.[1] || "0");
+    const height = parseFloat(attrs.match(/height="([^"]+)"/)?.[1] || "0");
+    return {
+      type: "rect",
+      data: { x, y, width, height }
+    };
+  }
+  const polygonMatch = svg.match(/<polygon\s+points="([^"]+)"/);
+  if (polygonMatch && polygonMatch[1]) {
+    const pointsStr = polygonMatch[1];
+    const points = pointsStr.split(/\s+/).map((pair) => {
+      const [x, y] = pair.split(",").map(parseFloat);
+      return { x, y };
+    });
+    return {
+      type: "polygon",
+      data: { points }
+    };
+  }
+  const circleMatch = svg.match(/<circle\s+([^>]+)\/>/);
+  if (circleMatch && circleMatch[1]) {
+    const attrs = circleMatch[1];
+    const cx = parseFloat(attrs.match(/cx="([^"]+)"/)?.[1] || "0");
+    const cy = parseFloat(attrs.match(/cy="([^"]+)"/)?.[1] || "0");
+    const r = parseFloat(attrs.match(/r="([^"]+)"/)?.[1] || "0");
+    return {
+      type: "circle",
+      data: { cx, cy, r }
+    };
+  }
+  return null;
+}
+function normalizeCoordinates(point, displayWidth, displayHeight, imageWidth, imageHeight) {
+  return {
+    x: point.x / displayWidth * imageWidth,
+    y: point.y / displayHeight * imageHeight
+  };
+}
+function scaleSvgToNative(svg, displayWidth, displayHeight, imageWidth, imageHeight) {
+  const parsed = parseSvgSelector(svg);
+  if (!parsed) return svg;
+  const scaleX = imageWidth / displayWidth;
+  const scaleY = imageHeight / displayHeight;
+  switch (parsed.type) {
+    case "rect": {
+      const { x, y, width, height } = parsed.data;
+      return createRectangleSvg(
+        { x: x * scaleX, y: y * scaleY },
+        { x: (x + width) * scaleX, y: (y + height) * scaleY }
+      );
+    }
+    case "circle": {
+      const { cx, cy, r } = parsed.data;
+      return createCircleSvg(
+        { x: cx * scaleX, y: cy * scaleY },
+        r * Math.min(scaleX, scaleY)
+      );
+    }
+    case "polygon": {
+      const points = parsed.data.points.map((p) => ({
+        x: p.x * scaleX,
+        y: p.y * scaleY
+      }));
+      return createPolygonSvg(points);
+    }
+  }
+  return svg;
+}
+
+// src/utils/text-context.ts
+function extractContext(content, start, end) {
+  const CONTEXT_LENGTH = 64;
+  const MAX_EXTENSION = 32;
+  let prefix;
+  if (start > 0) {
+    let prefixStart = Math.max(0, start - CONTEXT_LENGTH);
+    let extensionCount = 0;
+    while (prefixStart > 0 && extensionCount < MAX_EXTENSION) {
+      const char = content[prefixStart - 1];
+      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) {
+        break;
+      }
+      prefixStart--;
+      extensionCount++;
+    }
+    prefix = content.substring(prefixStart, start);
+  }
+  let suffix;
+  if (end < content.length) {
+    let suffixEnd = Math.min(content.length, end + CONTEXT_LENGTH);
+    let extensionCount = 0;
+    while (suffixEnd < content.length && extensionCount < MAX_EXTENSION) {
+      const char = content[suffixEnd];
+      if (!char || /[\s.,;:!?'"()\[\]{}<>\/\\]/.test(char)) {
+        break;
+      }
+      suffixEnd++;
+      extensionCount++;
+    }
+    suffix = content.substring(end, suffixEnd);
+  }
+  return { prefix, suffix };
+}
+function levenshteinDistance(str1, str2) {
+  const len1 = str1.length;
+  const len2 = str2.length;
+  const matrix = [];
+  for (let i = 0; i <= len1; i++) {
+    matrix[i] = [i];
+  }
+  for (let j = 0; j <= len2; j++) {
+    matrix[0][j] = j;
+  }
+  for (let i = 1; i <= len1; i++) {
+    for (let j = 1; j <= len2; j++) {
+      const cost = str1[i - 1] === str2[j - 1] ? 0 : 1;
+      const deletion = matrix[i - 1][j] + 1;
+      const insertion = matrix[i][j - 1] + 1;
+      const substitution = matrix[i - 1][j - 1] + cost;
+      matrix[i][j] = Math.min(deletion, insertion, substitution);
+    }
+  }
+  return matrix[len1][len2];
+}
+function findBestMatch(content, searchText, aiStart, aiEnd) {
+  const maxFuzzyDistance = Math.max(5, Math.floor(searchText.length * 0.05));
+  const exactIndex = content.indexOf(searchText);
+  if (exactIndex !== -1) {
+    return {
+      start: exactIndex,
+      end: exactIndex + searchText.length,
+      matchQuality: "exact"
+    };
+  }
+  console.log("[findBestMatch] Exact match failed, trying case-insensitive...");
+  const lowerContent = content.toLowerCase();
+  const lowerSearch = searchText.toLowerCase();
+  const caseInsensitiveIndex = lowerContent.indexOf(lowerSearch);
+  if (caseInsensitiveIndex !== -1) {
+    console.log("[findBestMatch] Found case-insensitive match");
+    return {
+      start: caseInsensitiveIndex,
+      end: caseInsensitiveIndex + searchText.length,
+      matchQuality: "case-insensitive"
+    };
+  }
+  console.log("[findBestMatch] Case-insensitive failed, trying fuzzy match...");
+  const windowSize = searchText.length;
+  const searchRadius = Math.min(500, content.length);
+  const searchStart = Math.max(0, aiStart - searchRadius);
+  const searchEnd = Math.min(content.length, aiEnd + searchRadius);
+  let bestMatch = null;
+  for (let i = searchStart; i <= searchEnd - windowSize; i++) {
+    const candidate = content.substring(i, i + windowSize);
+    const distance = levenshteinDistance(searchText, candidate);
+    if (distance <= maxFuzzyDistance) {
+      if (!bestMatch || distance < bestMatch.distance) {
+        bestMatch = { start: i, distance };
+        console.log(`[findBestMatch] Found fuzzy match at ${i} with distance ${distance}`);
+      }
+    }
+  }
+  if (bestMatch) {
+    return {
+      start: bestMatch.start,
+      end: bestMatch.start + windowSize,
+      matchQuality: "fuzzy"
+    };
+  }
+  console.log("[findBestMatch] No acceptable match found");
+  return null;
+}
+function validateAndCorrectOffsets(content, aiStart, aiEnd, exact) {
+  const exactPreview = exact.length > 50 ? exact.substring(0, 50) + "..." : exact;
+  const textAtOffset = content.substring(aiStart, aiEnd);
+  if (textAtOffset === exact) {
+    console.log(`[validateAndCorrectOffsets] \u2713 Offsets correct for: "${exactPreview}"`);
+    const context2 = extractContext(content, aiStart, aiEnd);
+    return {
+      start: aiStart,
+      end: aiEnd,
+      exact,
+      prefix: context2.prefix,
+      suffix: context2.suffix,
+      corrected: false,
+      matchQuality: "exact"
+    };
+  }
+  const foundPreview = textAtOffset.length > 50 ? textAtOffset.substring(0, 50) + "..." : textAtOffset;
+  console.warn(
+    `[validateAndCorrectOffsets] \u26A0 AI offset mismatch:
+  Expected text: "${exactPreview}"
+  Found at AI offset (${aiStart}-${aiEnd}): "${foundPreview}"
+  Attempting multi-strategy search...`
+  );
+  const match = findBestMatch(content, exact, aiStart, aiEnd);
+  if (!match) {
+    const exactLong = exact.length > 100 ? exact.substring(0, 100) + "..." : exact;
+    console.error(
+      `[validateAndCorrectOffsets] \u2717 No acceptable match found:
+  AI offsets: start=${aiStart}, end=${aiEnd}
+  AI text: "${exactLong}"
+  Text at AI offset: "${foundPreview}"
+  All search strategies (exact, case-insensitive, fuzzy) failed.
+  This suggests the AI hallucinated text that doesn't exist in the document.`
+    );
+    throw new Error(
+      "Cannot find acceptable match for text in content. All search strategies failed. Text may be hallucinated."
+    );
+  }
+  const actualText = content.substring(match.start, match.end);
+  const actualPreview = actualText.length > 50 ? actualText.substring(0, 50) + "..." : actualText;
+  const offsetDelta = match.start - aiStart;
+  const matchSymbol = match.matchQuality === "exact" ? "\u2713" : match.matchQuality === "case-insensitive" ? "\u2248" : "~";
+  console.warn(
+    `[validateAndCorrectOffsets] ${matchSymbol} Found ${match.matchQuality} match:
+  AI offsets: start=${aiStart}, end=${aiEnd}
+  Corrected: start=${match.start}, end=${match.end}
+  Offset delta: ${offsetDelta} characters
+  Actual text: "${actualPreview}"`
+  );
+  if (match.matchQuality === "fuzzy") {
+    console.warn(
+      `[validateAndCorrectOffsets] Fuzzy match details:
+  AI provided: "${exactPreview}"
+  Found in doc: "${actualPreview}"
+  Minor text differences detected - using document version`
+    );
+  }
+  const context = extractContext(content, match.start, match.end);
+  return {
+    start: match.start,
+    end: match.end,
+    exact: actualText,
+    // Use actual text from document, not AI's version
+    prefix: context.prefix,
+    suffix: context.suffix,
+    corrected: true,
+    fuzzyMatched: match.matchQuality !== "exact",
+    matchQuality: match.matchQuality
+  };
+}
+
+// src/utils/text-encoding.ts
+function extractCharset(mediaType) {
+  const charsetMatch = mediaType.match(/charset=([^\s;]+)/i);
+  return (charsetMatch?.[1] || "utf-8").toLowerCase();
+}
+function decodeWithCharset(buffer, mediaType) {
+  const charset = extractCharset(mediaType);
+  const decoder = new TextDecoder(charset);
+  return decoder.decode(buffer);
+}
 
 // src/utils/validation.ts
 var JWTTokenSchema = {
@@ -1690,6 +2033,6 @@ function getMimeCategory(mimeType) {
   return "unsupported";
 }
 
-export { APIError, JWTTokenSchema, LOCALES, SSEClient, SemiontApiClient, accessToken, annotationUri, authCode, baseUrl, cloneToken, email, entityType, extractBoundingBox, formatEventType, formatLocaleDisplay, formatRelativeTime, getAllLocaleCodes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getEntityTypes, getEventDisplayContent, getEventEmoji, getEventEntityTypes, getExactText, getExtensionForMimeType, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceCreationDetails, getResourceId, getSvgSelector, getTagCategory, getTagSchemaId, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isAssessment, isBodyResolved, isComment, isEventRelatedToAnnotation, isHighlight, isImageMimeType, isReference, isResolvedReference, isResourceEvent, isStubReference, isTag, isTextMimeType, isValidEmail, jobId, mcpToken, refreshToken, resourceAnnotationUri, resourceUri, searchQuery, userDID, validateData, validateSvgMarkup };
+export { APIError, JWTTokenSchema, LOCALES, SSEClient, SemiontApiClient, accessToken, annotationUri, authCode, baseUrl, cloneToken, createCircleSvg, createPolygonSvg, createRectangleSvg, decodeRepresentation, decodeWithCharset, email, entityType, extractBoundingBox, extractCharset, extractContext, findTextWithContext, formatEventType, formatLocaleDisplay, formatRelativeTime, getAllLocaleCodes, getAnnotationExactText, getAnnotationUriFromEvent, getBodySource, getBodyType, getChecksum, getCommentText, getCreator, getDerivedFrom, getEventDisplayContent, getEventEmoji, getEventEntityTypes, getExactText, getExtensionForMimeType, getLanguage, getLocaleEnglishName, getLocaleInfo, getLocaleNativeName, getMimeCategory, getNodeEncoding, getPrimaryMediaType, getPrimaryRepresentation, getPrimarySelector, getResourceCreationDetails, getResourceEntityTypes, getResourceId, getStorageUri, getSvgSelector, getTargetSelector, getTargetSource, getTextPositionSelector, getTextQuoteSelector, googleCredential, hasTargetSelector, isArchived, isAssessment, isBodyResolved, isComment, isDraft, isEventRelatedToAnnotation, isHighlight, isImageMimeType, isReference, isResolvedReference, isResourceEvent, isStubReference, isTag, isTextMimeType, isValidEmail, jobId, mcpToken, normalizeCoordinates, parseSvgSelector, refreshToken, resourceAnnotationUri, resourceUri, scaleSvgToNative, searchQuery, userDID, validateAndCorrectOffsets, validateData, validateSvgMarkup, verifyPosition };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map