@coeiro-operator/core 1.0.0

package/README.md

@@ -0,0 +1,11 @@
+# @coeiro-operator/core
+
+COEIRO Operatorコア機能
+
+内部パッケージです。直接のインストールは推奨されません。
+
+設定管理、オペレータ管理、セッション管理などの中核機能を提供します。
+
+## ライセンス
+
+MIT

package/dist/common/config-paths.d.ts

@@ -0,0 +1,12 @@
+/**
+ * 共通設定パス管理
+ */
+/**
+ * 設定ディレクトリを決定（ホームディレクトリベース）
+ */
+export declare function getConfigDir(): Promise<string>;
+/**
+ * 設定ファイルのパスを取得
+ */
+export declare function getConfigPath(filename: string): Promise<string>;
+//# sourceMappingURL=config-paths.d.ts.map

package/dist/common/config-paths.js

@@ -0,0 +1,43 @@
+/**
+ * 共通設定パス管理
+ */
+import { mkdir } from 'fs/promises';
+import { join } from 'path';
+/**
+ * 設定ディレクトリを決定（ホームディレクトリベース）
+ */
+export async function getConfigDir() {
+    // ホームディレクトリの ~/.coeiro-operator/ を優先
+    const homeDir = join(process.env.HOME || process.env.USERPROFILE || '~', '.coeiro-operator');
+    try {
+        await mkdir(homeDir, { recursive: true });
+        return homeDir;
+    }
+    catch {
+        // フォールバック: 作業ディレクトリの .coeiroink/
+        const workDir = join(process.cwd(), '.coeiroink');
+        try {
+            await mkdir(workDir, { recursive: true });
+            return workDir;
+        }
+        catch {
+            // 最終フォールバック: /tmp/coeiroink-mcp-shared/
+            const tmpDir = '/tmp/coeiroink-mcp-shared';
+            try {
+                await mkdir(tmpDir, { recursive: true });
+            }
+            catch {
+                // ディレクトリ作成エラーは無視
+            }
+            return tmpDir;
+        }
+    }
+}
+/**
+ * 設定ファイルのパスを取得
+ */
+export async function getConfigPath(filename) {
+    const configDir = await getConfigDir();
+    return join(configDir, filename);
+}
+//# sourceMappingURL=config-paths.js.map

package/dist/dictionary/default-dictionaries.d.ts

@@ -0,0 +1,20 @@
+/**
+ * デフォルト辞書データ
+ *
+ * COEIROINKに登録する標準的な単語の定義
+ */
+import { DictionaryWord } from './dictionary-client.js';
+/**
+ * デフォルトの技術用語辞書
+ */
+export declare const DEFAULT_TECHNICAL_WORDS: DictionaryWord[];
+/**
+ * キャラクター名辞書
+ */
+export declare const CHARACTER_NAME_WORDS: DictionaryWord[];
+/**
+ * 全デフォルト辞書
+ * 技術用語とキャラクター名を統合
+ */
+export declare const ALL_DEFAULT_WORDS: DictionaryWord[];
+//# sourceMappingURL=default-dictionaries.d.ts.map

package/dist/dictionary/default-dictionaries.js

