@buaa_smat/hometrans 0.1.9 → 0.1.11

package/dist/cli/config-store.js

@@ -1,13 +1,45 @@
 /**
  * 全局配置存储：~/.hometrans/config.json
  *
- * 当前包含 editors 配置（Claude Code / Cursor / OpenCode / Codex），后续可扩展
+ * 当前包含 editors 配置（Claude Code / Cursor / OpenCode / Codex / CodeBuddy），后续可扩展
  * 其它顶层字段。首次 setup 时若文件不存在则写入默认值；之后用户可手动编辑。
  * `ht config` 只读不改。
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
 import os from 'node:os';
+/** 由 DEVECO_SDK_HOME 派生其余三个 SDK 相关路径。输入为空时全部返回空串。 */
+export function deriveSdkPaths(devecoSdkHome) {
+    const home = devecoSdkHome.trim().replace(/[\\/]+$/, '');
+    if (!home) {
+        return { DEVECO_SDK_HOME: '', DEVECO_PATH: '', OHOS_SDK_PATH: '', HMS_SDK_PATH: '' };
+    }
+    return {
+        DEVECO_SDK_HOME: home,
+        DEVECO_PATH: path.dirname(home),
+        OHOS_SDK_PATH: path.join(home, 'default', 'openharmony', 'ets'),
+        HMS_SDK_PATH: path.join(home, 'default', 'hms', 'ets'),
+    };
+}
+/**
+ * 旧配置迁移：从 OHOS_SDK_PATH（…/sdk/default/openharmony/ets）反推
+ * DEVECO_SDK_HOME（…/sdk）。HMS 同理。匹配不上返回 ''。
+ */
+export function sdkHomeFromLegacyPaths(env) {
+    const tryStrip = (p, suffix) => {
+        if (!p)
+            return '';
+        const norm = p.replace(/[\\/]+$/, '').split(/[\\/]/);
+        if (norm.length <= suffix.length)
+            return '';
+        const tail = norm.slice(-suffix.length).map((s) => s.toLowerCase());
+        if (tail.join('/') !== suffix.join('/'))
+            return '';
+        return norm.slice(0, -suffix.length).join(path.sep);
+    };
+    return (tryStrip(env.OHOS_SDK_PATH, ['default', 'openharmony', 'ets']) ||
+        tryStrip(env.HMS_SDK_PATH, ['default', 'hms', 'ets']));
+}
 export function getConfigDir() {
     return path.join(os.homedir(), '.hometrans');
 }
@@ -76,6 +108,19 @@ export function defaultEditors() {
                 section: 'mcp_servers.hometrans',
             },
         },
