@nahisaho/shikigami 1.1.0

package/mcp-server/src/index.ts

@@ -0,0 +1,418 @@
+#!/usr/bin/env node
+/**
+ * SHIKIGAMI MCP Server
+ * 
+ * Deep Research tools with DuckDuckGo search and Jina AI page fetching.
+ * Implements REQ-DR-002, REQ-DR-003, REQ-CS-002, REQ-CS-003, REQ-CS-004 from requirements.
+ */
+
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import {
+  CallToolRequestSchema,
+  ListToolsRequestSchema,
+  type CallToolRequest,
+  type Tool,
+} from '@modelcontextprotocol/sdk/types.js';
+
+import { searchDuckDuckGo, type SearchResult } from './tools/search.js';
+import { visitPage, type PageContent } from './tools/visit.js';
+import { parseFile, parseFiles, parseDirectory, type ParsedFile } from './tools/file-parser.js';
+import {
+  embed,
+  embedBatch,
+  similarity,
+  semanticSearch,
+  type EmbeddingResult,
+  type SimilarityResult,
+  type SearchResult as SemanticSearchResult,
+} from './tools/embedding.js';
+
+// Tool definitions
+const TOOLS: Tool[] = [
+  {
+    name: 'search',
+    description: `バッチWeb検索を実行（DuckDuckGo使用）。
+複数クエリを配列で指定可。各クエリのTop10結果を返却。
+Deep Researchの情報収集フェーズで使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          oneOf: [
+            { type: 'string', description: '単一の検索クエリ' },
+            {
+              type: 'array',
+              items: { type: 'string' },
+              minItems: 1,
+              description: '検索クエリのリスト（バッチ検索）',
+            },
+          ],
+          description: '検索クエリ（文字列または文字列配列）',
+        },
+        maxResults: {
+          type: 'number',
+          default: 10,
+          description: '各クエリあたりの最大結果数（デフォルト: 10）',
+        },
+      },
+      required: ['query'],
+    },
+  },
+  {
+    name: 'visit',
+    description: `Webページを訪問し、内容のテキストを抽出（Jina AI Reader使用）。
+LLM用に最適化されたクリーンなテキストを返却。
+Deep Researchの詳細調査フェーズで使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        url: {
+          oneOf: [
+            { type: 'string', description: '単一のURL' },
+            {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'URLのリスト（バッチ訪問）',
+            },
+          ],
+          description: '訪問するURL（文字列または文字列配列）',
+        },
+        goal: {
+          type: 'string',
+          description: 'このページ訪問の目的（抽出する情報の指針）',
+        },
+      },
+      required: ['url'],
+    },
+  },
+  {
+    name: 'parse_file',
+    description: `ローカルファイルを解析してテキストを抽出。
+対応形式: テキスト(txt,md,json,yaml,csv)、コード(ts,js,py等)。
+ドキュメント調査やコード解析に使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          oneOf: [
+            { type: 'string', description: '単一のファイルパス' },
+            {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'ファイルパスのリスト（バッチ解析）',
+            },
+          ],
+          description: '解析するファイルパス（文字列または文字列配列）',
+        },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'parse_directory',
+    description: `ディレクトリ内のファイルを再帰的に解析。
+コードベース全体の理解や、プロジェクト構造の把握に使用。
+node_modules, .git等は自動除外。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        path: {
+          type: 'string',
+          description: '解析するディレクトリパス',
+        },
+        extensions: {
+          type: 'array',
+          items: { type: 'string' },
+          description: '解析する拡張子リスト（例: [".ts", ".js"]）',
+        },
+        exclude: {
+          type: 'array',
+          items: { type: 'string' },
+          description: '除外パターン（デフォルト: node_modules, .git, dist, build）',
+        },
+        maxFiles: {
+          type: 'number',
+          default: 100,
+          description: '最大ファイル数（デフォルト: 100）',
+        },
+      },
+      required: ['path'],
+    },
+  },
+  {
+    name: 'embed',
+    description: `テキストの埋め込みベクトルを生成（Ollama/OpenAI使用）。
+セマンティック検索や類似度計算の基盤。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        text: {
+          oneOf: [
+            { type: 'string', description: '単一のテキスト' },
+            {
+              type: 'array',
+              items: { type: 'string' },
+              description: 'テキストのリスト（バッチ処理）',
+            },
+          ],
+          description: '埋め込みを生成するテキスト',
+        },
+      },
+      required: ['text'],
+    },
+  },
+  {
+    name: 'similarity',
+    description: `2つのテキスト間の意味的類似度を計算（0-1のスコア）。
+コンテンツの関連性判定に使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        textA: {
+          type: 'string',
+          description: '比較するテキストA',
+        },
+        textB: {
+          type: 'string',
+          description: '比較するテキストB',
+        },
+      },
+      required: ['textA', 'textB'],
+    },
+  },
+  {
+    name: 'semantic_search',
+    description: `クエリに最も類似したドキュメントを検索。
+関連情報の発見やコンテキスト取得に使用。`,
+    inputSchema: {
+      type: 'object',
+      properties: {
+        query: {
+          type: 'string',
+          description: '検索クエリ',
+        },
+        documents: {
+          type: 'array',
+          items: {
+            type: 'object',
+            properties: {
+              text: { type: 'string', description: 'ドキュメントテキスト' },
+              metadata: { type: 'object', description: 'メタデータ（任意）' },
+            },
+            required: ['text'],
+          },
+          description: '検索対象ドキュメントのリスト',
+        },
+        topK: {
+          type: 'number',
+          default: 5,
+          description: '返却する最大件数（デフォルト: 5）',
+        },
+        minScore: {
+          type: 'number',
+          default: 0,
+          description: '最小類似度閾値（デフォルト: 0）',
+        },
+      },
+      required: ['query', 'documents'],
+    },
+  },
+];
+
+// Server setup
+const server = new Server(
+  {
+    name: 'shikigami-mcp-server',
+    version: '1.0.0',
+  },
+  {
+    capabilities: {
+      tools: {},
+    },
+  }
+);
+
+// List tools handler
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+  return { tools: TOOLS };
+});
+
+// Call tool handler
+server.setRequestHandler(CallToolRequestSchema, async (request: CallToolRequest) => {
+  const { name, arguments: args } = request.params;
+
+  try {
+    switch (name) {
+      case 'search': {
+        const queryInput = args?.query as string | string[];
+        const maxResults = (args?.maxResults as number) ?? 10;
+        
+        const queries = Array.isArray(queryInput) ? queryInput : [queryInput];
+        const results: Record<string, SearchResult[]> = {};
+        
+        for (const query of queries) {
+          results[query] = await searchDuckDuckGo(query, maxResults);
+        }
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'visit': {
+        const urlInput = args?.url as string | string[];
+        const goal = (args?.goal as string) ?? '';
+        
+        const urls = Array.isArray(urlInput) ? urlInput : [urlInput];
+        const results: PageContent[] = [];
+        
+        for (const url of urls) {
+          const content = await visitPage(url, goal);
+          results.push(content);
+        }
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'parse_file': {
+        const pathInput = args?.path as string | string[];
+        
+        const paths = Array.isArray(pathInput) ? pathInput : [pathInput];
+        const results: ParsedFile[] = await parseFiles(paths);
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'parse_directory': {
+        const dirPath = args?.path as string;
+        const extensions = args?.extensions as string[] | undefined;
+        const exclude = args?.exclude as string[] | undefined;
+        const maxFiles = (args?.maxFiles as number) ?? 100;
+        
+        const results: ParsedFile[] = await parseDirectory(dirPath, {
+          extensions,
+          exclude,
+          maxFiles,
+        });
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'embed': {
+        const textInput = args?.text as string | string[];
+        
+        if (Array.isArray(textInput)) {
+          const results: EmbeddingResult[] = await embedBatch(textInput);
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(results, null, 2),
+              },
+            ],
+          };
+        } else {
+          const result: EmbeddingResult = await embed(textInput);
+          return {
+            content: [
+              {
+                type: 'text',
+                text: JSON.stringify(result, null, 2),
+              },
+            ],
+          };
+        }
+      }
+
+      case 'similarity': {
+        const textA = args?.textA as string;
+        const textB = args?.textB as string;
+        
+        const result: SimilarityResult = await similarity(textA, textB);
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(result, null, 2),
+            },
+          ],
+        };
+      }
+
+      case 'semantic_search': {
+        const query = args?.query as string;
+        const documents = args?.documents as Array<{ text: string; metadata?: Record<string, unknown> }>;
+        const topK = (args?.topK as number) ?? 5;
+        const minScore = (args?.minScore as number) ?? 0;
+        
+        const results: SemanticSearchResult[] = await semanticSearch(query, documents, {
+          topK,
+          minScore,
+        });
+        
+        return {
+          content: [
+            {
+              type: 'text',
+              text: JSON.stringify(results, null, 2),
+            },
+          ],
+        };
+      }
+
+      default:
+        throw new Error(`Unknown tool: ${name}`);
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      content: [
+        {
+          type: 'text',
+          text: `Error: ${message}`,
+        },
+      ],
+      isError: true,
+    };
+  }
+});
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error('SHIKIGAMI MCP Server running on stdio');
+}
+
+main().catch((error) => {
+  console.error('Fatal error:', error);
+  process.exit(1);
+});

