@agentdomain/eliza-plugin 0.6.0 → 0.7.1

package/dist/text-parsing.d.ts

@@ -0,0 +1,14 @@
+export interface CompactQuantity {
+    value: number;
+    suffix: 'k' | 'm';
+}
+export declare function readLabeledRemainder(text: string, labels: readonly string[], options?: {
+    requireSeparator?: boolean;
+    stopCharacter?: string;
+    stopLabels?: readonly string[];
+}): string | undefined;
+export declare function readLabeledEmailUsername(text: string, labels: readonly string[]): string | undefined;
+export declare function extractEmailAddresses(text: string): string[];
+export declare function readLabeledEmail(text: string, labels: readonly string[]): string | undefined;
+export declare function extractFencedBlock(text: string, optionalLanguages: readonly string[]): string | undefined;
+export declare function parseCompactQuantity(text: string): CompactQuantity | undefined;

package/dist/text-parsing.js

@@ -0,0 +1,226 @@
+function isAsciiWhitespace(character) {
+    return character === ' ' || character === '\t' || character === '\r' || character === '\n';
+}
+function isAsciiDigit(character) {
+    return character !== undefined && character >= '0' && character <= '9';
+}
+function isAsciiLetter(character) {
+    return (character !== undefined &&
+        ((character >= 'a' && character <= 'z') || (character >= 'A' && character <= 'Z')));
+}
+function isAsciiAlphanumeric(character) {
+    return isAsciiDigit(character) || isAsciiLetter(character);
+}
+function isWordCharacter(character) {
+    return isAsciiAlphanumeric(character) || character === '_';
+}
+function isEmailLocalCharacter(character) {
+    return (isAsciiAlphanumeric(character) ||
+        character === '.' ||
+        character === '_' ||
+        character === '%' ||
+        character === '+' ||
+        character === '-');
+}
+function isEmailDomainCharacter(character) {
+    return isAsciiAlphanumeric(character) || character === '.' || character === '-';
+}
+function skipWhitespace(text, start) {
+    let cursor = start;
+    while (cursor < text.length && isAsciiWhitespace(text[cursor]))
+        cursor += 1;
+    return cursor;
+}
+function asciiCharactersEqual(left, right) {
+    if (left === right)
+        return true;
+    if (left === undefined || !isAsciiLetter(left) || !isAsciiLetter(right))
+        return false;
+    return (left.charCodeAt(0) | 32) === (right.charCodeAt(0) | 32);
+}
+function matchesAsciiCaseInsensitive(text, pattern, start) {
+    if (start + pattern.length > text.length)
+        return false;
+    for (let offset = 0; offset < pattern.length; offset += 1) {
+        if (!asciiCharactersEqual(text[start + offset], pattern[offset]))
+            return false;
+    }
+    return true;
+}
+function findLabeledValue(text, labels, requireSeparator, fromIndex = 0, requireWhitespaceBefore = false) {
+    let best = null;
+    for (const label of labels) {
+        let searchFrom = fromIndex;
+        while (searchFrom + label.length <= text.length) {
+            if (!matchesAsciiCaseInsensitive(text, label, searchFrom)) {
+                searchFrom += 1;
+                continue;
+            }
+            const labelStart = searchFrom;
+            const labelEnd = labelStart + label.length;
+            const hasStartBoundary = labelStart === 0 || !isWordCharacter(text[labelStart - 1]);
+            const hasEndBoundary = labelEnd === text.length || !isWordCharacter(text[labelEnd]);
+            const hasRequiredWhitespace = !requireWhitespaceBefore ||
+                labelStart === fromIndex ||
+                isAsciiWhitespace(text[labelStart - 1]);
+            if (hasStartBoundary && hasEndBoundary && hasRequiredWhitespace) {
+                let valueStart = skipWhitespace(text, labelEnd);
+                const hasSeparator = text[valueStart] === ':' || text[valueStart] === '=';
+                if (hasSeparator)
+                    valueStart = skipWhitespace(text, valueStart + 1);
+                if (!requireSeparator || hasSeparator) {
+                    if (best === null || labelStart < best.labelStart)
+                        best = { labelStart, valueStart };
+                    break;
+                }
+            }
+            searchFrom += 1;
+        }
+    }
+    return best;
+}
+export function readLabeledRemainder(text, labels, options = {}) {
+    const match = findLabeledValue(text, labels, options.requireSeparator ?? true);
+    if (match === null)
+        return undefined;
+    let valueEnd = text.length;
+    if (options.stopCharacter) {
+        const stop = text.indexOf(options.stopCharacter, match.valueStart);
+        if (stop >= 0)
+            valueEnd = stop;
+    }
+    if (options.stopLabels?.length) {
+        const stop = findLabeledValue(text, options.stopLabels, true, match.valueStart, true);
+        if (stop !== null && stop.labelStart < valueEnd)
+            valueEnd = stop.labelStart;
+    }
+    const value = text.slice(match.valueStart, valueEnd).trim();
+    return value || undefined;
+}
+export function readLabeledEmailUsername(text, labels) {
+    const match = findLabeledValue(text, labels, false);
+    if (match === null || !isEmailLocalCharacter(text[match.valueStart]))
+        return undefined;
+    let end = match.valueStart;
+    while (end < text.length && isEmailLocalCharacter(text[end]))
+        end += 1;
+    return text.slice(match.valueStart, end);
+}
+function isValidDomain(domain) {
+    let labelStart = 0;
+    let dotCount = 0;
+    for (let index = 0; index <= domain.length; index += 1) {
+        if (index < domain.length && domain[index] !== '.') {
+            if (!isAsciiAlphanumeric(domain[index]) && domain[index] !== '-')
+                return false;
+            continue;
+        }
+        if (index === labelStart ||
+            !isAsciiAlphanumeric(domain[labelStart]) ||
+            !isAsciiAlphanumeric(domain[index - 1])) {
+            return false;
+        }
+        if (index < domain.length) {
+            dotCount += 1;
+            labelStart = index + 1;
+        }
+    }
+    if (dotCount < 1 || domain.length - labelStart < 2)
+        return false;
+    for (let index = labelStart; index < domain.length; index += 1) {
+        if (!isAsciiLetter(domain[index]))
+            return false;
+    }
+    return true;
+}
+function isValidEmailParts(local, domain) {
+    if (!local || local.startsWith('.') || local.endsWith('.') || local.includes('..') || !domain) {
+        return false;
+    }
+    return isValidDomain(domain);
+}
+function readEmailAt(text, start) {
+    if (!isEmailLocalCharacter(text[start]))
+        return { nextIndex: start + 1 };
+    let cursor = start;
+    while (cursor < text.length && isEmailLocalCharacter(text[cursor]))
+        cursor += 1;
+    const localEnd = cursor;
+    if (text[cursor] !== '@')
+        return { nextIndex: cursor };
+    cursor += 1;
+    const domainStart = cursor;
+    while (cursor < text.length && isEmailDomainCharacter(text[cursor]))
+        cursor += 1;
+    let addressEnd = cursor;
+    while (addressEnd > domainStart && text[addressEnd - 1] === '.')
+        addressEnd -= 1;
+    const local = text.slice(start, localEnd);
+    const domain = text.slice(domainStart, addressEnd);
+    return {
+        email: isValidEmailParts(local, domain) ? text.slice(start, addressEnd) : undefined,
+        nextIndex: Math.max(cursor, start + 1),
+    };
+}
+export function extractEmailAddresses(text) {
+    const emails = [];
+    let cursor = 0;
+    while (cursor < text.length) {
+        if (!isEmailLocalCharacter(text[cursor])) {
+            cursor += 1;
+            continue;
+        }
+        const result = readEmailAt(text, cursor);
+        if (result.email)
+            emails.push(result.email);
+        cursor = result.nextIndex;
+    }
+    return emails;
+}
+export function readLabeledEmail(text, labels) {
+    const match = findLabeledValue(text, labels, true);
+    if (match === null)
+        return undefined;
+    return readEmailAt(text, match.valueStart).email;
+}
+export function extractFencedBlock(text, optionalLanguages) {
+    const openingFence = text.indexOf('```');
+    if (openingFence < 0)
+        return undefined;
+    let contentStart = openingFence + 3;
+    for (const language of optionalLanguages) {
+        if (matchesAsciiCaseInsensitive(text, language, contentStart)) {
+            contentStart += language.length;
+            break;
+        }
+    }
+    contentStart = skipWhitespace(text, contentStart);
+    const closingFence = text.indexOf('```', contentStart);
+    return closingFence < 0 ? undefined : text.slice(contentStart, closingFence);
+}
+export function parseCompactQuantity(text) {
+    let cursor = 0;
+    while (cursor < text.length) {
+        if (!isAsciiDigit(text[cursor])) {
+            cursor += 1;
+            continue;
+        }
+        const numberStart = cursor;
+        while (cursor < text.length && isAsciiDigit(text[cursor]))
+            cursor += 1;
+        if (text[cursor] === '.' && isAsciiDigit(text[cursor + 1])) {
+            cursor += 1;
+            while (cursor < text.length && isAsciiDigit(text[cursor]))
+                cursor += 1;
+        }
+        const numberEnd = cursor;
+        const suffixIndex = skipWhitespace(text, cursor);
+        const suffix = text[suffixIndex]?.toLowerCase();
+        if (suffix === 'k' || suffix === 'm') {
+            const value = Number(text.slice(numberStart, numberEnd));
+            if (Number.isFinite(value))
+                return { value, suffix };
+        }
+    }
+    return undefined;
+}

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "@agentdomain/eliza-plugin",
-  "version": "0.6.0",
+  "version": "0.7.1",
   "description": "ElizaOS plugin for AgentDomain - give your Eliza agent a complete identity stack",
   "license": "Apache-2.0",
   "repository": "https://github.com/0xmdrakib/AgentDomain.git",
-  "homepage": "https://agentdomain.app/docs",
+  "homepage": "https://docs.agentdomain.app",
   "bugs": "https://github.com/0xmdrakib/AgentDomain/issues",
   "type": "module",
   "main": "./dist/index.js",
@@ -18,6 +18,8 @@
   "files": [
     "dist",
     "README.md",
+    "LICENSE",
+    "NOTICE",
     "package.json"
   ],
   "publishConfig": {
@@ -26,8 +28,8 @@
   "dependencies": {
     "viem": "^2.55.2",
     "zod": "^3.24.1",
-    "@agentdomain/sdk": "^0.6.0",
-    "@agentdomain/shared": "^0.6.0"
+    "@agentdomain/sdk": "^0.7.0",
+    "@agentdomain/shared": "^0.7.0"
   },
   "peerDependencies": {
     "@elizaos/core": "^1.0.0"
@@ -37,6 +39,7 @@
   },
   "scripts": {
     "build": "tsc",
+    "test": "pnpm --filter @agentdomain/sdk build && pnpm run build && node --test test/*.test.mjs",
     "typecheck": "tsc --noEmit",
     "lint": "echo \"no lint\""
   }