svharness 0.8.0

package/dist/commands/apply.js

@@ -0,0 +1,272 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runApply = runApply;
+const fs_extra_1 = __importDefault(require("fs-extra"));
+const node_path_1 = __importDefault(require("node:path"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const prompts_1 = __importDefault(require("prompts"));
+const adapters_1 = require("../adapters");
+const validate_args_1 = require("../utils/validate-args");
+const logger_1 = require("../utils/logger");
+const version_1 = require("../utils/version");
+const DISPATCHER_SKILL_NAME = 'harness-apply-skills-main';
+/**
+ * Resolve the absolute path to the bundled templates/ directory.
+ * At runtime __dirname is dist/commands, so templates are at ../../templates.
+ */
+function resolveTemplatesRoot() {
+    return node_path_1.default.resolve(__dirname, '..', '..', 'templates');
+}
+/**
+ * Read the agent id from `<harness>/.harness-build-state.yaml`. Returns
+ * undefined when the state file is missing or malformed.
+ */
+async function readAgentFromState(harnessRoot) {
+    const stateFile = node_path_1.default.join(harnessRoot, '.harness-build-state.yaml');
+    if (!(await fs_extra_1.default.pathExists(stateFile)))
+        return undefined;
+    try {
+        const raw = await fs_extra_1.default.readFile(stateFile, 'utf8');
+        const parsed = js_yaml_1.default.load(raw);
+        const agent = parsed?.agent?.trim();
+        if (!agent)
+            return undefined;
+        if (!(0, validate_args_1.listSupportedAgents)().includes(agent))
+            return undefined;
+        return agent;
+    }
+    catch (err) {
+        logger_1.logger.debug(`failed to read agent from state: ${err.message}`);
+        return undefined;
+    }
+}
+/**
+ * Read `<harness>/VERSION` if present. Falls back to 'unknown'.
+ */
+async function readHarnessVersion(harnessRoot) {
+    const versionFile = node_path_1.default.join(harnessRoot, 'VERSION');
+    if (!(await fs_extra_1.default.pathExists(versionFile)))
+        return 'unknown';
+    try {
+        const raw = (await fs_extra_1.default.readFile(versionFile, 'utf8')).trim();
+        return raw || 'unknown';
+    }
+    catch {
+        return 'unknown';
+    }
+}
+/**
+ * Derive the harness project name from the harness directory.
+ * `<name>-harness` → `<name>`; otherwise fall back to basename.
+ */
+function deriveHarnessName(harnessRoot) {
+    const base = node_path_1.default.basename(harnessRoot);
+    return base.endsWith('-harness') ? base.slice(0, -'-harness'.length) : base;
+}
+/**
+ * Entry point for `svharnessbuild apply`.
+ *
+ * Minimum-invasion binding: copies a single dispatcher skill
+ * (`harness-apply-skills-main/SKILL.{md|mdc}`) into the target project's
+ * agent-native skills directory. The skill carries the harness binding
+ * metadata **inlined into its own body** (`## 绑定元数据` section), so any
+ * agent can resolve `harness_root` purely from the skill's loaded content
+ * without depending on CWD or "same-directory" heuristics (scheme B).
+ *
+ * `references/binding.yaml` is still written as a redundant copy for
+ * `svharnessbuild`'s own tooling (status / detach / re-apply detection) —
+ * it is NOT the runtime source of truth.
+ */
+async function runApply(opts) {
+    (0, logger_1.setVerbose)(!!opts.verbose);
+    // 1. Resolve and validate harness directory.
+    if (!opts.harness) {
+        throw new Error('--harness <path> 是必填参数');
+    }
+    const harnessRoot = node_path_1.default.resolve(opts.harness);
+    if (!(await fs_extra_1.default.pathExists(harnessRoot))) {
+        throw new Error(`harness 目录不存在：${harnessRoot}`);
+    }
+    const stat = await fs_extra_1.default.stat(harnessRoot);
+    if (!stat.isDirectory()) {
+        throw new Error(`--harness 必须指向目录：${harnessRoot}`);
+    }
+    const agentEnvDir = node_path_1.default.join(harnessRoot, 'agent-env');
+    if (!(await fs_extra_1.default.pathExists(agentEnvDir))) {
+        throw new Error(`harness 目录下缺少 agent-env/：${agentEnvDir}\n  请确认该目录由 svharness build 生成。`);
+    }
+    // 2. Resolve target project root.
+    const cwd = opts.cwd ?? process.cwd();
+    const targetRoot = node_path_1.default.resolve(opts.target ?? cwd);
+    if (!(await fs_extra_1.default.pathExists(targetRoot))) {
+        throw new Error(`目标项目目录不存在：${targetRoot}`);
+    }
+    // 2b. Optional clone: copy the entire harness directory into the target
+    //     project root. After cloning, `effectiveHarnessRoot` points to the
+    //     cloned copy so binding.yaml resolves to the local path.
+    let effectiveHarnessRoot = harnessRoot;
+    const cloneMode = !!opts.clone;
+    const harnessDirName = node_path_1.default.basename(harnessRoot);
+    const cloneDest = node_path_1.default.join(targetRoot, harnessDirName);
+    if (cloneMode) {
+        // Guard: never copy a directory onto itself (would recurse forever).
+        const sameDir = node_path_1.default.resolve(cloneDest).toLowerCase() ===
+            node_path_1.default.resolve(harnessRoot).toLowerCase();
+        if (sameDir) {
+            logger_1.logger.warn(`源 harness 与克隆目标路径相同，跳过拷贝：${cloneDest}`);
+        }
+        else {
+            effectiveHarnessRoot = cloneDest;
+        }
+    }
+    // 3. Resolve agent (explicit > state file).
+    let agent = opts.agent;
+    if (!agent) {
+        agent = await readAgentFromState(harnessRoot);
+        if (agent) {
+            logger_1.logger.info(`从 harness 状态文件读取 agent：${agent}`);
+        }
+    }
+    if (!agent) {
+        throw new Error('无法推断目标 agent。请显式传入 --agent <codechat|qoder|cursor|claude-code|generic>，' +
+            '或确认 harness 下存在 .harness-build-state.yaml。');
+    }
+    const adapter = (0, adapters_1.getAdapter)(agent);
+    // 4. Compute injection target.
+    const skillsBaseDir = node_path_1.default.join(targetRoot, adapter.skillsDir);
+    const dispatcherDir = node_path_1.default.join(skillsBaseDir, DISPATCHER_SKILL_NAME);
+    const skillFile = node_path_1.default.join(dispatcherDir, 'SKILL' + adapter.skillExt);
+    const bindingFile = node_path_1.default.join(dispatcherDir, 'references', 'binding.yaml');
+    // 5. Load dispatcher skill template.
+    const templatePath = node_path_1.default.join(resolveTemplatesRoot(), '_shared', 'apply-skills', `${DISPATCHER_SKILL_NAME}.md`);
+    if (!(await fs_extra_1.default.pathExists(templatePath))) {
+        throw new Error(`dispatcher skill 模板缺失：${templatePath}`);
+    }
+    const harnessName = deriveHarnessName(harnessRoot);
+    const harnessVersion = await readHarnessVersion(harnessRoot);
+    // harness_root / harness_root_rel are always computed against the
+    // effective (possibly cloned) location, so agents always resolve to the
+    // on-disk harness the user actually has.
+    const harnessRootRel = node_path_1.default.relative(targetRoot, effectiveHarnessRoot).replace(/\\/g, '/') || '.';
+    const cliVersion = (0, version_1.getCliVersion)();
+    const appliedAt = new Date().toISOString();
+    // 6. Confirm (unless --yes).
+    const configRows = [
+        { label: 'harness 源路径', value: harnessRoot },
+        { label: 'harness 名称', value: harnessName },
+        { label: 'harness 版本', value: harnessVersion },
+        { label: '目标项目', value: targetRoot },
+        { label: 'agent', value: agent },
+        { label: '模式', value: cloneMode ? 'clone（拷贝整个 harness 到目标项目）' : 'bind-only（仅绑定，不拷贝）' },
+    ];
+    if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
+        configRows.push({ label: '克隆目标', value: effectiveHarnessRoot });
+    }
+    configRows.push({ label: '注入 skill', value: node_path_1.default.relative(targetRoot, skillFile) }, { label: '绑定元数据（冗余副本）', value: node_path_1.default.relative(targetRoot, bindingFile) }, { label: '工具版本', value: `svharness@${cliVersion}` });
+    logger_1.logger.configBox('apply 配置确认', configRows);
+    if (!opts.yes) {
+        const { ok } = await (0, prompts_1.default)({
+            type: 'confirm',
+            name: 'ok',
+            message: '确认把以上 harness 绑定到该项目？',
+            initial: true,
+        });
+        if (!ok) {
+            logger_1.logger.warn('用户取消');
+            return;
+        }
+    }
+    // 7. Guard against overwrite.
+    if (await fs_extra_1.default.pathExists(dispatcherDir)) {
+        if (!opts.force) {
+            throw new Error(`目标 skill 目录已存在：${dispatcherDir}\n  使用 --force 覆盖，或先执行 svharness detach（暂未实现：可手动删除该目录）。`);
+        }
+        logger_1.logger.warn(`--force 生效，删除已有 ${dispatcherDir}`);
+        await fs_extra_1.default.remove(dispatcherDir);
+    }
+    // 7b. Clone step — copy the whole harness into the target project first,
+    //     so subsequent skill injection and binding resolve to the local copy.
+    const totalSteps = cloneMode && effectiveHarnessRoot !== harnessRoot ? 3 : 2;
+    let stepNo = 1;
+    if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
+        logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 克隆 harness 到目标项目`);
+        if (await fs_extra_1.default.pathExists(cloneDest)) {
+            if (!opts.force) {
+                throw new Error(`克隆目标已存在：${cloneDest}\n  使用 --force 覆盖，或改用 bind-only（去掉 --clone）。`);
+            }
+            logger_1.logger.warn(`--force 生效，删除已有 ${cloneDest}`);
+            await fs_extra_1.default.remove(cloneDest);
+        }
+        await fs_extra_1.default.copy(harnessRoot, cloneDest, {
+            overwrite: true,
+            errorOnExist: false,
+        });
+        logger_1.logger.success(`已克隆 harness：${node_path_1.default.relative(targetRoot, cloneDest)}`);
+        stepNo++;
+    }
+    // 8. Build binding metadata first (needed for both inline rendering into
+    //    the skill body and the redundant sidecar file).
+    const binding = {
+        harness_name: harnessName,
+        harness_root: effectiveHarnessRoot,
+        harness_root_rel: harnessRootRel,
+        harness_version: harnessVersion,
+        target_project: targetRoot,
+        agent,
+        mode: cloneMode ? 'clone' : 'bind-only',
+        applied_at: appliedAt,
+        applied_by: `svharness@${cliVersion}`,
+    };
+    const bindingYaml = '# Generated by `svharness apply`. DO NOT edit by hand.\n' +
+        '# Re-run `svharness apply --force` to refresh.\n' +
+        js_yaml_1.default.dump(binding, { lineWidth: 120, noRefs: true });
+    // 8b. Write skill content with binding inlined into the template body
+    //     (agent-specific transform keeps frontmatter rules consistent across
+    //     IDEs). The inlined `## 绑定元数据` block is the runtime source of
+    //     truth — agents parse it from the skill content itself, never from
+    //     the sidecar file.
+    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 注入 dispatcher skill`);
+    const rawSkill = await fs_extra_1.default.readFile(templatePath, 'utf8');
+    const bindingPlaceholder = '{{BINDING_YAML_BLOCK}}';
+    if (!rawSkill.includes(bindingPlaceholder)) {
+        throw new Error(`dispatcher skill 模板缺少占位符 ${bindingPlaceholder}：${templatePath}\n` +
+            '  请升级 svharness 到同时包含内联 binding 机制的版本。');
+    }
+    const bindingBlock = '```yaml\n' +
+        js_yaml_1.default.dump(binding, { lineWidth: 120, noRefs: true }).trimEnd() +
+        '\n```';
+    const renderedSkill = rawSkill.replace(bindingPlaceholder, bindingBlock);
+    const skillContent = adapter.transform
+        ? adapter.transform(renderedSkill, `${DISPATCHER_SKILL_NAME}.md`)
+        : renderedSkill;
+    await fs_extra_1.default.ensureDir(dispatcherDir);
+    await fs_extra_1.default.outputFile(skillFile, skillContent, 'utf8');
+    logger_1.logger.success(`已写入 ${node_path_1.default.relative(targetRoot, skillFile)}`);
+    stepNo++;
+    // 9. Write binding.yaml as a redundant sidecar copy (scheme B tooling:
+    //    detach / status / re-apply detection). Runtime dispatcher does NOT
+    //    read this file — the authoritative source is the inlined block
+    //    written in step 8b.
+    logger_1.logger.section(`步骤 ${stepNo}/${totalSteps} - 写入 harness 绑定元数据（冗余副本）`);
+    await fs_extra_1.default.outputFile(bindingFile, bindingYaml, 'utf8');
+    logger_1.logger.success(`已写入 ${node_path_1.default.relative(targetRoot, bindingFile)}（冗余副本）`);
+    // 10. Next steps hint.
+    logger_1.logger.plain('');
+    logger_1.logger.plain('✨ harness 已绑定到当前项目');
+    logger_1.logger.plain('');
+    logger_1.logger.plain('  下一步：在 agent 中输入');
+    logger_1.logger.plain(`    应用 ${DISPATCHER_SKILL_NAME} 完成 <你的功能> 功能开发`);
+    logger_1.logger.plain('');
+    if (cloneMode && effectiveHarnessRoot !== harnessRoot) {
+        logger_1.logger.plain(`  harness 内容已克隆至：${node_path_1.default.relative(targetRoot, effectiveHarnessRoot)}/（已纳入目标项目）`);
+        logger_1.logger.plain(`  源 harness 仍保留在：${harnessRoot}（可独立演进后再次 apply --clone --force 更新）`);
+    }
+    else {
+        logger_1.logger.plain(`  harness 内容仍位于：${harnessRoot}（未拷贝；如需完整内聚请加 --clone）`);
+    }
+    logger_1.logger.plain(`  解绑命令：手动删除 ${node_path_1.default.relative(targetRoot, dispatcherDir)}`);
+    logger_1.logger.plain('');
+}