@sellable/mcp 0.1.268 → 0.1.269

package/dist/tools/engage-discovery.d.ts

@@ -1,14 +1,3 @@
-type FollowerBandFit = "in_target_band" | "below_target_band" | "above_target_band" | "unknown";
-type ReachSignals = {
-    targetFollowerMin?: number;
-    targetFollowerMax?: number;
-    followerBandFit: FollowerBandFit;
-    engagementPer1kFollowers: number | null;
-    weightedEngagementPer1kFollowers: number | null;
-    reachPenaltyMultiplier: number;
-    reachAdjustedScore: number;
-    confidence: "high" | "medium" | "low";
-};
 export type EngagementPost = {
     postId: string;
     url: string;
@@ -18,7 +7,6 @@ export type EngagementPost = {
         name: string;
         headline: string;
         profileUrl: string;
-        followerCount?: number;
     };
     engagement: {
         likes: number;
@@ -26,7 +14,6 @@ export type EngagementPost = {
         shares: number;
         total: number;
     };
-    reachSignals?: ReachSignals;
     contentPreview: string;
 };
 export type SearchEngagementPostsInput = {
@@ -36,8 +23,6 @@ export type SearchEngagementPostsInput = {
     minTotalEngagement?: number;
     maxPosts?: number;
     excludePostUrls?: string[];
-    targetFollowerMin?: number;
-    targetFollowerMax?: number;
 };
 export type SearchEngagementPostsResponse = {
     success: boolean;
@@ -85,18 +70,9 @@ export declare const engageDiscoveryToolDefinitions: {
                 };
                 description: string;
             };
-            targetFollowerMin: {
-                type: string;
-                description: string;
-            };
-            targetFollowerMax: {
-                type: string;
-                description: string;
-            };
         };
         required: string[];
         additionalProperties: boolean;
     };
 }[];
 export declare function searchEngagementPosts(input: SearchEngagementPostsInput): Promise<SearchEngagementPostsResponse>;
-export {};

package/dist/tools/engage-discovery.js

@@ -32,14 +32,6 @@ export const engageDiscoveryToolDefinitions = [
                     items: { type: "string" },
                     description: "Optional list of post URLs to exclude (e.g. already engaged/scheduled).",
                 },
-                targetFollowerMin: {
-                    type: "number",
-                    description: "Optional lower bound for creator follower count when reach-normalizing hook/source quality.",
-                },
-                targetFollowerMax: {
-                    type: "number",
-                    description: "Optional upper bound for creator follower count when reach-normalizing hook/source quality.",
-                },
             },
             required: ["keywords"],
             additionalProperties: false,
@@ -71,79 +63,6 @@ function safeNumber(value) {
     const n = typeof value === "number" ? value : Number(value);
     return Number.isFinite(n) ? n : 0;
 }
