@sellable/mcp 0.1.137 → 0.1.138

package/dist/engage-memory.d.ts

@@ -1,3 +1,4 @@
+import { type IdentityMemoryChunk, type IdentityMemoryDirectory } from "./identity-memory.js";
 export interface EngageStyleGuide {
     markdown: string;
     updatedAt: string;
@@ -20,6 +21,18 @@ export interface EngageMemory {
     styleGuide?: EngageStyleGuide;
     provenSearches: ProvenSearch[];
     trackedPeople: TrackedPerson[];
+    identity?: IdentityMemoryChunk;
+    company?: IdentityMemoryChunk;
+    antiAiStyle?: IdentityMemoryChunk;
+    proofLedger?: IdentityMemoryChunk;
+    winsLedger?: IdentityMemoryChunk;
+    storyBank?: IdentityMemoryChunk;
+    answerBank?: IdentityMemoryChunk;
+    contextModes?: IdentityMemoryChunk;
+    decisionRules?: IdentityMemoryChunk;
+    changeLog?: IdentityMemoryChunk;
+    transcripts?: IdentityMemoryDirectory;
+    references?: IdentityMemoryDirectory;
 }
 /** Check if a sender has per-sender config directory. */
 export declare function senderHasConfig(senderId: string): boolean;

package/dist/engage-memory.js

@@ -1,5 +1,7 @@
 import * as fs from "fs";
+import * as os from "os";
 import * as path from "path";
+import { readIdentityMemory, } from "./identity-memory.js";
 // ── Config directory resolution ────────────────────────────────────────────
 function resolveConfigsDir() {
     const candidates = [];
@@ -11,6 +13,7 @@ function resolveConfigsDir() {
         candidates.push(path.resolve(path.dirname(process.argv[1]), "../../.sellable/configs"));
     }
     candidates.push(path.resolve(process.cwd(), ".sellable/configs"));
+    candidates.push(path.resolve(os.homedir(), ".sellable/configs"));
     for (const candidate of candidates) {
         if (fs.existsSync(candidate)) {
             return candidate;
@@ -44,22 +47,21 @@ function writeFile(relPath, content) {
     fs.writeFileSync(fullPath, content);
 }
 // ── Sender-scoped path resolution ─────────────────────────────────────────
-/** Per-sender file paths. When senderId is given, resolves to senders/{id}/file.
- *  Falls back to legacy flat path when senderId is omitted or sender dir doesn't exist. */
+/** Per-sender reads fall back by file so partial sender dirs do not hide flat memory. */
 function senderPath(senderId, fileName, flatFallback) {
     if (senderId) {
-        const senderDir = `senders/${senderId}`;
-        const senderFile = `${senderDir}/${fileName}`;
-        // If sender dir exists, always use it (even if file doesn't exist yet — it'll be created)
-        if (fs.existsSync(path.join(getConfigsDir(), senderDir))) {
-            return senderFile;
-        }
-        // If the file exists in sender dir (dir just created), use it
+        const senderFile = `senders/${senderId}/${fileName}`;
         if (fs.existsSync(path.join(getConfigsDir(), senderFile))) {
             return senderFile;
         }
     }
-    // Fallback to flat path
+    return flatFallback;
+}
+/** Per-sender writes are deterministic when a sender ID is supplied. */
+function senderWritePath(senderId, fileName, flatFallback) {
+    if (senderId) {
+        return `senders/${senderId}/${fileName}`;
+    }
     return flatFallback;
 }
 /** Check if a sender has per-sender config directory. */
@@ -119,39 +121,132 @@ function buildMarkdownTable(headers, rows) {
 // ── Style guide ────────────────────────────────────────────────────────────
 const FLAT_STYLE_CORE_PATH = "writing/styleguide-core.md";
 const STYLE_COMMENTS_PATH = "writing/comments.md";
-function readStyleGuide(senderId) {
+const LEGACY_AUDIENCE_ICP_PATH = "audience/icp.md";
+const LEGACY_FAQS_CORE_PATH = "faqs/core.md";
+function readStyleGuide(senderId, identityMemory) {
     const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
     const core = readFile(corePath);
     // comments.md is always shared
     const comments = readFile(STYLE_COMMENTS_PATH);
-    if (!core && !comments)
-        return undefined;
+    if (!hasCoreIdentityMemory(identityMemory)) {
+        if (!core && !comments)
+            return undefined;
+        const legacyParts = [];
+        if (core)
+            legacyParts.push(core.trim());
+        if (comments)
+            legacyParts.push(comments.trim());
+        return {
+            markdown: legacyParts.join("\n\n"),
+            updatedAt: latestUpdatedAt([corePath, STYLE_COMMENTS_PATH]),
+        };
+    }
     const parts = [];
-    if (core)
-        parts.push(core.trim());
-    if (comments)
-        parts.push(comments.trim());
-    const markdown = parts.join("\n\n");
-    // Use file mtime as updatedAt
-    const coreFullPath = path.join(getConfigsDir(), corePath);
-    const commentsFullPath = path.join(getConfigsDir(), STYLE_COMMENTS_PATH);
-    const coreMtime = fs.existsSync(coreFullPath)
-        ? fs.statSync(coreFullPath).mtime
-        : new Date(0);
-    const commentsMtime = fs.existsSync(commentsFullPath)
-        ? fs.statSync(commentsFullPath).mtime
-        : new Date(0);
-    const updatedAt = new Date(Math.max(coreMtime.getTime(), commentsMtime.getTime())).toISOString();
-    return { markdown, updatedAt };
+    const sourcePaths = [];
+    parts.push("# Sellable Core Identity Memory");
+    appendCoreSection(parts, sourcePaths, "Core Identity", identityMemory.identity);
+    appendCoreSection(parts, sourcePaths, "Core Company", identityMemory.company);
+    appendCoreSection(parts, sourcePaths, "Core Anti-AI Writing Style", identityMemory.antiAiStyle);
+    appendCoreSection(parts, sourcePaths, "Core Proof Ledger", identityMemory.proofLedger);
+    appendCoreSection(parts, sourcePaths, "Core Wins Ledger", identityMemory.winsLedger);
+    appendCoreSection(parts, sourcePaths, "Core Story Bank", identityMemory.storyBank);
+    appendCoreSection(parts, sourcePaths, "Core Answer Bank", identityMemory.answerBank);
+    appendCoreSection(parts, sourcePaths, "Core Context Modes", identityMemory.contextModes);
+    appendCoreSection(parts, sourcePaths, "Core Decision Rules", identityMemory.decisionRules);
+    appendCoreSection(parts, sourcePaths, "Core Change Log", identityMemory.changeLog);
+    appendCoreDirectoryIndex(parts, sourcePaths, "Core Transcripts Index", identityMemory.transcripts);
+    appendCoreDirectoryIndex(parts, sourcePaths, "Core References Index", identityMemory.references);
+    if (core) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: senderId
+                ? "Legacy Compatibility: Connected Sender Style Guide"
+                : "Legacy Compatibility: Style Guide",
+            relativePath: corePath,
+            markdown: core,
+        });
+    }
+    if (comments) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: "Legacy Compatibility: Comment Rules",
+            relativePath: STYLE_COMMENTS_PATH,
+            markdown: comments,
+        });
+    }
+    const legacyAudienceIcp = readFile(LEGACY_AUDIENCE_ICP_PATH);
+    if (!identityMemory.company && legacyAudienceIcp) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: "Legacy Compatibility: Audience ICP",
+            relativePath: LEGACY_AUDIENCE_ICP_PATH,
+            markdown: legacyAudienceIcp,
+        });
+    }
+    const legacyFaqsCore = readFile(LEGACY_FAQS_CORE_PATH);
+    if (!identityMemory.proofLedger && legacyFaqsCore) {
+        appendCompatibilitySection(parts, sourcePaths, {
+            title: "Legacy Compatibility: FAQ Proof",
+            relativePath: LEGACY_FAQS_CORE_PATH,
+            markdown: legacyFaqsCore,
+        });
+    }
+    return {
+        markdown: parts.join("\n\n"),
+        updatedAt: latestUpdatedAt(sourcePaths),
+    };
+}
+function hasCoreIdentityMemory(identityMemory) {
+    return Boolean(identityMemory.identity ||
+        identityMemory.company ||
+        identityMemory.antiAiStyle ||
+        identityMemory.proofLedger ||
+        identityMemory.winsLedger ||
+        identityMemory.storyBank ||
+        identityMemory.answerBank ||
+        identityMemory.contextModes ||
+        identityMemory.decisionRules ||
+        identityMemory.changeLog ||
+        identityMemory.transcripts?.index ||
+        identityMemory.references?.index);
+}
+function appendCoreSection(parts, sourcePaths, title, chunk) {
+    if (!chunk)
+        return;
+    parts.push(`## ${title}: ${chunk.source.relativePath}\n\n${chunk.markdown.trim()}`);
+    sourcePaths.push(chunk.source.relativePath);
+}
+function appendCoreDirectoryIndex(parts, sourcePaths, title, directory) {
+    if (!directory?.index)
+        return;
+    appendCoreSection(parts, sourcePaths, title, directory.index);
+}
+function appendCompatibilitySection(parts, sourcePaths, section) {
+    parts.push(`## ${section.title} (${section.relativePath})\n\n${section.markdown.trim()}`);
+    sourcePaths.push(section.relativePath);
+}
+function latestUpdatedAt(relativePaths) {
+    const latest = relativePaths.reduce((max, relativePath) => {
+        const fullPath = path.join(getConfigsDir(), relativePath);
+        if (!fs.existsSync(fullPath))
+            return max;
+        return Math.max(max, fs.statSync(fullPath).mtime.getTime());
+    }, 0);
+    return new Date(latest).toISOString();
 }
 export function getEngageMemory(senderId) {
-    const styleGuide = readStyleGuide(senderId);
+    const identityMemory = readIdentityMemory({ connectedSenderId: senderId });
+    const styleGuide = readStyleGuide(senderId, identityMemory);
     const provenSearches = readProvenSearches(senderId);
     const trackedPeople = readTrackedPeople(senderId);
-    return { memory: { styleGuide, provenSearches, trackedPeople } };
+    return {
+        memory: {
+            styleGuide,
+            provenSearches,
+            trackedPeople,
+            ...identityMemory,
+        },
+    };
 }
 export function setStyleGuide(markdown, senderId) {
-    const corePath = senderPath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
+    const corePath = senderWritePath(senderId, "styleguide-core.md", FLAT_STYLE_CORE_PATH);
     writeFile(corePath, markdown + "\n");
     const updatedAt = new Date().toISOString();
     return { styleGuide: { markdown, updatedAt } };
@@ -202,7 +297,7 @@ function writeProvenSearches(searches, senderId) {
         Yielded: String(s.totalYielded),
         "Hit Rate": s.avgHitRate.toFixed(2),
     }));
