@sellable/mcp 0.1.219 → 0.1.220

package/dist/tools/csv-linkedin.js

@@ -41,6 +41,9 @@ const RESERVED_TARGET_COLUMNS = new Set([
     "Open Link",
     "Enrich Prospect",
 ]);
+const COLUMN_MAPPING_SAMPLE_SIZE = 50;
+const MIN_COLUMN_CONFIDENCE = 0.65;
+const MIN_DOMAIN_COLUMN_CONFIDENCE = 0.8;
 const CSV_LINKEDIN_LIMITS = {
     maxBytes: MAX_CSV_LINKEDIN_UPLOAD_BYTES,
     maxRows: MAX_CSV_LINKEDIN_UPLOAD_ROWS,
@@ -187,38 +190,166 @@ function findHeader(csvHeaders, normalizedHeaders, candidates) {
     }
     return undefined;
 }
-function getSuggestedStandardMappings(headers, linkedInColumn) {
+function getSampleValues(rows, header) {
+    return rows
+        .slice(0, COLUMN_MAPPING_SAMPLE_SIZE)
+        .map((row) => String(row[header] ?? "").trim())
+        .filter(Boolean);
+}
+function getValueMatchStats(rows, header, predicate) {
+    const values = getSampleValues(rows, header);
+    const matchCount = values.filter(predicate).length;
+    return {
+        nonEmptyCount: values.length,
+        matchCount,
+        confidence: values.length > 0 ? matchCount / values.length : 0,
+    };
+}
+function hasConfidentValues(rows, header, predicate, options = {}) {
+    if (rows.length === 0) {
+        return true;
+    }
+    const stats = getValueMatchStats(rows, header, predicate);
+    if (stats.nonEmptyCount === 0) {
+        return options.allowEmpty ?? false;
+    }
+    const minMatches = Math.min(options.minMatches ?? 2, stats.nonEmptyCount);
+    const minConfidence = options.minConfidence ?? MIN_COLUMN_CONFIDENCE;
+    return stats.matchCount >= minMatches && stats.confidence >= minConfidence;
+}
+function findConfidentHeader(csvHeaders, normalizedHeaders, candidates, rows, predicate, options) {
+    const header = findHeader(csvHeaders, normalizedHeaders, candidates);
+    if (!header) {
+        return undefined;
+    }
+    return hasConfidentValues(rows, header, predicate, options)
+        ? header
+        : undefined;
+}
+function findBestHeaderByContent(headers, rows, predicate, options = {}) {
+    if (rows.length === 0) {
+        return undefined;
+    }
+    const candidates = headers
+        .map((header) => ({
+        header,
+        ...getValueMatchStats(rows, header, predicate),
+    }))
+        .filter((entry) => {
+        const minMatches = Math.min(options.minMatches ?? 2, entry.nonEmptyCount);
+        const minConfidence = options.minConfidence ?? MIN_COLUMN_CONFIDENCE;
+        return (entry.nonEmptyCount > 0 &&
+            entry.matchCount >= minMatches &&
+            entry.confidence >= minConfidence);
+    })
+        .sort((left, right) => {
+        if (right.confidence !== left.confidence) {
+            return right.confidence - left.confidence;
+        }
+        return right.matchCount - left.matchCount;
+    });
+    if (candidates.length === 0) {
+        return undefined;
+    }
+    const [best, second] = candidates;
+    if (second &&
+        second.confidence === best.confidence &&
+        second.matchCount === best.matchCount) {
+        return undefined;
+    }
+    return best.header;
+}
+function looksLikePersonName(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2 || trimmed.length > 120) {
+        return false;
+    }
+    if (/[0-9@/:]/.test(trimmed) || sanitizeCompanyWebsite(trimmed)) {
+        return false;
+    }
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    if (words.length === 0 || words.length > 5) {
+        return false;
+    }
+    if (/\b(inc|llc|ltd|corp|company|technologies|technology|security|systems|labs|software|group|studio|studios|ventures|capital|partners|agency|solutions|platform|cloud|data)\b/i.test(trimmed)) {
+        return false;
+    }
+    return words.every((word) => /\p{L}/u.test(word));
+}
+function looksLikeJobTitle(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2 || trimmed.length > 160) {
+        return false;
+    }
+    if (/@|https?:\/\//i.test(trimmed) || sanitizeCompanyWebsite(trimmed)) {
+        return false;
+    }
+    const words = trimmed.split(/\s+/).filter(Boolean);
+    return words.length > 0 && words.length <= 12 && /\p{L}/u.test(trimmed);
+}
+function looksLikeLocation(value) {
+    const trimmed = value.trim();
+    if (trimmed.length < 2 || trimmed.length > 120) {
+        return false;
+    }
+    if (/[0-9@/]/.test(trimmed) || sanitizeCompanyWebsite(trimmed)) {
+        return false;
+    }
+    return /\p{L}/u.test(trimmed);
+}
+function looksLikeCompanyWebsite(value) {
+    return sanitizeCompanyWebsite(value) !== null;
+}
+function isWebsiteContentFallbackHeader(header) {
+    const key = normalizeHeaderKey(header);
+    if (key.includes("linkedin") ||
+        key.includes("profile") ||
+        key.includes("email")) {
+        return false;
+    }
+    const normalized = normalizeHeaderForLookup(header);
+    return (normalized.includes("company") ||
+        normalized.includes("website") ||
+        normalized.includes("domain") ||
+        normalized.includes("url") ||
+        normalized.includes("site"));
+}
+function getSuggestedStandardMappings(headers, linkedInColumn, rows) {
     const filteredHeaders = headers.filter((header) => header !== linkedInColumn);
     const normalizedHeaders = filteredHeaders.map(normalizeHeaderForLookup);
     const mappings = {};
-    const directNameHeader = findHeader(filteredHeaders, normalizedHeaders, [
-        "name",
-        "full name",
-        "contact name",
-    ]);
+    const directNameHeader = findConfidentHeader(filteredHeaders, normalizedHeaders, ["name", "full name", "contact name", "contact full name"], rows, looksLikePersonName, { allowEmpty: true }) ??
+        findConfidentHeader(filteredHeaders, normalizedHeaders, [
+            "person",
+            "person name",
+            "prospect",
+            "prospect name",
+            "lead",
+            "lead name",
+            "recipient",
+            "recipient name",
+        ], rows, looksLikePersonName);
     if (directNameHeader) {
         mappings["Name"] = directNameHeader;
     }
     else {
         const firstNameIndex = normalizedHeaders.findIndex((header) => header === "first name");
         const lastNameIndex = normalizedHeaders.findIndex((header) => header === "last name");
-        if (firstNameIndex !== -1 && lastNameIndex !== -1) {
+        if (firstNameIndex !== -1 &&
+            lastNameIndex !== -1 &&
+            hasConfidentValues(rows, filteredHeaders[firstNameIndex], looksLikePersonName, { allowEmpty: true }) &&
+            hasConfidentValues(rows, filteredHeaders[lastNameIndex], looksLikePersonName, { allowEmpty: true })) {
             mappings["Name"] = [
                 filteredHeaders[firstNameIndex],
                 filteredHeaders[lastNameIndex],
             ];
         }
     }
-    const titleHeader = findHeader(filteredHeaders, normalizedHeaders, [
-        "title",
-        "job title",
-        "position",
-        "role",
-    ]);
+    const titleHeader = findConfidentHeader(filteredHeaders, normalizedHeaders, ["title", "job title", "position", "role"], rows, looksLikeJobTitle, { allowEmpty: true });
     if (titleHeader) {
         mappings["Title"] = titleHeader;
     }
-    const companyWebsiteHeader = findHeader(filteredHeaders, normalizedHeaders, [
+    const companyWebsiteHeader = findConfidentHeader(filteredHeaders, normalizedHeaders, [
         "company website",
         "website",
         "domain",
@@ -226,16 +357,12 @@ function getSuggestedStandardMappings(headers, linkedInColumn) {
         "website url",
         "company url",
         "organization website",
-    ]);
+    ], rows, looksLikeCompanyWebsite, { allowEmpty: true, minConfidence: MIN_DOMAIN_COLUMN_CONFIDENCE }) ??
+        findBestHeaderByContent(filteredHeaders.filter(isWebsiteContentFallbackHeader), rows, looksLikeCompanyWebsite, { minConfidence: MIN_DOMAIN_COLUMN_CONFIDENCE, minMatches: 3 });
     if (companyWebsiteHeader) {
         mappings["Company Website"] = companyWebsiteHeader;
     }
-    const locationHeader = findHeader(filteredHeaders, normalizedHeaders, [
-        "location",
-        "city",
-        "geography",
-        "region",
-    ]);
+    const locationHeader = findConfidentHeader(filteredHeaders, normalizedHeaders, ["location", "city", "geography", "region"], rows, looksLikeLocation, { allowEmpty: true });
     if (locationHeader) {
         mappings["Location"] = locationHeader;
     }
@@ -595,7 +722,7 @@ export function buildCsvLinkedinPreview(input) {
         }
     }
     const candidateLinkedInColumns = getCandidateLinkedInColumns(headers, parsed.rows);
-    const standardMappings = getSuggestedStandardMappings(headers, resolvedLinkedInColumn);
+    const standardMappings = getSuggestedStandardMappings(headers, resolvedLinkedInColumn, parsed.rows);
     let selectedColumns = getSuggestedCarryoverColumns(headers, resolvedLinkedInColumn, standardMappings);
     if (input.selectedColumns) {
         if (input.selectedColumns.length > MAX_CSV_LINKEDIN_UPLOAD_CARRY_COLUMNS) {

package/dist/tools/linkedin.d.ts

@@ -176,6 +176,42 @@ export declare const linkedinToolDefinitions: ({
         required: string[];
     };
 })[];
+interface RawLinkedInPost {
+    id?: string;
+    entityId?: string;
+    activityId?: string;
+    author?: {
+        authorName?: string;
+        authorPublicIdentifier?: string;
+    };
+    text?: string;
+    content?: string;
+    activityDate?: string;
+    postedAt?: string | {
+        date?: string;
+        timestamp?: number;
+        postedAgoText?: string;
+    };
+    reactionsCount?: number;
+    commentsCount?: number;
+    engagement?: {
+        likes?: number;
+        comments?: number;
+        shares?: number;
+    };
+    activityUrl?: string;
+    linkedinUrl?: string;
+    shareLinkedinUrl?: string;
+    socialContent?: {
+        shareUrl?: string;
+    };
+    header?: {
+        linkedinUrl?: string;
+    };
+    isRepublishedPost?: boolean;
+    repostedBy?: unknown;
+    repostedAt?: unknown;
+}
 interface SerializedPost {
     text: string;
     date: string;
@@ -184,6 +220,7 @@ interface SerializedPost {
     url: string;
     isRepost: boolean;
 }
+export declare function serializeLinkedInPosts(rawPosts: RawLinkedInPost[] | undefined, context: string): SerializedPost[];
 export declare function fetchLinkedInPosts(linkedinUrl: string, limit?: number): Promise<{
     posts: SerializedPost[];
     count: number;

package/dist/tools/linkedin.js

@@ -137,6 +137,51 @@ export const linkedinToolDefinitions = [
         },
     },
 ];
+function normalizePostDate(post) {
+    if (post.activityDate)
+        return post.activityDate;
+    if (typeof post.postedAt === "string")
+        return post.postedAt;
+    if (post.postedAt?.date)
+        return post.postedAt.date;
+    if (typeof post.postedAt?.timestamp === "number") {
+        return new Date(post.postedAt.timestamp).toISOString();
+    }
+    return "";
+}
+function normalizePostUrl(post) {
+    return (post.activityUrl ||
+        post.linkedinUrl ||
+        post.shareLinkedinUrl ||
+        post.socialContent?.shareUrl ||
+        post.header?.linkedinUrl ||
+        "");
+}
+function serializeLinkedInPost(post) {
+    return {
+        text: post.text || post.content || "",
+        date: normalizePostDate(post),
+        reactions: post.reactionsCount ?? post.engagement?.likes ?? 0,
+        comments: post.commentsCount ?? post.engagement?.comments ?? 0,
+        url: normalizePostUrl(post),
+        isRepost: Boolean(post.isRepublishedPost || post.repostedBy || post.repostedAt),
+    };
+}
+function isUsableSerializedPost(post) {
+    return Boolean(post.text.trim() ||
+        post.date ||
+        post.url ||
+        post.reactions > 0 ||
+        post.comments > 0);
+}
+export function serializeLinkedInPosts(rawPosts, context) {
+    const raw = rawPosts || [];
+    const posts = raw.map(serializeLinkedInPost).filter(isUsableSerializedPost);
+    if (raw.length > 0 && posts.length === 0) {
+        throw new Error(`${context} returned ${raw.length} post placeholder row(s), but none contained usable text, date, URL, or engagement data.`);
+    }
+    return posts;
+}
 export async function fetchLinkedInPosts(linkedinUrl, limit = 25) {
     const api = getApi();
     const normalizedLinkedinUrl = normalizeLinkedInProfileInput(linkedinUrl);
@@ -145,15 +190,7 @@ export async function fetchLinkedInPosts(linkedinUrl, limit = 25) {
         limit: String(limit),
     });
     const response = await api.get(`/api/v1/scrape/linkedin/user-posts?${params.toString()}`);
-    // Serialize to compact format: just text and key metadata
-    const posts = (response.posts || []).map((post) => ({
-        text: post.text || "",
-        date: post.activityDate || "",
-        reactions: post.reactionsCount || 0,
-        comments: post.commentsCount || 0,
-        url: post.activityUrl || "",
-        isRepost: post.isRepublishedPost || false,
-    }));
+    const posts = serializeLinkedInPosts(response.posts, "LinkedIn user posts fetch");
     return {
         posts,
         count: posts.length,
@@ -198,14 +235,7 @@ export async function fetchCompanyPosts(companyUrl, limit = 25, sortBy = "recent
         sortBy,
     });
     const response = await api.get(`/api/v1/scrape/linkedin/company-posts?${params.toString()}`);
-    const posts = (response.posts || []).map((post) => ({
-        text: post.text || "",
-        date: post.activityDate || "",
-        reactions: post.reactionsCount || 0,
-        comments: post.commentsCount || 0,
-        url: post.activityUrl || "",
-        isRepost: post.isRepublishedPost || false,
-    }));
+    const posts = serializeLinkedInPosts(response.posts, "LinkedIn company posts fetch");
     return {
         posts,
         count: posts.length,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sellable/mcp",
-  "version": "0.1.219",
+  "version": "0.1.220",
   "type": "module",
   "description": "Sellable MCP server for Claude Code and Codex campaign workflows",
   "main": "dist/index.js",

package/skills/research/config.json

@@ -1,9 +0,0 @@
-{
-  "parallelMode": "wide",
-  "agentCount": 6,
-  "maxToolCallsPerAgent": 2,
-  "senderMaxAgents": 2,
-  "senderMaxToolCallsPerAgent": 3,
-  "progressMode": true,
-  "debugMode": true
-}