@coeiro-operator/mcp 1.0.0

package/README.md

@@ -0,0 +1,86 @@
+# @coeiro-operator/mcp
+
+COEIROINK音声合成のMCP（Model Context Protocol）サーバー
+
+Claude Codeで音声対話機能を実現するMCPサーバーです。
+
+## インストール
+
+### 方法1: グローバルインストール（推奨）
+
+```bash
+# インストール
+npm install -g @coeiro-operator/mcp
+
+# MCPサーバーを登録
+claude mcp add coeiro-operator
+```
+
+### 方法2: npxで直接実行
+
+`claude_desktop_config.json`に直接追加：
+
+```json
+{
+  "mcpServers": {
+    "coeiro-operator": {
+      "command": "npx",
+      "args": ["-y", "@coeiro-operator/mcp"]
+    }
+  }
+}
+```
+
+※ `npx @coeiro-operator/mcp`は内部的に`coeiro-operator`コマンドを実行します
+
+## 提供される機能
+
+### 音声合成
+
+- `say` - テキストを音声で読み上げ
+- `operator_assign` - オペレータ（音声キャラクター）の割り当て
+- `operator_release` - オペレータの解放
+- `operator_status` - 現在のオペレータ状態確認
+- `operator_available` - 利用可能なオペレータ一覧
+- `operator_styles` - 音声スタイル一覧
+
+### ユーザー辞書
+
+- `dictionary_register` - 単語の読み方を登録
+
+### デバッグ
+
+- `debug_logs` - デバッグログの取得
+- `parallel_generation_control` - 並行生成制御
+
+## 使用例（Claude Codeでの会話）
+
+```
+ユーザー: こんにちはと音声で言って
+
+Claude Code: [say ツールを使用して「こんにちは」を音声出力]
+
+ユーザー: つくよみちゃんに切り替えて
+
+Claude Code: [operator_assign ツールでtsukuyomiに切り替え]
+
+ユーザー: ひそひそ声でお疲れ様と言って
+
+Claude Code: [say ツールでstyle: "ひそひそ"を指定して音声出力]
+```
+
+※ MCPツールはClaude Codeが自動的に判断して使用します
+
+## 動作要件
+
+- Node.js 18以上
+- COEIROINK本体が起動済み（http://localhost:50032）
+- Claude Code（MCPクライアント）
+
+## 詳細
+
+完全なドキュメントは [GitHub](https://github.com/otolab/coeiro-operator) を参照してください。
+
+## ライセンス
+
+MIT

package/dist/server.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node --no-deprecation
+export {};
+//# sourceMappingURL=server.d.ts.map

package/dist/server.js

@@ -0,0 +1,833 @@
+#!/usr/bin/env node --no-deprecation
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { z } from 'zod';
+import * as path from 'path';
+import { SayCoeiroink } from '@coeiro-operator/audio';
+import { ConfigManager, getConfigDir, OperatorManager, DictionaryService, TerminalBackground } from '@coeiro-operator/core';
+import { logger, LoggerPresets } from '@coeiro-operator/common';
+// コマンドライン引数の解析
+const parseArguments = () => {
+    const args = process.argv.slice(2);
+    let isDebugMode = false;
+    let configPath;
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        if (arg === '--debug' || arg === '-d') {
+            isDebugMode = true;
+        }
+        else if (arg === '--config' || arg === '-c') {
+            configPath = args[i + 1];
+            i++; // 次の引数をスキップ
+        }
+        else if (arg.startsWith('--config=')) {
+            configPath = arg.split('=')[1];
+        }
+    }
+    return { isDebugMode, configPath };
+};
+const { isDebugMode, configPath } = parseArguments();
+// デバッグモードの場合は詳細ログ、そうでなければMCPサーバーモード
+if (isDebugMode) {
+    LoggerPresets.mcpServerDebugWithAccumulation(); // デバッグモード：全レベル出力・蓄積
+    logger.info('DEBUG MODE: Verbose logging enabled (--debug flag detected)');
+}
+else {
+    LoggerPresets.mcpServerWithAccumulation(); // 通常モード：info以上のみ蓄積
+}
+if (configPath) {
+    logger.info(`Using config file: ${configPath}`);
+}
+const server = new McpServer({
+    name: 'coeiro-operator',
+    version: '1.0.0',
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// top-level awaitを使用した同期的初期化
+logger.info('Initializing COEIRO Operator services...');
+// 環境変数のデバッグ出力
+logger.debug('Environment variables check:', {
+    TERM_PROGRAM: process.env.TERM_PROGRAM,
+    ITERM_SESSION_ID: process.env.ITERM_SESSION_ID,
+    TERM_SESSION_ID: process.env.TERM_SESSION_ID,
+    NODE_ENV: process.env.NODE_ENV
+});
+let sayCoeiroink;
+let operatorManager;
+let dictionaryService;
+let terminalBackground = null;
+try {
+    const configDir = configPath ? path.dirname(configPath) : await getConfigDir();
+    const configManager = new ConfigManager(configDir);
+    await configManager.buildDynamicConfig();
+    // TerminalBackgroundを初期化
+    terminalBackground = new TerminalBackground(configManager);
+    sayCoeiroink = new SayCoeiroink(configManager);
+    logger.info('Initializing SayCoeiroink...');
+    await sayCoeiroink.initialize();
+    logger.info('Building dynamic config...');
+    await sayCoeiroink.buildDynamicConfig();
+    logger.info('Initializing OperatorManager...');
+    operatorManager = new OperatorManager();
+    await operatorManager.initialize();
+    logger.info('Initializing Dictionary...');
+    const config = await configManager.getFullConfig();
+    dictionaryService = new DictionaryService(config?.connection);
+    await dictionaryService.initialize();
+    logger.info('SayCoeiroink, OperatorManager and Dictionary initialized successfully');
+}
+catch (error) {
+    logger.error('Failed to initialize services:', error.message);
+    logger.error('Error stack:', error.stack);
+    logger.warn('Using fallback configuration...');
+    // フォールバック設定で初期化
+    try {
+        const fallbackConfigDir = await getConfigDir();
+        const fallbackConfigManager = new ConfigManager(fallbackConfigDir);
+        await fallbackConfigManager.buildDynamicConfig();
+        // TerminalBackgroundを初期化
+        terminalBackground = new TerminalBackground(fallbackConfigManager);
+        sayCoeiroink = new SayCoeiroink(fallbackConfigManager);
+        await sayCoeiroink.initialize();
+        await sayCoeiroink.buildDynamicConfig();
+        operatorManager = new OperatorManager();
+        await operatorManager.initialize();
+        dictionaryService = new DictionaryService();
+        await dictionaryService.initialize();
+        logger.info('Fallback initialization completed');
+    }
+    catch (fallbackError) {
+        logger.error('Fallback initialization also failed:', fallbackError.message);
+        throw fallbackError;
+    }
+}
+// Utility functions for operator assignment
+function validateOperatorInput(operator) {
+    if (operator !== undefined && operator !== '' && operator !== null) {
+        if (/[\u3040-\u309F\u30A0-\u30FF\u4E00-\u9FAF]/.test(operator)) {
+            throw new Error('オペレータ名は英語表記で指定してください（例: tsukuyomi, alma）。日本語は使用できません。');
+        }
+    }
+}
+async function assignOperator(manager, operator, style) {
+    if (operator && operator !== '' && operator !== null) {
+        return await manager.assignSpecificOperator(operator, style);
+    }
+    else {
+        return await manager.assignRandomOperator(style);
+    }
+}
+function extractStyleInfo(character) {
+    return (character.speaker?.styles || []).map(style => ({
+        id: style.styleId.toString(),
+        name: style.styleName,
+        personality: character.personality,
+        speakingStyle: character.speakingStyle,
+    }));
+}
+function formatAssignmentResult(assignResult, availableStyles) {
+    let resultText = `${assignResult.characterName} (${assignResult.characterId}) をアサインしました。\n\n`;
+    if (assignResult.currentStyle) {
+        resultText += `📍 現在のスタイル: ${assignResult.currentStyle.styleName}\n`;
+        resultText += `   性格: ${assignResult.currentStyle.personality}\n`;
+        resultText += `   話し方: ${assignResult.currentStyle.speakingStyle}\n\n`;
+    }
+    if (availableStyles.length > 1) {
+        resultText += `🎭 利用可能なスタイル（切り替え可能）:\n`;
+        availableStyles.forEach(style => {
+            const isCurrent = style.id === assignResult.currentStyle?.styleId;
+            const marker = isCurrent ? '→ ' : '  ';
+            resultText += `${marker}${style.id}: ${style.name}\n`;
+            resultText += `    性格: ${style.personality}\n`;
+            resultText += `    話し方: ${style.speakingStyle}\n`;
+        });
+    }
+    else {
+        resultText += `ℹ️  このキャラクターは1つのスタイルのみ利用可能です。\n`;
+    }
+    if (assignResult.greeting) {
+        resultText += `\n💬 "${assignResult.greeting}"\n`;
+    }
+    return resultText;
+}
+// Utility functions for operator styles
+async function getTargetCharacter(manager, characterId) {
+    if (characterId) {
+        try {
+            const character = await manager.getCharacterInfo(characterId);
+            if (!character) {
+                throw new Error(`キャラクター '${characterId}' が見つかりません`);
+            }
+            return { character, characterId };
+        }
+        catch (error) {
+            throw new Error(`キャラクター '${characterId}' が見つかりません`);
+        }
+    }
+    else {
+        const currentOperator = await manager.showCurrentOperator();
+        if (!currentOperator.characterId) {
+            throw new Error('現在オペレータが割り当てられていません。まず operator_assign を実行してください。');
+        }
+        const character = await manager.getCharacterInfo(currentOperator.characterId);
+        if (!character) {
+            throw new Error(`現在のオペレータ '${currentOperator.characterId}' のキャラクター情報が見つかりません`);
+        }
+        return { character, characterId: currentOperator.characterId };
+    }
+}
+function formatStylesResult(character, availableStyles) {
+    let resultText = `🎭 ${character.speaker?.speakerName || character.characterId} のスタイル情報\n\n`;
+    resultText += `📋 基本情報:\n`;
+    resultText += `   性格: ${character.personality}\n`;
+    resultText += `   話し方: ${character.speakingStyle}\n`;
+    resultText += `   デフォルトスタイル: ${character.defaultStyle}\n\n`;
+    if (availableStyles.length > 0) {
+        resultText += `🎨 利用可能なスタイル (${availableStyles.length}種類):\n`;
+        availableStyles.forEach((style, index) => {
+            const isDefault = style.id === character.defaultStyle;
+            const marker = isDefault ? '★ ' : `${index + 1}. `;
+            resultText += `${marker}${style.id}: ${style.name}\n`;
+            resultText += `   性格: ${style.personality}\n`;
+            resultText += `   話し方: ${style.speakingStyle}\n`;
+            if (isDefault) {
+                resultText += `   (デフォルトスタイル)\n`;
+            }
+            resultText += `\n`;
+        });
+    }
+    else {
+        resultText += `⚠️  利用可能なスタイルがありません。\n`;
+    }
+    return resultText;
+}
+// operator-manager操作ツール
+server.registerTool('operator_assign', {
+    description: 'オペレータをランダム選択して割り当てます。アサイン後に現在のスタイルと利用可能な他のスタイル情報を表示します。スタイル切り替えはsayツールのstyleパラメータで日本語名を指定します（例: say({message: "テスト", style: "ひそひそ"})）。',
+    inputSchema: {
+        operator: z
+            .string()
+            .optional()
+            .describe("指定するオペレータ名（英語表記、例: 'tsukuyomi', 'alma'など。省略時または空文字列時はランダム選択。日本語表記は無効）"),
+        style: z
+            .string()
+            .optional()
+            .describe("指定するスタイル名（例: 'normal', 'ura', 'sleepy'など。省略時はキャラクターのデフォルト設定に従う）"),
+    },
+}, async (args) => {
+    const { operator, style } = args || {};
+    logger.info('オペレータアサイン開始', { operator, style });
+    validateOperatorInput(operator);
+    try {
+        const assignResult = await assignOperator(operatorManager, operator, style);
+        logger.info('オペレータアサイン成功', {
+            characterId: assignResult.characterId,
+            characterName: assignResult.characterName,
+        });
+        // 背景画像を切り替え
+        if (terminalBackground) {
+            logger.error('🔧 TerminalBackground instance exists');
+            const isEnabled = await terminalBackground.isEnabled();
+            logger.error('📊 Terminal background enabled check:', { isEnabled });
+            if (isEnabled) {
+                logger.error('🔄 Switching background for character:', assignResult.characterId);
+                await terminalBackground.switchCharacter(assignResult.characterId);
+                logger.error('✅ 背景画像切り替え完了', { characterId: assignResult.characterId });
+            }
+            else {
+                logger.error('⚠️ Terminal background is not enabled');
+            }
+        }
+        else {
+            logger.error('❌ TerminalBackground instance is null');
+        }
+        const character = await operatorManager.getCharacterInfo(assignResult.characterId);
+        if (!character) {
+            throw new Error(`キャラクター情報が見つかりません: ${assignResult.characterId}`);
+        }
+        const availableStyles = extractStyleInfo(character);
+        const resultText = formatAssignmentResult(assignResult, availableStyles);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: resultText,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`オペレータ割り当てエラー: ${error.message}`);
+    }
+});
+server.registerTool('operator_release', {
+    description: '現在のオペレータを解放します',
+    inputSchema: {},
+}, async () => {
+    try {
+        const result = await operatorManager.releaseOperator();
+        let releaseMessage;
+        if (result.wasAssigned) {
+            releaseMessage = `オペレータを解放しました: ${result.characterName}`;
+            logger.info(`オペレータ解放: ${result.characterId}`);
+        }
+        else {
+            releaseMessage = 'オペレータは割り当てられていません';
+            logger.info('オペレータ未割り当て状態');
+        }
+        // 背景画像をクリア（オペレータの有無に関わらず実行）
+        if (terminalBackground) {
+            if (await terminalBackground.isEnabled()) {
+                await terminalBackground.clearBackground();
+                logger.info('背景画像クリア完了');
+            }
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: releaseMessage,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`オペレータ解放エラー: ${error.message}`);
+    }
+});
+server.registerTool('operator_status', {
+    description: '現在のオペレータ状況を確認します',
+    inputSchema: {},
+}, async () => {
+    try {
+        const status = await operatorManager.showCurrentOperator();
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: status.message,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`オペレータ状況確認エラー: ${error.message}`);
+    }
+});
+server.registerTool('operator_available', {
+    description: '利用可能なオペレータ一覧を表示します',
+    inputSchema: {},
+}, async () => {
+    try {
+        const result = await operatorManager.getAvailableOperators();
+        let text = result.available.length > 0
+            ? `利用可能なオペレータ: ${result.available.join(', ')}`
+            : '利用可能なオペレータがありません';
+        if (result.busy.length > 0) {
+            text += `\n仕事中のオペレータ: ${result.busy.join(', ')}`;
+        }
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: text,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`利用可能オペレータ確認エラー: ${error.message}`);
+    }
+});
+// say音声出力ツール（src/say/index.js使用）
+server.registerTool('say', {
+    description: 'COEIROINKを使って日本語音声を非同期で出力します（低レイテンシストリーミング対応、即座にレスポンス）',
+    inputSchema: {
+        message: z.string().describe('発話させるメッセージ（日本語）'),
+        voice: z.string().optional().describe('音声ID（省略時はオペレータ設定を使用）'),
+        rate: z.number().optional().describe('話速（WPM、デフォルト200）'),
+        style: z
+            .string()
+            .optional()
+            .describe("スタイル名（日本語名をそのまま指定。例: ディアちゃんの場合 'のーまる', 'ひそひそ', 'セクシー'）"),
+    },
+}, async (args) => {
+    const { message, voice, rate, style } = args;
+    try {
+        logger.debug('=== SAY TOOL DEBUG START ===');
+        logger.debug(`Input parameters:`);
+        logger.debug(`  message: "${message}"`);
+        logger.debug(`  voice: ${voice || 'null (will use operator voice)'}`);
+        logger.debug(`  rate: ${rate || 'undefined (will use config default)'}`);
+        logger.debug(`  style: ${style || 'undefined (will use operator default)'}`);
+        // Issue #58: オペレータ未アサイン時の再アサイン促進メッセージ
+        const currentOperator = await operatorManager.showCurrentOperator();
+        if (!currentOperator.characterId) {
+            // オペレータ未割り当て時に背景画像をクリア
+            if (terminalBackground) {
+                if (await terminalBackground.isEnabled()) {
+                    await terminalBackground.clearBackground();
+                    logger.info('オペレータ未割り当てのため背景画像をクリア');
+                }
+            }
+            // 利用可能なオペレータを取得
+            let availableOperators = [];
+            try {
+                const result = await operatorManager.getAvailableOperators();
+                availableOperators = result.available;
+            }
+            catch (error) {
+                logger.warn(`Failed to get available operators: ${error.message}`);
+            }
+            let guidanceMessage = '⚠️  オペレータが割り当てられていません。\n\n';
+            guidanceMessage += '🔧 次の手順で進めてください：\n';
+            guidanceMessage += '1. operator_assign を実行してオペレータを選択\n';
+            guidanceMessage += '2. 再度 say コマンドで音声を生成\n\n';
+            if (availableOperators.length > 0) {
+                guidanceMessage += `🎭 利用可能なオペレータ: ${availableOperators.join(', ')}\n\n`;
+                guidanceMessage +=
+                    "💡 例：operator_assign ツールで 'tsukuyomi' を選択する場合は、operator パラメータに 'tsukuyomi' を指定してください。";
+            }
+            else {
+                guidanceMessage +=
+                    '❌ 現在利用可能なオペレータがありません。しばらく待ってから再試行してください。';
+            }
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: guidanceMessage,
+                    },
+                ],
+            };
+        }
+        // Issue #58: 動的タイムアウト延長 - sayコマンド実行時にオペレータ予約を延長
+        // ベストエフォート非同期処理（エラーは無視、音声生成をブロックしない）
+        operatorManager
+            .refreshOperatorReservation()
+            .then(refreshSuccess => {
+            if (refreshSuccess) {
+                logger.debug(`Operator reservation refreshed for: ${currentOperator.characterId}`);
+            }
+            else {
+                logger.debug(`Could not refresh operator reservation for: ${currentOperator.characterId} (not critical)`);
+            }
+        })
+            .catch(error => {
+            logger.debug(`Operator reservation refresh failed: ${error.message} (not critical)`);
+        });
+        // スタイル検証（事前チェック）
+        if (style && currentOperator.characterId) {
+            try {
+                const character = await operatorManager.getCharacterInfo(currentOperator.characterId);
+                if (!character) {
+                    throw new Error(`キャラクター情報が取得できません`);
+                }
+                // 利用可能なスタイルを取得
+                const availableStyles = character.speaker?.styles || [];
+                // 指定されたスタイルが存在するか確認
+                const styleExists = availableStyles.some(s => s.styleName === style);
+                if (!styleExists) {
+                    const styleNames = availableStyles.map(s => s.styleName);
+                    throw new Error(`指定されたスタイル '${style}' が見つかりません。利用可能なスタイル: ${styleNames.join(', ')}`);
+                }
+            }
+            catch (error) {
+                logger.error(`スタイル検証エラー: ${error.message}`);
+                throw error;
+            }
+        }
+        // 設定情報をログ出力
+        // NOTE: ConfigManagerはすでにsayCoeiroink内部で管理されているため、
+        // ここでは設定のログ出力をスキップ
+        logger.debug('Audio config is managed internally by SayCoeiroink');
+        logger.debug('==============================');
+        // MCP設計: 音声合成タスクをキューに投稿のみ（再生完了を待たない）
+        // - synthesize() はキューに追加して即座にレスポンス
+        // - 実際の音声合成・再生は背景のSpeechQueueで非同期処理
+        // - CLIとは異なり、MCPではウォームアップ・完了待機は実行しない
+        const result = sayCoeiroink.synthesize(message, {
+            voice: voice || null,
+            rate: rate || undefined,
+            style: style || undefined,
+            allowFallback: false, // MCPツールではオペレータが必須
+        });
+        // 結果をログ出力
+        logger.debug(`Result: ${JSON.stringify(result)}`);
+        const modeInfo = `発声キューに追加 - オペレータ: ${currentOperator.characterId}, タスクID: ${result.taskId}`;
+        logger.info(modeInfo);
+        logger.debug('=== SAY TOOL DEBUG END ===');
+        // 即座にレスポンスを返す（音声合成の完了を待たない）
+        const responseText = `音声合成を開始しました - オペレータ: ${currentOperator.characterId}`;
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: responseText,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        logger.debug(`SAY TOOL ERROR: ${error.message}`);
+        logger.debug(`Stack trace: ${error.stack}`);
+        throw new Error(`音声出力エラー: ${error.message}`);
+    }
+});
+// ログ取得ツール
+server.registerTool('debug_logs', {
+    description: 'デバッグ用ログの取得と表示。ログレベル・時刻・検索条件による絞り込み、統計情報の表示が可能',
+    inputSchema: {
+        action: z
+            .enum(['get', 'stats', 'clear'])
+            .describe('実行するアクション: get=ログ取得, stats=統計表示, clear=ログクリア'),
+        level: z
+            .array(z.enum(['error', 'warn', 'info', 'verbose', 'debug']))
+            .optional()
+            .describe('取得するログレベル（複数選択可）'),
+        since: z.string().optional().describe('この時刻以降のログを取得（ISO 8601形式）'),
+        limit: z
+            .number()
+            .min(1)
+            .max(1000)
+            .optional()
+            .describe('取得する最大ログエントリ数（1-1000）'),
+        search: z.string().optional().describe('ログメッセージ内の検索キーワード'),
+        format: z
+            .enum(['formatted', 'raw'])
+            .optional()
+            .describe('出力形式: formatted=整形済み, raw=生データ'),
+    },
+}, async (args) => {
+    const { action = 'get', level, since, limit, search, format = 'formatted' } = args || {};
+    try {
+        switch (action) {
+            case 'get': {
+                const options = {};
+                if (level && level.length > 0) {
+                    options.level = level;
+                }
+                if (since) {
+                    try {
+                        options.since = new Date(since);
+                    }
+                    catch {
+                        throw new Error(`無効な日時形式です: ${since}`);
+                    }
+                }
+                if (limit) {
+                    options.limit = limit;
+                }
+                if (search) {
+                    options.search = search;
+                }
+                const entries = logger.getLogEntries(options);
+                if (entries.length === 0) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: '条件に一致するログエントリが見つかりませんでした。',
+                            },
+                        ],
+                    };
+                }
+                let resultText;
+                if (format === 'raw') {
+                    resultText = `ログエントリ (${entries.length}件):\n\n${JSON.stringify(entries, null, 2)}`;
+                }
+                else {
+                    resultText = `ログエントリ (${entries.length}件):\n\n`;
+                    entries.forEach((entry, index) => {
+                        resultText += `${index + 1}. [${entry.level.toUpperCase()}] ${entry.timestamp}\n`;
+                        resultText += `   ${entry.message}\n`;
+                        if (entry.args && entry.args.length > 0) {
+                            resultText += `   引数: ${entry.args
+                                .map(arg => (typeof arg === 'object' ? JSON.stringify(arg) : String(arg)))
+                                .join(', ')}\n`;
+                        }
+                        resultText += '\n';
+                    });
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: resultText,
+                        },
+                    ],
+                };
+            }
+            case 'stats': {
+                const stats = logger.getLogStats();
+                const statsText = `📊 ログ統計情報\n\n` +
+                    `総エントリ数: ${stats.totalEntries}\n\n` +
+                    `レベル別エントリ数:\n` +
+                    `  ERROR: ${stats.entriesByLevel.error}\n` +
+                    `  WARN:  ${stats.entriesByLevel.warn}\n` +
+                    `  INFO:  ${stats.entriesByLevel.info}\n` +
+                    `  VERB:  ${stats.entriesByLevel.verbose}\n` +
+                    `  DEBUG: ${stats.entriesByLevel.debug}\n\n` +
+                    `時刻範囲:\n` +
+                    `  最古: ${stats.oldestEntry || 'なし'}\n` +
+                    `  最新: ${stats.newestEntry || 'なし'}\n\n` +
+                    `蓄積モード: ${logger.isAccumulating() ? 'ON' : 'OFF'}`;
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: statsText,
+                        },
+                    ],
+                };
+            }
+            case 'clear': {
+                const beforeCount = logger.getLogStats().totalEntries;
+                logger.clearLogEntries();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `ログエントリをクリアしました（${beforeCount}件削除）`,
+                        },
+                    ],
+                };
+            }
+            default:
+                throw new Error(`無効なアクション: ${action}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`ログ取得エラー: ${error.message}`);
+    }
+});
+// スタイル情報表示ツール
+server.registerTool('operator_styles', {
+    description: '現在のオペレータまたは指定したキャラクターの利用可能なスタイル一覧を表示します。キャラクターの基本情報、全スタイルの詳細（性格・話し方）、スタイル選択方法を確認できます。スタイル切り替えにはsayツールのstyleパラメータで日本語名を使用してください。',
+    inputSchema: {
+        character: z
+            .string()
+            .optional()
+            .describe('キャラクターID（省略時は現在のオペレータのスタイル情報を表示）'),
+    },
+}, async (args) => {
+    const { character } = args || {};
+    try {
+        let targetCharacter;
+        let targetCharacterId;
+        if (character) {
+            // 指定されたキャラクターの情報を取得
+            try {
+                targetCharacter = await operatorManager.getCharacterInfo(character);
+                if (!targetCharacter) {
+                    throw new Error(`キャラクター '${character}' が見つかりません`);
+                }
+                targetCharacterId = character;
+            }
+            catch (error) {
+                throw new Error(`キャラクター '${character}' が見つかりません`);
+            }
+        }
+        else {
+            // 現在のオペレータの情報を取得
+            const currentOperator = await operatorManager.showCurrentOperator();
+            if (!currentOperator.characterId) {
+                throw new Error('現在オペレータが割り当てられていません。まず operator_assign を実行してください。');
+            }
+            targetCharacter = await operatorManager.getCharacterInfo(currentOperator.characterId);
+            targetCharacterId = currentOperator.characterId;
+            if (!targetCharacter) {
+                throw new Error(`現在のオペレータ '${currentOperator.characterId}' のキャラクター情報が見つかりません`);
+            }
+        }
+        // スタイル情報を取得
+        const availableStyles = extractStyleInfo(targetCharacter);
+        // 結果を整形
+        const resultText = formatStylesResult(targetCharacter, availableStyles);
+        return {
+            content: [
+                {
+                    type: 'text',
+                    text: resultText,
+                },
+            ],
+        };
+    }
+    catch (error) {
+        throw new Error(`スタイル情報取得エラー: ${error.message}`);
+    }
+});
+// 並行生成制御ツール
+server.registerTool('parallel_generation_control', {
+    description: 'チャンク並行生成機能の制御と設定管理を行います。生成の並行数、待機時間、先読み数、初回ポーズ機能などを調整できます。',
+    inputSchema: {
+        action: z
+            .enum(['enable', 'disable', 'status', 'update_options'])
+            .describe('実行するアクション'),
+        options: z
+            .object({
+            maxConcurrency: z.number().min(1).max(5).optional().describe('最大並行生成数（1-5）'),
+            delayBetweenRequests: z
+                .number()
+                .min(0)
+                .max(1000)
+                .optional()
+                .describe('リクエスト間隔（ms、0-1000）'),
+            bufferAheadCount: z.number().min(0).max(3).optional().describe('先読みチャンク数（0-3）'),
+            pauseUntilFirstComplete: z
+                .boolean()
+                .optional()
+                .describe('初回チャンク完了まで並行生成をポーズ（レイテンシ改善）'),
+        })
+            .optional()
+            .describe('更新するオプション（action=update_optionsの場合）'),
+    },
+}, async (args) => {
+    const { action, options } = args || {};
+    try {
+        switch (action) {
+            case 'enable':
+                sayCoeiroink.setParallelGenerationEnabled(true);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '✅ 並行チャンク生成を有効化しました。\n\n⚡ 効果:\n- 複数チャンクの同時生成により高速化\n- レスポンシブな音声再生開始\n- 体感的なレイテンシ削減',
+                        },
+                    ],
+                };
+            case 'disable':
+                sayCoeiroink.setParallelGenerationEnabled(false);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: '⏸️ 並行チャンク生成を無効化しました。\n\n🔄 従来の逐次生成モードに戻りました。\n- 安定性重視の動作\n- メモリ使用量削減',
+                        },
+                    ],
+                };
+            case 'status': {
+                const currentOptions = sayCoeiroink.getStreamControllerOptions();
+                const stats = sayCoeiroink.getGenerationStats();
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `📊 並行生成ステータス\n\n` +
+                                `🎛️ 設定:\n` +
+                                `  - 状態: ${currentOptions.maxConcurrency > 1 ? '✅ 並行生成' : '❌ 逐次生成'}\n` +
+                                `  - 最大並行数: ${currentOptions.maxConcurrency} ${currentOptions.maxConcurrency === 1 ? '(逐次モード)' : '(並行モード)'}\n` +
+                                `  - リクエスト間隔: ${currentOptions.delayBetweenRequests}ms\n` +
+                                `  - 先読み数: ${currentOptions.bufferAheadCount}\n` +
+                                `  - 初回ポーズ: ${currentOptions.pauseUntilFirstComplete ? '✅ 有効' : '❌ 無効'}\n\n` +
+                                `📈 現在の統計:\n` +
+                                `  - アクティブタスク: ${stats.activeTasks}\n` +
+                                `  - 完了済み結果: ${stats.completedResults}\n` +
+                                `  - メモリ使用量: ${(stats.totalMemoryUsage / 1024).toFixed(1)}KB`,
+                        },
+                    ],
+                };
+            }
+            case 'update_options':
+                if (options) {
+                    sayCoeiroink.updateStreamControllerOptions(options);
+                    const updatedOptions = sayCoeiroink.getStreamControllerOptions();
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `⚙️ オプション更新完了\n\n` +
+                                    `🔧 新しい設定:\n` +
+                                    `  - 最大並行数: ${updatedOptions.maxConcurrency} ${updatedOptions.maxConcurrency === 1 ? '(逐次モード)' : '(並行モード)'}\n` +
+                                    `  - リクエスト間隔: ${updatedOptions.delayBetweenRequests}ms\n` +
+                                    `  - 先読み数: ${updatedOptions.bufferAheadCount}\n` +
+                                    `  - 初回ポーズ: ${updatedOptions.pauseUntilFirstComplete ? '✅ 有効' : '❌ 無効'}\n\n` +
+                                    `💡 次回の音声合成から適用されます。`,
+                            },
+                        ],
+                    };
+                }
+                else {
+                    throw new Error('update_optionsアクションにはoptionsパラメータが必要です');
+                }
+            default:
+                throw new Error(`無効なアクション: ${action}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`並行生成制御エラー: ${error.message}`);
+    }
+});
+// 辞書登録ツール
+server.registerTool('dictionary_register', {
+    description: 'COEIROINKのユーザー辞書に単語を登録します。専門用語や固有名詞の読み方を正確に制御できます。',
+    inputSchema: {
+        word: z.string().describe('登録する単語（半角英数字も可、自動で全角変換されます）'),
+        yomi: z.string().describe('読み方（全角カタカナ）'),
+        accent: z.number().describe('アクセント位置（0:平板型、1以上:該当モーラが高い）'),
+        numMoras: z.number().describe('モーラ数（カタカナの音節数）'),
+    },
+}, async (args) => {
+    const { word, yomi, accent, numMoras } = args;
+    try {
+        // 接続確認
+        const isConnected = await dictionaryService.checkConnection();
+        if (!isConnected) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: '❌ COEIROINKサーバーに接続できません。\n' +
+                            'サーバーが起動していることを確認してください。',
+                    },
+                ],
+            };
+        }
+        // 単語を登録（DictionaryServiceが永続化まで処理）
+        const success = await dictionaryService.addWord({ word, yomi, accent, numMoras });
+        if (success) {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `✅ 単語を辞書に登録しました\n\n` +
+                            `単語: ${word}\n` +
+                            `読み方: ${yomi}\n` +
+                            `アクセント: ${accent}\n` +
+                            `モーラ数: ${numMoras}\n\n` +
+                            `💾 辞書データは永続化され、次回起動時に自動登録されます。`,
+                    },
+                ],
+            };
+        }
+        else {
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: `❌ 辞書登録に失敗しました`,
+                    },
+                ],
+            };
+        }
+    }
+    catch (error) {
+        logger.error(`Dictionary registration error:`, error);
+        throw new Error(`辞書登録エラー: ${error.message}`);
+    }
+});
+// サーバーの起動
+async function main() {
+    const transport = new StdioServerTransport();
+    logger.info('Say COEIROINK MCP Server starting...');
+    await server.connect(transport);
+    logger.info('Say COEIROINK MCP Server started');
+}
+main().catch(error => {
+    logger.error('Server error:', error);
+    process.exit(1);
+});
+//# sourceMappingURL=server.js.map

