@logictan/dsh-config-manager 0.1.60

package/lib/ui/migration-consult-view.d.ts

@@ -0,0 +1,91 @@
+/**
+ * 迁移前咨询的纯渲染模型（Phase 7，m6-ui）。
+ *
+ * 把 core 的 ConsultReport 转成 React 可直接绑定的视图数据：
+ *  - 健康评分徽章（verdict → Badge kind）
+ *  - 维度明细（每维度：label / score / verdict / issues）
+ *  - 建议（proceed / review / block + 触发项）
+ *  - 将应用摘要（willApply）
+ *
+ * 安全：所有展示文本渲染前由 UI 层 redact() 兜底；本模型只做结构转换，不引入敏感值。
+ * 文案走 UiT（zh 源 / en 镜像，见 src/ui/i18n.ts）。
+ */
+import type { UiT } from './i18n.ts';
+import type { ConsultReport, ConsultDimensionId, HealthVerdict, Recommendation } from '../core/migration-consult.ts';
+/** Badge kind（与 DESIGN.md 四态语义一一对应） */
+export type ConsultBadgeKind = 'ok' | 'info' | 'warn' | 'error';
+/** 维度视图数据 */
+export interface ConsultDimensionView {
+    id: ConsultDimensionId;
+    label: string;
+    score: number;
+    verdict: HealthVerdict;
+    badgeKind: ConsultBadgeKind;
+    issues: {
+        severity: 'info' | 'warning' | 'error';
+        message: string;
+    }[];
+}
+/** 咨询卡视图数据 */
+export interface ConsultView {
+    healthScore: number;
+    verdict: HealthVerdict;
+    verdictBadgeKind: ConsultBadgeKind;
+    recommendation: Recommendation;
+    recommendationBadgeKind: ConsultBadgeKind;
+    recommendationLabel: string;
+    reasons: string[];
+    dimensions: ConsultDimensionView[];
+    willApply: {
+        sections: string[];
+        itemCount: number;
+        conflicts: number;
+        risks: number;
+        overwritten: number;
+        dryRun: boolean;
+    };
+}
+/** 建议依据分组条目（去重后的 message + 在原始数组中的出现次数） */
+export interface ConsultReasonGroup {
+    message: string;
+    /** 该 message 在原始 reasons 数组中的出现次数（≥1；仅用于 UI 展示「×N」） */
+    count: number;
+}
+/**
+ * 「建议依据」去重（纯函数）。
+ *
+ * 背景：core 的 `recommendationReasons` 是各维度 error/warning issue message 的
+ * 直接拼接，同一句话可能被 push 多次（如 migratability 维度按 `m.warnings` 逐条 push
+ * 「存在需注意的迁移项」），同一句也可能既出现在维度 issue 又出现在 reasons 中。
+ *
+ * 去重规则（严格按此实现，勿擅自放宽）：
+ *  1. **按原文去重**：只有完全相同的字符串才算重复——不做 trim 后合并、不做大小写
+ *     折叠、不做前缀/子串归并。因此 `'A'`、`' A'`、`'A '` 是三个不同条目。
+ *  2. **保持首次出现顺序**：稳定去重，输出顺序 = 各条目在输入中首次出现的顺序。
+ *  3. **丢弃空串与纯空白字符串**（`trim() === ''`），它们不参与展示。
+ *
+ * 不修改入参，返回新数组。
+ */
+export declare function dedupeConsultReasons(reasons: string[]): string[];
+/**
+ * 「建议依据」分组（纯函数）：去重后给出每个条目的重复次数，供 UI 渲染「×N」。
+ *
+ * 规则：
+ *  1. 先经 `dedupeConsultReasons` 去重（原文去重、丢弃空串/纯空白、保持首现顺序）；
+ *  2. `count` = 该 message 在**原始数组**（未去重）中的出现次数，按原文精确匹配统计，
+ *     因此 count ≥ 1；count 仅用于展示「×N」，不代表任何业务优先级或权重；
+ *  3. 输出顺序 = 去重后的顺序（即各条目首次出现的顺序）。
+ *
+ * 不修改入参，返回新数组。
+ */
+export declare function consultReasonGroups(reasons: string[]): ConsultReasonGroup[];
+/** verdict → Badge kind（语义映射） */
+export declare function consultVerdictBadgeKind(v: HealthVerdict): ConsultBadgeKind;
+/** recommendation → Badge kind */
+export declare function consultRecommendationBadgeKind(r: Recommendation): ConsultBadgeKind;
+/** 维度 label（i18n key 后缀） */
+export declare function consultDimensionLabel(id: ConsultDimensionId, t: UiT): string;
+/** 把 ConsultReport 转成视图数据（纯函数） */
+export declare function consultView(report: ConsultReport, t: UiT): ConsultView;
+/** recommendation 的可读标签 */
+export declare function consultRecommendationLabel(r: Recommendation, t: UiT): string;