+        {
+            // CodeBuddy（腾讯）：与 Claude Code 同构的 .codebuddy/ 目录，
+            // 全局安装映射到 ~/.codebuddy/{skills,agents}，MCP 走 mcpServers JSON。
+            name: 'CodeBuddy',
+            markerDir: '~/.codebuddy',
+            skillsDir: '~/.codebuddy/skills',
+            agentsDir: '~/.codebuddy/agents',
+            mcp: {
+                format: 'jsonc-object',
+                path: '~/.codebuddy/mcp.json',
+                keyPath: ['mcpServers', 'hometrans'],
+            },
+        },
     ];
 }
 async function fileExists(p) {
@@ -93,9 +138,12 @@ async function fileExists(p) {
  */
 export function defaultEnv() {
     return {
+        DEVECO_SDK_HOME: '',
+        DEVECO_PATH: '',
         OHOS_SDK_PATH: '',
         HMS_SDK_PATH: '',
         TEST_API_KEY: '',
+        GLM_API_KEY: '',
         TOOL_PATH: '',
     };
 }
@@ -139,6 +187,38 @@ export async function loadHomeTransConfig() {
     delete anyParsed.sdkPaths;
     delete anyParsed.params;
     delete anyParsed.tool_path;
+    // SDK 路径统一迁移：老配置只有 OHOS_SDK_PATH/HMS_SDK_PATH 时反推
+    // DEVECO_SDK_HOME，再用它补齐缺失的派生路径（不覆盖已有非空值）。
+    let envDirty = false;
+    if (!config.env.DEVECO_SDK_HOME) {
+        const migrated = sdkHomeFromLegacyPaths(config.env);
+        if (migrated) {
+            config.env.DEVECO_SDK_HOME = migrated;
+            envDirty = true;
+        }
+    }
+    if (config.env.DEVECO_SDK_HOME) {
+        const derived = deriveSdkPaths(config.env.DEVECO_SDK_HOME);
+        for (const key of ['DEVECO_PATH', 'OHOS_SDK_PATH', 'HMS_SDK_PATH']) {
+            if (!config.env[key]) {
+                config.env[key] = derived[key];
+                envDirty = true;
+            }
+        }
+    }
+    if (envDirty) {
+        await saveHomeTransConfig(config);
+    }
+    // Append any default editors that this (older) config predates, matched by
+    // name. Existing entries are never modified, so manual edits are preserved;
+    // we only add editors the user's file is missing (e.g. CodeBuddy shipped
+    // after they first ran `ht init`). Persist so the new editor shows up.
+    const existingNames = new Set(config.editors.map((e) => e.name));
+    const missingEditors = defaultEditors().filter((e) => !existingNames.has(e.name));
+    if (missingEditors.length > 0) {
+        config.editors.push(...missingEditors);
+        await saveHomeTransConfig(config);
+    }
     return config;
 }
 export async function saveHomeTransConfig(config) {

package/dist/cli/config.js

@@ -2,7 +2,7 @@
  * `ht config` — 打印 editors.json 路径与内容。
  *
  * 该命令只读：用户若要修改 editor 配置，直接编辑这个 JSON 文件即可。
- * 文件不存在时自动写入默认 4 个 editor。
+ * 文件不存在时自动写入默认 5 个 editor。
  */
 import fs from 'node:fs/promises';
 import { getConfigPath, loadHomeTransConfig } from './config-store.js';
@@ -17,16 +17,15 @@ export async function configCommand() {
     console.log(`  Path: ${configPath}`);
     console.log('');
     // User parameters
-    const maskedKey = config.env.TEST_API_KEY
-        ? config.env.TEST_API_KEY.slice(0, 4) +
-            '***' +
-            config.env.TEST_API_KEY.slice(-4)
-        : '(not set)';
+    const mask = (key) => key ? key.slice(0, 4) + '***' + key.slice(-4) : '(not set)';
     console.log('  Parameters:');
-    console.log(`    OHOS_SDK_PATH : ${config.env.OHOS_SDK_PATH || '(not set)'}`);
-    console.log(`    HMS_SDK_PATH  : ${config.env.HMS_SDK_PATH || '(not set)'}`);
-    console.log(`    TEST_API_KEY  : ${maskedKey}`);
-    console.log(`    TOOL_PATH     : ${config.env.TOOL_PATH || '(not set)'}`);
+    console.log(`    DEVECO_SDK_HOME : ${config.env.DEVECO_SDK_HOME || '(not set)'}`);
+    console.log(`    DEVECO_PATH     : ${config.env.DEVECO_PATH || '(not set)'} (derived)`);
+    console.log(`    OHOS_SDK_PATH   : ${config.env.OHOS_SDK_PATH || '(not set)'} (derived)`);
+    console.log(`    HMS_SDK_PATH    : ${config.env.HMS_SDK_PATH || '(not set)'} (derived)`);
+    console.log(`    TEST_API_KEY    : ${mask(config.env.TEST_API_KEY)}`);
+    console.log(`    GLM_API_KEY     : ${mask(config.env.GLM_API_KEY)}`);
+    console.log(`    TOOL_PATH       : ${config.env.TOOL_PATH || '(not set)'}`);
     console.log('');
     // Full config content
     console.log('  Full Content:');

package/dist/cli/index.js

@@ -1,12 +1,34 @@
 #!/usr/bin/env node
 import { Command } from 'commander';
 import { createRequire } from 'node:module';
+import chalk from 'chalk';
 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');
+/**
+ * Global Ctrl-C safety net.
+ *
+ * inquirer intercepts Ctrl-C as a keypress *inside* a prompt (raw mode) and the
+ * per-command catches print a tailored "Cancelled" notice there. But Ctrl-C
+ * pressed *outside* a prompt — e.g. while `init` is copying files or `uninstall`
+ * is deleting — arrives as an OS SIGINT, which Node would otherwise terminate on
+ * silently. This handler guarantees a cancel notice in that case too.
+ *
+ * The MCP server (`ht mcp`) runs over stdio and must keep its own shutdown
+ * semantics, so it removes this handler on startup.
+ */
+let interrupted = false;
+function onSigint() {
+    if (interrupted)
+        process.exit(130);
+    interrupted = true;
+    console.log(chalk.yellow('\n  Cancelled by Ctrl-C. No further changes will be made.\n'));
+    process.exit(130);
+}
+process.on('SIGINT', onSigint);
 const program = new Command();
 program
     .name('hometrans')
@@ -23,6 +45,8 @@ program
     .command('mcp')
     .description('Run the HomeTrans MCP server (stdio)')
     .action(async () => {
+    // The MCP server owns its own SIGINT/shutdown handling; drop the CLI net.
+    process.off('SIGINT', onSigint);
     await runMcpServer();
 });
 program

package/dist/cli/init.js

@@ -7,18 +7,33 @@
  */
 import fs from 'node:fs/promises';
 import path from 'node:path';
-import os from 'node:os';
+import { execFileSync } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
 import chalk from 'chalk';
 import figlet from 'figlet';
 import inquirer from 'inquirer';
+import { parseTree, modify, applyEdits } from 'jsonc-parser';
 import { setupMcpForAllEditors } from './mcp-setup.js';
-import { expandHome, getConfigPath, getToolsDir, loadHomeTransConfig, saveHomeTransConfig, } from './config-store.js';
+import { deriveSdkPaths, expandHome, getConfigPath, getToolsDir, loadHomeTransConfig, saveHomeTransConfig, } from './config-store.js';
 function ensureChalkColor() {
     if (process.stdout.isTTY && chalk.level === 0) {
         chalk.level = 1;
     }
 }
+/**
+ * Did the user abort an inquirer prompt with Ctrl-C / Esc?
+ * inquirer v14 (@inquirer/core) rejects with an `ExitPromptError` in that case.
+ * We must distinguish this from a genuine non-interactive failure (no TTY),
+ * otherwise Ctrl-C silently gets swallowed and the install proceeds anyway.
+ */
+export function isPromptAbort(err) {
+    return err instanceof Error && err.name === 'ExitPromptError';
+}
+/** Print a cancellation notice and exit with the conventional SIGINT code. */
+function abortInit() {
+    console.log(chalk.yellow('\n  Cancelled. No changes were made beyond this point.\n'));
+    process.exit(130);
+}
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 export async function dirExists(dirPath) {
@@ -116,6 +131,70 @@ async function refreshAutotestConfig(autotestDir, apiKey) {
         ? `autotest config.yaml seeded + api_key filled`
         : `autotest config.yaml api_key refreshed`;
 }
+const UI_ALIGN_SKILL = 'hmos-incremental-ui-align';
+/**
+ * Initialize / refresh `<skillsDir>/hmos-incremental-ui-align/config.json`
+ * in an editor's installed skills dir — same semantics as the autotest
+ * config.yaml handling:
+ *   - If config.json does not exist, seed it from config-example.json.
+ *   - If it exists, surgically overwrite ONLY the `glm_api_key` and
+ *     `hmos_sdk_dir` values (via jsonc edits), preserving every other
+ *     field the user has set. `hmos_sdk_dir` = `<DEVECO_SDK_HOME>/default`.
+ *
+ * Returns a status string for the result summary, or null if nothing was
+ * done (skill not installed there, or no values to write into an existing file).
+ */
+export async function refreshUiAlignConfig(skillsDir, glmApiKey, hmosSdkDir) {
+    const skillDir = path.join(skillsDir, UI_ALIGN_SKILL);
+    const examplePath = path.join(skillDir, 'config-example.json');
+    const configPath = path.join(skillDir, 'config.json');
+    const hasExample = await fs
+        .access(examplePath)
+        .then(() => true)
+        .catch(() => false);
+    if (!hasExample)
+        return null;
+    let seeded = false;
+    const hasConfig = await fs
+        .access(configPath)
+        .then(() => true)
+        .catch(() => false);
+    if (!hasConfig) {
+        await fs.copyFile(examplePath, configPath);
+        seeded = true;
+    }
+    const updates = [];
+    if (glmApiKey)
+        updates.push(['glm_api_key', glmApiKey]);
+    if (hmosSdkDir)
+        updates.push(['hmos_sdk_dir', hmosSdkDir]);
+    if (updates.length === 0) {
+        return seeded
+            ? `${UI_ALIGN_SKILL}/config.json seeded (glm_api_key / hmos_sdk_dir left empty)`
+            : null;
+    }
+    let raw = await fs.readFile(configPath, 'utf-8');
+    const parseErrors = [];
+    const tree = parseTree(raw, parseErrors);
+    if (!tree || tree.type !== 'object' || parseErrors.length > 0) {
+        // Corrupt config — never regenerate over user content; just report.
+        return `${UI_ALIGN_SKILL}/config.json NOT updated (file is not valid JSON — fix it manually)`;
+    }
+    const original = raw;
+    for (const [key, value] of updates) {
+        const edits = modify(raw, [key], value, {
+            formattingOptions: { tabSize: 2, insertSpaces: true },
+        });
+        raw = applyEdits(raw, edits);
+    }
+    if (raw !== original) {
+        await fs.writeFile(configPath, raw, 'utf-8');
+    }
+    const what = updates.map(([k]) => k).join(' + ');
+    return seeded
+        ? `${UI_ALIGN_SKILL}/config.json seeded + ${what} filled`
+        : `${UI_ALIGN_SKILL}/config.json ${what} refreshed`;
+}
 async function installSkillsTo(skillsRoot, targetDir) {
     let entries;
     try {
@@ -166,7 +245,7 @@ async function installAgentsTo(agentsRoot, targetDir) {
     }
     return installed;
 }
-async function installForEditor(editor, skillsRoot, agentsRoot, result) {
+async function installForEditor(editor, skillsRoot, agentsRoot, glmApiKey, hmosSdkDir, result) {
     const marker = expandHome(editor.markerDir);
     if (marker && !(await dirExists(marker))) {
         result.skipped.push(`${editor.name} (not installed)`);
@@ -183,6 +262,17 @@ async function installForEditor(editor, skillsRoot, agentsRoot, result) {
     catch (err) {
         result.errors.push(`${editor.name} skills: ${err.message}`);
     }
+    // Seed / refresh the incremental-ui-align per-skill config.json with the
+    // GLM key + SDK dir from ~/.hometrans/config.json (existing files: key-only update).
+    try {
+        const status = await refreshUiAlignConfig(skillsDir, glmApiKey, hmosSdkDir);
+        if (status) {
+            result.configured.push(`${editor.name} ${status}`);
+        }
+    }
+    catch (err) {
+        result.errors.push(`${editor.name} ${UI_ALIGN_SKILL}/config.json: ${err.message}`);
+    }
     try {
         const agents = await installAgentsTo(agentsRoot, agentsDir);
         if (agents.length > 0) {
@@ -193,12 +283,185 @@ async function installForEditor(editor, skillsRoot, agentsRoot, result) {
         result.errors.push(`${editor.name} agents: ${err.message}`);
     }
 }
+/**
+ * Display paths as full absolute OS-native paths (e.g. on Windows:
+ * `C:\Users\<you>\.claude\skills`) — no `~` abbreviation, no separator
+ * rewriting, so output matches what the user can copy into their shell.
+ */
 export function prettyHome(p) {
-    const home = os.homedir();
-    if (p.startsWith(home)) {
-        return '~' + p.slice(home.length).replace(/\\/g, '/');
+    return p;
+}
+/** Locate a command on PATH (`where` on Windows, `which` elsewhere). */
+function whichSync(cmd) {
+    const isWin = process.platform === 'win32';
+    try {
+        const out = execFileSync(isWin ? 'where' : 'which', [cmd], {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        const lines = out.split('\n').map((l) => l.trim()).filter(Boolean);
+        return lines[0] || null;
+    }
+    catch {
+        return null;
+    }
+}
+function captureVersion(cmd, args) {
+    try {
+        const out = execFileSync(cmd, args, {
+            encoding: 'utf-8',
+            timeout: 5000,
+            stdio: ['ignore', 'pipe', 'pipe'],
+        });
+        return out.split('\n')[0].trim() || null;
+    }
+    catch {
+        return null;
+    }
+}
+async function fileExists(p) {
+    try {
+        await fs.access(p);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** Install hints shown when a tool is missing. */
+const TOOL_HINTS = {
+    deveco: 'set DEVECO_SDK_HOME via `ht init` (DevEco Studio install)',
+    adb: 'Android SDK platform-tools (needed for Android-device capture)',
+    hdc: 'ships with DevEco: <sdk>/default/openharmony/toolchains',
+    python: 'install Python >= 3.10 and add to PATH (UI-align capture/parse scripts)',
+    uv: 'https://docs.astral.sh/uv (AutoTest runs under uv)',
+    java: 'any JDK 17+, or reuse DevEco jbr: <deveco>/jbr/bin',
+    gitnexus: 'npm i -g gitnexus && gitnexus setup',
+};
+/**
+ * Detect external tools. `hdc` falls back to the DevEco toolchains dir and
+ * `java` to DevEco's bundled jbr when not on PATH, mirroring how the
+ * skills/agents themselves resolve them.
+ */
+async function detectEnvironment(env) {
+    const status = new Map();
+    const isWin = process.platform === 'win32';
+    const sdkOk = env.DEVECO_SDK_HOME ? await dirExists(env.DEVECO_SDK_HOME) : false;
+    status.set('deveco', {
+        found: sdkOk,
+        path: sdkOk ? env.DEVECO_SDK_HOME : undefined,
+    });
+    for (const cmd of ['adb', 'python', 'uv', 'gitnexus']) {
+        const p = whichSync(cmd);
+        const st = { found: !!p, path: p ?? undefined };
+        if (cmd === 'python' && p) {
+            const v = captureVersion('python', ['--version']);
+            if (v) {
+                st.note = v;
+                const m = v.match(/(\d+)\.(\d+)/);
+                if (m && (Number(m[1]) < 3 || (Number(m[1]) === 3 && Number(m[2]) < 10))) {
+                    st.note += '  (UI-align scripts require >= 3.10)';
+                }
+            }
+        }
+        status.set(cmd, st);
+    }
+    // hdc: PATH first, then DevEco toolchains.
+    let hdcPath = whichSync('hdc');
+    if (!hdcPath && sdkOk) {
+        const cand = path.join(env.DEVECO_SDK_HOME, 'default', 'openharmony', 'toolchains', isWin ? 'hdc.exe' : 'hdc');
+        if (await fileExists(cand))
+            hdcPath = cand;
+    }
+    status.set('hdc', { found: !!hdcPath, path: hdcPath ?? undefined });
+    // java: PATH first, then DevEco jbr.
+    let javaPath = whichSync('java');
+    let javaNote;
+    if (!javaPath && env.DEVECO_PATH) {
+        const cand = path.join(env.DEVECO_PATH, 'jbr', 'bin', isWin ? 'java.exe' : 'java');
+        if (await fileExists(cand)) {
+            javaPath = cand;
+            javaNote = 'via DevEco jbr';
+        }
+    }
+    status.set('java', { found: !!javaPath, path: javaPath ?? undefined, note: javaNote });
+    return status;
+}
+/**
+ * Which tools each skill/agent needs. `required` missing → BLOCKED;
+ * only `optional` missing → LIMITED. Kept in sync with the README
+ * "Per-skill environment requirements" matrix.
+ */
+const IMPACT_MATRIX = [
+    { name: 'hmos-spec-generate', kind: 'skill', required: ['gitnexus'], optional: [] },
+    { name: 'hmos-resources-convert', kind: 'skill', required: [], optional: ['java'], note: 'no java -> falls back to source res/' },
+    { name: 'hmos-batch-ui-align', kind: 'skill', required: ['python'], optional: ['adb'], note: 'adb only for page exploration' },
+    { name: 'hmos-incremental-ui-align', kind: 'skill', required: ['deveco', 'python', 'hdc', 'adb'], optional: [] },
+    { name: 'hmos-integration-test', kind: 'skill', required: ['deveco', 'uv', 'hdc'], optional: [] },
+    { name: 'hmos-fix-build-errors', kind: 'skill', required: ['deveco'], optional: [] },
+    { name: 'hmos-convert-pipeline', kind: 'skill', required: ['deveco'], optional: ['uv', 'hdc'], note: 'test stage skippable via skip-test' },
+    { name: 'logic-context-builder', kind: 'agent', required: [], optional: ['python'] },
+    { name: 'logic-coder', kind: 'agent', required: [], optional: ['python'] },
+    { name: 'spec-generator', kind: 'agent', required: ['gitnexus'], optional: [] },
+    { name: 'build-fixer', kind: 'agent', required: ['deveco'], optional: [] },
+    { name: 'code-reviewer', kind: 'agent', required: [], optional: ['deveco'] },
+    { name: 'review-fixer', kind: 'agent', required: [], optional: [] },
+    { name: 'self-tester', kind: 'agent', required: ['uv', 'hdc'], optional: [] },
+    { name: 'self-test-fixer', kind: 'agent', required: [], optional: [] },
+];
+/** Print detected tools + the per-skill/agent impact table. */
+export async function runEnvironmentCheck(env) {
+    console.log('');
+    console.log(chalk.blue('  Environment Check'));
+    const tools = await detectEnvironment(env);
+    const order = ['deveco', 'adb', 'hdc', 'python', 'uv', 'java', 'gitnexus'];
+    for (const name of order) {
+        const st = tools.get(name);
+        if (st.found) {
+            const note = st.note ? chalk.gray(`  (${st.note})`) : '';
+            console.log(`    ${chalk.green('+')} ${name.padEnd(9)} ${st.path ?? ''}${note}`);
+        }
+        else {
+            console.log(`    ${chalk.yellow('!')} ${name.padEnd(9)} ${chalk.yellow('not found')}  ${chalk.gray(TOOL_HINTS[name] ?? '')}`);
+        }
+    }
+    const missing = order.filter((n) => !tools.get(n).found);
+    console.log('');
+    console.log(chalk.blue('  Impact on skills/agents:'));
+    const nameW = 28;
+    console.log(chalk.gray(`    ${'Name'.padEnd(nameW)} ${'Kind'.padEnd(6)} ${'Status'.padEnd(8)} Missing`));
+    for (const row of IMPACT_MATRIX) {
+        const missReq = row.required.filter((t) => missing.includes(t));
+        const missOpt = row.optional.filter((t) => missing.includes(t));
+        let plain;
+        let color;
+        let parts;
+        if (missReq.length > 0) {
+            plain = 'BLOCKED';
+            color = chalk.red;
+            parts = [...missReq, ...missOpt.map((t) => `${t}(optional)`)];
+        }
+        else if (missOpt.length > 0) {
+            plain = 'LIMITED';
+            color = chalk.yellow;
+            parts = missOpt.map((t) => `${t}(optional)`);
+        }
+        else {
+            plain = 'OK';
+            color = chalk.green;
+            parts = [];
+        }
+        const noteStr = parts.length > 0 && row.note ? chalk.gray(`  — ${row.note}`) : '';
+        console.log(`    ${row.name.padEnd(nameW)} ${row.kind.padEnd(6)} ${color(plain.padEnd(8))} ${parts.join(', ')}${noteStr}`);
+    }
+    console.log('');
+    if (missing.length === 0) {
+        console.log(chalk.green('  All environment dependencies found — every skill/agent is fully usable.'));
+    }
+    else {
+        console.log(chalk.gray('  Install the missing tools above and re-run `ht init` to clear the impact list.'));
     }
-    return p.replace(/\\/g, '/');
 }
 async function detectInstalledEditors(editors) {
     const status = new Map();
@@ -256,13 +519,26 @@ export async function initCommand(options = {}) {
                 {
                     type: 'checkbox',
                     name: 'selectedEditors',
-                    message: 'Select editors to configure (arrow keys + space to toggle, enter to confirm):',
+                    message: 'Select editors to configure:',
                     choices,
+                    // Append a "ctrl-c cancel" entry to the built-in key help line, reusing
+                    // @inquirer/checkbox's default formatting (bold key · dim action · dim
+                    // " • " separator):
+                    //   ↑↓ navigate • space select • a all • i invert • ⏎ submit • ctrl-c cancel
+                    theme: {
+                        style: {
+                            keysHelpTip: (keys) => [...keys, ['ctrl-c', 'cancel']]
+                                .map(([key, action]) => `${chalk.bold(key)} ${chalk.dim(action)}`)
+                                .join(chalk.dim(' • ')),
+                        },
+                    },
                 },
             ]);
             selectedEditors = answers.selectedEditors;
         }
-        catch {
+        catch (err) {
+            if (isPromptAbort(err))
+                abortInit();
             console.log(chalk.yellow('\n  Interactive selection failed. Auto-selecting all detected editors.'));
             console.log(chalk.gray('  Tip: use --all to skip interactive selection.\n'));
             selectedEditors = editors
@@ -282,31 +558,72 @@ export async function initCommand(options = {}) {
         const answers = await inquirer.prompt([
             {
                 type: 'input',
-                name: 'OHOS_SDK_PATH',
-                message: 'OHOS_SDK_PATH:',
-                default: config.env.OHOS_SDK_PATH || undefined,
+                name: 'DEVECO_SDK_HOME',
+                message: 'DEVECO_SDK_HOME (DevEco Studio SDK dir):',
+                default: config.env.DEVECO_SDK_HOME || undefined,
             },
             {
                 type: 'input',
-                name: 'HMS_SDK_PATH',
-                message: 'HMS_SDK_PATH:',
-                default: config.env.HMS_SDK_PATH || undefined,
+                name: 'TEST_API_KEY',
+                message: 'TEST_API_KEY (LLM API key used by the integration-test agent to run test cases):',
+                default: config.env.TEST_API_KEY || undefined,
             },
             {
                 type: 'input',
-                name: 'TEST_API_KEY',
-                message: 'TEST_API_KEY (for autotest config.yaml):',
-                default: config.env.TEST_API_KEY || undefined,
+                name: 'GLM_API_KEY',
+                message: 'GLM_API_KEY (LLM API key for the GLM phone-agent used in UI alignment):',
+                default: config.env.GLM_API_KEY || undefined,
             },
         ]);
-        config.env.OHOS_SDK_PATH = answers.OHOS_SDK_PATH.trim();
-        config.env.HMS_SDK_PATH = answers.HMS_SDK_PATH.trim();
+        const sdk = deriveSdkPaths(answers.DEVECO_SDK_HOME);
+        config.env.DEVECO_SDK_HOME = sdk.DEVECO_SDK_HOME;
+        config.env.DEVECO_PATH = sdk.DEVECO_PATH;
+        config.env.OHOS_SDK_PATH = sdk.OHOS_SDK_PATH;
+        config.env.HMS_SDK_PATH = sdk.HMS_SDK_PATH;
         config.env.TEST_API_KEY = answers.TEST_API_KEY.trim();
+        config.env.GLM_API_KEY = answers.GLM_API_KEY.trim();
         await saveHomeTransConfig(config);
+        // Echo the derived paths and validate each exists on disk; missing ones are
+        // a strong signal of a typo'd DEVECO_SDK_HOME or a broken DevEco install.
+        if (sdk.DEVECO_SDK_HOME) {
+            const checks = [
+                ['DEVECO_SDK_HOME', sdk.DEVECO_SDK_HOME],
+                ['DEVECO_PATH', sdk.DEVECO_PATH],
+                ['OHOS_SDK_PATH', sdk.OHOS_SDK_PATH],
+                ['HMS_SDK_PATH', sdk.HMS_SDK_PATH],
+            ];
+            console.log('');
+            console.log(chalk.blue('  Derived from DEVECO_SDK_HOME:'));
+            let missingCount = 0;
+            for (const [name, p] of checks) {
+                const exists = await dirExists(p);
+                if (!exists)
+                    missingCount++;
+                const mark = exists ? chalk.green('+') : chalk.yellow('!');
+                const note = exists ? '' : chalk.yellow('  (not found on disk)');
+                console.log(`    ${mark} ${name.padEnd(15)} : ${p}${note}`);
+            }
+            if (missingCount > 0) {
+                console.log('');
+                console.log(chalk.yellow('  ! Check DEVECO_SDK_HOME (it should be the "sdk" folder inside your DevEco Studio install)'));
+                console.log(chalk.yellow('    and re-run `ht init` after fixing it. Skills that build or'));
+                console.log(chalk.yellow('    review code will not work until these paths resolve.'));
+            }
+        }
     }
-    catch {
+    catch (err) {
+        if (isPromptAbort(err))
+            abortInit();
         console.log(chalk.yellow('  Parameter prompts skipped (non-interactive mode).'));
     }
+    // Detect external tools (adb / hdc / python / uv / java / gitnexus + DevEco)
+    // and report which skills/agents are impacted by anything missing.
+    try {
+        await runEnvironmentCheck(config.env);
+    }
+    catch (err) {
+        console.log(chalk.yellow(`  ! environment check skipped: ${err.message}`));
+    }
     // Copy bundled tools/ into ~/.hometrans/tools and record env.TOOL_PATH.
     // Must run before the autotest config step below, which seeds config.yaml
     // into the installed tools dir (the location agents read via env.TOOL_PATH).
@@ -340,9 +657,13 @@ export async function initCommand(options = {}) {
     console.log('');
     const editorsToSetup = editors.filter((e) => selectedEditors.includes(e.name));
     const result = { configured: [], skipped: [], errors: [] };
+    // hmos_sdk_dir consumed by incremental-ui-align = <DEVECO_SDK_HOME>/default.
+    const hmosSdkDir = config.env.DEVECO_SDK_HOME
+        ? path.join(config.env.DEVECO_SDK_HOME, 'default')
+        : '';
     for (const editor of editorsToSetup) {
         console.log(chalk.blue(`  Configuring ${editor.name}...`));
-        await installForEditor(editor, skillsRoot, agentsRoot, result);
+        await installForEditor(editor, skillsRoot, agentsRoot, config.env.GLM_API_KEY, hmosSdkDir, result);
     }
     await setupMcpForAllEditors(editorsToSetup, result);
     console.log('');

package/dist/cli/mcp-setup.js

@@ -227,12 +227,8 @@ async function writeTomlSection(editor, result) {
     }
 }
 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, '/');
+    // 与 init.ts 中 prettyHome 行为一致：完整绝对路径、OS 原生分隔符，不做 ~ 缩写。
+    return p;
 }
 async function setupOneEditor(editor, result) {
     const marker = expandHome(editor.markerDir);