everything-dev 1.4.1 → 1.5.0

package/src/cli/init.ts

@@ -148,7 +148,7 @@ export async function copyFilteredFiles(
   sourceDir: string,
   destination: string,
   patterns: string[],
-  options: { withHost: boolean },
+  options: { withHost: boolean; plugins?: string[]; pluginRoutes?: Record<string, string[]> },
 ): Promise<number> {
   if (patterns.length === 0) {
     return 0;
@@ -158,8 +158,24 @@ export async function copyFilteredFiles(
     ? [...patterns, "host/**"]
     : patterns.filter((p) => !p.startsWith("host/") && p !== "host/**");
 
+  const filteredPatterns = effectivePatterns.filter((p) => {
+    const pluginMatch = p.match(/^plugins\/([^/]+)/);
+    if (!pluginMatch) return true;
+    const pluginName = pluginMatch[1];
+    return options.plugins?.includes(pluginName) ?? true;
+  });
+
+  const excludedRoutePatterns: string[] = [];
+  if (options.pluginRoutes) {
+    for (const [pluginKey, routePatterns] of Object.entries(options.pluginRoutes)) {
+      if (!(options.plugins?.includes(pluginKey) ?? true)) {
+        excludedRoutePatterns.push(...routePatterns);
+      }
+    }
+  }
+
   const allFiles = new Set<string>();
-  for (const pattern of effectivePatterns) {
+  for (const pattern of filteredPatterns) {
     const matches = await glob(pattern, {
       cwd: sourceDir,
       nodir: true,
@@ -167,10 +183,38 @@ export async function copyFilteredFiles(
       absolute: false,
     });
     for (const match of matches) {
+      const pluginMatch = match.match(/^plugins\/([^/]+)/);
+      if (pluginMatch) {
+        const pluginName = pluginMatch[1];
+        if (!(options.plugins?.includes(pluginName) ?? true)) continue;
+      }
+      if (isRouteExcluded(match, excludedRoutePatterns)) continue;
       allFiles.add(match);
     }
   }
 
+  const routeFiles = new Set<string>();
+  if (options.pluginRoutes) {
+    for (const [pluginKey, routePatterns] of Object.entries(options.pluginRoutes)) {
+      if (!(options.plugins?.includes(pluginKey) ?? true)) continue;
+      for (const rp of routePatterns) {
+        const matches = await glob(rp, {
+          cwd: sourceDir,
+          nodir: true,
+          dot: true,
+          absolute: false,
+        });
+        for (const match of matches) {
+          if (!isRouteExcluded(match, excludedRoutePatterns)) {
+            routeFiles.add(match);
+          }
+        }
+      }
+    }
+  }
+
+  for (const f of routeFiles) allFiles.add(f);
+
   mkdirSync(destination, { recursive: true });
 
   let count = 0;
@@ -179,7 +223,10 @@ export async function copyFilteredFiles(
     const stat = lstatSync(src);
     if (!stat.isFile()) continue;
 
-    const dest = join(destination, filePath);
+    const destPath = filePath.startsWith(".templates/")
+      ? filePath.slice(".templates/".length)
+      : filePath;
+    const dest = join(destination, destPath);
     mkdirSync(dirname(dest), { recursive: true });
     const content = readFileSync(src);
     writeFileSync(dest, content);
@@ -189,6 +236,19 @@ export async function copyFilteredFiles(
   return count;
 }
 
+function isRouteExcluded(filePath: string, excludedPatterns: string[]): boolean {
+  if (excludedPatterns.length === 0) return false;
+  for (const pattern of excludedPatterns) {
+    if (pattern.endsWith("/**")) {
+      const prefix = pattern.slice(0, -3);
+      if (filePath.startsWith(`${prefix}/`) || filePath === prefix) return true;
+    } else if (filePath === pattern || filePath.startsWith(`${pattern}/`)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 export async function personalizeConfig(
   destination: string,
   opts: {
@@ -196,6 +256,8 @@ export async function personalizeConfig(
     extendsGateway: string;
     account?: string;
     domain?: string;
+    plugins?: string[];
+    pluginRoutes?: Record<string, string[]>;
     workspaceOpts?: { localOverrides?: boolean; sourceDir?: string };
   },
 ): Promise<void> {
@@ -228,6 +290,15 @@ export async function personalizeConfig(
 
     if (config.plugins && typeof config.plugins === "object") {
       const plugins = config.plugins as Record<string, unknown>;
+
+      if (opts.plugins && opts.plugins.length > 0) {
+        for (const pluginKey of Object.keys(plugins)) {
+          if (!opts.plugins.includes(pluginKey)) {
+            delete plugins[pluginKey];
+          }
+        }
+      }
+
       for (const pluginKey of Object.keys(plugins)) {
         const plugin = plugins[pluginKey];
         if (plugin && typeof plugin === "object") {
@@ -236,6 +307,10 @@ export async function personalizeConfig(
           delete p.productionIntegrity;
         }
       }
+
+      if (Object.keys(plugins).length === 0) {
+        delete config.plugins;
+      }
     }
 
     writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
@@ -248,7 +323,13 @@ export async function personalizeConfig(
     if (pkg.workspaces && typeof pkg.workspaces === "object") {
       const ws = pkg.workspaces as { packages?: string[] };
       if (Array.isArray(ws.packages)) {
-        ws.packages = ws.packages.filter((p: string) => p !== "host" && !p.startsWith("packages/"));
+        ws.packages = ws.packages
+          .filter((p: string) => p !== "host" && !p.startsWith("packages/"))
+          .filter((p: string) => {
+            const pluginMatch = p.match(/^plugins\/([^/]+)/);
+            if (!pluginMatch) return true;
+            return opts.plugins?.includes(pluginMatch[1]) ?? true;
+          });
       }
     }
 
@@ -322,7 +403,7 @@ async function resolveWorkspaceRefs(
   await normalizePackageManifestsInTree({
     sourceRootDir: options?.sourceDir ?? destination,
     targetDir: destination,
-    resolveCatalogRefs: false,
+    resolveCatalogRefs: true,
     removeWorkspaceDeps: ["host"],
   });
 
@@ -363,12 +444,21 @@ export async function writeInitSnapshot(
   extendsGateway: string,
   sourceDir: string,
   patterns: string[],
-  options: { withHost: boolean },
+  options: { withHost: boolean; plugins?: string[]; pluginRoutes?: Record<string, string[]> },
 ): Promise<void> {
   const effectivePatterns = options.withHost
     ? [...patterns, "host/**"]
     : patterns.filter((p) => !p.startsWith("host/") && p !== "host/**");
 
+  const excludedRoutePatterns: string[] = [];
+  if (options.pluginRoutes) {
+    for (const [pluginKey, routePatterns] of Object.entries(options.pluginRoutes)) {
+      if (!(options.plugins?.includes(pluginKey) ?? true)) {
+        excludedRoutePatterns.push(...routePatterns);
+      }
+    }
+  }
+
   const allFiles = new Set<string>();
   for (const pattern of effectivePatterns) {
     const matches = await glob(pattern, {
@@ -378,17 +468,42 @@ export async function writeInitSnapshot(
       absolute: false,
     });
     for (const match of matches) {
+      const pluginMatch = match.match(/^plugins\/([^/]+)/);
+      if (pluginMatch && !(options.plugins?.includes(pluginMatch[1]) ?? true)) continue;
+      if (isRouteExcluded(match, excludedRoutePatterns)) continue;
       allFiles.add(match);
     }
   }
 
+  if (options.pluginRoutes) {
+    for (const [pluginKey, routePatterns] of Object.entries(options.pluginRoutes)) {
+      if (!(options.plugins?.includes(pluginKey) ?? true)) continue;
+      for (const rp of routePatterns) {
+        const matches = await glob(rp, {
+          cwd: sourceDir,
+          nodir: true,
+          dot: true,
+          absolute: false,
+        });
+        for (const match of matches) {
+          if (!isRouteExcluded(match, excludedRoutePatterns)) {
+            allFiles.add(match);
+          }
+        }
+      }
+    }
+  }
+
   const fileHashes: Record<string, string> = {};
   for (const filePath of allFiles) {
     const src = join(sourceDir, filePath);
     const stat = lstatSync(src);
     if (!stat.isFile()) continue;
     const content = readFileSync(src);
-    fileHashes[filePath] = computeHash(content);
+    const destPath = filePath.startsWith(".templates/")
+      ? filePath.slice(".templates/".length)
+      : filePath;
+    fileHashes[destPath] = computeHash(content);
   }
 
   await writeSnapshot(destination, {

package/src/cli/prompts.ts

@@ -25,9 +25,10 @@ export async function promptYesNo(question: string, defaultVal = false): Promise
   return answer.toLowerCase() === "y" || answer.toLowerCase() === "yes";
 }
 
-function deriveDirectoryFromDomain(domain: string): string {
-  const firstSegment = domain.split(".")[0];
-  return firstSegment || domain;
+function parseExtendsRef(ref: string): { account: string; gateway: string } | null {
+  const match = ref.match(/^(?:bos:\/\/)?([^/]+)\/(.+)$/);
+  if (!match) return null;
+  return { account: match[1], gateway: match[2] };
 }
 
 function deriveAccountFromDomain(domain: string, extendsAccount: string): string {
@@ -39,12 +40,73 @@ function deriveAccountFromDomain(domain: string, extendsAccount: string): string
   return `${firstSegment}.${suffix}`;
 }
 
+const AVAILABLE_PLUGINS = [
+  {
+    key: "_template",
+    label: "template",
+    description: "Plugin scaffold and boilerplate",
+    default: true,
+  },
+  {
+    key: "registry",
+    label: "registry",
+    description: "FastKV app discovery and metadata",
+    default: false,
+  },
+];
+
+async function promptPluginSelect(): Promise<string[]> {
+  const selected = new Set<string>(AVAILABLE_PLUGINS.filter((p) => p.default).map((p) => p.key));
+
+  console.log();
+  console.log("  Select plugins (enter number to toggle, enter to confirm):");
+  for (let i = 0; i < AVAILABLE_PLUGINS.length; i++) {
+    const p = AVAILABLE_PLUGINS[i];
+    const marker = selected.has(p.key) ? "●" : "○";
+    console.log(`    ${marker} ${i + 1}. ${p.label} — ${p.description}`);
+  }
+  console.log();
+
+  while (true) {
+    const answer = await prompt(
+      "  Plugins",
+      selected.size > 0 ? Array.from(selected).join(",") : "",
+    );
+    if (!answer) break;
+
+    const num = Number.parseInt(answer, 10);
+    if (num >= 1 && num <= AVAILABLE_PLUGINS.length) {
+      const plugin = AVAILABLE_PLUGINS[num - 1];
+      if (selected.has(plugin.key)) {
+        selected.delete(plugin.key);
+      } else {
+        selected.add(plugin.key);
+      }
+
+      console.log("  Current selection:");
+      for (let i = 0; i < AVAILABLE_PLUGINS.length; i++) {
+        const p = AVAILABLE_PLUGINS[i];
+        const marker = selected.has(p.key) ? "●" : "○";
+        console.log(`    ${marker} ${i + 1}. ${p.label}`);
+      }
+      console.log();
+      continue;
+    }
+
+    break;
+  }
+
+  return Array.from(selected);
+}
+
 export async function promptInitOptions(input: {
   extendsAccount?: string;
   extendsGateway?: string;
+  extends?: string;
   directory?: string;
   account?: string;
   domain?: string;
+  plugins?: string[];
   withHost?: boolean;
 }): Promise<{
   extendsAccount: string;
@@ -52,21 +114,32 @@ export async function promptInitOptions(input: {
   directory: string;
   account?: string;
   domain?: string;
+  plugins: string[];
   withHost: boolean;
 }> {
-  const extendsAccount =
-    input.extendsAccount || (await prompt("Extends account", "dev.everything.near"));
+  const domain = input.domain || (await prompt("Project domain"));
 
-  const extendsGateway =
-    input.extendsGateway || (await prompt("Extends gateway", "everything.dev"));
+  const extendsInput = input.extends || (await prompt("Extend from", ""));
+  let extendsAccount = input.extendsAccount || "";
+  let extendsGateway = input.extendsGateway || "";
 
-  const domain = input.domain || (await prompt("Project domain"));
+  if (extendsInput) {
+    const parsed = parseExtendsRef(extendsInput);
+    if (parsed) {
+      extendsAccount = extendsAccount || parsed.account;
+      extendsGateway = extendsGateway || parsed.gateway;
+    }
+  }
+
+  extendsAccount = extendsAccount || "dev.everything.near";
+  extendsGateway = extendsGateway || "everything.dev";
 
   const accountDefault = domain ? deriveAccountFromDomain(domain, extendsAccount) : "";
   const account = input.account || (await prompt("Project NEAR account", accountDefault));
 
-  const directoryDefault = domain ? deriveDirectoryFromDomain(domain) : extendsGateway;
-  const directory = input.directory || (await prompt("Project directory", directoryDefault));
+  const directory = input.directory || domain || extendsGateway;
+
+  const plugins = input.plugins || (await promptPluginSelect());
 
   const withHost =
     input.withHost !== undefined ? input.withHost : await promptYesNo("Include host?", false);
@@ -77,6 +150,7 @@ export async function promptInitOptions(input: {
     directory,
     account: account || undefined,
     domain: domain || undefined,
+    plugins,
     withHost,
   };
 }

package/src/cli/sync.ts

@@ -74,6 +74,71 @@ function backupFiles(projectDir: string, filePaths: string[]): string | null {
   return backupDir;
 }
 
+function mergePackageJson(
+  local: Record<string, unknown>,
+  template: Record<string, unknown>,
+): Record<string, unknown> {
+  const merged = { ...template };
+
+  for (const depField of ["dependencies", "devDependencies", "peerDependencies"] as const) {
+    const localDeps = local[depField] as Record<string, string> | undefined;
+    const templateDeps = template[depField] as Record<string, string> | undefined;
+
+    if (!localDeps && !templateDeps) continue;
+
+    const mergedDeps: Record<string, string> = { ...(templateDeps ?? {}) };
+
+    if (localDeps) {
+      for (const [name, version] of Object.entries(localDeps)) {
+        if (!(name in mergedDeps)) {
+          mergedDeps[name] = version;
+        }
+      }
+    }
+
+    if (Object.keys(mergedDeps).length > 0) {
+      merged[depField] = mergedDeps;
+    }
+  }
+
+  if (local.scripts && typeof local.scripts === "object") {
+    merged.scripts = {
+      ...((template.scripts as Record<string, string>) ?? {}),
+      ...(local.scripts as Record<string, string>),
+    };
+  }
+
+  return merged;
+}
+
+function toDestPath(filePath: string): string {
+  return filePath.startsWith(".templates/") ? filePath.slice(".templates/".length) : filePath;
+}
+
+function writeSyncedFile(sourceDir: string, projectDir: string, filePath: string): void {
+  const src = join(sourceDir, filePath);
+  const destPath = filePath.startsWith(".templates/")
+    ? filePath.slice(".templates/".length)
+    : filePath;
+  const dest = join(projectDir, destPath);
+  mkdirSync(dirname(dest), { recursive: true });
+
+  if (filePath.endsWith("package.json")) {
+    const localContent = existsSync(dest) ? readFileSync(dest, "utf-8") : null;
+    const templateContent = readFileSync(src, "utf-8");
+
+    if (localContent) {
+      const local = JSON.parse(localContent) as Record<string, unknown>;
+      const template = JSON.parse(templateContent) as Record<string, unknown>;
+      const merged = mergePackageJson(local, template);
+      writeFileSync(dest, `${JSON.stringify(merged, null, 2)}\n`);
+      return;
+    }
+  }
+
+  writeFileSync(dest, readFileSync(src));
+}
+
 export async function syncTemplate(projectDir: string, options: SyncOptions): Promise<SyncResult> {
   const localConfig = JSON.parse(
     readFileSync(join(projectDir, "bos.config.json"), "utf-8"),
@@ -104,7 +169,10 @@ export async function syncTemplate(projectDir: string, options: SyncOptions): Pr
   const extendsAccount = extendsMatch[1];
   const extendsGateway = extendsMatch[2];
 
-  const { sourceDir, cleanup } = await resolveSourceDir({ extendsAccount, extendsGateway });
+  const { sourceDir, parentConfig, cleanup } = await resolveSourceDir({
+    extendsAccount,
+    extendsGateway,
+  });
 
   try {
     const patterns = await readTemplatekeep(sourceDir);
@@ -135,40 +203,87 @@ export async function syncTemplate(projectDir: string, options: SyncOptions): Pr
       }
     }
 
+    const childPlugins =
+      localConfig.plugins && typeof localConfig.plugins === "object"
+        ? Object.keys(localConfig.plugins as Record<string, unknown>)
+        : [];
+
+    const pluginRoutes: Record<string, string[]> = {};
+    if (parentConfig.plugins) {
+      for (const [key, ref] of Object.entries(parentConfig.plugins)) {
+        if (ref.routes && ref.routes.length > 0) {
+          pluginRoutes[key] = ref.routes;
+        }
+      }
+    }
+
+    const excludedRoutePatterns: string[] = [];
+    for (const [pluginKey, routePatterns] of Object.entries(pluginRoutes)) {
+      if (!childPlugins.includes(pluginKey)) {
+        excludedRoutePatterns.push(...routePatterns);
+      }
+    }
+
+    const filteredFiles = new Set<string>();
+    for (const filePath of allTemplateFiles) {
+      const pluginMatch = filePath.match(/^plugins\/([^/]+)/);
+      if (pluginMatch && !childPlugins.includes(pluginMatch[1])) continue;
+      if (isExcluded(filePath, excludedRoutePatterns)) continue;
+      filteredFiles.add(filePath);
+    }
+
+    for (const [pluginKey, routePatterns] of Object.entries(pluginRoutes)) {
+      if (!childPlugins.includes(pluginKey)) continue;
+      for (const rp of routePatterns) {
+        const matches = await glob(rp, {
+          cwd: sourceDir,
+          nodir: true,
+          dot: true,
+          absolute: false,
+        });
+        for (const match of matches) {
+          if (!isExcluded(match, excludedRoutePatterns)) {
+            filteredFiles.add(match);
+          }
+        }
+      }
+    }
+
     const snapshot = await readSnapshot(projectDir);
 
     const updated: string[] = [];
     const skipped: string[] = [];
     const added: string[] = [];
 
-    for (const filePath of allTemplateFiles) {
-      if (isExcluded(filePath, excludePatterns)) continue;
+    for (const filePath of filteredFiles) {
+      const destPath = toDestPath(filePath);
+      if (isExcluded(destPath, excludePatterns)) continue;
 
-      const localHash = computeLocalHash(projectDir, filePath);
+      const localHash = computeLocalHash(projectDir, destPath);
       const sourceContent = readFileSync(join(sourceDir, filePath));
       const sourceHash = createHash("sha256").update(sourceContent).digest("hex").substring(0, 16);
 
       if (localHash === null) {
-        added.push(filePath);
+        added.push(destPath);
         continue;
       }
 
       if (localHash === sourceHash) continue;
 
-      const snapshotHash = snapshot?.files[filePath];
+      const snapshotHash = snapshot?.files[destPath];
 
       if (snapshotHash === undefined) {
-        updated.push(filePath);
+        updated.push(destPath);
         continue;
       }
 
       if (localHash === snapshotHash) {
-        updated.push(filePath);
+        updated.push(destPath);
       } else {
         if (options.force) {
-          updated.push(filePath);
+          updated.push(destPath);
         } else {
-          skipped.push(filePath);
+          skipped.push(destPath);
         }
       }
     }
@@ -184,24 +299,27 @@ export async function syncTemplate(projectDir: string, options: SyncOptions): Pr
 
     const filesToWrite = [...updated, ...added].filter((f) => !isExcluded(f, excludePatterns));
 
+    const destToSource = new Map<string, string>();
+    for (const filePath of filteredFiles) {
+      destToSource.set(toDestPath(filePath), filePath);
+    }
+
     if (filesToWrite.length > 0) {
       backupFiles(projectDir, filesToWrite);
 
-      for (const filePath of filesToWrite) {
-        const src = join(sourceDir, filePath);
-        const dest = join(projectDir, filePath);
-        mkdirSync(dirname(dest), { recursive: true });
-        writeFileSync(dest, readFileSync(src));
+      for (const destPath of filesToWrite) {
+        const sourcePath = destToSource.get(destPath) ?? destPath;
+        writeSyncedFile(sourceDir, projectDir, sourcePath);
       }
     }
 
     const newSnapshotFiles: Record<string, string> = {};
-    for (const filePath of allTemplateFiles) {
+    for (const filePath of filteredFiles) {
       const src = join(sourceDir, filePath);
       const stat = lstatSync(src);
       if (!stat.isFile()) continue;
       const content = readFileSync(src);
-      newSnapshotFiles[filePath] = createHash("sha256")
+      newSnapshotFiles[toDestPath(filePath)] = createHash("sha256")
         .update(content)
         .digest("hex")
         .substring(0, 16);
@@ -220,6 +338,8 @@ export async function syncTemplate(projectDir: string, options: SyncOptions): Pr
       extendsGateway,
       account,
       domain,
+      plugins: childPlugins,
+      pluginRoutes,
       workspaceOpts: { sourceDir },
     });
 

package/src/cli.ts

@@ -113,6 +113,8 @@ async function main() {
       console.log(`  ${colors.dim("Directory:")} ${result.directory}`);
       if (result.account) console.log(`  ${colors.dim("Account:")} ${result.account}`);
       if (result.domain) console.log(`  ${colors.dim("Domain:")} ${result.domain}`);
+      if (result.plugins && result.plugins.length > 0)
+        console.log(`  ${colors.dim("Plugins:")} ${result.plugins.join(", ")}`);
       console.log(`  ${colors.dim("Files copied:")} ${result.filesCopied}`);
       console.log();
       console.log(colors.dim("  Next steps:"));
@@ -156,6 +158,24 @@ async function main() {
       if (result.updated.length === 0 && result.added.length === 0 && result.skipped.length === 0) {
         console.log(`  ${colors.dim("Already up to date")}`);
       }
+      if (result.status !== "dry-run" && result.updated.length > 0) {
+        console.log();
+        console.log(colors.dim("  Review changes — your customizations take priority:"));
+        console.log(
+          colors.dim(
+            "    • api/src/contract.ts, api/src/index.ts, api/src/db/schema.ts — never overwritten",
+          ),
+        );
+        console.log(
+          colors.dim("    • ui/src/components/**, ui/src/styles.css — never overwritten"),
+        );
+        console.log(
+          colors.dim(
+            "    • Other updated files — accept framework improvements, then restore your changes",
+          ),
+        );
+        console.log(colors.dim("    • Skipped files — yours already, only update with --force"));
+      }
       console.log();
       return;
     }
@@ -169,7 +189,7 @@ async function main() {
       if (result.status === "dry-run") {
         console.log(colors.cyan(`${icons.ok} Dry run — no changes applied`));
       } else {
-        console.log(colors.green(`${icons.ok} Framework upgraded`));
+        console.log(colors.green(`${icons.ok} Upgrade successful`));
       }
       for (const pkg of result.packages) {
         if (pkg.from && pkg.from !== pkg.to) {
@@ -186,15 +206,46 @@ async function main() {
       if (result.sync) {
         const sync = result.sync;
         if (sync.updated.length > 0) {
-          console.log(`  ${colors.dim("Synced updated:")} ${sync.updated.length} file(s)`);
+          console.log(`  ${colors.dim("Updated:")} ${sync.updated.length} file(s)`);
+          for (const f of sync.updated) console.log(`    ${colors.dim(f)}`);
         }
         if (sync.added.length > 0) {
-          console.log(`  ${colors.dim("Synced added:")} ${sync.added.length} file(s)`);
+          console.log(`  ${colors.dim("Added:")} ${sync.added.length} file(s)`);
+          for (const f of sync.added) console.log(`    ${colors.dim(f)}`);
         }
         if (sync.skipped.length > 0) {
           console.log(
-            `  ${colors.yellow("Synced skipped:")} ${sync.skipped.length} file(s) (locally modified, use --force to overwrite)`,
+            `  ${colors.yellow("Skipped:")} ${sync.skipped.length} file(s) (locally modified, use --force to overwrite)`,
+          );
+          for (const f of sync.skipped) console.log(`    ${colors.dim(f)}`);
+        }
+        if (
+          result.status !== "dry-run" &&
+          (sync.updated.length > 0 || sync.added.length > 0 || sync.skipped.length > 0)
+        ) {
+          console.log();
+          console.log(colors.dim("  Resolve differences — your code takes priority:"));
+          console.log();
+          console.log(colors.dim("  Never overwritten (safe):"));
+          console.log(
+            colors.dim("    • api/src/contract.ts, api/src/index.ts, api/src/db/schema.ts"),
+          );
+          console.log(colors.dim("    • ui/src/components/**, ui/src/styles.css"));
+          console.log();
+          console.log(colors.dim("  Replaced — review and keep your changes:"));
+          console.log(
+            colors.dim(
+              "    • api/drizzle.config.ts, api/tsconfig.json, api/tsconfig.contract.json",
+            ),
           );
+          console.log(colors.dim("    • api/plugin.dev.ts, api/rspack.config.js"));
+          console.log(colors.dim("    • ui/src/routes/* (core routes only)"));
+          console.log();
+          console.log(colors.dim("  Merged — your deps preserved:"));
+          console.log(colors.dim("    • package.json, api/package.json, ui/package.json"));
+          console.log();
+          console.log(colors.dim("  Skipped — already yours:"));
+          console.log(colors.dim("    • Use --force only if you want framework updates"));
         }
       }
       console.log();