package/lib/ui/migration-consult-view.js

@@ -0,0 +1,115 @@
+/**
+ * 「建议依据」去重（纯函数）。
+ *
+ * 背景：core 的 `recommendationReasons` 是各维度 error/warning issue message 的
+ * 直接拼接，同一句话可能被 push 多次（如 migratability 维度按 `m.warnings` 逐条 push
+ * 「存在需注意的迁移项」），同一句也可能既出现在维度 issue 又出现在 reasons 中。
+ *
+ * 去重规则（严格按此实现，勿擅自放宽）：
+ *  1. **按原文去重**：只有完全相同的字符串才算重复——不做 trim 后合并、不做大小写
+ *     折叠、不做前缀/子串归并。因此 `'A'`、`' A'`、`'A '` 是三个不同条目。
+ *  2. **保持首次出现顺序**：稳定去重，输出顺序 = 各条目在输入中首次出现的顺序。
+ *  3. **丢弃空串与纯空白字符串**（`trim() === ''`），它们不参与展示。
+ *
+ * 不修改入参，返回新数组。
+ */
+export function dedupeConsultReasons(reasons) {
+    const seen = new Set();
+    const out = [];
+    for (const reason of reasons) {
+        if (reason.trim() === '')
+            continue; // 空串/纯空白：直接丢弃
+        if (seen.has(reason))
+            continue; // 原文去重：仅完全相同才视为重复
+        seen.add(reason);
+        out.push(reason);
+    }
+    return out;
+}
+/**
+ * 「建议依据」分组（纯函数）：去重后给出每个条目的重复次数，供 UI 渲染「×N」。
+ *
+ * 规则：
+ *  1. 先经 `dedupeConsultReasons` 去重（原文去重、丢弃空串/纯空白、保持首现顺序）；
+ *  2. `count` = 该 message 在**原始数组**（未去重）中的出现次数，按原文精确匹配统计，
+ *     因此 count ≥ 1；count 仅用于展示「×N」，不代表任何业务优先级或权重；
+ *  3. 输出顺序 = 去重后的顺序（即各条目首次出现的顺序）。
+ *
+ * 不修改入参，返回新数组。
+ */
+export function consultReasonGroups(reasons) {
+    const counts = new Map();
+    for (const reason of reasons) {
+        counts.set(reason, (counts.get(reason) ?? 0) + 1);
+    }
+    return dedupeConsultReasons(reasons).map((message) => ({
+        message,
+        // 去重结果必来自入参，故此处理论上不会取到兜底值
+        count: counts.get(message) ?? 0,
+    }));
+}
+/** verdict → Badge kind（语义映射） */
+export function consultVerdictBadgeKind(v) {
+    switch (v) {
+        case 'healthy': return 'ok';
+        case 'needs-attention': return 'warn';
+        case 'critical': return 'error';
+    }
+}
+/** recommendation → Badge kind */
+export function consultRecommendationBadgeKind(r) {
+    switch (r) {
+        case 'proceed': return 'ok';
+        case 'review': return 'warn';
+        case 'block': return 'error';
+    }
+}
+/** 维度 label（i18n key 后缀） */
+export function consultDimensionLabel(id, t) {
+    switch (id) {
+        case 'compatibility': return t('consult.dim.compatibility');
+        case 'integrity': return t('consult.dim.integrity');
+        case 'sections': return t('consult.dim.sections');
+        case 'consistency': return t('consult.dim.consistency');
+        case 'sensitive': return t('consult.dim.sensitive');
+        case 'migratability': return t('consult.dim.migratability');
+    }
+}
+/** 把 ConsultReport 转成视图数据（纯函数） */
+export function consultView(report, t) {
+    const dimensions = report.dimensions.map((d) => ({
+        id: d.id,
+        label: consultDimensionLabel(d.id, t),
+        score: d.score,
+        verdict: d.verdict,
+        badgeKind: consultVerdictBadgeKind(d.verdict),
+        issues: d.issues.map((i) => ({ severity: i.severity, message: i.message })),
+    }));
+    return {
+        healthScore: report.healthScore,
+        verdict: report.verdict,
+        verdictBadgeKind: consultVerdictBadgeKind(report.verdict),
+        recommendation: report.recommendation,
+        recommendationBadgeKind: consultRecommendationBadgeKind(report.recommendation),
+        recommendationLabel: consultRecommendationLabel(report.recommendation, t),
+        reasons: report.recommendationReasons,
+        dimensions,
+        willApply: {
+            sections: report.willApply.sections,
+            itemCount: report.willApply.itemCount,
+            conflicts: report.willApply.conflicts,
+            risks: report.willApply.risks,
+            overwritten: report.willApply.overwritten,
+            dryRun: report.willApply.dryRun,
+        },
+    };
+}
+/** recommendation 的可读标签 */
+export function consultRecommendationLabel(r, t) {
+    switch (r) {
+        case 'proceed': return t('consult.recommendation.proceed');
+        case 'review': return t('consult.recommendation.review');
+        case 'block': return t('consult.recommendation.block');
+    }
+}
+//# sourceMappingURL=migration-consult-view.js.map

