add-coder 0.1.8 → 0.1.9

package/README.md

@@ -1,6 +1,8 @@
 # add-coder
 
-**AI 代码治理的落地方案** — [codein2027](https://github.com/xiaomingming92/codein2027) 快速构建 ADD 编程范式的完整脚手架。以「审计即基础设施」为核心，彻底打破编程过程黑盒与跨轮失忆，让编程范式进化为可审计、可追溯、可收敛的新时代。[本项目NPM包地址](https://www.npmjs.com/package/add-coder)
+**AI 代码治理的落地方案** — [codein2027](https://github.com/xiaomingming92/codein2027) 快速构建 ADD 编程范式的完整脚手架。以「审计即基础设施」为核心，彻底打破编程过程黑盒与跨轮失忆，让编程范式进化为可审计、可追溯、可收敛的新时代。[本项目NPM包地址](https://www.npmjs.com/package/add-coder)[本项目GITHUB地址](https://github.com/xiaomingming92/add-coder)
+
+> 🧭 **从零上手实操？** 请参见 [GUIDE.md](./GUIDE.md) — 包含触发词速查、需求转 Plan、完整链路演练。
 
 ```bash
 npx add-coder init

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 
 // 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
@@ -33,9 +33,7 @@ function detectIDE(projectRoot) {
 }
 
 // src/caijuehub/strategies/adapter.strategy.ts
-var AUTO_DEPLOY_ADAPTERS = ["claude", "qoder", "vscode"];
 function resolveAdapters(target) {
-  if (target === "auto") return AUTO_DEPLOY_ADAPTERS;
   return [target];
 }
 
@@ -53,7 +51,7 @@ import { join as join2 } from "path";
 
 // src/config/schema.ts
 import { z } from "zod";
-var AdapterEnum = z.enum(["claude", "qoder", "vscode", "auto"]);
+var AdapterEnum = z.enum(["claude", "qoder", "vscode"]);
 var AddCoderConfigSchema = z.object({
   projectName: z.string().min(1, "\u9879\u76EE\u540D\u4E0D\u80FD\u4E3A\u7A7A"),
   projectRoot: z.string().default(""),
@@ -64,7 +62,8 @@ var AddCoderConfigSchema = z.object({
   auditLoggerPath: z.string().default("src/lib/agent-audit-logger.ts"),
   mcpServerCommand: z.string().default("tsx"),
   agentAuditImport: z.string().default("@/lib/agent-audit-logger"),
-  adapters: z.array(AdapterEnum).default(["auto"]),
+  magicDir: z.string(),
+  adapters: z.array(AdapterEnum).default([]),
   overrides: z.record(z.string(), z.string()).default({})
 });
 
@@ -79,7 +78,8 @@ var defaults = {
   auditLoggerPath: "src/lib/agent-audit-logger.ts",
   mcpServerCommand: "tsx",
   agentAuditImport: "@/lib/agent-audit-logger",
-  adapters: ["auto"],
+  magicDir: "",
+  adapters: [],
   overrides: {}
 };
 
@@ -113,11 +113,13 @@ ${errors}`);
 }
 
 // src/caijuehub/strategies/writer.strategy.ts
-import { existsSync as existsSync3, mkdirSync, writeFileSync, chmodSync } from "fs";
+import { existsSync as existsSync4, mkdirSync, writeFileSync, chmodSync } from "fs";
 import { join as join3, dirname } from "path";
 
 // src/lib/utils.ts
 import { createInterface } from "readline";
+import { existsSync as existsSync3 } from "fs";
+import { resolve } from "path";
 function ask(q) {
   const rl = createInterface({ input: process.stdin, output: process.stdout });
   return new Promise((r) => {
@@ -127,6 +129,9 @@ function ask(q) {
     });
   });
 }
