@agifyai/leadify-mcp 8.5.4 → 8.6.1

package/dist/tools/context_workspace.js

@@ -1,15 +1,43 @@
 import { z } from "zod";
 import { getClient } from "../client.js";
 import { handleToolError, toolResult } from "../types.js";
-const CONTEXT_KINDS = ["company_brain", "gtm_playbook"];
+const CONTEXT_KIND = "company_brain";
 const MAX_READINESS_ISSUES = 20;
-const kindSchema = z.enum(CONTEXT_KINDS);
-const sectionSchema = z.object({
-    value: z.unknown(),
+const ACTIVE_CONTEXT_SECTIONS = [
+    "identity",
+    "positioning",
+    "allowedVocabulary",
+    "prohibitedVocabulary",
+    "legalConstraints",
+];
+const shortText = z.string().trim().max(500);
+const longText = z.string().trim().max(20_000);
+const section = (value) => z.object({
+    value,
     evidenceIds: z.array(z.string().min(1)).max(100),
     approved: z.boolean(),
 }).strict();
-const sectionPatchSchema = z.record(z.string().min(1), sectionSchema).refine(sections => Object.keys(sections).length > 0, "At least one section is required");
+const sectionPatchSchema = z.object({
+    identity: section(z.object({
+        companyName: shortText.optional(),
+        website: shortText.optional(),
+        industry: shortText.optional(),
+        summary: longText.optional(),
+    }).strict()).optional(),
+    positioning: section(z.object({
+        statement: longText.optional(),
+        elevatorPitch: longText.optional(),
+        geographies: z.array(shortText).max(50).optional(),
+    }).strict()).optional(),
+    allowedVocabulary: section(z.array(shortText).max(100)).optional(),
+    prohibitedVocabulary: section(z.array(shortText).max(100)).optional(),
+    legalConstraints: section(z.array(z.object({
+        id: z.string().trim().min(1).max(100),
+        title: shortText,
+        description: longText.optional(),
+    }).strict()).max(50)).optional(),
+}).strict()
+    .refine((sections) => Object.keys(sections).length > 0, "At least one active section is required");
 function compactReadiness(readiness) {
     if (!readiness || typeof readiness !== "object" || Array.isArray(readiness))
         return readiness;
@@ -25,6 +53,12 @@ function compactReadiness(readiness) {
             : {}),
     };
 }
+function activeContent(content) {
+    const source = record(content);
+    return Object.fromEntries(ACTIVE_CONTEXT_SECTIONS
+        .filter(section => Object.prototype.hasOwnProperty.call(source, section))
+        .map(section => [section, source[section]]));
+}
 function compactDraft(draft) {
     if (!draft || typeof draft !== "object" || Array.isArray(draft))
         return draft;
@@ -34,7 +68,7 @@ function compactDraft(draft) {
         base_version: source.baseVersion,
         rollback_from_version: source.rollbackFromVersion,
         readiness: compactReadiness(source.readiness),
-        content: source.content,
+        content: activeContent(source.content),
         created_at: source.createdAt,
         updated_at: source.updatedAt,
     };
@@ -47,7 +81,7 @@ function compactPublished(published) {
         version: source.version,
         source_draft_id: source.sourceDraftId,
         readiness: compactReadiness(source.readiness),
-        content: source.content,
+        content: activeContent(source.content),
         published_at: source.publishedAt,
     };
 }
@@ -57,10 +91,19 @@ export function projectContextWorkspaceRead(data) {
         ? data
         : {};
     const published = Array.isArray(source.published) ? source.published : [];
+    if (source.kind !== undefined && source.kind !== CONTEXT_KIND) {
+        throw new Error("Only company_brain remains exposed by the MCP Context Workspace.");
+    }
+    const latestPublished = published.reduce((latest, candidate) => {
+        const current = record(candidate);
+        const currentVersion = typeof current.version === "number" ? current.version : -1;
+        const latestVersion = typeof latest?.version === "number" ? latest.version : -1;
+        return currentVersion > latestVersion ? current : latest;
+    }, null);
     return {
-        kind: source.kind,
+        kind: CONTEXT_KIND,
         draft: compactDraft(source.draft),
-        latest_published: compactPublished(published[0] ?? null),
+        latest_published: compactPublished(latestPublished),
         published_version_count: published.length,
         ...(published.length > 1 ? { historical_versions_omitted: published.length - 1 } : {}),
     };
@@ -82,20 +125,34 @@ function mergeSections(read, sections) {
     const published = Array.isArray(state.published) ? state.published : [];
     // Start a new draft from the latest published document, then change only the
     // named sections. This preserves every untouched section across revisions.
-    const base = Object.keys(draft).length > 0
+    const latestPublished = published.reduce((latest, candidate) => {
+        const current = record(candidate);
+        const currentVersion = typeof current.version === "number" ? current.version : -1;
+        const latestVersion = typeof latest?.version === "number" ? latest.version : -1;
+        return currentVersion > latestVersion ? current : latest;
+    }, null);
+    const rawBase = Object.keys(draft).length > 0
         ? record(draft.content)
-        : record(record(published[0]).content);
-    return { ...base, ...sections };
+        : record(latestPublished?.content);
+    return { ...activeContent(rawBase), ...sections };
+}
+function assertActiveSections(sections) {
+    const allowed = new Set(ACTIVE_CONTEXT_SECTIONS);
+    const frozen = Object.keys(sections).filter(section => !allowed.has(section));
+    if (frozen.length > 0) {
+        throw new Error(`PRD-1415 strict ownership: company_brain.${frozen.sort().join(", company_brain.")} is historical and cannot be edited.`);
+    }
 }
 async function updateSections(client, input) {
-    const read = await client.get(`/api/context-workspace/${input.kind}`, new URLSearchParams({ organizationId: input.organizationId }));
+    assertActiveSections(input.sections);
+    const read = await client.get(`/api/context-workspace/${CONTEXT_KIND}`, new URLSearchParams({ organizationId: input.organizationId }));
     const actualRevision = currentRevision(record(read).draft);
     if (actualRevision !== input.expectedRevision) {
         throw new Error(`Revision conflict before write: expected ${input.expectedRevision}, current ${actualRevision}. Re-read and retry without overwriting concurrent sections.`);
     }
     return client.put("/api/context-workspace/draft", {
         organizationId: input.organizationId,
-        kind: input.kind,
+        kind: CONTEXT_KIND,
         content: mergeSections(read, input.sections),
         expectedRevision: input.expectedRevision,
         idempotencyKey: input.idempotencyKey,
@@ -135,50 +192,49 @@ export function registerContextWorkspaceTools(server, client = getClient()) {
     });
     server.registerTool("get_context_workspace", {
         title: "Read canonical versioned Context Workspace",
-        description: "Read the canonical Leadify Context Workspace for one explicitly selected organization and kind. " +
-            "Returns the current draft plus the latest published Company Brain or GTM Playbook, with bounded readiness metadata. " +
-            "Use this for every Leadify workflow. The Data Room is no longer exposed by this MCP.",
+        description: "Read the versioned Company Brain for one explicitly selected organization. " +
+            "Returns the current draft plus the latest published version, with bounded readiness metadata. " +
+            "Verticals, Offers and Personas use their dedicated non-versioned tools; historical GTM Playbook rows are not exposed.",
         inputSchema: {
             organization_id: z.string().trim().min(1).describe("Required organization ID. Always select it explicitly; there is no default tenant."),
-            kind: kindSchema.describe("Canonical workspace document: `company_brain` or `gtm_playbook`."),
         },
         annotations: { readOnlyHint: true },
-    }, async ({ organization_id, kind }) => {
+    }, async ({ organization_id }) => {
         try {
             const params = new URLSearchParams({ organizationId: organization_id });
-            const data = await client.get(`/api/context-workspace/${kind}`, params);
+            const data = await client.get(`/api/context-workspace/${CONTEXT_KIND}`, params);
             return toolResult(projectContextWorkspaceRead(data));
         }
         catch (error) {
             return handleToolError(error);
         }
     });
-    const sectionTools = [
-        { name: "update_company_brain_sections", kind: "company_brain", title: "Update Company Brain sections" },
-        { name: "update_gtm_playbook_sections", kind: "gtm_playbook", title: "Update GTM Playbook sections" },
-    ];
-    for (const tool of sectionTools) {
-        server.registerTool(tool.name, {
-            title: tool.title,
-            description: "Update only the named canonical sections. The MCP re-reads the current draft (or latest published version), merges only those sections, " +
-                "and saves with optimistic concurrency. Unnamed sections are preserved; a concurrent revision is never overwritten.",
-            inputSchema: {
-                organization_id: z.string().trim().min(1).describe("Required organization ID; section writes require admin access."),
-                sections: sectionPatchSchema.describe("Only sections to change. Each section must include `value`, `evidenceIds`, and `approved`."),
-                expected_revision: z.number().int().nonnegative().describe("Current draft revision, or 0 when no draft exists. Re-read first."),
-                idempotency_key: z.string().trim().min(1).max(200).describe("Stable unique key for this exact section patch."),
-            },
-            annotations: { idempotentHint: true },
-        }, async ({ organization_id, sections, expected_revision, idempotency_key }) => {
-            try {
-                const data = await updateSections(client, { organizationId: organization_id, kind: tool.kind, sections, expectedRevision: expected_revision, idempotencyKey: idempotency_key });
-                return toolResult(compactDraft(data));
-            }
-            catch (error) {
-                return handleToolError(error);
-            }
-        });
-    }
+    server.registerTool("update_company_brain_sections", {
+        title: "Update Company Brain sections",
+        description: "Update only the named Company Brain sections. The MCP re-reads the current draft (or latest published version), merges only those sections, " +
+            `and saves with optimistic concurrency. Allowed sections: ${ACTIVE_CONTEXT_SECTIONS.join(", ")}. ` +
+            "Historical fields moved to Vertical, Offer, Persona or Lead Group are rejected by the closed schema.",
+        inputSchema: {
+            organization_id: z.string().trim().min(1).describe("Required organization ID; section writes require admin access."),
+            sections: sectionPatchSchema.describe("Only active Company Brain sections to change. Each section includes value, evidenceIds, and approved."),
+            expected_revision: z.number().int().nonnegative().describe("Current draft revision, or 0 when no draft exists. Re-read first."),
+            idempotency_key: z.string().trim().min(1).max(200).describe("Stable unique key for this exact section patch."),
+        },
+        annotations: { idempotentHint: true },
+    }, async ({ organization_id, sections, expected_revision, idempotency_key }) => {
+        try {
+            const data = await updateSections(client, {
+                organizationId: organization_id,
+                sections,
+                expectedRevision: expected_revision,
+                idempotencyKey: idempotency_key,
+            });
+            return toolResult(compactDraft(data));
+        }
+        catch (error) {
+            return handleToolError(error);
+        }
+    });
     server.registerTool("publish_context_workspace", {
         title: "Publish a ready Context Workspace draft",
         description: "Publish exactly one ready draft revision of the canonical Context Workspace. This is a consequential action: it requires " +
@@ -186,17 +242,16 @@ export function registerContextWorkspaceTools(server, client = getClient()) {
             "content with its readiness reasons and rejects stale revisions without overwriting anything.",
         inputSchema: {
             organization_id: z.string().trim().min(1).describe("Required organization ID; publication is restricted to an admin key for this tenant."),
-            kind: kindSchema,
             expected_revision: z.number().int().positive().describe("Exact ready draft revision to publish, obtained from `get_context_workspace`."),
             idempotency_key: z.string().trim().min(1).max(200).describe("Stable unique key for this exact publication request."),
             confirm_publish: z.literal(true).describe("Must be explicitly true after the user has confirmed this publication."),
         },
         annotations: { destructiveHint: true, idempotentHint: true },
-    }, async ({ organization_id, kind, expected_revision, idempotency_key }) => {
+    }, async ({ organization_id, expected_revision, idempotency_key }) => {
         try {
             const data = await client.post("/api/context-workspace/publish", {
                 organizationId: organization_id,
-                kind,
+                kind: CONTEXT_KIND,
                 expectedRevision: expected_revision,
                 idempotencyKey: idempotency_key,
             });