@sellable/mcp 0.1.239 → 0.1.242

package/dist/tools/content-posts.js

@@ -80,13 +80,18 @@ export const contentPostToolDefinitions = [
     },
     {
         name: "save_post_draft",
-        description: "Save a validated LinkedIn post draft under ~/.sellable/content/linkedin/drafts.",
+        description: "Save a validated LinkedIn post draft under ~/.sellable/content/linkedin/drafts. Use versioned draft IDs for multiple drafts of the same idea.",
         inputSchema: {
             type: "object",
             properties: {
                 draftId: { type: "string" },
                 ideaId: { type: "string" },
                 hookResearchId: { type: "string" },
+                priorDraftId: {
+                    type: "string",
+                    description: "Optional previous draft ID this draft is trying to improve on.",
+                },
+                iteration: draftIterationSchema(),
                 title: { type: "string" },
                 body: { type: "string" },
                 validationReceipt: {
@@ -99,11 +104,38 @@ export const contentPostToolDefinitions = [
             additionalProperties: false,
         },
     },
+    {
+        name: "update_post_draft",
+        description: "Update an existing LinkedIn post draft in place while preserving omitted fields. Useful for adding iteration receipts, status changes, or final copy edits without rewriting the whole artifact.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                draftId: { type: "string" },
+                hookResearchId: { type: "string" },
+                priorDraftId: { type: "string" },
+                iteration: draftIterationSchema(),
+                title: { type: "string" },
+                body: { type: "string" },
+                validationReceipt: {
+                    description: "Markdown string or structured object to replace the saved validation receipt.",
+                },
+                status: { type: "string" },
+                updatedAt: { type: "string" },
+            },
+            required: ["draftId"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "list_post_drafts",
         description: "List saved LinkedIn post drafts with compact sanitized previews. Use get_post_draft for full Markdown.",
         inputSchema: listInputSchema(),
     },
+    {
+        name: "list_post_draft_iterations",
+        description: "List all draft versions for one idea, including iteration scores, verdicts, prior draft links, status, and sanitized previews.",
+        inputSchema: idInputSchema("ideaId"),
+    },
     {
         name: "get_post_draft",
         description: "Read one saved LinkedIn post draft by ID.",
@@ -121,11 +153,47 @@ export const contentPostToolDefinitions = [
                 publishedAt: { type: "string" },
                 finalText: { type: "string" },
                 title: { type: "string" },
+                updateDraftStatus: {
+                    type: "boolean",
+                    description: "Defaults to true when draftId is supplied. Marks the source draft as published and links it to the published record.",
+                },
             },
             required: ["publishUrl"],
             additionalProperties: false,
         },
     },
+    {
+        name: "get_published_post",
+        description: "Read one published LinkedIn post record by ID. If year is omitted, searches all published year folders.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                publishedPostId: { type: "string" },
+                year: { type: "string" },
+            },
+            required: ["publishedPostId"],
+            additionalProperties: false,
+        },
+    },
+    {
+        name: "update_published_post_metrics",
+        description: "Append a metrics snapshot to a published LinkedIn post record and update latest metric fields for post-performance learning.",
+        inputSchema: {
+            type: "object",
+            properties: {
+                publishedPostId: { type: "string" },
+                year: { type: "string" },
+                capturedAt: { type: "string" },
+                metrics: {
+                    type: "object",
+                    additionalProperties: true,
+                },
+                note: { type: "string" },
+            },
+            required: ["publishedPostId", "metrics"],
+            additionalProperties: false,
+        },
+    },
     {
         name: "list_published_posts",
         description: "List published LinkedIn post records with compact sanitized previews.",
@@ -152,6 +220,13 @@ function idInputSchema(propertyName) {
         additionalProperties: false,
     };
 }
