@nogataka/smart-edit 0.0.14

package/dist/serena/cli.js

@@ -0,0 +1,731 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import process from 'node:process';
+import { spawn } from 'node:child_process';
+import { Command, Option } from 'commander';
+import { DEFAULT_CONTEXT, DEFAULT_MODES, PROMPT_TEMPLATES_DIR_IN_USER_HOME, PROMPT_TEMPLATES_DIR_INTERNAL, SERENA_MANAGED_DIR_IN_HOME, SERENAS_OWN_CONTEXT_YAMLS_DIR, SERENAS_OWN_MODE_YAMLS_DIR, SERENA_LOG_FORMAT, USER_CONTEXT_YAMLS_DIR, USER_MODE_YAMLS_DIR } from './constants.js';
+import { SerenaAgentContext, SerenaAgentMode } from './config/context_mode.js';
+import { ProjectConfig, SerenaConfig, SerenaPaths } from './config/serena_config.js';
+import { createSerenaLogger, setConsoleLoggingEnabled } from './util/logging.js';
+import { SerenaAgent } from './agent.js';
+import { SerenaMCPFactorySingleProcess, createSerenaHttpServer, createSerenaStdioServer } from './mcp.js';
+import { ToolRegistry } from './tools/tools_base.js';
+import { coerceLanguage } from '../solidlsp/ls_config.js';
+import { ensureDefaultSubprocessOptions } from '../solidlsp/util/subprocess_util.js';
+const LOG_LEVEL_NAMES = ['DEBUG', 'INFO', 'WARNING', 'ERROR', 'CRITICAL'];
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.length > 0;
+}
+function isTransportChoice(value) {
+    return value === 'stdio' || value === 'sse' || value === 'streamable-http';
+}
+function isLogLevelName(value) {
+    return LOG_LEVEL_NAMES.some((name) => name === value);
+}
+function parseOptionalBoolean(value) {
+    if (value === undefined) {
+        return true;
+    }
+    const normalized = value.toLowerCase();
+    if (['true', '1', 'yes', 'on'].includes(normalized)) {
+        return true;
+    }
+    if (['false', '0', 'no', 'off'].includes(normalized)) {
+        return false;
+    }
+    throw new Error(`ブーリアン値として解釈できません: ${value}`);
+}
+function parseInteger(value, optionName) {
+    const parsed = Number.parseInt(value, 10);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`${optionName} は整数で指定してください: ${value}`);
+    }
+    return parsed;
+}
+function parseFloatSeconds(value) {
+    const parsed = Number.parseFloat(value);
+    if (Number.isNaN(parsed)) {
+        throw new Error(`秒数は数値で指定してください: ${value}`);
+    }
+    return parsed;
+}
+function normalizeStartMcpServerOptions(raw) {
+    const context = isNonEmptyString(raw.context) ? raw.context : DEFAULT_CONTEXT;
+    const rawModes = raw.modes ?? raw.mode;
+    const normalizedModes = (() => {
+        if (Array.isArray(rawModes)) {
+            const filtered = rawModes.filter(isNonEmptyString);
+            return filtered.length > 0 ? filtered : Array.from(DEFAULT_MODES);
+        }
+        if (isNonEmptyString(rawModes)) {
+            return [rawModes];
+        }
+        return Array.from(DEFAULT_MODES);
+    })();
+    const transportCandidate = typeof raw.transport === 'string' ? raw.transport : 'stdio';
+    if (!isTransportChoice(transportCandidate)) {
+        throw new Error(`未知のトランスポートが指定されました: ${String(raw.transport)}`);
+    }
+    const transport = transportCandidate;
+    const host = isNonEmptyString(raw.host) ? raw.host : '0.0.0.0';
+    const port = typeof raw.port === 'number' ? raw.port : 8000;
+    const coerceBoolean = (value) => {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === 'boolean') {
+            return value;
+        }
+        return undefined;
+    };
+    const coerceLogLevel = (value) => {
+        if (value === undefined) {
+            return undefined;
+        }
+        if (value === null) {
+            return null;
+        }
+        if (typeof value === 'string') {
+            const normalized = value.toUpperCase();
+            if (isLogLevelName(normalized)) {
+                return normalized;
+            }
+        }
+        return undefined;
+    };
+    return {
+        project: isNonEmptyString(raw.project) ? raw.project : null,
+        projectFile: isNonEmptyString(raw.projectFile) ? raw.projectFile : null,
+        context,
+        modes: normalizedModes.slice(),
+        transport,
+        host,
+        port,
+        enableWebDashboard: coerceBoolean(raw.enableWebDashboard) ?? null,
+        enableGuiLogWindow: coerceBoolean(raw.enableGuiLogWindow) ?? null,
+        logLevel: coerceLogLevel(raw.logLevel) ?? null,
+        traceLspCommunication: coerceBoolean(raw.traceLspCommunication) ?? null,
+        toolTimeout: typeof raw.toolTimeout === 'number' ? raw.toolTimeout : null,
+        instructionsOverride: typeof raw.instructionsOverride === 'string' ? raw.instructionsOverride : null
+    };
+}
+function isPathInside(child, parent) {
+    const relative = path.relative(parent, child);
+    return relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative));
+}
+function normalizeProjectArgument(value) {
+    if (!value) {
+        return null;
+    }
+    const resolved = path.resolve(value);
+    try {
+        const stat = fs.statSync(resolved);
+        if (stat.isDirectory()) {
+            return resolved;
+        }
+    }
+    catch {
+        // ignore resolution errors and fall back to the raw value
+    }
+    return value;
+}
+async function openInEditor(targetPath) {
+    if (process.env.SERENA_SKIP_EDITOR === '1') {
+        return;
+    }
+    const run = (command, args, options = {}) => new Promise((resolve, reject) => {
+        const child = spawn(command, args, ensureDefaultSubprocessOptions({
+            stdio: 'ignore',
+            detached: false,
+            shell: options.shell ?? false
+        }));
+        child.on('error', reject);
+        child.on('close', () => resolve());
+    });
+    try {
+        const editor = process.env.EDITOR;
+        if (editor && editor.trim().length > 0) {
+            await run(editor, [targetPath], { shell: true });
+            return;
+        }
+        if (process.platform === 'win32') {
+            await run('cmd', ['/c', 'start', '', `"${targetPath}"`], { shell: true });
+            return;
+        }
+        if (process.platform === 'darwin') {
+            await run('open', [targetPath]);
+            return;
+        }
+        await run('xdg-open', [targetPath]);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.error(`Failed to open ${targetPath}: ${message}`);
+    }
+}
+function setupCliLogging(prefix, options) {
+    const { logger, memoryHandler } = createSerenaLogger({
+        level: 'info',
+        emitToConsole: options.emitToConsole,
+        name: `serena.cli.${prefix}`
+    });
+    const paths = new SerenaPaths();
+    const logFilePath = paths.getNextLogFilePath(prefix);
+    const stream = fs.createWriteStream(logFilePath, { encoding: 'utf-8', flags: 'w' });
+    const callback = (message) => {
+        stream.write(`${message}\n`);
+        if (options.duplicateToStderr) {
+            process.stderr.write(`${message}\n`);
+        }
+    };
+    memoryHandler.addEmitCallback(callback);
+    const dispose = () => {
+        memoryHandler.removeEmitCallback(callback);
+        stream.end();
+    };
+    return { logger, memoryHandler, logFilePath, dispose };
+}
+async function handleStartMcpServer(options, projectArg) {
+    const suppressConsoleLogs = options.transport === 'stdio';
+    let restoreConsoleLogging = () => {
+        // noop
+    };
+    if (suppressConsoleLogs) {
+        setConsoleLoggingEnabled(false);
+        restoreConsoleLogging = () => setConsoleLoggingEnabled(true);
+    }
+    const cliLog = setupCliLogging('mcp', {
+        emitToConsole: !suppressConsoleLogs,
+        duplicateToStderr: suppressConsoleLogs
+    });
+    const { logger } = cliLog;
+    logger.info('Initializing Serena MCP server');
+    logger.info(`Storing logs in ${cliLog.logFilePath}`);
+    logger.info(`Serena CLI log format: ${SERENA_LOG_FORMAT}`);
+    const project = normalizeProjectArgument(projectArg ?? options.projectFile ?? options.project ?? null);
+    if (projectArg && projectArg !== project) {
+        logger.warn('--project 引数の代わりに位置引数を使用する方法は非推奨です (--project を使用してください)。');
+    }
+    const modes = options.modes.length > 0 ? options.modes : Array.from(DEFAULT_MODES);
+    const factory = new SerenaMCPFactorySingleProcess({
+        context: options.context ?? DEFAULT_CONTEXT,
+        project,
+        memoryLogHandler: cliLog.memoryHandler,
+        agentFactory: (agentOptions) => new SerenaAgent({
+            project: agentOptions.project,
+            serenaConfig: agentOptions.serenaConfig,
+            context: agentOptions.context,
+            modes: agentOptions.modes,
+            memoryLogHandler: agentOptions.memoryLogHandler ?? undefined
+        })
+    });
+    try {
+        const serverOptions = {
+            host: options.host,
+            port: options.port,
+            modes,
+            enableWebDashboard: options.enableWebDashboard ?? undefined,
+            enableGuiLogWindow: options.enableGuiLogWindow ?? undefined,
+            logLevel: options.logLevel ?? undefined,
+            traceLspCommunication: options.traceLspCommunication ?? undefined,
+            toolTimeout: options.toolTimeout ?? undefined,
+            instructionsOverride: options.instructionsOverride ?? undefined
+        };
+        switch (options.transport) {
+            case 'streamable-http': {
+                const server = await createSerenaHttpServer(factory, serverOptions);
+                logger.info(`Streamable HTTP MCP server started: ${server.url.href}`);
+                logger.info('Press Ctrl+C to exit.');
+                await new Promise((resolve) => {
+                    const shutdown = async () => {
+                        logger.info('Stopping HTTP MCP server...');
+                        await server.close();
+                        resolve();
+                    };
+                    process.once('SIGINT', () => {
+                        void shutdown();
+                    });
+                    process.once('SIGTERM', () => {
+                        void shutdown();
+                    });
+                });
+                break;
+            }
+            case 'stdio': {
+                const server = await createSerenaStdioServer(factory, serverOptions);
+                logger.info('STDIO MCP server started. Press Ctrl+C to exit.');
+                await new Promise((resolve) => {
+                    let settled = false;
+                    const finalize = async (reason) => {
+                        if (settled) {
+                            return;
+                        }
+                        settled = true;
+                        logger.info('Stopping STDIO MCP server...');
+                        if (reason === 'signal') {
+                            await server.close();
+                        }
+                        resolve();
+                    };
+                    server.transport.onclose = () => {
+                        void finalize('transport-close');
+                    };
+                    server.transport.onerror = (error) => {
+                        logger.error('STDIO MCP トランスポートでエラーが発生しました。', error);
+                        void finalize('transport-close');
+                    };
+                    const onSignal = (signal) => {
+                        logger.info(`Received signal ${signal}`);
+                        void finalize('signal');
+                    };
+                    process.once('SIGINT', onSignal);
+                    process.once('SIGTERM', onSignal);
+                });
+                break;
+            }
+            case 'sse':
+                throw new Error('SSE トランスポートは TypeScript 版では未実装です。HTTP モード (--transport streamable-http) を利用してください。');
+            default:
+                throw new Error(`未知のトランスポートが指定されました: ${options.transport}`);
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        logger.error(`Serena MCP サーバーの起動に失敗しました: ${message}`);
+        throw error;
+    }
+    finally {
+        cliLog.dispose();
+        restoreConsoleLogging();
+    }
+}
+function formatModeLine(name, yamlPath) {
+    const isInternal = isPathInside(yamlPath, SERENAS_OWN_MODE_YAMLS_DIR);
+    const descriptor = isInternal ? '(internal)' : `(at ${yamlPath})`;
+    return `${name}    ${descriptor}`;
+}
+function formatContextLine(name, yamlPath) {
+    const isInternal = isPathInside(yamlPath, SERENAS_OWN_CONTEXT_YAMLS_DIR);
+    const descriptor = isInternal ? '(internal)' : `(at ${yamlPath})`;
+    return `${name}    ${descriptor}`;
+}
+function ensureDirExists(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function handleModeCreate(options) {
+    const { name, fromInternal } = options;
+    if (!name && !fromInternal) {
+        throw new Error('--name か --from-internal のいずれかを指定してください。');
+    }
+    const modeName = name ?? fromInternal ?? '';
+    const destination = path.join(USER_MODE_YAMLS_DIR, `${modeName}.yml`);
+    const source = fromInternal
+        ? path.join(SERENAS_OWN_MODE_YAMLS_DIR, `${fromInternal}.yml`)
+        : path.join(SERENAS_OWN_MODE_YAMLS_DIR, 'mode.template.yml');
+    if (!fs.existsSync(source)) {
+        const available = SerenaAgentMode.listRegisteredModeNames().join(', ');
+        throw new Error(`内部モード '${fromInternal ?? ''}' が見つかりません。利用可能なモード: ${available}`);
+    }
+    ensureDirExists(path.dirname(destination));
+    fs.copyFileSync(source, destination);
+    return destination;
+}
+function handleContextCreate(options) {
+    const { name, fromInternal } = options;
+    if (!name && !fromInternal) {
+        throw new Error('--name か --from-internal のいずれかを指定してください。');
+    }
+    const contextName = name ?? fromInternal ?? '';
+    const destination = path.join(USER_CONTEXT_YAMLS_DIR, `${contextName}.yml`);
+    const source = fromInternal
+        ? path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, `${fromInternal}.yml`)
+        : path.join(SERENAS_OWN_CONTEXT_YAMLS_DIR, 'context.template.yml');
+    if (!fs.existsSync(source)) {
+        const available = SerenaAgentContext.listRegisteredContextNames().join(', ');
+        throw new Error(`内部コンテキスト '${fromInternal ?? ''}' が見つかりません。利用可能なコンテキスト: ${available}`);
+    }
+    ensureDirExists(path.dirname(destination));
+    fs.copyFileSync(source, destination);
+    return destination;
+}
+function formatPromptListLine(promptYamlName, userPromptYamlPath) {
+    if (fs.existsSync(userPromptYamlPath)) {
+        return `${userPromptYamlPath} merged with default prompts in ${promptYamlName}`;
+    }
+    return promptYamlName;
+}
+function getUserPromptPath(promptYamlName) {
+    ensureDirExists(PROMPT_TEMPLATES_DIR_IN_USER_HOME);
+    return path.join(PROMPT_TEMPLATES_DIR_IN_USER_HOME, promptYamlName);
+}
+function ensurePromptYamlName(promptYamlName) {
+    return promptYamlName.endsWith('.yml') ? promptYamlName : `${promptYamlName}.yml`;
+}
+export function createSerenaCli(options = {}) {
+    const program = new Command('serena');
+    program
+        .description('Serena CLI commands. 各コマンドの詳細は `<command> --help` を参照してください。')
+        .showHelpAfterError('(ヘルプ: serena --help)')
+        .configureOutput({
+        writeOut: options.writeOut ?? ((str) => process.stdout.write(str)),
+        writeErr: options.writeErr ?? ((str) => process.stderr.write(str)),
+        outputError: (str, write) => write(str)
+    });
+    if (options.enableExitOverride) {
+        program.exitOverride();
+    }
+    const startMcpServerCommand = new Command('start-mcp-server')
+        .description('Serena MCP サーバーを起動します。')
+        .option('--project [project]', '起動時にアクティブ化するプロジェクト名またはパス。')
+        .option('--project-file [project]', '[非推奨] --project の旧名称。')
+        .argument('[project]', '[非推奨] プロジェクトの位置引数。')
+        .option('--context <context>', 'ビルトインコンテキスト名またはカスタム YAML へのパス。')
+        .addOption(new Option('--mode <mode...>', 'ビルトインモード名またはカスタムモード YAML を複数指定できます。')
+        .default(Array.from(DEFAULT_MODES)))
+        .addOption(new Option('--transport <transport>', '使用するトランスポート。')
+        .choices(['stdio', 'sse', 'streamable-http'])
+        .default('stdio'))
+        .option('--host <host>', 'サーバーのバインドホスト。', '0.0.0.0')
+        .option('--port <port>', 'サーバーのポート。', (value) => parseInteger(value, '--port'), 8000)
+        .option('--enable-web-dashboard [value]', 'Config の web_dashboard 設定を上書きします。', parseOptionalBoolean, undefined)
+        .option('--enable-gui-log-window [value]', 'Config の gui_log_window 設定を上書きします。', parseOptionalBoolean, undefined)
+        .addOption(new Option('--log-level <level>', 'Config の log_level を上書きします。')
+        .choices([...LOG_LEVEL_NAMES]))
+        .option('--trace-lsp-communication [value]', 'LSP 通信のトレースを有効／無効にします。', parseOptionalBoolean, undefined)
+        .option('--tool-timeout <seconds>', 'ツール実行のタイムアウト(秒)。', (value) => parseFloatSeconds(value))
+        .option('--instructions-override <prompt>', 'ツールに公開する初期インストラクションを明示的に上書きします。', undefined)
+        .action(async function (projectArg) {
+        const opts = normalizeStartMcpServerOptions(this.optsWithGlobals());
+        const normalizedProjectArg = projectArg ?? null;
+        try {
+            await handleStartMcpServer(opts, normalizedProjectArg);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            this.error(`${message}\n`, { exitCode: 1 });
+        }
+    });
+    const printSystemPromptCommand = new Command('print-system-prompt')
+        .description('プロジェクトに対するシステムプロンプトを表示します。')
+        .argument('[project]', 'プロジェクトパス (省略時はカレントディレクトリ)。', process.cwd())
+        .option('--log-level <level>', 'プロンプト生成時のログレベル。', 'WARNING')
+        .option('--only-instructions', '初期指示部分のみ出力します。')
+        .option('--context <context>', 'ビルトインコンテキスト名または YAML パス。', DEFAULT_CONTEXT)
+        .addOption(new Option('--mode <mode...>', 'ビルトインモードまたは YAML を複数指定。').default(Array.from(DEFAULT_MODES)))
+        .action((projectPath, command) => {
+        const err = 'print-system-prompt はエージェント実装が移植され次第サポート予定です。現在は未実装のため利用できません。';
+        command.error(`${err}\n`, { exitCode: 1 });
+    });
+    program.addCommand(startMcpServerCommand);
+    program.addCommand(printSystemPromptCommand);
+    const modeCommand = new Command('mode')
+        .description('Serena モードを管理します。');
+    modeCommand
+        .command('list')
+        .description('利用可能なモードを一覧表示します。')
+        .action(() => {
+        const modes = SerenaAgentMode.listRegisteredModeNames();
+        const output = modes
+            .map((name) => {
+            const yamlPath = SerenaAgentMode.getPath(name);
+            return formatModeLine(name, yamlPath);
+        })
+            .join('\n');
+        if (output.length > 0) {
+            console.log(output);
+        }
+    });
+    modeCommand
+        .command('create')
+        .description('新しいモードを作成するか、内部モードをコピーします。')
+        .option('--name <name>', '新しいモード名。')
+        .option('--from-internal <name>', '内部モードからコピーします。')
+        .action(async (options) => {
+        try {
+            const destination = handleModeCreate({
+                name: options.name ?? null,
+                fromInternal: options.fromInternal ?? null
+            });
+            console.log(`Created mode '${path.parse(destination).name}' at ${destination}`);
+            await openInEditor(destination);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`${message}`);
+        }
+    });
+    modeCommand
+        .command('edit')
+        .description('カスタムモード YAML を編集します。')
+        .argument('<modeName>', 'モード名')
+        .action(async (modeName) => {
+        const destination = path.join(USER_MODE_YAMLS_DIR, `${modeName}.yml`);
+        if (!fs.existsSync(destination)) {
+            if (SerenaAgentMode.listRegisteredModeNames(false).includes(modeName)) {
+                throw new Error(`Mode '${modeName}' は内部モードのため直接編集できません。'mode create --from-internal ${modeName}' を使用してカスタムモードを作成してください。`);
+            }
+            throw new Error(`カスタムモード '${modeName}' が見つかりません。'mode create --name ${modeName}' を使用してください。`);
+        }
+        await openInEditor(destination);
+    });
+    modeCommand
+        .command('delete')
+        .description('カスタムモードファイルを削除します。')
+        .argument('<modeName>', 'モード名')
+        .action((modeName) => {
+        const destination = path.join(USER_MODE_YAMLS_DIR, `${modeName}.yml`);
+        if (!fs.existsSync(destination)) {
+            throw new Error(`カスタムモード '${modeName}' が存在しません。`);
+        }
+        fs.rmSync(destination);
+        console.log(`Deleted custom mode '${modeName}'.`);
+    });
+    program.addCommand(modeCommand);
+    const contextCommand = new Command('context')
+        .description('Serena コンテキストを管理します。');
+    contextCommand
+        .command('list')
+        .description('利用可能なコンテキストを一覧表示します。')
+        .action(() => {
+        const contexts = SerenaAgentContext.listRegisteredContextNames();
+        const output = contexts
+            .map((name) => {
+            const yamlPath = SerenaAgentContext.getPath(name);
+            return formatContextLine(name, yamlPath);
+        })
+            .join('\n');
+        if (output.length > 0) {
+            console.log(output);
+        }
+    });
+    contextCommand
+        .command('create')
+        .description('新しいコンテキストを作成するか、内部コンテキストをコピーします。')
+        .option('--name <name>', '新しいコンテキスト名。')
+        .option('--from-internal <name>', '内部コンテキストからコピーします。')
+        .action(async (options) => {
+        try {
+            const destination = handleContextCreate({
+                name: options.name ?? null,
+                fromInternal: options.fromInternal ?? null
+            });
+            console.log(`Created context '${path.parse(destination).name}' at ${destination}`);
+            await openInEditor(destination);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(`${message}`);
+        }
+    });
+    contextCommand
+        .command('edit')
+        .description('カスタムコンテキスト YAML を編集します。')
+        .argument('<contextName>', 'コンテキスト名')
+        .action(async (contextName) => {
+        const destination = path.join(USER_CONTEXT_YAMLS_DIR, `${contextName}.yml`);
+        if (!fs.existsSync(destination)) {
+            if (SerenaAgentContext.listRegisteredContextNames(false).includes(contextName)) {
+                throw new Error(`Context '${contextName}' は内部コンテキストのため直接編集できません。'context create --from-internal ${contextName}' を使用してカスタムコンテキストを作成してください。`);
+            }
+            throw new Error(`カスタムコンテキスト '${contextName}' が見つかりません。'context create --name ${contextName}' を使用してください。`);
+        }
+        await openInEditor(destination);
+    });
+    contextCommand
+        .command('delete')
+        .description('カスタムコンテキストファイルを削除します。')
+        .argument('<contextName>', 'コンテキスト名')
+        .action((contextName) => {
+        const destination = path.join(USER_CONTEXT_YAMLS_DIR, `${contextName}.yml`);
+        if (!fs.existsSync(destination)) {
+            throw new Error(`カスタムコンテキスト '${contextName}' は存在しません。`);
+        }
+        fs.rmSync(destination);
+        console.log(`Deleted custom context '${contextName}'.`);
+    });
+    program.addCommand(contextCommand);
+    const configCommand = new Command('config')
+        .description('Serena の設定ファイルを扱います。');
+    configCommand
+        .command('edit')
+        .description('serena_config.yml を既定のエディタで開きます。')
+        .action(async () => {
+        const configPath = path.join(SERENA_MANAGED_DIR_IN_HOME, 'serena_config.yml');
+        if (!fs.existsSync(configPath)) {
+            ensureDirExists(path.dirname(configPath));
+            SerenaConfig.generateConfigFile(configPath);
+        }
+        await openInEditor(configPath);
+    });
+    program.addCommand(configCommand);
+    const projectCommand = new Command('project')
+        .description('Serena プロジェクト関連の操作。');
+    projectCommand
+        .command('generate-yml')
+        .description('プロジェクトの project.yml を生成します。')
+        .argument('[projectPath]', 'プロジェクトディレクトリ (既定: カレントディレクトリ)。', process.cwd())
+        .option('--language <language>', 'プロジェクトの言語。指定しない場合は自動推測。')
+        .action((projectPath, options) => {
+        const resolved = path.resolve(projectPath);
+        try {
+            const language = options.language ? coerceLanguage(options.language) : undefined;
+            const config = ProjectConfig.autogenerate(resolved, {
+                projectLanguage: language ?? null
+            });
+            console.log(`Generated project.yml with language ${config.language} at ${path.join(resolved, ProjectConfig.relPathToProjectYml())}.`);
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            throw new Error(message);
+        }
+    });
+    projectCommand
+        .command('index')
+        .description('プロジェクトのシンボルをインデックスします。')
+        .action(() => {
+        throw new Error('project index はエージェントおよび SolidLSP モジュール移植後に実装予定です。');
+    });
+    projectCommand
+        .command('index-deprecated')
+        .description('project index の旧名称。')
+        .action(() => {
+        throw new Error('project index-deprecated は TypeScript 版では利用できません。`serena project index` をお待ちください。');
+    });
+    projectCommand
+        .command('is_ignored_path')
+        .description('プロジェクト設定で無視されるパスか確認します。')
+        .action(() => {
+        throw new Error('is_ignored_path は TypeScript 版で未実装です。');
+    });
+    projectCommand
+        .command('index-file')
+        .description('単一ファイルのインデックス化を行います。')
+        .action(() => {
+        throw new Error('index-file は TypeScript 版で未実装です。');
+    });
+    projectCommand
+        .command('health-check')
+        .description('プロジェクトのヘルスチェックを実行します。')
+        .action(() => {
+        throw new Error('health-check は SolidLSP およびエージェント移植後に実装予定です。');
+    });
+    program.addCommand(projectCommand);
+    const toolsCommand = new Command('tools')
+        .description('Serena のツール情報を表示します。');
+    toolsCommand
+        .command('list')
+        .description('利用可能なツールの概要を表示します。')
+        .option('--quiet', '-q', 'ツール名のみを表示します。')
+        .option('--all', '-a', 'オプションツールを含め全て表示します。')
+        .option('--only-optional', 'オプションツールのみ表示します。')
+        .action((options) => {
+        const registry = new ToolRegistry();
+        if (options.quiet) {
+            let toolNames;
+            if (options.onlyOptional) {
+                toolNames = registry.getToolNamesOptional();
+            }
+            else if (options.all) {
+                toolNames = registry.getToolNames();
+            }
+            else {
+                toolNames = registry.getToolNamesDefaultEnabled();
+            }
+            console.log(toolNames.join('\n'));
+            return;
+        }
+        registry.printToolOverview(undefined, {
+            includeOptional: options.all,
+            onlyOptional: options.onlyOptional
+        });
+    });
+    toolsCommand
+        .command('description')
+        .description('指定したツールの説明を表示します。')
+        .argument('<toolName>', 'ツール名')
+        .option('--context <context>', 'コンテキスト名または YAML パス。')
+        .action(() => {
+        throw new Error('tools description はエージェント移植後に実装予定です。');
+    });
+    program.addCommand(toolsCommand);
+    const promptsCommand = new Command('prompts')
+        .description('プロンプト関連のコマンド。');
+    promptsCommand
+        .command('list')
+        .description('プロンプト定義に使用される YAML を一覧表示します。')
+        .action(() => {
+        const names = fs
+            .readdirSync(PROMPT_TEMPLATES_DIR_INTERNAL, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.yml'))
+            .map((entry) => entry.name)
+            .sort();
+        const lines = names.map((name) => formatPromptListLine(name, getUserPromptPath(name)));
+        console.log(lines.join('\n'));
+    });
+    promptsCommand
+        .command('create-override')
+        .description('内部プロンプト YAML のオーバーライドを作成します。')
+        .argument('<promptYamlName>', 'プロンプト YAML 名')
+        .action(async (promptYamlName) => {
+        const normalized = ensurePromptYamlName(promptYamlName);
+        const destination = getUserPromptPath(normalized);
+        if (fs.existsSync(destination)) {
+            throw new Error(`${destination} は既に存在します。`);
+        }
+        const source = path.join(PROMPT_TEMPLATES_DIR_INTERNAL, normalized);
+        if (!fs.existsSync(source)) {
+            throw new Error(`内部プロンプト '${normalized}' が見つかりません。'prompts list' で確認してください。`);
+        }
+        fs.copyFileSync(source, destination);
+        await openInEditor(destination);
+    });
+    promptsCommand
+        .command('edit-override')
+        .description('既存のプロンプトオーバーライドを編集します。')
+        .argument('<promptYamlName>', 'プロンプト YAML 名')
+        .action(async (promptYamlName) => {
+        const normalized = ensurePromptYamlName(promptYamlName);
+        const destination = getUserPromptPath(normalized);
+        if (!fs.existsSync(destination)) {
+            throw new Error(`Override file '${normalized}' は存在しません。'prompts create-override ${normalized}' を使用してください。`);
+        }
+        await openInEditor(destination);
+    });
+    promptsCommand
+        .command('list-overrides')
+        .description('既存のプロンプトオーバーライドを一覧表示します。')
+        .action(() => {
+        ensureDirExists(PROMPT_TEMPLATES_DIR_IN_USER_HOME);
+        const overrides = fs
+            .readdirSync(PROMPT_TEMPLATES_DIR_IN_USER_HOME, { withFileTypes: true })
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.yml'))
+            .map((entry) => path.join(PROMPT_TEMPLATES_DIR_IN_USER_HOME, entry.name))
+            .sort();
+        for (const filePath of overrides) {
+            console.log(filePath);
+        }
+    });
+    promptsCommand
+        .command('delete-override')
+        .description('プロンプトオーバーライドファイルを削除します。')
+        .argument('<promptYamlName>', 'プロンプト YAML 名')
+        .action((promptYamlName) => {
+        const normalized = ensurePromptYamlName(promptYamlName);
+        const destination = getUserPromptPath(normalized);
+        if (!fs.existsSync(destination)) {
+            throw new Error(`Override file '${normalized}' は存在しません。`);
+        }
+        fs.rmSync(destination);
+        console.log(`Deleted override file '${normalized}'.`);
+    });
+    program.addCommand(promptsCommand);
+    return program;
+}
+export async function runSerenaCli(argv = process.argv.slice(2)) {
+    const cli = createSerenaCli();
+    await cli.parseAsync(argv, { from: 'user' });
+}
+export default runSerenaCli;