-    const filePath = senderPath(senderId, "proven-searches.md", FLAT_PROVEN_SEARCHES_PATH);
+    const filePath = senderWritePath(senderId, "proven-searches.md", FLAT_PROVEN_SEARCHES_PATH);
     const table = buildMarkdownTable(PROVEN_HEADERS, rows);
     writeFile(filePath, PROVEN_SEARCHES_HEADER + table + "\n");
 }
@@ -251,7 +346,7 @@ const INFLUENCER_HEADERS = [
     "Include in Discovery",
 ];
 function readTrackedPeople(senderId) {
-    const filePath = senderPath(senderId, "influencers.md", FLAT_INFLUENCERS_PATH);
+    const filePath = senderWritePath(senderId, "influencers.md", FLAT_INFLUENCERS_PATH);
     const content = readFile(filePath);
     if (!content)
         return [];

package/dist/identity-compiler.d.ts

@@ -0,0 +1,119 @@
+export interface IdentityGeneratedSectionProposal {
+    relativePath: string;
+    key: string;
+    markdown: string;
+}
+export interface IdentityProofEntryProposal {
+    key?: string;
+    claim: string;
+    source?: string;
+    confidence?: string;
+    allowedUse?: string;
+    privacy?: string;
+    notes?: string;
+}
+export interface IdentityWinEntryProposal {
+    key?: string;
+    title: string;
+    proofType?: string;
+    outcome?: string;
+    source?: string;
+    permission?: string;
+    confidence?: string;
+    publicSafety?: string;
+    allowedUse?: string;
+    notes?: string;
+}
+export interface IdentityStoryEntryProposal {
+    key?: string;
+    title: string;
+    setup?: string;
+    moment?: string;
+    lesson?: string;
+    source?: string;
+    contexts?: string;
+    privacy?: string;
+    notes?: string;
+}
+export interface IdentityAnswerEntryProposal {
+    key?: string;
+    question: string;
+    answer: string;
+    topicTags?: string;
+    source?: string;
+    useContexts?: string;
+    confidence?: string;
+    privacy?: string;
+    derivedMemoryLinks?: string;
+}
+export interface IdentityRuleEntryProposal {
+    key?: string;
+    title: string;
+    rule: string;
+    source?: string;
+}
+export interface IdentityAntiAiBanProposal {
+    key?: string;
+    pattern: string;
+    rule: string;
+    context?: string;
+    source?: string;
+}
+export interface IdentityChangeLogEntryProposal {
+    key?: string;
+    date: string;
+    source?: string;
+    changed: string;
+    newRule: string;
+}
+export interface IdentityTranscriptIndexRowProposal {
+    key?: string;
+    title: string;
+    sourcePath: string;
+    date?: string;
+    speakers?: string;
+    targetSpeaker?: string;
+    topics?: string;
+    contextMode?: string;
+    sampleType?: string;
+    sensitivity?: string;
+}
+export interface IdentityTopicTranscriptProposal {
+    key?: string;
+    topicSlug: string;
+    title: string;
+    sourcePath: string;
+    targetSpeaker?: string;
+    excerpt: string;
+}
+export interface IdentityReferenceRowProposal {
+    key?: string;
+    category?: string;
+    indexPath?: string;
+    title: string;
+    source: string;
+    copiedPath?: string;
+    tags?: string;
+    whyItMatters?: string;
+    usageContexts?: string;
+    lastReviewed?: string;
+}
+export interface IdentityCompilerProposal {
+    configsDir?: string;
+    generatedSections?: IdentityGeneratedSectionProposal[];
+    proofEntries?: IdentityProofEntryProposal[];
+    winsEntries?: IdentityWinEntryProposal[];
+    storyEntries?: IdentityStoryEntryProposal[];
+    answerEntries?: IdentityAnswerEntryProposal[];
+    decisionRules?: IdentityRuleEntryProposal[];
+    antiAiBans?: IdentityAntiAiBanProposal[];
+    changeLogEntries?: IdentityChangeLogEntryProposal[];
+    transcriptIndexRows?: IdentityTranscriptIndexRowProposal[];
+    topicTranscripts?: IdentityTopicTranscriptProposal[];
+    referenceRows?: IdentityReferenceRowProposal[];
+}
+export interface IdentityCompilerResult {
+    configsDir: string;
+    filesChanged: string[];
+}
+export declare function applyIdentityCompilerProposal(proposal: IdentityCompilerProposal): IdentityCompilerResult;