@sellable/mcp 0.1.0

package/dist/tools/engage-memory.js

@@ -0,0 +1,143 @@
+import { copySenderConfig, getEngageMemory, migrateFlatConfigs, recordProvenSearch, setStyleGuide, upsertTrackedPerson, } from "../engage-memory.js";
+export const engageMemoryToolDefinitions = [
+    {
+        name: "get_engage_memory",
+        description: "Load engage memory from .sellable/configs/: style guide, proven search keywords, and tracked people. All data lives in readable markdown files the user can also edit directly. When senderId is provided, reads from senders/{senderId}/ with flat-path fallback.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                senderId: {
+                    type: "string",
+                    description: "Optional sender ID. When provided, reads per-sender configs from senders/{senderId}/. Falls back to flat configs if sender dir doesn't exist.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "set_engage_style_guide",
+        description: "Write the user's commenting style guide. When senderId is provided, writes to .sellable/configs/senders/{senderId}/styleguide-core.md. Otherwise writes to .sellable/configs/writing/styleguide-core.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                markdown: {
+                    type: "string",
+                    description: "The style guide content in markdown format.",
+                },
+                senderId: {
+                    type: "string",
+                    description: "Optional sender ID. When provided, writes to per-sender config.",
+                },
+            },
+            required: ["markdown"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "record_engage_proven_search",
+        description: "Record a keyword search outcome. When senderId is provided, writes to senders/{senderId}/proven-searches.md. Otherwise writes to discovery/proven-searches.md. Updates running averages if the keyword already exists.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                keyword: {
+                    type: "string",
+                    description: "The search keyword that was used.",
+                },
+                totalReturned: {
+                    type: "number",
+                    description: "How many posts were returned by the search.",
+                },
+                postsYielded: {
+                    type: "number",
+                    description: "How many posts from this search were selected for the shortlist.",
+                },
+                senderId: {
+                    type: "string",
+                    description: "Optional sender ID. When provided, writes to per-sender config.",
+                },
+            },
+            required: ["keyword", "totalReturned", "postsYielded"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "upsert_engage_tracked_person",
+        description: "Add or update a person in tracked people. When senderId is provided, writes to senders/{senderId}/influencers.md. Otherwise writes to discovery/influencers.md.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                name: {
+                    type: "string",
+                    description: "Display name of the person.",
+                },
+                linkedinUrl: {
+                    type: "string",
+                    description: "Full LinkedIn profile URL.",
+                },
+                reason: {
+                    type: "string",
+                    description: "Why this person is being tracked (e.g. 'thought leader in B2B sales').",
+                },
+                senderId: {
+                    type: "string",
+                    description: "Optional sender ID. When provided, writes to per-sender config.",
+                },
+            },
+            required: ["name", "linkedinUrl", "reason"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "copy_sender_config",
+        description: "Copy all per-sender config files (styleguide-core.md, proven-searches.md, influencers.md) from one sender to another. Useful for bootstrapping a new sender from an existing one.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                fromSenderId: {
+                    type: "string",
+                    description: "Source sender ID to copy configs from.",
+                },
+                toSenderId: {
+                    type: "string",
+                    description: "Target sender ID to copy configs to.",
+                },
+            },
+            required: ["fromSenderId", "toSenderId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "migrate_flat_configs",
+        description: "One-time migration: copy existing flat configs (writing/styleguide-core.md, discovery/proven-searches.md, discovery/influencers.md) into senders/{senderId}/. Leaves originals in place. Run once per sender when transitioning to per-sender config.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                senderId: {
+                    type: "string",
+                    description: "Sender ID whose per-sender directory to populate from flat configs.",
+                },
+            },
+            required: ["senderId"],
+            additionalProperties: false,
+        },
+    },
+];
+export function getEngageMemoryTool(input) {
+    return getEngageMemory(input?.senderId);
+}
+export function setEngageStyleGuideTool(input) {
+    return setStyleGuide(input.markdown, input.senderId);
+}
+export function recordEngageProvenSearchTool(input) {
+    return recordProvenSearch(input);
+}
+export function upsertEngageTrackedPersonTool(input) {
+    return upsertTrackedPerson(input);
+}
+export function copySenderConfigTool(input) {
+    return copySenderConfig(input);
+}
+export function migrateFlatConfigsTool(input) {
+    return migrateFlatConfigs(input);
+}

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