package/lib/ui/progress.d.ts

@@ -0,0 +1,38 @@
+/**
+ * 进度阶段文案与进度追踪（规范 §29，m6-ui）。
+ *
+ * 纯文本层：每个阶段 id 有默认文案；未知阶段回退显示 id 本身。
+ * ProgressTracker 供导出/导入控制器在调用 core 前后发出阶段事件（UI 不冻结）。
+ */
+import type { ProgressListener } from './types.ts';
+import { type UiT } from './i18n.ts';
+/** 导出阶段文案（规范 §29 Export 示例） */
+export declare const EXPORT_STAGES: readonly string[];
+/** 导入阶段文案（规范 §29 Import 示例 + 快照/回滚阶段） */
+export declare const IMPORT_STAGES: readonly string[];
+/**
+ * 真实执行阶段（不在 IMPORT_STAGES 序列里，因此 step/total 缺省 → 进度条渲染
+ * 为不定态动画而非伪造百分比）。execute 是一个单次 HTTP 请求，Host 端串行
+ * 跑完全部计划项（其中插件安装是 npm 串行，耗时最长）；请求期间没有中间
+ * 进度事件可回传，旧实现把 restoring-settings / restoring-plugins /
+ * restoring-mcp / validating-config 在请求前全部预发，导致进度条瞬间跳到
+ * 78% 后长时间无变化——像卡死。现在统一在请求期间显示 'executing' 不定态，
+ * 让用户明确知道「仍在执行，请等待」。
+ */
+export declare const EXECUTING_STAGE: 'executing';
+/** 阶段 id → 用户可读文案（未知阶段回退 id） */
+export declare function stageText(stage: string, t?: UiT): string;
+/**
+ * 进度追踪器：按给定阶段序列在回调时附带 step/total 序号。
+ * 控制器调用 core 前后 emit()，UI 侧渲染进度条/阶段文字。
+ */
+export declare class ProgressTracker {
+    private readonly listener;
+    private readonly stages;
+    private readonly emitted;
+    constructor(stages: readonly string[], listener?: ProgressListener);
+    /** 发出某阶段事件（可携带 detail）；未在序列中的阶段 step/total 缺省 */
+    emit(stage: string, detail?: string): void;
+    /** 已发出阶段的快照（测试与日志用） */
+    get events(): readonly string[];
+}

