@dudefactory/payload-plugin-content-planner 3.0.0

package/README.md

@@ -0,0 +1,90 @@
+# Payload Content Planner Plugin
+
+A Payload CMS plugin that adds content planning collections and integrates with your MCP system.
+
+## What It Does
+
+Adds three collections to your Payload CMS:
+
+- **Content Tasks** - Work items for agents to execute
+- **Keywords** - SEO keyword database
+- **Instructions** - Writing guidelines and rules
+
+Exports MCP tools so agents can query and manage these collections via your MCP interface.
+
+## Install
+
+```bash
+npm install @dudefactory/payload-plugin-content-planner
+```
+
+## Setup
+
+In your Payload config:
+
+```typescript
+import { buildConfig } from 'payload/config';
+import {
+  contentPlannerPlugin,
+  contentPlannerTools,
+  contentPlannerPrompts,
+} from '@dudefactory/payload-plugin-content-planner';
+
+export default buildConfig({
+  plugins: [
+    contentPlannerPlugin({ enabled: true }),
+
+    // Add tools/prompts to your MCP plugin
+    mcpPlugin({
+      tools: [...existingTools, ...contentPlannerTools],
+      prompts: [...existingPrompts, ...contentPlannerPrompts],
+    }),
+  ],
+});
+```
+
+## Collections
+
+### Content Tasks
+
+- `title` - Task name
+- `instructions` - What to do
+- `status` - todo | in-progress | done | blocked
+- `priority` - low | normal | high
+- `deadline` - Due date
+- `tags` - Categories
+- `notes` - Notes/results
+
+### Keywords
+
+- `keyword` - The keyword phrase
+- `category` - Content category
+- `searchVolume` - Monthly searches
+- `difficulty` - SEO difficulty
+- `intent` - Search intent type
+- `relatedKeywords` - Related phrases
+
+### Instructions
+
+- `title` - Guideline name
+- `type` - Tone, Style, Terminology, etc.
+- `content` - The actual guideline
+- `active` - Whether agents use it
+
+## MCP Tools
+
+Available via your `/api/mcp` endpoint:
+
+- `contentplanner/get-oldest-task` - Get next todo task
+- `contentplanner/fetch-keywords` - Fetch keywords by category
+- `contentplanner/fetch-instructions` - Fetch guidelines
+- `contentplanner/update-task` - Update task status/notes
+
+## Docs
+
+- [Agent Instructions](./AGENT_INITIALIZATION_INSTRUCTION.md) - How agents use the plugin
+- [Architecture](./MCP_ARCHITECTURE.md) - Technical design
+
+## License
+
+MIT

package/dist/collections/ContentTasks.d.ts

@@ -0,0 +1,2 @@
+import { CollectionConfig } from 'payload/types';
+export declare const contentTasksCollection: CollectionConfig;

package/dist/collections/ContentTasks.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentTasksCollection = void 0;
+exports.contentTasksCollection = {
+    slug: 'cp-content-tasks',
+    admin: {
+        useAsTitle: 'title',
+        defaultColumns: ['title', 'status', 'priority', 'deadline', 'createdAt'],
+        group: 'Content Planning',
+    },
+    fields: [
+        {
+            name: 'title',
+            label: 'Task Title',
+            type: 'text',
+            required: true,
+            maxLength: 150,
+        },
+        {
+            name: 'instructions',
+            label: 'Detailed Instructions',
+            type: 'textarea',
+            required: true,
+            admin: {
+                rows: 10,
+            },
+        },
+        {
+            name: 'status',
+            label: 'Status',
+            type: 'select',
+            required: true,
+            options: [
+                { label: 'To Do', value: 'todo' },
+                { label: 'In Progress', value: 'in-progress' },
+                { label: 'In Review', value: 'review' },
+                { label: 'Done', value: 'done' },
+                { label: 'Blocked', value: 'blocked' },
+            ],
+            defaultValue: 'todo',
+        },
+        {
+            name: 'priority',
+            label: 'Priority',
+            type: 'select',
+            required: true,
+            options: [
+                { label: 'Low', value: 'low' },
+                { label: 'Normal', value: 'normal' },
+                { label: 'High', value: 'high' },
+            ],
+            defaultValue: 'normal',
+        },
+        {
+            name: 'deadline',
+            label: 'Deadline',
+            type: 'date',
+            required: true,
+        },
+        {
+            name: 'tags',
+            label: 'Tags',
+            type: 'array',
+            fields: [
+                {
+                    name: 'tag',
+                    type: 'text',
+                },
+            ],
+        },
+        {
+            name: 'notes',
+            label: 'Completion Notes',
+            type: 'textarea',
+            admin: {
+                rows: 6,
+            },
+        },
+        {
+            name: 'assignedTo',
+            label: 'Assigned To',
+            type: 'text',
+        },
+    ],
+    timestamps: true,
+};