@@ -0,0 +1,72 @@
+export declare const engageStateToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            lastSenderId?: undefined;
+            lastCommentCampaignTableId?: undefined;
+            clearCommentCampaignTableId?: undefined;
+            lastSenderIds?: undefined;
+            lastCommentCampaignTableIds?: undefined;
+            lastMode?: undefined;
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            lastSenderId: {
+                type: string;
+                description: string;
+            };
+            lastCommentCampaignTableId: {
+                type: string;
+            };
+            clearCommentCampaignTableId: {
+                type: string;
+                description: string;
+            };
+            lastSenderIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+            lastCommentCampaignTableIds: {
+                type: string;
+                additionalProperties: {
+                    type: string;
+                };
+                description: string;
+            };
+            lastMode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+        };
+        required: never[];
+        additionalProperties: boolean;
+    };
+})[];
+export declare function getEngageStateTool(): {
+    activeWorkspaceId: string | null;
+    state: import("../auth.js").EngageWorkspaceState | null;
+};
+export declare function setEngageStateTool(input: {
+    lastSenderId?: string;
+    lastCommentCampaignTableId?: string;
+    clearCommentCampaignTableId?: boolean;
+    lastSenderIds?: string[];
+    lastCommentCampaignTableIds?: Record<string, string>;
+    lastMode?: "interactive" | "autonomous";
+}): {
+    activeWorkspaceId: string;
+    state: import("../auth.js").EngageWorkspaceState;
+};

package/dist/tools/engage-state.js

@@ -0,0 +1,62 @@
+import { getEngageState, updateEngageState } from "../auth.js";
+export const engageStateToolDefinitions = [
+    {
+        name: "get_engage_state",
+        description: "Get persisted engage defaults (per active workspace) to avoid relying on LLM memory. Includes lastSenderId, lastSenderIds (multi-sender), lastCommentCampaignTableIds, and lastMode.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "set_engage_state",
+        description: "Persist engage defaults (per active workspace) so future runs can auto-select sender/table without relying on LLM memory. Supports both single-sender (lastSenderId) and multi-sender (lastSenderIds) fields.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                lastSenderId: {
+                    type: "string",
+                    description: "Primary sender ID (backward compat).",
+                },
+                lastCommentCampaignTableId: { type: "string" },
+                clearCommentCampaignTableId: {
+                    type: "boolean",
+                    description: "If true, clears the stored lastCommentCampaignTableId for this workspace.",
+                },
+                lastSenderIds: {
+                    type: "array",
+                    items: { type: "string" },
+                    description: "Array of sender IDs from last multi-sender session.",
+                },
+                lastCommentCampaignTableIds: {
+                    type: "object",
+                    additionalProperties: { type: "string" },
+                    description: "Map of senderId → comment campaign tableId for multi-sender sessions.",
+                },
+                lastMode: {
+                    type: "string",
+                    enum: ["interactive", "autonomous"],
+                    description: "Last session mode.",
+                },
+            },
+            required: [],
+            additionalProperties: false,
+        },
+    },
+];
+export function getEngageStateTool() {
+    return getEngageState();
+}
+export function setEngageStateTool(input) {
+    return updateEngageState({
+        lastSenderId: input.lastSenderId,
+        lastCommentCampaignTableId: input.clearCommentCampaignTableId
+            ? null
+            : input.lastCommentCampaignTableId,
+        lastSenderIds: input.lastSenderIds,
+        lastCommentCampaignTableIds: input.lastCommentCampaignTableIds,
+        lastMode: input.lastMode,
+    });
+}

package/dist/tools/enrichment.d.ts