@@ -0,0 +1,48 @@
+/**
+ * デフォルト辞書データ
+ *
+ * COEIROINKに登録する標準的な単語の定義
+ */
+/**
+ * デフォルトの技術用語辞書
+ */
+export const DEFAULT_TECHNICAL_WORDS = [
+    // 音声合成関連
+    { word: 'COEIRO', yomi: 'コエイロ', accent: 2, numMoras: 4 },
+    { word: 'COEIROINK', yomi: 'コエイロインク', accent: 5, numMoras: 7 },
+    // AI関連
+    { word: 'Claude', yomi: 'クロード', accent: 2, numMoras: 4 },
+    { word: 'Anthropic', yomi: 'アンソロピック', accent: 4, numMoras: 7 },
+    { word: 'ChatGPT', yomi: 'チャットジーピーティー', accent: 0, numMoras: 10 },
+    // 開発ツール
+    { word: 'GitHub', yomi: 'ギットハブ', accent: 3, numMoras: 5 },
+    { word: 'TypeScript', yomi: 'タイプスクリプト', accent: 5, numMoras: 8 },
+    { word: 'Node.js', yomi: 'ノードジェイエス', accent: 0, numMoras: 8 },
+    { word: 'npm', yomi: 'エヌピーエム', accent: 0, numMoras: 6 },
+    // プロトコル・形式
+    { word: 'MCP', yomi: 'エムシーピー', accent: 0, numMoras: 6 },
+    { word: 'API', yomi: 'エーピーアイ', accent: 0, numMoras: 6 },
+    { word: 'JSON', yomi: 'ジェイソン', accent: 1, numMoras: 4 },
+    { word: 'CLI', yomi: 'シーエルアイ', accent: 0, numMoras: 6 },
+    { word: 'GUI', yomi: 'ジーユーアイ', accent: 0, numMoras: 6 },
+];
+/**
+ * キャラクター名辞書
+ */
+export const CHARACTER_NAME_WORDS = [
+    { word: 'つくよみちゃん', yomi: 'ツクヨミチャン', accent: 3, numMoras: 6 },
+    { word: 'アンジー', yomi: 'アンジー', accent: 1, numMoras: 4 },
+    { word: 'アルマ', yomi: 'アルマ', accent: 1, numMoras: 3 },
+    { word: 'ディア', yomi: 'ディア', accent: 1, numMoras: 2 },
+    { word: 'リリン', yomi: 'リリン', accent: 1, numMoras: 3 },
+    { word: 'クロワ', yomi: 'クロワ', accent: 1, numMoras: 3 },
+];
+/**
+ * 全デフォルト辞書
+ * 技術用語とキャラクター名を統合
+ */
+export const ALL_DEFAULT_WORDS = [
+    ...DEFAULT_TECHNICAL_WORDS,
+    ...CHARACTER_NAME_WORDS,
+];
+//# sourceMappingURL=default-dictionaries.js.map

package/dist/dictionary/dictionary-client.d.ts

@@ -0,0 +1,73 @@
+/**
+ * COEIROINK ユーザー辞書API クライアント
+ *
+ * COEIROINKのユーザー辞書機能にアクセスするための独立したモジュール
+ * CLI、MCP、その他のコンポーネントから再利用可能
+ */
+/**
+ * 辞書単語の定義
+ */
+export interface DictionaryWord {
+    /** 登録する単語（全角英数字推奨） */
+    word: string;
+    /** 読み方（全角カタカナ） */
+    yomi: string;
+    /** アクセント位置（0:平板型、1以上:該当モーラが高い） */
+    accent: number;
+    /** モーラ数（音節数） */
+    numMoras: number;
+}
+/**
+ * 辞書登録レスポンス
+ */
+export interface DictionaryResponse {
+    /** 登録成功フラグ */
+    success: boolean;
+    /** エラーメッセージ（エラー時のみ） */
+    error?: string;
+    /** 登録された単語数 */
+    registeredCount?: number;
+}
+/**
+ * COEIROINKサーバー設定
+ */
+export interface CoeiroinkServerConfig {
+    /** ホスト名（デフォルト: localhost） */
+    host?: string;
+    /** ポート番号（デフォルト: 50032） */
+    port?: string | number;
+}
+/**
+ * ユーザー辞書クライアント
+ */
+export declare class DictionaryClient {
+    private baseUrl;
+    constructor(config?: CoeiroinkServerConfig);
+    /**
+     * 辞書に単語を登録
+     *
+     * 注意事項:
+     * - 半角英数字は登録できません（全角に変換して登録）
+     * - 登録した辞書はCOEIROINK再起動時にリセットされます
+     * - 全角で登録すれば半角入力にも適用されます
+     *
+     * @param words 登録する単語の配列
+     * @returns 登録結果
+     */
+    registerWords(words: DictionaryWord[]): Promise<DictionaryResponse>;
+    /**
+     * 半角英数字・記号を全角に変換
+     * COEIROINKのAPI制限により、半角英数字では辞書登録が効かないため
+     *
+     * @param str 変換する文字列
+     * @returns 全角変換後の文字列
+     */
+    private toFullWidth;
+    /**
+     * サーバーの接続確認
+     *
+     * @returns 接続可能かどうか
+     */
+    checkConnection(): Promise<boolean>;
+}
+//# sourceMappingURL=dictionary-client.d.ts.map