package/dist/collections/Instructions.d.ts

@@ -0,0 +1,2 @@
+import { CollectionConfig } from 'payload/types';
+export declare const instructionsCollection: CollectionConfig;

package/dist/collections/Instructions.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.instructionsCollection = void 0;
+exports.instructionsCollection = {
+    slug: 'cp-instructions',
+    admin: {
+        useAsTitle: 'title',
+        defaultColumns: ['title', 'type', 'category'],
+        group: 'Content Planning',
+    },
+    fields: [
+        {
+            name: 'title',
+            label: 'Instruction Title',
+            type: 'text',
+            required: true,
+        },
+        {
+            name: 'type',
+            label: 'Type',
+            type: 'select',
+            required: true,
+            options: [
+                { label: 'Tone & Voice', value: 'tone-voice' },
+                { label: 'Writing Style', value: 'writing-style' },
+                { label: 'Quality Standards', value: 'quality-standards' },
+                { label: 'Industry Terminology', value: 'terminology' },
+                { label: 'Brand Guidelines', value: 'brand-guidelines' },
+                { label: 'Content Format', value: 'content-format' },
+                { label: 'MCP Prompt', value: 'mcp-prompt' },
+                { label: 'Other', value: 'other' },
+            ],
+        },
+        {
+            name: 'category',
+            label: 'Category',
+            type: 'text',
+        },
+        {
+            name: 'content',
+            label: 'Instruction Content',
+            type: 'textarea',
+            required: true,
+            admin: {
+                rows: 12,
+            },
+        },
+        {
+            name: 'examples',
+            label: 'Examples',
+            type: 'array',
+            fields: [
+                {
+                    name: 'example',
+                    type: 'textarea',
+                },
+            ],
+        },
+        {
+            name: 'active',
+            label: 'Active (Use in MCP)',
+            type: 'checkbox',
+            defaultValue: true,
+        },
+    ],
+    timestamps: true,
+};

package/dist/collections/Keywords.d.ts

@@ -0,0 +1,2 @@
+import { CollectionConfig } from 'payload/types';
+export declare const keywordsCollection: CollectionConfig;

package/dist/collections/Keywords.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keywordsCollection = void 0;
+exports.keywordsCollection = {
+    slug: 'cp-keywords',
+    admin: {
+        useAsTitle: 'keyword',
+        defaultColumns: ['keyword', 'category', 'searchVolume', 'difficulty'],
+        group: 'Content Planning',
+    },
+    fields: [
+        {
+            name: 'keyword',
+            label: 'Keyword/Phrase',
+            type: 'text',
+            required: true,
+            unique: true,
+        },
+        {
+            name: 'category',
+            label: 'Category',
+            type: 'text',
+        },
+        {
+            name: 'searchVolume',
+            label: 'Monthly Search Volume',
+            type: 'number',
+        },
+        {
+            name: 'difficulty',
+            label: 'SEO Difficulty',
+            type: 'select',
+            options: [
+                { label: 'Easy', value: 'easy' },
+                { label: 'Medium', value: 'medium' },
+                { label: 'Hard', value: 'hard' },
+            ],
+        },
+        {
+            name: 'intent',
+            label: 'Search Intent',
+            type: 'select',
+            options: [
+                { label: 'Informational', value: 'informational' },
+                { label: 'Navigational', value: 'navigational' },
+                { label: 'Commercial', value: 'commercial' },
+                { label: 'Transactional', value: 'transactional' },
+            ],
+        },
+        {
+            name: 'relatedKeywords',
+            label: 'Related Keywords',
+            type: 'array',
+            fields: [
+                {
+                    name: 'keyword',
+                    type: 'text',
+                },
+            ],
+        },
+        {
+            name: 'notes',
+            label: 'Notes',
+            type: 'textarea',
+        },
+    ],
+    timestamps: true,
+};