@@ -0,0 +1,167 @@
+export type EnrichWithProspeoInput = {
+    linkedinUrl?: string;
+    firstName?: string;
+    lastName?: string;
+    companyName?: string;
+    companyWebsite?: string;
+    onlyVerifiedEmail?: boolean;
+    enrichMobile?: boolean;
+};
+export type BulkEnrichWithProspeoInput = {
+    inputs: Array<{
+        identifier: string;
+        linkedin_url?: string;
+        first_name?: string;
+        last_name?: string;
+        company_name?: string;
+    }>;
+    onlyVerifiedEmail?: boolean;
+};
+export declare const enrichmentToolDefinitions: ({
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            linkedinUrl: {
+                type: string;
+                description: string;
+            };
+            firstName: {
+                type: string;
+                description: string;
+            };
+            lastName: {
+                type: string;
+                description: string;
+            };
+            companyName: {
+                type: string;
+                description: string;
+            };
+            companyWebsite: {
+                type: string;
+                description: string;
+            };
+            onlyVerifiedEmail: {
+                type: string;
+                description: string;
+            };
+            enrichMobile: {
+                type: string;
+                description: string;
+            };
+            inputs?: undefined;
+        };
+        required: never[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            inputs: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        identifier: {
+                            type: string;
+                            description: string;
+                        };
+                        linkedin_url: {
+                            type: string;
+                            description: string;
+                        };
+                        first_name: {
+                            type: string;
+                        };
+                        last_name: {
+                            type: string;
+                        };
+                        company_name: {
+                            type: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            onlyVerifiedEmail: {
+                type: string;
+                description: string;
+            };
+            linkedinUrl?: undefined;
+            firstName?: undefined;
+            lastName?: undefined;
+            companyName?: undefined;
+            companyWebsite?: undefined;
+            enrichMobile?: undefined;
+        };
+        required: string[];
+    };
+} | {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            linkedinUrl?: undefined;
+            firstName?: undefined;
+            lastName?: undefined;
+            companyName?: undefined;
+            companyWebsite?: undefined;
+            onlyVerifiedEmail?: undefined;
+            enrichMobile?: undefined;
+            inputs?: undefined;
+        };
+        required: never[];
+    };
+})[];
+export declare function enrichWithProspeo(input: EnrichWithProspeoInput): Promise<{
+    success: boolean;
+    creditsUsed: number;
+    person: {
+        name: string | undefined;
+        title: string | undefined;
+        headline: string | undefined;
+        email: string | undefined;
+        emailStatus: string | undefined;
+        phone: string | undefined;
+        phoneStatus: string | undefined;
+        linkedinUrl: string | undefined;
+        location: string;
+    };
+    company: {
+        name: string | undefined;
+        domain: string | undefined;
+        industry: string | undefined;
+        employeeRange: string | undefined;
+    } | null;
+}>;
+export declare function bulkEnrichWithProspeo(input: BulkEnrichWithProspeoInput): Promise<{
+    success: boolean;
+    totalCost: number;
+    summary: {
+        requested: number;
+        matched: number;
+        notMatched: number;
+        invalid: number;
+    };
+    matched: {
+        identifier: string;
+        name: string | undefined;
+        email: string | undefined;
+        emailStatus: string | undefined;
+        company: string | undefined;
+    }[];
+    notMatched: string[];
+    invalidDatapoints: string[];
+}>;
+export declare function getProspeoCredits(): Promise<{
+    plan: string;
+    remainingCredits: number;
+    usedCredits: number;
+    renewsInDays: number;
+}>;

package/dist/tools/enrichment.js