+function detectPm(projectRoot) {
+  return existsSync3(resolve(projectRoot, "pnpm-lock.yaml")) ? "pnpm" : "npm";
+}
 
 // src/caijuehub/strategies/writer.strategy.ts
 var WRITER_CONFIG = {
@@ -137,21 +142,27 @@ var WRITER_CONFIG = {
 async function writeFiles(projectRoot, files, options = {}) {
   const C = WRITER_CONFIG;
   let created = 0, skipped = 0, overwritten = 0;
+  let skipAll = false;
   for (const [relPath, content] of files) {
     const dest = join3(projectRoot, relPath);
     if (options.dryRun) {
-      console.log(`[dry-run] ${existsSync3(dest) ? "\u8986\u76D6" : "\u65B0\u5EFA"}: ${relPath}`);
+      console.log(`[dry-run] ${existsSync4(dest) ? "\u8986\u76D6" : "\u65B0\u5EFA"}: ${relPath}`);
       created++;
       continue;
     }
-    if (existsSync3(dest)) {
+    if (existsSync4(dest)) {
       if (options.force) {
         overwritten++;
-      } else if (options.yes || C.onExisting === "skip") {
+      } else if (options.yes || skipAll || C.onExisting === "skip") {
         skipped++;
         continue;
       } else {
-        const choice = await ask(`\u6587\u4EF6\u5DF2\u5B58\u5728 ${relPath}\uFF1A[s]\u8DF3\u8FC7 / [o]\u8986\u76D6\uFF08\u9ED8\u8BA4 s\uFF09: `);
+        const choice = await ask(`\u6587\u4EF6\u5DF2\u5B58\u5728 ${relPath}\uFF1A[s]\u8DF3\u8FC7 / [o]\u8986\u76D6 / [a]\u5168\u90E8\u8DF3\u8FC7\uFF08\u9ED8\u8BA4 s\uFF09: `);
+        if (choice === "a") {
+          skipAll = true;
+          skipped++;
+          continue;
+        }
         if (choice !== "o" && choice !== "overwrite") {
           skipped++;
           continue;
@@ -199,20 +210,21 @@ var PLACEHOLDERS = {
 function render(content, config) {
   let result = content;
   for (const [placeholder, key] of Object.entries(PLACEHOLDERS)) {
-    result = result.replaceAll(placeholder, config[key]);
+    result = result.replaceAll(placeholder, String(config[key]));
   }
   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"]);
 function renderCore(config, dryRun) {
   const files = /* @__PURE__ */ new Map();
   function walk(dir, base) {
     for (const name of readdirSync(dir)) {
       const full = join4(dir, name);
       if (statSync(full).isDirectory()) {
-        walk(full, join4(base, name));
+        if (!SKIP_DIRS.has(name)) walk(full, join4(base, name));
       } else {
         const content = readFileSync2(full, "utf-8");
         const rendered = render(content, config);
@@ -322,13 +334,13 @@ function renderAdapter3(config, targetDir, dryRun) {
 }
 
 // src/cli/prisma-injector.ts
-import { resolve as resolve2, dirname as dirname6 } from "path";
+import { resolve as resolve3, dirname as dirname6 } from "path";
 import { fileURLToPath as fileURLToPath5 } from "url";
 
 // src/caijuehub/strategies/prisma.strategy.ts
 import { spawnSync } from "child_process";
-import { copyFileSync, existsSync as existsSync4, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync2 } from "fs";
-import { resolve } from "path";
+import { copyFileSync, existsSync as existsSync5, readFileSync as readFileSync6, unlinkSync, writeFileSync as writeFileSync2, mkdirSync as mkdirSync2 } from "fs";
+import { resolve as resolve2 } from "path";
 var PRISMA_CONFIG = {
   onMissing: "ask",
   onExistingAddPrisma: "ask",
@@ -336,70 +348,118 @@ var PRISMA_CONFIG = {
   autoGenerate: true,
   migrationName: "add_workflow_init",
   schemaArg: "--schema=prisma/",
-  requiresUserModel: true
+  requiresUserModel: false
 };
+function ensurePrismaConfig(projectRoot) {
+  const configPath = resolve2(projectRoot, "prisma.config.ts");
+  writeFileSync2(configPath, [
+    'import dotenv from "dotenv";',
+    'import { existsSync } from "fs";',
+    'for (const f of [".env.development.local", ".env.development", ".env.local", ".env"]) {',
+    "  if (existsSync(f)) { dotenv.config({ path: f }); break; }",
+    "}",
+    'import { defineConfig, env } from "prisma/config";',
+    "export default defineConfig({",
+    '  schema: "prisma",',
+    "  datasource: {",
+    '    url: env("DATABASE_URL"),',
+    "  },",
+    "});"
+  ].join("\n") + "\n", "utf-8");
+}
+function backupAddTables(projectRoot) {
+  const pgDump = spawnSync("which", ["pg_dump"], { timeout: 2e3 });
+  if (pgDump.status !== 0) return null;
+  const bak = resolve2(projectRoot, `add-backup-${(/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-").slice(0, 19)}.sql`);
+  const r = spawnSync("pg_dump", ["--table=AddUser", "--table=DevOperation", "--table=AuditLog", "--if-exists"], {
+    cwd: projectRoot,
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: 3e4
+  });
+  if (r.stdout.length > 0) {
+    writeFileSync2(bak, r.stdout, "utf-8");
+    console.log(`>>> \u5907\u4EFD ADD \u8868\u5230 ${bak}`);
+    return bak;
+  }
+  return null;
+}
+function runPrismaInit(projectRoot, provider, schemaPath) {
+  console.log("\u6267\u884C npx prisma init ...");
+  const pm = detectPm(projectRoot);
+  const initArgs = pm === "pnpm" ? ["dlx", "prisma", "init", "--datasource-provider", provider] : ["prisma", "init", "--datasource-provider", provider];
+  const initResult = spawnSync(pm, initArgs, {
+    cwd: projectRoot,
+    stdio: "inherit",
+    shell: false
+  });
+  if (initResult.status !== 0 || !existsSync5(schemaPath)) {
+    console.log("prisma init \u5931\u8D25\uFF0C\u624B\u52A8\u521B\u5EFA schema.prisma ...");
+    const prismaDir = resolve2(projectRoot, "prisma");
+    if (!existsSync5(prismaDir)) mkdirSync2(prismaDir, { recursive: true });
+    const content = `generator client {
+  provider = "prisma-client-js"
+}
+
+datasource db {
+  provider = "${provider}"
+}
+`;
+    writeFileSync2(schemaPath, content, "utf-8");
+    const devEnvPath = resolve2(projectRoot, ".env.development");
+    if (!existsSync5(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");
+    }
+    return false;
+  }
+  return true;
+}
+function postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath) {
+  const envPath = resolve2(projectRoot, ".env");
+  const devEnvPath = resolve2(projectRoot, ".env.development");
+  if (existsSync5(envPath)) {
+    const envContent = readFileSync6(envPath, "utf-8");
+    const dbUrl = envContent.match(/DATABASE_URL=.*/);
+    if (dbUrl) {
+      const existing = existsSync5(devEnvPath) ? readFileSync6(devEnvPath, "utf-8") : "";
+      if (!existing.includes("DATABASE_URL=")) {
+        writeFileSync2(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
+`, "utf-8");
+      }
+      if (existsSync5(envPath)) unlinkSync(envPath);
+      console.log("\u5DF2\u5C06 DATABASE_URL \u8FC1\u79FB\u5230 .env.development");
+    }
+  }
+  copyFileSync(addPrismaTemplate, destPath);
+  console.log("\u5DF2\u590D\u5236 add.prisma");
+}
 async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
   const C = PRISMA_CONFIG;
-  const prismaDir = resolve(projectRoot, "prisma");
-  const schemaPath = resolve(prismaDir, "schema.prisma");
-  const destPath = resolve(prismaDir, "add.prisma");
-  if (!existsSync4(prismaDir) || !existsSync4(schemaPath)) {
+  const prismaDir = resolve2(projectRoot, "prisma");
+  const schemaPath = resolve2(prismaDir, "schema.prisma");
+  const destPath = resolve2(prismaDir, "add.prisma");
+  let justInited = false;
+  if (!existsSync5(prismaDir) || !existsSync5(schemaPath)) {
     if (C.onMissing === "skip") {
       console.log("\u8DF3\u8FC7\uFF1A\u7F3A\u5C11 Prisma");
       return true;
     }
-    if (C.onMissing === "ask" && !options.force && !options.yes) {
+    const shouldInit = options.force || options.yes;
+    if (!shouldInit && C.onMissing === "ask") {
       const a = await ask("\u9879\u76EE\u7F3A\u5C11 Prisma\uFF0C\u662F\u5426\u6267\u884C prisma init\uFF1F[Y/n] ");
-      if (a !== "n" && a !== "no") {
-        console.log("\u6267\u884C npx prisma init ...");
-        spawnSync("npx", ["prisma", "init", "--datasource-provider", "postgresql"], { cwd: projectRoot, stdio: "inherit", shell: false });
-        const envPath = resolve(projectRoot, ".env");
-        const devEnvPath = resolve(projectRoot, ".env.development");
-        if (existsSync4(envPath)) {
-          const envContent = readFileSync6(envPath, "utf-8");
-          const dbUrl = envContent.match(/DATABASE_URL=.*/);
-          if (dbUrl) {
-            const existing = existsSync4(devEnvPath) ? readFileSync6(devEnvPath, "utf-8") : "";
-            if (!existing.includes("DATABASE_URL=")) {
-              writeFileSync2(devEnvPath, `${existing}${existing ? "\n" : ""}${dbUrl[0]}
-`, "utf-8");
-            }
-            if (existsSync4(envPath)) unlinkSync(envPath);
-            console.log("\u5DF2\u5C06 DATABASE_URL \u8FC1\u79FB\u5230 .env.development");
-          }
-        }
-        console.log("\u8BF7\u7F16\u8F91 .env.development \u914D\u7F6E DATABASE_URL\uFF0C\u7136\u540E\u91CD\u65B0\u8FD0\u884C add-coder init \u5B8C\u6210\u8FC1\u79FB");
-        console.log("  \u53EF\u9009\u6587\u4EF6\u4F18\u5148\u7EA7: .env.development.local > .env.development > .env.local > .env");
-        const schemaContent = readFileSync6(schemaPath, "utf-8");
-        if (!/model\s+User\s*\{/.test(schemaContent)) {
-          writeFileSync2(schemaPath, "model User {\n  id String @id @default(cuid())\n}\n\n" + schemaContent, "utf-8");
-          console.log("\u5DF2\u6CE8\u5165 User \u6A21\u578B");
-        }
-        copyFileSync(addPrismaTemplate, destPath);
-        console.log("\u5DF2\u590D\u5236 add.prisma");
-        return true;
+      if (a === "n" || a === "no") {
+        throw new Error("\u9879\u76EE\u7F3A\u5C11 Prisma \u914D\u7F6E\u3002ADD \u5DE5\u4F5C\u6D41\u4F9D\u8D56 Prisma + PostgreSQL\u3002");
       }
+    } else if (!shouldInit) {
+      throw new Error("\u9879\u76EE\u7F3A\u5C11 Prisma \u914D\u7F6E\u3002ADD \u5DE5\u4F5C\u6D41\u4F9D\u8D56 Prisma + PostgreSQL\u3002");
     }
-    throw new Error("\u9879\u76EE\u7F3A\u5C11 Prisma \u914D\u7F6E\u3002ADD \u5DE5\u4F5C\u6D41\u4F9D\u8D56 Prisma + PostgreSQL\u3002");
+    const provider = options.datasource || "postgresql";
+    runPrismaInit(projectRoot, provider, schemaPath);
+    postInitSetup(projectRoot, schemaPath, addPrismaTemplate, destPath);
+    justInited = true;
   }
-  if (C.requiresUserModel && !/model\s+User\s*\{/.test(readFileSync6(schemaPath, "utf-8"))) {
-    const userModel = "model User {\n  id String @id @default(cuid())\n}\n";
-    if (options.yes || options.force) {
-      const schema = readFileSync6(schemaPath, "utf-8");
-      writeFileSync2(schemaPath, userModel + "\n" + schema, "utf-8");
-      console.log("\u5DF2\u6CE8\u5165 User \u6A21\u578B\u5230 schema.prisma");
-    } else {
-      const a = await ask("schema.prisma \u7F3A\u5C11 User \u6A21\u578B\uFF0C\u662F\u5426\u81EA\u52A8\u6CE8\u5165\uFF1F[Y/n] ");
-      if (a !== "n" && a !== "no") {
-        const schema = readFileSync6(schemaPath, "utf-8");
-        writeFileSync2(schemaPath, userModel + "\n" + schema, "utf-8");
-        console.log("\u5DF2\u6CE8\u5165 User \u6A21\u578B");
-      } else {
-        throw new Error("\u9700\u8981 User \u6A21\u578B\uFF08id: String\uFF09\uFF0C\u8BF7\u5728 prisma/schema.prisma \u4E2D\u521B\u5EFA\u540E\u91CD\u8BD5\u3002");
-      }
-    }
-  }
-  if (existsSync4(destPath)) {
+  if (existsSync5(destPath) && !justInited) {
     if (options.dryRun) {
       console.log("[dry-run] \u5DF2\u6709 add.prisma");
       return true;
@@ -429,17 +489,19 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     }
   }
   if (options.dryRun) {
-    console.log("[dry-run] \u5C06\u6267\u884C prisma migrate");
+    console.log("[dry-run] \u5C06\u6267\u884C prisma db push");
     return true;
   }
-  copyFileSync(addPrismaTemplate, destPath);
-  console.log("\u5DF2\u590D\u5236 add.prisma");
+  if (!justInited) copyFileSync(addPrismaTemplate, destPath);
   try {
-    const args = ["prisma", "migrate", "dev", "--name", C.migrationName];
+    ensurePrismaConfig(projectRoot);
+    backupAddTables(projectRoot);
+    const pm = detectPm(projectRoot);
+    const args = pm === "pnpm" ? ["dlx", "prisma", "db", "push"] : ["prisma", "db", "push"];
     if (C.schemaArg) args.push(C.schemaArg);
-    console.log(`\u6267\u884C npx ${args.join(" ")} ...`);
-    const r = spawnSync("npx", args, { cwd: projectRoot, stdio: "inherit", shell: false });
-    if (r.status !== 0) throw new Error(`prisma migrate dev \u9000\u51FA\u7801: ${r.status}`);
+    console.log(`\u6267\u884C ${pm} ${args.join(" ")} ...`);
+    const r = spawnSync(pm, args, { cwd: projectRoot, stdio: "inherit", shell: false });
+    if (r.status !== 0) throw new Error(`prisma db push \u9000\u51FA\u7801: ${r.status}`);
   } catch (err) {
     if (C.onMigrateFail === "keep") {
       console.log("\u8FC1\u79FB\u5931\u8D25\uFF0C\u4FDD\u7559\u6587\u4EF6");
@@ -453,8 +515,9 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
     throw new Error(`\u8FC1\u79FB\u5931\u8D25: ${err instanceof Error ? err.message : String(err)}`);
   }
   if (C.autoGenerate) {
+    const pm = detectPm(projectRoot);
     console.log("\u6267\u884C prisma generate ...");
-    spawnSync("npx", ["prisma", "generate"], { cwd: projectRoot, stdio: "inherit", shell: false });
+    spawnSync(pm, pm === "pnpm" ? ["dlx", "prisma", "generate"] : ["prisma", "generate"], { cwd: projectRoot, stdio: "inherit", shell: false });
   }
   console.log("ADD \u6CBB\u7406\u6A21\u578B\u5DF2\u5C31\u7EEA");
   return true;
@@ -463,69 +526,314 @@ async function injectPrisma(projectRoot, addPrismaTemplate, options = {}) {
 // src/cli/prisma-injector.ts
 var __filename5 = fileURLToPath5(import.meta.url);
 var __dirname5 = dirname6(__filename5);
-var ADD_PRISMA_TEMPLATE = resolve2(__dirname5, "../templates/core/prisma/add.prisma");
+var ADD_PRISMA_TEMPLATE = resolve3(__dirname5, "../templates/core/prisma/add.prisma");
 async function injectPrisma2(projectRoot, options = {}) {
   return injectPrisma(projectRoot, ADD_PRISMA_TEMPLATE, options);
 }
 
 // src/cli/commands/init.ts
+import { readFileSync as readFileSync7, writeFileSync as writeFileSync3, existsSync as existsSync6, mkdirSync as mkdirSync3 } from "fs";
+import { resolve as resolve4 } from "path";
+import { spawnSync as spawnSync2 } from "child_process";
+import { createConnection } from "net";
 var ADAPTER_RENDERERS = {
   claude: renderAdapter,
   qoder: renderAdapter2,
   vscode: renderAdapter3
 };
+var MAGIC_DIR_MAP = { claude: ".claude", qoder: ".qoder", vscode: ".vscode" };
+async function resolveAdapter(projectRoot, specified) {
+  if (specified) {
+    if (!MAGIC_DIR_MAP[specified]) throw new Error(`\u672A\u77E5 adapter: ${specified}`);
+    console.log(`\u76EE\u6807 IDE: ${specified} (--adapter)`);
+    return specified;
+  }
+  const detected = detectIDE2(projectRoot);
+  if (detected !== "auto") {
+    console.log(`\u68C0\u6D4B\u5230 IDE: ${detected} (\u81EA\u52A8)`);
+    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();
+  if (a === "1" || a === "qoder") return "qoder";
+  if (a === "2" || a === "claude") return "claude";
+  if (a === "3" || a === "vscode") return "vscode";
+  console.log("\u8F93\u5165\u65E0\u6CD5\u8BC6\u522B\uFF0C\u9ED8\u8BA4 qoder");
+  return "qoder";
+}
+async function resolveDbEngine(force) {
+  if (force) {
+    console.log("\u6570\u636E\u5E93\u5F15\u64CE: PostgreSQL (--force \u9ED8\u8BA4)");
+    return { engine: "postgresql", container: "podman" };
+  }
+  console.log(["", "\u6570\u636E\u5E93\u5F15\u64CE:", "  [1] PostgreSQL (\u63A8\u8350)", "  [2] SQLite \u2014 \u96F6\u4F9D\u8D56", "  [3] \u81EA\u884C\u7BA1\u7406"].join("\n"));
+  const a = (await ask("\u8BF7\u9009\u62E9 [1/2/3] \u2192 ")).trim();
+  if (a === "2" || a === "sqlite") return { engine: "sqlite" };
+  if (a === "3" || a === "manual") return { engine: "manual" };
+  if (a !== "" && a !== "1" && !a.startsWith("postgres")) console.log("\u8F93\u5165\u65E0\u6CD5\u8BC6\u522B\uFF0C\u9ED8\u8BA4 PostgreSQL");
+  return { engine: "postgresql" };
+}
+async function resolveContainer(force) {
+  if (force) return "podman";
+  console.log(["", "\u5BB9\u5668\u8FD0\u884C\u65F6:", "  [1] podman (\u63A8\u8350)", "  [2] docker", "  [3] \u81EA\u884C\u7BA1\u7406"].join("\n"));
+  const a = (await ask("\u8BF7\u9009\u62E9 [1/2/3] \u2192 ")).trim();
+  if (a === "2" || a === "docker") return "docker";
+  if (a === "3" || a === "manual") return "manual";
+  if (a !== "" && a !== "1" && a !== "podman") console.log("\u8F93\u5165\u65E0\u6CD5\u8BC6\u522B\uFF0C\u9ED8\u8BA4 podman");
+  return "podman";
+}
+function portInUse(port) {
+  return new Promise((r) => {
+    const s = createConnection({ port, host: "127.0.0.1" }, () => {
+      s.destroy();
+      r(true);
+    });
+    s.on("error", () => r(false));
+  });
+}
+function hasPgIsready() {
+  try {
+    const containers = spawnSync2("podman", ["ps", "--filter", "publish=5433", "--format", "{{.Names}}"], { timeout: 3e3 });
+    const name = containers.stdout.toString().trim().split("\n")[0];
+    if (name && spawnSync2("podman", ["exec", name, "pg_isready", "--version"], { timeout: 2e3 }).status === 0) return true;
+  } catch {
+  }
+  return spawnSync2("which", ["pg_isready"], { timeout: 2e3 }).status === 0;
+}
+function testPostgresConnection(port, user, password, dbName) {
+  if (!hasPgIsready()) {
+    console.log("  \u26A0\uFE0F  \u65E0\u6CD5\u9A8C\u8BC1\u51ED\u636E\uFF08\u5BB9\u5668\u672A\u8FD0\u884C\u4E14 pg_isready \u672A\u5B89\u88C5\uFF09\uFF0C\u4FE1\u4EFB\u8F93\u5165");
+    return true;
+  }
+  const containers = spawnSync2("podman", ["ps", "--filter", "publish=5433", "--format", "{{.Names}}"], { timeout: 3e3 });
+  const containerName = containers.stdout.toString().trim().split("\n")[0];
+  const args = containerName ? ["exec", containerName, "pg_isready", "-U", user, "-d", dbName] : ["-h", "localhost", "-p", port, "-U", user, "-d", dbName];
+  const cmd = containerName ? "podman" : "pg_isready";
+  const r = spawnSync2(cmd, args, {
+    timeout: 5e3,
+    env: containerName ? process.env : { ...process.env, PGPASSWORD: password }
+  });
+  return r.status === 0;
+}
+async function resolveDbCredentials(force) {
+  const d = { user: "admin", password: "change-me-in-production", port: "5433" };
+  if (force) return d;
+  console.log("", "\u6570\u636E\u5E93\u51ED\u636E\uFF08\u56DE\u8F66\u4F7F\u7528\u9884\u8BBE\u503C\uFF09\uFF1A");
+  let port = (await ask(`DATABASE_PORT [${d.port}]: `)).trim() || d.port;
+  while (true) {
+    const portNum = parseInt(port);
+    if (!isNaN(portNum) && await portInUse(portNum)) {
+      console.log(`
+\u26A0\uFE0F  \u7AEF\u53E3 ${port} \u5DF2\u88AB\u5360\u7528`);
+      const choice = (await ask("  [1] \u6362\u7AEF\u53E3  [2] \u8FDE\u63A5\u5DF2\u6709\u5B9E\u4F8B\uFF08\u8F93\u5165\u5176\u7528\u6237/\u5BC6\u7801\uFF09\u2192 ")).trim();
+      if (choice === "2") {
+        const existingUser = (await ask(`  \u7528\u6237: `)).trim() || "admin";
+        const existingPass = (await ask(`  \u5BC6\u7801: `)).trim() || "change-me-in-production";
+        const testDb = (await ask(`  \u6D4B\u8BD5\u6570\u636E\u540D (\u9ED8\u8BA4 postgres): `)).trim() || "postgres";
+        const ok = testPostgresConnection(port, existingUser, existingPass, testDb);
+        if (ok) {
+          console.log(`  \u2705 \u8FDE\u63A5\u6210\u529F`);
+          return { user: existingUser, password: existingPass, port, reuseExisting: true };
+        } else {
+          console.log(`  \u274C \u8FDE\u63A5\u5931\u8D25\uFF0C\u8BF7\u68C0\u67E5\u51ED\u636E`);
+        }
+      }
+    } else {
+      break;
+    }
+    port = (await ask(`DATABASE_PORT: `)).trim() || d.port;
+  }
+  return { user: (await ask(`DATABASE_USER [${d.user}]: `)).trim() || d.user, password: (await ask(`DATABASE_PASSWORD [${d.password}]: `)).trim() || d.password, port };
+}
+function composeContent(projectName) {
+  return `services:
+  postgres:
+    image: docker.io/postgres:16-alpine
+    container_name: \${PROJECT_NAME:-${projectName}}-postgres
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:\${DATABASE_PORT:-5433}:5432"
+    volumes:
+      - ./data/postgres/\${PROJECT_NAME:-${projectName}}:/var/lib/postgresql/data
+    env_file:
+      - .env.development
+    environment:
+      POSTGRES_USER: \${DATABASE_USER:-admin}
+      POSTGRES_PASSWORD: \${DATABASE_PASSWORD:-change-me-in-production}
+      POSTGRES_DB: \${PROJECT_NAME:-${projectName}}
+      TZ: "Asia/Shanghai"
+    networks:
+      - \${PROJECT_NAME:-${projectName}}-network
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U \${DATABASE_USER:-admin} -d \${PROJECT_NAME:-${projectName}}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5
+
+networks:
+  \${PROJECT_NAME:-${projectName}}-network:
+    driver: bridge
+`;
+}
+function writeSqliteExportScript(projectRoot, dryRun) {
+  const scriptsDir = resolve4(projectRoot, "scripts");
+  const scriptPath = resolve4(scriptsDir, "export-db.ts");
+  const content = `import { PrismaClient } from "@prisma/client";
+import { writeFileSync, mkdirSync, existsSync } from "fs";
+import { resolve } from "path";
+
+const prisma = new PrismaClient();
+const EXPORTS_DIR = resolve(process.cwd(), "data/exports");
+
+async function main() {
+    if (!existsSync(EXPORTS_DIR)) mkdirSync(EXPORTS_DIR, { recursive: true });
+    const ts = new Date().toISOString().replace(/[:.]/g, "-").slice(0, 19);
+    const auditLogs = await prisma.auditLog.findMany({ orderBy: { createdAt: "desc" } });
+    const devOps = await prisma.devOperation.findMany({ orderBy: { createdAt: "desc" } });
+    writeFileSync(resolve(EXPORTS_DIR, \`audit-export-\${ts}.json\`), JSON.stringify({ exportedAt: new Date().toISOString(), auditLogs: { count: auditLogs.length, rows: auditLogs }, devOperations: { count: devOps.length, rows: devOps } }, null, 2), "utf-8");
+    console.log(\`\u5DF2\u5BFC\u51FA \${auditLogs.length} AuditLog + \${devOps.length} DevOperation\`);
+    await prisma.\\$disconnect();
+}
+
+main().catch((e) => { console.error(e); process.exit(1); });
+`;
+  if (dryRun) {
+    console.log(`[dry-run] \u5C06\u5199\u5165 ${scriptPath}`);
+    return;
+  }
+  if (!existsSync6(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 = resolve4(projectRoot, "package.json");
+  if (!existsSync6(pkgPath)) return;
+  if (dryRun) {
+    console.log("[dry-run] \u5C06\u6CE8\u5165 db:export");
+    return;
+  }
+  const pkg = JSON.parse(readFileSync7(pkgPath, "utf-8"));
+  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");
+    console.log("\u5DF2\u5728 package.json \u6CE8\u5165 db:export");
+  }
+}
 async function initCommand(options) {
   const projectRoot = process.cwd();
-  const specified = options.adapter && options.adapter !== "auto" ? options.adapter : null;
-  const target = specified || detectIDE2(projectRoot);
-  console.log(`\u68C0\u6D4B\u5230 IDE: ${target}${specified ? " (--adapter)" : " (\u81EA\u52A8)"}`);
-  const config = await loadConfig(projectRoot, options.config, { yes: options.yes, force: options.force });
+  const target = await resolveAdapter(projectRoot, options.adapter);
+  const magicDir = MAGIC_DIR_MAP[target];
+  const config = await loadConfig(projectRoot, options.config, { force: options.force });
   config.projectRoot = projectRoot;
-  const MAGIC_DIR_MAP = { claude: ".claude", qoder: ".qoder", vscode: ".vscode" };
-  const magicDir = MAGIC_DIR_MAP[target] || ".qoder";
-  console.log(`magicDir: ${magicDir}`);
-  const renderConfig = { ...config, magicDir };
-  if (!options.dryRun) {
-    await injectPrisma2(projectRoot, { yes: options.yes, force: options.force, dryRun: options.dryRun });
+  config.magicDir = magicDir;
+  const db = await resolveDbEngine(!!options.force);
+  if (db.engine === "postgresql") {
+    db.container = await resolveContainer(!!options.force);
+    if (db.container && db.container !== "manual") {
+      Object.assign(db, await resolveDbCredentials(!!options.force));
+    }
+  }
+  if (db.engine === "postgresql" && db.container && db.container !== "manual") {
+    if (!db.reuseExisting) {
+      const composeName = db.container === "podman" ? "podman-compose.yml" : "docker-compose.yml";
+      const composePath = resolve4(projectRoot, composeName);
+      if (!options.dryRun && (!existsSync6(composePath) || options.force)) {
+        writeFileSync3(composePath, composeContent(config.projectName || "add-project"), "utf-8");
+        console.log(`\u5DF2\u521B\u5EFA ${composeName}`);
+      }
+    }
+    const devEnvPath = resolve4(projectRoot, ".env.development");
+    if (!options.dryRun && existsSync6(devEnvPath)) {
+      const existing = readFileSync7(devEnvPath, "utf-8");
+      if (!/^DATABASE_USER=/m.test(existing)) {
+        writeFileSync3(devEnvPath, existing + `
+DATABASE_USER=${db.user || "admin"}
+DATABASE_PASSWORD=${db.password || "change-me-in-production"}
+DATABASE_PORT=${db.port || "5433"}
+PROJECT_NAME=${config.projectName || "add-project"}
+`, "utf-8");
+        console.log("\u5DF2\u5C06\u51ED\u636E\u8FFD\u52A0\u5230 .env.development");
+      }
+    }
   }
-  const coreFiles = renderCore(renderConfig, !!options.dryRun);
+  const coreFiles = renderCore(config, !!options.dryRun);
   console.log(`Core \u6A21\u677F: ${coreFiles.size} \u6587\u4EF6`);
-  const CORE_TARGETS = [".add", ".qoder", ".claude"];
+  const CORE_TARGETS = [".add", ".qoder", ".claude", ".vscode"];
   const allFiles = /* @__PURE__ */ new Map();
   for (const [relPath, content] of coreFiles) {
-    for (const target2 of CORE_TARGETS) {
-      const targetPath = relPath.replace(/^\.add/, target2);
-      if (!allFiles.has(targetPath)) {
-        allFiles.set(targetPath, content);
-      }
+    for (const t of CORE_TARGETS) {
+      const targetPath = relPath.replace(/^\.add/, t);
+      if (!allFiles.has(targetPath)) allFiles.set(targetPath, content);
     }
   }
-  const adapters = resolveAdapters2(target);
-  for (const adapter of adapters) {
+  for (const adapter of resolveAdapters2(target)) {
     const renderFn = ADAPTER_RENDERERS[adapter];
     if (renderFn) {
       const adapterFiles = renderFn(config, projectRoot, !!options.dryRun);
-      for (const [path, content] of adapterFiles) {
-        allFiles.set(path, content);
-      }
+      for (const [p, c] of adapterFiles) allFiles.set(p, c);
       console.log(`${adapter} adapter: ${adapterFiles.size} \u6587\u4EF6`);
     }
   }
-  const result = await writeFiles2(projectRoot, allFiles, {
-    yes: options.yes,
-    force: options.force,
-    dryRun: options.dryRun
-  });
+  const result = await writeFiles2(projectRoot, allFiles, { force: options.force, dryRun: options.dryRun });
+  if (db.engine === "postgresql" && db.container && db.container !== "manual") {
+    if (!options.dryRun) {
+      const dbScript = resolve4(projectRoot, ".qoder", "scripts", "db-ensure.sh");
+      const dbEnv = { ...process.env, DATABASE_USER: db.user, DATABASE_PASSWORD: db.password, DATABASE_PORT: db.port, PROJECT_NAME: config.projectName };
+      const mode = db.reuseExisting ? "manual" : db.container;
+      console.log(db.reuseExisting ? "\u590D\u7528\u5DF2\u6709 PostgreSQL ..." : `\u90E8\u7F72\u6570\u636E\u5E93 (${db.container}) ...`);
+      spawnSync2("bash", [dbScript, "postgresql", mode, "--migrate"], { cwd: projectRoot, stdio: "inherit", env: dbEnv });
+      try {
+        await injectPrisma2(projectRoot, { force: !!options.force });
+      } catch (e) {
+        console.log(`Prisma \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
+  if (db.engine === "postgresql" && db.container === "manual") {
+    if (!options.dryRun) {
+      const dbScript = resolve4(projectRoot, ".qoder", "scripts", "db-ensure.sh");
+      if (existsSync6(dbScript)) spawnSync2("bash", [dbScript, "postgresql", "manual"], { cwd: projectRoot, stdio: "inherit" });
+      console.log(["", "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501", "ADD \u6A21\u677F\u5DF2\u5C31\u4F4D\u3002\u5728\u5B8C\u6210\u4EE5\u4E0B\u64CD\u4F5C\u524D MCP \u4E0D\u53EF\u7528\uFF1A", "", "1. \u7F16\u8F91 .env.development\uFF0C\u914D\u7F6E DATABASE_URL", "2. \u91CD\u65B0\u8FD0\u884C add-coder init \u5B8C\u6210\u8FC1\u79FB", "", "\u26A0\uFE0F  \u975E PG \u6570\u636E\u5E93\u9700\u7F16\u8F91 .qoder/scripts/mcp-server.ts \u624B\u52A8\u914D Prisma 7 adapter", "\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501\u2501"].join("\n"));
+    }
+  }
+  if (db.engine === "manual") {
+    if (!options.dryRun) {
+      console.log(["", "Prisma \u652F\u6301\u7684 datasource: postgresql / mysql / sqlite / sqlserver / cockroachdb", "\u81EA\u884C prisma init + \u7F16\u8F91 .env.development\uFF0C\u91CD\u65B0 run init \u5B8C\u6210\u8FC1\u79FB\u3002", "", "\u26A0\uFE0F Prisma 7 adapter \u9700\u624B\u52A8\u914D \u2192 .qoder/scripts/mcp-server.ts"].join("\n"));
+    }
+  }
+  if (db.engine === "sqlite") {
+    writeSqliteExportScript(projectRoot, !!options.dryRun);
+    injectDbExportScript(projectRoot, !!options.dryRun);
+    if (!options.dryRun) {
+      try {
+        await injectPrisma2(projectRoot, { force: !!options.force, datasource: "sqlite" });
+      } catch (e) {
+        console.log(`SQLite \u540C\u6B65\u5931\u8D25: ${e instanceof Error ? e.message : String(e)}`);
+      }
+    }
+  }
   console.log(`
 \u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}, \u8986\u76D6 ${result.overwritten}`);
   if (!options.dryRun) {
-    console.log("\u63D0\u793A: \u91CD\u542F IDE \u4EE5\u52A0\u8F7D hook \u914D\u7F6E");
+    if (db.engine === "sqlite") console.log("\u6570\u636E\u5907\u4EFD: npm run db:export \u2192 data/exports/");
+    const pkg = JSON.parse(readFileSync7(resolve4(import.meta.dirname, "../package.json"), "utf-8"));
+    const peerNames = Object.keys(pkg.peerDependencies || {});
+    if (peerNames.length > 0) {
+      console.log(`
+\u5B89\u88C5 peer \u4F9D\u8D56 (${peerNames.join(" ")}) ...`);
+      const pm = detectPm(projectRoot);
+      spawnSync2(pm, pm === "pnpm" ? ["add", ...peerNames] : ["install", ...peerNames], { cwd: projectRoot, stdio: "inherit" });
+    }
+    if (db.engine !== "manual" && (db.engine !== "postgresql" || db.container !== "manual")) {
+      console.log("\u63D0\u793A: \u91CD\u542F IDE \u4EE5\u52A0\u8F7D hook \u914D\u7F6E");
+    }
   }
 }
 
 // src/cli/commands/sync.ts
-import { existsSync as existsSync5 } from "fs";
-import { resolve as resolve3 } from "path";
+import { existsSync as existsSync7 } from "fs";
+import { resolve as resolve5 } from "path";
 async function syncCommand() {
   const projectRoot = process.cwd();
   const config = await loadConfig(projectRoot);
@@ -533,7 +841,7 @@ async function syncCommand() {
   const coreFiles = renderCore(config, false);
   const missing = /* @__PURE__ */ new Map();
   for (const [relPath, content] of coreFiles) {
-    if (!existsSync5(resolve3(projectRoot, relPath))) {
+    if (!existsSync7(resolve5(projectRoot, relPath))) {
       missing.set(relPath, content);
     }
   }
@@ -541,13 +849,13 @@ async function syncCommand() {
     console.log("\u6240\u6709 ADD \u6A21\u677F\u6587\u4EF6\u5DF2\u5C31\u4F4D\u3002");
     return;
   }
-  const result = await writeFiles2(projectRoot, missing, { yes: true });
+  const result = await writeFiles2(projectRoot, missing, {});
   console.log(`\u540C\u6B65\u5B8C\u6210: \u65B0\u5EFA ${result.created}, \u8DF3\u8FC7 ${result.skipped}`);
 }
 
 // src/cli/commands/status.ts
-import { existsSync as existsSync6 } from "fs";
-import { resolve as resolve4 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { resolve as resolve6 } from "path";
 async function statusCommand() {
   const projectRoot = process.cwd();
   const config = await loadConfig(projectRoot);
@@ -556,29 +864,29 @@ async function statusCommand() {
   const missing = [];
   const present = [];
   for (const [relPath] of coreFiles) {
-    if (existsSync6(resolve4(projectRoot, relPath))) {
+    if (existsSync8(resolve6(projectRoot, relPath))) {
       present.push(relPath);
     } else {
       missing.push(relPath);
     }
   }
-  console.log(`ADD \u6A21\u677F\u5B8C\u6574\u6027\u68C0\u67E5:`);
+  console.log("ADD \u6A21\u677F\u5B8C\u6574\u6027\u68C0\u67E5:");
   console.log(`  \u5DF2\u5C31\u4F4D: ${present.length} \u6587\u4EF6`);
   if (missing.length > 0) {
     console.log(`  \u7F3A\u5931: ${missing.length} \u6587\u4EF6`);
     missing.forEach((f) => console.log(`    - ${f}`));
   } else {
-    console.log(`  \u6240\u6709\u6587\u4EF6\u5B8C\u6574\u3002`);
+    console.log("  \u6240\u6709\u6587\u4EF6\u5B8C\u6574\u3002");
   }
 }
 
 // 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);
-program.command("init").description("\u521D\u59CB\u5316 ADD \u6A21\u677F\u5230\u5F53\u524D\u9879\u76EE").option("--adapter <type>", "\u76EE\u6807 IDE: claude | qoder | vscode | auto", "auto").option("--config <path>", "\u6307\u5B9A\u914D\u7F6E\u6587\u4EF6\u8DEF\u5F84").option("--yes", "\u8DF3\u8FC7\u4EA4\u4E92\uFF0C\u53EA\u521B\u5EFA\u65B0\u6587\u4EF6").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("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").action(syncCommand);
 program.command("status").description("\u68C0\u67E5 ADD \u6A21\u677F\u5B8C\u6574\u6027").action(statusCommand);
 program.parse();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "add-coder",
-  "version": "0.1.8",
+  "version": "0.1.9",
   "private": false,
   "description": "[codein2027](https://github.com/xiaomingming92/codein2027) 快速构建 ADD 编程范式的完整脚手架——AI 代码治理的落地方案。以「审计即基础设施」为核心，彻底打破编程过程黑盒与跨轮失忆，让编程范式进化为可审计、可追溯、可收敛的新时代。npx 即用，人人可体验。",
   "type": "module",
@@ -39,8 +39,14 @@
     "zod": "^3.24.0"
   },
   "peerDependencies": {
-    "@prisma/client": "^6.9.0 || ^7.0.0",
-    "prisma": "^6.9.0 || ^7.0.0"
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "@prisma/adapter-libsql": "^7.0.0",
+    "@prisma/adapter-pg": "^7.0.0",
+    "@prisma/client": "^7.0.0",
+    "dotenv": "*",
+    "prisma": "^7.0.0",
+    "tsx": "*",
+    "zod": "^3.24.0"
   },
   "peerDependenciesMeta": {
     "@prisma/client": {
@@ -48,6 +54,24 @@
     },
     "prisma": {
       "optional": false
+    },
+    "@modelcontextprotocol/sdk": {
+      "optional": false
+    },
+    "zod": {
+      "optional": false
+    },
+    "dotenv": {
+      "optional": false
+    },
+    "tsx": {
+      "optional": false
+    },
+    "@prisma/adapter-pg": {
+      "optional": true
+    },
+    "@prisma/adapter-libsql": {
+      "optional": true
     }
   },
   "devDependencies": {
@@ -56,14 +80,17 @@
     "eslint": "^9.39.4",
     "tsup": "^8.4.0",
     "typescript": "^6.0.3",
-    "typescript-eslint": "^8.62.1"
+    "typescript-eslint": "^8.62.1",
+    "vitest": "^4.1.10"
   },
   "scripts": {
     "build": "tsup",
+    "predev": "npm run db:ensure",
     "dev": "tsup --watch",
+    "db:ensure": "bash scripts/db-ensure.sh",
     "lint": "eslint src/",
     "lint:fix": "eslint src/ --fix",
     "generate": "tsx src/caijuehub/transcribe.ts",
-    "test": "node bin/add-coder.js --help"
+    "test": "vitest run"
   }
 }

package/templates/core/podman-compose.yml

@@ -0,0 +1,19 @@
+services:
+  postgres:
+    image: docker.io/postgres:16-alpine
+    container_name: {{projectName}}-postgres
+    restart: unless-stopped
+    ports:
+      - "127.0.0.1:5433:5432"
+    volumes:
+      - ./data/postgres:/var/lib/postgresql/data
+    environment:
+      POSTGRES_DB: {{projectName}}
+      POSTGRES_USER: admin
+      POSTGRES_PASSWORD: ${POSTGRES_PASSWORD}
+      TZ: "Asia/Shanghai"
+    healthcheck:
+      test: ["CMD-SHELL", "pg_isready -U admin -d {{projectName}}"]
+      interval: 10s
+      timeout: 5s
+      retries: 5

package/templates/core/prisma/add.prisma

@@ -1,10 +1,17 @@
-// add.prisma — ADD 治理模型（npm 包写入，不修改用户业务文件）
-// 前置条件：用户项目必须已有 User 模型（id: String），否则 prisma migrate 失败
+// add.prisma — ADD 治理模型，独立于用户业务表
+
+model AddUser {
+  id              String          @id @default(cuid())
+  username        String          @unique
+  email           String?
+  devOperations   DevOperation[]
+  auditLogs       AuditLog[]
+}
 
 model DevOperation {
   id          String   @id @default(cuid())
   userId      String
-  user        User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  user        AddUser  @relation(fields: [userId], references: [id], onDelete: Cascade)
   planKeyword String
   action      String
   targetType  String
@@ -20,7 +27,7 @@ model DevOperation {
 model AuditLog {
   id          String   @id @default(cuid())
   userId      String
-  user        User     @relation(fields: [userId], references: [id], onDelete: Cascade)
+  user        AddUser  @relation(fields: [userId], references: [id], onDelete: Cascade)
   action      String
   targetType  String
   targetId    String
@@ -31,4 +38,4 @@ model AuditLog {
   createdAt   DateTime @default(now())
 
   @@index([traceId])
-}
+}

package/templates/core/scripts/db-ensure.sh

@@ -0,0 +1,83 @@
+#!/usr/bin/env bash
+# db-ensure.sh — 容器启动 + 环境准备
+# prisma init/copy/push/generate 由 init.ts → injectPrisma() 裁决层处理
+# 用法: bash db-ensure.sh <engine> <container> [--migrate]
+set -euo pipefail
+
+ENGINE="${1:-postgresql}"
+CONTAINER="${2:-none}"
+DO_MIGRATE="false"
+[[ "${3:-}" == "--migrate" ]] && DO_MIGRATE="true"
+
+PROJECT_DIR="${PROJECT_DIR:-$(pwd)}"
+PROJECT_NAME="${PROJECT_NAME:-$(basename "$PROJECT_DIR")}"
+DB_USER="${DATABASE_USER:-admin}"
+DB_PASS="${DATABASE_PASSWORD:-change-me-in-production}"
+DB_PORT="${DATABASE_PORT:-5433}"
+DB_URL="postgresql://${DB_USER}:${DB_PASS}@localhost:${DB_PORT}/${PROJECT_NAME}?schema=public"
+
+# ADD 表备份
+backup_add_tables() {
+  if ! command -v pg_dump > /dev/null 2>&1; then return; fi
+  local bak="add-backup-$(date +%Y%m%d_%H%M%S).sql"
+  echo ">>> 备份 ADD 表到 $bak ..."
+  PGPASSWORD="$DB_PASS" pg_dump -h localhost -p "$DB_PORT" -U "$DB_USER" -d "$PROJECT_NAME" \
+    --table=AddUser --table=DevOperation --table=AuditLog --if-exists > "$bak" 2>/dev/null || true
+}
+
+# 0. 确保 .env.development 存在
+if [ ! -f "$PROJECT_DIR/.env.development" ]; then
+  cat > "$PROJECT_DIR/.env.development" <<EOF
+DATABASE_URL="${DB_URL}"
+DATABASE_USER=${DB_USER}
+DATABASE_PASSWORD=${DB_PASS}
+DATABASE_PORT=${DB_PORT}
+PROJECT_NAME=${PROJECT_NAME}
+EOF
+  echo ">>> 已创建 .env.development"
+fi
+
+# ── SQLite：无需容器 ──
+if [ "$ENGINE" = "sqlite" ]; then exit 0; fi
+
+# ── 自行管理 PostgreSQL ──
+if [ "$CONTAINER" = "none" ] || [ "$CONTAINER" = "manual" ]; then
+  echo ">>> 自行管理 PostgreSQL，跳过容器 ..."
+  if [ "$DO_MIGRATE" = "true" ]; then
+    backup_add_tables
+  fi
+  exit 0
+fi
+
+# ── 容器模式 ──
+COMPOSE_CMD=""
+if [ "$CONTAINER" = "podman" ]; then COMPOSE_CMD="podman-compose"
+elif [ "$CONTAINER" = "docker" ]; then COMPOSE_CMD="docker-compose"
+else echo "未知容器: $CONTAINER"; exit 1
+fi
+
+echo ">>> 启动 PostgreSQL ($COMPOSE_CMD up -d) ..."
+$COMPOSE_CMD up -d || {
+  echo "容器启动失败，请检查 $COMPOSE_CMD 是否已安装或端口是否冲突"
+  exit 1
+}
+
+# 等待 PostgreSQL 就绪
+echo ">>> 等待 PostgreSQL 就绪 ..."
+MAX_RETRIES=30
+RETRY=0
+while [ $RETRY -lt $MAX_RETRIES ]; do
+  if $COMPOSE_CMD exec -T postgres pg_isready -U "$DB_USER" > /dev/null 2>&1; then
+    echo "PostgreSQL 已就绪"; break
+  fi
+  sleep 1
+  RETRY=$((RETRY + 1))
+done
+if [ $RETRY -ge $MAX_RETRIES ]; then
+  echo "PostgreSQL 启动超时，请检查: $COMPOSE_CMD logs postgres"
+  exit 1
+fi
+
+if [ "$DO_MIGRATE" = "true" ]; then
+  backup_add_tables
+fi

package/templates/core/scripts/mcp-server.ts

@@ -11,7 +11,7 @@ const MAGIC_DIR = basename(dirname(__dirname)) // ".qoder" or ".claude"
 const ENV_CANDIDATES = [".env.development.local", ".env.development", ".env.local", ".env"];
 for (const f of ENV_CANDIDATES) {
     const p = resolve(PROJECT_ROOT, f);
-    if (existsSync(p)) { dotenv.config({ path: p }); break; }
+    if (existsSync(p)) { dotenv.config({ path: p, override: true }); break; }
 }
 
 const DATABASE_URL = process.env.DATABASE_URL
@@ -26,10 +26,25 @@ import { readFile, readdir, stat, mkdir, writeFile } from "fs/promises"
 import { join, relative } from "path"
 import { existsSync } from "fs"
 import { spawnSync } from "child_process"
-import { PrismaClient, Prisma } from "@prisma/client"
+
+const { PrismaClient } = await import("@prisma/client").catch(() =>
+  import("../../generated/prisma/client.js").catch(() =>
+    import("../../src/generated/prisma/client.js"))
+)
+
+// Prisma 7 按 DATABASE_URL 前缀自动选 adapter
+let adapter = undefined
+if (DATABASE_URL.startsWith("postgresql://") || DATABASE_URL.startsWith("postgres://")) {
+  const { PrismaPg } = await import("@prisma/adapter-pg")
+  adapter = new PrismaPg({ connectionString: DATABASE_URL })
+} else if (DATABASE_URL.startsWith("file:") || DATABASE_URL.startsWith("sqlite:")) {
+  const { PrismaLibSQL } = await import("@prisma/adapter-libsql")
+  const url = DATABASE_URL.replace(/^file:/, "")
+  adapter = new PrismaLibSQL({ url })
+}
 
 const prisma = new PrismaClient({
-  datasourceUrl: DATABASE_URL,
+  ...(adapter ? { adapter } : {}),
   log: process.env.NODE_ENV === "development" ? ["error", "warn"] : ["error"],
 })
 
@@ -1108,11 +1123,11 @@ server.registerTool(
         }
       }
 
-      let parsedBefore: Prisma.InputJsonValue | undefined
-      let parsedAfter: Prisma.InputJsonValue | undefined
+      let parsedBefore: any | undefined
+      let parsedAfter: any | undefined
       try {
-        if (beforeState) parsedBefore = JSON.parse(beforeState) as Prisma.InputJsonValue
-        if (afterState) parsedAfter = JSON.parse(afterState) as Prisma.InputJsonValue
+        if (beforeState) parsedBefore = JSON.parse(beforeState)
+        if (afterState) parsedAfter = JSON.parse(afterState)
       } catch {
         const beforePreview = beforeState ? beforeState.slice(0, 80) : "(未传)"
         const afterPreview = afterState ? afterState.slice(0, 80) : "(未传)"
@@ -1123,18 +1138,17 @@ server.registerTool(
         )
       }
 
-      let systemUser = await prisma.user.findUnique({
+      let systemUser = await prisma.addUser.findUnique({
         where: { username: "ai-assistant" },
         select: { id: true },
       })
 
       if (!systemUser) {
-        systemUser = await prisma.user.create({
+        systemUser = await prisma.addUser.create({
           data: {
             id: "ai-assistant",
             username: "ai-assistant",
-            email: "ai-assistant@internal",
-            password: "internal",
+            email: "ai-assistant@internal"
           },
           select: { id: true },
         })
@@ -1147,8 +1161,8 @@ server.registerTool(
           action,
           targetType,
           targetId: targetId || "unknown",
-          beforeState: parsedBefore ?? Prisma.JsonNull,
-          afterState: parsedAfter ?? Prisma.JsonNull,
+          beforeState: parsedBefore ?? null,
+          afterState: parsedAfter ?? null,
           reason: reason || null,
         },
       })