package/dist/index.d.ts

@@ -0,0 +1,153 @@
+import { Config } from 'payload/config';
+import { generateInitInstruction, warmupInitialization, setupInstructions, generateContentTask, executeContentTask } from './mcp/prompts-handlers';
+export declare const contentPlannerPrompts: ({
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            projectName: {
+                type: string;
+                description: string;
+            };
+            projectPurpose: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+} | {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {};
+        required: never[];
+    };
+    handler: () => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+} | {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            brandName: {
+                type: string;
+                description: string;
+            };
+            category: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+} | {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            taskType: {
+                type: string;
+                description: string;
+            };
+            topic: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+} | {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            taskId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+})[];
+export { generateInitInstruction, warmupInitialization, setupInstructions, generateContentTask, executeContentTask, };
+export interface ContentPlannerPluginConfig {
+    enabled?: boolean;
+}
+/**
+ * Payload Content Planner Plugin
+ *
+ * Extends your existing Payload MCP plugin with:
+ * - ContentTasks, Keywords, Instructions collections
+ * - MCP tools and prompts (register with your MCP plugin)
+ *
+ * Each project installs independently. No cross-project sync.
+ *
+ * Usage:
+ * ```typescript
+ * import { buildConfig } from 'payload/config'
+ * import { contentPlannerPlugin, contentPlannerTools, contentPlannerPrompts } from '@dudefactory/payload-plugin-content-planner'
+ *
+ * export default buildConfig({
+ *   plugins: [
+ *     contentPlannerPlugin({ enabled: true }),
+ *     // Add to your existing MCP plugin:
+ *     // mcpPlugin({ tools: contentPlannerTools, prompts: contentPlannerPrompts })
+ *   ],
+ * })
+ * ```
+ */
+export declare const contentPlannerPlugin: (config?: ContentPlannerPluginConfig) => (incomingConfig: Config) => Config;

