sdd-flow-kit 1.0.16 → 1.0.22

package/README.md

@@ -15,9 +15,12 @@
 
 1.  进入你要开发的项目目录
 2.  安装：`pnpm add -D sdd-flow-kit `
-    检查是否安装  - `ls .cursor/skills/sdd-flow-kit/SKILL.md`
-    - `ls .claude/skills/sdd-flow-kit/SKILL.md`
-    - `ls docs/*-doc-skill/SKILL.md`
+    检查是否安装（Cursor 用户看 `.cursor`，不是 `.claude`）：
+    - `ls .cursor/skills/sdd-flow-kit/SKILL.md`
+    - `ls docs/adi-doc-skill/SKILL.md`（adInsight 应为 **adi**，不是 oms）
+    - Claude Code 用户：`ls .claude/skills/sdd-flow-kit/SKILL.md`
+
+> 若在 `adInsight-web/frontend` 等子目录安装，工具会**向上识别**仓库名；仍不对时：`SDD_FLOW_KIT_PROJECT=ADI pnpm add -D sdd-flow-kit` 或 `npx sdd-flow-kit install --project ADI -y`
 3.  若 skill 未生成，执行手动兜底：
     - `node ./node_modules/sdd-flow-kit/dist/postinstall.js`（轻量，秒级）
     - 或 `npx sdd-flow-kit install -y`（完整环境）
@@ -61,6 +64,22 @@
 
 阶段口语（可选，非必须）：`继续` / `做提案` → propose；`开始 apply` → 实现。
 
+##### `/opsx-apply` 与 TDD + Playwright 检查机制
+
+| 环节 | 实现 | 说明 |
+|------|------|------|
+| 安装时 | `postinstall`（light） | 只写 sdd skill/rule；**不**自动跑 opsx-workflow（避免 `pnpm i` 卡住） |
+| 完整安装 | `npx sdd-flow-kit install -y` | 缺什么跑什么 → `ensureOpsxWorkflow` → `npx @lixin5257xxx/opsx-workflow setup` |
+| Apply 前 | `npx sdd-flow-kit ensure-opsx -y` | **阶段 D 第 0 步**；doctor 加 `--fix` 等价修复 |
+| Apply 时 | Cursor 读 skill 链 + `pnpm run opsx:delivery-pipeline` | 由 `AGENTS.md` / `06-agent-skill` 约束 AI，非 Node 自动执行 |
+
+```bash
+npx sdd-flow-kit ensure-opsx --agent cursor -y   # /opsx-apply 前
+npx sdd-flow-kit doctor --agent cursor --fix     # 检查并尝试修复
+```
+
+常见遗漏：只 `pnpm add sdd-flow-kit` 未跑 `ensure-opsx`；或 AI 跳过 skill 直接改代码。
+
 1.  `install`（等价 `setup`）：提示选择开发环境（cursor/claude-code/codex/openclaw，默认 claude-code）与开发分支（无则自动创建），并检测/安装 openspec+superpower 基础环境，同时写入项目级 Skill 与 Cursor 门禁规则
 2.  安装完成后，本工具主要负责“流程环境与模板”落地；业务需求由你在目标 AI 工具中自然语言驱动
 3.  `start`/`run`/`invoke` 属于进阶能力（脚本化或一键编排时使用）

package/dist/cli.js

