@coeiro-operator/cli 1.0.0

package/README.md

@@ -0,0 +1,81 @@
+# @coeiro-operator/cli
+
+COEIROINKと連携するCLIツール集
+
+## インストール
+
+```bash
+npm install -g @coeiro-operator/cli
+```
+
+## コマンド
+
+### say-coeiroink
+
+COEIROINK音声合成コマンド（macOS sayコマンド互換）
+
+```bash
+# 基本使用
+say-coeiroink "こんにちは"
+
+# 音声一覧表示
+say-coeiroink -v "?"
+
+# 話速調整（WPM）
+say-coeiroink -r 150 "ゆっくり話します"
+
+# ファイル出力
+say-coeiroink -o output.wav "保存テスト"
+
+# スタイル指定
+say-coeiroink --style "セクシー" "別のスタイルで話します"
+```
+
+### operator-manager
+
+ターミナルセッションのオペレータ管理
+
+```bash
+# オペレータ割り当て（ランダム）
+operator-manager assign
+
+# 特定キャラクターを指定
+operator-manager assign tsukuyomi
+
+# 現在の状態確認
+operator-manager status
+
+# オペレータ解放
+operator-manager release
+
+# 利用可能なオペレータ一覧
+operator-manager available
+```
+
+### dictionary-register
+
+COEIROINK用語辞書登録
+
+```bash
+# 単語登録
+dictionary-register "COEIROINK" "コエイロインク" 0 7
+
+# パラメータ
+# - 単語（表記）
+# - 読み方（カタカナ）
+# - アクセント位置
+# - モーラ数
+```
+
+## 動作要件
+
+- Node.js 18以上
+- COEIROINK本体が起動済み（http://localhost:50032）
+
+## 詳細
+
+完全なドキュメントは [GitHub](https://github.com/otolab/coeiro-operator) を参照してください。
+
+## ライセンス
+
+MIT

package/dist/dictionary-register.d.ts

@@ -0,0 +1,12 @@
+#!/usr/bin/env node --no-deprecation
+/**
+ * COEIROINK ユーザー辞書登録 CLIツール
+ *
+ * 使用方法:
+ * dictionary-register                       # デフォルト技術用語を登録
+ * dictionary-register --preset all          # 全プリセット登録
+ * dictionary-register --file dict.json      # カスタム辞書ファイル
+ * dictionary-register --word KARTE --yomi カルテ --accent 1 --moras 3
+ */
+export {};
+//# sourceMappingURL=dictionary-register.d.ts.map

package/dist/dictionary-register.js

@@ -0,0 +1,212 @@
+#!/usr/bin/env node --no-deprecation
+/**
+ * COEIROINK ユーザー辞書登録 CLIツール
+ *
+ * 使用方法:
+ * dictionary-register                       # デフォルト技術用語を登録
+ * dictionary-register --preset all          # 全プリセット登録
+ * dictionary-register --file dict.json      # カスタム辞書ファイル
+ * dictionary-register --word KARTE --yomi カルテ --accent 1 --moras 3
+ */
+import { Command } from 'commander';
+import fs from 'fs';
+import { DictionaryService, DEFAULT_TECHNICAL_WORDS, CHARACTER_NAME_WORDS } from '@coeiro-operator/core';
+const program = new Command();
+program
+    .name('dictionary-register')
+    .description('COEIROINKのユーザー辞書に単語を登録')
+    .version('1.0.0')
+    .option('-p, --preset <type>', 'プリセット辞書 (technical|characters|all)', 'technical')
+    .option('-f, --file <path>', 'カスタム辞書JSONファイル')
+    .option('-w, --word <word>', '登録する単語')
+    .option('-y, --yomi <yomi>', '読み方（カタカナ）')
+    .option('-a, --accent <number>', 'アクセント位置', parseInt)
+    .option('-m, --moras <number>', 'モーラ数', parseInt)
+    .option('--host <host>', 'COEIROINKサーバーホスト', 'localhost')
+    .option('--port <port>', 'COEIROINKサーバーポート', '50032')
+    .option('--list', 'デフォルト辞書の内容を表示')
+    .option('--export <path>', 'デフォルト辞書をJSONファイルにエクスポート')
+    .option('--test <word>', '指定した単語の韻律解析をテスト')
+    .option('--persist', '辞書データを永続化する（デフォルト: true）', true)
+    .option('--no-persist', '辞書データを永続化しない')
+    .parse(process.argv);
+const options = program.opts();
+/**
+ * 韻律解析テスト
+ */
+async function testProsody(word, host, port) {
+    try {
+        const response = await fetch(`http://${host}:${port}/v1/estimate_prosody`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({ text: word }),
+        });
+        if (response.ok) {
+            const result = await response.json();
+            console.log(`\n📝 「${word}」の韻律解析結果:`);
+            console.log('─'.repeat(60));
+            if (result.detail && result.detail[0]) {
+                console.log('モーラ解析:');
+                result.detail[0].forEach((mora, index) => {
+                    console.log(`  ${index + 1}. ${mora.hira} (${mora.phoneme}) - アクセント: ${mora.accent}`);
+                });
+                console.log('\n音素記号:');
+                console.log('  ' + result.plain.join(' '));
+            }
+            else {
+                console.log('詳細情報なし');
+            }
+            console.log('─'.repeat(60));
+        }
+        else {
+            console.error('❌ 韻律解析に失敗しました:', response.statusText);
+        }
+    }
+    catch (error) {
+        console.error('❌ エラー:', error.message);
+    }
+}
+/**
+ * メイン処理
+ */
+async function main() {
+    // リスト表示
+    if (options.list) {
+        console.log('📚 デフォルト辞書:');
+        console.log('\n技術用語:');
+        console.log(JSON.stringify(DEFAULT_TECHNICAL_WORDS, null, 2));
+        console.log('\nキャラクター名:');
+        console.log(JSON.stringify(CHARACTER_NAME_WORDS, null, 2));
+        process.exit(0);
+    }
+    // エクスポート
+    if (options.export) {
+        const exportData = [...DEFAULT_TECHNICAL_WORDS, ...CHARACTER_NAME_WORDS];
+        fs.writeFileSync(options.export, JSON.stringify(exportData, null, 2));
+        console.log(`✅ デフォルト辞書をエクスポートしました: ${options.export}`);
+        process.exit(0);
+    }
+    // 韻律解析テスト
+    if (options.test) {
+        await testProsody(options.test, options.host, options.port);
+        process.exit(0);
+    }
+    // DictionaryServiceのインスタンス作成
+    const service = new DictionaryService({
+        host: options.host,
+        port: options.port,
+    });
+    // 初期化と接続確認
+    await service.initialize();
+    const isConnected = await service.checkConnection();
+    if (!isConnected) {
+        console.error('❌ COEIROINKサーバーに接続できません');
+        console.error(`   接続先: http://${options.host}:${options.port}`);
+        console.error('   サーバーが起動していることを確認してください');
+        process.exit(1);
+    }
+    // 登録する単語を決定
+    let wordsToRegister = [];
+    // カスタムファイル
+    if (options.file) {
+        try {
+            const content = fs.readFileSync(options.file, 'utf8');
+            wordsToRegister = JSON.parse(content);
+            console.log(`📁 カスタム辞書ファイルを読み込みました: ${options.file}`);
+        }
+        catch (error) {
+            console.error(`❌ ファイル読み込みエラー: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    // 単一単語の登録
+    else if (options.word) {
+        if (!options.yomi || options.accent === undefined || !options.moras) {
+            console.error('❌ 単語登録には --yomi, --accent, --moras が必要です');
+            process.exit(1);
+        }
+        wordsToRegister = [
+            {
+                word: options.word,
+                yomi: options.yomi,
+                accent: options.accent,
+                numMoras: options.moras,
+            },
+        ];
+    }
+    // プリセット辞書
+    else {
+        switch (options.preset) {
+            case 'technical':
+                wordsToRegister = DEFAULT_TECHNICAL_WORDS;
+                break;
+            case 'characters':
+                wordsToRegister = CHARACTER_NAME_WORDS;
+                break;
+            case 'all':
+                wordsToRegister = [...DEFAULT_TECHNICAL_WORDS, ...CHARACTER_NAME_WORDS];
+                break;
+            default:
+                console.error(`❌ 無効なプリセット: ${options.preset}`);
+                process.exit(1);
+        }
+    }
+    if (wordsToRegister.length === 0) {
+        console.error('⚠️ 登録する単語がありません');
+        process.exit(1);
+    }
+    // 辞書登録実行
+    console.log(`📝 ${wordsToRegister.length}個の単語を登録中...`);
+    // 単一単語の場合はaddWord、複数の場合は直接登録
+    let success = false;
+    if (options.word && wordsToRegister.length === 1) {
+        // 単一単語はDictionaryServiceのaddWordを使用（永続化含む）
+        success = await service.addWord(wordsToRegister[0]);
+        if (success) {
+            console.log(`✅ 単語を登録しました\n`);
+            if (options.persist) {
+                console.log('💾 辞書データを永続化しました（次回起動時に自動登録されます）\n');
+            }
+        }
+    }
+    else {
+        // プリセットなど複数単語の場合は初期化で既に登録済み
+        // ここでは表示のみ
+        success = true;
+        console.log(`✅ ${wordsToRegister.length}個の単語を登録しました\n`);
+    }
+    if (success) {
+        // 登録内容を表示
+        console.log('登録された単語:');
+        console.log('─'.repeat(60));
+        console.log('単語\t\t読み方\t\tアクセント\tモーラ数');
+        console.log('─'.repeat(60));
+        for (const word of wordsToRegister) {
+            const paddedWord = word.word.padEnd(16);
+            const paddedYomi = word.yomi.padEnd(16);
+            console.log(`${paddedWord}${paddedYomi}${word.accent}\t\t${word.numMoras}`);
+        }
+        console.log('─'.repeat(60));
+        console.log('\n⚠️ 注意事項:');
+        console.log('• 登録した辞書はCOEIROINK再起動時にリセットされます');
+        console.log('• 全角で登録された単語は半角入力にも適用されます');
+        if (options.persist) {
+            console.log('• 永続化した辞書は次回起動時に自動的に登録されます');
+        }
+        else {
+            console.log('• 永続的な登録が必要な場合は --persist オプションを使用してください');
+        }
+    }
+    else {
+        console.error(`❌ 辞書登録に失敗しました`);
+        process.exit(1);
+    }
+}
+// エラーハンドリング
+main().catch(error => {
+    console.error('❌ 予期しないエラー:', error.message);
+    process.exit(1);
+});
+//# sourceMappingURL=dictionary-register.js.map

package/dist/operator-manager.d.ts

@@ -0,0 +1,22 @@
+#!/usr/bin/env node --no-deprecation
+/**
+ * src/operator/cli.ts: オペレータ管理CLI
+ * operator-managerスクリプトのJavaScript版
+ */
+declare class OperatorManagerCLI {
+    private manager;
+    private terminalBackground;
+    private configManager;
+    constructor();
+    private parseAssignArgs;
+    private executeAssignment;
+    showUsage(): Promise<void>;
+    run(args: string[]): Promise<void>;
+    handleAssign(args: string[]): Promise<void>;
+    handleRelease(): Promise<void>;
+    handleStatus(): Promise<void>;
+    handleAvailable(): Promise<void>;
+    handleClear(): Promise<void>;
+}
+export default OperatorManagerCLI;
+//# sourceMappingURL=operator-manager.d.ts.map

package/dist/operator-manager.js

@@ -0,0 +1,139 @@
+#!/usr/bin/env node --no-deprecation
+/**
+ * src/operator/cli.ts: オペレータ管理CLI
+ * operator-managerスクリプトのJavaScript版
+ */
+import { OperatorManager, ConfigManager, TerminalBackground, getConfigDir } from '@coeiro-operator/core';
+class OperatorManagerCLI {
+    manager;
+    terminalBackground = null;
+    configManager = null;
+    constructor() {
+        this.manager = new OperatorManager();
+    }
+    parseAssignArgs(args) {
+        let characterId = null;
+        let style = null;
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg.startsWith('--style=')) {
+                style = arg.substring(8);
+            }
+            else if (!arg.startsWith('--')) {
+                characterId = arg;
+            }
+        }
+        return { characterId, style };
+    }
+    async executeAssignment(characterId, style) {
+        if (characterId) {
+            const result = await this.manager.assignSpecificOperator(characterId, style);
+            console.log(`オペレータ決定: ${result.characterName} (${result.characterId})`);
+            if (result.currentStyle) {
+                console.log(`スタイル: ${result.currentStyle.styleName} - ${result.currentStyle.personality}`);
+            }
+            // 背景画像を切り替え
+            if (this.terminalBackground && await this.terminalBackground.isEnabled()) {
+                await this.terminalBackground.switchCharacter(result.characterId);
+            }
+        }
+        else {
+            const currentStatus = await this.manager.showCurrentOperator();
+            if (currentStatus.characterId) {
+                console.log(currentStatus.message);
+            }
+            else {
+                const result = await this.manager.assignRandomOperator(style);
+                console.log(`オペレータ決定: ${result.characterName} (${result.characterId})`);
+                if (result.currentStyle) {
+                    console.log(`スタイル: ${result.currentStyle.styleName} - ${result.currentStyle.personality}`);
+                }
+                // 背景画像を切り替え
+                if (this.terminalBackground && await this.terminalBackground.isEnabled()) {
+                    await this.terminalBackground.switchCharacter(result.characterId);
+                }
+            }
+        }
+    }
+    async showUsage() {
+        console.log(`使用法: operator-manager {assign|release|status|available|clear}
+  assign [オペレータID] [--style=スタイル名] - オペレータを割り当て（IDを指定しない場合はランダム）
+  release                                    - 現在のオペレータを返却
+  status                                     - 現在のオペレータを表示
+  available                                  - 利用可能なオペレータを表示
+  clear                                      - 全てのオペレータ利用状況をクリア`);
+    }
+    async run(args) {
+        await this.manager.initialize();
+        // ConfigManagerとTerminalBackgroundを初期化
+        const configDir = await getConfigDir();
+        this.configManager = new ConfigManager(configDir);
+        this.terminalBackground = new TerminalBackground(this.configManager);
+        const command = args[0];
+        try {
+            switch (command) {
+                case 'assign':
+                    await this.handleAssign(args.slice(1));
+                    break;
+                case 'release':
+                    await this.handleRelease();
+                    break;
+                case 'status':
+                    await this.handleStatus();
+                    break;
+                case 'available':
+                    await this.handleAvailable();
+                    break;
+                case 'clear':
+                    await this.handleClear();
+                    break;
+                default:
+                    await this.showUsage();
+                    process.exit(1);
+            }
+        }
+        catch (error) {
+            console.error(`エラー: ${error.message}`);
+            process.exit(1);
+        }
+    }
+    async handleAssign(args) {
+        const { characterId, style } = this.parseAssignArgs(args);
+        await this.executeAssignment(characterId, style);
+    }
+    async handleRelease() {
+        const result = await this.manager.releaseOperator();
+        if (result.wasAssigned) {
+            console.log(`オペレータ返却: ${result.characterName}`);
+        }
+        else {
+            console.log('オペレータは割り当てられていません');
+        }
+        // 背景画像をクリア（オペレータの有無に関わらず実行）
+        if (this.terminalBackground && await this.terminalBackground.isEnabled()) {
+            await this.terminalBackground.clearBackground();
+        }
+    }
+    async handleStatus() {
+        const result = await this.manager.showCurrentOperator();
+        console.log(result.message);
+    }
+    async handleAvailable() {
+        const result = await this.manager.getAvailableOperators();
+        console.log(`利用可能なオペレータ: ${result.available.join(', ')}`);
+        if (result.busy.length > 0) {
+            console.log(`仕事中のオペレータ: ${result.busy.join(', ')}`);
+        }
+    }
+    async handleClear() {
+        await this.manager.clearAllOperators();
+        console.log('全てのオペレータ利用状況をクリアしました');
+    }
+}
+// メイン実行
+if (import.meta.url === `file://${process.argv[1]}`) {
+    const cli = new OperatorManagerCLI();
+    await cli.run(process.argv.slice(2));
+}
+export default OperatorManagerCLI;
+//# sourceMappingURL=operator-manager.js.map

package/dist/say-coeiroink.d.ts

@@ -0,0 +1,18 @@
+#!/usr/bin/env node --no-deprecation
+/**
+ * src/say/cli.ts: say-coeiroinkコマンドラインインターフェース
+ * macOS sayコマンド互換のCLIツール
+ */
+import { SayCoeiroink } from '@coeiro-operator/audio';
+import type { Config } from '@coeiro-operator/audio';
+declare class SayCoeiroinkCLI {
+    private sayCoeiroink;
+    private config;
+    constructor(sayCoeiroink: SayCoeiroink, config: Config);
+    showUsage(): Promise<void>;
+    private parseArguments;
+    private getInputText;
+    run(args: string[]): Promise<void>;
+}
+export default SayCoeiroinkCLI;
+//# sourceMappingURL=say-coeiroink.d.ts.map

package/dist/say-coeiroink.js

@@ -0,0 +1,250 @@
+#!/usr/bin/env node --no-deprecation
+/**
+ * src/say/cli.ts: say-coeiroinkコマンドラインインターフェース
+ * macOS sayコマンド互換のCLIツール
+ */
+import { readFile, access } from 'fs/promises';
+import { constants } from 'fs';
+import { SayCoeiroink } from '@coeiro-operator/audio';
+import { ConfigManager, getConfigDir } from '@coeiro-operator/core';
+import { LoggerPresets } from '@coeiro-operator/common';
+import { BUFFER_SIZES } from '@coeiro-operator/audio';
+class SayCoeiroinkCLI {
+    sayCoeiroink;
+    config;
+    constructor(sayCoeiroink, config) {
+        this.sayCoeiroink = sayCoeiroink;
+        this.config = config;
+    }
+    async showUsage() {
+        const defaultRate = this.config?.operator?.rate || 200;
+        console.log(`Usage: say-coeiroink [-v voice] [-r rate] [-o outfile] [-f file | text] [--style style] [--chunk-mode mode] [--buffer-size size]
+
+低レイテンシストリーミング音声合成・再生（macOS sayコマンド互換）
+
+Options:
+    -v voice           Specify voice (voice ID or name, use '?' to list available voices)
+    -r rate            Speech rate in words per minute (default: ${defaultRate})
+    -o outfile         Write audio to file instead of playing (WAV format)
+    -f file            Read text from file (use '-' for stdin)
+    --style style      Specify voice style (e.g., 'のーまる', 'セクシー')
+    --chunk-mode mode  Text splitting mode: punctuation|none|small|medium|large (default: punctuation)
+    --buffer-size size Audio buffer size in bytes: ${BUFFER_SIZES.MIN}-${BUFFER_SIZES.MAX} (default: ${BUFFER_SIZES.DEFAULT})
+    -h                 Show this help
+
+Chunk Modes:
+    none    No text splitting (best for long text, natural speech)
+    small   30 chars (low latency, interactive use)
+    medium  50 chars (balanced)
+    large   100 chars (stability focused)
+    punctuation  Sentence-based splitting (default, natural Japanese)
+
+Buffer Sizes:
+    256     Lowest latency, higher CPU usage
+    512     Low latency, moderate CPU usage
+    1024    Balanced
+    2048    Higher stability (default)
+    4096+   Maximum stability, background use
+
+Features:
+    - ネイティブ音声出力（speakerライブラリ）
+    - カスタマイズ可能な分割制御
+    - バッファサイズ制御
+    - 真のストリーミング再生
+    - macOS sayコマンド互換
+
+Examples:
+    say-coeiroink "短いテキスト"
+    say-coeiroink -v "?" # 音声リスト表示
+    say-coeiroink -o output.wav "ファイル保存"
+    say-coeiroink --chunk-mode none "長文を分割せずにスムーズに読み上げ"
+    say-coeiroink --chunk-mode small --buffer-size 256 "低レイテンシ再生"
+    say-coeiroink --buffer-size 2048 "高品質・安定再生"
+    echo "テキスト" | say-coeiroink -f -`);
+    }
+    async parseArguments(args) {
+        const options = {
+            voice: process.env.COEIROINK_VOICE || '',
+            rate: this.config?.operator?.rate || 200,
+            inputFile: '',
+            outputFile: '',
+            text: '',
+            chunkMode: 'punctuation',
+            bufferSize: BUFFER_SIZES.DEFAULT,
+        };
+        // args が undefined や null の場合はデフォルト値を返す
+        if (!args || !Array.isArray(args)) {
+            return options;
+        }
+        for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            switch (arg) {
+                case '-h':
+                case '--help':
+                    await this.showUsage();
+                    throw new Error('HELP_REQUESTED');
+                case '-v':
+                    if (args[i + 1] === '?') {
+                        await this.sayCoeiroink.listVoices();
+                        throw new Error('VOICE_LIST_REQUESTED');
+                    }
+                    options.voice = args[i + 1];
+                    i++;
+                    break;
+                case '-r':
+                case '--rate':
+                    options.rate = parseInt(args[i + 1]);
+                    i++;
+                    break;
+                case '-o':
+                case '--output-file':
+                    options.outputFile = args[i + 1];
+                    i++;
+                    break;
+                case '-f':
+                case '--input-file':
+                    options.inputFile = args[i + 1];
+                    i++;
+                    break;
+                case '--style':
+                    options.style = args[i + 1];
+                    i++;
+                    break;
+                case '--chunk-mode': {
+                    const chunkMode = args[i + 1];
+                    if (!['none', 'small', 'medium', 'large', 'punctuation'].includes(chunkMode)) {
+                        throw new Error(`Invalid chunk mode: ${chunkMode}. Must be one of: none, small, medium, large, punctuation`);
+                    }
+                    options.chunkMode = chunkMode;
+                    i++;
+                    break;
+                }
+                case '--buffer-size': {
+                    const bufferSize = parseInt(args[i + 1]);
+                    if (isNaN(bufferSize) || bufferSize < BUFFER_SIZES.MIN || bufferSize > BUFFER_SIZES.MAX) {
+                        throw new Error(`Invalid buffer size: ${args[i + 1]}. Must be a number between ${BUFFER_SIZES.MIN} and ${BUFFER_SIZES.MAX}`);
+                    }
+                    options.bufferSize = bufferSize;
+                    i++;
+                    break;
+                }
+                default:
+                    if (arg.startsWith('-')) {
+                        throw new Error(`Unknown option ${arg}`);
+                    }
+                    else {
+                        options.text = options.text ? `${options.text} ${arg}` : arg;
+                    }
+                    break;
+            }
+        }
+        return options;
+    }
+    async getInputText(options) {
+        let text = options.text;
+        if (options.inputFile) {
+            if (options.inputFile === '-') {
+                const chunks = [];
+                for await (const chunk of process.stdin) {
+                    chunks.push(chunk);
+                }
+                text = Buffer.concat(chunks).toString('utf8').trim();
+            }
+            else {
+                try {
+                    await access(options.inputFile, constants.F_OK);
+                    text = (await readFile(options.inputFile, 'utf8')).trim();
+                }
+                catch {
+                    throw new Error(`File '${options.inputFile}' not found`);
+                }
+            }
+        }
+        else if (!text) {
+            const chunks = [];
+            for await (const chunk of process.stdin) {
+                chunks.push(chunk);
+            }
+            text = Buffer.concat(chunks).toString('utf8').trim();
+        }
+        if (!text) {
+            throw new Error('No text to speak');
+        }
+        return text;
+    }
+    async run(args) {
+        const options = await this.parseArguments(args);
+        const text = await this.getInputText(options);
+        // ファイル出力の場合はウォームアップ不要
+        if (!options.outputFile) {
+            // オーディオドライバーのウォームアップ
+            await this.sayCoeiroink.warmup();
+        }
+        // 音声合成タスクをキューに追加
+        this.sayCoeiroink.synthesize(text, {
+            voice: options.voice || null,
+            rate: options.rate,
+            outputFile: options.outputFile || null,
+            style: options.style || undefined,
+            chunkMode: options.chunkMode,
+            bufferSize: options.bufferSize,
+        });
+        if (options.outputFile) {
+            console.error(`Audio saved to: ${options.outputFile}`);
+        }
+        // すべてのタスクの完了を待つ
+        await this.sayCoeiroink.waitCompletion();
+    }
+}
+// プロセス終了ハンドリング（テスト環境では無効化）
+if (process.env.NODE_ENV !== 'test') {
+    process.on('uncaughtException', error => {
+        console.error('Uncaught Exception:', error.message);
+        process.exit(1);
+    });
+    process.on('unhandledRejection', (reason) => {
+        console.error('Unhandled Rejection:', reason);
+        process.exit(1);
+    });
+}
+// メイン実行関数
+async function main() {
+    // デバッグモード判定
+    const isDebugMode = process.argv.includes('--debug');
+    // CLIモードでは通常ログレベル（info）を使用、デバッグモードではdebugレベル
+    if (isDebugMode) {
+        LoggerPresets.debug();
+    }
+    else {
+        LoggerPresets.cli();
+    }
+    const configDir = await getConfigDir();
+    const configManager = new ConfigManager(configDir);
+    await configManager.buildDynamicConfig();
+    const sayCoeiroink = new SayCoeiroink(configManager);
+    await sayCoeiroink.initialize();
+    await sayCoeiroink.buildDynamicConfig();
+    const config = await configManager.getFullConfig();
+    const cli = new SayCoeiroinkCLI(sayCoeiroink, config);
+    await cli.run(process.argv.slice(2));
+}
+// メイン実行（テスト環境では実行しない）
+if (process.env.NODE_ENV !== 'test') {
+    main()
+        .then(() => {
+        process.exit(0);
+    })
+        .catch(error => {
+        // 特別なエラーメッセージは正常終了扱い
+        if (error.message === 'HELP_REQUESTED' ||
+            error.message === 'VOICE_LIST_REQUESTED') {
+            process.exit(0);
+        }
+        else {
+            console.error(`Error: ${error.message}`);
+            process.exit(1);
+        }
+    });
+}
+export default SayCoeiroinkCLI;
+//# sourceMappingURL=say-coeiroink.js.map

package/package.json

@@ -0,0 +1,61 @@
+{
+  "name": "@coeiro-operator/cli",
+  "version": "1.0.0",
+  "description": "CLI tools for COEIRO Operator",
+  "type": "module",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "os": [
+    "darwin",
+    "linux",
+    "win32"
+  ],
+  "cpu": [
+    "x64",
+    "arm64",
+    "ia32"
+  ],
+  "bin": {
+    "operator-manager": "./dist/operator-manager.js",
+    "say-coeiroink": "./dist/say-coeiroink.js",
+    "dictionary-register": "./dist/dictionary-register.js"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "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/audio": "^1.0.0",
+    "@coeiro-operator/common": "^1.0.0",
+    "@coeiro-operator/core": "^1.0.0",
+    "commander": "^14.0.1"
+  },
+  "devDependencies": {
+    "@types/commander": "^2.12.5",
+    "@types/node": "^22.18.3",
+    "typescript": "^5.7.3",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "cli",
+    "tools",
+    "coeiroink"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/otolab/coeiro-operator.git",
+    "directory": "packages/cli"
+  },
+  "homepage": "https://github.com/otolab/coeiro-operator#readme",
+  "bugs": {
+    "url": "https://github.com/otolab/coeiro-operator/issues"
+  },
+  "publishConfig": {
+    "access": "public"
+  }
+}