@nahisaho/katashiro-mcp-server 0.1.0

package/src/server/mcp-server.ts

@@ -0,0 +1,474 @@
+/**
+ * KatashiroMCPServer - MCP準拠サーバー実装
+ *
+ * Model Context Protocol (https://modelcontextprotocol.io) に準拠
+ * JSON-RPC 2.0ベースのプロトコルでTools, Resources, Promptsを提供
+ *
+ * @module @nahisaho/katashiro-mcp-server
+ * @task TSK-060
+ */
+
+import { ok, err, type Result } from '@nahisaho/katashiro-core';
+
+/**
+ * MCP Tool definition (JSON Schema based)
+ */
+export interface MCPTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+}
+
+/**
+ * MCP Prompt definition
+ */
+export interface MCPPrompt {
+  name: string;
+  description: string;
+  arguments?: Array<{
+    name: string;
+    description: string;
+    required?: boolean;
+  }>;
+}
+
+/**
+ * MCP Resource definition
+ */
+export interface MCPResource {
+  uri: string;
+  name: string;
+  description?: string;
+  mimeType?: string;
+}
+
+/**
+ * Tool execution result (MCP content array format)
+ */
+export interface ToolResult {
+  content: Array<{
+    type: 'text' | 'image' | 'resource';
+    text?: string;
+    data?: string;
+    mimeType?: string;
+  }>;
+  isError?: boolean;
+}
+
+/**
+ * Prompt result (MCP messages format)
+ */
+export interface PromptResult {
+  messages: Array<{
+    role: 'user' | 'assistant';
+    content: {
+      type: 'text';
+      text: string;
+    };
+  }>;
+}
+
+/**
+ * Server capabilities (MCP capability negotiation)
+ */
+export interface ServerCapabilities {
+  tools?: { listChanged?: boolean };
+  resources?: { subscribe?: boolean; listChanged?: boolean };
+  prompts?: { listChanged?: boolean };
+}
+
+/**
+ * Server info
+ */
+export interface ServerInfo {
+  name: string;
+  version: string;
+}
+
+/**
+ * KatashiroMCPServer
+ *
+ * MCP server implementation for KATASHIRO
+ * Provides tools, resources, and prompts for AI-powered research
+ */
+export class KatashiroMCPServer {
+  private tools: Map<string, MCPTool> = new Map();
+  private prompts: Map<string, MCPPrompt> = new Map();
+  private resources: Map<string, MCPResource> = new Map();
+
+  private readonly serverInfo: ServerInfo = {
+    name: 'katashiro',
+    version: '0.1.0',
+  };
+
+  private readonly capabilities: ServerCapabilities = {
+    tools: { listChanged: true },
+    resources: { subscribe: false, listChanged: true },
+    prompts: { listChanged: true },
+  };
+
+  constructor() {
+    this.registerTools();
+    this.registerPrompts();
+    this.registerResources();
+  }
+
+  /**
+   * Get server name
+   */
+  getName(): string {
+    return this.serverInfo.name;
+  }
+
+  /**
+   * Get server info
+   */
+  getServerInfo(): ServerInfo {
+    return this.serverInfo;
+  }
+
+  /**
+   * Get server capabilities
+   */
+  getCapabilities(): ServerCapabilities {
+    return this.capabilities;
+  }
+
+  /**
+   * Get all registered tools (tools/list)
+   */
+  getTools(): MCPTool[] {
+    return Array.from(this.tools.values());
+  }
+
+  /**
+   * Get all registered prompts (prompts/list)
+   */
+  getPrompts(): MCPPrompt[] {
+    return Array.from(this.prompts.values());
+  }
+
+  /**
+   * Execute a tool (tools/call)
+   */
+  async executeTool(
+    name: string,
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    try {
+      const tool = this.tools.get(name);
+      if (!tool) {
+        return err(new Error(`Unknown tool: ${name}`));
+      }
+
+      const result = await this.handleToolExecution(name, args);
+      return result;
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Execute a prompt (prompts/get)
+   */
+  async executePrompt(
+    name: string,
+    args: Record<string, unknown>
+  ): Promise<Result<PromptResult, Error>> {
+    try {
+      const prompt = this.prompts.get(name);
+      if (!prompt) {
+        return err(new Error(`Unknown prompt: ${name}`));
+      }
+
+      const result = await this.handlePromptExecution(name, args);
+      return result;
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * List all resources (resources/list)
+   */
+  async listResources(): Promise<Result<MCPResource[], Error>> {
+    try {
+      return ok(Array.from(this.resources.values()));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Read a resource (resources/read)
+   */
+  async readResource(uri: string): Promise<Result<string, Error>> {
+    try {
+      const resource = this.resources.get(uri);
+      if (!resource) {
+        return err(new Error(`Resource not found: ${uri}`));
+      }
+
+      return ok(`Resource content for: ${uri}`);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Register KATASHIRO tools
+   */
+  private registerTools(): void {
+    // Web Search Tool
+    this.tools.set('web_search', {
+      name: 'web_search',
+      description: 'Search the web for information on any topic',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query' },
+          limit: { type: 'number', description: 'Maximum number of results' },
+        },
+        required: ['query'],
+      },
+    });
+
+    // Analyze Content Tool
+    this.tools.set('analyze_content', {
+      name: 'analyze_content',
+      description: 'Analyze content for entities, topics, and sentiment',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          content: { type: 'string', description: 'Content to analyze' },
+          type: { type: 'string', description: 'Content type (text, code, html)' },
+        },
+        required: ['content'],
+      },
+    });
+
+    // Generate Summary Tool
+    this.tools.set('generate_summary', {
+      name: 'generate_summary',
+      description: 'Generate a summary of the provided content',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          content: { type: 'string', description: 'Content to summarize' },
+          style: { type: 'string', description: 'Summary style (brief, detailed, bullet)' },
+        },
+        required: ['content'],
+      },
+    });
+
+    // Knowledge Query Tool
+    this.tools.set('query_knowledge', {
+      name: 'query_knowledge',
+      description: 'Query the knowledge graph for related information',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Query string' },
+          type: { type: 'string', description: 'Node type filter' },
+        },
+        required: ['query'],
+      },
+    });
+
+    // Generate Report Tool
+    this.tools.set('generate_report', {
+      name: 'generate_report',
+      description: 'Generate a comprehensive research report',
+      inputSchema: {
+        type: 'object',
+        properties: {
+          topic: { type: 'string', description: 'Report topic' },
+          format: { type: 'string', description: 'Output format (markdown, html, pdf)' },
+          sections: { type: 'array', description: 'Report sections to include' },
+        },
+        required: ['topic'],
+      },
+    });
+  }
+
+  /**
+   * Register KATASHIRO prompts
+   */
+  private registerPrompts(): void {
+    this.prompts.set('research_topic', {
+      name: 'research_topic',
+      description: 'Research a topic comprehensively using web search and analysis',
+      arguments: [
+        { name: 'topic', description: 'Topic to research', required: true },
+        { name: 'depth', description: 'Research depth (shallow, moderate, deep)', required: false },
+      ],
+    });
+
+    this.prompts.set('analyze_document', {
+      name: 'analyze_document',
+      description: 'Analyze a document for key insights and structure',
+      arguments: [
+        { name: 'document', description: 'Document content to analyze', required: true },
+      ],
+    });
+
+    this.prompts.set('create_presentation', {
+      name: 'create_presentation',
+      description: 'Create a presentation outline from research',
+      arguments: [
+        { name: 'topic', description: 'Presentation topic', required: true },
+        { name: 'slides', description: 'Number of slides', required: false },
+      ],
+    });
+  }
+
+  /**
+   * Register KATASHIRO resources
+   */
+  private registerResources(): void {
+    this.resources.set('katashiro://knowledge/graph', {
+      uri: 'katashiro://knowledge/graph',
+      name: 'Knowledge Graph',
+      description: 'The knowledge graph containing research data',
+      mimeType: 'application/json',
+    });
+
+    this.resources.set('katashiro://patterns/library', {
+      uri: 'katashiro://patterns/library',
+      name: 'Pattern Library',
+      description: 'Learned patterns from user feedback',
+      mimeType: 'application/json',
+    });
+
+    this.resources.set('katashiro://feedback/stats', {
+      uri: 'katashiro://feedback/stats',
+      name: 'Feedback Statistics',
+      description: 'Statistics about user feedback and learning',
+      mimeType: 'application/json',
+    });
+  }
+
+  /**
+   * Handle tool execution
+   */
+  private async handleToolExecution(
+    name: string,
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    switch (name) {
+      case 'web_search':
+        return this.executeWebSearch(args);
+      case 'analyze_content':
+        return this.executeAnalyzeContent(args);
+      case 'generate_summary':
+        return this.executeGenerateSummary(args);
+      case 'query_knowledge':
+        return this.executeQueryKnowledge(args);
+      case 'generate_report':
+        return this.executeGenerateReport(args);
+      default:
+        return err(new Error(`Unhandled tool: ${name}`));
+    }
+  }
+
+  /**
+   * Handle prompt execution
+   */
+  private async handlePromptExecution(
+    name: string,
+    args: Record<string, unknown>
+  ): Promise<Result<PromptResult, Error>> {
+    const topic = String(args['topic'] || args['document'] || 'Unknown');
+
+    return ok({
+      messages: [
+        {
+          role: 'user',
+          content: {
+            type: 'text',
+            text: `Execute prompt "${name}" with topic: ${topic}`,
+          },
+        },
+      ],
+    });
+  }
+
+  // Tool implementations
+
+  private async executeWebSearch(
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    const query = String(args['query']);
+    return ok({
+      content: [
+        {
+          type: 'text',
+          text: `Search results for: ${query}\n\n[Simulated results]`,
+        },
+      ],
+    });
+  }
+
+  private async executeAnalyzeContent(
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    const content = String(args['content']);
+    const type = String(args['type'] || 'text');
+    return ok({
+      content: [
+        {
+          type: 'text',
+          text: `Analysis of ${type} content:\n\nLength: ${content.length}\nType: ${type}`,
+        },
+      ],
+    });
+  }
+
+  private async executeGenerateSummary(
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    const content = String(args['content']);
+    const style = String(args['style'] || 'brief');
+    return ok({
+      content: [
+        {
+          type: 'text',
+          text: `Summary (${style}):\n\n${content.substring(0, 100)}...`,
+        },
+      ],
+    });
+  }
+
+  private async executeQueryKnowledge(
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    const query = String(args['query']);
+    return ok({
+      content: [
+        {
+          type: 'text',
+          text: `Knowledge query: ${query}\n\n[Query results]`,
+        },
+      ],
+    });
+  }
+
+  private async executeGenerateReport(
+    args: Record<string, unknown>
+  ): Promise<Result<ToolResult, Error>> {
+    const topic = String(args['topic']);
+    const format = String(args['format'] || 'markdown');
+    return ok({
+      content: [
+        {
+          type: 'text',
+          text: `# Report: ${topic}\n\nFormat: ${format}\n\n[Report content]`,
+        },
+      ],
+    });
+  }
+}