@@ -0,0 +1,174 @@
+import { getApi } from "../api.js";
+export const enrichmentToolDefinitions = [
+    {
+        name: "enrich_with_prospeo",
+        description: "Enrich a person with email and company data using Prospeo. Provide LinkedIn URL (preferred) or name+company. Returns verified email, job history, and company details. Costs 1 credit (10 for mobile).",
+        inputSchema: {
+            type: "object",
+            properties: {
+                linkedinUrl: {
+                    type: "string",
+                    description: "LinkedIn profile URL (preferred input method)",
+                },
+                firstName: {
+                    type: "string",
+                    description: "First name (alternative to linkedinUrl)",
+                },
+                lastName: {
+                    type: "string",
+                    description: "Last name (alternative to linkedinUrl)",
+                },
+                companyName: {
+                    type: "string",
+                    description: "Company name for matching",
+                },
+                companyWebsite: {
+                    type: "string",
+                    description: "Company domain for matching",
+                },
+                onlyVerifiedEmail: {
+                    type: "boolean",
+                    description: "Only return if email is verified (default: true)",
+                },
+                enrichMobile: {
+                    type: "boolean",
+                    description: "Include mobile number - costs 10 credits (default: false)",
+                },
+            },
+            required: [],
+        },
+    },
+    {
+        name: "bulk_enrich_with_prospeo",
+        description: "Bulk enrich multiple people with Prospeo. Up to 100 inputs per request. Each input needs a unique identifier for correlation.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                inputs: {
+                    type: "array",
+                    description: "Array of people to enrich (max 100)",
+                    items: {
+                        type: "object",
+                        properties: {
+                            identifier: {
+                                type: "string",
+                                description: "Unique ID for correlation in results",
+                            },
+                            linkedin_url: {
+                                type: "string",
+                                description: "LinkedIn profile URL",
+                            },
+                            first_name: {
+                                type: "string",
+                            },
+                            last_name: {
+                                type: "string",
+                            },
+                            company_name: {
+                                type: "string",
+                            },
+                        },
+                        required: ["identifier"],
+                    },
+                },
+                onlyVerifiedEmail: {
+                    type: "boolean",
+                    description: "Only return verified emails (default: true)",
+                },
+            },
+            required: ["inputs"],
+        },
+    },
+    {
+        name: "get_prospeo_credits",
+        description: "Get Prospeo account credits remaining. Use to check balance before bulk operations.",
+        inputSchema: {
+            type: "object",
+            properties: {},
+            required: [],
+        },
+    },
+];
+export async function enrichWithProspeo(input) {
+    const api = getApi();
+    // Validate input
+    const hasLinkedIn = !!input.linkedinUrl;
+    const hasName = !!(input.firstName && input.lastName);
+    const hasCompany = !!(input.companyName || input.companyWebsite);
+    if (!hasLinkedIn && !(hasName && hasCompany)) {
+        throw new Error("Must provide linkedinUrl OR (firstName + lastName + company info)");
+    }
+    const response = await api.post("/api/v3/prospeo/enrich", {
+        linkedinUrl: input.linkedinUrl,
+        firstName: input.firstName,
+        lastName: input.lastName,
+        companyName: input.companyName,
+        companyWebsite: input.companyWebsite,
+        onlyVerifiedEmail: input.onlyVerifiedEmail ?? true,
+        enrichMobile: input.enrichMobile ?? false,
+        normalize: true,
+    });
+    // Return compact summary for LLM
+    const n = response.normalized;
+    return {
+        success: true,
+        creditsUsed: response.creditsUsed,
+        person: {
+            name: n?.name,
+            title: n?.title,
+            headline: n?.headline,
+            email: n?.email,
+            emailStatus: n?.emailStatus,
+            phone: n?.phone,
+            phoneStatus: n?.phoneStatus,
+            linkedinUrl: n?.linkedin_url,
+            location: [n?.city, n?.state, n?.country].filter(Boolean).join(", "),
+        },
+        company: n?.organization
+            ? {
+                name: n.organization.name,
+                domain: n.organization.domain,
+                industry: n.organization.industry,
+                employeeRange: n.organization.employeeRange,
+            }
+            : null,
+    };
+}
+export async function bulkEnrichWithProspeo(input) {
+    const api = getApi();
+    if (!input.inputs || input.inputs.length === 0) {
+        throw new Error("inputs array is required");
+    }
+    if (input.inputs.length > 100) {
+        throw new Error("Maximum 100 inputs per request");
+    }
+    const response = await api.post("/api/v3/prospeo/bulk-enrich", {
+        inputs: input.inputs,
+        onlyVerifiedEmail: input.onlyVerifiedEmail ?? true,
+        normalize: true,
+    });
+    return {
+        success: true,
+        totalCost: response.totalCost,
+        summary: response.summary,
+        matched: response.matched.map((m) => ({
+            identifier: m.identifier,
+            name: m.normalized?.name,
+            email: m.normalized?.email,
+            emailStatus: m.normalized?.emailStatus,
+            company: m.normalized?.organization?.name,
+        })),
+        notMatched: response.notMatched,
+        invalidDatapoints: response.invalidDatapoints,
+    };
+}
+export async function getProspeoCredits() {
+    const api = getApi();
+    const response = await api.get("/api/v3/prospeo/account");
+    return {
+        plan: response.currentPlan,
+        remainingCredits: response.remainingCredits,
+        usedCredits: response.usedCredits,
+        renewsInDays: response.nextQuotaRenewalDays,
+    };
+}