package/mcp-server/src/tools/embedding.ts

@@ -0,0 +1,279 @@
+/**
+ * Embedding Service
+ *
+ * Implements REQ-CS-002: セマンティック検索
+ *
+ * Supports:
+ * - Ollama (local, default)
+ * - OpenAI Embeddings API
+ *
+ * Used for semantic search, similarity matching, and context retrieval.
+ */
+
+import { getConfig } from '../config/loader.js';
+
+export interface EmbeddingResult {
+  /** 入力テキスト */
+  text: string;
+  /** 埋め込みベクトル */
+  embedding: number[];
+  /** モデル名 */
+  model: string;
+  /** ベクトル次元数 */
+  dimensions: number;
+}
+
+export interface SimilarityResult {
+  /** テキストA */
+  textA: string;
+  /** テキストB */
+  textB: string;
+  /** コサイン類似度 (0-1) */
+  similarity: number;
+}
+
+export interface SearchResult {
+  /** 検索対象テキスト */
+  text: string;
+  /** 類似度スコア */
+  score: number;
+  /** インデックス（元の配列での位置） */
+  index: number;
+  /** メタデータ（任意） */
+  metadata?: Record<string, unknown>;
+}
+
+/**
+ * コサイン類似度を計算
+ */
+function cosineSimilarity(a: number[], b: number[]): number {
+  if (a.length !== b.length) {
+    throw new Error('Vectors must have the same dimensions');
+  }
+
+  let dotProduct = 0;
+  let normA = 0;
+  let normB = 0;
+
+  for (let i = 0; i < a.length; i++) {
+    dotProduct += a[i] * b[i];
+    normA += a[i] * a[i];
+    normB += b[i] * b[i];
+  }
+
+  const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+  if (magnitude === 0) return 0;
+
+  return dotProduct / magnitude;
+}
+
+/**
+ * Ollama Embedding API を呼び出し
+ */
+async function embedWithOllama(
+  text: string,
+  model: string,
+  endpoint: string
+): Promise<number[]> {
+  const response = await fetch(`${endpoint}/api/embeddings`, {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+    },
+    body: JSON.stringify({
+      model,
+      prompt: text,
+    }),
+  });
+
+  if (!response.ok) {
+    throw new Error(`Ollama embedding failed: ${response.status} ${response.statusText}`);
+  }
+
+  const data = await response.json() as { embedding: number[] };
+  return data.embedding;
+}
+
+/**
+ * OpenAI Embedding API を呼び出し
+ */
+async function embedWithOpenAI(
+  text: string,
+  model: string,
+  apiKey: string
+): Promise<number[]> {
+  const response = await fetch('https://api.openai.com/v1/embeddings', {
+    method: 'POST',
+    headers: {
+      'Content-Type': 'application/json',
+      'Authorization': `Bearer ${apiKey}`,
+    },
+    body: JSON.stringify({
+      model,
+      input: text,
+    }),
+  });
+
+  if (!response.ok) {
+    const errorText = await response.text();
+    throw new Error(`OpenAI embedding failed: ${response.status} ${errorText}`);
+  }
+
+  const data = await response.json() as {
+    data: Array<{ embedding: number[] }>;
+  };
+
+  return data.data[0].embedding;
+}
+
+/**
+ * テキストの埋め込みベクトルを生成
+ */
+export async function embed(text: string): Promise<EmbeddingResult> {
+  const config = getConfig();
+  const embeddingConfig = config.embedding;
+
+  const provider = embeddingConfig?.provider ?? 'ollama';
+  const model = embeddingConfig?.model ?? 'nomic-embed-text';
+
+  let embedding: number[];
+
+  switch (provider) {
+    case 'ollama': {
+      const endpoint = embeddingConfig?.options?.endpoint ?? 'http://localhost:11434';
+      embedding = await embedWithOllama(text, model, endpoint);
+      break;
+    }
+
+    case 'openai': {
+      const apiKey = embeddingConfig?.options?.apiKey ?? process.env.OPENAI_API_KEY;
+      if (!apiKey) {
+        throw new Error('OpenAI API key is required for embedding');
+      }
+      embedding = await embedWithOpenAI(text, model, apiKey);
+      break;
+    }
+
+    default:
+      throw new Error(`Unsupported embedding provider: ${provider}`);
+  }
+
+  return {
+    text,
+    embedding,
+    model,
+    dimensions: embedding.length,
+  };
+}
+
+/**
+ * 複数テキストの埋め込みベクトルを生成
+ */
+export async function embedBatch(texts: string[]): Promise<EmbeddingResult[]> {
+  const results: EmbeddingResult[] = [];
+
+  for (const text of texts) {
+    const result = await embed(text);
+    results.push(result);
+  }
+
+  return results;
+}
+
+/**
+ * 2つのテキストの類似度を計算
+ */
+export async function similarity(textA: string, textB: string): Promise<SimilarityResult> {
+  const [embA, embB] = await Promise.all([embed(textA), embed(textB)]);
+
+  const sim = cosineSimilarity(embA.embedding, embB.embedding);
+
+  return {
+    textA,
+    textB,
+    similarity: sim,
+  };
+}
+
+/**
+ * クエリに最も類似したテキストを検索
+ */
+export async function semanticSearch(
+  query: string,
+  documents: Array<{ text: string; metadata?: Record<string, unknown> }>,
+  options?: {
+    /** 返却する最大件数 */
+    topK?: number;
+    /** 最小類似度閾値 */
+    minScore?: number;
+  }
+): Promise<SearchResult[]> {
+  const topK = options?.topK ?? 5;
+  const minScore = options?.minScore ?? 0;
+
+  // クエリの埋め込みを生成
+  const queryEmbedding = await embed(query);
+
+  // 各ドキュメントの埋め込みを生成して類似度を計算
+  const results: SearchResult[] = [];
+
+  for (let i = 0; i < documents.length; i++) {
+    const doc = documents[i];
+    const docEmbedding = await embed(doc.text);
+    const score = cosineSimilarity(queryEmbedding.embedding, docEmbedding.embedding);
+
+    if (score >= minScore) {
+      results.push({
+        text: doc.text,
+        score,
+        index: i,
+        metadata: doc.metadata,
+      });
+    }
+  }
+
+  // スコア降順でソートしてtopK件を返却
+  results.sort((a, b) => b.score - a.score);
+
+  return results.slice(0, topK);
+}
+
+/**
+ * ベクトルを使った高速セマンティック検索
+ * （事前に埋め込みが計算済みの場合）
+ */
+export function semanticSearchWithVectors(
+  queryEmbedding: number[],
+  documentEmbeddings: Array<{
+    embedding: number[];
+    text: string;
+    metadata?: Record<string, unknown>;
+  }>,
+  options?: {
+    topK?: number;
+    minScore?: number;
+  }
+): SearchResult[] {
+  const topK = options?.topK ?? 5;
+  const minScore = options?.minScore ?? 0;
+
+  const results: SearchResult[] = [];
+
+  for (let i = 0; i < documentEmbeddings.length; i++) {
+    const doc = documentEmbeddings[i];
+    const score = cosineSimilarity(queryEmbedding, doc.embedding);
+
+    if (score >= minScore) {
+      results.push({
+        text: doc.text,
+        score,
+        index: i,
+        metadata: doc.metadata,
+      });
+    }
+  }
+
+  results.sort((a, b) => b.score - a.score);
+
+  return results.slice(0, topK);
+}