add-coder 0.3.4 → 0.3.6-feature-hitl-enhance-v1.0

package/README.md

@@ -2,6 +2,8 @@
 
 Make 0.75 into one.
 
+ ![npm downloads](https://img.shields.io/npm/dm/add-coder) 
+
 > 🀄中文 | 🔤[English](#-english-readme)
 
 **AI 代码治理的落地方案** — [codein2027](https://github.com/xiaomingming92/codein2027) 快速构建 ADD 编程范式的完整脚手架。以「审计即基础设施」为核心，彻底打破编程过程黑盒与跨轮失忆，让编程范式进化为可审计、可追溯、可收敛的新时代。 [NPM](https://www.npmjs.com/package/add-coder) · [GitHub](https://github.com/xiaomingming92/add-coder)
@@ -9,7 +11,7 @@ Make 0.75 into one.
 
 > 🧭 **从零上手实操？** 请参见 [GUIDE.md](https://github.com/xiaomingming92/add-coder/blob/main/GUIDE.md) — 包含触发词速查、需求转 Plan、完整链路演练。
 >
-> 📖 **想看 ADD 范式真实落地案例？** → [老设备续命工程](#-案例示范老安卓设备续命工程) — weather_proxy 实践。
+> 📖 **想看 ADD 范式真实落地案例？** → [老设备续命工程](#-案例示范老安卓设备续命工程) — weather_proxy 实践。->或者add-coder项目本身就是很好的落地案例(自举成功)。
 >
 > 🔄 **add-coder 升级后担心更新本地Skills,rules,hooks,templates等等会很麻烦？** `npx add-coder sync --adapter=qoder --patch` — 实操看 [GUIDE.md §版本升级](https://github.com/xiaomingming92/add-coder/blob/main/GUIDE.md#%E4%B8%83add-coder-%E5%8D%87%E7%BA%A7%E5%90%8E%E6%80%8E%E4%B9%88%E6%9B%B4%E6%96%B0%E6%9C%AC%E5%9C%B0%E6%96%87%E4%BB%B6) | 原理看 [DEVELOPMENT.md](https://github.com/xiaomingming92/add-coder/blob/main/DEVELOPMENT.md)
 

package/dist/index.js

@@ -1,7 +1,13 @@
 #!/usr/bin/env node
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
 
 // src/cli/index.ts
-import { readFileSync as readFileSync7 } from "fs";
+import { readFileSync as readFileSync8 } from "fs";
 import { Command } from "commander";
 
 // src/caijuehub/strategies/detect.strategy.ts
@@ -296,13 +302,97 @@ async function writeFiles(projectRoot, files, options = {}) {
   return { created, skipped, overwritten };
 }
 
+// src/caijuehub/strategies/prisma-sync.strategy.ts
+var SYNC_PRISMA_CONFIG = {
+  BASE_SCHEMA: "node_modules/add-coder/templates/core/prisma/add.prisma",
+  TARGET_PATTERN: "prisma/add.prisma",
+  SYNC_ITEMS: ["model", "enum"],
+  ON_MISSING_MODEL: "interactive",
+  ON_FIELD_CONFLICT: "skip",
+  ON_MISSING_FIELD: "interactive",
+  ON_EXTRA_FIELD: "ignore",
+  PROMPT: "add-coder \u6807\u51C6 add.prisma \u4E0E\u6D88\u8D39\u65B9 schema \u5B58\u5728\u5DEE\u5F02\u3002"
+};
+
 // src/cli/writer.ts
+import { existsSync as existsSync4, readFileSync as readFileSync3 } from "fs";
 async function writeFiles2(projectRoot, files, options = {}) {
   return writeFiles(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;
+    let fields = [];
+    if (type === "enum") {
+      fields = inner.split("\n").map((l) => l.replace(/#.*$/, "").trim()).filter((l) => l.length > 0);
+    } else {
+      const fieldRegex = /^\s*(\w+)\s+(\w+(?:\([^)]*\))?(?:\[\])?\??)/gm;
+      let fm;
+      while ((fm = fieldRegex.exec(inner)) !== null) {
+        fields.push(`${fm[1]}:${fm[2]}`);
+      }
+    }
+    blocks.set(`${type}:${name}`, { type, name, body: match[0], fields });
+  }
+  return blocks;
+}
+function diffPrisma(basePath, targetPath) {
+  const baseContent = existsSync4(basePath) ? readFileSync3(basePath, "utf-8") : "";
+  const targetContent = existsSync4(targetPath) ? readFileSync3(targetPath, "utf-8") : "";
+  if (!baseContent) return { hasDiff: false, baseSchema: basePath, targetPath, missing: [], fieldDiffs: [] };
+  const baseBlocks = parseSchemaBlocks(baseContent);
+  const targetBlocks = parseSchemaBlocks(targetContent);
+  const missing = [];
+  const fieldDiffs = [];
+  const types = SYNC_PRISMA_CONFIG.SYNC_ITEMS;
+  for (const [key, block] of baseBlocks) {
+    if (!types.includes(block.type)) continue;
+    if (!targetBlocks.has(key)) {
+      missing.push(block);
+    } else {
+      const target = targetBlocks.get(key);
+      const baseByName = /* @__PURE__ */ new Map();
+      for (const f of block.fields) {
+        const [name] = f.split(":");
+        baseByName.set(name, f);
+      }
+      const targetByName = /* @__PURE__ */ new Map();
+      for (const f of target.fields) {
+        const [name] = f.split(":");
+        targetByName.set(name, f);
+      }
+      const conflicts = [];
+      const missingFields = [];
+      const extraFields = [];
+      for (const [name, baseDef] of baseByName) {
+        if (targetByName.has(name)) {
+          const targetDef = targetByName.get(name);
+          if (baseDef !== targetDef) {
+            conflicts.push({ fieldName: name, baseDef, targetDef });
+          }
+        } else {
+          missingFields.push(baseDef);
+        }
+      }
+      for (const [name, targetDef] of targetByName) {
+        if (!baseByName.has(name)) {
+          extraFields.push(targetDef);
+        }
+      }
+      if (conflicts.length > 0 || missingFields.length > 0 || extraFields.length > 0) {
+        fieldDiffs.push({ type: block.type, name: block.name, conflicts, missingFields, extraFields });
+      }
+    }
+  }
+  const hasDiff = missing.length > 0 || fieldDiffs.length > 0;
+  return { hasDiff, baseSchema: basePath, targetPath, missing, fieldDiffs };
+}
 
 // src/core/renderer.ts
-import { readFileSync as readFileSync3, readdirSync, statSync } from "fs";
+import { readFileSync as readFileSync4, readdirSync, statSync } from "fs";
 import { join as join4, relative, dirname as dirname2 } from "path";
 import { fileURLToPath } from "url";
 var __filename = fileURLToPath(import.meta.url);
@@ -339,7 +429,7 @@ function renderCore(config, dryRun) {
       if (statSync(full).isDirectory()) {
         if (!SKIP_DIRS.has(name)) walk(full, join4(base, name));
       } else {
-        const content = readFileSync3(full, "utf-8");
+        const content = readFileSync4(full, "utf-8");
         const rendered = render(content, config);
         const targetRel = join4(CORE_TARGET, relative(CORE_DIR, full));
         files.set(targetRel, rendered);
@@ -365,7 +455,7 @@ function renderAdapterBase(config, magicPath, githubHooksToRoot, dryRun) {
       if (statSync(full).isDirectory()) {
         walk(full, join4(base, name), targetPrefix);
       } else {
-        const content = readFileSync3(full, "utf-8");
+        const content = readFileSync4(full, "utf-8");
         const rendered = render(content, config);
         let targetRel;
         if (targetPrefix) {
@@ -414,7 +504,7 @@ function renderAdapter5(config, targetDir, dryRun, magicDir) {
 
 // src/lib/utils.ts
 import { createInterface as createInterface2 } from "readline";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync5 } from "fs";
 import { resolve as resolve2 } from "path";
 function ask(q) {
   const rl = createInterface2({ input: process.stdin, output: process.stdout });
@@ -426,7 +516,7 @@ function ask(q) {
   });
 }
 function detectPm(projectRoot) {
-  return existsSync4(resolve2(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+  return existsSync5(resolve2(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
 }
 
 // src/cli/prisma-injector.ts
@@ -435,7 +525,7 @@ import { fileURLToPath as fileURLToPath2 } from "url";
 
 // src/caijuehub/strategies/prisma.strategy.ts
 import { spawnSync } from "child_process";
-import { copyFileSync, existsSync as existsSync5, readFileSync as readFileSync4, unlinkSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { copyFileSync, existsSync as existsSync6, readFileSync as readFileSync5, unlinkSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
 import { resolve as resolve3 } from "path";
 var PRISMA_CONFIG = {
   onMissing: "ask",
@@ -488,10 +578,10 @@ function runPrismaInit(projectRoot, provider, schemaPath) {
     stdio: "inherit",
     shell: false
   });
-  if (initResult.status !== 0 || !existsSync5(schemaPath)) {
+  if (initResult.status !== 0 || !existsSync6(schemaPath)) {
     console.log("prisma init \u5931\u8D25\uFF0C\u624B\u52A8\u521B\u5EFA schema.prisma ...");
     const prismaDir = resolve3(projectRoot, "prisma");
-    if (!existsSync5(prismaDir)) mkdirSync2(prismaDir, { recursive: true });
+    if (!existsSync6(prismaDir)) mkdirSync2(prismaDir, { recursive: true });
     const content = `generator client {
   provider = "prisma-client-js"
 }
@@ -502,7 +592,7 @@ datasource db {
 `;
     writeFileSync2(schemaPath, content, "utf-8");
     const devEnvPath = resolve3(projectRoot, ".env.development");
-    if (!existsSync5(devEnvPath)) {
+    if (!existsSync6(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");
       console.log("\u5DF2\u521B\u5EFA .env.development");
@@ -514,16 +604,16 @@ datasource db {
 function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
   const envPath = resolve3(projectRoot, ".env");
   const devEnvPath = resolve3(projectRoot, ".env.development");
-  if (existsSync5(envPath)) {
-    const envContent = readFileSync4(envPath, "utf-8");
+  if (existsSync6(envPath)) {
+    const envContent = readFileSync5(envPath, "utf-8");
     const dbUrl = envContent.match(/DATABASE_URL=.*/);
     if (dbUrl) {
-      const existing = existsSync5(devEnvPath) ? readFileSync4(devEnvPath, "utf-8") : "";
+      const existing = existsSync6(devEnvPath) ? readFileSync5(devEnvPath, "utf-8") : "";
       if (!existing.includes("DATABASE_URL=")) {
         writeFileSync2(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
 `, "utf-8");
       }
-      if (existsSync5(envPath)) unlinkSync(envPath);
+      if (existsSync6(envPath)) unlinkSync(envPath);
       console.log("\u5DF2\u5C06 DATABASE_URL \u8FC1\u79FB\u5230 .env.development");
     }
   }
@@ -536,7 +626,7 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
   const schemaPath = resolve3(prismaDir, "schema.prisma");
   const destPath = resolve3(prismaDir, "add.prisma");
   let justInited = false;
-  if (!existsSync5(prismaDir) || !existsSync5(schemaPath)) {
+  if (!existsSync6(prismaDir) || !existsSync6(schemaPath)) {
     if (C.onMissing === "skip") {
       console.log("\u8DF3\u8FC7\uFF1A\u7F3A\u5C11 Prisma");
       return true;
@@ -555,7 +645,7 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath);
     justInited = true;
   }
-  if (existsSync5(destPath) && !justInited) {
+  if (existsSync6(destPath) && !justInited) {
     if (options.dryRun) {
       console.log("[dry-run] \u5DF2\u6709 add.prisma");
       return true;
@@ -572,8 +662,8 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
         console.log("\u8986\u76D6");
       } else if (choice === "d") {
         copyFileSync(destPath, destPath + ".bak");
-        console.log("=== \u5F53\u524D\uFF08\u5DF2\u5907\u4EFD\uFF09===\n" + readFileSync4(destPath, "utf-8"));
-        console.log("=== \u6A21\u677F ===\n" + readFileSync4(addPrismaTemplate, "utf-8"));
+        console.log("=== \u5F53\u524D\uFF08\u5DF2\u5907\u4EFD\uFF09===\n" + readFileSync5(destPath, "utf-8"));
+        console.log("=== \u6A21\u677F ===\n" + readFileSync5(addPrismaTemplate, "utf-8"));
         if (await ask("\u786E\u8BA4\u8986\u76D6\uFF1F[y/N] ") !== "y") {
           console.log("\u5DF2\u8DF3\u8FC7");
           return true;
@@ -628,7 +718,7 @@ async function injectPrisma2(projectRoot, options = {}) {
 }
 
 // src/cli/commands/init.ts
-import { readFileSync as readFileSync5, writeFileSync as writeFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3, copyFileSync as copyFileSync2, readdirSync as readdirSync2 } from "fs";
+import { readFileSync as readFileSync6, writeFileSync as writeFileSync3, existsSync as existsSync7, mkdirSync as mkdirSync3, 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";
@@ -808,18 +898,18 @@ main().catch((e) => { console.error(e); process.exit(1); });
     console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
     return;
   }
-  if (!existsSync6(scriptsDir)) mkdirSync3(scriptsDir, { recursive: true });
+  if (!existsSync7(scriptsDir)) mkdirSync3(scriptsDir, { recursive: true });
   writeFileSync3(scriptPath, content, "utf-8");
   console.log("\u5DF2\u751F\u6210 scripts/export-db.ts");
 }
 function injectDbExportScript(projectRoot, dryRun) {
   const pkgPath = resolve5(projectRoot, "package.json");
-  if (!existsSync6(pkgPath)) return;
+  if (!existsSync7(pkgPath)) return;
   if (dryRun) {
     console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
     return;
   }
-  const pkg = JSON.parse(readFileSync5(pkgPath, "utf-8"));
+  const pkg = JSON.parse(readFileSync6(pkgPath, "utf-8"));
   if (!pkg.scripts) pkg.scripts = {};
   if (!pkg.scripts["db:export"]) {
     pkg.scripts["db:export"] = "npx tsx scripts/export-db.ts";
@@ -849,14 +939,14 @@ function writeComposeEnv(ctx) {
   if (!db.reuseExisting) {
     const composeName = db.container === "podman" ? "podman-compose.add.yml" : "docker-compose.add.yml";
     const composePath = resolve5(projectRoot, composeName);
-    if (!options.dryRun && (!existsSync6(composePath) || options.force)) {
+    if (!options.dryRun && (!existsSync7(composePath) || options.force)) {
       writeFileSync3(composePath, composeContent(config.projectName || "add-project"), "utf-8");
       console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
     }
   }
   const devEnvPath = resolve5(projectRoot, ".env.development");
-  if (!options.dryRun && existsSync6(devEnvPath)) {
-    const existing = readFileSync5(devEnvPath, "utf-8");
+  if (!options.dryRun && existsSync7(devEnvPath)) {
+    const existing = readFileSync6(devEnvPath, "utf-8");
     if (!/^DATABASE_USER=/m.test(existing)) {
       writeFileSync3(devEnvPath, existing + `
 DATABASE_USER=${db.user || "admin"}
@@ -896,7 +986,7 @@ async function renderAndWrite(ctx) {
   }
   for (const d of [".add", magicDir]) {
     const reviewsDir = resolve5(projectRoot, d, "reviews");
-    if (!existsSync6(reviewsDir)) {
+    if (!existsSync7(reviewsDir)) {
       if (dry) {
         console.log(`[dry-run] \u5C06\u521B\u5EFA ${reviewsDir}/`);
       } else {
@@ -908,7 +998,7 @@ async function renderAndWrite(ctx) {
     const hashMap = {};
     let npmVer = "";
     try {
-      npmVer = JSON.parse(readFileSync5(resolve5(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
+      npmVer = JSON.parse(readFileSync6(resolve5(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json"), "utf-8"))._version ?? "";
     } catch {
     }
     for (const [rp, c] of allFiles) {
@@ -940,7 +1030,7 @@ async function deployDatabase(ctx) {
   }
   if (db.engine === "postgresql" && db.container === "manual") {
     const dbScript = resolve5(projectRoot, magicDir, "scripts", "db-ensure.sh");
-    if (existsSync6(dbScript)) spawnSync2("bash", [dbScript, "postgresql", "manual"], { cwd: projectRoot, stdio: "inherit" });
+    if (existsSync7(dbScript)) spawnSync2("bash", [dbScript, "postgresql", "manual"], { cwd: projectRoot, stdio: "inherit" });
     console.log([
       "",
       "\u2501".repeat(30),
@@ -981,12 +1071,12 @@ 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 (!existsSync6(destDir)) mkdirSync3(destDir, { recursive: true });
-    if (!existsSync6(srcDir)) continue;
+    if (!existsSync7(destDir)) mkdirSync3(destDir, { recursive: true });
+    if (!existsSync7(srcDir)) continue;
     for (const f of readdirSync2(srcDir)) {
       const src = resolve5(srcDir, f);
       const dest = resolve5(destDir, f);
-      if (existsSync6(dest)) continue;
+      if (existsSync7(dest)) continue;
       try {
         copyFileSync2(src, dest);
       } catch {
@@ -1000,7 +1090,7 @@ function finalize(ctx, result) {
 \u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}, \u8986\u76D6 ${result.overwritten}`);
   if (options.dryRun) return;
   if (db.engine === "sqlite") console.log("\u6570\u636E\u5907\u4EFD: npm run db:export \u2192 data/exports/");
-  const pkg = JSON.parse(readFileSync5(resolve5(import.meta.dirname, "../package.json"), "utf-8"));
+  const pkg = JSON.parse(readFileSync6(resolve5(import.meta.dirname, "../package.json"), "utf-8"));
   const peerNames = Object.keys(pkg.peerDependencies || {});
   if (peerNames.length > 0) {
     console.log(`
@@ -1014,7 +1104,7 @@ function finalize(ctx, result) {
 }
 
 // src/cli/commands/sync.ts
-import { existsSync as existsSync7, readFileSync as readFileSync6, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync8, readFileSync as readFileSync7, writeFileSync as writeFileSync4 } from "fs";
 import { resolve as resolve6 } from "path";
 import { createHash as createHash2 } from "crypto";
 
@@ -1068,14 +1158,14 @@ function hash8(c) {
 }
 function loadHashFile(root, magic) {
   try {
-    return JSON.parse(readFileSync6(resolve6(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
+    return JSON.parse(readFileSync7(resolve6(root, magic, SYNC_CONFIG.HASH_OUTPUT_FILE), "utf-8"));
   } catch {
     return {};
   }
 }
 function loadVersionFile(root, magic) {
   try {
-    return readFileSync6(resolve6(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
+    return readFileSync7(resolve6(root, magic, SYNC_CONFIG.VERSION_SENTINEL), "utf-8").trim();
   } catch {
     return "";
   }
@@ -1132,7 +1222,7 @@ async function syncCommand(options = {}) {
     const srcHashPath = resolve6(projectRoot, "node_modules", "add-coder", "templates", ".add-coder-src-hash.json");
     let npmVersion = "";
     try {
-      npmVersion = JSON.parse(readFileSync6(srcHashPath, "utf-8"))._version ?? "";
+      npmVersion = JSON.parse(readFileSync7(srcHashPath, "utf-8"))._version ?? "";
     } catch {
     }
     const installedVersion = loadVersionFile(projectRoot, magicDir);
@@ -1152,12 +1242,12 @@ async function syncCommand(options = {}) {
     let sameCount = 0;
     for (const [relPath, content] of candidates) {
       const absPath = resolve6(projectRoot, relPath);
-      if (!existsSync7(absPath)) {
+      if (!existsSync8(absPath)) {
         missingFiles.set(relPath, content);
       } else if (establishBaseline) {
         missingFiles.set(relPath, content);
       } else {
-        const curH = hash8(readFileSync6(absPath, "utf-8"));
+        const curH = hash8(readFileSync7(absPath, "utf-8"));
         const storedH = outHash[relPath];
         if (storedH && curH === storedH) {
           sameCount++;
@@ -1185,11 +1275,12 @@ async function syncCommand(options = {}) {
     }
     saveHashFile(projectRoot, magicDir, new Map([...missingFiles, ...conflictFiles]));
     saveVersionFile(projectRoot, magicDir, npmVersion);
+    await checkPrismaDiff(projectRoot, options);
     return;
   }
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of allFiles) {
-    if (!existsSync7(resolve6(projectRoot, relPath))) {
+    if (!existsSync8(resolve6(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
@@ -1207,10 +1298,235 @@ async function syncCommand(options = {}) {
   }
   const result = await writeFiles2(projectRoot, filesToWrite, { yes: true });
   console.log(`\u540C\u6B65\u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}`);
+  await checkPrismaDiff(projectRoot, options);
+}
+async function checkPrismaDiff(projectRoot, options) {
+  if (!options.patch) return;
+  const basePath = resolve6(projectRoot, SYNC_PRISMA_CONFIG.BASE_SCHEMA);
+  const targetPath = resolve6(projectRoot, SYNC_PRISMA_CONFIG.TARGET_PATTERN);
+  if (!existsSync8(basePath)) {
+    console.log(`
+\u26A0\uFE0F  \u57FA\u51C6 schema \u4E0D\u5B58\u5728: ${basePath}`);
+    console.log(`  \u8BF7\u786E\u4FDD add-coder \u5DF2\u6B63\u786E\u5B89\u88C5\u3002`);
+    return;
+  }
+  const result = diffPrisma(basePath, targetPath);
+  if (!result.hasDiff) {
+    console.log(`
+\u2705 Prisma schema \u4E0E add-coder \u6807\u51C6\u4E00\u81F4\uFF0C\u65E0\u9700\u540C\u6B65\u3002`);
+    return;
+  }
+  const targetExists = existsSync8(targetPath);
+  console.log(`
+\u26A0\uFE0F  Prisma schema \u5DEE\u5F02\u68C0\u6D4B:`);
+  console.log(`  \u57FA\u51C6: ${result.baseSchema} (add-coder \u6807\u51C6)`);
+  if (targetExists) console.log(`  \u76EE\u6807: ${result.targetPath} (\u6D88\u8D39\u65B9)`);
+  if (result.missing.length > 0 && targetExists) {
+    let selected = [];
+    await handleDiffAction(SYNC_PRISMA_CONFIG.ON_MISSING_MODEL, {
+      label: "\u7F3A\u5931\u6A21\u578B/\u679A\u4E3E",
+      show() {
+        console.log(`
+  \u{1F534} \u7F3A\u5931\u6A21\u578B/\u679A\u4E3E\uFF08${result.missing.length} \u9879\uFF09:`);
+        for (let i = 0; i < result.missing.length; i++) {
+          const m = result.missing[i];
+          console.log(`  [${i + 1}] ${m.type} ${m.name} (${m.fields.length} \u5B57\u6BB5)`);
+        }
+      },
+      async confirm() {
+        const ans = await ask(`
+  \u8F93\u5165\u7F16\u53F7\u9009\u62E9\u6027\u6CE8\u5165\uFF08\u5982 1,3\uFF09\uFF0Ca \u5168\u90E8\u6CE8\u5165\uFF0C\u56DE\u8F66\u8DF3\u8FC7: `);
+        if (ans === "a" || ans === "all") {
+          selected = [...result.missing];
+          return true;
+        }
+        if (!ans.trim()) return false;
+        const indices = ans.split(/[,，]+/).map((s) => parseInt(s.trim()) - 1).filter((i) => !isNaN(i) && i >= 0 && i < result.missing.length);
+        if (indices.length === 0) return false;
+        selected = indices.map((i) => result.missing[i]);
+        return true;
+      },
+      async execute() {
+        const n = injectMissingModels(result.targetPath, selected);
+        console.log(`  \u2705 \u5DF2\u5C06 ${n} \u4E2A\u6A21\u578B/\u679A\u4E3E\u6CE8\u5165 ${result.targetPath}`);
+        return n;
+      }
+    });
+  }
+  if (result.fieldDiffs.length > 0 && targetExists) {
+    console.log(`
+  \u{1F7E1} \u5B57\u6BB5\u7EA7\u5DEE\u5F02\uFF08${result.fieldDiffs.length} \u4E2A\u6A21\u578B/\u679A\u4E3E\uFF09:`);
+    for (const d of result.fieldDiffs) {
+      console.log(`
+  \u2500\u2500 ${d.type} ${d.name}:`);
+      if (d.conflicts.length > 0) {
+        await handleDiffAction(SYNC_PRISMA_CONFIG.ON_FIELD_CONFLICT, {
+          label: `\u51B2\u7A81\u5B57\u6BB5`,
+          show() {
+            console.log(`    \u26A1 \u51B2\u7A81\u5B57\u6BB5\uFF08\u540C\u540D\u5B57\u6BB5\u3001\u5B9A\u4E49\u4E0D\u540C\uFF09:`);
+            for (const c of d.conflicts) {
+              console.log(`      \xB7 ${c.fieldName}`);
+              console.log(`        \u57FA\u51C6: ${c.baseDef}`);
+              console.log(`        \u6D88\u8D39\u65B9: ${c.targetDef}`);
+            }
+          },
+          async confirm() {
+            const ans = await ask(`    \u662F\u5426\u7528\u57FA\u51C6\u5B9A\u4E49\u8986\u76D6\u8FD9\u4E9B\u51B2\u7A81\u5B57\u6BB5\uFF1F(y/n): `);
+            return ans === "y" || ans === "yes";
+          },
+          async execute() {
+            const n = overwriteFieldLines(targetPath, basePath, d.name, d.conflicts);
+            console.log(`    \u2705 \u5DF2\u8986\u76D6 ${n} \u4E2A\u51B2\u7A81\u5B57\u6BB5`);
+            return n;
+          }
+        });
+      }
+      if (d.missingFields.length > 0) {
+        await handleDiffAction(SYNC_PRISMA_CONFIG.ON_MISSING_FIELD, {
+          label: `\u7F3A\u5931\u5B57\u6BB5`,
+          show() {
+            console.log(`    \u{1F4CB} \u6D88\u8D39\u65B9\u7F3A\u5C11 ${d.missingFields.length} \u4E2A\u5B57\u6BB5:`);
+            for (const f of d.missingFields) {
+              console.log(`      + ${f}`);
+            }
+          },
+          async confirm() {
+            const ans = await ask(`    \u662F\u5426\u8865\u5145\u8FD9\u4E9B\u7F3A\u5931\u5B57\u6BB5\uFF1F(y/n): `);
+            return ans === "y" || ans === "yes";
+          },
+          async execute() {
+            const n = injectFieldLines(targetPath, basePath, d.name, d.missingFields);
+            console.log(`    \u2705 \u5DF2\u8865\u5145 ${n} \u4E2A\u5B57\u6BB5`);
+            return n;
+          }
+        });
+      }
+      if (d.extraFields.length > 0) {
+        await handleDiffAction(SYNC_PRISMA_CONFIG.ON_EXTRA_FIELD, {
+          label: `\u6D88\u8D39\u65B9\u7279\u6709\u5B57\u6BB5`,
+          show() {
+            console.log(`    \u2139\uFE0F  \u6D88\u8D39\u65B9\u7279\u6709 ${d.extraFields.length} \u4E2A\u5B57\u6BB5\uFF08\u4E0D\u505A\u64CD\u4F5C\uFF09:`);
+            for (const f of d.extraFields) {
+              console.log(`      - ${f}`);
+            }
+          },
+          async confirm() {
+            return false;
+          },
+          async execute() {
+            return 0;
+          }
+        });
+      }
+    }
+  }
+  if (targetExists) {
+    console.log(`
+  ${SYNC_PRISMA_CONFIG.PROMPT}`);
+    console.log(`  \u25B6 \u8BF7\u8FD0\u884C: npx prisma migrate dev && npx prisma generate`);
+  } else {
+    console.log(`
+  \u76EE\u6807 schema \u6587\u4EF6\u4E0D\u5B58\u5728: ${result.targetPath}`);
+    const { writeFileSync: writeFileSync5, mkdirSync: mkdirSync4 } = __require("fs");
+    const { dirname: dirname4 } = __require("path");
+    mkdirSync4(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`);
+    console.log(`  \u25B6 \u8BF7\u8FD0\u884C: npx prisma migrate dev && npx prisma generate`);
+  }
+}
+async function handleDiffAction(action, ctx) {
+  if (action === "skip" || action === "ignore") return;
+  ctx.show();
+  if (action === "auto") {
+    const n = await ctx.execute();
+    console.log(`  \u2705 ${ctx.label}: \u5DF2\u5904\u7406 ${n} \u9879`);
+    return;
+  }
+  if (action === "interactive") {
+    const ok = await ctx.confirm();
+    if (!ok) {
+      console.log(`  \u5DF2\u8DF3\u8FC7\u3002`);
+      return;
+    }
+    const n = await ctx.execute();
+    console.log(`  \u2705 ${ctx.label}: \u5DF2\u5904\u7406 ${n} \u9879`);
+    return;
+  }
+  if (action === "block") {
+    throw new Error(`\u26D4 Prisma \u540C\u6B65\u963B\u65AD: ${ctx.label}\uFF0C\u7B56\u7565\u4E3A block`);
+  }
+}
+function injectMissingModels(targetPath, models) {
+  let content = readFileSync7(targetPath, "utf-8");
+  content = content.replace(/\n*$/, "\n");
+  content += `
+// ===== \u7531 add-coder sync --patch \u81EA\u52A8\u6CE8\u5165 (${(/* @__PURE__ */ new Date()).toISOString().slice(0, 10)}) =====
+
+`;
+  for (const m of models) {
+    content += m.body + "\n\n";
+  }
+  writeFileSync4(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 fm = line.match(/^\s*(\w+)\s+/);
+      if (fm) fields[fm[1]] = line.trim();
+    }
+    return fields;
+  }
+  return {};
+}
+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;
+  for (const key of fieldKeys) {
+    const fieldName = key.split(":")[0];
+    const fieldLine = baseFields[fieldName];
+    if (!fieldLine) continue;
+    if (new RegExp(`^\\s*${fieldName}\\s+`, "m").test(content)) continue;
+    const modelRegex = new RegExp(`(model\\s+${modelName}\\s*\\{[^}]*?)\\n(\\s*\\})`, "m");
+    const m = content.match(modelRegex);
+    if (!m) continue;
+    content = content.replace(modelRegex, `$1
+  ${fieldLine}
+$2`);
+    count++;
+  }
+  if (count > 0) writeFileSync4(targetPath, content, "utf-8");
+  return count;
+}
+function overwriteFieldLines(targetPath, basePath, modelName, conflicts) {
+  const baseFields = getBaseFieldLines(basePath, modelName);
+  if (Object.keys(baseFields).length === 0) return 0;
+  let content = readFileSync7(targetPath, "utf-8");
+  let count = 0;
+  for (const { fieldName } of conflicts) {
+    const baseLine = baseFields[fieldName];
+    if (!baseLine) continue;
+    const fieldRegex = new RegExp(`^(\\s*)(${fieldName}\\s+.*)$`, "m");
+    const match = content.match(fieldRegex);
+    if (!match) continue;
+    content = content.replace(fieldRegex, `${match[1]}${baseLine}`);
+    count++;
+  }
+  if (count > 0) writeFileSync4(targetPath, content, "utf-8");
+  return count;
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync8 } from "fs";
+import { existsSync as existsSync9 } from "fs";
 import { resolve as resolve7 } from "path";
 async function statusCommand() {
   const projectRoot = process.cwd();
@@ -1220,7 +1536,7 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync8(resolve7(projectRoot, relPath))) {
+    if (existsSync9(resolve7(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
@@ -1238,7 +1554,7 @@ async function statusCommand() {
 
 // src/cli/index.ts
 var { version } = JSON.parse(
-  readFileSync7(new URL("../package.json", import.meta.url), "utf-8")
+  readFileSync8(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);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-coder",
-  "version": "0.3.4",
+  "version": "0.3.6-feature-hitl-enhance-v1.0",
   "private": false,
   "description": "[codein2027](https://github.com/xiaomingming92/codein2027) - A complete scaffolding for building the ADD programming paradigm, the implementation layer for AI code governance. Core principle: Audit as Infrastructure. Breaks the black-box programming process and cross-session amnesia, evolving programming paradigms into an auditable, traceable, and convergent new era. npx-ready.\n\n[codein2027](https://github.com/xiaomingming92/codein2027) 快速构建 ADD 编程范式的完整脚手架——AI 代码治理的落地方案。以「审计即基础设施」为核心，彻底打破编程过程黑盒与跨轮失忆，让编程范式进化为可审计、可追溯、可收敛的新时代。npx 即用，人人可体验。",
   "repository": {
@@ -43,6 +43,7 @@
     "@modelcontextprotocol/server": "2.0.0-beta.5",
     "commander": "^13.1.0",
     "smol-toml": "^1.7.0",
+    "vector-cosine-similarity": "^1.8.0",
     "zod": "^4.4.3"
   },
   "peerDependencies": {