package/lib/ui/progress.js

@@ -0,0 +1,87 @@
+import { zhUiT } from './i18n.js';
+/** 导出阶段文案（规范 §29 Export 示例） */
+export const EXPORT_STAGES = [
+    'analyzing', // Analyzing configuration...
+    'exporting-settings', // Exporting settings...
+    'scanning-secrets', // Scanning secrets...
+    'exporting-plugins', // Exporting plugins...
+    'creating-archive', // Creating archive...
+    'calculating-checksums', // Calculating checksums...
+    'done',
+];
+/** 导入阶段文案（规范 §29 Import 示例 + 快照/回滚阶段） */
+export const IMPORT_STAGES = [
+    'validating', // Validating backup...
+    'checking-compatibility', // Checking compatibility...
+    'creating-snapshot', // Creating safety snapshot...
+    'restoring-settings', // Restoring settings...
+    'restoring-plugins', // Restoring plugins...
+    'restoring-mcp', // Restoring MCP...
+    'validating-config', // Validating configuration...
+    'rolling-back', // Rolling back...（仅失败回滚时）
+    'done',
+];
+/**
+ * 真实执行阶段（不在 IMPORT_STAGES 序列里，因此 step/total 缺省 → 进度条渲染
+ * 为不定态动画而非伪造百分比）。execute 是一个单次 HTTP 请求，Host 端串行
+ * 跑完全部计划项（其中插件安装是 npm 串行，耗时最长）；请求期间没有中间
+ * 进度事件可回传，旧实现把 restoring-settings / restoring-plugins /
+ * restoring-mcp / validating-config 在请求前全部预发，导致进度条瞬间跳到
+ * 78% 后长时间无变化——像卡死。现在统一在请求期间显示 'executing' 不定态，
+ * 让用户明确知道「仍在执行，请等待」。
+ */
+export const EXECUTING_STAGE = 'executing';
+const STAGE_KEYS = {
+    analyzing: 'progress.analyzing',
+    'exporting-settings': 'progress.exportingSettings',
+    'scanning-secrets': 'progress.scanningSecrets',
+    'exporting-plugins': 'progress.exportingPlugins',
+    'creating-archive': 'progress.creatingArchive',
+    'calculating-checksums': 'progress.calculatingChecksums',
+    exporting: 'progress.exporting',
+    validating: 'progress.validating',
+    'checking-compatibility': 'progress.checkingCompatibility',
+    'creating-snapshot': 'progress.creatingSnapshot',
+    'restoring-settings': 'progress.restoringSettings',
+    'restoring-plugins': 'progress.restoringPlugins',
+    'restoring-mcp': 'progress.restoringMcp',
+    'validating-config': 'progress.validatingConfig',
+    'rolling-back': 'progress.rollingBack',
+    executing: 'progress.executing',
+    done: 'progress.done',
+};
+/** 阶段 id → 用户可读文案（未知阶段回退 id） */
+export function stageText(stage, t = zhUiT) {
+    const key = STAGE_KEYS[stage];
+    return key !== undefined ? t(key) : stage;
+}
+/**
+ * 进度追踪器：按给定阶段序列在回调时附带 step/total 序号。
+ * 控制器调用 core 前后 emit()，UI 侧渲染进度条/阶段文字。
+ */
+export class ProgressTracker {
+    listener;
+    stages;
+    emitted = [];
+    constructor(stages, listener) {
+        this.stages = stages;
+        this.listener = listener;
+    }
+    /** 发出某阶段事件（可携带 detail）；未在序列中的阶段 step/total 缺省 */
+    emit(stage, detail) {
+        const idx = this.stages.indexOf(stage);
+        const event = {
+            stage,
+            detail,
+            step: idx >= 0 ? idx + 1 : undefined,
+            total: idx >= 0 ? this.stages.length : undefined,
+        };
+        this.emitted.push(stage);
+        this.listener?.(event);
+    }
+    /** 已发出阶段的快照（测试与日志用） */
+    get events() {
+        return [...this.emitted];
+    }
+}
+//# sourceMappingURL=progress.js.map

