@buaa_smat/hometrans 0.1.0

package/dist/cli/config.js

@@ -0,0 +1,28 @@
+/**
+ * `ht config` — 打印 editors.json 路径与内容。
+ *
+ * 该命令只读：用户若要修改 editor 配置，直接编辑这个 JSON 文件即可。
+ * 文件不存在时自动写入默认 4 个 editor。
+ */
+import fs from 'node:fs/promises';
+import { getConfigPath, loadHomeTransConfig } from './config-store.js';
+export async function configCommand() {
+    const configPath = getConfigPath();
+    // 触发不存在则写默认值的逻辑
+    await loadHomeTransConfig();
+    const raw = await fs.readFile(configPath, 'utf-8');
+    console.log('');
+    console.log('  HomeTrans Editor Config');
+    console.log('  =======================');
+    console.log('');
+    console.log(`  Path: ${configPath}`);
+    console.log('');
+    console.log('  Content:');
+    console.log('');
+    for (const line of raw.replace(/\r?\n$/, '').split(/\r?\n/)) {
+        console.log(`    ${line}`);
+    }
+    console.log('');
+    console.log('  Edit this file to add or modify editors, then re-run `ht init`.');
+    console.log('');
+}

package/dist/cli/index.js

@@ -0,0 +1,42 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import { createRequire } from 'node:module';
+import { initCommand } from './init.js';
+import { runMcpServer } from './mcp.js';
+import { configCommand } from './config.js';
+import { uninstallCommand } from './uninstall.js';
+const _require = createRequire(import.meta.url);
+const pkg = _require('../../package.json');
+const program = new Command();
+program
+    .name('hometrans')
+    .description('HomeTrans installer — distribute Android-to-HarmonyOS skills and agents into AI editors')
+    .version(pkg.version);
+program
+    .command('init')
+    .description('Initialize HomeTrans — select editors and install skills, agents, and MCP servers')
+    .action(async () => {
+    await initCommand();
+});
+program
+    .command('mcp')
+    .description('Run the HomeTrans MCP server (stdio)')
+    .action(async () => {
+    await runMcpServer();
+});
+program
+    .command('config')
+    .description('Show the editors.json path and content (~/.hometrans/editors.json). Edit the file directly to customize editors, then re-run `ht init`.')
+    .action(async () => {
+    await configCommand();
+});
+program
+    .command('uninstall')
+    .description('Remove all hometrans skills, agents, and MCP entries from configured editors')
+    .action(async () => {
+    await uninstallCommand();
+});
+program.parseAsync(process.argv).catch((err) => {
+    console.error(err instanceof Error ? err.message : err);
+    process.exit(1);
+});

package/dist/cli/init.js