@@ -41,7 +41,11 @@ function printHelp() {
         "   npx sdd-flow-kit invoke \"开发 XXX 1.2.3 需求\"",
         "",
         "5) 环境健检：",
-        "   npx sdd-flow-kit doctor --agent claude-code",
+        "   npx sdd-flow-kit doctor --agent cursor",
+        "",
+        "6) Apply 前确保 OPSX+TDD+Playwright（/opsx-apply 前必须）：",
+        "   npx sdd-flow-kit ensure-opsx --agent cursor -y",
+        "   （缺省时自动 npx @lixin5257xxx/opsx-workflow setup）",
         "",
         "可选参数：",
         "   --projectRoot <path>   目标项目根目录（默认当前目录）",
@@ -67,6 +71,7 @@ async function main() {
         cmd !== "setup" &&
         cmd !== "install" &&
         cmd !== "doctor" &&
+        cmd !== "ensure-opsx" &&
         cmd !== "invoke") {
         printHelp();
         node_process_1.default.exitCode = 1;
@@ -96,10 +101,16 @@ async function main() {
         node_process_1.default.exitCode = 1;
         return;
     }
-    if (cmd === "doctor") {
-        const doctor = await (0, doctor_1.runDoctor)({ projectRoot: node_path_1.default.resolve(projectRoot), agent });
+    if (cmd === "doctor" || cmd === "ensure-opsx") {
+        const fix = cmd === "ensure-opsx" || node_process_1.default.argv.includes("--fix");
+        const doctor = await (0, doctor_1.runDoctor)({
+            projectRoot: node_path_1.default.resolve(projectRoot),
+            agent,
+            fix,
+            dryRun,
+        });
         // eslint-disable-next-line no-console
-        console.log(`doctor=${doctor.ok ? "ok" : "failed"}, agent=${agent}`);
+        console.log(`${cmd}=${doctor.ok ? "ok" : "failed"}, agent=${agent}${fix ? ", fix=on" : ""}`);
         for (const check of doctor.checks) {
             // eslint-disable-next-line no-console
             console.log(`[${check.ok ? "OK" : "FAIL"}] ${check.name}: ${check.detail}`);
@@ -108,6 +119,15 @@ async function main() {
             // eslint-disable-next-line no-console
             console.log(JSON.stringify({ command: "doctor", projectRoot: node_path_1.default.resolve(projectRoot), result: doctor }, null, 2));
         }
+        if (cmd === "ensure-opsx" && !dryRun) {
+            await (0, setupProject_1.setupProject)({
+                projectRoot: node_path_1.default.resolve(projectRoot),
+                agent,
+                yes: true,
+                light: true,
+                projectKind: projectKind,
+            });
+        }
         if (!doctor.ok)
             node_process_1.default.exitCode = 1;
         return;

package/dist/core/inferProject.js

@@ -0,0 +1,152 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRODUCT_PREFIX_BY_KIND = exports.DOC_SKILL_BY_KIND = exports.ALLOWED_PROJECTS = void 0;
+exports.productToKind = productToKind;
+exports.resolveDocSkillDir = resolveDocSkillDir;
+exports.inferProjectKind = inferProjectKind;
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+exports.ALLOWED_PROJECTS = ["OMS", "ADI", "欢盟", "AD Tools"];
+exports.DOC_SKILL_BY_KIND = {
+    ADI: "adi-doc-skill",
+    OMS: "oms-doc-skill",
+    欢盟: "huan-doc-skill",
+    "AD Tools": "ad-tools-doc-skill",
+};
+exports.PRODUCT_PREFIX_BY_KIND = {
+    ADI: "ADI",
+    OMS: "OMS",
+    欢盟: "HUAN",
+    "AD Tools": "ADTOOLS",
+};
+function productToKind(product) {
+    const p = product.trim().toUpperCase();
+    if (p === "ADI" || p.includes("ADINSIGHT"))
+        return "ADI";
+    if (p === "OMS" || p.includes("OPERATION"))
+        return "OMS";
+    if (p === "欢盟" || p === "HUAN")
+        return "欢盟";
+    if (p.includes("AD TOOLS") || p === "ADTOOLS")
+        return "AD Tools";
+    return "OMS";
+}
+/** 从 projectRoot 向上查找 docs/*-doc-skill（适配 frontend 子目录 + 根目录 docs） */
+async function resolveDocSkillDir(projectRoot, kind) {
+    const dirName = exports.DOC_SKILL_BY_KIND[kind];
+    let cur = node_path_1.default.resolve(projectRoot);
+    for (let i = 0; i < 8; i += 1) {
+        const candidate = node_path_1.default.join(cur, "docs", dirName);
+        if (await pathExists(node_path_1.default.join(candidate, "confluence-doc.py"))) {
+            const rel = node_path_1.default.relative(projectRoot, candidate);
+            return {
+                absPath: candidate,
+                relFromRoot: rel.startsWith("..") ? rel : node_path_1.default.join("docs", dirName),
+            };
+        }
+        const parent = node_path_1.default.dirname(cur);
+        if (parent === cur)
+            break;
+        cur = parent;
+    }
+    return {
+        absPath: node_path_1.default.join(projectRoot, "docs", dirName),
+        relFromRoot: node_path_1.default.join("docs", dirName),
+    };
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function matchKindInText(text) {
+    const t = text.toLowerCase().replace(/_/g, "-");
+    if (t.includes("adinsight") || t.includes("adi-web") || /(^|\/|-)adi(-|\/|$)/.test(t)) {
+        return "ADI";
+    }
+    if (t.includes("operation-web") || t.includes("operation") || /(^|\/|-)oms(-|\/|$)/.test(t)) {
+        return "OMS";
+    }
+    if (t.includes("huan-union") || t.includes("huanunion") || /\bhm\b/.test(t)) {
+        return "欢盟";
+    }
+    if (t.includes("ad-tools") || t.includes("adtools")) {
+        return "AD Tools";
+    }
+    return null;
+}
+/** 从 projectRoot 向上查找已存在的 docs/*-doc-skill */
+async function inferFromExistingDocSkill(projectRoot) {
+    let dir = projectRoot;
+    for (let i = 0; i < 8; i += 1) {
+        for (const kind of exports.ALLOWED_PROJECTS) {
+            const rel = node_path_1.default.join(dir, "docs", exports.DOC_SKILL_BY_KIND[kind]);
+            if (await pathExists(node_path_1.default.join(rel, "SKILL.md"))) {
+                return kind;
+            }
+        }
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    return null;
+}
+/** 从目录路径（含父级）推断产品类型 */
+function inferFromPathSegments(projectRoot) {
+    const resolved = node_path_1.default.resolve(projectRoot);
+    const parts = resolved.split(node_path_1.default.sep);
+    for (let i = parts.length; i > 0; i -= 1) {
+        const segment = parts.slice(0, i).join(node_path_1.default.sep);
+        const hit = matchKindInText(segment);
+        if (hit)
+            return hit;
+    }
+    return null;
+}
+async function inferFromPackageJson(dir) {
+    try {
+        const pkgText = await promises_1.default.readFile(node_path_1.default.join(dir, "package.json"), "utf8");
+        const pkg = JSON.parse(pkgText);
+        const blob = `${pkg.name ?? ""} ${pkg.description ?? ""}`;
+        return matchKindInText(blob);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * 推断 OMS / ADI / 欢盟 / AD Tools。
+ *  monorepo 子目录（如 adInsight-web/frontend）会向上扫描路径，避免误判为 OMS。
+ */
+async function inferProjectKind(projectRoot) {
+    const fromEnv = (process.env.SDD_FLOW_KIT_PROJECT ?? "").trim();
+    if (exports.ALLOWED_PROJECTS.includes(fromEnv)) {
+        return fromEnv;
+    }
+    // 路径优先于已存在的 docs skill（避免 frontend 子目录曾误装 oms-doc-skill 后一直错下去）
+    const fromPath = inferFromPathSegments(projectRoot);
+    if (fromPath)
+        return fromPath;
+    let dir = projectRoot;
+    for (let i = 0; i < 6; i += 1) {
+        const fromPkg = await inferFromPackageJson(dir);
+        if (fromPkg)
+            return fromPkg;
+        const parent = node_path_1.default.dirname(dir);
+        if (parent === dir)
+            break;
+        dir = parent;
+    }
+    const fromExisting = await inferFromExistingDocSkill(projectRoot);
+    if (fromExisting)
+        return fromExisting;
+    return "OMS";
+}

package/dist/core/opsxDelivery.js

@@ -0,0 +1,248 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.deliveryPipelineNpmScripts = deliveryPipelineNpmScripts;
+exports.pathExists = pathExists;
+exports.resolveOpsxAgent = resolveOpsxAgent;
+exports.repairOpsxDeliveryScripts = repairOpsxDeliveryScripts;
+exports.buildOpsxWorkflowSetupCommand = buildOpsxWorkflowSetupCommand;
+exports.isOpsxApplyReady = isOpsxApplyReady;
+exports.ensureOpsxWorkflow = ensureOpsxWorkflow;
+exports.collectDeliverySetupChecks = collectDeliverySetupChecks;
+const node_child_process_1 = require("node:child_process");
+const promises_1 = __importDefault(require("node:fs/promises"));
+const node_path_1 = __importDefault(require("node:path"));
+const fs_1 = require("./fs");
+const DELIVERY_SCRIPT_REL = ".cursor/skills/opsx-dev-delivery-pipeline/scripts/opsx-delivery-pipeline.sh";
+function deliveryPipelineNpmScripts() {
+    const full = `bash ${DELIVERY_SCRIPT_REL}`;
+    const short = `OPSX_PIPELINE_MODE=short ${full}`;
+    return { full, short };
+}
+async function pathExists(filePath) {
+    try {
+        await promises_1.default.access(filePath);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** 优先使用已安装 OPSX skills 的 editor 目录 */
+async function resolveOpsxAgent(projectRoot, preferred) {
+    const deliverySkill = node_path_1.default.join(projectRoot, ".cursor", "skills", "opsx-dev-delivery-pipeline", "SKILL.md");
+    if (await pathExists(deliverySkill))
+        return "cursor";
+    const claudeDelivery = node_path_1.default.join(projectRoot, ".claude", "skills", "opsx-dev-delivery-pipeline", "SKILL.md");
+    if (await pathExists(claudeDelivery))
+        return "claude-code";
+    if (await pathExists(node_path_1.default.join(projectRoot, ".cursor")))
+        return "cursor";
+    if (await pathExists(node_path_1.default.join(projectRoot, ".claude")))
+        return "claude-code";
+    return preferred;
+}
+/** 将 package.json 中过期的 poquan-delivery-pipeline 脚本修正为 opsx-dev-delivery-pipeline */
+async function repairOpsxDeliveryScripts(projectRoot) {
+    const pkgPath = node_path_1.default.join(projectRoot, "package.json");
+    if (!(await pathExists(pkgPath)))
+        return false;
+    const scriptOnDisk = node_path_1.default.join(projectRoot, DELIVERY_SCRIPT_REL);
+    if (!(await pathExists(scriptOnDisk)))
+        return false;
+    const { full, short } = deliveryPipelineNpmScripts();
+    const text = await promises_1.default.readFile(pkgPath, "utf8");
+    const pkg = JSON.parse(text);
+    if (!pkg.scripts)
+        pkg.scripts = {};
+    let changed = false;
+    const needsFix = (v) => !v || v.includes("poquan-dev-delivery-pipeline") || v.includes("poquan-delivery-pipeline");
+    if (needsFix(pkg.scripts["opsx:delivery-pipeline"])) {
+        pkg.scripts["opsx:delivery-pipeline"] = full;
+        changed = true;
+    }
+    if (needsFix(pkg.scripts["opsx:delivery-pipeline:short"])) {
+        pkg.scripts["opsx:delivery-pipeline:short"] = short;
+        changed = true;
+    }
+    if (!changed)
+        return false;
+    await (0, fs_1.writeTextFileEnsuredDir)(pkgPath, `${JSON.stringify(pkg, null, 2)}\n`);
+    return true;
+}
+function hasCommand(cmd) {
+    return (0, node_child_process_1.spawnSync)("which", [cmd], { stdio: "ignore" }).status === 0;
+}
+function buildOpsxWorkflowSetupCommand(projectRoot, agent) {
+    const baseArgs = ["@lixin5257xxx/opsx-workflow", "setup"];
+    if (agent === "cursor") {
+        return {
+            cmd: "npx",
+            args: [...baseArgs, "--editor", "cursor", "--project", projectRoot, "-y"],
+        };
+    }
+    if (agent === "claude-code") {
+        return { cmd: "npx", args: [...baseArgs, "--editor", "claude-code", "-y"] };
+    }
+    if (agent === "openclaw") {
+        return { cmd: "npx", args: [...baseArgs, "--editor", "openclaw", "-y"] };
+    }
+    return { cmd: "npx", args: [...baseArgs, "--editor", "codex", "-y"] };
+}
+async function isOpsxApplyReady(projectRoot) {
+    const checks = await collectDeliverySetupChecks(projectRoot);
+    return checks.every((c) => c.ok);
+}
+/** 缺 openspec/TDD/Playwright 工作流时安装 @lixin5257xxx/opsx-workflow，并修复 delivery 脚本 */
+async function ensureOpsxWorkflow(options) {
+    const plannedActions = [];
+    let checks = await collectDeliverySetupChecks(options.projectRoot);
+    if (checks.every((c) => c.ok)) {
+        return {
+            ready: true,
+            workflowInstalled: false,
+            repairedScripts: false,
+            checks,
+            plannedActions,
+        };
+    }
+    const agent = await resolveOpsxAgent(options.projectRoot, options.agent);
+    const { cmd, args } = buildOpsxWorkflowSetupCommand(options.projectRoot, agent);
+    plannedActions.push(`missing opsx apply stack → run: ${cmd} ${args.join(" ")}`);
+    if (options.dryRun) {
+        return {
+            ready: false,
+            workflowInstalled: false,
+            repairedScripts: false,
+            checks,
+            plannedActions,
+        };
+    }
+    const ret = (0, node_child_process_1.spawnSync)(cmd, args, {
+        cwd: options.projectRoot,
+        stdio: "inherit",
+        env: process.env,
+    });
+    if (ret.status !== 0) {
+        throw new Error(`opsx-workflow 安装失败：${cmd} ${args.join(" ")}`);
+    }
+    const repairedScripts = await repairOpsxDeliveryScripts(options.projectRoot);
+    if (repairedScripts) {
+        plannedActions.push("repaired package.json opsx:delivery-pipeline scripts");
+    }
+    checks = await collectDeliverySetupChecks(options.projectRoot);
+    return {
+        ready: checks.every((c) => c.ok),
+        workflowInstalled: true,
+        repairedScripts,
+        checks,
+        plannedActions,
+    };
+}
+async function collectDeliverySetupChecks(projectRoot) {
+    const checks = [];
+    checks.push({
+        name: "openspec-dir",
+        ok: await pathExists(node_path_1.default.join(projectRoot, "openspec")),
+        detail: "openspec/ 目录",
+    });
+    checks.push({
+        name: "openspec-cli",
+        ok: hasCommand("openspec"),
+        detail: "openspec CLI（npx openspec 或全局安装）",
+    });
+    const skillPath = node_path_1.default.join(projectRoot, ".cursor", "skills", "opsx-dev-delivery-pipeline", "SKILL.md");
+    checks.push({
+        name: "opsx-dev-delivery-pipeline-skill",
+        ok: await pathExists(skillPath),
+        detail: skillPath,
+    });
+    const tddPath = node_path_1.default.join(projectRoot, ".cursor", "skills", "tdd-script", "SKILL.md");
+    checks.push({
+        name: "tdd-script-skill",
+        ok: await pathExists(tddPath),
+        detail: tddPath,
+    });
+    const applyPath = node_path_1.default.join(projectRoot, ".cursor", "skills", "openspec-apply-change", "SKILL.md");
+    checks.push({
+        name: "openspec-apply-change-skill",
+        ok: await pathExists(applyPath),
+        detail: applyPath,
+    });
+    const pipelineScript = node_path_1.default.join(projectRoot, DELIVERY_SCRIPT_REL);
+    checks.push({
+        name: "delivery-pipeline-script",
+        ok: await pathExists(pipelineScript),
+        detail: pipelineScript,
+    });
+    try {
+        const pkgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8");
+        const pkg = JSON.parse(pkgText);
+        const cmd = pkg.scripts?.["opsx:delivery-pipeline"] ?? "";
+        const ok = cmd.includes("opsx-dev-delivery-pipeline") &&
+            cmd.includes("opsx-delivery-pipeline.sh") &&
+            !cmd.includes("poquan");
+        checks.push({
+            name: "package-json-delivery-script",
+            ok,
+            detail: ok ? cmd : `错误或缺失: ${cmd || "(empty)"}`,
+        });
+    }
+    catch {
+        checks.push({
+            name: "package-json-delivery-script",
+            ok: false,
+            detail: "无法读取 package.json",
+        });
+    }
+    try {
+        const cfgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, ".opsx", "config.json"), "utf8");
+        const cfg = JSON.parse(cfgText);
+        const skillsDir = cfg.skillsDir ?? "";
+        const hasCursorDelivery = await pathExists(node_path_1.default.join(projectRoot, ".cursor", "skills", "opsx-dev-delivery-pipeline", "SKILL.md"));
+        const nameOk = cfg.deliveryPipeline?.skillName === "opsx-dev-delivery-pipeline";
+        const dirOk = (hasCursorDelivery && skillsDir.includes(".cursor")) ||
+            (!hasCursorDelivery && (skillsDir.includes(".cursor") || skillsDir.includes(".claude")));
+        checks.push({
+            name: "opsx-config-skills-dir",
+            ok: nameOk && dirOk,
+            detail: hasCursorDelivery && !skillsDir.includes(".cursor")
+                ? `skills 在 .cursor 但 config 指向 ${skillsDir}，请 npx sdd-flow-kit install -y`
+                : `skillsDir=${skillsDir}, skillName=${cfg.deliveryPipeline?.skillName ?? ""}`,
+        });
+    }
+    catch {
+        checks.push({
+            name: "opsx-config",
+            ok: false,
+            detail: ".opsx/config.json 缺失",
+        });
+    }
+    try {
+        const pkgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8");
+        const pkg = JSON.parse(pkgText);
+        const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+        const hasPw = Boolean(deps["@playwright/test"] || deps.playwright);
+        checks.push({
+            name: "playwright-dependency",
+            ok: hasPw,
+            detail: hasPw ? "@playwright/test 或 playwright 已声明" : "package.json 缺少 Playwright 依赖",
+        });
+    }
+    catch {
+        checks.push({
+            name: "playwright-dependency",
+            ok: false,
+            detail: "无法读取 package.json 检查 Playwright",
+        });
+    }
+    const agentsMd = node_path_1.default.join(projectRoot, "AGENTS.md");
+    checks.push({
+        name: "agents-md",
+        ok: await pathExists(agentsMd),
+        detail: "AGENTS.md（Apply/TDD/pipeline 编排 SSOT）",
+    });
+    return checks;
+}

package/dist/postinstall.js

@@ -1,55 +1,55 @@
 "use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 var __importDefault = (this && this.__importDefault) || function (mod) {
     return (mod && mod.__esModule) ? mod : { "default": mod };
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 const node_path_1 = __importDefault(require("node:path"));
-const promises_1 = __importDefault(require("node:fs/promises"));
 const node_process_1 = __importDefault(require("node:process"));
+const inferProject_1 = require("./core/inferProject");
+const opsxDelivery_1 = require("./core/opsxDelivery");
 const setupProject_1 = require("./steps/setupProject");
-const ALLOWED_PROJECTS = ["OMS", "ADI", "欢盟", "AD Tools"];
-async function inferProjectKind(projectRoot) {
-    const fromEnv = (node_process_1.default.env.SDD_FLOW_KIT_PROJECT ?? "").trim();
-    if (ALLOWED_PROJECTS.includes(fromEnv)) {
-        return fromEnv;
-    }
-    const base = node_path_1.default.basename(projectRoot).toLowerCase();
-    const hit = (s) => base.includes(s);
-    if (hit("adi") || hit("adinsight"))
-        return "ADI";
-    if (hit("oms") || hit("operation"))
-        return "OMS";
-    if (hit("huan-union") || hit("hm"))
-        return "欢盟";
-    if (hit("ad-tools") || hit("adtools") || hit("tools"))
-        return "AD Tools";
-    try {
-        const pkgText = await promises_1.default.readFile(node_path_1.default.join(projectRoot, "package.json"), "utf8");
-        const pkg = JSON.parse(pkgText);
-        const name = (pkg.name ?? "").toLowerCase();
-        const has = (s) => name.includes(s);
-        if (has("adi") || has("adinsight"))
-            return "ADI";
-        if (has("oms") || has("operation"))
-            return "OMS";
-        if (has("huan-union") || has("hm"))
-            return "欢盟";
-        if (has("ad-tools") || has("adtools") || has("tools"))
-            return "AD Tools";
-    }
-    catch {
-        // ignore and fallback
-    }
-    return "OMS";
-}
 async function inferAgent(projectRoot) {
     const fromEnv = (node_process_1.default.env.SDD_FLOW_KIT_AGENT ?? "").trim();
     const allowed = ["cursor", "claude-code", "codex", "openclaw"];
     if (allowed.includes(fromEnv))
         return fromEnv;
+    const fs = await Promise.resolve().then(() => __importStar(require("node:fs/promises")));
     const exists = async (rel) => {
         try {
-            await promises_1.default.access(node_path_1.default.join(projectRoot, rel));
+            await fs.access(node_path_1.default.join(projectRoot, rel));
             return true;
         }
         catch {
@@ -75,7 +75,7 @@ async function main() {
     const projectRoot = initCwd ?? node_process_1.default.cwd();
     if (projectRoot === pkgDir)
         return;
-    const projectKind = await inferProjectKind(projectRoot);
+    const projectKind = await (0, inferProject_1.inferProjectKind)(projectRoot);
     const agent = await inferAgent(projectRoot);
     // eslint-disable-next-line no-console
     console.log(`[sdd-flow-kit] postinstall (light) at: ${projectRoot}`);
@@ -89,8 +89,26 @@ async function main() {
         dryRun: false,
         projectKind,
     });
+    const repaired = await (0, opsxDelivery_1.repairOpsxDeliveryScripts)(projectRoot);
+    if (repaired) {
+        // eslint-disable-next-line no-console
+        console.log("[sdd-flow-kit] repaired package.json opsx:delivery-pipeline scripts");
+    }
+    const ready = await (0, opsxDelivery_1.isOpsxApplyReady)(projectRoot);
+    if (!ready) {
+        // eslint-disable-next-line no-console
+        console.warn("[sdd-flow-kit] OPSX/TDD/Playwright 工作流未就绪。/opsx-apply 前请执行: npx sdd-flow-kit ensure-opsx -y");
+    }
+    else {
+        // eslint-disable-next-line no-console
+        console.log("[sdd-flow-kit] opsx apply stack ready");
+    }
     // eslint-disable-next-line no-console
-    console.log("[sdd-flow-kit] light setup done (skills/rules only). Full env: npx sdd-flow-kit install -y");
+    console.log("[sdd-flow-kit] light setup done (skills/rules). Full install: npx sdd-flow-kit install --project ADI -y");
+    if (agent === "cursor") {
+        // eslint-disable-next-line no-console
+        console.log("[sdd-flow-kit] Cursor skill: .cursor/skills/sdd-flow-kit/SKILL.md");
+    }
 }
 main().catch((err) => {
     // eslint-disable-next-line no-console

package/dist/steps/doctor.js

@@ -7,6 +7,7 @@ exports.runDoctor = runDoctor;
 const node_child_process_1 = require("node:child_process");
 const promises_1 = __importDefault(require("node:fs/promises"));
 const node_path_1 = __importDefault(require("node:path"));
+const opsxDelivery_1 = require("../core/opsxDelivery");
 function hasCommand(cmd) {
     const out = (0, node_child_process_1.spawnSync)("which", [cmd], { stdio: "ignore" });
     return out.status === 0;
@@ -71,6 +72,28 @@ async function runDoctor(options) {
             detail: `${expectedDir} 目录存在性`,
         });
     }
-    const ok = checks.every((c) => c.ok);
+    for (const c of await (0, opsxDelivery_1.collectDeliverySetupChecks)(options.projectRoot)) {
+        checks.push(c);
+    }
+    let ok = checks.every((c) => c.ok);
+    if (!ok && options.fix) {
+        const ensured = await (0, opsxDelivery_1.ensureOpsxWorkflow)({
+            projectRoot: options.projectRoot,
+            agent: options.agent,
+            dryRun: options.dryRun,
+        });
+        checks.length = 0;
+        for (const c of ensured.checks) {
+            checks.push(c);
+        }
+        if (ensured.plannedActions.length > 0) {
+            checks.push({
+                name: "ensure-opsx-actions",
+                ok: ensured.ready,
+                detail: ensured.plannedActions.join(" | "),
+            });
+        }
+        ok = checks.every((c) => c.ok);
+    }
     return { ok, checks };
 }