package/lib/ui/report.d.ts

@@ -0,0 +1,23 @@
+/**
+ * 报告渲染（规范 §21 导出报告 / §22 导入报告 / §17 回滚报告，m6-ui）。
+ *
+ * 纯文本渲染：输出用户可读的多行文本（未来 React 客户端可直接替换为组件渲染）。
+ * 导入报告按分区统计：从 ExecutedItem.itemId 前缀推断所属分区（与 adapters 的 id 规则一致）。
+ */
+import type { SectionId } from '../schema/types.ts';
+import type { ExecutedItem, ExportReport, ImportResult, RollbackReport } from '../core/types.ts';
+import type { ImportResultAction, ImportSectionStat } from './types.ts';
+import { type UiT } from './i18n.ts';
+export declare function renderExportReport(report: ExportReport, t?: UiT): string;
+/** 从 itemId 前缀推断所属分区（与 adapters id 规则对齐；未知归 'other'） */
+export declare function sectionFromItemId(itemId: string): SectionId | 'other';
+/** 按分区聚合执行结果（统计 + 明细） */
+export declare function importSectionStats(executed: readonly ExecutedItem[]): ImportSectionStat[];
+/** 导入报告渲染（含回滚状态；§22 动作按钮由 suggestedActions 给出） */
+export declare function renderImportReport(result: ImportResult, t?: UiT): string;
+/** 结果页动作按钮（§22）。报告已内联展示全部失败/警告项的原因与回滚详情（§23），
+ * 不再提供空操作的 Fix Issues / View Details 按钮——仅保留「完成」。 */
+export declare function suggestedActions(_result: ImportResult): ImportResultAction[];
+/** 回滚报告渲染（full / partial + 人工恢复清单） */
+export declare function renderRollbackReport(rr: RollbackReport, t?: UiT): string;
+export declare function formatBytes(n: number): string;

package/lib/ui/report.js