@@ -0,0 +1,224 @@
+/**
+ * `ht init` — interactive initialization for HomeTrans.
+ *
+ * Displays the HomeTrans banner, lets the user select which editors to
+ * configure, then copies bundled skills/agents and registers MCP servers
+ * for the chosen editors.
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import os from 'node:os';
+import { fileURLToPath } from 'node:url';
+import chalk from 'chalk';
+import figlet from 'figlet';
+import inquirer from 'inquirer';
+import { setupMcpForAllEditors } from './mcp-setup.js';
+import { expandHome, loadHomeTransConfig, } from './config-store.js';
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+export async function dirExists(dirPath) {
+    try {
+        const stat = await fs.stat(dirPath);
+        return stat.isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function copyDirRecursive(src, dest) {
+    await fs.mkdir(dest, { recursive: true });
+    const entries = await fs.readdir(src, { withFileTypes: true });
+    for (const entry of entries) {
+        const srcPath = path.join(src, entry.name);
+        const destPath = path.join(dest, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath);
+        }
+        else {
+            await fs.copyFile(srcPath, destPath);
+        }
+    }
+}
+function resolveSkillsRoot() {
+    return path.resolve(__dirname, '..', '..', 'skills');
+}
+function resolveAgentsRoot() {
+    return path.resolve(__dirname, '..', '..', 'agents');
+}
+async function installSkillsTo(skillsRoot, targetDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(skillsRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    const installed = [];
+    for (const entry of entries) {
+        if (!entry.isDirectory())
+            continue;
+        const skillSrc = path.join(skillsRoot, entry.name);
+        const hasSkillFile = await fs
+            .access(path.join(skillSrc, 'SKILL.md'))
+            .then(() => true)
+            .catch(() => false);
+        if (!hasSkillFile)
+            continue;
+        const skillDest = path.join(targetDir, entry.name);
+        await copyDirRecursive(skillSrc, skillDest);
+        installed.push(entry.name);
+    }
+    return installed;
+}
+async function installAgentsTo(agentsRoot, targetDir) {
+    let entries;
+    try {
+        entries = await fs.readdir(agentsRoot, { withFileTypes: true });
+    }
+    catch {
+        return [];
+    }
+    await fs.mkdir(targetDir, { recursive: true });
+    const installed = [];
+    for (const entry of entries) {
+        const srcPath = path.join(agentsRoot, entry.name);
+        const destPath = path.join(targetDir, entry.name);
+        if (entry.isDirectory()) {
+            await copyDirRecursive(srcPath, destPath);
+        }
+        else if (entry.isFile()) {
+            await fs.copyFile(srcPath, destPath);
+            if (entry.name.endsWith('.md')) {
+                installed.push(entry.name.slice(0, -3));
+            }
+        }
+    }
+    return installed;
+}
+async function installForEditor(editor, skillsRoot, agentsRoot, result) {
+    const marker = expandHome(editor.markerDir);
+    if (marker && !(await dirExists(marker))) {
+        result.skipped.push(`${editor.name} (not installed)`);
+        return;
+    }
+    const skillsDir = expandHome(editor.skillsDir);
+    const agentsDir = expandHome(editor.agentsDir);
+    try {
+        const skills = await installSkillsTo(skillsRoot, skillsDir);
+        if (skills.length > 0) {
+            result.configured.push(`${editor.name} skills (${skills.length} -> ${prettyHome(skillsDir)})`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} skills: ${err.message}`);
+    }
+    try {
+        const agents = await installAgentsTo(agentsRoot, agentsDir);
+        if (agents.length > 0) {
+            result.configured.push(`${editor.name} agents (${agents.length} -> ${prettyHome(agentsDir)})`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} agents: ${err.message}`);
+    }
+}
+export function prettyHome(p) {
+    const home = os.homedir();
+    if (p.startsWith(home)) {
+        return '~' + p.slice(home.length).replace(/\\/g, '/');
+    }
+    return p.replace(/\\/g, '/');
+}
+async function detectInstalledEditors(editors) {
+    const status = new Map();
+    for (const editor of editors) {
+        const marker = expandHome(editor.markerDir);
+        if (!marker) {
+            status.set(editor.name, true);
+        }
+        else {
+            status.set(editor.name, await dirExists(marker));
+        }
+    }
+    return status;
+}
+export async function initCommand() {
+    const banner = figlet.textSync('HomeTrans', { font: 'Standard' });
+    console.log(chalk.cyan(`\n${banner.trimEnd()}`));
+    console.log(chalk.gray('\n   Android-to-HarmonyOS skill & agent installer for AI editors\n'));
+    const skillsRoot = resolveSkillsRoot();
+    const agentsRoot = resolveAgentsRoot();
+    const hasSkills = await dirExists(skillsRoot);
+    const hasAgents = await dirExists(agentsRoot);
+    if (!hasSkills && !hasAgents) {
+        console.error(chalk.red(`  ! Neither skills/ nor agents/ found at package root.`));
+        console.error(chalk.gray(`    Looked in: ${skillsRoot}`));
+        console.error(chalk.gray(`               ${agentsRoot}`));
+        console.error(chalk.gray('    Reinstall hometrans or run `npm run build` from the package root.'));
+        process.exitCode = 1;
+        return;
+    }
+    const { editors } = await loadHomeTransConfig();
+    const installedStatus = await detectInstalledEditors(editors);
+    const choices = editors.map((editor) => {
+        const installed = installedStatus.get(editor.name);
+        const label = installed
+            ? `${editor.name}  ${chalk.green('(detected)')}`
+            : `${editor.name}  ${chalk.gray('(not detected)')}`;
+        return {
+            name: label,
+            value: editor.name,
+            checked: installed,
+        };
+    });
+    const { selectedEditors } = await inquirer.prompt([
+        {
+            type: 'checkbox',
+            name: 'selectedEditors',
+            message: 'Select editors to configure:',
+            choices,
+        },
+    ]);
+    if (selectedEditors.length === 0) {
+        console.log(chalk.yellow('\n  No editors selected. Nothing to do.\n'));
+        return;
+    }
+    console.log('');
+    const editorsToSetup = editors.filter((e) => selectedEditors.includes(e.name));
+    const result = { configured: [], skipped: [], errors: [] };
+    for (const editor of editorsToSetup) {
+        console.log(chalk.blue(`  Configuring ${editor.name}...`));
+        await installForEditor(editor, skillsRoot, agentsRoot, result);
+    }
+    await setupMcpForAllEditors(editorsToSetup, result);
+    console.log('');
+    if (result.configured.length > 0) {
+        console.log(chalk.green('  Configured:'));
+        for (const name of result.configured)
+            console.log(chalk.green(`    + ${name}`));
+    }
+    if (result.skipped.length > 0) {
+        console.log('');
+        console.log(chalk.yellow('  Skipped:'));
+        for (const name of result.skipped)
+            console.log(chalk.yellow(`    - ${name}`));
+    }
+    if (result.errors.length > 0) {
+        console.log('');
+        console.log(chalk.red('  Errors:'));
+        for (const err of result.errors)
+            console.log(chalk.red(`    ! ${err}`));
+    }
+    console.log('');
+    console.log(chalk.gray(`  Source skills: ${skillsRoot}`));
+    console.log(chalk.gray(`  Source agents: ${agentsRoot}`));
+    console.log('');
+    if (result.configured.length === 0 && result.errors.length === 0) {
+        console.log(chalk.yellow('  No editors were configured. Make sure the selected editors are installed,'));
+        console.log(chalk.yellow('  then re-run `ht init`.'));
+    }
+    else {
+        console.log(chalk.green('  Done. Re-open your editor for the new skills/agents to be picked up.'));
+    }
+    console.log('');
+}

package/dist/cli/mcp-setup.js

@@ -0,0 +1,262 @@
+/**
+ * `ht init` 阶段：按 editors.json 中每个 editor 的 mcp.format 把 hometrans MCP
+ * server 注册到对应的 editor 配置文件。
+ *
+ * 支持的 mcp.format：
+ *   jsonc-object        Cursor / Claude Code 风格：jsonc 文件，key 路径写对象
+ *   jsonc-command-array OpenCode 风格：jsonc 文件，value 是 {type, command:[]}
+ *   codex-cli           Codex：优先 `codex mcp add`，失败回退追加 TOML section
+ *   toml-section        纯 TOML：追加 [<section>] 段
+ *   none                跳过 MCP 写入
+ */
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { execFile, execFileSync } from 'node:child_process';
+import { createRequire } from 'node:module';
+import { promisify } from 'node:util';
+import { parseTree, modify, applyEdits, } from 'jsonc-parser';
+import { dirExists } from './init.js';
+import { expandHome } from './config-store.js';
+const execFileAsync = promisify(execFile);
+const _require = createRequire(import.meta.url);
+const _pkg = _require('../../package.json');
+if (typeof _pkg.version !== 'string' || !_pkg.version) {
+    throw new Error('hometrans package.json#version is missing — cannot generate MCP fallback config.');
+}
+const PKG_NAME = typeof _pkg.name === 'string' && _pkg.name ? _pkg.name : 'hometrans';
+const NPX_REF = `${PKG_NAME}@${_pkg.version}`;
+/** Locate the globally-installed `hometrans` (or `ht`) binary. */
+function resolveHometransBin() {
+    const isWin = process.platform === 'win32';
+    const cmd = isWin ? 'where' : 'which';
+    for (const candidate of ['hometrans', 'ht']) {
+        try {
+            const output = execFileSync(cmd, [candidate], {
+                encoding: 'utf-8',
+                timeout: 5000,
+                stdio: ['ignore', 'pipe', 'ignore'],
+            });
+            const lines = output
+                .split('\n')
+                .map(l => l.trim())
+                .filter(Boolean);
+            if (lines.length === 0)
+                continue;
+            if (isWin) {
+                const cmdLine = lines.find(l => /\.(cmd|bat)$/i.test(l));
+                return cmdLine || lines[0];
+            }
+            return lines[0];
+        }
+        catch {
+            // try next candidate
+        }
+    }
+    return null;
+}
+/**
+ * MCP server entry written to editor config.
+ *
+ * Prefers global binary (fast startup) over `npx -y hometrans@<version> mcp`
+ * (cold-start may exceed Claude Code's 30s MCP connect timeout, esp. with
+ * arkanalyzer install). Falls back to npx when binary not on PATH.
+ */
+function getMcpEntry() {
+    const bin = resolveHometransBin();
+    if (bin) {
+        return { command: bin, args: ['mcp'] };
+    }
+    if (process.platform === 'win32') {
+        return { command: 'cmd', args: ['/c', 'npx', '-y', NPX_REF, 'mcp'] };
+    }
+    return { command: 'npx', args: ['-y', NPX_REF, 'mcp'] };
+}
+/** OpenCode uses a flat command-array format. */
+function getOpenCodeMcpEntry() {
+    const bin = resolveHometransBin();
+    if (bin) {
+        return { type: 'local', command: [bin, 'mcp'] };
+    }
+    if (process.platform === 'win32') {
+        return {
+            type: 'local',
+            command: ['cmd', '/c', 'npx', '-y', NPX_REF, 'mcp'],
+        };
+    }
+    return { type: 'local', command: ['npx', '-y', NPX_REF, 'mcp'] };
+}
+function detectIndentation(raw) {
+    const firstIndented = raw.match(/^( +|\t)/m);
+    if (!firstIndented)
+        return { tabSize: 2, insertSpaces: true };
+    if (firstIndented[1] === '\t')
+        return { tabSize: 1, insertSpaces: false };
+    return { tabSize: firstIndented[1].length, insertSpaces: true };
+}
+/**
+ * Merge a key/value pair into a JSONC config file, preserving comments and formatting.
+ * Returns false if the file is genuinely corrupt (leaves it untouched).
+ */
+async function mergeJsoncFile(filePath, keyPath, value) {
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, 'utf-8');
+    }
+    catch {
+        raw = '';
+    }
+    if (raw.trim().length === 0) {
+        await fs.mkdir(path.dirname(filePath), { recursive: true });
+        const formattingOptions = { tabSize: 2, insertSpaces: true };
+        const edits = modify('{}', keyPath, value, { formattingOptions });
+        const result = applyEdits('{}', edits);
+        await fs.writeFile(filePath, result, 'utf-8');
+        return true;
+    }
+    const parseErrors = [];
+    const tree = parseTree(raw, parseErrors);
+    if (tree && tree.type === 'object' && parseErrors.length === 0) {
+        const formattingOptions = detectIndentation(raw);
+        const edits = modify(raw, keyPath, value, { formattingOptions });
+        const result = applyEdits(raw, edits);
+        await fs.writeFile(filePath, result, 'utf-8');
+        return true;
+    }
+    return false;
+}
+function getTomlSection(sectionHeader) {
+    const entry = getMcpEntry();
+    const command = JSON.stringify(entry.command);
+    const args = `[${entry.args.map(arg => JSON.stringify(arg)).join(', ')}]`;
+    return `[${sectionHeader}]\ncommand = ${command}\nargs = ${args}\n`;
+}
+async function upsertTomlSection(configPath, sectionHeader) {
+    let existing = '';
+    try {
+        existing = await fs.readFile(configPath, 'utf-8');
+    }
+    catch {
+        existing = '';
+    }
+    if (existing.includes(`[${sectionHeader}]`)) {
+        return;
+    }
+    const section = getTomlSection(sectionHeader);
+    const nextContent = existing.trim().length > 0 ? `${existing.trimEnd()}\n\n${section}` : section;
+    await fs.mkdir(path.dirname(configPath), { recursive: true });
+    await fs.writeFile(configPath, `${nextContent.trimEnd()}\n`, 'utf-8');
+}
+// ─── Per-format writers ────────────────────────────────────────────
+async function writeJsoncObject(editor, result) {
+    const mcp = editor.mcp;
+    if (!mcp.path || !mcp.keyPath) {
+        result.errors.push(`${editor.name} MCP: jsonc-object format requires path + keyPath`);
+        return;
+    }
+    const configPath = expandHome(mcp.path);
+    try {
+        const ok = await mergeJsoncFile(configPath, mcp.keyPath, getMcpEntry());
+        if (ok) {
+            result.configured.push(`${editor.name} MCP (${prettyConfigPath(configPath)})`);
+        }
+        else {
+            result.errors.push(`${editor.name} MCP: ${configPath} is corrupt — skipping to preserve existing content`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} MCP: ${err.message}`);
+    }
+}
+async function writeJsoncCommandArray(editor, result) {
+    const mcp = editor.mcp;
+    if (!mcp.path || !mcp.keyPath) {
+        result.errors.push(`${editor.name} MCP: jsonc-command-array format requires path + keyPath`);
+        return;
+    }
+    const configPath = expandHome(mcp.path);
+    try {
+        const ok = await mergeJsoncFile(configPath, mcp.keyPath, getOpenCodeMcpEntry());
+        if (ok) {
+            result.configured.push(`${editor.name} MCP (${prettyConfigPath(configPath)})`);
+        }
+        else {
+            result.errors.push(`${editor.name} MCP: ${configPath} is corrupt — skipping to preserve existing content`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} MCP: ${err.message}`);
+    }
+}
+async function writeCodexCli(editor, result) {
+    try {
+        const entry = getMcpEntry();
+        await execFileAsync('codex', ['mcp', 'add', 'hometrans', '--', entry.command, ...entry.args], { shell: process.platform === 'win32' });
+        result.configured.push(`${editor.name} MCP (via codex mcp add)`);
+        return;
+    }
+    catch {
+        // Fall through to TOML write.
+    }
+    const mcp = editor.mcp;
+    if (!mcp.path || !mcp.section) {
+        result.errors.push(`${editor.name} MCP: codex-cli fallback requires path + section`);
+        return;
+    }
+    try {
+        const configPath = expandHome(mcp.path);
+        await upsertTomlSection(configPath, mcp.section);
+        result.configured.push(`${editor.name} MCP (${prettyConfigPath(configPath)})`);
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} MCP: ${err.message}`);
+    }
+}
+async function writeTomlSection(editor, result) {
+    const mcp = editor.mcp;
+    if (!mcp.path || !mcp.section) {
+        result.errors.push(`${editor.name} MCP: toml-section format requires path + section`);
+        return;
+    }
+    try {
+        const configPath = expandHome(mcp.path);
+        await upsertTomlSection(configPath, mcp.section);
+        result.configured.push(`${editor.name} MCP (${prettyConfigPath(configPath)})`);
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} MCP: ${err.message}`);
+    }
+}
+function prettyConfigPath(p) {
+    // 与 init.ts 中 prettyHome 行为一致，但避免循环引用：就地实现。
+    const home = process.env.HOME || process.env.USERPROFILE || '';
+    if (home && p.startsWith(home)) {
+        return '~' + p.slice(home.length).replace(/\\/g, '/');
+    }
+    return p.replace(/\\/g, '/');
+}
+async function setupOneEditor(editor, result) {
+    const marker = expandHome(editor.markerDir);
+    if (marker && !(await dirExists(marker))) {
+        result.skipped.push(`${editor.name} MCP (not installed)`);
+        return;
+    }
+    switch (editor.mcp.format) {
+        case 'jsonc-object':
+            return writeJsoncObject(editor, result);
+        case 'jsonc-command-array':
+            return writeJsoncCommandArray(editor, result);
+        case 'codex-cli':
+            return writeCodexCli(editor, result);
+        case 'toml-section':
+            return writeTomlSection(editor, result);
+        case 'none':
+            return;
+        default:
+            result.errors.push(`${editor.name} MCP: unknown mcp.format "${editor.mcp.format}"`);
+    }
+}
+export async function setupMcpForAllEditors(editors, result) {
+    for (const editor of editors) {
+        await setupOneEditor(editor, result);
+    }
+}

