add-coder 0.3.16 → 0.3.19

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // src/cli/index.ts
-import { readFileSync as readFileSync8 } from "fs";
+import { readFileSync as readFileSync9 } from "fs";
 import { Command } from "commander";
 
 // src/caijuehub/strategies/detect.strategy.ts
@@ -63,6 +63,7 @@ var AddCoderConfigSchema = z.object({
   mcpServerCommand: z.string().default("tsx"),
   agentAuditImport: z.string().default("@/lib/agent-audit-logger"),
   magicDir: z.string(),
+  stack: z.string().optional(),
   adapters: z.array(AdapterEnum).default([]),
   overrides: z.record(z.string(), z.string()).default({})
 });
@@ -79,6 +80,7 @@ var defaults = {
   mcpServerCommand: "tsx",
   agentAuditImport: "@/lib/agent-audit-logger",
   magicDir: "",
+  stack: "",
   adapters: [],
   overrides: {}
 };
@@ -182,7 +184,7 @@ async function selectFiles(projectRoot, files) {
     process.stdout.write(renderList(items, selected, scrollIdx, VISIBLE));
   }
   draw();
-  return new Promise((resolve8) => {
+  return new Promise((resolve9) => {
     input.on("keypress", (_char, key) => {
       if (!key) return;
       if (key.name === "up") {
@@ -223,7 +225,7 @@ async function selectFiles(projectRoot, files) {
         if (selected.has(idx)) result.set(relPath, content);
         idx++;
       }
-      resolve8(result);
+      resolve9(result);
     });
   });
 }
@@ -314,7 +316,7 @@ var SYNC_PRISMA_CONFIG = {
       { label: "\u751F\u4EA7/CI\uFF08\u53EA\u5E94\u7528\u5DF2\u6709\u8FC1\u79FB\uFF09", cmd: "npx prisma migrate deploy" },
       { label: "\u4E0D\u786E\u5B9A\uFF1F\u5148\u67E5\u72B6\u6001", cmd: "npx prisma migrate status" }
     ],
-    P3005: { hint: "\u82E5\u62A5 P3005\uFF08\u5E93\u6709\u8868\u4F46\u65E0\u8FC1\u79FB\u8BB0\u5F55\uFF09= \u9700\u5148\u57FA\u7EBF\u5316:", cmd: "npx prisma migrate resolve --applied <\u8FC1\u79FB\u540D>\uFF0C\u518D\u6267\u884C deploy" },
+    P3005: { hint: "\u82E5\u62A5 P3005\uFF08\u5E93\u6709\u8868\u4F46\u65E0\u8FC1\u79FB\u8BB0\u5F55\uFF09= \u9700\u5148\u57FA\u7EBF\u5316:", cmd: "npx prisma migrate resolve --applied <\uFFFD\uFFFD\u79FB\u540D>\uFF0C\u518D\u6267\u884C deploy" },
     UNMANAGED_ACTIONS: [
       { label: "\u9996\u6B21\u63A5\u5165\u8FC1\u79FB\u7BA1\u7406\uFF08\u7A7A\u5E93\uFF09", cmd: "npx prisma migrate dev --name init" },
       { label: "\u5E93\u5DF2\u6709\u8868\uFF08db push \u5EFA\u8FC7\uFF09", hint: "\u5148\u624B\u52A8\u57FA\u7EBF\u5316\uFF0C\u518D deploy:", steps: ["npx prisma migrate diff --from-empty --to-schema-datamodel <schema\u6587\u4EF6> --script", "\u5C06\u8F93\u51FA\u5199\u5165 prisma/migrations/<\u65F6\u95F4\u6233>_init/migration.sql", "npx prisma migrate resolve --applied <\u65F6\u95F4\u6233>_init"] }
@@ -329,13 +331,34 @@ async function writeFiles2(projectRoot, files, options = {}) {
 }
 function parseSchemaBlocks(content) {
   const blocks = /* @__PURE__ */ new Map();
-  const blockRegex = /^(model|enum)\s+(\w+)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    const [, type, name, inner] = match;
+  const lines = content.split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const head = lines[i].match(/^(model|enum)\s+(\w+)\s*\{/);
+    if (!head) {
+      i++;
+      continue;
+    }
+    const type = head[1];
+    const name = head[2];
+    const bodyLines = [lines[i]];
+    let depth = 1;
+    let j = i + 1;
+    while (j < lines.length && depth > 0) {
+      const line = lines[j];
+      bodyLines.push(line);
+      const commentless = line.split("//")[0];
+      for (const ch of commentless) {
+        if (ch === "{") depth++;
+        else if (ch === "}") depth--;
+      }
+      j++;
+    }
+    const body = bodyLines.join("\n");
+    const inner = bodyLines.slice(1, -1).join("\n");
     let fields = [];
     if (type === "enum") {
-      fields = inner.split("\n").map((l) => l.replace(/#.*$/, "").trim()).filter((l) => l.length > 0);
+      fields = inner.split("\n").map((l) => l.replace(/\/\/.*$/, "").replace(/#.*$/, "").trim()).filter((l) => l.length > 0);
     } else {
       const fieldRegex = /^\s*(\w+)\s+(\w+(?:\([^)]*\))?(?:\[\])?\??)/gm;
       let fm;
@@ -343,7 +366,8 @@ function parseSchemaBlocks(content) {
         fields.push(`${fm[1]}:${fm[2]}`);
       }
     }
-    blocks.set(`${type}:${name}`, { type, name, body: match[0], fields });
+    blocks.set(`${type}:${name}`, { type, name, body, fields });
+    i = j;
   }
   return blocks;
 }
@@ -400,7 +424,7 @@ function diffPrisma(basePath, targetPath) {
 }
 
 // src/core/renderer.ts
-import { readFileSync as readFileSync4, readdirSync, statSync, existsSync as existsSync5 } from "fs";
+import { readFileSync as readFileSync4, readdirSync, statSync, existsSync as existsSync5, mkdirSync as mkdirSync2, writeFileSync as writeFileSync2 } from "fs";
 import { join as join4, relative, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 import { parse } from "smol-toml";
@@ -418,6 +442,24 @@ var PLACEHOLDERS = {
   "{{mcpServerCommand}}": "mcpServerCommand",
   "{{agentAuditImport}}": "agentAuditImport"
 };
+function renderStackPlaceholders(result, config) {
+  const stackName = config.stack || "\u672A\u8BBE\u7F6E";
+  const stackProfile = config.stack ? `${config.stack}-profile.md` : "\u672A\u8BBE\u7F6E";
+  let refLine;
+  if (config.stack) {
+    refLine = [
+      `\u672C\u9879\u76EE\u7684\u6280\u672F\u6808\u7EA6\u675F\u7531 \`${config.magicDir}/rules/profiles/${stackProfile}\` \u5B9A\u4E49\uFF08\u7531 \`add-coder stack set\` \u7BA1\u7406\uFF09\u3002`,
+      `- **\u5F53\u524D\u6280\u672F\u6808**: \`${stackName}\`\uFF08${stackProfile} \u5DF2\u751F\u6548\uFF0CAI \u5FC5\u987B\u9075\u5B88\u5176\u4E2D\u5168\u90E8\u7EA6\u675F\uFF09`
+    ].join("\n");
+  } else {
+    refLine = [
+      "\u672C\u9879\u76EE\u7684\u6280\u672F\u6808\u672A\u8BBE\u7F6E\uFF0C\u4E0D\u65BD\u52A0\u4EFB\u4F55\u6280\u672F\u6808\u5047\u8BBE\u3002",
+      "AI \u5FC5\u987B\u901A\u8FC7 `get_project_context` \u8BFB\u53D6\u9879\u76EE\u5B9E\u9645\u4EE3\u7801\u63A8\u65AD\u771F\u5B9E\u6280\u672F\u6808\uFF0C\u7981\u6B62\u5957\u7528\u6A21\u677F\u6216\u6848\u4F8B\u4E2D\u7684\u9ED8\u8BA4\u6280\u672F\u6808\u3002",
+      "\uFF08\u53EF\u7528 `add-coder stack set <name>` \u542F\u7528\u6280\u672F\u6808\u7EA6\u675F\uFF09"
+    ].join("\n");
+  }
+  return result.replaceAll("{{stackReferenceLine}}", refLine).replaceAll("{{stackName}}", stackName).replaceAll("{{stackProfile}}", stackProfile);
+}
 function loadDpsThresholds() {
   try {
     const candidates = [
@@ -455,12 +497,44 @@ function render(content, config) {
     result = result.replaceAll("{{dpsPass}}", thresholds.pass);
     result = result.replaceAll("{{dpsWarn}}", thresholds.warn);
   }
+  result = renderStackPlaceholders(result, config);
   return result;
 }
 var TEMPLATES_ROOT = join4(__dirname, "../templates");
 var CORE_DIR = join4(TEMPLATES_ROOT, "core");
 var CORE_TARGET = ".add";
-var SKIP_DIRS = /* @__PURE__ */ new Set(["prisma"]);
+var SKIP_DIRS = /* @__PURE__ */ new Set(["prisma", "profiles"]);
+function loadProfileRegistry() {
+  try {
+    const tomlPath = join4(CORE_DIR, "rules", "profiles", "index.toml");
+    if (!existsSync5(tomlPath)) return [];
+    const doc = parse(readFileSync4(tomlPath, "utf-8"));
+    return doc.profile || [];
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : String(e);
+    console.warn(`[renderer] profile \u6CE8\u518C\u8868\u8BFB\u53D6\u5931\u8D25: ${errorMessage}`);
+    return [];
+  }
+}
+function loadStack(projectRoot, magicDir) {
+  try {
+    const p = join4(projectRoot, magicDir, "stack.json");
+    if (!existsSync5(p)) return "";
+    const doc = JSON.parse(readFileSync4(p, "utf-8"));
+    return typeof doc.stack === "string" ? doc.stack : "";
+  } catch {
+    return "";
+  }
+}
+function saveStack(projectRoot, magicDir, stack) {
+  const dir = join4(projectRoot, magicDir);
+  mkdirSync2(dir, { recursive: true });
+  writeFileSync2(
+    join4(dir, "stack.json"),
+    JSON.stringify({ stack, updatedAt: (/* @__PURE__ */ new Date()).toISOString() }, null, 2),
+    "utf-8"
+  );
+}
 function renderCore(config, dryRun) {
   const files = /* @__PURE__ */ new Map();
   function walk(dir, base) {
@@ -480,6 +554,17 @@ function renderCore(config, dryRun) {
     }
   }
   walk(CORE_DIR, "");
+  if (config.stack) {
+    const registry = loadProfileRegistry();
+    const profile = registry.find((p) => p.name === config.stack);
+    if (profile) {
+      const src = join4(CORE_DIR, "rules", "profiles", profile.file);
+      if (existsSync5(src)) {
+        const rendered = render(readFileSync4(src, "utf-8"), config);
+        files.set(join4(".add", "rules", "profiles", profile.file), rendered);
+      }
+    }
+  }
   if (dryRun) {
     console.log(`[dry-run] Core templates: ${files.size} files`);
   }
@@ -565,7 +650,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/caijuehub/strategies/prisma.strategy.ts
 import { spawnSync } from "child_process";
-import { copyFileSync, existsSync as existsSync7, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync7, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync3, mkdirSync as mkdirSync3 } from "fs";
 import { resolve as resolve3 } from "path";
 var PRISMA_CONFIG = {
   onMissing: "ask",
@@ -578,7 +663,7 @@ var PRISMA_CONFIG = {
 };
 function ensurePrismaConfig(projectRoot) {
   const configPath = resolve3(projectRoot, "prisma.config.ts");
-  writeFileSync2(configPath, [
+  writeFileSync3(configPath, [
     'import dotenv from "dotenv";',
     'import { existsSync } from "fs";',
     'for (const f of [".env.development.local", ".env.development", ".env.local", ".env"]) {',
@@ -603,7 +688,7 @@ function backupAddTables(projectRoot) {
     timeout: 3e4
   });
   if (r.stdout.length > 0) {
-    writeFileSync2(bak, r.stdout, "utf-8");
+    writeFileSync3(bak, r.stdout, "utf-8");
     console.log(`>>> \u5907\u4EFD ADD \u8868\u5230 ${bak}`);
     return bak;
   }
@@ -621,7 +706,7 @@ function runPrismaInit(projectRoot, provider, schemaPath) {
   if (initResult.status !== 0 || !existsSync7(schemaPath)) {
     console.log("prisma init \u5931\u8D25\uFF0C\u624B\u52A8\u521B\u5EFA schema.prisma ...");
     const prismaDir = resolve3(projectRoot, "prisma");
-    if (!existsSync7(prismaDir)) mkdirSync2(prismaDir, { recursive: true });
+    if (!existsSync7(prismaDir)) mkdirSync3(prismaDir, { recursive: true });
     const content = `generator client {
   provider = "prisma-client-js"
 }
@@ -630,11 +715,11 @@ datasource db {
   provider = "${provider}"
 }
 `;
-    writeFileSync2(schemaPath, content, "utf-8");
+    writeFileSync3(schemaPath, content, "utf-8");
     const devEnvPath = resolve3(projectRoot, ".env.development");
     if (!existsSync7(devEnvPath)) {
       const defaultUrl = provider === "sqlite" ? 'DATABASE_URL="file:./data/dev.db"' : '# \u8BF7\u7F16\u8F91\u4E3A\u4F60\u7684\u6570\u636E\u5E93\u8FDE\u63A5\u4FE1\u606F\nDATABASE_URL="postgresql://USER:PASSWORD@HOST:PORT/DB?schema=public"';
-      writeFileSync2(devEnvPath, defaultUrl + "\n", "utf-8");
+      writeFileSync3(devEnvPath, defaultUrl + "\n", "utf-8");
       console.log("\u5DF2\u521B\u5EFA .env.development");
     }
     return false;
@@ -650,7 +735,7 @@ function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
     if (dbUrl) {
       const existing = existsSync7(devEnvPath) ? readFileSync5(devEnvPath, "utf-8") : "";
       if (!existing.includes("DATABASE_URL=")) {
-        writeFileSync2(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
+        writeFileSync3(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
 `, "utf-8");
       }
       if (existsSync7(envPath)) unlinkSync(envPath);
@@ -758,7 +843,7 @@ async function injectPrisma2(projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync8, mkdirSync as mkdirSync3, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync4, existsSync as existsSync8, mkdirSync as mkdirSync4, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
 import { createHash } from "crypto";
 import { resolve as resolve5 } from "path";
 import { spawnSync as spawnSync2 } from "child_process";
@@ -774,6 +859,12 @@ var MAGIC_DIR_MAP = { claude: ".claude", qoder: ".qoder", vscode: ".vscode", tra
 async function initCommand(options) {
   const ctx = await prepare(options);
   writeComposeEnv(ctx);
+  if (!options.dryRun) {
+    saveStack(ctx.projectRoot, ctx.magicDir, ctx.stack);
+    if (ctx.stack) console.log(`\u6280\u672F\u6808\u72B6\u6001\u5DF2\u5199\u5165 ${ctx.magicDir}/stack.json \u2192 ${ctx.stack}`);
+  } else if (ctx.stack) {
+    console.log(`[dry-run] \u5C06\u5199\u5165 ${ctx.magicDir}/stack.json \u2192 ${ctx.stack}`);
+  }
   const result = await renderAndWrite(ctx);
   await deployDatabase(ctx);
   deployDocs(ctx);
@@ -791,10 +882,12 @@ async function resolveAdapter(projectRoot, specified) {
     return detected;
   }
   console.log("\u672A\u68C0\u6D4B\u5230 IDE \u73AF\u5883");
-  const a = (await ask("\u8BF7\u9009\u62E9\u76EE\u6807 IDE: [1] Qoder  [2] Claude  [3] VS Code \u2192 ")).trim();
+  const a = (await ask("\u8BF7\u9009\u62E9\u76EE\u6807 IDE: [1] Qoder  [2] Claude  [3] VS Code  [4] Trae  [5] Codex \u2192 ")).trim();
   if (a === "1" || a === "qoder") return "qoder";
   if (a === "2" || a === "claude") return "claude";
   if (a === "3" || a === "vscode") return "vscode";
+  if (a === "4" || a === "trae") return "trae";
+  if (a === "5" || a === "codex") return "codex";
   console.log("\u8F93\u5165\u65E0\u6CD5\u8BC6\u522B\uFF0C\u9ED8\u8BA4 qoder");
   return "qoder";
 }
@@ -938,8 +1031,8 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync8(scriptsDir)) mkdirSync3(scriptsDir, { recursive: true });
-  writeFileSync3(scriptPath, content, "utf-8");
+  if (!existsSync8(scriptsDir)) mkdirSync4(scriptsDir, { recursive: true });
+  writeFileSync4(scriptPath, content, "utf-8");
   console.log("\u5DF2\u751F\u6210 scripts/export-db.ts");
 }
 function injectDbExportScript(projectRoot, dryRun) {
@@ -953,10 +1046,26 @@ function injectDbExportScript(projectRoot, dryRun) {
   if (!pkg.scripts) pkg.scripts = {};
   if (!pkg.scripts["db:export"]) {
     pkg.scripts["db:export"] = "npx tsx scripts/export-db.ts";
-    writeFileSync3(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
+    writeFileSync4(pkgPath, JSON.stringify(pkg, null, 2) + "\n", "utf-8");
     console.log("\u5DF2\u5728 package.json \u6CE8\u5165 db:export");
   }
 }
+async function resolveStack(options) {
+  if (options.stack) {
+    console.log(`\u6280\u672F\u6808\u7EA6\u675F: ${options.stack} (--stack)`);
+    return options.stack;
+  }
+  if (options.force) return "";
+  console.log(["", "\u6280\u672F\u6808\u7EA6\u675F\uFF08\u53EF\u9009\uFF09:", "  [1] \u4E0D\u8BBE\u7F6E\uFF08\u4E2D\u6027\uFF0C\u63A8\u8350\uFF09", "  [2] webapp", "  [3] machineserver", "  [4] \u81EA\u5B9A\u4E49\uFF08\u8F93\u5165 profile \u540D\uFF09"].join("\n"));
+  const a = (await ask("\u8BF7\u9009\u62E9 [1/2/3/4] \u2192 ")).trim();
+  if (a === "2" || a === "webapp") return "webapp";
+  if (a === "3" || a === "machineserver") return "machineserver";
+  if (a === "4" || a === "custom") {
+    const name = (await ask("\u81EA\u5B9A\u4E49 profile \u540D\uFF08\u9700\u5DF2\u5728 .qoder/rules/profiles/ \u5B58\u5728\uFF09: ")).trim();
+    return name || "";
+  }
+  return "";
+}
 async function prepare(options) {
   const projectRoot = process.cwd();
   const target = await resolveAdapter(projectRoot, options.adapter);
@@ -964,6 +1073,8 @@ async function prepare(options) {
   const config = await loadConfig(projectRoot, options.config, { force: options.force });
   config.projectRoot = projectRoot;
   config.magicDir = magicDir;
+  const stack = await resolveStack(options);
+  config.stack = stack;
   const db = await resolveDbEngine(!!options.force);
   if (db.engine === "postgresql") {
     db.container = await resolveContainer(!!options.force);
@@ -971,7 +1082,7 @@ async function prepare(options) {
       Object.assign(db, await resolveDbCredentials(!!options.force));
     }
   }
-  return { projectRoot, options, target, magicDir, config, db };
+  return { projectRoot, options, target, magicDir, config, db, stack };
 }
 function writeComposeEnv(ctx) {
   const { projectRoot, options, config, db } = ctx;
@@ -980,7 +1091,7 @@ function writeComposeEnv(ctx) {
     const composeName = db.container === "podman" ? "podman-compose.add.yml" : "docker-compose.add.yml";
     const composePath = resolve5(projectRoot, composeName);
     if (!options.dryRun && (!existsSync8(composePath) || options.force)) {
-      writeFileSync3(composePath, composeContent(config.projectName || "add-project"), "utf-8");
+      writeFileSync4(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
@@ -988,7 +1099,7 @@ function writeComposeEnv(ctx) {
   if (!options.dryRun && existsSync8(devEnvPath)) {
     const existing = readFileSync6(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
-      writeFileSync3(devEnvPath, existing + `
+      writeFileSync4(devEnvPath, existing + `
 DATABASE_USER=${db.user || "admin"}
 DATABASE_PASSWORD=${db.password || "change-me-in-production"}
 DATABASE_PORT=${db.port || "5433"}
@@ -1030,7 +1141,7 @@ async function renderAndWrite(ctx) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
-        mkdirSync3(reviewsDir, { recursive: true });
+        mkdirSync4(reviewsDir, { recursive: true });
       }
     }
   }
@@ -1045,9 +1156,9 @@ async function renderAndWrite(ctx) {
       hashMap[rp] = createHash("sha256").update(c).digest("hex").slice(0, 8);
     }
     const hashOut = resolve5(projectRoot, magicDir, ".add-coder-hash.json");
-    writeFileSync3(hashOut, JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
+    writeFileSync4(hashOut, JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
     if (npmVer) {
-      writeFileSync3(resolve5(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
+      writeFileSync4(resolve5(projectRoot, magicDir, ".add-coder-version"), npmVer + "\n", "utf-8");
     }
     console.log(`hash: ${Object.keys(hashMap).length} entries \u2192 ${magicDir}/.add-coder-hash.json`);
   }
@@ -1111,7 +1222,7 @@ function deployDocs(ctx) {
   for (const d of ["00-\u9700\u6C42", "01-\u67B6\u6784", "02-\u89C4\u8303"]) {
     const srcDir = resolve5(groundingSrc, d);
     const destDir = resolve5(docsBase, d);
-    if (!existsSync8(destDir)) mkdirSync3(destDir, { recursive: true });
+    if (!existsSync8(destDir)) mkdirSync4(destDir, { recursive: true });
     if (!existsSync8(srcDir)) continue;
     for (const f of readdirSync2(srcDir)) {
       const src = resolve5(srcDir, f);
@@ -1144,13 +1255,13 @@ function finalize(ctx, result) {
 }
 
 // src/cli/commands/sync.ts
-import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync4, mkdirSync as mkdirSync4 } from "fs";
+import { existsSync as existsSync9, readFileSync as readFileSync7, writeFileSync as writeFileSync5, mkdirSync as mkdirSync5 } from "fs";
 import { resolve as resolve6, dirname as dirname4 } from "path";
 import { createHash as createHash2 } from "crypto";
 
 // src/caijuehub/strategies/sync.strategy.ts
 var SYNC_CONFIG = {
-  PATCH_GUARD: [/[/]plans[/]/, /[/]specs[/]/, /[/]reviews[/]/],
+  PATCH_GUARD: [/[/]plans[/]/, /[/]specs[/]/, /[/]reviews[/]/, /[/]rules[/]profiles[/]/],
   HASH_OUTPUT_FILE: ".add-coder-hash.json",
   HASH_SRC_FILE: "templates/.add-coder-src-hash.json",
   HASH_HEX_LENGTH: 8,
@@ -1211,12 +1322,12 @@ function loadVersionFile(root, magic) {
   }
 }
 function saveVersionFile(root, magic, version2) {
-  writeFileSync4(resolve6(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
+  writeFileSync5(resolve6(root, magic, SYNC_CONFIG.VERSION_SENTINEL), version2 + "\n", "utf-8");
 }
 function saveHashFile(root, magic, files) {
   const m = {};
   for (const [p, c] of files) m[p] = hash8(c);
-  writeFileSync4(resolve6(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
+  writeFileSync5(resolve6(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), JSON.stringify(m, null, 2) + "\n", "utf-8");
 }
 async function syncCommand(options = {}) {
   const projectRoot = process.cwd();
@@ -1497,8 +1608,8 @@ async function checkPrismaDiff(projectRoot, options) {
   } else {
     console.log(`
   \u76EE\u6807 schema \u6587\u4EF6\u4E0D\u5B58\u5728: ${result.targetPath}`);
-    mkdirSync4(dirname4(targetPath), { recursive: true });
-    writeFileSync4(targetPath, "// add.prisma \u2014 ADD \u6CBB\u7406\u6A21\u578B\n\n", "utf-8");
+    mkdirSync5(dirname4(targetPath), { recursive: true });
+    writeFileSync5(targetPath, "// add.prisma \u2014 ADD \u6CBB\u7406\u6A21\u578B\n\n", "utf-8");
     const n = injectMissingModels(targetPath, result.missing);
     console.log(`  \u2705 \u5DF2\u521B\u5EFA\u5E76\u6CE8\u5165 ${n} \u4E2A\u6A21\u578B/\u679A\u4E3E`);
     if (n > 0) {
@@ -1538,43 +1649,76 @@ function injectMissingModels(targetPath, models) {
   for (const m of models) {
     content += m.body + "\n\n";
   }
-  writeFileSync4(targetPath, content, "utf-8");
+  writeFileSync5(targetPath, content, "utf-8");
   return models.length;
 }
 function getBaseFieldLines(basePath, modelName) {
   const content = readFileSync7(basePath, "utf-8");
-  const blockRegex = /^(model|enum)\s+(\w+)\s*\{([^}]*(?:\{[^}]*\}[^}]*)*)\}/gm;
-  let match;
-  while ((match = blockRegex.exec(content)) !== null) {
-    if (match[2] !== modelName) continue;
-    const fields = {};
-    for (const line of match[3].split("\n")) {
+  const blocks = parseSchemaBlocks(content);
+  const block = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
+  if (!block) return {};
+  const fields = {};
+  for (const line of block.body.split("\n")) {
+    const clean = line.replace(/\/\/.*$/, "").trim();
+    if (!clean) continue;
+    if (block.type === "enum") {
+      if (/^\w+$/.test(clean)) fields[clean] = line.trim();
+    } else {
       const fm = line.match(/^\s*(\w+)\s+/);
       if (fm) fields[fm[1]] = line.trim();
     }
-    return fields;
   }
-  return {};
+  return fields;
 }
 function injectFieldLines(targetPath, basePath, modelName, fieldKeys) {
   const baseFields = getBaseFieldLines(basePath, modelName);
-  if (Object.keys(baseFields).length === 0) return 0;
-  let content = readFileSync7(targetPath, "utf-8");
-  let count = 0;
+  if (Object.keys(baseFields).length === 0) {
+    console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A${modelName} \u5728\u57FA\u51C6\u4E2D\u672A\u627E\u5230\u5B57\u6BB5\u5B9A\u4E49\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
+    return 0;
+  }
+  const content = readFileSync7(targetPath, "utf-8");
+  const lines = content.split("\n");
+  const blocks = parseSchemaBlocks(content);
+  const target = blocks.get(`model:${modelName}`) ?? blocks.get(`enum:${modelName}`);
+  if (!target) {
+    console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A\u76EE\u6807\u4E2D\u4E0D\u5B58\u5728 ${modelName} \u5757\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
+    return 0;
+  }
+  const bodyLines = target.body.split("\n");
+  const startIdx = lines.findIndex((l) => l === bodyLines[0]);
+  if (startIdx < 0) {
+    console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A\u65E0\u6CD5\u5B9A\u4F4D ${modelName} \u5757\u4F4D\u7F6E\uFF08${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF09`);
+    return 0;
+  }
+  const endIdx = startIdx + bodyLines.length - 1;
+  const existingNames = new Set(
+    target.fields.map((f) => f.split(":")[0])
+  );
+  const newFieldLines = [];
   for (const key of fieldKeys) {
     const fieldName = key.split(":")[0];
     const fieldLine = baseFields[fieldName];
     if (!fieldLine) continue;
-    const modelRegex = new RegExp(`(model\\s+${modelName}\\s*\\{)([^}]*?)(\\n\\s*\\})`, "m");
-    const m = content.match(modelRegex);
-    if (!m) continue;
-    if (new RegExp(`^\\s*${fieldName}\\s+`, "m").test(m[2])) continue;
-    content = content.replace(modelRegex, `$1$2
-  ${fieldLine}$3`);
-    count++;
+    if (existingNames.has(fieldName)) continue;
+    newFieldLines.push(`  ${fieldLine}`);
   }
-  if (count > 0) writeFileSync4(targetPath, content, "utf-8");
-  return count;
+  if (newFieldLines.length === 0) {
+    if (fieldKeys.length > 0) {
+      console.warn(`\u26A0\uFE0F  \u6CE8\u5165\u5931\u8D25\uFF1A${modelName} \u7684 ${fieldKeys.length} \u4E2A\u5B57\u6BB5\u672A\u5199\u5165\uFF08\u53EF\u80FD\u5DF2\u5B58\u5728\u6216\u5B9A\u4E49\u4E0D\u5339\u914D\uFF09`);
+    }
+    return 0;
+  }
+  let insertIdx = endIdx;
+  for (let k = startIdx + 1; k < endIdx; k++) {
+    if (/^\s*@@/.test(lines[k])) insertIdx = k;
+  }
+  const merged = [
+    ...lines.slice(0, insertIdx),
+    ...newFieldLines,
+    ...lines.slice(insertIdx)
+  ];
+  writeFileSync5(targetPath, merged.join("\n"), "utf-8");
+  return newFieldLines.length;
 }
 function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
   const baseFields = getBaseFieldLines(basePath, modelName);
@@ -1590,7 +1734,7 @@ function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
     content = content.replace(fieldRegex, `${match[1]}${baseLine}`);
     count++;
   }
-  if (count > 0) writeFileSync4(targetPath, content, "utf-8");
+  if (count > 0) writeFileSync5(targetPath, content, "utf-8");
   return count;
 }
 
@@ -1621,13 +1765,156 @@ async function statusCommand() {
   }
 }
 
+// src/cli/commands/stack.ts
+import { readdirSync as readdirSync3, readFileSync as readFileSync8, writeFileSync as writeFileSync6, existsSync as existsSync11, mkdirSync as mkdirSync6 } from "fs";
+import { resolve as resolve8, join as join5 } from "path";
+import { createHash as createHash3 } from "crypto";
+var MAGIC_DIR_MAP3 = { claude: ".claude", qoder: ".qoder", vscode: ".vscode", trae: ".trae", codex: ".codex" };
+var HASH_OUTPUT_FILE = ".add-coder-hash.json";
+function hash82(c) {
+  return createHash3("sha256").update(c).digest("hex").slice(0, 8);
+}
+function resolveMagicDir(projectRoot, specified) {
+  if (specified) {
+    if (!MAGIC_DIR_MAP3[specified]) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
+    return MAGIC_DIR_MAP3[specified];
+  }
+  const detected = detectIDE2(projectRoot);
+  const adapter = detected !== "auto" ? detected : "qoder";
+  return MAGIC_DIR_MAP3[adapter];
+}
+function listCustomProfiles(projectRoot, magicDir, registryNames) {
+  const dir = resolve8(projectRoot, magicDir, "rules", "profiles");
+  if (!existsSync11(dir)) return [];
+  return readdirSync3(dir).filter((f) => f.endsWith(".md") && !registryNames.has(f.replace(/-profile\.md$/, ""))).sort();
+}
+function profileExists(projectRoot, magicDir, name) {
+  const registry = loadProfileRegistry();
+  if (registry.some((p) => p.name === name)) return true;
+  return existsSync11(resolve8(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`));
+}
+function stackCommand(sub, name, options = {}) {
+  const projectRoot = process.cwd();
+  const magicDir = resolveMagicDir(projectRoot, options.adapter);
+  const registry = loadProfileRegistry();
+  if (options.clear) {
+    saveStack(projectRoot, magicDir, "");
+    console.log(`\u5DF2\u6E05\u9664\u6280\u672F\u6808\u8BBE\u7F6E\uFF08${magicDir}/stack.json \u2192 \u4E2D\u6027\uFF09`);
+    return;
+  }
+  if (sub === "list" || !sub) {
+    const current = loadStack(projectRoot, magicDir);
+    console.log("\u6280\u672F\u6808 profile \u5217\u8868:");
+    console.log("  \u5185\u7F6E\uFF08\u6CE8\u518C\u8868\uFF09:");
+    for (const p of registry) {
+      const mark = p.name === current ? "  \u2190 \u5F53\u524D" : "";
+      console.log(`    ${p.name} \u2014 ${p.description}${mark}`);
+    }
+    const custom = listCustomProfiles(projectRoot, magicDir, new Set(registry.map((p) => p.name)));
+    if (custom.length > 0) {
+      console.log("  \u81EA\u5B9A\u4E49\uFF08\u9879\u76EE\u4FA7\uFF09:");
+      for (const c of custom) {
+        const name2 = c.replace(/-profile\.md$/, "");
+        const mark = name2 === current ? "  \u2190 \u5F53\u524D" : "";
+        console.log(`    ${name2}${mark}`);
+      }
+    }
+    if (!current) console.log("\n\u5F53\u524D: \u672A\u8BBE\u7F6E\uFF08\u4E0D\u65BD\u52A0\u4EFB\u4F55\u6280\u672F\u6808\u5047\u8BBE\uFF09");
+    return;
+  }
+  if (sub === "show") {
+    const current = loadStack(projectRoot, magicDir);
+    if (!current) {
+      console.log("\u6280\u672F\u6808: \u672A\u8BBE\u7F6E\uFF08\u4E2D\u6027\uFF0C\u65E0\u6280\u672F\u6808\u5047\u8BBE\uFF09");
+      return;
+    }
+    const profilePath = resolve8(projectRoot, magicDir, "rules", "profiles", `${current}-profile.md`);
+    const stat = existsSync11(profilePath) ? readFileSync8(profilePath, "utf-8").length : 0;
+    console.log(`\u6280\u672F\u6808: ${current}`);
+    console.log(`profile \u6587\u4EF6: ${profilePath}${existsSync11(profilePath) ? ` (${stat} \u5B57\u7B26)` : "\uFF08\u7F3A\u5931\uFF09"}`);
+    try {
+      const raw = JSON.parse(readFileSync8(resolve8(projectRoot, magicDir, "stack.json"), "utf-8"));
+      if (raw.updatedAt) console.log(`\u66F4\u65B0\u65F6\u95F4: ${raw.updatedAt}`);
+    } catch {
+    }
+    return;
+  }
+  if (sub === "set") {
+    if (!name) {
+      console.log("\u7528\u6CD5: add-coder stack set <name>\uFF08\u5185\u7F6E: " + registry.map((p) => p.name).join(" | ") + "\uFF0C\u6216\u81EA\u5B9A\u4E49 profile \u540D\uFF09");
+      return;
+    }
+    applyStack(projectRoot, magicDir, name);
+    return;
+  }
+  console.log(`\u672A\u77E5\u5B50\u547D\u4EE4: ${sub}\uFF08\u53EF\u7528: list / set <name> / show / --clear\uFF09`);
+}
+function buildConfig(projectRoot, magicDir, stack) {
+  const config = {
+    ...defaults,
+    projectName: "add-project",
+    projectRoot,
+    magicDir,
+    stack
+  };
+  try {
+    const pkgPath = resolve8(projectRoot, "package.json");
+    if (existsSync11(pkgPath)) {
+      const pkg = JSON.parse(readFileSync8(pkgPath, "utf-8"));
+      if (pkg.name) config.projectName = pkg.name;
+    }
+  } catch {
+  }
+  return config;
+}
+function applyStack(projectRoot, magicDir, name) {
+  if (!profileExists(projectRoot, magicDir, name)) {
+    const registry = loadProfileRegistry();
+    console.error(`\u2717 profile \u4E0D\u5B58\u5728: ${name}`);
+    console.error(`  \u5185\u7F6E: ${registry.map((p) => p.name).join(" | ")}\uFF08\u6216\u81EA\u5B9A\u4E49: ${magicDir}/rules/profiles/{name}-profile.md\uFF09`);
+    process.exit(1);
+  }
+  const config = buildConfig(projectRoot, magicDir, name);
+  saveStack(projectRoot, magicDir, name);
+  const coreFiles = renderCore(config, false);
+  const stackRelated = /* @__PURE__ */ new Map();
+  for (const [relPath, content] of coreFiles) {
+    if (relPath.includes("/rules/profiles/") || relPath.endsWith("/rules/project_rules.md")) {
+      stackRelated.set(relPath, content);
+    }
+  }
+  const hashMap = {};
+  try {
+    Object.assign(hashMap, JSON.parse(readFileSync8(resolve8(projectRoot, magicDir, HASH_OUTPUT_FILE), "utf-8")));
+  } catch {
+  }
+  let written = 0;
+  for (const [relPath, content] of stackRelated) {
+    for (const t of [".add", magicDir]) {
+      const targetPath = resolve8(projectRoot, relPath.replace(/^\.add/, t));
+      mkdirSync6(join5(targetPath, ".."), { recursive: true });
+      writeFileSync6(targetPath, content, "utf-8");
+      hashMap[relPath.replace(/^\.add/, t)] = hash82(content);
+      written++;
+    }
+  }
+  writeFileSync6(resolve8(projectRoot, magicDir, HASH_OUTPUT_FILE), JSON.stringify(hashMap, null, 2) + "\n", "utf-8");
+  console.log(`\u2705 \u6280\u672F\u6808\u5DF2\u8BBE\u7F6E\u4E3A ${name}`);
+  console.log(`   ${magicDir}/stack.json \u2192 ${name}`);
+  console.log(`   ${magicDir}/rules/profiles/${name}-profile.md ${existsSync11(resolve8(projectRoot, magicDir, "rules", "profiles", `${name}-profile.md`)) ? "\u5DF2\u5C31\u4F4D" : "\uFF08\u81EA\u5B9A\u4E49 profile\uFF0C\u9879\u76EE\u4FA7\u6587\u4EF6\uFF09"}`);
+  console.log(`   project_rules.md \u5F15\u7528\u884C\u5DF2\u66F4\u65B0 + hash \u5DF2\u5237\u65B0\uFF08${written} \u4E2A\u6587\u4EF6\uFF09`);
+}
+
 // src/cli/index.ts
 var { version } = JSON.parse(
-  readFileSync8(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync9(new URL("../package.json", import.meta.url), "utf-8")
 );
 var program = new Command();
 program.name("add-coder").description("\u521D\u59CB\u5316 ADD \u8303\u5F0F\u5DE5\u4F5C\u6D41\u6A21\u677F").version(version);
-program.command("init").description("\u521D\u59CB\u5316 ADD \u6A21\u677F\u5230\u5F53\u524D\u9879\u76EE").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode").option("--config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("--force", "\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\uFF0C\u4E0D\u4EA4\u4E92").option("--dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4E0D\u5B9E\u9645\u5199\u5165").action(initCommand);
-program.command("sync").description("\u589E\u91CF\u540C\u6B65\u7F3A\u5931\u6587\u4EF6\uFF08--patch \u8986\u76D6\u5DF2\u6709\u6A21\u677F\uFF09").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode").option("--patch", "\u8986\u76D6\u5DF2\u6709\u6A21\u677F\u6587\u4EF6\uFF08\u4E0D\u78B0 plans/specs/reviews\uFF09").option("-i, --interactive", "\u4EA4\u4E92\u5F0F\u9009\u62E9\u8981\u540C\u6B65\u7684\u6587\u4EF6").action(syncCommand);
+program.command("init").description("\u521D\u59CB\u5316 ADD \u6A21\u677F\u5230\u5F53\u524D\u9879\u76EE").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("--force", "\u8986\u76D6\u5DF2\u6709\u6587\u4EF6\uFF0C\u4E0D\u4EA4\u4E92").option("--dry-run", "\u9884\u89C8\u6A21\u5F0F\uFF0C\u4E0D\u5B9E\u9645\u5199\u5165").option("--stack <name>", "\u6280\u672F\u6808\u7EA6\u675F profile \u540D\uFF08\u5982 machineserver\uFF0C\u53EF\u9009\uFF09").action(initCommand);
+program.command("sync").description("\u589E\u91CF\u540C\u6B65\u7F3A\u5931\u6587\u4EF6\uFF08--patch \u8986\u76D6\u5DF2\u6709\u6A21\u677F\uFF09").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--patch", "\u8986\u76D6\u5DF2\u6709\u6A21\u677F\u6587\u4EF6\uFF08\u4E0D\u78B0 plans/specs/reviews\uFF09").option("-i, --interactive", "\u4EA4\u4E92\u5F0F\u9009\u62E9\u8981\u540C\u6B65\u7684\u6587\u4EF6").action(syncCommand);
 program.command("status").description("\u68C0\u67E5 ADD \u6A21\u677F\u5B8C\u6574\u6027").action(statusCommand);
+program.command("stack").description("\u7BA1\u7406\u6280\u672F\u6808\u7EA6\u675F profile\uFF08list / set <name> / show / --clear\uFF09").argument("[sub]", "list | set | show").argument("[name]", "set <name>: profile \u540D\uFF08\u5185\u7F6E\u6216\u81EA\u5B9A\u4E49\uFF09").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | trae | codex").option("--clear", "\u6E05\u9664\u6280\u672F\u6808\u8BBE\u7F6E\uFF08\u4E2D\u6027\uFF09").action(
+  (sub, name, options) => stackCommand(sub, name, options)
+);
 program.parse();