@mseep/mcp-agent-social 1.1.0

package/src/prompts/index.ts

@@ -0,0 +1,121 @@
+// ABOUTME: Main prompt registration and handling for MCP prompts
+// ABOUTME: Coordinates all prompt types and implements list/get endpoints
+
+import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type {
+  GetPromptResult,
+  ListPromptsResult,
+  ServerNotification,
+  ServerRequest,
+} from '@modelcontextprotocol/sdk/types.js';
+import type { z } from 'zod';
+import type { IApiClient } from '../api-client.js';
+import { logger } from '../logger.js';
+import type { SessionManager } from '../session-manager.js';
+import { analyzePrompts } from './analyze.js';
+import { generatePrompts } from './generate.js';
+import { summarizePrompts } from './summarize.js';
+
+export interface PromptContext {
+  apiClient: IApiClient;
+  sessionManager: SessionManager;
+  hooksManager?: any;
+}
+
+// Type for prompt handlers - use any for args since prompts have different arg types
+type PromptHandler<T = any> = (
+  args: T,
+  extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+  context: PromptContext,
+) => Promise<GetPromptResult>;
+
+interface PromptDefinition {
+  description: string;
+  argsSchema: Record<string, z.ZodString | z.ZodOptional<z.ZodString>>;
+  handler: PromptHandler<any>;
+}
+
+// Combine all prompts
+const allPrompts: Record<string, PromptDefinition> = {
+  // Summarization prompts
+  'summarize-thread': summarizePrompts.summarizeThread,
+  'summarize-agent-activity': summarizePrompts.summarizeAgentActivity,
+
+  // Generation prompts
+  'draft-reply': generatePrompts.draftReply,
+  'generate-hashtags': generatePrompts.generateHashtags,
+  'create-engagement-post': generatePrompts.createEngagementPost,
+
+  // Analysis prompts
+  'analyze-sentiment': analyzePrompts.analyzeSentiment,
+  'find-related-discussions': analyzePrompts.findRelatedDiscussions,
+  'generate-engagement-report': analyzePrompts.generateEngagementReport,
+};
+
+/**
+ * Register all prompts with the MCP server
+ */
+export function registerPrompts(server: McpServer, context: PromptContext): void {
+  logger.info('Registering MCP prompts');
+
+  // Register each prompt
+  for (const [name, prompt] of Object.entries(allPrompts)) {
+    server.prompt(
+      name,
+      prompt.description,
+      prompt.argsSchema,
+      async (args: any, extra: RequestHandlerExtra<ServerRequest, ServerNotification>) => {
+        logger.debug(`Executing prompt: ${name}`, { args });
+        return prompt.handler(args, extra, context);
+      },
+    );
+  }
+
+  logger.info('Prompts registered', {
+    count: Object.keys(allPrompts).length,
+    prompts: Object.keys(allPrompts),
+  });
+}
+
+/**
+ * List all available prompts
+ */
+export async function listPrompts(): Promise<ListPromptsResult> {
+  logger.debug('Listing all prompts');
+
+  const prompts = Object.entries(allPrompts).map(([name, prompt]) => ({
+    name,
+    description: prompt.description,
+    arguments: Object.entries(prompt.argsSchema).map(([argName, schema]) => ({
+      name: argName,
+      description: schema._def.description || '',
+      required: !schema.isOptional(),
+    })),
+  }));
+
+  return { prompts };
+}
+
+/**
+ * Get a specific prompt by name
+ */
+export async function getPrompt(
+  name: string,
+  args: Record<string, string>,
+  context: PromptContext,
+  extra?: RequestHandlerExtra<ServerRequest, ServerNotification>,
+): Promise<GetPromptResult | null> {
+  const prompt = allPrompts[name];
+  if (!prompt) {
+    logger.warn('Prompt not found', { name });
+    return null;
+  }
+
+  // If no extra provided, this shouldn't be called directly
+  if (!extra) {
+    throw new Error('getPrompt requires RequestHandlerExtra parameter');
+  }
+
+  return prompt.handler(args, extra, context);
+}

package/src/prompts/summarize.ts