package/dist/dictionary/dictionary-client.js

@@ -0,0 +1,115 @@
+/**
+ * COEIROINK ユーザー辞書API クライアント
+ *
+ * COEIROINKのユーザー辞書機能にアクセスするための独立したモジュール
+ * CLI、MCP、その他のコンポーネントから再利用可能
+ */
+/**
+ * ユーザー辞書クライアント
+ */
+export class DictionaryClient {
+    baseUrl;
+    constructor(config = {}) {
+        const host = config.host || 'localhost';
+        const port = config.port || '50032';
+        this.baseUrl = `http://${host}:${port}`;
+    }
+    /**
+     * 辞書に単語を登録
+     *
+     * 注意事項:
+     * - 半角英数字は登録できません（全角に変換して登録）
+     * - 登録した辞書はCOEIROINK再起動時にリセットされます
+     * - 全角で登録すれば半角入力にも適用されます
+     *
+     * @param words 登録する単語の配列
+     * @returns 登録結果
+     */
+    async registerWords(words) {
+        try {
+            // 半角英数字を全角に変換（API制限対策）
+            const convertedWords = words.map(word => ({
+                ...word,
+                word: this.toFullWidth(word.word),
+            }));
+            const response = await fetch(`${this.baseUrl}/v1/set_dictionary`, {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    dictionaryWords: convertedWords,
+                }),
+            });
+            if (!response.ok) {
+                throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+            }
+            // COEIROINKは常にnullを返すが、成功とみなす
+            return {
+                success: true,
+                registeredCount: words.length,
+            };
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : 'Unknown error';
+            // 接続エラーの詳細メッセージ
+            if (message.includes('ECONNREFUSED')) {
+                return {
+                    success: false,
+                    error: `COEIROINKサーバーに接続できません。サーバーが起動していることを確認してください (${this.baseUrl})`,
+                };
+            }
+            return {
+                success: false,
+                error: message,
+            };
+        }
+    }
+    /**
+     * 半角英数字・記号を全角に変換
+     * COEIROINKのAPI制限により、半角英数字では辞書登録が効かないため
+     *
+     * @param str 変換する文字列
+     * @returns 全角変換後の文字列
+     */
+    toFullWidth(str) {
+        return str.replace(/[A-Za-z0-9!-/:-@[-`{-~]/g, char => {
+            const code = char.charCodeAt(0);
+            // ASCII文字（0x21-0x7E）は基本的に0xFEE0を加算で全角に変換可能
+            // ただし、一部の文字は個別対応が必要
+            // スペース（0x20）は対象外なのでここでは処理しない
+            // 特殊な変換が必要な文字
+            switch (char) {
+                case ' ': return '　'; // 半角スペース → 全角スペース (U+3000)
+                case '"': return '"'; // ダブルクォート
+                case '\'': return `’`; // シングルクォート
+                case '\\': return '＼'; // バックスラッシュ
+                case '~': return '～'; // チルダ
+                default:
+                    // その他のASCII印字可能文字（! から ~ まで）
+                    if (code >= 0x21 && code <= 0x7E) {
+                        return String.fromCharCode(code + 0xFEE0);
+                    }
+                    return char;
+            }
+        });
+    }
+    /**
+     * サーバーの接続確認
+     *
+     * @returns 接続可能かどうか
+     */
+    async checkConnection() {
+        try {
+            const response = await fetch(`${this.baseUrl}/`, {
+                method: 'GET',
+                signal: AbortSignal.timeout(3000), // 3秒タイムアウト
+            });
+            return response.ok;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=dictionary-client.js.map

package/dist/dictionary/dictionary-persistence.d.ts

@@ -0,0 +1,48 @@
+/**
+ * COEIROINK ユーザー辞書永続化機能
+ *
+ * 登録した辞書データを永続化し、次回起動時に自動的に復元する
+ */
+import { DictionaryWord } from './dictionary-client.js';
+/**
+ * 永続化辞書データ
+ */
+export interface PersistentDictionary {
+    /** 辞書のバージョン */
+    version: string;
+    /** 最終更新日時 */
+    lastUpdated: string;
+    /** カスタム単語リスト */
+    customWords: DictionaryWord[];
+    /** デフォルト辞書を含めるか */
+    includeDefaults: boolean;
+}
+/**
+ * 辞書永続化マネージャー
+ */
+export declare class DictionaryPersistenceManager {
+    private readonly configDir;
+    private readonly dictionaryFile;
+    constructor();
+    /**
+     * 辞書データを保存
+     */
+    save(words: DictionaryWord[], includeDefaults?: boolean): Promise<void>;
+    /**
+     * 辞書データを読み込み
+     */
+    load(): Promise<PersistentDictionary | null>;
+    /**
+     * 辞書データを削除
+     */
+    clear(): Promise<void>;
+    /**
+     * 辞書データが存在するか確認
+     */
+    exists(): boolean;
+    /**
+     * 辞書データのパスを取得
+     */
+    getFilePath(): string;
+}
+//# sourceMappingURL=dictionary-persistence.d.ts.map

package/dist/dictionary/dictionary-persistence.js

@@ -0,0 +1,82 @@
+/**
+ * COEIROINK ユーザー辞書永続化機能
+ *
+ * 登録した辞書データを永続化し、次回起動時に自動的に復元する
+ */
+import fs from 'fs';
+import path from 'path';
+import os from 'os';
+/**
+ * 辞書永続化マネージャー
+ */
+export class DictionaryPersistenceManager {
+    configDir;
+    dictionaryFile;
+    constructor() {
+        // ~/.coeiro-operator ディレクトリを使用
+        this.configDir = path.join(os.homedir(), '.coeiro-operator');
+        this.dictionaryFile = path.join(this.configDir, 'user-dictionary.json');
+        // ディレクトリが存在しない場合は作成
+        if (!fs.existsSync(this.configDir)) {
+            fs.mkdirSync(this.configDir, { recursive: true });
+        }
+    }
+    /**
+     * 辞書データを保存
+     */
+    async save(words, includeDefaults = true) {
+        const data = {
+            version: '1.0.0',
+            lastUpdated: new Date().toISOString(),
+            customWords: words,
+            includeDefaults,
+        };
+        try {
+            await fs.promises.writeFile(this.dictionaryFile, JSON.stringify(data, null, 2), 'utf8');
+        }
+        catch (error) {
+            throw new Error(`辞書データの保存に失敗しました: ${error.message}`);
+        }
+    }
+    /**
+     * 辞書データを読み込み
+     */
+    async load() {
+        if (!fs.existsSync(this.dictionaryFile)) {
+            return null;
+        }
+        try {
+            const content = await fs.promises.readFile(this.dictionaryFile, 'utf8');
+            const data = JSON.parse(content);
+            // バージョンチェック（将来の拡張用）
+            if (!data.version) {
+                throw new Error('辞書データのバージョンが不明です');
+            }
+            return data;
+        }
+        catch (error) {
+            throw new Error(`辞書データの読み込みに失敗しました: ${error.message}`);
+        }
+    }
+    /**
+     * 辞書データを削除
+     */
+    async clear() {
+        if (fs.existsSync(this.dictionaryFile)) {
+            await fs.promises.unlink(this.dictionaryFile);
+        }
+    }
+    /**
+     * 辞書データが存在するか確認
+     */
+    exists() {
+        return fs.existsSync(this.dictionaryFile);
+    }
+    /**
+     * 辞書データのパスを取得
+     */
+    getFilePath() {
+        return this.dictionaryFile;
+    }
+}
+//# sourceMappingURL=dictionary-persistence.js.map

package/dist/dictionary/dictionary-service.d.ts

@@ -0,0 +1,32 @@
+/**
+ * 辞書管理サービス
+ *
+ * 辞書の登録・永続化を統一的に管理
+ */
+import { DictionaryWord } from './dictionary-client.js';
+import { ConnectionConfig } from '../environment/speaker-provider.js';
+/**
+ * 辞書管理サービス
+ */
+export declare class DictionaryService {
+    private client;
+    private persistenceManager;
+    constructor(connectionConfig?: ConnectionConfig);
+    /**
+     * 辞書を初期化（起動時の自動登録）
+     */
+    initialize(): Promise<void>;
+    /**
+     * 単語を追加登録
+     */
+    addWord(word: DictionaryWord): Promise<boolean>;
+    /**
+     * すべての辞書（デフォルト＋カスタム）を登録
+     */
+    private registerAllWords;
+    /**
+     * 接続確認
+     */
+    checkConnection(): Promise<boolean>;
+}
+//# sourceMappingURL=dictionary-service.d.ts.map

package/dist/dictionary/dictionary-service.js

@@ -0,0 +1,102 @@
+/**
+ * 辞書管理サービス
+ *
+ * 辞書の登録・永続化を統一的に管理
+ */
+import { DictionaryClient } from './dictionary-client.js';
+import { DictionaryPersistenceManager } from './dictionary-persistence.js';
+import { DEFAULT_TECHNICAL_WORDS, CHARACTER_NAME_WORDS } from './default-dictionaries.js';
+import { logger } from '@coeiro-operator/common';
+/**
+ * 辞書管理サービス
+ */
+export class DictionaryService {
+    client;
+    persistenceManager;
+    constructor(connectionConfig) {
+        this.client = new DictionaryClient(connectionConfig);
+        this.persistenceManager = new DictionaryPersistenceManager();
+    }
+    /**
+     * 辞書を初期化（起動時の自動登録）
+     */
+    async initialize() {
+        try {
+            const isConnected = await this.client.checkConnection();
+            if (!isConnected) {
+                logger.warn('COEIROINKサーバーに接続できないため、辞書の初期化をスキップしました');
+                return;
+            }
+            // 保存された辞書を読み込み
+            const savedDictionary = await this.persistenceManager.load();
+            let customWords = [];
+            if (savedDictionary) {
+                customWords = savedDictionary.customWords || [];
+                logger.info(`保存された辞書を読み込みました: カスタム単語${customWords.length}個`);
+            }
+            else {
+                // 初回起動時は空の辞書で永続化ファイルを作成
+                await this.persistenceManager.save([], true);
+                logger.info('辞書設定ファイルを初期化しました');
+            }
+            // すべての辞書を登録
+            await this.registerAllWords(customWords);
+        }
+        catch (error) {
+            logger.warn(`辞書の初期化中にエラーが発生しました: ${error.message}`);
+        }
+    }
+    /**
+     * 単語を追加登録
+     */
+    async addWord(word) {
+        try {
+            // 既存のカスタム辞書を読み込み
+            let existingWords = [];
+            const savedDictionary = await this.persistenceManager.load();
+            if (savedDictionary) {
+                existingWords = savedDictionary.customWords || [];
+            }
+            // 重複チェック（同じ単語があれば上書き）
+            const updatedWords = existingWords.filter(w => w.word !== word.word);
+            updatedWords.push(word);
+            // すべての辞書を登録
+            const success = await this.registerAllWords(updatedWords);
+            if (success) {
+                // 永続化
+                await this.persistenceManager.save(updatedWords, true);
+                logger.info(`辞書に単語を追加: ${word.word} → ${word.yomi}`);
+            }
+            return success;
+        }
+        catch (error) {
+            logger.error(`単語の追加に失敗しました: ${error.message}`);
+            return false;
+        }
+    }
+    /**
+     * すべての辞書（デフォルト＋カスタム）を登録
+     */
+    async registerAllWords(customWords) {
+        const allWords = [...DEFAULT_TECHNICAL_WORDS, ...CHARACTER_NAME_WORDS, ...customWords];
+        if (allWords.length === 0) {
+            return true;
+        }
+        const result = await this.client.registerWords(allWords);
+        if (result.success) {
+            logger.info(`辞書を登録しました: 合計${result.registeredCount}個の単語`);
+            return true;
+        }
+        else {
+            logger.warn(`辞書登録に失敗: ${result.error}`);
+            return false;
+        }
+    }
+    /**
+     * 接続確認
+     */
+    async checkConnection() {
+        return await this.client.checkConnection();
+    }
+}
+//# sourceMappingURL=dictionary-service.js.map

package/dist/environment/speaker-provider.d.ts

@@ -0,0 +1,72 @@
+/**
+ * src/core/environment/speaker-provider.ts: Speaker情報プロバイダ
+ * COEIROINKサーバーからの動的Speaker情報取得を一元管理
+ */
+export interface VoiceStyle {
+    styleId: number;
+    styleName: string;
+}
+export interface Speaker {
+    speakerName: string;
+    speakerUuid: string;
+    styles: VoiceStyle[];
+    base64Portrait?: string;
+}
+export interface ConnectionConfig {
+    host: string;
+    port: string;
+}
+/**
+ * Speaker情報プロバイダクラス
+ * COEIROINKサーバーからのSpeaker情報取得を一元管理
+ */
+export declare class SpeakerProvider {
+    private connectionConfig;
+    constructor(connectionConfig?: Partial<ConnectionConfig>);
+    /**
+     * 接続設定を更新
+     */
+    updateConnection(config: Partial<ConnectionConfig>): void;
+    /**
+     * サーバー接続確認
+     */
+    checkConnection(): Promise<boolean>;
+    /**
+     * 利用可能な音声一覧を取得
+     */
+    getSpeakers(): Promise<Speaker[]>;
+    /**
+     * 特定のSpeakerの立ち絵画像を取得
+     */
+    getSpeakerPortrait(speakerId: string): Promise<string | null>;
+    /**
+     * 特定の音声のスタイル情報を取得
+     */
+    getVoiceStyles(voiceId: string): Promise<VoiceStyle[]>;
+    /**
+     * 特定の音声の最初のスタイルIDを取得（フォールバック用）
+     */
+    getFirstStyleId(voiceId: string): Promise<number>;
+    /**
+     * 全Speakerを取得（エイリアス）
+     */
+    getAllSpeakers(): Promise<Speaker[]>;
+    /**
+     * デバッグ用：音声一覧をコンソール出力
+     */
+    logAvailableVoices(): Promise<void>;
+    /**
+     * 音声名からIDを生成（英語名への変換）
+     */
+    private speakerNameToId;
+}
+/**
+ * グローバルSpeakerプロバイダを取得
+ * 設定ファイルから接続情報を読み込んで初期化
+ */
+export declare function getSpeakerProvider(connectionConfig?: Partial<ConnectionConfig>): SpeakerProvider;
+/**
+ * Speakerプロバイダをリセット（テスト用）
+ */
+export declare function resetSpeakerProvider(): void;
+//# sourceMappingURL=speaker-provider.d.ts.map