package/dist/cli/mcp.js

@@ -0,0 +1,94 @@
+/**
+ * `ht mcp` — stdio MCP server exposing HomeTrans tools.
+ *
+ * Currently registers a single tool: `extract_commit_context`, which wraps
+ * the vendored ArkTS commit-context extractor (src/context/index.ts).
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { extractCommitContext } from '../context/index.js';
+// stdio is the MCP protocol channel — any console.log from vendored code
+// would corrupt frames. Redirect stdout-side logging to stderr.
+console.log = console.error;
+console.info = console.error;
+console.dir = (...args) => process.stderr.write(args.map(a => (typeof a === 'string' ? a : JSON.stringify(a))).join(' ') + '\n');
+const EXTRACT_COMMIT_CONTEXT_TOOL = {
+    name: 'extract_commit_context',
+    description: '提取 HarmonyOS 工程指定 commit 的代码上下文索引（git diff + ArkTS 语义依赖：模块依赖、字符串/复数/数组资源依赖），供 AI 评审 Android→HarmonyOS 转换代码时使用。返回 {path, kind, ranges?, resourceNames?}[]：source 文件给出 1-based 行号区间数组，调用方按需读取；resource 文件给出引用到的资源名列表。不返回文件内容，避免上下文过长。',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            projectPath: {
+                type: 'string',
+                description: 'HarmonyOS 工程的绝对路径（包含 .git 目录的仓库根）',
+            },
+            commitId: {
+                type: 'string',
+                description: '要分析的 git commit id（会和它的第一个父提交做 diff）',
+            },
+            mode: {
+                type: 'string',
+                description: '分析模式：default = 构建完整 call graph 做调用链上下文；其它值跳过 call graph 构建',
+                default: 'default',
+            },
+            ohosSdkPath: {
+                type: 'string',
+                description: 'OpenHarmony SDK ETS 目录绝对路径（如 D:/DevEco Studio/sdk/default/openharmony/ets）。未传则读环境变量 HOMETRANS_OHOS_SDK_PATH。',
+            },
+            hmsSdkPath: {
+                type: 'string',
+                description: 'HMS SDK ETS 目录绝对路径（如 D:/DevEco Studio/sdk/default/hms/ets）。未传则读环境变量 HOMETRANS_HMS_SDK_PATH。',
+            },
+        },
+        required: ['projectPath', 'commitId'],
+    },
+};
+export async function runMcpServer() {
+    const server = new Server({ name: 'hometrans', version: '0.1.2' }, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({
+        tools: [EXTRACT_COMMIT_CONTEXT_TOOL],
+    }));
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+        const { name, arguments: args } = request.params;
+        if (name !== EXTRACT_COMMIT_CONTEXT_TOOL.name) {
+            return {
+                isError: true,
+                content: [{ type: 'text', text: `Unknown tool: ${name}` }],
+            };
+        }
+        try {
+            const input = (args ?? {});
+            const result = await extractCommitContext({
+                projectPath: input.projectPath ?? '',
+                commitId: input.commitId ?? '',
+                mode: input.mode,
+                ohosSdkPath: input.ohosSdkPath,
+                hmsSdkPath: input.hmsSdkPath,
+            });
+            return {
+                content: [{ type: 'text', text: JSON.stringify(result, null, 2) }],
+            };
+        }
+        catch (err) {
+            return {
+                isError: true,
+                content: [
+                    {
+                        type: 'text',
+                        text: `extract_commit_context failed: ${err?.message ?? String(err)}`,
+                    },
+                ],
+            };
+        }
+    });
+    process.on('uncaughtException', err => {
+        console.error('[hometrans/mcp] uncaughtException:', err);
+    });
+    process.on('unhandledRejection', err => {
+        console.error('[hometrans/mcp] unhandledRejection:', err);
+    });
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error('[hometrans/mcp] server connected on stdio');
+}