@@ -0,0 +1,217 @@
+// ABOUTME: Summarization prompts for threads and conversations
+// ABOUTME: Provides templates for summarizing social media content
+
+import type { RequestHandlerExtra } from '@modelcontextprotocol/sdk/shared/protocol.js';
+import type {
+  GetPromptResult,
+  ServerNotification,
+  ServerRequest,
+} from '@modelcontextprotocol/sdk/types.js';
+import { z } from 'zod';
+import type { IApiClient } from '../api-client.js';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+
+export interface SummarizePromptContext {
+  apiClient: IApiClient;
+}
+
+const summarizeThreadArgsSchema = {
+  thread_id: z.string().describe('The ID of the thread to summarize'),
+};
+
+export async function summarizeThreadPrompt(
+  args: { thread_id: string },
+  _extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+  context: SummarizePromptContext,
+): Promise<GetPromptResult> {
+  try {
+    logger.debug('Generating thread summary prompt', { threadId: args.thread_id });
+
+    // Fetch the thread posts
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      thread_id: args.thread_id,
+      limit: 100,
+      offset: 0,
+    });
+
+    if (!response.posts || response.posts.length === 0) {
+      return {
+        description: 'Thread not found',
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `Unable to find thread with ID: ${args.thread_id}`,
+            },
+          },
+        ],
+      };
+    }
+
+    // Build the conversation history
+    const conversation = response.posts
+      .sort((a, b) => a.timestamp.localeCompare(b.timestamp))
+      .map((post) => `${post.author_name}: ${post.content}`)
+      .join('\n\n');
+
+    // Count unique participants
+    const participants = new Set(response.posts.map((p) => p.author_name));
+
+    return {
+      description: 'Summarize a social media conversation thread',
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Please summarize the following social media conversation thread:
+
+Thread ID: ${args.thread_id}
+Participants: ${participants.size} (${Array.from(participants).join(', ')})
+Total Posts: ${response.posts.length}
+
+Conversation:
+${conversation}
+
+Please provide:
+1. A brief summary of the main topic(s) discussed
+2. Key points or decisions made
+3. Any action items or follow-ups mentioned
+4. The overall sentiment/tone of the conversation`,
+          },
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error generating thread summary prompt', { error, threadId: args.thread_id });
+    return {
+      description: 'Error generating prompt',
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Error fetching thread data: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          },
+        },
+      ],
+    };
+  }
+}
+
+const summarizeAgentArgsSchema = {
+  agent_name: z.string().describe('The name of the agent to summarize'),
+  limit: z.string().optional().describe('Maximum number of posts to analyze (default: 20)'),
+};
+
+export async function summarizeAgentActivityPrompt(
+  args: { agent_name: string; limit?: string },
+  _extra: RequestHandlerExtra<ServerRequest, ServerNotification>,
+  context: SummarizePromptContext,
+): Promise<GetPromptResult> {
+  try {
+    const limit = args.limit ? Number.parseInt(args.limit, 10) : 20;
+    logger.debug('Generating agent activity summary prompt', { agentName: args.agent_name, limit });
+
+    // Fetch the agent's posts
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      agent_filter: args.agent_name,
+      limit,
+      offset: 0,
+    });
+
+    if (!response.posts || response.posts.length === 0) {
+      return {
+        description: 'Agent not found or has no posts',
+        messages: [
+          {
+            role: 'user',
+            content: {
+              type: 'text',
+              text: `No posts found for agent: ${args.agent_name}`,
+            },
+          },
+        ],
+      };
+    }
+
+    // Analyze post patterns
+    const posts = response.posts.sort((a, b) => b.timestamp.localeCompare(a.timestamp));
+    const tags = posts.flatMap((p) => p.tags || []);
+    const tagCounts = tags.reduce(
+      (acc, tag) => {
+        acc[tag] = (acc[tag] || 0) + 1;
+        return acc;
+      },
+      {} as Record<string, number>,
+    );
+
+    const recentPosts = posts
+      .slice(0, 5)
+      .map((p) => `- ${p.content}${p.tags?.length ? ` [${p.tags.join(', ')}]` : ''}`)
+      .join('\n');
+
+    return {
+      description: `Summarize ${args.agent_name}'s social media activity`,
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Please analyze and summarize the social media activity for agent "${args.agent_name}":
+
+Total Posts: ${response.total || response.posts.length}
+Posts Analyzed: ${posts.length}
+Time Range: ${posts[posts.length - 1]?.timestamp} to ${posts[0]?.timestamp}
+
+Most Used Tags: ${Object.entries(tagCounts)
+              .sort(([, a], [, b]) => b - a)
+              .slice(0, 5)
+              .map(([tag, count]) => `${tag} (${count})`)
+              .join(', ')}
+
+Recent Posts:
+${recentPosts}
+
+Please provide:
+1. A summary of this agent's main topics of interest
+2. Their posting patterns and frequency
+3. Their communication style and tone
+4. Key themes or recurring subjects in their posts
+5. Their level of engagement with others (replies vs original posts)`,
+          },
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error generating agent summary prompt', { error, agentName: args.agent_name });
+    return {
+      description: 'Error generating prompt',
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Error fetching agent data: ${error instanceof Error ? error.message : 'Unknown error'}`,
+          },
+        },
+      ],
+    };
+  }
+}
+
+// Export schemas for registration
+export const summarizePrompts = {
+  summarizeThread: {
+    description: 'Generate a summary of a conversation thread',
+    argsSchema: summarizeThreadArgsSchema,
+    handler: summarizeThreadPrompt,
+  },
+  summarizeAgentActivity: {
+    description: "Summarize an agent's posting patterns and activity",
+    argsSchema: summarizeAgentArgsSchema,
+    handler: summarizeAgentActivityPrompt,
+  },
+};

package/src/prompts/types.ts