package/dist/index.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.contentPlannerPlugin = exports.executeContentTask = exports.generateContentTask = exports.setupInstructions = exports.warmupInitialization = exports.generateInitInstruction = exports.contentPlannerPrompts = void 0;
+const ContentTasks_1 = require("./collections/ContentTasks");
+const Keywords_1 = require("./collections/Keywords");
+const Instructions_1 = require("./collections/Instructions");
+const prompts_handlers_1 = require("./mcp/prompts-handlers");
+Object.defineProperty(exports, "generateInitInstruction", { enumerable: true, get: function () { return prompts_handlers_1.generateInitInstruction; } });
+Object.defineProperty(exports, "warmupInitialization", { enumerable: true, get: function () { return prompts_handlers_1.warmupInitialization; } });
+Object.defineProperty(exports, "setupInstructions", { enumerable: true, get: function () { return prompts_handlers_1.setupInstructions; } });
+Object.defineProperty(exports, "generateContentTask", { enumerable: true, get: function () { return prompts_handlers_1.generateContentTask; } });
+Object.defineProperty(exports, "executeContentTask", { enumerable: true, get: function () { return prompts_handlers_1.executeContentTask; } });
+// Export MCP prompts as array for mcpPlugin integration
+exports.contentPlannerPrompts = [
+    prompts_handlers_1.generateInitInstruction,
+    prompts_handlers_1.warmupInitialization,
+    prompts_handlers_1.setupInstructions,
+    prompts_handlers_1.generateContentTask,
+    prompts_handlers_1.executeContentTask,
+];
+/**
+ * Payload Content Planner Plugin
+ *
+ * Extends your existing Payload MCP plugin with:
+ * - ContentTasks, Keywords, Instructions collections
+ * - MCP tools and prompts (register with your MCP plugin)
+ *
+ * Each project installs independently. No cross-project sync.
+ *
+ * Usage:
+ * ```typescript
+ * import { buildConfig } from 'payload/config'
+ * import { contentPlannerPlugin, contentPlannerTools, contentPlannerPrompts } from '@dudefactory/payload-plugin-content-planner'
+ *
+ * export default buildConfig({
+ *   plugins: [
+ *     contentPlannerPlugin({ enabled: true }),
+ *     // Add to your existing MCP plugin:
+ *     // mcpPlugin({ tools: contentPlannerTools, prompts: contentPlannerPrompts })
+ *   ],
+ * })
+ * ```
+ */
+const contentPlannerPlugin = (config = {}) => (incomingConfig) => {
+    const { enabled = true } = config;
+    if (!enabled) {
+        return incomingConfig;
+    }
+    return {
+        ...incomingConfig,
+        collections: [
+            ...(incomingConfig.collections || []),
+            ContentTasks_1.contentTasksCollection,
+            Keywords_1.keywordsCollection,
+            Instructions_1.instructionsCollection,
+        ],
+    };
+};
+exports.contentPlannerPlugin = contentPlannerPlugin;

package/dist/mcp/prompts-handlers.d.ts

