@ytinnovation/harness-core 0.0.0

package/dist/init/command.js

@@ -0,0 +1,783 @@
+import { readFile, stat } from 'node:fs/promises';
+import { dirname, posix, resolve } from 'node:path';
+import { HarnessError } from '../contracts/errors.js';
+import { detectProjectFingerprint } from './fingerprint.js';
+import { generateInitArtifactPlan } from './plan.js';
+import { createCliInitPromptAdapter } from './prompt.js';
+import { applyPackSelectionToMatchedContext, applyReviewTogglesToAnswers, deriveInitAnswersFromMatchedContext, filterCloudAssetsBySelection, resolveMatchedInitContext, } from './matched-init.js';
+import { applyInitArtifactPlan } from './write.js';
+import { createDefaultCursorCliAdapter } from './cursor-adapter.js';
+import { createDefaultCloudInitAdapter } from './cloud-auto.js';
+import { createDefaultCloudAssetClient } from './cloud-asset-client.js';
+import { injectInstalledAssetIdHeader, isMarkdownLikeAssetPath } from '../assets/install-content.js';
+import { createInitProjectManifest } from '../assets/project-manifest.js';
+import { resolvePublishedAssetBody } from '../assets/published-content.js';
+import { buildInstalledRegistryFromInitPlan, buildConfigPackManifestFromInit } from './manifest-records.js';
+import { renderDebugBoundary, renderSection, renderSuccessBlock, renderWarningBlock } from '../cli-output/renderers.js';
+function renderInitHelp(programName = 'harness') {
+    return [
+        '为当前工作区初始化 Harness 项目资产。',
+        '',
+        '用法：',
+        `  ${programName} init [--cwd <path>] [--mode <template-match|cloud-auto|local-manual>] [--dry-run]`,
+        '',
+        '模式：',
+        '  template-match  按工程指纹匹配云端配置包；无精确命中或服务不可用时直接失败。',
+        '  cloud-auto      上报工程指纹和用户角色，由云端 Mastra agent 选择资产。',
+        '  local-manual    调用 Cursor CLI 生成项目 Rule；缺少 Cursor CLI 时退出。',
+        '',
+        '选项：',
+        '  --cwd <path>  指定初始化目录，默认当前工作目录。',
+        '  --mode <mode> 选择初始化模式。',
+        '  --dry-run     只预览计划，不写入文件。',
+        '  -h, --help    查看帮助。',
+    ].join('\n');
+}
+const VALID_INIT_MODES = ['template-match', 'cloud-auto', 'local-manual'];
+function parseInitMode(value) {
+    if (VALID_INIT_MODES.includes(value)) {
+        return value;
+    }
+    throw new HarnessError('INIT_INVALID_ARGS', `Unknown init mode: ${value}. Expected one of ${VALID_INIT_MODES.join(', ')}.`);
+}
+function parseInitArgs(args) {
+    let cwd = process.cwd();
+    let dryRun = false;
+    let help = false;
+    let mode;
+    for (let index = 0; index < args.length; index += 1) {
+        const arg = args[index];
+        if (arg === '--help' || arg === '-h') {
+            help = true;
+            continue;
+        }
+        if (arg === '--dry-run') {
+            dryRun = true;
+            continue;
+        }
+        if (arg === '--cwd') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('--')) {
+                throw new HarnessError('INIT_INVALID_ARGS', 'Missing value for --cwd.');
+            }
+            cwd = resolve(value);
+            index += 1;
+            continue;
+        }
+        if (arg === '--mode') {
+            const value = args[index + 1];
+            if (!value || value.startsWith('--')) {
+                throw new HarnessError('INIT_INVALID_ARGS', 'Missing value for --mode.');
+            }
+            mode = parseInitMode(value);
+            index += 1;
+            continue;
+        }
+        throw new HarnessError('INIT_INVALID_ARGS', `Unknown init option: ${arg}`);
+    }
+    return {
+        cwd,
+        dryRun,
+        help,
+        mode,
+    };
+}
+async function assertValidCwd(cwd) {
+    try {
+        const details = await stat(cwd);
+        if (!details.isDirectory()) {
+            throw new HarnessError('INIT_INVALID_CWD', `Invalid cwd: ${cwd} is not a directory.`);
+        }
+    }
+    catch (error) {
+        if (error instanceof HarnessError) {
+            throw error;
+        }
+        throw new HarnessError('INIT_INVALID_CWD', `Invalid cwd: ${cwd}`, {
+            cause: error,
+        });
+    }
+}
+function selectInitMode(options, _fingerprint) {
+    if (options.mode) {
+        return {
+            mode: options.mode,
+            source: 'argument',
+        };
+    }
+    return {
+        mode: 'template-match',
+        source: 'default-selector',
+    };
+}
+function mapArtifactType(artifactId) {
+    if (artifactId.startsWith('cloud:')) {
+        const cloudTypePart = artifactId.slice('cloud:'.length).split(':')[0];
+        if (typeof cloudTypePart === 'string' && cloudTypePart.length > 0) {
+            return cloudTypePart;
+        }
+    }
+    switch (artifactId) {
+        case 'rules':
+            return 'rule';
+        case 'skill-suggestions':
+            return 'skill';
+        case 'mcp-config-draft':
+            return 'mcp-config';
+        case 'ai-coding-readme':
+        case 'local-manual-spec':
+            return 'spec';
+        case 'local-manual-command':
+            return 'command';
+        case 'cursorignore-secrets':
+        case 'gitignore-secrets':
+            return 'rule';
+        default:
+            return 'unknown';
+    }
+}
+function sanitizeArtifactIdPart(value) {
+    return value
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-+|-+$/g, '');
+}
+export function normalizeCursorAssetTargetPath(asset) {
+    const normalizedName = sanitizeArtifactIdPart(asset.name) || 'asset';
+    const rawTargetPath = (asset.targetPath ?? '').replace(/\\/g, '/').replace(/^\/+/, '');
+    if (!rawTargetPath.startsWith('.cursor/') && !rawTargetPath.startsWith('.harness/') && !rawTargetPath.startsWith('.agents/')) {
+        if (rawTargetPath === 'AI_CODING_README.md' || asset.name === 'ai-coding-readme') {
+            return rawTargetPath;
+        }
+    }
+    if (asset.assetType === 'rule') {
+        if (rawTargetPath.startsWith('.cursor/rules/')) {
+            return rawTargetPath;
+        }
+        return `.cursor/rules/${normalizedName}.mdc`;
+    }
+    if (rawTargetPath.startsWith('.harness/')) {
+        return `.cursor/harness/${rawTargetPath.slice('.harness/'.length)}`;
+    }
+    if (rawTargetPath.startsWith('.agents/')) {
+        return `.cursor/${rawTargetPath.slice('.agents/'.length)}`;
+    }
+    if (rawTargetPath.startsWith('.cursor/')) {
+        return rawTargetPath;
+    }
+    if (asset.assetType === 'mcp-config') {
+        return '.cursor/mcp.json';
+    }
+    if (asset.assetType === 'skill') {
+        return `.cursor/skills/${normalizedName}/SKILL.md`;
+    }
+    if (asset.assetType === 'spec') {
+        return `.cursor/specs/${normalizedName}.md`;
+    }
+    if (asset.assetType === 'command') {
+        return `.cursor/commands/${normalizedName}.md`;
+    }
+    return `.cursor/assets/${normalizedName}`;
+}
+function parseCloudAssetContent(asset) {
+    if (asset.content === undefined) {
+        return { content: undefined, metadata: {} };
+    }
+    if (asset.bundleFiles && asset.bundleFiles.length > 0) {
+        const metadata = asset.content !== undefined
+            ? resolvePublishedAssetBody(asset.content, { assetName: asset.name }).metadata
+            : {};
+        return {
+            content: asset.content,
+            metadata,
+            bundleFiles: asset.bundleFiles,
+        };
+    }
+    const parsed = resolvePublishedAssetBody(asset.content, { assetName: asset.name });
+    return {
+        content: parsed.content,
+        metadata: parsed.metadata,
+        bundleFiles: parsed.bundleFiles,
+    };
+}
+function joinPosixPath(...segments) {
+    return posix.join(...segments.map((segment) => segment.replace(/\\/g, '/')));
+}
+function renderCloudAssetContent(asset, targetPath, parsedInput) {
+    const parsed = parsedInput ?? parseCloudAssetContent(asset);
+    if (parsed.content !== undefined) {
+        if (targetPath && isMarkdownLikeAssetPath(targetPath) && asset.assetId) {
+            return injectInstalledAssetIdHeader(parsed.content, asset.assetId);
+        }
+        return parsed.content;
+    }
+    const metadata = {
+        source: asset.source,
+        version: asset.version,
+        reason: asset.reason ?? null,
+    };
+    if (asset.targetPath.endsWith('.json')) {
+        return JSON.stringify({
+            generatedBy: 'harness-cloud',
+            asset: {
+                assetType: asset.assetType,
+                name: asset.name,
+            },
+            metadata,
+        }, null, 2);
+    }
+    return [
+        `# Cloud Asset: ${asset.name}`,
+        '',
+        `- assetType: ${asset.assetType}`,
+        `- source: ${asset.source}`,
+        `- version: ${asset.version}`,
+        `- reason: ${asset.reason ?? 'n/a'}`,
+    ].join('\n');
+}
+async function resolveArtifactAction(cwd, targetPath) {
+    const absoluteTargetPath = resolve(cwd, targetPath);
+    try {
+        await stat(absoluteTargetPath);
+        return 'update';
+    }
+    catch {
+        return 'create';
+    }
+}
+async function convertCloudAssetsToWritePlan(args) {
+    const orderedCloudAssets = [...args.cloudAssets].sort((left, right) => left.targetPath.localeCompare(right.targetPath));
+    const seenTargetPaths = new Set();
+    const artifacts = [];
+    for (const asset of orderedCloudAssets) {
+        const targetPath = normalizeCursorAssetTargetPath(asset);
+        if (seenTargetPaths.has(targetPath)) {
+            artifacts.push({
+                id: `cloud:${asset.assetType}:${sanitizeArtifactIdPart(asset.name)}:duplicate`,
+                targetPath,
+                action: 'skip',
+                content: '',
+                reason: 'duplicate-cloud-asset-target',
+            });
+            continue;
+        }
+        seenTargetPaths.add(targetPath);
+        const parsed = parseCloudAssetContent(asset);
+        const action = await resolveArtifactAction(args.cwd, targetPath);
+        artifacts.push({
+            id: asset.assetId ?? `cloud:${asset.assetType}:${sanitizeArtifactIdPart(asset.name)}`,
+            targetPath,
+            action,
+            content: renderCloudAssetContent(asset, targetPath, parsed),
+            reason: asset.reason,
+            publishedVersion: asset.publishedVersionLabel,
+            contentRevision: asset.contentCommitSha ?? (asset.version !== 'unknown' ? asset.version : undefined),
+        });
+        const bundleFiles = parsed.bundleFiles ?? [];
+        if (bundleFiles.length > 0) {
+            const installDir = dirname(targetPath.replace(/\\/g, '/'));
+            const entrypointBasename = posix.basename(targetPath.replace(/\\/g, '/'));
+            for (const bundleFile of bundleFiles) {
+                if (bundleFile.path === entrypointBasename) {
+                    continue;
+                }
+                const siblingTargetPath = joinPosixPath(installDir, bundleFile.path);
+                if (seenTargetPaths.has(siblingTargetPath)) {
+                    continue;
+                }
+                seenTargetPaths.add(siblingTargetPath);
+                const siblingAction = await resolveArtifactAction(args.cwd, siblingTargetPath);
+                artifacts.push({
+                    id: `${asset.assetId ?? `cloud:${asset.assetType}:${sanitizeArtifactIdPart(asset.name)}`}:file:${sanitizeArtifactIdPart(bundleFile.path)}`,
+                    targetPath: siblingTargetPath,
+                    action: siblingAction,
+                    content: bundleFile.content,
+                    reason: asset.reason,
+                    publishedVersion: asset.publishedVersionLabel,
+                    contentRevision: asset.contentCommitSha ?? (asset.version !== 'unknown' ? asset.version : undefined),
+                });
+            }
+        }
+    }
+    const mergedArtifacts = [...artifacts].sort((left, right) => left.targetPath.localeCompare(right.targetPath));
+    return {
+        ...args.initialPlan,
+        artifacts: mergedArtifacts,
+        summary: summarizeArtifacts({
+            ...args.initialPlan,
+            artifacts: mergedArtifacts,
+        }),
+        cloudPlanSource: args.cloudPlanSource,
+        localFallback: false,
+    };
+}
+function summarizeArtifacts(plan) {
+    return plan.artifacts.reduce((summary, artifact) => {
+        summary[artifact.action] += 1;
+        return summary;
+    }, {
+        create: 0,
+        update: 0,
+        skip: 0,
+    });
+}
+function appendCursorAssetManifest(plan, cloudAssets = [], matchedContext) {
+    const { configPacks, installFromByAssetId } = matchedContext !== undefined
+        ? buildConfigPackManifestFromInit({
+            context: matchedContext,
+            selectedCloudAssets: cloudAssets,
+        })
+        : { configPacks: [], installFromByAssetId: new Map() };
+    const installed = buildInstalledRegistryFromInitPlan({
+        plan,
+        cloudAssets,
+        installFromByAssetId,
+    });
+    const manifest = createInitProjectManifest({
+        generatedBy: 'harness init',
+        cloudPlanSource: plan.cloudPlanSource ?? null,
+        installed,
+        configPacks,
+    });
+    const shouldWriteManifest = installed.length > 0 || configPacks.length > 0;
+    const artifacts = [
+        ...plan.artifacts.filter((artifact) => artifact.id !== 'asset-manifest'),
+        {
+            id: 'asset-manifest',
+            targetPath: '.cursor/harness-assets.json',
+            action: shouldWriteManifest ? 'create' : 'skip',
+            content: JSON.stringify(manifest, null, 2),
+            reason: shouldWriteManifest ? undefined : 'No enabled init assets to track.',
+        },
+    ];
+    return {
+        ...plan,
+        artifacts,
+        summary: summarizeArtifacts({
+            ...plan,
+            artifacts,
+        }),
+    };
+}
+async function buildLocalManualPlan(args) {
+    const byId = new Map(args.plan.artifacts.map((artifact) => [artifact.id, artifact]));
+    const needsCursorDrafts = args.answers.includeRules;
+    let drafts = null;
+    if (needsCursorDrafts) {
+        const context = await args.cursorCliAdapter.collectRepositoryContext({
+            cwd: args.cwd,
+            fingerprint: args.fingerprint,
+        });
+        drafts = await args.cursorCliAdapter.generateRuleAndSpecDrafts({
+            context,
+            answers: args.answers,
+        });
+    }
+    const rulesArtifact = byId.get('rules');
+    const secretArtifacts = args.plan.artifacts.filter((artifact) => artifact.id === 'cursorignore-secrets' || artifact.id === 'gitignore-secrets');
+    const ordered = [];
+    if (rulesArtifact) {
+        ordered.push({
+            ...rulesArtifact,
+            content: rulesArtifact.action === 'create' && drafts !== null
+                ? drafts.ruleDraft
+                : rulesArtifact.content,
+        });
+    }
+    ordered.push(...secretArtifacts);
+    return {
+        ...args.plan,
+        artifacts: ordered,
+        summary: summarizeArtifacts({
+            ...args.plan,
+            artifacts: ordered,
+        }),
+    };
+}
+function summarizePlannedAssetTypes(plan) {
+    const types = new Set();
+    for (const artifact of plan.artifacts) {
+        if (artifact.action === 'create' || artifact.action === 'update') {
+            types.add(mapArtifactType(artifact.id));
+        }
+    }
+    if (types.size === 0) {
+        return 'none';
+    }
+    return Array.from(types).sort().join(', ');
+}
+function rollbackHintForMode(mode) {
+    switch (mode) {
+        case 'template-match':
+            return 'Use --dry-run first and revert generated files via version control if needed.';
+        case 'cloud-auto':
+            return 'If cloud output is not desired, rerun with --mode template-match or --mode local-manual.';
+        case 'local-manual':
+            return 'Keep manual edits in version control and rerun with template-match when standardizing.';
+    }
+}
+function formatGitIdentity(gitIdentity) {
+    const name = gitIdentity.name ?? 'missing';
+    const email = gitIdentity.email ?? 'missing';
+    return `name:${name},email:${email}`;
+}
+function deriveFingerprintFallback(fingerprint) {
+    const reasons = [];
+    if (fingerprint.languages.length === 1 && fingerprint.languages[0] === 'unknown') {
+        reasons.push('language-not-detected');
+    }
+    if (fingerprint.packageManager === 'unknown') {
+        reasons.push('package-manager-not-detected');
+    }
+    if (!fingerprint.markers.git) {
+        reasons.push('git-repository-not-detected');
+    }
+    else if (fingerprint.gitIdentity.name === null && fingerprint.gitIdentity.email === null) {
+        reasons.push('git-identity-not-configured');
+    }
+    return {
+        reasons,
+        nextSteps: fingerprint.recommendations,
+    };
+}
+function logFingerprintSummary(fingerprint) {
+    console.log(renderSection('初始化指纹摘要'));
+    console.log(`  语言=${fingerprint.languages.join(',')}`);
+    console.log(`  包管理器=${fingerprint.packageManager}`);
+    console.log(`  Git 身份=${formatGitIdentity(fingerprint.gitIdentity)}`);
+    console.log(`  建议配置=${fingerprint.recommendations.length > 0 ? fingerprint.recommendations.join(' | ') : 'none'}`);
+    const fallback = deriveFingerprintFallback(fingerprint);
+    if (fallback.reasons.length > 0) {
+        console.log(renderSection('初始化回退提示'));
+        console.log(`  原因=${fallback.reasons.join(',')}`);
+        console.log(`  下一步=${fallback.nextSteps.join(' | ') || 'none'}`);
+    }
+}
+function logModePreflight(mode, plan) {
+    console.log([
+        `初始化预检 mode=${mode.mode}`,
+        `输入来源=${mode.source}`,
+        `资产类型=${summarizePlannedAssetTypes(plan)}`,
+        `回退提示=${rollbackHintForMode(mode.mode)}`,
+    ].join(' | '));
+}
+function logPlannedArtifactList(plan) {
+    console.log(renderSection('初始化文件计划'));
+    for (const artifact of plan.artifacts) {
+        console.log(`  - ${artifact.action.toUpperCase()} ${artifact.targetPath}`);
+    }
+}
+function firstPreviewLine(content) {
+    const [firstLine = ''] = content.split(/\r?\n/, 1);
+    const compact = firstLine.trim();
+    if (compact.length === 0) {
+        return '[empty-line]';
+    }
+    return compact.length > 80 ? `${compact.slice(0, 77)}...` : compact;
+}
+async function readTargetFileOrNull(cwd, targetPath) {
+    const absoluteTargetPath = resolve(cwd, targetPath);
+    try {
+        return await readFile(absoluteTargetPath, 'utf8');
+    }
+    catch {
+        return null;
+    }
+}
+async function logLocalDiffPreview(cwd, plan) {
+    console.log(renderSection('初始化本地差异预览'));
+    for (const artifact of plan.artifacts) {
+        if (artifact.action === 'skip') {
+            const reason = artifact.reason ?? 'unchanged-or-disabled';
+            console.log(`  - SKIP ${artifact.targetPath} | reason=${reason}`);
+            continue;
+        }
+        const existing = await readTargetFileOrNull(cwd, artifact.targetPath);
+        if (existing === null) {
+            console.log(`  - CREATE ${artifact.targetPath}`);
+            console.log(`    + ${firstPreviewLine(artifact.content)}`);
+            continue;
+        }
+        if (existing === artifact.content) {
+            console.log(`  - SKIP ${artifact.targetPath} | reason=no-content-change`);
+            continue;
+        }
+        console.log(`  - UPDATE ${artifact.targetPath}`);
+        console.log(`    - ${firstPreviewLine(existing)}`);
+        console.log(`    + ${firstPreviewLine(artifact.content)}`);
+    }
+}
+function logAppliedArtifactList(plan) {
+    console.log(renderSection('初始化写入结果'));
+    for (const artifact of plan.artifacts) {
+        console.log(`  - ${artifact.action.toUpperCase()} ${artifact.targetPath}`);
+    }
+}
+function logCloudDiffPreview(preview) {
+    console.log(renderSection('云端差异预览', `来源=${preview.source} 版本=${preview.version}`));
+    for (const entry of preview.entries) {
+        const reasonSuffix = entry.reason ? ` | reason=${entry.reason}` : '';
+        console.log(`  - ${entry.action.toUpperCase()} ${entry.targetPath}${reasonSuffix}`);
+    }
+}
+function buildCloudPlanPreviewFromWritePlan(plan) {
+    if (!plan.cloudPlanSource) {
+        return null;
+    }
+    const entries = plan.artifacts
+        .filter((artifact) => artifact.id.startsWith('cloud:'))
+        .map((artifact) => ({
+        id: artifact.id,
+        targetPath: artifact.targetPath,
+        action: artifact.action,
+        reason: artifact.reason,
+    }));
+    if (entries.length === 0) {
+        return null;
+    }
+    return {
+        source: `harness-cloud/${plan.cloudPlanSource}`,
+        version: 'dynamic',
+        entries,
+    };
+}
+function logCloudDynamicAssemblyResult(result) {
+    console.log(renderSection('云端动态组装日志'));
+    if (result.explainableLog.length === 0) {
+        console.log('  - [none]');
+    }
+    else {
+        for (const logEntry of result.explainableLog) {
+            console.log(`  - ${logEntry}`);
+        }
+    }
+    console.log(renderSection('云端动态组装资产'));
+    if (result.assets.length === 0) {
+        console.log('  - [none]');
+    }
+    else {
+        for (const asset of result.assets) {
+            console.log(`  - ${asset.assetType} ${asset.name} -> ${asset.targetPath} | source=${asset.source} | reason=${asset.reason ?? 'unknown'}`);
+        }
+    }
+    if (result.fallbackReason) {
+        console.log(`云端动态组装回退：${result.fallbackReason}`);
+    }
+}
+async function tryRenderCloudPreview(args) {
+    if (args.mode.mode !== 'cloud-auto') {
+        return;
+    }
+    const hydratedPreview = buildCloudPlanPreviewFromWritePlan(args.plan);
+    if (hydratedPreview) {
+        logCloudDiffPreview(hydratedPreview);
+        return;
+    }
+    if (!args.plan.cloudRequestPayload) {
+        return;
+    }
+    try {
+        const preview = await args.cloudInitAdapter.generatePlanPreview({
+            cwd: args.options.cwd,
+            payload: args.plan.cloudRequestPayload,
+        });
+        logCloudDiffPreview(preview);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        console.log(renderWarningBlock('云端自动初始化暂不可用', [
+            ['原因', message],
+        ], ['本次 cloud-auto 预览未生成云端差异。']));
+    }
+}
+function logMatchedInitContext(context) {
+    if (context.cloudMiss) {
+        console.log(renderWarningBlock('云端配置包未命中', [['原因', context.cloudMiss.hitReason]]));
+        if (context.cloudMiss.rollbackHint) {
+            console.log(`云端配置包回退提示：${context.cloudMiss.rollbackHint}`);
+        }
+    }
+    console.log(renderSection('初始化配置包匹配'));
+    const packs = context.matchedPacks ?? [];
+    if (packs.length > 1) {
+        console.log(`  命中数量=${packs.length}`);
+        for (const pack of packs) {
+            console.log(`  配置包=${pack.packName} (${pack.packId} @ ${pack.version})`);
+            console.log(`  原因=${pack.hitReason}`);
+        }
+    }
+    else {
+        console.log(`  配置包=${context.packName} (${context.packId} @ ${context.version})`);
+        console.log(`  原因=${context.hitReason}`);
+    }
+    console.log(`  来源=${context.source}`);
+    if (context.includeCloudDynamicAssembly) {
+        console.log('  说明=cloud-auto 将追加云端动态组装资产');
+    }
+}
+async function maybeHydratePlanFromCloudAssets(args) {
+    if (args.mode.mode !== 'template-match' && args.mode.mode !== 'cloud-auto') {
+        return args.initialPlan;
+    }
+    const cloudAssets = args.matchedContext.cloudAssets ?? [];
+    if (args.mode.mode === 'template-match' && cloudAssets.length === 0) {
+        throw new HarnessError('INIT_CLOUD_ASSET_UNAVAILABLE', 'Template-match requires cloud config-pack assets; none were returned.');
+    }
+    try {
+        let hydratedAssets = [...cloudAssets];
+        let cloudPlanSource = cloudAssets.length > 0 ? 'config-pack' : 'mastra';
+        if (args.mode.mode === 'cloud-auto' && args.matchedContext.includeCloudDynamicAssembly) {
+            const assembledResult = await args.cloudAssetClient.assembleAssets({
+                fingerprint: args.fingerprint,
+                answers: args.answers,
+            });
+            logCloudDynamicAssemblyResult(assembledResult);
+            const byPath = new Map();
+            for (const asset of hydratedAssets) {
+                byPath.set(asset.targetPath, asset);
+            }
+            for (const asset of assembledResult.assets) {
+                byPath.set(asset.targetPath, asset);
+            }
+            hydratedAssets = [...byPath.values()];
+            cloudPlanSource = cloudAssets.length > 0 ? 'config-pack+mastra' : 'mastra';
+        }
+        const filteredAssets = filterCloudAssetsBySelection({
+            assets: hydratedAssets,
+            answers: args.answers,
+            disabledAssetKeys: args.disabledAssetKeys,
+        });
+        if (filteredAssets.length === 0) {
+            throw new HarnessError('INIT_CLOUD_ASSET_UNAVAILABLE', 'No cloud assets remain after applying init selections.');
+        }
+        return convertCloudAssetsToWritePlan({
+            cwd: args.options.cwd,
+            initialPlan: args.initialPlan,
+            cloudAssets: filteredAssets,
+            cloudPlanSource,
+        });
+    }
+    catch (error) {
+        if (error instanceof HarnessError) {
+            throw error;
+        }
+        const message = error instanceof Error ? error.message : String(error);
+        throw new HarnessError('INIT_CLOUD_ASSET_UNAVAILABLE', message, { cause: error });
+    }
+}
+export async function runInitCommand(args, dependencies = {}) {
+    const startedAt = Date.now();
+    const options = parseInitArgs(args);
+    try {
+        if (options.help) {
+            console.log(renderInitHelp());
+            return 0;
+        }
+        await assertValidCwd(options.cwd);
+        const fingerprint = await detectProjectFingerprint({ cwd: options.cwd });
+        logFingerprintSummary(fingerprint);
+        const promptAdapter = dependencies.promptAdapter ?? createCliInitPromptAdapter();
+        const selectedMode = selectInitMode(options, fingerprint);
+        const cloudAssetClient = dependencies.cloudAssetClient ?? createDefaultCloudAssetClient();
+        const matchedContext = await resolveMatchedInitContext({
+            mode: selectedMode.mode,
+            fingerprint,
+            cloudAssetClient,
+        });
+        logMatchedInitContext(matchedContext);
+        const reviewResult = await promptAdapter.reviewMatchedInitConfig({
+            cwd: options.cwd,
+            mode: selectedMode.mode,
+            matched: matchedContext,
+        });
+        if (!reviewResult.confirmed) {
+            console.log(renderWarningBlock('初始化写入已取消', [], ['用户确认阶段选择取消，本次未写入文件。']));
+            return 0;
+        }
+        const effectiveMatchedContext = applyPackSelectionToMatchedContext(matchedContext, reviewResult.disabledPackIds);
+        if ((effectiveMatchedContext.cloudAssets ?? []).length === 0 && selectedMode.mode === 'template-match') {
+            throw new HarnessError('INIT_TEMPLATE_MATCH_MISS', 'No config packs remain selected after review.');
+        }
+        const baseAnswers = deriveInitAnswersFromMatchedContext(effectiveMatchedContext, fingerprint);
+        baseAnswers.mode = selectedMode.mode;
+        const answers = applyReviewTogglesToAnswers(baseAnswers, effectiveMatchedContext, {
+            useSkills: reviewResult.answers.useSkills,
+            includeRules: reviewResult.answers.includeRules,
+            bootstrapMcp: reviewResult.answers.bootstrapMcp,
+            syncSpec: reviewResult.answers.syncSpec,
+            generateReadme: reviewResult.answers.generateReadme,
+            enableRedaction: reviewResult.answers.enableRedaction,
+        });
+        const generatedPlan = generateInitArtifactPlan(fingerprint, answers);
+        const cloudHydratedPlan = await maybeHydratePlanFromCloudAssets({
+            mode: selectedMode,
+            options,
+            answers,
+            fingerprint,
+            initialPlan: generatedPlan,
+            matchedContext: effectiveMatchedContext,
+            disabledAssetKeys: reviewResult.disabledAssetKeys,
+            cloudAssetClient,
+        });
+        const assembledPlan = selectedMode.mode === 'local-manual'
+            ? await buildLocalManualPlan({
+                plan: cloudHydratedPlan,
+                answers,
+                fingerprint,
+                cwd: options.cwd,
+                cursorCliAdapter: dependencies.cursorCliAdapter ?? createDefaultCursorCliAdapter(),
+            })
+            : cloudHydratedPlan;
+        const registryCloudAssets = selectedMode.mode === 'template-match' || selectedMode.mode === 'cloud-auto'
+            ? filterCloudAssetsBySelection({
+                assets: effectiveMatchedContext.cloudAssets ?? [],
+                answers,
+                disabledAssetKeys: reviewResult.disabledAssetKeys,
+            })
+            : [];
+        const plan = appendCursorAssetManifest(assembledPlan, registryCloudAssets, effectiveMatchedContext);
+        await tryRenderCloudPreview({
+            mode: selectedMode,
+            options,
+            plan,
+            cloudInitAdapter: dependencies.cloudInitAdapter ?? createDefaultCloudInitAdapter(),
+        });
+        logModePreflight(selectedMode, plan);
+        logPlannedArtifactList(plan);
+        await logLocalDiffPreview(options.cwd, plan);
+        if (options.dryRun) {
+            console.log(renderSuccessBlock('初始化 Dry Run 完成', [
+                ['目录', options.cwd],
+                ['创建', plan.summary.create],
+                ['更新', plan.summary.update],
+                ['跳过', plan.summary.skip],
+            ]));
+            return 0;
+        }
+        const writeResult = await applyInitArtifactPlan(plan, {
+            cwd: options.cwd,
+            allowUpdates: false,
+        });
+        logAppliedArtifactList(writeResult);
+        console.log(renderSuccessBlock('初始化完成', [
+            ['目录', options.cwd],
+            ['创建', writeResult.summary.create],
+            ['更新', writeResult.summary.update],
+            ['跳过', writeResult.summary.skip],
+        ]));
+        return 0;
+    }
+    finally {
+        const durationMs = Date.now() - startedAt;
+        const budgetMs = 5_000;
+        const debugLine = renderDebugBoundary('init', durationMs, budgetMs);
+        if (debugLine) {
+            console.log(debugLine);
+        }
+    }
+}
+export function registerInitCommand(router, dependencies = {}) {
+    router.register('init', (args) => runInitCommand(args, dependencies));
+}
+export { renderInitHelp };
+//# sourceMappingURL=command.js.map