@yg-toolkit/datapull 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 YG Toolkit contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,74 @@
+# DataPull
+
+DataPull 是一款面向人类交互、同时提供稳定 Agent 自动化接口的数据库结构文件拉取 CLI。它将 MySQL、PostgreSQL 或 SQL Server 的 DDL 按对象保存到当前项目根目录的 `.database-schema/`，不拉取业务数据、用户、角色或授权。
+
+## 安装
+
+```bash
+npm install --global @yg-toolkit/datapull
+datapull
+```
+
+需要 Node.js `>=22.12`。只执行 `datapull` 会进入中文引导流程；NPM 安装生命周期不会启动交互、访问数据库或安装 Agent Skill。
+
+## 常用命令
+
+```bash
+# 进入完整中文向导
+datapull
+
+# 查看脱敏连接
+datapull connection list
+
+# 拉取表和视图；连接必须已经登记
+datapull pull --connection main --database app --include table,view --yes
+
+# Agent 友好的机器可读输出
+datapull pull --connection main --database app --include table,view --yes --json
+
+# 为使用自签名证书的 SQL Server 保存显式信任设置
+datapull connection update --alias sqlserver-dev --trust-server-certificate --yes
+
+# 恢复严格证书验证
+datapull connection update --alias sqlserver-dev --verify-server-certificate --yes
+
+# 诊断环境，不自动安装
+datapull doctor --json
+
+# 为 Codex 用户级目录安装内置 Skill
+datapull skill install --target codex:user --yes
+```
+
+完整命令族包括 `connection add|list|show|update|remove|test`、`database list|favorite add|favorite remove`、`pull`、`skill install|list|status|sync`、`config path|validate` 和 `doctor`。
+
+## 配置和秘密
+
+登记连接是当前操作系统用户的全局配置：
+
+- Windows：`%APPDATA%/datapull/`
+- macOS：`$HOME/Library/Application Support/datapull/`
+- Linux：`${XDG_CONFIG_HOME:-$HOME/.config}/datapull/`
+
+非秘密连接信息保存在 `config.json`，密码或完整含秘密 URL 保存在权限受限的 `credentials.env`。秘密只能通过交互式隐藏输入或用户手工编辑该文件写入；不要把密码放入命令参数。
+
+SQL Server 始终启用传输加密并默认严格验证服务器证书。自签名或内部 CA 环境可在用户明确确认后，仅本次使用 `--trust-server-certificate --yes`，或把该设置保存到登记连接。该模式不会关闭加密，但无法验证服务器身份，适合已确认风险的开发、测试或受控内网；生产连接优先安装可信 CA，并保持严格验证。
+
+## 覆盖规则
+
+本次选择的对象类型作为一个文件事务整体更新；未选择类型原样保留。任一所选类型读取、生成、校验或提交失败时，所有所选类型保留上一次结果。进程异常终止后，下一次访问同一目标时会先执行持久化事务恢复。
+
+SQL 文件默认可纳入 Git。DataPull 只在 `.database-schema/.gitignore` 中忽略临时目录、锁、事务日志和提交期备份，不修改项目根 `.gitignore`。
+
+## 开发验证
+
+```bash
+npm install --ignore-scripts
+npm run check
+npm test
+npm run build
+npm run skill:check
+```
+
+`npm run release:check` 验证 `resources/compatibility-matrix.json` 是否已经包含三种数据库、五类操作系统、NPM 安装及八个 Skill 目标路径的真实通过记录。开发包的空矩阵会阻止公开发布，不能用本地单元测试替代真实数据库或跨平台验收。Agent 实际发现采用独立兼容性认证；未认证组合必须保留原因并标为计划兼容，不得宣称已支持。
+
+跨平台验收使用仓库的“DataPull 兼容性验收”GitHub Actions 工作流。远程数据库、Actions Secrets、自托管运行器和取证步骤见 [兼容性 CI 说明](https://github.com/phoben/agent-skills/blob/main/cli/datapull/docs/release-ci.md)。

package/dist/cli/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+import { ConfigStore } from "../config/store.js";
+export declare function buildProgram(store?: ConfigStore): Command;
+//# sourceMappingURL=program.d.ts.map

package/dist/cli/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../../src/cli/program.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAU,MAAM,WAAW,CAAC;AAQ5C,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AA+BjD,wBAAgB,YAAY,CAAC,KAAK,cAAoB,GAAG,OAAO,CA+B/D"}

package/dist/cli/program.js

@@ -0,0 +1,540 @@
+import { confirm, password } from "@inquirer/prompts";
+import { Command, Option } from "commander";
+import { createRequire } from "node:module";
+import { ConnectionService, connectionSecurityWarnings, createConnection, redactedConnection, } from "../connections/service.js";
+import { ConfigStore } from "../config/store.js";
+import { DataPullError } from "../core/errors.js";
+import { Output } from "../core/output.js";
+import { runDoctor } from "../doctor/service.js";
+import { exporterFor } from "../exporters/factory.js";
+import { promptAndAddConnection } from "../interactive/connections.js";
+import { runWizard } from "../interactive/wizard.js";
+import { PullService } from "../pull/service.js";
+import { SkillInstaller } from "../skills/installer.js";
+import { allSkillTargets, parseSkillTarget } from "../skills/targets.js";
+import { discoverProjectRoot, validatePathSegment } from "../utils/path.js";
+import { ToolManager } from "../tools/manager.js";
+const packageJson = createRequire(import.meta.url)("../../package.json");
+export function buildProgram(store = new ConfigStore()) {
+    const program = new Command();
+    program
+        .name("datapull")
+        .description("交互式拉取 MySQL、PostgreSQL 与 SQL Server 数据库结构文件")
+        .version(packageJson.version)
+        .option("--json", "仅在结束时向 stdout 输出一个 JSON 文档")
+        .option("--yes", "确认当前命令声明的写入或安装操作")
+        .option("--no-color", "禁用 ANSI 色彩")
+        .showHelpAfterError()
+        .exitOverride();
+    program.action(async (_options, command) => {
+        const global = globals(command);
+        if (!process.stdin.isTTY || !process.stdout.isTTY || global.json === true) {
+            throw new DataPullError("INTERACTIVE_TTY_REQUIRED", "无参数 datapull 需要交互式终端；自动化场景请使用子命令和 --json。", 2);
+        }
+        await runWizard(store);
+    });
+    registerConnectionCommands(program, store);
+    registerDatabaseCommands(program, store);
+    registerPullCommand(program, store);
+    registerSkillCommands(program);
+    registerConfigCommands(program, store);
+    registerDoctorCommand(program, store);
+    return program;
+}
+function registerConnectionCommands(program, store) {
+    const connection = program.command("connection").description("管理用户级数据库连接");
+    connection
+        .command("add")
+        .description("登记数据库连接")
+        .option("--alias <alias>", "连接别名")
+        .addOption(new Option("--engine <engine>", "数据库类型").choices(["mysql", "postgresql", "sqlserver"]))
+        .addOption(new Option("--auth-mode <mode>", "认证方式").choices(["password", "url", "integrated"]))
+        .option("--host <host>", "数据库主机")
+        .option("--port <port>", "端口", numberParser)
+        .option("--username <username>", "用户名")
+        .option("--credential-ref <name>", "密码变量名")
+        .option("--url-ref <name>", "连接 URL 变量名")
+        .option("--ssl-mode <mode>", "MySQL/PostgreSQL TLS 模式")
+        .option("--trust-server-certificate", "保持加密但不验证 SQL Server 身份；仅用于明确接受风险的连接")
+        .action(async (options, command) => {
+        const global = globals(command);
+        await initializeForWrite(store, global.yes === true);
+        const service = new ConnectionService(store);
+        let created;
+        if (process.stdin.isTTY && global.json !== true) {
+            created = await promptAndAddConnection(service, options);
+        }
+        else {
+            requireYes(global);
+            const requiredOptions = requireConnectionCreateOptions(options);
+            if (requiredOptions.authMode === "integrated" && process.platform !== "win32") {
+                throw new DataPullError("INVALID_ARGUMENT", "Windows 集成认证只支持 Windows。", 2);
+            }
+            const secretReference = requiredOptions.authMode === "url"
+                ? requiredOptions.urlRef
+                : requiredOptions.authMode === "password"
+                    ? requiredOptions.credentialRef
+                    : undefined;
+            if (secretReference !== undefined)
+                await store.resolveSecret(secretReference);
+            created = await service.add(createConnection(requiredOptions));
+        }
+        output(command, "connection add").success(redactedConnection(created), successMessage(`已登记连接：${created.alias}`, created));
+    });
+    connection
+        .command("list")
+        .description("列出脱敏连接")
+        .action(async (_options, command) => {
+        const service = new ConnectionService(store);
+        const registered = await service.list();
+        const connections = registered.map(redactedConnection);
+        output(command, "connection list").success({ connections }, connections.length === 0
+            ? "尚未登记数据库连接。"
+            : registered
+                .map((item) => `${item.alias} · ${item.engine}${connectionSecurityWarnings(item).length > 0 ? " · ⚠ 未验证服务器身份" : ""}`)
+                .join("\n"));
+    });
+    connection
+        .command("show")
+        .description("查看单个脱敏连接")
+        .requiredOption("--alias <alias>", "连接别名")
+        .action(async (options, command) => {
+        const item = await new ConnectionService(store).get(requiredString(options.alias, "--alias"));
+        output(command, "connection show").success(redactedConnection(item), JSON.stringify(redactedConnection(item), null, 2));
+    });
+    connection
+        .command("update")
+        .description("更新连接或凭证引用")
+        .requiredOption("--alias <alias>", "连接别名")
+        .addOption(new Option("--engine <engine>").choices(["mysql", "postgresql", "sqlserver"]))
+        .addOption(new Option("--auth-mode <mode>").choices(["password", "url", "integrated"]))
+        .option("--host <host>")
+        .option("--port <port>", "端口", numberParser)
+        .option("--username <username>")
+        .option("--credential-ref <name>")
+        .option("--url-ref <name>")
+        .option("--ssl-mode <mode>")
+        .addOption(new Option("--trust-server-certificate", "保持加密但不验证 SQL Server 身份").conflicts("verifyServerCertificate"))
+        .addOption(new Option("--verify-server-certificate", "恢复严格验证 SQL Server 证书").conflicts("trustServerCertificate"))
+        .option("--refresh-credential", "在交互终端隐藏输入新凭证")
+        .action(async (options, command) => {
+        const global = globals(command);
+        await requireWriteConfirmation(global, options.trustServerCertificate === true
+            ? "确认保存“信任服务器证书”？连接仍加密，但 SQL Server 身份不再验证。"
+            : "确认更新该登记连接？");
+        const service = new ConnectionService(store);
+        const alias = requiredString(options.alias, "--alias");
+        const existing = await service.get(alias);
+        if (options.refreshCredential === true) {
+            if (!process.stdin.isTTY || global.json === true) {
+                throw new DataPullError("INTERACTIVE_TTY_REQUIRED", "更新凭证值需要交互式隐藏输入；非交互模式只能切换凭证引用。", 2);
+            }
+            const reference = existing.authMode === "url" ? existing.urlRef : existing.credentialRef;
+            if (reference === undefined) {
+                throw new DataPullError("INVALID_ARGUMENT", "当前连接没有可刷新的凭证引用。", 2);
+            }
+            await store.setCredential(reference, await password({ message: `更新 ${reference}（输入不会回显）：`, mask: "*" }));
+        }
+        const changes = compactConnectionChanges(options, existing);
+        if (Object.keys(changes).length === 0 && options.refreshCredential !== true) {
+            throw new DataPullError("INVALID_ARGUMENT", "至少提供一个待修改选项。", 2);
+        }
+        for (const reference of [changes.credentialRef, changes.urlRef]) {
+            if (reference !== undefined)
+                await store.resolveSecret(reference);
+        }
+        const updated = Object.keys(changes).length === 0 ? existing : await service.update(alias, changes);
+        output(command, "connection update").success(redactedConnection(updated), successMessage(`已更新连接：${alias}`, updated));
+    });
+    connection
+        .command("remove")
+        .description("删除登记连接，不删除项目结构文件")
+        .requiredOption("--alias <alias>", "连接别名")
+        .option("--delete-credential", "同时删除没有被其他连接引用的凭证变量")
+        .action(async (options, command) => {
+        const global = globals(command);
+        await requireWriteConfirmation(global, "确认删除登记连接？项目结构文件将保留。");
+        const service = new ConnectionService(store);
+        const removed = await service.remove(requiredString(options.alias, "--alias"));
+        let credentialRemoved = false;
+        if (options.deleteCredential === true) {
+            const reference = removed.authMode === "url" ? removed.urlRef : removed.credentialRef;
+            if (reference !== undefined)
+                credentialRemoved = await store.removeCredentialIfUnused(reference);
+        }
+        output(command, "connection remove").success({ connectionAlias: removed.alias, removed: true, credentialRemoved }, `已删除登记连接：${removed.alias}；项目结构文件未删除。`);
+    });
+    connection
+        .command("test")
+        .description("只读校验连接或目标数据库")
+        .requiredOption("--alias <alias>", "连接别名")
+        .option("--database <database>", "目标数据库")
+        .option("--trust-server-certificate", "仅本次保持加密但不验证 SQL Server 身份")
+        .action(async (options, command) => {
+        const service = new ConnectionService(store);
+        const alias = requiredString(options.alias, "--alias");
+        const configured = await service.get(alias);
+        if (options.trustServerCertificate === true && configured.engine !== "sqlserver") {
+            throw new DataPullError("INVALID_ARGUMENT", "--trust-server-certificate 只适用于 SQL Server。", 2);
+        }
+        if (options.trustServerCertificate === true) {
+            await requireRiskConfirmation(globals(command));
+        }
+        if (options.database !== undefined)
+            validatePathSegment(options.database, "数据库名");
+        const connection = await service.resolve(alias, options.database, {
+            ...(options.trustServerCertificate === true
+                ? { trustServerCertificate: true }
+                : {}),
+        });
+        await new ToolManager().ensure(connection.engine, false, false);
+        const testResult = await exporterFor(connection.engine).test(connection, options.database);
+        output(command, "connection test").success({
+            connectionAlias: alias,
+            database: options.database ?? null,
+            reachable: true,
+            serverVersion: testResult.serverVersion,
+            ...(connectionSecurityWarnings(connection).length === 0
+                ? {}
+                : { securityWarnings: connectionSecurityWarnings(connection) }),
+        }, successMessage(`连接校验通过：${alias}${options.database === undefined ? "" : ` / ${options.database}`}`, connection));
+    });
+}
+function registerDatabaseCommands(program, store) {
+    const database = program.command("database").description("查看和收藏目标数据库");
+    database
+        .command("list")
+        .requiredOption("--connection <alias>", "连接别名")
+        .option("--trust-server-certificate", "仅本次保持加密但不验证 SQL Server 身份")
+        .action(async (options, command) => {
+        const service = new ConnectionService(store);
+        const connection = await service.get(options.connection);
+        if (options.trustServerCertificate === true && connection.engine !== "sqlserver") {
+            throw new DataPullError("INVALID_ARGUMENT", "--trust-server-certificate 只适用于 SQL Server。", 2);
+        }
+        if (options.trustServerCertificate === true) {
+            await requireRiskConfirmation(globals(command));
+        }
+        const effectiveConnection = options.trustServerCertificate === true
+            ? {
+                ...connection,
+                tls: { encrypt: true, trustServerCertificate: true },
+            }
+            : connection;
+        let enumerated = [];
+        let enumerationError;
+        try {
+            enumerated = await exporterFor(connection.engine).listDatabases(await service.resolve(connection.alias, undefined, {
+                ...(options.trustServerCertificate === true
+                    ? { trustServerCertificate: true }
+                    : {}),
+            }));
+        }
+        catch (error) {
+            const normalized = error instanceof DataPullError ? error : new DataPullError("DATABASE_CLIENT_FAILED", String(error), 1);
+            enumerationError = { code: normalized.code, message: normalized.message };
+        }
+        const values = [...new Set([...connection.favoriteDatabases, ...connection.recentDatabases, ...enumerated])];
+        output(command, "database list").success({
+            connectionAlias: connection.alias,
+            databases: values.map((name) => ({
+                name,
+                favorite: connection.favoriteDatabases.includes(name),
+                recent: connection.recentDatabases.includes(name),
+                enumerated: enumerated.includes(name),
+            })),
+            manualInputAllowed: true,
+            ...(connectionSecurityWarnings(effectiveConnection).length > 0
+                ? { securityWarnings: connectionSecurityWarnings(effectiveConnection) }
+                : {}),
+            ...(enumerationError === undefined ? {} : { enumerationError }),
+        }, successMessage(values.length > 0
+            ? values.join("\n")
+            : "未枚举到数据库，可在拉取时手工指定名称。", effectiveConnection));
+    });
+    const favorite = database.command("favorite").description("维护数据库收藏");
+    for (const action of ["add", "remove"]) {
+        favorite
+            .command(action)
+            .requiredOption("--connection <alias>", "连接别名")
+            .requiredOption("--database <database>", "目标数据库")
+            .action(async (options, command) => {
+            await requireWriteConfirmation(globals(command), `确认${action === "add" ? "收藏" : "取消收藏"}该数据库？`);
+            await new ConnectionService(store).setFavorite(options.connection, options.database, action === "add");
+            output(command, `database favorite ${action}`).success({ connectionAlias: options.connection, database: options.database, favorite: action === "add" }, action === "add" ? "已收藏数据库。" : "已取消收藏。");
+        });
+    }
+}
+function registerPullCommand(program, store) {
+    program
+        .command("pull")
+        .description("拉取目标数据库结构文件")
+        .requiredOption("--connection <alias>", "连接别名")
+        .requiredOption("--database <database>", "目标数据库")
+        .option("--include <types>", "逗号分隔的对象类型")
+        .option("--install-missing", "安装缺少的官方数据库工具")
+        .option("--trust-server-certificate", "仅本次保持加密但不验证 SQL Server 身份")
+        .action(async (options, command) => {
+        const global = globals(command);
+        if (global.yes !== true && options.installMissing === true) {
+            const connection = await new ConnectionService(store).get(options.connection);
+            const tools = new ToolManager();
+            const missing = await tools.missing(connection.engine);
+            if (missing.length > 0) {
+                throw new DataPullError("CONFIRMATION_REQUIRED", "自动安装数据库工具需要显式确认。", 2, { actionPlan: { installation: tools.plans(missing) }, manualRequired: missing.filter((tool) => !tools.plans(missing).some((plan) => plan.tool === tool)) });
+            }
+        }
+        requireYes(global);
+        const result = await new PullService(new ConnectionService(store)).execute({
+            connectionAlias: options.connection,
+            database: options.database,
+            include: options.include?.split(",").map((value) => value.trim()).filter(Boolean),
+            installMissing: options.installMissing === true,
+            confirmed: global.yes === true,
+            trustServerCertificate: options.trustServerCertificate === true,
+            onStage: (stage) => {
+                if (global.json === true)
+                    process.stderr.write(`${stage}\n`);
+                else
+                    process.stdout.write(`• ${stage}\n`);
+            },
+        });
+        output(command, "pull").success(result, [
+            `结构文件已写入：${result.outputPath}`,
+            ...(result.warnings ?? []).map((warning) => `警告：${warning}`),
+        ].join("\n"));
+    });
+}
+function registerSkillCommands(program) {
+    const skill = program.command("skill").description("安装和同步 DataPull Skill");
+    skill.command("list").action(async (_options, command) => {
+        const projectRoot = await discoverProjectRoot();
+        const targets = allSkillTargets(projectRoot);
+        output(command, "skill list").success({ targets }, targets.map((target) => `${target.agent}:${target.scope} → ${target.path}`).join("\n"));
+    });
+    skill
+        .command("status")
+        .option("--target <target>", "目标 agent:scope，可重复", collect, [])
+        .action(async (options, command) => {
+        const projectRoot = await discoverProjectRoot();
+        const targets = options.target.length === 0
+            ? allSkillTargets(projectRoot)
+            : options.target.map((target) => parseTarget(target, projectRoot));
+        const installer = new SkillInstaller();
+        const statuses = await Promise.all(targets.map(async (target) => installer.status(target)));
+        output(command, "skill status").success({ targets: statuses }, statuses.map((item) => `${item.agent}:${item.scope} · ${item.status} · ${item.path}`).join("\n"));
+    });
+    skill
+        .command("install")
+        .option("--target <target>", "目标 agent:scope，可重复", collect, [])
+        .action(async (options, command) => {
+        if (options.target.length === 0)
+            throw new DataPullError("INVALID_ARGUMENT", "至少提供一个 --target。", 2);
+        await requireWriteConfirmation(globals(command), "确认创建目录并安装所选 DataPull Skill？");
+        const projectRoot = await discoverProjectRoot();
+        const installer = new SkillInstaller();
+        const targets = [];
+        for (const value of options.target) {
+            const target = parseTarget(value, projectRoot);
+            try {
+                targets.push(await installer.install(target, true));
+            }
+            catch (error) {
+                targets.push({
+                    agent: target.agent,
+                    scope: target.scope,
+                    path: target.path,
+                    status: "failed",
+                    modified: false,
+                    action: "none",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        if (targets.some((target) => target.status === "failed")) {
+            throw new DataPullError("SKILL_PARTIAL_FAILURE", "部分 Skill 目标安装失败。", 1, { targets });
+        }
+        output(command, "skill install").success({ targets }, "DataPull Skill 安装完成。\n" + targets.map((item) => item.path).join("\n"));
+    });
+    skill
+        .command("sync")
+        .option("--target <target>", "目标 agent:scope，可重复", collect, [])
+        .option("--force", "备份后覆盖用户修改")
+        .action(async (options, command) => {
+        if (options.target.length === 0)
+            throw new DataPullError("INVALID_ARGUMENT", "skill sync 必须明确提供 --target。", 2);
+        const global = globals(command);
+        if (options.force === true && global.yes !== true) {
+            throw new DataPullError("CONFIRMATION_REQUIRED", "覆盖用户修改必须同时提供明确目标、--force 和 --yes。", 2);
+        }
+        await requireWriteConfirmation(global, "确认同步所选 DataPull Skill？");
+        const projectRoot = await discoverProjectRoot();
+        const installer = new SkillInstaller();
+        const targets = [];
+        for (const value of options.target) {
+            const target = parseTarget(value, projectRoot);
+            try {
+                targets.push(await installer.sync(target, true, options.force === true));
+            }
+            catch (error) {
+                targets.push({
+                    agent: target.agent,
+                    scope: target.scope,
+                    path: target.path,
+                    status: "failed",
+                    modified: false,
+                    action: "none",
+                    error: error instanceof Error ? error.message : String(error),
+                });
+            }
+        }
+        if (targets.some((target) => target.status === "failed")) {
+            throw new DataPullError("SKILL_PARTIAL_FAILURE", "部分 Skill 目标同步失败。", 1, { targets });
+        }
+        output(command, "skill sync").success({ targets }, targets.map((item) => `${item.path} · ${item.status}`).join("\n"));
+    });
+}
+function registerConfigCommands(program, store) {
+    const config = program.command("config").description("查看和校验用户级配置");
+    config.command("path").action((_options, command) => {
+        output(command, "config path").success({ configRoot: store.paths.root, configPath: store.paths.config, credentialsPath: store.paths.credentials }, `配置：${store.paths.config}\n凭证：${store.paths.credentials}`);
+    });
+    config.command("validate").action(async (_options, command) => {
+        const parsed = await store.read();
+        await store.readCredentials();
+        output(command, "config validate").success({ valid: true, version: parsed.version, connectionCount: parsed.connections.length }, `配置有效：${parsed.connections.length} 个登记连接。`);
+    });
+}
+function registerDoctorCommand(program, store) {
+    program.command("doctor").description("诊断运行环境，不自动安装").action(async (_options, command) => {
+        const checks = await runDoctor(store);
+        output(command, "doctor").success({ healthy: checks.every((check) => check.ok), checks }, checks.map((check) => `${check.ok ? "✓" : "✗"} ${check.name}：${check.detail}`).join("\n"));
+    });
+}
+function globals(command) {
+    return command.optsWithGlobals();
+}
+function output(command, name) {
+    return new Output({ command: name, json: globals(command).json === true });
+}
+async function initializeForWrite(store, confirmed) {
+    if (await store.exists()) {
+        await store.initialize();
+        return;
+    }
+    if (!confirmed && !process.stdin.isTTY) {
+        throw new DataPullError("CONFIRMATION_REQUIRED", "初始化用户级配置需要 --yes。", 2, {
+            configRoot: store.paths.root,
+        });
+    }
+    if (!confirmed) {
+        process.stdout.write(`将创建用户级配置：${store.paths.root}\n`);
+        if (!(await confirm({ message: "确认初始化？", default: true }))) {
+            throw new DataPullError("OPERATION_CANCELLED", "已取消初始化。", 1);
+        }
+    }
+    await store.initialize();
+}
+async function requireWriteConfirmation(global, message) {
+    if (global.yes === true)
+        return;
+    if (!process.stdin.isTTY || global.json === true) {
+        throw new DataPullError("CONFIRMATION_REQUIRED", `${message} 非交互模式请添加 --yes。`, 2);
+    }
+    if (!(await confirm({ message, default: false }))) {
+        throw new DataPullError("OPERATION_CANCELLED", "操作已取消。", 1);
+    }
+}
+function requireYes(global) {
+    if (global.yes !== true) {
+        throw new DataPullError("CONFIRMATION_REQUIRED", "命令模式拉取会写入项目目录，请添加 --yes。", 2);
+    }
+}
+function requireConnectionCreateOptions(options) {
+    const alias = requiredString(options.alias, "--alias");
+    const engine = requiredString(options.engine, "--engine");
+    const authMode = requiredString(options.authMode, "--auth-mode");
+    if (authMode === "password") {
+        requiredString(options.host, "--host");
+        requiredString(options.username, "--username");
+        requiredString(options.credentialRef, "--credential-ref");
+    }
+    else if (authMode === "url")
+        requiredString(options.urlRef, "--url-ref");
+    else
+        requiredString(options.host, "--host");
+    if (options.trustServerCertificate === true && engine !== "sqlserver") {
+        throw new DataPullError("INVALID_ARGUMENT", "--trust-server-certificate 只适用于 SQL Server。", 2);
+    }
+    return {
+        alias,
+        engine,
+        authMode,
+        ...(options.host === undefined ? {} : { host: options.host }),
+        ...(options.port === undefined ? {} : { port: options.port }),
+        ...(options.username === undefined ? {} : { username: options.username }),
+        ...(options.credentialRef === undefined ? {} : { credentialRef: options.credentialRef }),
+        ...(options.urlRef === undefined ? {} : { urlRef: options.urlRef }),
+        ...(options.sslMode === undefined ? {} : { sslMode: options.sslMode }),
+        ...(options.trustServerCertificate === undefined
+            ? {}
+            : { trustServerCertificate: options.trustServerCertificate }),
+    };
+}
+function compactConnectionChanges(options, existing) {
+    const fields = ["engine", "authMode", "host", "port", "username", "credentialRef", "urlRef", "sslMode"];
+    const changes = Object.fromEntries(fields.flatMap((field) => (options[field] === undefined ? [] : [[field, options[field]]])));
+    const targetEngine = options.engine ?? existing.engine;
+    if ((options.trustServerCertificate === true || options.verifyServerCertificate === true) &&
+        targetEngine !== "sqlserver") {
+        throw new DataPullError("INVALID_ARGUMENT", "服务器证书信任选项只适用于 SQL Server。", 2);
+    }
+    if (options.trustServerCertificate === true) {
+        changes.tls = { encrypt: true, trustServerCertificate: true };
+    }
+    else if (options.verifyServerCertificate === true) {
+        changes.tls = { encrypt: true, trustServerCertificate: false };
+    }
+    return changes;
+}
+async function requireRiskConfirmation(global) {
+    if (global.yes === true)
+        return;
+    const message = "信任服务器证书会保留加密，但不验证 SQL Server 身份，可能受到中间人攻击。";
+    if (!process.stdin.isTTY || global.json === true) {
+        throw new DataPullError("CONFIRMATION_REQUIRED", `${message} 如确认仅本次使用，请添加 --yes。`, 2);
+    }
+    if (!(await confirm({ message: `${message} 是否继续？`, default: false }))) {
+        throw new DataPullError("OPERATION_CANCELLED", "操作已取消。", 1);
+    }
+}
+function requiredString(value, option) {
+    if (value !== undefined && value.trim().length > 0)
+        return value.trim();
+    throw new DataPullError("INVALID_ARGUMENT", `缺少必需选项 ${option}。`, 2);
+}
+function successMessage(message, connection) {
+    return [
+        message,
+        ...connectionSecurityWarnings(connection).map((warning) => `警告：${warning}`),
+    ].join("\n");
+}
+function numberParser(value) {
+    const parsed = Number.parseInt(value, 10);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65_535) {
+        throw new DataPullError("INVALID_ARGUMENT", `端口无效：${value}`, 2);
+    }
+    return parsed;
+}
+function collect(value, previous) {
+    return [...previous, value];
+}
+function parseTarget(value, projectRoot) {
+    try {
+        return parseSkillTarget(value, projectRoot);
+    }
+    catch (error) {
+        throw new DataPullError("INVALID_ARGUMENT", error instanceof Error ? error.message : String(error), 2);
+    }
+}
+//# sourceMappingURL=program.js.map