@@ -0,0 +1,44 @@
+// ABOUTME: Type definitions for MCP prompts in the social media server
+// ABOUTME: Defines prompt structures and interfaces
+
+import { z } from 'zod';
+
+export interface PromptMessage {
+  role: 'user' | 'assistant';
+  content: {
+    type: 'text';
+    text: string;
+  };
+}
+
+export interface PromptTemplate {
+  name: string;
+  description?: string;
+  arguments?: Record<string, z.ZodString | z.ZodOptional<z.ZodString>>;
+  messages: PromptMessage[];
+}
+
+// Prompt argument schemas
+export const threadIdSchema = {
+  thread_id: z.string().describe('The ID of the thread to analyze'),
+};
+
+export const agentNameSchema = {
+  agent_name: z.string().describe('The name of the agent to analyze'),
+};
+
+export const postContentSchema = {
+  post_content: z.string().describe('The content of the post to analyze or reply to'),
+  context: z.string().optional().describe('Additional context about the conversation'),
+};
+
+export const topicSchema = {
+  topic: z.string().describe('The topic or theme to search for'),
+  limit: z.string().optional().describe('Maximum number of results to return'),
+};
+
+export const timeRangeSchema = {
+  start_date: z.string().optional().describe('Start date for the report (ISO format)'),
+  end_date: z.string().optional().describe('End date for the report (ISO format)'),
+  agent_filter: z.string().optional().describe('Filter by specific agent name'),
+};

package/src/resources/agents.ts

@@ -0,0 +1,165 @@
+// ABOUTME: Agent resource handlers for reading agent profiles and posts
+// ABOUTME: Implements resource callbacks for agent-related URIs
+
+import type { URL } from 'node:url';
+import type { ReadResourceResult } from '@modelcontextprotocol/sdk/types.js';
+import type { IApiClient } from '../api-client.js';
+import { config } from '../config.js';
+import { logger } from '../logger.js';
+import type { AgentPostsResource, AgentProfileResource } from './types.js';
+
+export interface AgentResourceContext {
+  apiClient: IApiClient;
+}
+
+/**
+ * Read an agent's profile
+ * URI: social://agents/{agentName}/profile
+ */
+export async function readAgentProfileResource(
+  uri: URL,
+  context: AgentResourceContext,
+): Promise<ReadResourceResult> {
+  try {
+    // Extract agentName from URI path
+    const pathMatch = uri.pathname.match(/^\/\/agents\/([^/]+)\/profile$/);
+    const agentName = pathMatch?.[1];
+
+    if (!agentName) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({ error: 'Invalid agent profile URI: missing agentName' }),
+          },
+        ],
+      };
+    }
+
+    logger.debug('Reading agent profile resource', { agentName });
+
+    // Fetch all posts by this agent to build profile
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      agent_filter: agentName,
+      limit: 100,
+      offset: 0,
+    });
+
+    // Calculate profile stats
+    let firstSeenAt: string | undefined;
+    let lastSeenAt: string | undefined;
+
+    if (response.posts.length > 0) {
+      const timestamps = response.posts.map((p) => p.timestamp);
+      timestamps.sort();
+      firstSeenAt = timestamps[0];
+      lastSeenAt = timestamps[timestamps.length - 1];
+    }
+
+    const resource: AgentProfileResource = {
+      profile: {
+        agentName,
+        postCount: response.total || response.posts.length,
+        firstSeenAt,
+        lastSeenAt,
+      },
+    };
+
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify(resource, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading agent profile resource', { error, uri: uri.toString() });
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify({
+            error: 'Failed to read agent profile resource',
+            details: error instanceof Error ? error.message : 'Unknown error',
+          }),
+        },
+      ],
+    };
+  }
+}
+
+/**
+ * Read an agent's posts
+ * URI: social://agents/{agentName}/posts
+ */
+export async function readAgentPostsResource(
+  uri: URL,
+  context: AgentResourceContext,
+): Promise<ReadResourceResult> {
+  try {
+    // Extract agentName from URI path
+    const pathMatch = uri.pathname.match(/^\/\/agents\/([^/]+)\/posts$/);
+    const agentName = pathMatch?.[1];
+
+    if (!agentName) {
+      return {
+        contents: [
+          {
+            uri: uri.toString(),
+            mimeType: 'application/json',
+            text: JSON.stringify({ error: 'Invalid agent posts URI: missing agentName' }),
+          },
+        ],
+      };
+    }
+
+    logger.debug('Reading agent posts resource', { agentName });
+
+    // Fetch posts by this agent
+    const response = await context.apiClient.fetchPosts(config.teamName, {
+      agent_filter: agentName,
+      limit: 50, // Reasonable default
+      offset: 0,
+    });
+
+    const resource: AgentPostsResource = {
+      agentName,
+      posts: response.posts.map((p) => ({
+        id: p.id,
+        content: p.content,
+        tags: p.tags,
+        timestamp: p.timestamp,
+        parent_post_id: p.parent_post_id,
+      })),
+      total: response.total || response.posts.length,
+    };
+
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify(resource, null, 2),
+        },
+      ],
+    };
+  } catch (error) {
+    logger.error('Error reading agent posts resource', { error, uri: uri.toString() });
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: 'application/json',
+          text: JSON.stringify({
+            error: 'Failed to read agent posts resource',
+            details: error instanceof Error ? error.message : 'Unknown error',
+          }),
+        },
+      ],
+    };
+  }
+}