-function round3(value) {
-    return Number(value.toFixed(3));
-}
-function parseFollowerCount(author) {
-    const direct = safeNumber(author?.followerCount);
-    if (direct > 0)
-        return direct;
-    const text = String(author?.followers || author?.followerCountText || "");
-    const match = text.match(/([\d,.]+)\s*([kKmM])?/);
-    if (!match)
-        return undefined;
-    const base = Number(match[1].replace(/,/g, ""));
-    if (!Number.isFinite(base) || base <= 0)
-        return undefined;
-    const suffix = match[2]?.toLowerCase();
-    if (suffix === "m")
-        return Math.round(base * 1_000_000);
-    if (suffix === "k")
-        return Math.round(base * 1_000);
-    return Math.round(base);
-}
-function reachPenaltyMultiplier(followerCount, targetFollowerMin, targetFollowerMax) {
-    if (!followerCount || !targetFollowerMin || !targetFollowerMax)
-        return 0.4;
-    if (followerCount >= targetFollowerMin && followerCount <= targetFollowerMax) {
-        return 1;
-    }
-    if (followerCount < targetFollowerMin)
-        return 0.75;
-    if (followerCount <= targetFollowerMax * 2)
-        return 0.65;
-    if (followerCount <= targetFollowerMax * 5)
-        return 0.35;
-    return 0.15;
-}
-function followerBandFit(followerCount, targetFollowerMin, targetFollowerMax) {
-    if (!followerCount || !targetFollowerMin || !targetFollowerMax) {
-        return "unknown";
-    }
-    if (followerCount >= targetFollowerMin && followerCount <= targetFollowerMax) {
-        return "in_target_band";
-    }
-    if (followerCount < targetFollowerMin)
-        return "below_target_band";
-    return "above_target_band";
-}
-function buildReachSignals(params) {
-    const { followerCount, likes, comments, shares, total } = params;
-    const hasTarget = Boolean(params.targetFollowerMin && params.targetFollowerMax);
-    if (!hasTarget && !followerCount)
-        return undefined;
-    const weightedEngagement = likes + comments * 4 + shares * 12;
-    const penalty = reachPenaltyMultiplier(followerCount, params.targetFollowerMin, params.targetFollowerMax);
-    const engagementPer1kFollowers = followerCount
-        ? round3((total / followerCount) * 1000)
-        : null;
-    const weightedEngagementPer1kFollowers = followerCount
-        ? round3((weightedEngagement / followerCount) * 1000)
-        : null;
-    const reachAdjustedScore = weightedEngagementPer1kFollowers === null
-        ? 0
-        : round3(weightedEngagementPer1kFollowers * penalty);
-    return {
-        targetFollowerMin: params.targetFollowerMin,
-        targetFollowerMax: params.targetFollowerMax,
-        followerBandFit: followerBandFit(followerCount, params.targetFollowerMin, params.targetFollowerMax),
-        engagementPer1kFollowers,
-        weightedEngagementPer1kFollowers,
-        reachPenaltyMultiplier: penalty,
-        reachAdjustedScore,
-        confidence: followerCount ? (hasTarget ? "high" : "medium") : "low",
-    };
-}
 export async function searchEngagementPosts(input) {
     const api = getApi();
     const keywords = (input.keywords || [])
@@ -160,12 +79,6 @@ export async function searchEngagementPosts(input) {
     const maxPosts = typeof input.maxPosts === "number" && input.maxPosts > 0
         ? Math.min(50, input.maxPosts)
         : 25;
-    const targetFollowerMin = typeof input.targetFollowerMin === "number" && input.targetFollowerMin > 0
-        ? input.targetFollowerMin
-        : undefined;
-    const targetFollowerMax = typeof input.targetFollowerMax === "number" && input.targetFollowerMax > 0
-        ? input.targetFollowerMax
-        : undefined;
     const exclude = new Set((input.excludePostUrls || [])
         .map((u) => normalizePostUrl(u))
         .filter(Boolean));
@@ -174,10 +87,10 @@ export async function searchEngagementPosts(input) {
         keywords: keywords.map((keyword) => ({ keyword })),
         page,
     });
-    const rawPosts = Array.isArray(response?.posts)
-        ? response.posts
-        : Array.isArray(response?.topPostsForLLM)
-            ? response.topPostsForLLM
+    const rawPosts = Array.isArray(response?.topPostsForLLM)
+        ? response.topPostsForLLM
+        : Array.isArray(response?.posts)
+            ? response.posts
             : [];
     const now = Date.now();
     const oldestMs = now - maxAgeDays * 24 * 60 * 60 * 1000;
@@ -208,16 +121,6 @@ export async function searchEngagementPosts(input) {
             tooOld += 1;
             continue;
         }
-        const followerCount = parseFollowerCount(p?.author);
-        const reachSignals = buildReachSignals({
-            followerCount,
-            likes,
-            comments,
-            shares,
-            total,
-            targetFollowerMin,
-            targetFollowerMax,
-        });
         kept.push({
             postId: String(p?.id || ""),
             url,
@@ -229,26 +132,18 @@ export async function searchEngagementPosts(input) {
                 name: String(p?.author?.name || ""),
                 headline: String(p?.author?.headline || ""),
                 profileUrl: String(p?.author?.profileUrl || ""),
-                ...(followerCount ? { followerCount } : {}),
             },
             engagement: { likes, comments, shares, total },
-            ...(reachSignals ? { reachSignals } : {}),
             contentPreview: previewText(String(p?.content || ""), 220),
         });
+        if (kept.length >= maxPosts)
+            break;
     }
