@nutin/cli 2.1.1 → 3.0.0

package/lib/src/add-feature/feature-context-builder.mjs

@@ -16,6 +16,7 @@ export class FeatureContextBuilder {
     return {
       projectName: packageJson.name,
       packageManager,
+      lang: meta.lang ?? 'ts',
       ciCommand: getCiCommand(packageManager),
       version: PACKAGE_VERSION,
       ...(meta.features ?? {}),

package/lib/src/add-feature/nutin-config-updater.mjs

@@ -5,25 +5,51 @@ import { print } from '../utils/print.mjs';
 const fs = fsExtra.default;
 
 const GENERATE_SEO_LINE_RE = /^([ \t]*generateSEOFiles:[^\n]*\n)/m;
-const DOCKER_PORTS_LINE = '\n// Nutin features\n  dockerPorts: [9090],     // Ports the Docker container exposes/listens on — edit as needed\n';
+const FEATURES_HEADER_RE = /^([ \t]*\/\/ Nutin features[^\n]*\n)/m;
+const FEATURES_HEADER = '\n  // Nutin features\n';
+
+const FEATURE_CONFIGS = {
+  docker: {
+    key: 'dockerPorts',
+    lines: '  dockerPorts: [9090],     // Ports the Docker container exposes/listens on — edit as needed\n',
+    added: 'Added "dockerPorts" to nutin.config.js — edit it if you need different port(s).',
+    manual: 'add "dockerPorts: [9090]" to it manually before building.',
+  },
+  markdown: {
+    key: 'markdownSources',
+    lines:
+      '  markdownSources: {       // Markdown folders compiled to /generated/<name>.json at build time\n' +
+      "    sourceFolders: ['markdown-content'], // folder paths, or { folder, hubFiles, routePrefix, sectionInPath, prefixReplacements, seo }\n" +
+      '  },\n',
+    added: 'Added "markdownSources" to nutin.config.js — add your own folders to "sourceFolders".',
+    manual: 'add "markdownSources: { sourceFolders: [\'markdown-content\'] }" to it manually.',
+  },
+};
 
 export async function updateNutinConfig(projectPath, feature) {
-  if (feature.key !== 'docker') return;
+  const featureConfig = FEATURE_CONFIGS[feature.key];
+  if (!featureConfig) return;
 
   const configPath = path.join(projectPath, 'nutin.config.js');
   const content = await fs.readFile(configPath, 'utf-8');
 
-  if (/dockerPorts\s*:/.test(content)) {
-    print.info('Kept existing "dockerPorts" value in nutin.config.js');
+  if (new RegExp(`${featureConfig.key}\\s*:`).test(content)) {
+    print.info(`Kept existing "${featureConfig.key}" value in nutin.config.js`);
     return;
   }
 
-  if (!GENERATE_SEO_LINE_RE.test(content)) {
-    print.warn('Could not find a "generateSEOFiles:" line in nutin.config.js — add "dockerPorts: [9090]" to it manually before building.');
+  // Features share one "// Nutin features" block, created after generateSEOFiles by
+  // whichever feature is added first.
+  let updated;
+  if (FEATURES_HEADER_RE.test(content)) {
+    updated = content.replace(FEATURES_HEADER_RE, `$1${featureConfig.lines}`);
+  } else if (GENERATE_SEO_LINE_RE.test(content)) {
+    updated = content.replace(GENERATE_SEO_LINE_RE, `$1${FEATURES_HEADER}${featureConfig.lines}`);
+  } else {
+    print.warn(`Could not find a "generateSEOFiles:" line in nutin.config.js — ${featureConfig.manual}`);
     return;
   }
 
-  const updated = content.replace(GENERATE_SEO_LINE_RE, `$1${DOCKER_PORTS_LINE}`);
   await fs.writeFile(configPath, updated);
-  print.warn('Added "dockerPorts" to nutin.config.js — edit it if you need different port(s).');
+  print.warn(featureConfig.added);
 }

package/lib/src/add-feature/package-json-updater.mjs

@@ -1,7 +1,7 @@
 import path from 'path';
 import * as fsExtra from 'fs-extra';
 import { print } from '../utils/print.mjs';
-import { getDockerScripts } from '../common/package-json-helper.mjs';
+import { getDockerScripts, getMarkdownScripts } from '../common/package-json-helper.mjs';
 
 const fs = fsExtra.default;
 
@@ -26,15 +26,13 @@ export async function updatePackageJson(projectPath, feature) {
   const packageJsonPath = path.join(projectPath, 'package.json');
   const packageJson = await fs.readJSON(packageJsonPath);
   
-  const isDocker = feature.key === 'docker';
+  const featureScripts = {
+    docker: getDockerScripts,
+    markdown: getMarkdownScripts,
+  };
 
-  let scripts = {};
-
-  if (isDocker) {
-    scripts = getDockerScripts();
-  } else {
-    return;
-  }
+  if (!featureScripts[feature.key]) return;
+  const scripts = featureScripts[feature.key]();
 
   const scriptsResult = mergeAdditive(packageJson.scripts ?? {}, scripts);
   packageJson.scripts = scriptsResult.merged;

package/lib/src/common/feature-registry.mjs

@@ -4,6 +4,10 @@ export const FEATURES = [
     key: 'docker',
     cli: 'docker',
   },
+  {
+    key: 'markdown',
+    cli: 'markdown',
+  },
 ];
 
 export function findFeatureByCli(cliName) {

package/lib/src/common/file-generator.mjs

@@ -4,6 +4,7 @@ import * as fsExtra from 'fs-extra';
 import { TemplateCompiler } from './template-compiler.mjs';
 import { print } from '../utils/print.mjs';
 import { FEATURES } from './feature-registry.mjs';
+import { toJsOutput } from './transpile-ts.mjs';
 
 const fs = fsExtra.default;
 const __filename = fileURLToPath(import.meta.url);
@@ -16,6 +17,17 @@ const BINARY_EXTENSIONS = new Set([
   '.pdf', '.zip', '.tar', '.gz'
 ]);
 
+// Template-repo housekeeping, never generated. .gitkeep only keeps otherwise-empty
+// template folders in git/npm; the folder itself is still created (ensureDir).
+const IGNORED_TEMPLATE_FILES = new Set(['.DS_Store', '.gitkeep']);
+
+// Templates that only make sense in a TypeScript project — not generated for JS-only ones.
+const TS_ONLY_TEMPLATES = [
+  path.join('tools', 'builder', 'core', 'app', 'compile-ts.js.hbs'),
+  path.join('tools', 'builder', 'core', 'app', 'handler-refs.js.hbs'),
+  path.join('tools', 'builder', 'core', 'app', 'handler-refs.test.js.hbs'),
+];
+
 export class FileGenerator {
   constructor() {
     this.compiler = new TemplateCompiler();
@@ -42,7 +54,7 @@ export class FileGenerator {
     const entries = await fs.readdir(templateDir, { withFileTypes: true });
 
     for (const entry of entries) {
-      if (entry.name === '.DS_Store') continue;
+      if (IGNORED_TEMPLATE_FILES.has(entry.name)) continue;
 
       const templatePath = path.join(templateDir, entry.name);
 
@@ -76,8 +88,13 @@ export class FileGenerator {
   }
 
   async isRenderTemplateFile(templatePath, fileName, context) {
+    const isJsOnly = context.lang === 'js';
+    if (isJsOnly && TS_ONLY_TEMPLATES.some((template) => templatePath.endsWith(template))) {
+      return null;
+    }
+
     const fileExt = path.extname(fileName).toLowerCase();
-    const outputFileName = fileName.endsWith('.hbs') ? fileName.replace('.hbs', '') : fileName;
+    const outputFileName = fileName.replace(/\.hbs$/, '');
     const isBinary = BINARY_EXTENSIONS.has(fileExt);
 
     let content;
@@ -89,6 +106,11 @@ export class FileGenerator {
       content = await fs.readFile(templatePath, 'utf8');
     }
 
+    if (isJsOnly && !isBinary) {
+      const jsOutput = await toJsOutput(outputFileName, content);
+      return jsOutput && { ...jsOutput, isBinary };
+    }
+
     return { outputFileName, isBinary, content };
   }
 
@@ -140,7 +162,7 @@ export class FileGenerator {
     const entries = await fs.readdir(dir, { withFileTypes: true });
 
     for (const entry of entries) {
-      if (entry.name === '.DS_Store') continue;
+      if (IGNORED_TEMPLATE_FILES.has(entry.name)) continue;
 
       const entryPath = path.join(dir, entry.name);
 

package/lib/src/common/git.mjs

@@ -0,0 +1,31 @@
+import { execFile } from 'child_process';
+import { promisify } from 'util';
+
+export const execFileAsync = promisify(execFile);
+
+// nutin new runs `git init` with it, and nutin-update needs it to merge files you edited.
+export async function isGitAvailable() {
+  try {
+    await execFileAsync('git', ['--version']);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+// The project folder's uncommitted changes, untracked files included (ignored ones aren't listed).
+// Scoped to the folder, so a project inside a bigger repository isn't blocked by changes elsewhere.
+// `repo: false` when git is missing or the folder isn't in a repository.
+export async function getWorkingTreeStatus(projectPath) {
+  try {
+    await execFileAsync('git', ['rev-parse', '--is-inside-work-tree'], { cwd: projectPath });
+  } catch {
+    return { repo: false, gitFound: await isGitAvailable(), changes: [] };
+  }
+  const { stdout } = await execFileAsync(
+    'git',
+    ['status', '--porcelain', '--untracked-files=all', '--', '.'],
+    { cwd: projectPath, maxBuffer: 1024 * 1024 * 10 },
+  );
+  return { repo: true, gitFound: true, changes: stdout.split('\n').filter(Boolean) };
+}

package/lib/src/common/meta-bootstrap-prompt.mjs

@@ -1,11 +1,35 @@
+import path from 'path';
+import * as fsExtra from 'fs-extra';
 import inquirer from 'inquirer';
 import { print } from '../utils/print.mjs';
 import { FEATURES } from './feature-registry.mjs';
 import { detectPackageManager } from './package-json-helper.mjs';
 import { writeProjectMeta } from './project-meta.mjs';
+import { META_FILE_NAME } from './package-data.mjs';
+
+const fs = fsExtra.default;
+
+// `--js-only` apps have src/app/main.js and no main.ts. Projects from before JS-only
+// support are all TypeScript, so anything else counts as 'ts'.
+async function detectLang(projectPath) {
+  const appDir = path.join(projectPath, 'src', 'app');
+  const hasMainJs = await fs.pathExists(path.join(appDir, 'main.js'));
+  const hasMainTs = await fs.pathExists(path.join(appDir, 'main.ts'));
+  return hasMainJs && !hasMainTs ? 'js' : 'ts';
+}
 
 export async function bootstrapProjectMeta(projectPath) {
-  print.warn('⚠️  No .nutin-meta.json found for this project.');
+  // inquirer can't prompt without a TTY: it throws on a closed stdin and waits forever on an open pipe.
+  if (!process.stdin.isTTY) {
+    throw new Error(
+      `No ${META_FILE_NAME} found for this project, and this shell is non-interactive, so it can't be reconstructed. ` +
+      `Run this command again in a terminal to answer a couple of questions, or create ${META_FILE_NAME} yourself, e.g. ` +
+      `{ "version": "1.3.1", "packageManager": "npm", "lang": "ts", "features": { "docker": false, "markdown": false } } ` +
+      `("lang": "js" for a --js-only project)`
+    );
+  }
+
+  print.warn(`⚠️  No ${META_FILE_NAME} found for this project.`);
   print.section('Answer a couple of questions so a baseline can be reconstructed:\n');
 
   const { version } = await inquirer.prompt([
@@ -27,7 +51,9 @@ export async function bootstrapProjectMeta(projectPath) {
   ]);
 
   const packageManager = await detectPackageManager(projectPath);
+  const lang = await detectLang(projectPath);
   const flags = Object.fromEntries(FEATURES.map((f) => [f.key, features.includes(f.key)]));
 
-  return writeProjectMeta(projectPath, { version: version.trim(), packageManager, ...flags });
+  print.gray(`Detected ${lang === 'js' ? 'a JavaScript' : 'a TypeScript'} project using ${packageManager} — edit ${META_FILE_NAME} if that's wrong.`);
+  return writeProjectMeta(projectPath, { version: version.trim(), packageManager, lang, ...flags });
 }

package/lib/src/common/package-json-helper.mjs

@@ -5,6 +5,8 @@ import * as path from 'path';
 
 const fs = fsExtra.default;
 
+export const PACKAGE_MANAGERS = ['npm', 'yarn', 'pnpm', 'bun'];
+
 export async function detectPackageManager(projectPath) {
   if (await fs.pathExists(path.join(projectPath, 'pnpm-lock.yaml'))) return 'pnpm';
   if (await fs.pathExists(path.join(projectPath, 'yarn.lock'))) return 'yarn';
@@ -78,18 +80,25 @@ export function getDockerScripts() {
   };
 }
 
+export function getMarkdownScripts() {
+  return {
+    "markdown:check": "node tools/builder/core/markdown/generate-markdown-pages.js --check"
+  };
+}
+
 export function getAllScripts(context) {
-  const { packageManager, docker } = context;
+  const { packageManager, docker, markdown } = context;
 
   const baseScripts = {
     "build": "node tools/builder/builder.js",
-    "build:prod": "NODE_ENV=production node tools/builder/builder.js",
-    "serve": `${packageManager} run build && ${packageManager} run serve:only`,
+    "build:prod": "node tools/builder/builder.js --prod",
+    "serve": `${packageManager} run build && node tools/dev/serve.js`,
     "serve:only": "node tools/dev/serve.js",
-    "serve:prod": `${packageManager} run build:prod && ${packageManager} run serve:only`,
+    "serve:prod": `${packageManager} run build:prod && node tools/dev/serve.js`,
     "dev": "node tools/dev/dev-serve.js",
     "generate": "node tools/generator/generator.js",
     "testin-nutin": `${packageManager} run build && node tools/testin-nutin/runner.js`,
+    "testin-nutin:only": "node tools/testin-nutin/runner.js",
     "testin-nutin:watch": `${packageManager} run build && node tools/testin-nutin/watch-tests.js`,
     "testin-nutin:coverage": `${packageManager} run build && node tools/testin-nutin/runner.js --coverage`,
     "testin-nutin:verbose": `${packageManager} run build && node tools/testin-nutin/runner.js --verbose`
@@ -98,6 +107,7 @@ export function getAllScripts(context) {
   let scripts = { ...baseScripts };
 
   if (docker) scripts = { ...scripts, ...getDockerScripts() };
+  if (markdown) scripts = { ...scripts, ...getMarkdownScripts() };
 
   return scripts;
 }

package/lib/src/common/project-meta.mjs

@@ -1,11 +1,10 @@
 import path from 'path';
 import * as fsExtra from 'fs-extra';
 import { FEATURES } from './feature-registry.mjs';
+import { META_FILE_NAME } from './package-data.mjs';
 
 const fs = fsExtra.default;
 
-const META_FILE_NAME = '.nutin-meta.json';
-
 function metaPath(projectPath) {
   return path.join(projectPath, META_FILE_NAME);
 }
@@ -22,6 +21,7 @@ export async function writeProjectMeta(projectPath, context) {
   const meta = {
     version: context.version,
     packageManager: context.packageManager,
+    lang: context.lang ?? 'ts',
     features: extractFeatures(context),
   };
 

package/lib/src/common/template-compiler.mjs

@@ -34,6 +34,8 @@ export class TemplateCompiler {
       return a === b;
     });
 
+    // Unused by the current templates, but kept: nutin-update renders an older version's
+    // templates with this compiler, and those may still call it.
     Handlebars.registerHelper('hasAnyFeature', function(options) {
       const context = options.data.root;
       return context.i18n || context.template || context.testinNutin || context.stylinNutin

package/lib/src/common/transpile-ts.mjs

@@ -0,0 +1,94 @@
+// JS-only projects: the templates stay TypeScript-authored, and each rendered .ts file is
+// transpiled here at generation time. typescript is imported lazily so TS projects never load it.
+// Its version is pinned in package.json: nutin-update re-transpiles the old baseline and compares
+// it to the user's files, so any output change between versions would read as a user edit.
+// This pin is the CLI's own: generated apps install their own TypeScript (7.x) for tsc.
+let tsModule;
+
+async function loadTypeScript() {
+  tsModule ??= (await import('typescript')).default;
+  return tsModule;
+}
+
+// TypeScript's printer drops blank lines and indents by 4. Blank lines survive as marker
+// comments, which are turned back into blank lines after transpiling.
+const BLANK_LINE_MARKER = '//__NUTIN_BLANK_LINE__';
+const BLANK_LINE_MARKER_LINE = /^[ \t]*\/\/__NUTIN_BLANK_LINE__[ \t]*$/;
+
+function markBlankLines(source) {
+  return source
+    .split('\n')
+    .map((line) => (line.trim() === '' ? BLANK_LINE_MARKER : line))
+    .join('\n');
+}
+
+function restoreBlankLines(output) {
+  return output
+    .split('\n')
+    .map((line) => (BLANK_LINE_MARKER_LINE.test(line) ? '' : line))
+    .join('\n')
+    .replace(/\n{3,}/g, '\n\n')
+    .replace(/^\n+/, '')
+    .replace(/\n*$/, '\n');
+}
+
+// Template literal bodies are emitted verbatim (already 2-space), so lines starting inside
+// one are left alone.
+function getTemplateLiteralRanges(ts, code) {
+  const sourceFile = ts.createSourceFile('output.js', code, ts.ScriptTarget.Latest, true);
+  const ranges = [];
+
+  (function visit(node) {
+    if (ts.isTemplateExpression(node) || ts.isNoSubstitutionTemplateLiteral(node)) {
+      ranges.push([node.getStart(sourceFile), node.end]);
+      return;
+    }
+    ts.forEachChild(node, visit);
+  })(sourceFile);
+
+  return ranges;
+}
+
+// Each 4-space level becomes 2; a smaller remainder (JSDoc ` * ` alignment) is kept.
+function reindent(ts, code) {
+  const ranges = getTemplateLiteralRanges(ts, code);
+  let offset = 0;
+
+  return code
+    .split('\n')
+    .map((line) => {
+      const lineStart = offset;
+      offset += line.length + 1;
+
+      if (ranges.some(([start, end]) => lineStart > start && lineStart < end)) return line;
+
+      const indent = line.match(/^ */)[0].length;
+      return ' '.repeat(indent - 2 * Math.floor(indent / 4)) + line.slice(indent);
+    })
+    .join('\n');
+}
+
+/**
+ * Returns `{ outputFileName, content }` with a `.js` name and transpiled content,
+ * `null` for ambient `.d.ts` files (type-only, nothing to emit), or the input unchanged
+ * for any other file.
+ */
+export async function toJsOutput(outputFileName, content) {
+  if (outputFileName.endsWith('.d.ts')) return null;
+  if (!outputFileName.endsWith('.ts')) return { outputFileName, content };
+
+  const ts = await loadTypeScript();
+  const { outputText } = ts.transpileModule(markBlankLines(content), {
+    fileName: outputFileName,
+    compilerOptions: {
+      target: ts.ScriptTarget.ESNext,
+      module: ts.ModuleKind.ESNext,
+      removeComments: false,
+    },
+  });
+
+  return {
+    outputFileName: outputFileName.replace(/\.ts$/, '.js'),
+    content: restoreBlankLines(reindent(ts, outputText)),
+  };
+}

package/lib/src/create-app/context-builder.mjs

@@ -14,6 +14,7 @@ export class ContextBuilder {
     return {
       projectName: preferences.projectName,
       packageManager: preferences.packageManager,
+      lang: preferences.lang,
       ciCommand: ciCommand,
       version: version
     };

package/lib/src/create-app/git-manager.mjs

@@ -1,7 +1,17 @@
 import { print } from '../utils/print.mjs';
-import { promiseExec } from '../utils/promise-exec-alias.mjs';
+import { execFileAsync, isGitAvailable } from '../common/git.mjs';
 
+// A missing or failing git doesn't stop project creation: the project works without a repository.
 export async function initializeGit(projectPath) {
+  if (!(await isGitAvailable())) {
+    print.warn('⚠️ git was not found — skipping "git init". Install git to version the project; nutin-update also needs it to merge files you edit.');
+    return;
+  }
+
   print.section('⚙️ Initializing Git repository...');
-  await promiseExec('git init', { cwd: projectPath });
+  try {
+    await execFileAsync('git', ['init'], { cwd: projectPath });
+  } catch (error) {
+    print.warn(`⚠️ "git init" failed — skipping it (${(error.stderr || error.message).trim()}). Run it yourself once the issue is fixed.`);
+  }
 }

package/lib/src/create-app/json-manager.mjs

@@ -7,26 +7,34 @@ const fs = fsExtra.default;
 export class JsonManager {
   async generateJsonFiles(projectPath, context) {
     await this.generatePackageJson(projectPath, context);
-    await this.generateTsconfigJson(projectPath, context);
+    if (context.lang !== 'js') await this.generateTsconfigJson(projectPath);
   }
 
   async generatePackageJson(projectPath, context) {
-    const { testinNutin, projectName } = context;
+    await fs.writeJSON(path.join(projectPath, 'package.json'), this.buildPackageJson(context), { spaces: 2 });
+  }
+
+  async generateTsconfigJson(projectPath) {
+    await fs.writeJSON(path.join(projectPath, 'tsconfig.json'), this.buildTsconfigJson(), { spaces: 2 });
+  }
+
+  // Also used by nutin-update to compare an existing project's files with the current defaults.
+  buildPackageJson(context) {
+    const { projectName, lang } = context;
 
     const devDependencies = {
-      "chokidar": "^4.0.3",
-      "esbuild": "^0.25.12",
+      "chokidar": "^5.0.0",
+      "esbuild": "^0.28.2",
       "html-minifier-terser": "^7.2.0",
-      "jsdom": "^26.1.0",
-      "linkedom": "^0.18.12",
-      "live-server": "^1.2.2",
+      "jsdom": "^30.1.1",
+      "linkedom": "^0.18.13",
       "sass": "^1.89.0",
-      "typescript": "^5.8.3"
+      ...(lang === 'js' ? {} : { "typescript": "^7.0.2" })
     };
 
     const scripts = getAllScripts(context);
 
-    const packageJson = {
+    return {
       "name": projectName,
       "version": "0.1.0",
       "type": "module",
@@ -36,18 +44,14 @@ export class JsonManager {
       scripts,
       devDependencies,
       "engines": {
-        "node": ">=22"
+        "node": ">=24"
       }
     };
-    
-    await fs.writeJSON(path.join(projectPath, 'package.json'), packageJson, { spaces: 2 });
   }
 
-  async generateTsconfigJson(projectPath) {
-    const tsconfig = {
+  buildTsconfigJson() {
+    return {
       "compilerOptions": {
-        "baseUrl": "./",
-        "paths": {},
         "target": "ESNext",
         "module": "NodeNext",
         "moduleResolution": "NodeNext",
@@ -57,6 +61,7 @@ export class JsonManager {
         "skipLibCheck": true,
         "forceConsistentCasingInFileNames": true,
         "noUncheckedIndexedAccess": true,
+        "noUnusedLocals": true,
         "esModuleInterop": true,
         "allowSyntheticDefaultImports": true,
         "lib": ["es2022", "DOM"],
@@ -67,7 +72,5 @@ export class JsonManager {
       "include": ["src/app", "src/core"],
       "exclude": ["node_modules"]
     };
-    
-    await fs.writeJSON(path.join(projectPath, 'tsconfig.json'), tsconfig, { spaces: 2 });
   }
 }

package/lib/src/create-app/new-app-prompt.mjs

@@ -1,5 +1,6 @@
 import inquirer from 'inquirer';
 import { defaults } from './context-builder.mjs';
+import { PACKAGE_MANAGERS } from '../common/package-json-helper.mjs';
 
 export async function newAppPrompt(initialName, cliOptions = {}) {
 
@@ -26,10 +27,10 @@ export async function newAppPrompt(initialName, cliOptions = {}) {
   if (!packageManager) {
     const pmPreference = await inquirer.prompt([
       {
-        type: 'list',
+        type: 'select',
         name: 'packageManager',
         message: 'Package manager:',
-        choices: ['npm', 'yarn', 'pnpm', 'bun'],
+        choices: PACKAGE_MANAGERS,
         default: defaults.packageManager,
       },
     ]);
@@ -39,6 +40,7 @@ export async function newAppPrompt(initialName, cliOptions = {}) {
   return {
     projectName,
     packageManager,
+    lang: cliOptions.jsOnly ? 'js' : 'ts',
   };
 }
 

package/lib/src/create-app/success-message.mjs

@@ -2,7 +2,7 @@ import { print } from '../utils/print.mjs';
 import { PACKAGE_HOMEPAGE } from '../common/package-data.mjs';
 
 export function displaySuccessMessage(answers) {
-  const { projectName, packageManager, deployHelper } = answers;
+  const { projectName, packageManager } = answers;
   print.info(`Visit https://${PACKAGE_HOMEPAGE}`);
 
   print.boldSuccess('\n🎉 Your project is ready!\n');

package/lib/src/update-app/conflict-report-writer.mjs

@@ -1,31 +1,43 @@
 import path from 'path';
 import * as fsExtra from 'fs-extra';
-import * as Diff from 'diff';
+import { CONFLICT_MARKER } from './three-way-merge.mjs';
 
 const fs = fsExtra.default;
-const REPORT_FILE_NAME = 'NUTIN-UPDATE-REPORT.md';
+export const REPORT_FILE_NAME = 'NUTIN-UPDATE-REPORT.md';
 
-export async function writeConflictReport(projectPath, conflicts, oldVersion, newVersion) {
-  const sections = conflicts.map(({ relPath, actualContent, newEntry }) => {
-    if (newEntry.isBinary || Buffer.isBuffer(actualContent)) {
-      return `## ${relPath}\n\nBinary file — differs from both your recorded baseline and the new nutin version. Compare manually.\n`;
-    }
+const list = (items, describe = ({ relPath }) => `\`${relPath}\``) => items.map((item) => `- ${describe(item)}`).join('\n');
 
-    const patch = Diff.createTwoFilesPatch(
-      relPath,
-      relPath,
-      actualContent,
-      newEntry.content,
-      'yours',
-      `nutin v${newVersion}`,
+// Lists the files you edited that this update touched. No diffs: merged files hold both versions'
+// changes, and overlaps are marked in the files themselves.
+export async function writeUpdateReport(projectPath, { merged, conflicted, binaryConflicts }, oldVersion, newVersion) {
+  const sections = [
+    `# nutin-update report\n\nUpdate from nutin v${oldVersion} to v${newVersion}. These files had changes of yours and changes in the new nutin version.`,
+  ];
+
+  if (conflicted.length > 0) {
+    sections.push(
+      '## Conflicts to resolve\n\n' +
+      'Your edits and nutin\'s overlap in these files. **The project won\'t build until they\'re resolved.** ' +
+      `Each conflict is marked in the file: \`${CONFLICT_MARKER}\` starts your version, \`||||||| nutin v${oldVersion}\` ` +
+      `the original one, \`=======\` the new one, ending at \`>>>>>>> nutin v${newVersion}\`. ` +
+      'Keep what you need, delete the markers, then run nutin-update again to confirm.\n\n' +
+      list(conflicted, ({ relPath, conflictCount }) => `\`${relPath}\` (${conflictCount} conflict${conflictCount > 1 ? 's' : ''})`),
+    );
+  }
+
+  if (merged.length > 0) {
+    sections.push(
+      '## Merged automatically\n\nYour edits and the new version\'s changes didn\'t overlap, so both were kept. Review them.\n\n' +
+      list(merged),
     );
-    return `## ${relPath}\n\n\`\`\`diff\n${patch}\`\`\`\n`;
-  });
+  }
 
-  const header = '# nutin-update report\n\n' +
-    `These files changed between nutin v${oldVersion} and v${newVersion}, but you've customized them ` +
-    'since generation, so they were left untouched. Review each diff below (yours vs. the new nutin ' +
-    'version) and merge by hand.\n\n';
+  if (binaryConflicts.length > 0) {
+    sections.push(
+      '## Binary files left as they are\n\nThese can\'t be merged: your version was kept. Compare it with the new one manually.\n\n' +
+      list(binaryConflicts),
+    );
+  }
 
-  await fs.writeFile(path.join(projectPath, REPORT_FILE_NAME), header + sections.join('\n'));
+  await fs.writeFile(path.join(projectPath, REPORT_FILE_NAME), sections.join('\n\n') + '\n');
 }