@@ -0,0 +1,153 @@
+import { zhUiT } from './i18n.js';
+/* ---------------- §21 导出报告 ---------------- */
+export function renderExportReport(report, t = zhUiT) {
+    const lines = [t('report.backupCreated'), ''];
+    lines.push(t('report.included'));
+    for (const { section, counts } of report.included) {
+        const detail = Object.entries(counts)
+            .map(([k, v]) => `${v} ${k}`)
+            .join(', ');
+        lines.push(`  ✓ ${section}${detail !== '' ? ` (${detail})` : ''}`);
+    }
+    lines.push('');
+    if (report.excluded.length > 0) {
+        lines.push(t('report.excluded'));
+        for (const s of report.excluded)
+            lines.push(`  ○ ${s}`);
+        lines.push('');
+    }
+    lines.push(t('report.security'));
+    lines.push(`  ✓ ${t('report.apiKeysExcluded')} ${report.security.secretsExcluded ? t('report.yes') : t('report.no')}`);
+    lines.push(`  ✓ ${t('report.containsSecrets')} ${report.security.containsSecrets ? t('report.yesEncrypted') : t('report.no')}`);
+    lines.push(`  ✓ ${t('report.encrypted')} ${report.security.encrypted ? t('report.yes') : t('report.no')}`);
+    if (report.security.redactedHits > 0)
+        lines.push(`  ⚠ ${t('report.redacted', { count: String(report.security.redactedHits) })}`);
+    lines.push('');
+    lines.push(`${t('report.file')} ${report.file.name} (${formatBytes(report.file.sizeBytes)})`);
+    for (const w of report.warnings)
+        lines.push(`  ⚠ ${w}`);
+    return lines.join('\n');
+}
+/* ---------------- §22 导入报告 ---------------- */
+/** 从 itemId 前缀推断所属分区（与 adapters id 规则对齐；未知归 'other'） */
+export function sectionFromItemId(itemId) {
+    if (itemId.startsWith('settings:'))
+        return 'settings';
+    if (itemId.startsWith('ui:'))
+        return 'ui';
+    if (itemId.startsWith('provider:'))
+        return 'providers';
+    if (itemId.startsWith('plugin:') || itemId.startsWith('patch:'))
+        return 'plugins';
+    if (itemId.startsWith('mcp:'))
+        return 'mcp';
+    if (itemId.startsWith('prompt:'))
+        return 'prompts';
+    if (itemId.startsWith('workspace:'))
+        return 'workspaces';
+    if (itemId.startsWith('secret:'))
+        return 'credentialsStatus';
+    if (itemId.startsWith('skills:'))
+        return 'skills';
+    if (itemId.startsWith('agentPresets:'))
+        return 'agentPresets';
+    if (itemId.startsWith('agentInstructions:'))
+        return 'agentInstructions';
+    if (itemId.startsWith('pluginFiles:'))
+        return 'pluginFiles';
+    if (itemId.startsWith('sessions:'))
+        return 'sessions';
+    return 'other';
+}
+/** 按分区聚合执行结果（统计 + 明细） */
+export function importSectionStats(executed) {
+    const bySection = new Map();
+    for (const e of executed) {
+        const section = sectionFromItemId(e.itemId);
+        let stat = bySection.get(section);
+        if (!stat) {
+            stat = { section: section, ok: 0, skipped: 0, warned: 0, failed: 0, items: [] };
+            bySection.set(section, stat);
+        }
+        if (e.status === 'ok')
+            stat.ok += 1;
+        else if (e.status === 'skipped')
+            stat.skipped += 1;
+        else if (e.status === 'warning')
+            stat.warned += 1;
+        else
+            stat.failed += 1;
+        stat.items.push(e);
+    }
+    return [...bySection.values()];
+}
+/** 导入报告渲染（含回滚状态；§22 动作按钮由 suggestedActions 给出） */
+export function renderImportReport(result, t = zhUiT) {
+    const lines = [result.ok ? t('report.importComplete') : t('report.importFailed'), ''];
+    // F4：被删除墓碑过滤的条目提示（用户明确删过、不复活）
+    if ((result.skippedTombstoned?.length ?? 0) > 0) {
+        lines.push(t('report.tombstonedSkipped', { count: String(result.skippedTombstoned.length) }));
+        lines.push('');
+    }
+    const stats = importSectionStats(result.executed);
+    for (const s of stats) {
+        const parts = [];
+        if (s.ok > 0)
+            parts.push(`✓ ${s.ok} ${t('report.importedRestored')}`);
+        if (s.skipped > 0)
+            parts.push(`- ${s.skipped} ${t('report.skipped')}`);
+        if (s.warned > 0)
+            parts.push(`⚠ ${s.warned} ${t('report.needAttention')}`);
+        if (s.failed > 0)
+            parts.push(`✗ ${s.failed} ${t('report.failed')}`);
+        lines.push(`${s.section}: ${parts.join(' ') || t('report.noChanges')}`);
+        // 失败/警告项给出可操作原因（§23）
+        for (const it of s.items) {
+            if (it.status === 'failed' || it.status === 'warning') {
+                lines.push(`  ${it.status === 'failed' ? t('report.reason') : t('report.note')}: ${it.message ?? t('report.unknownReason')}`);
+            }
+        }
+    }
+    if (result.missingSecrets.length > 0) {
+        lines.push(`${t('report.secrets')} ⚠ ${t('report.credentialsNeedEntry', { count: String(result.missingSecrets.length) })}`);
+    }
+    if (result.needsRestart) {
+        lines.push(t('report.restartPluginsMcp'));
+    }
+    for (const w of result.warnings)
+        lines.push(`⚠ ${w}`);
+    if (result.rollback) {
+        lines.push('');
+        lines.push(renderRollbackReport(result.rollback, t));
+    }
+    return lines.join('\n');
+}
+/** 结果页动作按钮（§22）。报告已内联展示全部失败/警告项的原因与回滚详情（§23），
+ * 不再提供空操作的 Fix Issues / View Details 按钮——仅保留「完成」。 */
+export function suggestedActions(_result) {
+    return ['done'];
+}
+/* ---------------- §17 回滚报告 ---------------- */
+/** 回滚报告渲染（full / partial + 人工恢复清单） */
+export function renderRollbackReport(rr, t = zhUiT) {
+    if (rr.full) {
+        return t('report.rollbackFull');
+    }
+    const lines = [t('report.rollbackPartial')];
+    lines.push(t('report.rollbackManual'));
+    for (const f of rr.failed) {
+        lines.push(`  - ${f.item}: ${f.reason}${f.manualHint ? ` (${f.manualHint})` : ''}`);
+    }
+    if (rr.restored.length > 0)
+        lines.push(t('report.restored', { count: String(rr.restored.length) }));
+    return lines.join('\n');
+}
+/* ---------------- 工具 ---------------- */
+export function formatBytes(n) {
+    if (n < 1024)
+        return `${n} B`;
+    if (n < 1024 * 1024)
+        return `${(n / 1024).toFixed(1)} KB`;
+    return `${(n / (1024 * 1024)).toFixed(1)} MB`;
+}
+//# sourceMappingURL=report.js.map