@@ -0,0 +1,143 @@
+/**
+ * Content Planner Plugin MCP Prompts
+ *
+ * Generic, system-aware prompts that:
+ * 1. Check system state (what instructions/tasks exist)
+ * 2. Suggest next steps based on what's missing
+ * 3. Guide without domain-specific assumptions
+ */
+/**
+ * Generate project initialization instruction
+ * Creates a base instruction that teaches MCP clients how to discover and use this project
+ */
+export declare const generateInitInstruction: {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            projectName: {
+                type: string;
+                description: string;
+            };
+            projectPurpose: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+};
+/**
+ * Warm-up prompt for MCP client initialization
+ * This is the first prompt AI sees when connecting to understand capabilities
+ */
+export declare const warmupInitialization: {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {};
+        required: never[];
+    };
+    handler: () => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+};
+export declare const setupInstructions: {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            brandName: {
+                type: string;
+                description: string;
+            };
+            category: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+};
+export declare const generateContentTask: {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            taskType: {
+                type: string;
+                description: string;
+            };
+            topic: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+};
+export declare const executeContentTask: {
+    name: string;
+    title: string;
+    description: string;
+    argsSchema: {
+        type: "object";
+        properties: {
+            taskId: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    handler: (args: any) => {
+        messages: {
+            role: string;
+            content: {
+                type: string;
+                text: string;
+            };
+        }[];
+    };
+};

package/dist/mcp/prompts-handlers.js

@@ -0,0 +1,375 @@
+"use strict";
+/**
+ * Content Planner Plugin MCP Prompts
+ *
+ * Generic, system-aware prompts that:
+ * 1. Check system state (what instructions/tasks exist)
+ * 2. Suggest next steps based on what's missing
+ * 3. Guide without domain-specific assumptions
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.executeContentTask = exports.generateContentTask = exports.setupInstructions = exports.warmupInitialization = exports.generateInitInstruction = void 0;
+/**
+ * Generate project initialization instruction
+ * Creates a base instruction that teaches MCP clients how to discover and use this project
+ */
+exports.generateInitInstruction = {
+    name: 'cp-generate-init-instruction',
+    title: 'Generate Project Initialization Instruction',
+    description: 'Create a base instruction that teaches MCP clients how to discover tools and understand this project on first connection.',
+    argsSchema: {
+        type: 'object',
+        properties: {
+            projectName: {
+                type: 'string',
+                description: 'Name of this project/system',
+            },
+            projectPurpose: {
+                type: 'string',
+                description: 'What this project does (1-2 sentences)',
+            },
+        },
+        required: ['projectName', 'projectPurpose'],
+    },
+    handler: (args) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Generate initialization instruction for: ${args.projectName}
+
+Purpose: ${args.projectPurpose}
+
+CREATE AN INSTRUCTION THAT TEACHES MCP CLIENTS HOW TO START:
+
+This instruction will be stored in the database and shown to MCP clients on first connection.
+It should teach the agent:
+
+STEP 0: VALIDATE MCP SERVER (CRITICAL FIRST STEP)
+   - "Before proceeding, validate your MCP server connection"
+   - Ask the user: "Can you see available prompts and tools? Please confirm by running:"
+     • tools/list (should show tools starting with 'contentplanner/')
+     • prompts/list (should show prompts starting with 'cp-')
+   - If YES: "Great! MCP server is working. Continue to Step 1."
+   - If NO: "MCP server issue. Check:"
+     • Is MCP plugin configured in payload.config.ts?
+     • Is /api/mcp endpoint accessible?
+     • Are contentPlannerTools and contentPlannerPrompts registered?
+   - DO NOT PROCEED until server validation passes
+
+STEP 1: WHERE YOU ARE
+   - "You're connected to ${args.projectName}"
+   - "${args.projectPurpose}"
+
+STEP 2: DISCOVER CAPABILITIES
+   - Now that server is validated, call tools/list
+   - Look for tools starting with 'contentplanner/' prefix
+   - Read their descriptions to understand capabilities
+   - Note which tools are available
+
+STEP 3: LEARN PROJECT CONTEXT
+   - Fetch active instructions: GET /api/cp-instructions?where[active][equals]=true
+   - These instructions contain project-specific guidelines, prompts, and workflows
+   - Read ALL active instructions to understand how to help in this project
+   - Instructions with type='mcp-prompt' are especially important
+
+STEP 4: READY TO WORK
+   - After reading instructions, you'll know:
+     * What tasks you can execute
+     * What content you can generate
+     * What workflows to follow
+   - Ask the user: "What would you like help with?"
+
+Now create a cp-instruction record:
+
+POST /api/cp-instructions
+{
+  "title": "MCP Client Initialization - ${args.projectName}",
+  "type": "mcp-prompt",
+  "category": "system",
+  "content": "[Generate the full initialization instruction text here - be specific, clear, step-by-step. START WITH SERVER VALIDATION]",
+  "examples": [],
+  "active": true
+}
+
+CRITICAL: 
+- Make the content field a complete, standalone instruction
+- ALWAYS start with MCP server validation
+- Assume the agent knows NOTHING about this project
+- Include exact API endpoints and tool names
+
+Generate the instruction now.`,
+                },
+            },
+        ],
+    }),
+};
+/**
+ * Warm-up prompt for MCP client initialization
+ * This is the first prompt AI sees when connecting to understand capabilities
+ */
+exports.warmupInitialization = {
+    name: 'cp-warmup-initialization',
+    title: 'Content Planner Warm-Up',
+    description: 'Initialize and warm up with Content Planner. Discover available tools and current system state.',
+    argsSchema: {
+        type: 'object',
+        properties: {},
+        required: [],
+    },
+    handler: () => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Welcome to Content Planner MCP Plugin!
+
+You now have access to content planning and management tools. Let's warm up and understand what's available.
+
+WARM-UP TASKS:
+
+1. DISCOVER AVAILABLE TOOLS
+   - Call: tools/list
+   - Look for tools starting with "contentplanner/"
+   - You should see tools like:
+     • contentplanner/get-oldest-task
+     • contentplanner/fetch-keywords
+     • contentplanner/fetch-instructions
+     • contentplanner/update-task
+
+2. CHECK SYSTEM STATE
+   Once you identify the tools, check the current state:
+   
+   a) Check if Instructions exist:
+      - GET /api/cp-instructions?where[active][equals]=true
+      - If empty: System needs guidelines to be set up
+      - If exist: System is ready to create content
+
+   b) Check Content Tasks:
+      - GET /api/cp-content-tasks
+      - If empty: No tasks in queue
+      - If exist: Tasks available to execute
+
+   c) Check Keywords:
+      - GET /api/cp-keywords
+      - If empty: No keyword database
+      - If exist: Keywords available for content
+
+3. REPORT FINDINGS
+   After checking state, provide a summary:
+   - [ ] Which tools are available?
+   - [ ] Are instructions set up? (Y/N)
+   - [ ] Are there content tasks? (Y/N)
+   - [ ] Is keyword database populated? (Y/N)
+
+4. SUGGEST NEXT STEP
+   Based on what's missing:
+   - If NO instructions: Suggest running "cp-setup-instructions"
+   - If NO tasks: Suggest using "cp-generate-content-task"
+   - If NO keywords: Suggest populating keywords database
+   - If ready: Suggest executing "cp-execute-content-task"
+
+GUIDELINES:
+✓ You are an AI content assistant with access to planning and management tools
+✓ You can discover, create, and execute content tasks
+✓ You should follow all guidelines and instructions stored in the system
+✓ Always mark tasks as done/blocked with appropriate notes
+✓ Ask clarifying questions if system state requires user input
+
+Let's start! First, discover what tools are available.
+`,
+                },
+            },
+        ],
+    }),
+};
+exports.setupInstructions = {
+    name: 'cp-setup-instructions',
+    title: 'Setup Content Planner',
+    description: 'Initialize content planning. Checks existing instructions and suggests what to create.',
+    argsSchema: {
+        type: 'object',
+        properties: {
+            brandName: {
+                type: 'string',
+                description: 'Your brand/company name',
+            },
+            category: {
+                type: 'string',
+                description: 'Content category (e.g., general, blog, product, social-media)',
+            },
+        },
+        required: ['brandName', 'category'],
+    },
+    handler: (args) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Check and initialize content planner for: ${args.brandName} (${args.category})
+
+STEP 1: Check existing instructions
+- GET /api/cp-instructions?where[active][equals]=true
+- If instructions exist, list them and suggest next step
+- If none exist, ask what instruction types to create
+
+STEP 2: If instructions exist
+- User has guidelines established
+- Next: Check if content tasks exist
+  - GET /api/cp-content-tasks
+  - If empty: suggest planning content
+  - If tasks exist: suggest executing them
+
+STEP 3: If no instructions exist
+- List available instruction types: tone-voice, writing-style, quality-standards, terminology, brand-guidelines, content-format
+- Ask user which types they need
+- For each type, ask them to define the content
+
+RESPOND WITH:
+1. Current state (what instructions exist)
+2. If instructions exist: What to do next
+3. If instructions missing: What types are available + ask for content
+
+Keep it generic - don't assume specific tone or standards. Let user define them.
+`,
+                },
+            },
+        ],
+    }),
+};
+exports.generateContentTask = {
+    name: 'cp-generate-content-task',
+    title: 'Create Content Task',
+    description: 'Create a content task. Checks existing state and suggests planning if needed.',
+    argsSchema: {
+        type: 'object',
+        properties: {
+            taskType: {
+                type: 'string',
+                description: 'Type of task (e.g., Article, Review, Media, Translation, Audit)',
+            },
+            topic: {
+                type: 'string',
+                description: 'What the task is about',
+            },
+        },
+        required: ['taskType', 'topic'],
+    },
+    handler: (args) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Create a content task.
+
+Task: ${args.taskType} - ${args.topic}
+
+STEP 1: Check system state
+- GET /api/cp-instructions?where[active][equals]=true
+  - If empty: stop, user needs to run cp-setup-instructions first
+  - If exist: continue to step 2
+
+- GET /api/cp-content-tasks
+  - If empty: this is first task, suggest user plan out a schedule
+  - If tasks exist: continue to step 2
+
+STEP 2: Ask user for task details
+Required fields:
+- title (string, concise description)
+- instructions (string, detailed steps to complete)
+- priority (enum: low, normal, high)
+- deadline (ISO date)
+- tags (array of strings, for categorization)
+
+Optional fields:
+- assignedTo (user ID or name)
+- notes (context or additional info)
+- status (default: "todo")
+
+STEP 3: Create task
+- POST /api/cp-content-tasks
+- Include all fields provided
+
+RESPOND WITH:
+1. Check if instructions exist
+2. If no instructions: "Need to run cp-setup-instructions first"
+3. If instructions exist: Ask for task details above
+4. If no prior tasks: Suggest user plan out a content schedule
+5. Once details provided: Create task and return ID
+`,
+                },
+            },
+        ],
+    }),
+};
+exports.executeContentTask = {
+    name: 'cp-execute-content-task',
+    title: 'Execute Content Task',
+    description: 'Execute a content task. Fetches guidelines, follows instructions, updates status.',
+    argsSchema: {
+        type: 'object',
+        properties: {
+            taskId: {
+                type: 'string',
+                description: 'ID of the cp-content-tasks record to execute',
+            },
+        },
+        required: ['taskId'],
+    },
+    handler: (args) => ({
+        messages: [
+            {
+                role: 'user',
+                content: {
+                    type: 'text',
+                    text: `Execute content task: ${args.taskId}
+
+EXECUTION WORKFLOW:
+
+STEP 1: Fetch Task
+- GET /api/cp-content-tasks/${args.taskId}
+- Extract: title, instructions, tags, status
+- Verify status is "todo" or "in-progress"
+
+STEP 2: Fetch Guidelines
+- GET /api/cp-instructions?where[active][equals]=true
+- Get all active instructions (tone, style, quality, terminology, etc)
+- These guide your content generation
+
+STEP 3: Update Status
+- PATCH /api/cp-content-tasks/${args.taskId}
+- Set: status: "in-progress"
+
+STEP 4: Execute Task
+- Follow the instructions field step-by-step
+- Apply guidelines from cp-instructions
+- Generate content according to task specs
+- Use available Payload collections as needed
+
+STEP 5: Handle Result
+
+ON SUCCESS:
+- PATCH /api/cp-content-tasks/${args.taskId}
+- Set: status: "done"
+- Add notes: "Completed. [Summary of what was created/done]"
+
+ON FAILURE/BLOCKED:
+- PATCH /api/cp-content-tasks/${args.taskId}
+- Set: status: "blocked"
+- Add notes: "[What went wrong]. [Required to unblock]"
+
+CRITICAL RULES:
+✓ Follow instructions exactly
+✓ Apply all guidelines
+✓ Document results in notes
+✓ If resources missing, mark blocked with clear reason
+`,
+                },
+            },
+        ],
+    }),
+};

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@dudefactory/payload-plugin-content-planner",
+  "version": "3.0.0",
+  "description": "Payload CMS plugin that extends MCP with content planning collections and data sources",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "publishConfig": {
+    "access": "public"
+  },
+  "scripts": {
+    "build": "tsc",
+    "prepublishOnly": "npm run build"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "package.json"
+  ],
+  "keywords": [
+    "payload",
+    "cms",
+    "plugin",
+    "mcp",
+    "content",
+    "planner",
+    "scheduler",
+    "ai"
+  ],
+  "author": "DudeFactory",
+  "license": "MIT",
+  "peerDependencies": {
+    "payload": "^2.0.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.0.0",
+    "@types/node": "^20.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/DudeFactory/payload-plugin-content-planner.git"
+  }
+}