-    const hasReachTarget = Boolean(targetFollowerMin && targetFollowerMax);
-    kept.sort((a, b) => {
-        if (hasReachTarget) {
-            const reachDelta = (b.reachSignals?.reachAdjustedScore || 0) -
-                (a.reachSignals?.reachAdjustedScore || 0);
-            if (reachDelta !== 0)
-                return reachDelta;
-        }
-        return b.engagement.total - a.engagement.total;
-    });
+    // Sort by total engagement desc for a predictable shortlist.
+    kept.sort((a, b) => b.engagement.total - a.engagement.total);
     return {
         success: true,
-        posts: kept.slice(0, maxPosts),
+        posts: kept,
         totalReturned: rawPosts.length,
         filteredOut: { tooOld, excluded, tooLowEngagement },
     };

package/dist/tools/harvest-jobs.d.ts

@@ -0,0 +1,182 @@
+type ArtifactFormat = "markdown" | "csv" | "both";
+export interface SearchHarvestJobsInput {
+    search?: string;
+    searches?: string[];
+    location?: string;
+    geoId?: string;
+    postedLimit?: "24h" | "week" | "month";
+    sortBy?: "relevance" | "date";
+    workplaceType?: string | string[];
+    employmentType?: string | string[];
+    experienceLevel?: string | string[];
+    easyApply?: boolean;
+    under10Applicants?: boolean;
+    salary?: string;
+    pages?: number;
+    maxRows?: number;
+    artifactFormat?: ArtifactFormat;
+    outputDir?: string;
+    fileBaseName?: string;
+}
+export interface ConfirmHarvestJobCompaniesInput {
+    searchToken?: string;
+    selectedJobIds?: string[];
+    name?: string;
+    outputDir?: string;
+    fileBaseName?: string;
+    [key: string]: unknown;
+}
+export declare const harvestJobToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            search: {
+                type: string;
+            };
+            searches: {
+                type: string;
+                items: {
+                    type: string;
+                };
+            };
+            location: {
+                type: string;
+            };
+            geoId: {
+                type: string;
+            };
+            postedLimit: {
+                type: string;
+                enum: string[];
+            };
+            sortBy: {
+                type: string;
+                enum: string[];
+            };
+            workplaceType: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            employmentType: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            experienceLevel: {
+                oneOf: ({
+                    type: string;
+                    items?: undefined;
+                } | {
+                    type: string;
+                    items: {
+                        type: string;
+                    };
+                })[];
+            };
+            easyApply: {
+                type: string;
+            };
+            under10Applicants: {
+                type: string;
+            };
+            salary: {
+                type: string;
+            };
+            pages: {
+                type: string;
+                description: string;
+            };
+            maxRows: {
+                type: string;
+                description: string;
+            };
+            artifactFormat: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+            fileBaseName: {
+                type: string;
+                description: string;
+            };
+            searchToken?: undefined;
+            selectedJobIds?: undefined;
+            name?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            searchToken: {
+                type: string;
+                description: string;
+            };
+            selectedJobIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            name: {
+                type: string;
+            };
+            outputDir: {
+                type: string;
+                description: string;
+            };
+            fileBaseName: {
+                type: string;
+                description: string;
+            };
+            search?: undefined;
+            searches?: undefined;
+            location?: undefined;
+            geoId?: undefined;
+            postedLimit?: undefined;
+            sortBy?: undefined;
+            workplaceType?: undefined;
+            employmentType?: undefined;
+            experienceLevel?: undefined;
+            easyApply?: undefined;
+            under10Applicants?: undefined;
+            salary?: undefined;
+            pages?: undefined;
+            maxRows?: undefined;
+            artifactFormat?: undefined;
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function searchHarvestJobs(input: SearchHarvestJobsInput): Promise<{
+    [k: string]: unknown;
+}>;
+export declare function confirmHarvestJobCompanies(input: ConfirmHarvestJobCompaniesInput): Promise<{
+    [k: string]: unknown;
+}>;
+export {};