package/lib/ui/test-helpers.d.ts

@@ -0,0 +1,69 @@
+/**
+ * UI 层测试辅助（m6-ui）：mock core 调用与样本数据。
+ * 仅供 src/ui/*.test.ts 使用，不参与生产构建语义。
+ */
+import type { Manifest } from '../schema/types.ts';
+import type { ExportReport, ImportAnalysis, ImportDecisions, ImportPlan, ImportResult, PlanItem, RollbackReport } from '../core/types.ts';
+import type { ExportPort } from './export-flow.ts';
+import type { ImportPort } from './types.ts';
+/** 样本 manifest（UI 测试不关心真实字段，仅类型占位） */
+export declare function makeManifest(): Manifest;
+export declare function makeExportReport(overrides?: Partial<ExportReport>): ExportReport;
+/** 内存 ExportPort mock：记录调用参数，返回固定结果 */
+export declare class MockExportPort implements ExportPort {
+    calls: {
+        includeSecrets: boolean;
+        only?: string[];
+    }[];
+    result: {
+        zipPath: string;
+        manifest: Manifest;
+        report: ExportReport;
+    };
+    constructor(report?: ExportReport);
+    export(opts: {
+        includeSecrets: boolean;
+        only?: string[];
+    }): Promise<{
+        zipPath: string;
+        manifest: Manifest;
+        report: ExportReport;
+    }>;
+}
+export declare function makeAnalysis(overrides?: Partial<ImportAnalysis>): ImportAnalysis;
+export declare function makePlanItem(overrides?: Partial<PlanItem>): PlanItem;
+export declare function makePlan(overrides?: Partial<ImportPlan>): ImportPlan;
+export declare function makeRollbackReport(overrides?: Partial<RollbackReport>): RollbackReport;
+export declare function makeImportResult(overrides?: Partial<ImportResult>): ImportResult;
+/** 内存 ImportPort mock：可编排各阶段返回与调用记录 */
+export declare class MockImportPort implements ImportPort {
+    analysis: ImportAnalysis;
+    plan: ImportPlan;
+    result: ImportResult;
+    analyzeCalls: number;
+    planCalls: ImportDecisions[];
+    executeCalls: {
+        confirm: boolean;
+        secretInputs?: Record<string, string>;
+        rollbackOnError: boolean;
+        decryptPassword?: string;
+        plan?: ImportPlan;
+    }[];
+    constructor(opts?: {
+        analysis?: ImportAnalysis;
+        plan?: ImportPlan;
+        result?: ImportResult;
+    });
+    analyzeImport(): Promise<ImportAnalysis>;
+    createImportPlan(_zip: string, decisions: ImportDecisions): Promise<ImportPlan>;
+    decryptArchive(zipPath: string): Promise<{
+        zipPath: string;
+        refs: string[];
+    }>;
+    executeImportPlan(_zip: string, plan: ImportPlan, opts: {
+        confirm: boolean;
+        secretInputs?: Record<string, string>;
+        rollbackOnError: boolean;
+        decryptPassword?: string;
+    }): Promise<ImportResult>;
+}