package/package.json

@@ -0,0 +1,59 @@
+{
+  "name": "@coeiro-operator/mcp",
+  "version": "1.0.0",
+  "description": "MCP server for COEIRO Operator",
+  "type": "module",
+  "main": "dist/server.js",
+  "types": "dist/server.d.ts",
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64",
+    "ia32"
+  ],
+  "bin": {
+    "coeiro-operator": "./dist/server.js"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "start": "node dist/server.js",
+    "test": "vitest",
+    "test:watch": "vitest --watch",
+    "type-check": "tsc --noEmit",
+    "lint": "eslint src --ext .ts,.js",
+    "format": "prettier --write \"src/**/*.{ts,js,json,md}\""
+  },
+  "dependencies": {
+    "@coeiro-operator/common": "^1.0.0",
+    "@coeiro-operator/core": "^1.0.0",
+    "@coeiro-operator/audio": "^1.0.0",
+    "@modelcontextprotocol/sdk": "^1.17.0"
+  },
+  "devDependencies": {
+    "@types/node": "^22.18.3",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "mcp",
+    "server",
+    "coeiroink"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/otolab/coeiro-operator.git",
+    "directory": "packages/mcp"
+  },
+  "homepage": "https://github.com/otolab/coeiro-operator#readme",
+  "bugs": {
+    "url": "https://github.com/otolab/coeiro-operator/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}