package/src/tools/tool-registry.ts

@@ -0,0 +1,158 @@
+/**
+ * ToolRegistry - ツール登録・管理
+ *
+ * MCPツールの登録と実行を管理
+ *
+ * @module @nahisaho/katashiro-mcp-server
+ * @task TSK-061
+ */
+
+import { ok, err, type Result } from '@nahisaho/katashiro-core';
+
+/**
+ * Tool content item
+ */
+export interface ToolContent {
+  type: 'text' | 'image' | 'resource';
+  text?: string;
+  data?: string;
+  mimeType?: string;
+}
+
+/**
+ * Tool result
+ */
+export interface ToolExecutionResult {
+  content: ToolContent[];
+  isError?: boolean;
+}
+
+/**
+ * Tool handler function
+ */
+export type ToolHandler = (
+  args: Record<string, unknown>
+) => Promise<ToolExecutionResult>;
+
+/**
+ * Registered tool
+ */
+export interface RegisteredTool {
+  name: string;
+  description: string;
+  inputSchema: {
+    type: 'object';
+    properties: Record<string, unknown>;
+    required?: string[];
+  };
+  handler: ToolHandler;
+}
+
+/**
+ * ToolRegistry
+ *
+ * Manages MCP tool registration and execution
+ */
+export class ToolRegistry {
+  private tools: Map<string, RegisteredTool> = new Map();
+
+  /**
+   * Register a tool
+   *
+   * @param tool - Tool to register
+   * @returns Result
+   */
+  register(tool: RegisteredTool): Result<void, Error> {
+    try {
+      if (this.tools.has(tool.name)) {
+        return err(new Error(`Tool already registered: ${tool.name}`));
+      }
+      this.tools.set(tool.name, tool);
+      return ok(undefined);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Get a registered tool
+   *
+   * @param name - Tool name
+   * @returns Tool or null
+   */
+  get(name: string): Result<RegisteredTool | null, Error> {
+    try {
+      return ok(this.tools.get(name) ?? null);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * List all registered tools
+   *
+   * @returns Array of tools
+   */
+  list(): Result<RegisteredTool[], Error> {
+    try {
+      return ok(Array.from(this.tools.values()));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Execute a tool
+   *
+   * @param name - Tool name
+   * @param args - Tool arguments
+   * @returns Execution result
+   */
+  async execute(
+    name: string,
+    args: Record<string, unknown>
+  ): Promise<Result<ToolExecutionResult, Error>> {
+    try {
+      const tool = this.tools.get(name);
+      if (!tool) {
+        return err(new Error(`Unknown tool: ${name}`));
+      }
+
+      const result = await tool.handler(args);
+      return ok(result);
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Unregister a tool
+   *
+   * @param name - Tool name
+   * @returns Whether unregistered
+   */
+  unregister(name: string): Result<boolean, Error> {
+    try {
+      return ok(this.tools.delete(name));
+    } catch (error) {
+      return err(error instanceof Error ? error : new Error(String(error)));
+    }
+  }
+
+  /**
+   * Check if tool exists
+   *
+   * @param name - Tool name
+   * @returns Whether exists
+   */
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  /**
+   * Clear all tools
+   */
+  clear(): void {
+    this.tools.clear();
+  }
+}

package/src/transport/index.ts

@@ -0,0 +1,5 @@
+/**
+ * Transport module exports
+ */
+
+export * from './stdio-transport.js';