package/dist/tools/flow-preflight.d.ts

@@ -0,0 +1,68 @@
+type CreateCampaignPromptPreflightState = {
+    loadedAt: string;
+};
+type ResearchPromptMode = "generic" | "sender" | "prospect";
+type ResearchPromptPreflightState = {
+    loadedAt: string;
+    mode: ResearchPromptMode;
+    subskillName: string;
+};
+type SenderEnrichmentSnapshot = {
+    observedAt: string;
+    enrichmentStatus: "partial" | "complete";
+    hasCaseStudies: boolean;
+    hasProof: boolean;
+};
+type SenderResearchDepth = "minimal-verification" | "deep-proof";
+export declare function markCreateCampaignPromptLoaded(): CreateCampaignPromptPreflightState;
+export declare function markResearchPromptLoaded(mode?: ResearchPromptMode, subskillName?: string): ResearchPromptPreflightState;
+export declare function markSenderEnrichmentObserved(input: {
+    enrichmentStatus: "partial" | "complete";
+    caseStudies?: unknown;
+    proof?: unknown;
+}): SenderEnrichmentSnapshot;
+export declare function markSenderResearchCompleted(input?: {
+    depth?: SenderResearchDepth;
+    proofItemsFound?: number;
+    caseStudyItemsFound?: number;
+    credibilitySignalsFound?: number;
+    notes?: string | null;
+}): {
+    readonly completedAt: string;
+    readonly depth: SenderResearchDepth;
+    readonly proofItemsFound: number;
+    readonly caseStudyItemsFound: number;
+    readonly credibilitySignalsFound: number;
+    readonly notes?: string | null;
+    readonly ok: true;
+};
+export declare function assertCreateCampaignPromptLoaded(): {
+    readonly ok: true;
+    readonly loadedAt: string;
+};
+export declare function assertResearchPromptLoaded(mode?: ResearchPromptMode | "any"): {
+    readonly ok: true;
+    readonly loadedAt: string;
+    readonly mode: ResearchPromptMode;
+    readonly subskillName: string;
+};
+export declare function assertNetNewCreateCampaignResearchReady(): {
+    readonly ok: true;
+    readonly enrichmentStatus: "partial" | "complete";
+    readonly hasCaseStudies: boolean;
+    readonly hasProof: boolean;
+    readonly enrichmentLooksComplete: boolean;
+    readonly usedResearchPrompt: boolean;
+    readonly researchPromptMode: ResearchPromptMode;
+    readonly researchPromptSubskillName: string;
+    readonly researchCompletion: {
+        readonly depth: SenderResearchDepth;
+        readonly proofItemsFound: number;
+        readonly caseStudyItemsFound: number;
+        readonly credibilitySignalsFound: number;
+        readonly completedAt: string;
+    };
+    readonly needsResearch: true;
+};
+export declare function resetFlowPreflightState(): void;
+export {};