+function draftIterationSchema() {
+    return {
+        type: "object",
+        description: "Optional draft iteration metadata: version, priorDraftId, changeIntent, whatChanged, whatImproved, whatGotWorse, score, and verdict.",
+        additionalProperties: true,
+    };
+}
 export function resolveContentRoot() {
     const envValue = process.env[CONTENT_ROOT_ENV]?.trim();
     if (envValue) {
@@ -274,14 +349,13 @@ export function savePostDraftTool(input) {
     const safeResearchId = input.hookResearchId
         ? normalizeArtifactId(input.hookResearchId, "hookResearchId")
         : undefined;
+    const iteration = normalizeDraftIteration(input.iteration, input.priorDraftId);
     requireString(input.body, "body");
     const id = input.draftId ??
         `draft_${dateStamp(now)}_${slugify(input.title || safeIdeaId)}_v1`;
     const safeId = normalizeArtifactId(id, "draftId");
     const status = input.status || "draft";
-    if (!["draft", "ready", "needs_revision"].includes(status)) {
-        throw new Error(`Unsupported draft status: ${status}`);
-    }
+    assertDraftStatus(status);
     const metadata = {
         id: safeId,
         type: "draft",
@@ -289,6 +363,9 @@ export function savePostDraftTool(input) {
         title: input.title,
         ideaId: safeIdeaId,
         hookResearchId: safeResearchId,
+        draftVersion: iteration?.version || inferDraftVersion(safeId),
+        priorDraftId: iteration?.priorDraftId,
+        iteration,
         createdAt: now,
         updatedAt: now,
     };
@@ -304,13 +381,98 @@ export function savePostDraftTool(input) {
         status,
         ideaId: safeIdeaId,
         hookResearchId: safeResearchId,
+        draftVersion: metadata.draftVersion,
+        priorDraftId: metadata.priorDraftId,
+        iterationScore: iteration?.score,
+        iterationVerdict: iteration?.verdict,
         updatedAt: now,
         preview: sanitizedPreview(input.body),
     };
 }
+export function updatePostDraftTool(input) {
+    const safeDraftId = normalizeArtifactId(input.draftId, "draftId");
+    const relativePath = `${RELATIVE_DIRS.drafts}/${safeDraftId}.md`;
+    const existing = readArtifactIfExists(relativePath);
+    if (!existing) {
+        throw new Error(`No draftId found for ID: ${safeDraftId}`);
+    }
+    const now = normalizeDate(input.updatedAt);
+    const existingBody = extractMarkdownSection(existing.markdown, "Draft Body");
+    const existingReceipt = extractMarkdownSection(existing.markdown, "Validation Receipt");
+    const body = input.body ?? existingBody;
+    requireString(body, "body");
+    const validationReceipt = input.validationReceipt === undefined
+        ? existingReceipt
+        : formatReceipt(input.validationReceipt);
+    requireString(validationReceipt, "validationReceipt");
+    const safeResearchId = input.hookResearchId
+        ? normalizeArtifactId(input.hookResearchId, "hookResearchId")
+        : existing.metadata.hookResearchId;
+    const iteration = normalizeDraftIteration(input.iteration ?? existing.metadata.iteration, input.priorDraftId ?? existing.metadata.priorDraftId);
+    const status = input.status || existing.metadata.status || "draft";
+    assertDraftStatus(status);
+    const metadata = {
+        ...existing.metadata,
+        status,
+        title: input.title ?? existing.metadata.title,
+        hookResearchId: safeResearchId,
+        draftVersion: iteration?.version || existing.metadata.draftVersion || inferDraftVersion(safeDraftId),
+        priorDraftId: iteration?.priorDraftId,
+        iteration,
+        updatedAt: now,
+    };
+    const markdown = buildMarkdown(metadata, [
+        ["Draft Body", body],
+        ["Validation Receipt", validationReceipt],
+    ]);
+    writeArtifact(relativePath, markdown);
+    return {
+        id: safeDraftId,
+        path: relativePath,
+        status,
+        ideaId: metadata.ideaId,
+        hookResearchId: safeResearchId,
+        draftVersion: metadata.draftVersion,
+        priorDraftId: metadata.priorDraftId,
+        iterationScore: iteration?.score,
+        iterationVerdict: iteration?.verdict,
+        updatedAt: now,
+        preview: sanitizedPreview(body),
+    };
+}
 export function listPostDraftsTool(input) {
     return listArtifacts(RELATIVE_DIRS.drafts, "draft", input?.limit);
 }
+export function listPostDraftIterationsTool(input) {
+    const safeIdeaId = normalizeArtifactId(input.ideaId, "ideaId");
+    const drafts = readArtifactsFromDir(RELATIVE_DIRS.drafts)
+        .filter((artifact) => artifact.metadata.type === "draft" &&
+        artifact.metadata.ideaId === safeIdeaId)
+        .map((artifact) => {
+        const iteration = artifact.metadata.iteration ||
+            extractIterationFromReceipt(extractMarkdownSection(artifact.markdown, "Validation Receipt"));
+        return {
+            id: artifact.metadata.id,
+            type: artifact.metadata.type,
+            status: artifact.metadata.status,
+            title: artifact.metadata.title,
+            path: artifact.relativePath,
+            ideaId: artifact.metadata.ideaId,
+            hookResearchId: artifact.metadata.hookResearchId,
+            draftVersion: artifact.metadata.draftVersion ||
+                iteration?.version ||
+                inferDraftVersion(artifact.metadata.id),
+            priorDraftId: artifact.metadata.priorDraftId || iteration?.priorDraftId,
+            iterationScore: iteration?.score,
+            iterationVerdict: iteration?.verdict,
+            publishedPostId: artifact.metadata.publishedPostId,
+            publishedAt: artifact.metadata.publishedAt,
+            updatedAt: artifact.metadata.updatedAt,
+            preview: sanitizedPreview(previewBasis(artifact.markdown)),
+        };
+    });
+    return drafts.sort(compareDraftIterations);
+}
 export function getPostDraftTool(input) {
     return getArtifact(RELATIVE_DIRS.drafts, input.draftId, "draftId");
 }
@@ -327,6 +489,14 @@ export function markPostPublishedTool(input) {
     const relativePath = `${RELATIVE_DIRS.published}/${year}/${safeId}.md`;
     const existing = readArtifactIfExists(relativePath);
     const createdAt = existing?.metadata.createdAt || publishedAt;
+    const finalText = input.finalText ?? extractMarkdownSection(existing?.markdown || "", "Final Text");
+    const publishMetadata = readJsonSection(existing?.markdown || "", "Publish Metadata", {});
+    const futureMetrics = readJsonSection(existing?.markdown || "", "Future Metrics", {
+        impressions: null,
+        reactions: null,
+        comments: null,
+        snapshots: [],
+    });
     const metadata = {
         id: safeId,
         type: "published_post",
@@ -340,27 +510,23 @@ export function markPostPublishedTool(input) {
         updatedAt: publishedAt,
     };
     const markdown = buildMarkdown(metadata, [
-        ["Final Text", input.finalText || ""],
+        ["Final Text", finalText],
         [
             "Publish Metadata",
             jsonBlock(stripUndefined({
+                ...publishMetadata,
                 draftId: safeDraftId,
                 publishUrl: input.publishUrl,
                 activityId: activityId || undefined,
                 publishedAt,
             })),
         ],
-        [
-            "Future Metrics",
-            jsonBlock({
-                impressions: null,
-                reactions: null,
-                comments: null,
-                snapshots: [],
-            }),
-        ],
+        ["Future Metrics", jsonBlock(futureMetrics)],
     ]);
     writeArtifact(relativePath, markdown);
+    if (safeDraftId && input.updateDraftStatus !== false) {
+        markDraftAsPublished(safeDraftId, safeId, publishedAt);
+    }
     return {
         id: safeId,
         path: relativePath,
@@ -369,7 +535,65 @@ export function markPostPublishedTool(input) {
         publishUrl: input.publishUrl,
         publishedAt,
         updatedAt: publishedAt,
-        preview: sanitizedPreview(input.finalText || input.publishUrl),
+        preview: sanitizedPreview(finalText || input.publishUrl),
+    };
+}
+export function getPublishedPostTool(input) {
+    const found = findPublishedArtifact(input.publishedPostId, input.year);
+    if (!found) {
+        throw new Error(`No publishedPostId found for ID: ${normalizeArtifactId(input.publishedPostId, "publishedPostId")}`);
+    }
+    return {
+        id: found.artifact.metadata.id,
+        path: found.relativePath,
+        metadata: found.artifact.metadata,
+        markdown: found.artifact.markdown,
+    };
+}
+export function updatePublishedPostMetricsTool(input) {
+    if (!input.metrics || typeof input.metrics !== "object") {
+        throw new Error("metrics is required.");
+    }
+    const found = findPublishedArtifact(input.publishedPostId, input.year);
+    if (!found) {
+        throw new Error(`No publishedPostId found for ID: ${normalizeArtifactId(input.publishedPostId, "publishedPostId")}`);
+    }
+    const capturedAt = normalizeDate(input.capturedAt);
+    const finalText = extractMarkdownSection(found.artifact.markdown, "Final Text");
+    const publishMetadata = readJsonSection(found.artifact.markdown, "Publish Metadata", {});
+    const futureMetrics = readJsonSection(found.artifact.markdown, "Future Metrics", {});
+    const existingSnapshots = Array.isArray(futureMetrics.snapshots)
+        ? futureMetrics.snapshots
+        : [];
+    const snapshot = stripUndefined({
+        capturedAt,
+        metrics: input.metrics,
+        note: input.note,
+    });
+    const nextMetrics = {
+        ...futureMetrics,
+        ...input.metrics,
+        lastCapturedAt: capturedAt,
+        snapshots: [...existingSnapshots, snapshot],
+    };
+    const metadata = {
+        ...found.artifact.metadata,
+        updatedAt: capturedAt,
+    };
+    const markdown = buildMarkdown(metadata, [
+        ["Final Text", finalText],
+        ["Publish Metadata", jsonBlock(publishMetadata)],
+        ["Future Metrics", jsonBlock(nextMetrics)],
+    ]);
+    writeArtifact(found.relativePath, markdown);
+    return {
+        id: metadata.id,
+        path: found.relativePath,
+        status: metadata.status,
+        updatedAt: capturedAt,
+        metrics: input.metrics,
+        snapshotsCount: existingSnapshots.length + 1,
+        preview: sanitizedPreview(finalText || String(metadata.publishUrl || "")),
     };
 }
 export function listPublishedPostsTool(input) {
@@ -423,8 +647,135 @@ function summarizeArtifacts(artifacts, limit) {
         path: artifact.relativePath,
         updatedAt: artifact.metadata.updatedAt,
         preview: sanitizedPreview(previewBasis(artifact.markdown)),
+        ideaId: artifact.metadata.ideaId,
+        hookResearchId: artifact.metadata.hookResearchId,
+        draftVersion: artifact.metadata.draftVersion,
+        priorDraftId: artifact.metadata.priorDraftId,
+        iterationScore: artifact.metadata.iteration?.score,
+        iterationVerdict: artifact.metadata.iteration?.verdict,
+        publishedPostId: artifact.metadata.publishedPostId,
+        publishedAt: artifact.metadata.publishedAt,
     }));
 }
+function assertDraftStatus(status) {
+    if (!["draft", "ready", "needs_revision", "published", "archived"].includes(status)) {
+        throw new Error(`Unsupported draft status: ${status}`);
+    }
+}
+function normalizeDraftIteration(iteration, priorDraftId) {
+    if (!iteration && !priorDraftId)
+        return undefined;
+    const safePriorDraftId = priorDraftId
+        ? normalizeArtifactId(priorDraftId, "priorDraftId")
+        : iteration?.priorDraftId
+            ? normalizeArtifactId(iteration.priorDraftId, "priorDraftId")
+            : undefined;
+    return stripUndefined({
+        ...iteration,
+        priorDraftId: safePriorDraftId,
+    });
+}
+function inferDraftVersion(draftId) {
+    const match = draftId.match(/(?:^|_)v(\d+)(?:$|_)/i);
+    return match ? `v${match[1]}` : undefined;
+}
+function compareDraftIterations(a, b) {
+    const aVersion = numericVersion(a.draftVersion);
+    const bVersion = numericVersion(b.draftVersion);
+    if (aVersion !== bVersion)
+        return aVersion - bVersion;
+    const updated = String(a.updatedAt).localeCompare(String(b.updatedAt));
+    if (updated !== 0)
+        return updated;
+    return a.id.localeCompare(b.id);
+}
+function numericVersion(version) {
+    const match = version?.match(/^v(\d+)$/i);
+    return match ? Number(match[1]) : Number.MAX_SAFE_INTEGER;
+}
+function extractIterationFromReceipt(receipt) {
+    if (!receipt.includes("iteration:"))
+        return undefined;
+    const version = receipt.match(/^\s*version:\s*(\S+)/m)?.[1];
+    const priorDraftId = receipt.match(/^\s*priorDraftId:\s*(\S+)/m)?.[1];
+    const verdict = receipt.match(/^\s*verdict:\s*(\S+)/m)?.[1];
+    const scoreBlock = receipt.match(/^\s*score:\s*\n((?:\s{4}[A-Za-z][A-Za-z0-9_-]*:\s*[-\d.]+\n?)+)/m)?.[1];
+    const score = scoreBlock
+        ? Object.fromEntries(scoreBlock
+            .trim()
+            .split(/\n/)
+            .map((line) => line.trim().split(/:\s*/))
+            .filter(([key, value]) => key && value)
+            .map(([key, value]) => [key, Number(value)]))
+        : undefined;
+    return stripUndefined({
+        version,
+        priorDraftId: priorDraftId && priorDraftId !== "none" ? priorDraftId : undefined,
+        verdict,
+        score,
+    });
+}
+function extractMarkdownSection(markdown, heading) {
+    const escaped = heading.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+    const match = markdown.match(new RegExp(`(?:^|\\n)## ${escaped}\\n\\n([\\s\\S]*?)(?=\\n## |$)`));
+    return match?.[1]?.trimEnd() ?? "";
+}
+function readJsonSection(markdown, heading, fallback) {
+    const section = extractMarkdownSection(markdown, heading);
+    const match = section.match(/```json\n([\s\S]*?)\n```/);
+    if (!match)
+        return fallback;
+    try {
+        return JSON.parse(match[1]);
+    }
+    catch {
+        return fallback;
+    }
+}
+function findPublishedArtifact(publishedPostId, year) {
+    const safeId = normalizeArtifactId(publishedPostId, "publishedPostId");
+    if (year) {
+        if (!/^\d{4}$/.test(year))
+            throw new Error("year must be YYYY.");
+        const relativePath = `${RELATIVE_DIRS.published}/${year}/${safeId}.md`;
+        const artifact = readArtifactIfExists(relativePath);
+        return artifact ? { artifact, relativePath } : null;
+    }
+    const root = resolveContentRoot();
+    ensureContentLayout(root);
+    const publishedRoot = safePath(root, RELATIVE_DIRS.published);
+    if (!fs.existsSync(publishedRoot))
+        return null;
+    for (const yearDir of fs.readdirSync(publishedRoot).sort()) {
+        if (!/^\d{4}$/.test(yearDir))
+            continue;
+        const relativePath = `${RELATIVE_DIRS.published}/${yearDir}/${safeId}.md`;
+        const artifact = readArtifactIfExists(relativePath);
+        if (artifact)
+            return { artifact, relativePath };
+    }
+    return null;
+}
+function markDraftAsPublished(draftId, publishedPostId, publishedAt) {
+    const relativePath = `${RELATIVE_DIRS.drafts}/${draftId}.md`;
+    const existing = readArtifactIfExists(relativePath);
+    if (!existing)
+        return;
+    const body = extractMarkdownSection(existing.markdown, "Draft Body");
+    const receipt = extractMarkdownSection(existing.markdown, "Validation Receipt");
+    const metadata = {
+        ...existing.metadata,
+        status: "published",
+        publishedPostId,
+        publishedAt,
+        updatedAt: publishedAt,
+    };
+    const markdown = buildMarkdown(metadata, [
+        ["Draft Body", body],
+        ["Validation Receipt", receipt],
+    ]);
+    writeArtifact(relativePath, markdown);
+}
 function readArtifactsFromDir(relativeDir) {
     const root = resolveContentRoot();
     ensureContentLayout(root);