@wpmoo/toolkit 0.9.23 → 0.9.25

package/dist/module-quality.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { basename, join, relative } from 'node:path';
+import { parseOdooManifest } from './module-manifest.js';
 export function emptyModuleQualitySummary() {
     return {
         totalModules: 0,
@@ -11,7 +12,8 @@ export function emptyModuleQualitySummary() {
     };
 }
 export function isInstallableManifest(content) {
-    return /["']installable["']\s*:\s*(?:True|true)\b/u.test(content);
+    const parsed = parseOdooManifest(content);
+    return parsed.ok && parsed.manifest.installable !== false;
 }
 export function hasActionableMenuXml(content, moduleName) {
     const actionId = `action_${moduleName}`;
@@ -31,32 +33,144 @@ async function readMenusXml(modulePath) {
         return [];
     }
 }
+async function readPythonModelFiles(modulePath) {
+    try {
+        const entries = await readdir(join(modulePath, 'models'), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.py') && entry.name !== '__init__.py')
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function readViewXmlFiles(modulePath) {
+    try {
+        const entries = await readdir(join(modulePath, 'views'), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.xml') && !entry.name.endsWith('_menus.xml'))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function directoryExists(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readOptionalFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function moduleIssue(moduleName, path, issue) {
+    return { moduleName, path, issue };
+}
+function manifestData(manifest) {
+    return Array.isArray(manifest?.data) ? manifest.data : [];
+}
+function manifestDepends(manifest) {
+    return Array.isArray(manifest?.depends) ? manifest.depends : [];
+}
+function dataIncludesAccessCsv(data) {
+    return data.includes('security/ir.model.access.csv');
+}
+function dataIncludesViewXml(data) {
+    return data.some((entry) => entry.startsWith('views/') && entry.endsWith('.xml') && !entry.endsWith('_menus.xml'));
+}
+function moduleHasOdooStructures(modelFiles, viewFiles, menuXml, data) {
+    return (modelFiles.length > 0 ||
+        viewFiles.length > 0 ||
+        menuXml.length > 0 ||
+        data.some((entry) => entry.startsWith('security/') || entry.startsWith('views/')));
+}
+function pythonImportPresent(content, importName) {
+    if (!content)
+        return false;
+    return new RegExp(`^\\s*from\\s+\\.\\s+import\\s+.*\\b${importName}\\b`, 'mu').test(content);
+}
 export async function analyzeModuleDirectory(modulePath, moduleName = basename(modulePath), relativePath = modulePath) {
     const issues = [];
+    let manifest;
     let installable = false;
-    try {
-        installable = isInstallableManifest(await readFile(join(modulePath, '__manifest__.py'), 'utf8'));
+    const manifestContent = await readOptionalFile(join(modulePath, '__manifest__.py'));
+    if (!manifestContent) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing __manifest__.py'));
     }
-    catch {
-        installable = false;
+    else {
+        const parsedManifest = parseOdooManifest(manifestContent);
+        if (parsedManifest.ok) {
+            manifest = parsedManifest.manifest;
+            installable = manifest.installable !== false;
+        }
+        else {
+            issues.push(moduleIssue(moduleName, relativePath, `invalid manifest syntax: ${parsedManifest.error}`));
+        }
     }
-    if (!installable) {
-        issues.push({
-            moduleName,
-            path: relativePath,
-            issue: 'missing installable=True in __manifest__.py',
-        });
+    if (manifest?.installable === false) {
+        issues.push(moduleIssue(moduleName, relativePath, 'installable is false in __manifest__.py'));
+    }
+    if (manifest && !manifest.license) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing license in __manifest__.py'));
+    }
+    if (manifest && manifest.depends === undefined) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing depends in __manifest__.py'));
     }
     const menuXml = await readMenusXml(modulePath);
+    const modelFiles = await readPythonModelFiles(modulePath);
+    const viewFiles = await readViewXmlFiles(modulePath);
+    const depends = manifestDepends(manifest);
+    const data = manifestData(manifest);
+    const hasOdooStructures = moduleHasOdooStructures(modelFiles, viewFiles, menuXml, data);
+    if (hasOdooStructures && !depends.includes('base')) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing base dependency for model-based module'));
+    }
+    if (modelFiles.length > 0) {
+        const rootInit = await readOptionalFile(join(modulePath, '__init__.py'));
+        if (!pythonImportPresent(rootInit, 'models')) {
+            issues.push(moduleIssue(moduleName, relativePath, 'missing __init__.py models import'));
+        }
+        const modelsInit = await readOptionalFile(join(modulePath, 'models/__init__.py'));
+        const missingModelImport = modelFiles
+            .map((fileName) => fileName.replace(/\.py$/u, ''))
+            .some((modelImport) => !pythonImportPresent(modelsInit, modelImport));
+        if (missingModelImport) {
+            issues.push(moduleIssue(moduleName, relativePath, 'missing models/__init__.py model import'));
+        }
+        if (!(await fileExists(join(modulePath, 'security/ir.model.access.csv')))) {
+            issues.push(moduleIssue(moduleName, relativePath, 'missing security/ir.model.access.csv'));
+        }
+    }
+    if (hasOdooStructures && !dataIncludesAccessCsv(data)) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing security/ir.model.access.csv in manifest data'));
+    }
+    if (hasOdooStructures && viewFiles.length === 0 && !dataIncludesViewXml(data)) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing views XML under views/'));
+    }
+    if (!(await directoryExists(join(modulePath, 'tests')))) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing tests directory'));
+    }
     const hasMenuAction = menuXml.some((content) => hasActionableMenuXml(content, moduleName));
     if (!hasMenuAction) {
-        issues.push({
-            moduleName,
-            path: relativePath,
-            issue: 'missing actionable menu XML',
-        });
+        issues.push(moduleIssue(moduleName, relativePath, 'missing actionable menu XML'));
     }
-    return { moduleName, relativePath, installable, hasMenuAction, issues };
+    return { moduleName, relativePath, installable, hasMenuAction, depends, ...(manifest ? { manifest } : {}), issues };
 }
 export function addModuleQualityResult(summary, result) {
     return {
@@ -69,15 +183,86 @@ export function addModuleQualityResult(summary, result) {
     };
 }
 export function mergeModuleQualitySummaries(left, right) {
+    const missingDependencies = [
+        ...(left.dependencyGraph?.missingDependencies ?? []),
+        ...(right.dependencyGraph?.missingDependencies ?? []),
+    ];
+    const dependencies = [...(left.dependencyGraph?.dependencies ?? []), ...(right.dependencyGraph?.dependencies ?? [])];
+    const cycles = [...(left.dependencyGraph?.cycles ?? []), ...(right.dependencyGraph?.cycles ?? [])];
+    const dependencyGraph = dependencies.length > 0 || missingDependencies.length > 0 || cycles.length > 0
+        ? { dependencies, missingDependencies, cycles }
+        : undefined;
     return {
         totalModules: left.totalModules + right.totalModules,
         installableModules: left.installableModules + right.installableModules,
         nonInstallableModules: left.nonInstallableModules + right.nonInstallableModules,
         modulesWithMenuActions: left.modulesWithMenuActions + right.modulesWithMenuActions,
         modulesMissingMenuActions: left.modulesMissingMenuActions + right.modulesMissingMenuActions,
+        ...(dependencyGraph ? { dependencyGraph } : {}),
         issues: [...left.issues, ...right.issues],
     };
 }
+function firstToken(value) {
+    return value.split(/[_-]+/u, 1)[0] ?? value;
+}
+function looksLikeMissingLocalDependency(moduleName, dependency) {
+    if (dependency === 'base')
+        return false;
+    const namespace = firstToken(moduleName);
+    const generatedOrProjectNamespaces = new Set(['custom', 'demo', 'module', 'odoo', 'wpmoo']);
+    return Boolean(namespace) && generatedOrProjectNamespaces.has(namespace) && dependency.startsWith(`${namespace}_`);
+}
+function findCycleFrom(start, current, graph, path = [start]) {
+    for (const dependency of graph.get(current) ?? []) {
+        if (dependency === start) {
+            return [...path, start];
+        }
+        if (path.includes(dependency)) {
+            continue;
+        }
+        const found = findCycleFrom(start, dependency, graph, [...path, dependency]);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function moduleDependencyGraph(results) {
+    const byName = new Map(results.map((result) => [result.moduleName, result]));
+    const localModuleNames = new Set(byName.keys());
+    const dependencyEdges = new Map();
+    const missingDependencies = [];
+    const dependencies = [];
+    const issues = [];
+    for (const result of results) {
+        const localDependencies = result.depends.filter((dependency) => localModuleNames.has(dependency));
+        dependencyEdges.set(result.moduleName, localDependencies);
+        for (const dependency of result.depends) {
+            if (localModuleNames.has(dependency)) {
+                dependencies.push({ moduleName: result.moduleName, dependency, kind: 'local' });
+                continue;
+            }
+            if (looksLikeMissingLocalDependency(result.moduleName, dependency)) {
+                dependencies.push({ moduleName: result.moduleName, dependency, kind: 'unresolved' });
+                missingDependencies.push({ moduleName: result.moduleName, dependency });
+                issues.push(moduleIssue(result.moduleName, result.relativePath, `missing local dependency ${dependency}`));
+                continue;
+            }
+            dependencies.push({ moduleName: result.moduleName, dependency, kind: 'external' });
+        }
+    }
+    const cycles = [];
+    for (const moduleName of localModuleNames) {
+        const cycle = findCycleFrom(moduleName, moduleName, dependencyEdges);
+        if (cycle) {
+            cycles.push(cycle);
+            const result = byName.get(moduleName);
+            if (result) {
+                issues.push(moduleIssue(moduleName, result.relativePath, `dependency cycle detected: ${cycle.join(' -> ')}`));
+            }
+        }
+    }
+    return { graph: { dependencies, missingDependencies, cycles }, issues };
+}
 export async function scanModuleQuality(root, target) {
     try {
         const rootStat = await stat(root);
@@ -89,6 +274,7 @@ export async function scanModuleQuality(root, target) {
     }
     let summary = emptyModuleQualitySummary();
     const stack = [root];
+    const results = [];
     while (stack.length > 0) {
         const current = stack.pop();
         if (!current)
@@ -104,8 +290,16 @@ export async function scanModuleQuality(root, target) {
             }
         }
         if (hasManifest) {
-            summary = addModuleQualityResult(summary, await analyzeModuleDirectory(current, basename(current), relative(target, current)));
+            const result = await analyzeModuleDirectory(current, basename(current), relative(target, current));
+            results.push(result);
+            summary = addModuleQualityResult(summary, result);
         }
     }
-    return summary;
+    const dependencyGraph = moduleDependencyGraph(results);
+    const hasDependencyGraphIssues = dependencyGraph.graph.missingDependencies.length > 0 || dependencyGraph.graph.cycles.length > 0;
+    return {
+        ...summary,
+        ...(hasDependencyGraphIssues ? { dependencyGraph: dependencyGraph.graph } : {}),
+        issues: [...summary.issues, ...dependencyGraph.issues],
+    };
 }

package/dist/module-target-resolver.js

@@ -0,0 +1,91 @@
+function normalizeQuery(query) {
+    return query.trim().toLowerCase();
+}
+function moduleMatchesExact(query, module) {
+    return module.moduleName.toLowerCase() === query;
+}
+function moduleMatchesPartial(query, module) {
+    return module.moduleName.toLowerCase().includes(query);
+}
+function tokenizeModuleName(moduleName) {
+    return moduleName.toLowerCase().split(/[_-]+/g).filter(Boolean);
+}
+function levenshteinDistance(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (!a) {
+        return b.length;
+    }
+    if (!b) {
+        return a.length;
+    }
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const matrix = Array.from({ length: rows }, (_, rowIndex) => {
+        const row = new Array(cols);
+        if (rowIndex === 0) {
+            for (let col = 0; col < cols; col += 1) {
+                row[col] = col;
+            }
+        }
+        else {
+            row[0] = rowIndex;
+        }
+        return row;
+    });
+    for (let row = 1; row < rows; row += 1) {
+        for (let col = 1; col < cols; col += 1) {
+            const cost = a[row - 1] === b[col - 1] ? 0 : 1;
+            const substitutions = matrix[row - 1][col - 1] + cost;
+            const insertions = matrix[row][col - 1] + 1;
+            const deletions = matrix[row - 1][col] + 1;
+            matrix[row][col] = Math.min(substitutions, insertions, deletions);
+        }
+    }
+    return matrix[a.length][b.length];
+}
+function nearestCandidates(query, modules, maxItems = 3) {
+    const queryNormalized = query;
+    const scoredModules = modules
+        .map((module) => {
+        const fullMatchDistance = levenshteinDistance(module.moduleName.toLowerCase(), queryNormalized);
+        const tokenMatchDistance = tokenizeModuleName(module.moduleName).reduce((best, token) => Math.min(best, levenshteinDistance(token, queryNormalized)), Number.POSITIVE_INFINITY);
+        const distance = Math.min(fullMatchDistance, tokenMatchDistance);
+        return { module, distance };
+    })
+        .filter((entry) => entry.distance <= 4);
+    const scoredWithIndex = scoredModules.map((entry, index) => ({ ...entry, index }));
+    scoredWithIndex.sort((left, right) => {
+        if (left.distance !== right.distance) {
+            return left.distance - right.distance;
+        }
+        return left.index - right.index;
+    });
+    const topDistance = scoredWithIndex[0]?.distance ?? Number.POSITIVE_INFINITY;
+    return scoredWithIndex
+        .filter((entry) => entry.distance <= topDistance + 1)
+        .slice(0, maxItems)
+        .map((entry) => entry.module);
+}
+export function resolveModuleTarget(query, modules) {
+    const normalizedQuery = normalizeQuery(query);
+    if (!normalizedQuery) {
+        return { kind: 'no-match', query, candidates: [] };
+    }
+    const exactMatches = modules.filter((module) => moduleMatchesExact(normalizedQuery, module));
+    if (exactMatches.length === 1) {
+        return { kind: 'exact', query, module: exactMatches[0] };
+    }
+    if (exactMatches.length > 1) {
+        return { kind: 'ambiguous', query, candidates: exactMatches };
+    }
+    const partialMatches = normalizedQuery.length >= 3 ? modules.filter((module) => moduleMatchesPartial(normalizedQuery, module)) : [];
+    if (partialMatches.length === 1) {
+        return { kind: 'exact', query, module: partialMatches[0] };
+    }
+    if (partialMatches.length > 1) {
+        return { kind: 'ambiguous', query, candidates: partialMatches };
+    }
+    return { kind: 'no-match', query, candidates: nearestCandidates(normalizedQuery, modules) };
+}

package/dist/safe-reset.js

@@ -1,3 +1,5 @@
+import { execFileSync } from 'node:child_process';
+import { readFileSync } from 'node:fs';
 import { chmod, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { environmentMetadata, readEnvironmentMetadata } from './environment.js';
@@ -29,35 +31,258 @@ const safeResetProtectedGeneratedReadmes = new Set([
 function isProtectedGeneratedFile(filePath) {
     return safeResetProtectedGeneratedReadmes.has(filePath);
 }
-function mergeEnvironmentMetadata(target, options) {
+function mergeEnvironmentMetadataSync(target, options) {
     const generated = environmentMetadata(options);
-    return readFile(join(target, '.wpmoo/odoo.json'), 'utf8')
-        .then((content) => JSON.parse(content))
-        .then((existing) => {
+    try {
+        const existing = parseMetadataFromPath(target);
         if (!existing || typeof existing !== 'object' || Array.isArray(existing)) {
             return `${JSON.stringify(generated, null, 2)}\n`;
         }
         return `${JSON.stringify({ ...existing, ...generated, sourceRepos: generated.sourceRepos }, null, 2)}\n`;
+    }
+    catch {
+        return `${JSON.stringify(generated, null, 2)}\n`;
+    }
+}
+function parseMetadataFromPath(target) {
+    try {
+        const raw = readFileSync(join(target, '.wpmoo/odoo.json'), 'utf8');
+        const parsed = JSON.parse(raw);
+        if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) {
+            return undefined;
+        }
+        return parsed;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseAddonsFile(target) {
+    try {
+        return readFileSync(join(target, 'odoo/custom/src/addons.yaml'), 'utf8');
+    }
+    catch {
+        return '';
+    }
+}
+function parseGitmodules(target) {
+    try {
+        const gitmodules = readFileSync(join(target, '.gitmodules'), 'utf8');
+        const sections = gitmodules.split(/\n(?=\[submodule )/);
+        return sections.flatMap((section) => {
+            const pathMatch = section.match(/^\s*path\s*=\s*odoo\/custom\/src\/(private|oca|external)\/([^\s]+)\s*$/m);
+            if (!pathMatch) {
+                return [];
+            }
+            const source = section.match(/^\s*url\s*=\s*(.+)\s*$/m)?.[1]?.trim();
+            if (!source) {
+                return [];
+            }
+            const sourceType = pathMatch[1];
+            return [{ path: pathMatch[2], sourceType, url: source }];
+        });
+    }
+    catch {
+        return [];
+    }
+}
+function inferOptionsForPreviewSync(target) {
+    const metadata = parseMetadataFromPath(target);
+    const addonsYaml = parseAddonsFile(target);
+    const gitmoduleSources = parseGitmodules(target);
+    const addonRepos = parseRepoPathsFromAddonsYaml(addonsYaml);
+    const sourceByKey = new Map();
+    const sourceReposFromMetadata = Array.isArray(metadata?.sourceRepos)
+        ? metadata.sourceRepos
+        : [];
+    for (const repo of sourceReposFromMetadata) {
+        if (!repo?.path || !isValidPathSegment(repo.path)) {
+            continue;
+        }
+        sourceByKey.set(`${repo.sourceType ?? 'private'}:${repo.path}`, {
+            sourceType: repo.sourceType ?? 'private',
+            path: validateRepoPath(repo.path),
+        });
+    }
+    for (const repo of gitmoduleSources) {
+        sourceByKey.set(`${repo.sourceType}:${repo.path}`, repo);
+    }
+    for (const repoPath of addonRepos) {
+        sourceByKey.set(`private:${repoPath}`, {
+            sourceType: 'private',
+            path: repoPath,
+        });
+    }
+    const sourceLocations = [...sourceByKey.values()].sort((left, right) => {
+        if (left.sourceType !== right.sourceType) {
+            return left.sourceType.localeCompare(right.sourceType);
+        }
+        return left.path.localeCompare(right.path);
+    });
+    const productFromMetadata = typeof metadata?.product === 'string' ? metadata.product : undefined;
+    const composeTemplateUrl = typeof metadata?.composeTemplateUrl === 'string' ? metadata.composeTemplateUrl : undefined;
+    const composeTemplateRef = typeof metadata?.composeTemplateRef === 'string' ? metadata.composeTemplateRef : undefined;
+    const agentSkillsTemplateUrl = typeof metadata?.agentSkillsTemplateUrl === 'string'
+        ? metadata.agentSkillsTemplateUrl
+        : undefined;
+    const agentSkillsTemplateRef = typeof metadata?.agentSkillsTemplateRef === 'string'
+        ? metadata.agentSkillsTemplateRef
+        : undefined;
+    const odooVersion = typeof metadata?.odooVersion === 'string' ? metadata.odooVersion : undefined;
+    const devRepo = typeof metadata?.devRepo === 'string' ? metadata.devRepo : undefined;
+    const devRepoUrl = typeof metadata?.devRepoUrl === 'string' ? metadata.devRepoUrl : undefined;
+    const postgresVersion = typeof metadata?.postgresVersion === 'string' ? metadata.postgresVersion : undefined;
+    const httpPort = typeof metadata?.httpPort === 'string' ? metadata.httpPort : undefined;
+    const geventPort = typeof metadata?.geventPort === 'string' ? metadata.geventPort : undefined;
+    const product = productFromMetadata && isValidPathSegment(productFromMetadata) ? productFromMetadata
+        : sourceLocations[0]?.path ?? titleFromTarget(target);
+    return {
+        product,
+        odooVersion: odooVersion ?? '19.0',
+        devRepo: devRepo ?? basename(target),
+        devRepoUrl: devRepoUrl ?? target,
+        sourceRepos: sourceLocations.map(({ sourceType, path }) => {
+            const metadataMatch = sourceReposFromMetadata.find((repo) => isValidPathSegment(repo.path ?? '') && validateRepoPath(repo.path ?? '') === path && (repo.sourceType ?? 'private') === sourceType);
+            const gitmoduleMatch = gitmoduleSources.find((repo) => repo.path === path && repo.sourceType === sourceType);
+            return {
+                sourceType,
+                path,
+                url: metadataMatch?.url?.trim() ||
+                    gitmoduleMatch?.url ||
+                    readSubmoduleUrlFromPath(target, path, sourceType),
+                addons: parseAddonsForRepo(addonsYaml, path),
+            };
+        }),
+        engine: 'compose',
+        composeTemplateUrl,
+        composeTemplateRef,
+        agentSkillsTemplateUrl,
+        agentSkillsTemplateRef,
+        postgresVersion,
+        httpPort,
+        geventPort,
+        target,
+        dryRun: false,
+        initEmptyRepos: false,
+        stage: false,
+        skipSubmodules: true,
+    };
+}
+function readSubmoduleUrlFromPath(target, repoPath, sourceType) {
+    try {
+        const gitmodules = readFileSync(join(target, '.gitmodules'), 'utf8');
+        const escapedPath = `odoo/custom/src/${sourceType}/${repoPath}`;
+        const sections = gitmodules.split(/\n(?=\[submodule )/);
+        const section = sections.find((value) => value.includes(`path = ${escapedPath}`));
+        const url = section?.match(/^\s*url\s*=\s*(.+)$/m)?.[1]?.trim();
+        return url || `odoo/custom/src/${sourceType}/${repoPath}`;
+    }
+    catch {
+        return `odoo/custom/src/${sourceType}/${repoPath}`;
+    }
+}
+function safeResetTargetFileDiffs(scaffoldOptions, target) {
+    const files = generatedFiles(scaffoldOptions);
+    const candidates = [
+        ...files,
+        { path: '.env.example', content: renderComposeEnvExample(scaffoldOptions) },
+        { path: '.wpmoo/odoo.json', content: mergeEnvironmentMetadataSync(target, scaffoldOptions) },
+    ];
+    const changedPaths = candidates
+        .filter((file) => {
+        if (file.path === 'odoo/custom/src/addons.yaml' || isProtectedGeneratedFile(file.path)) {
+            return false;
+        }
+        const existing = readTextForPreview(target, file.path);
+        if (existing === undefined) {
+            return true;
+        }
+        return existing !== file.content;
     })
-        .catch(() => `${JSON.stringify(generated, null, 2)}\n`);
+        .map((file) => file.path);
+    return [...new Set(changedPaths)].sort();
+}
+function buildSafeResetSourceRepoLines(sourceRepos) {
+    const lines = [...new Set(sourceRepos.map((repo) => `${repo.sourceType ?? 'private'}/${repo.path}`))].sort();
+    if (lines.length === 0) {
+        return ['- (none detected)'];
+    }
+    return lines.map((repo) => `- ${repo}`);
+}
+function detectDirtyGeneratedFiles(target, candidatePaths) {
+    try {
+        const status = execFileSync('git', ['status', '--porcelain'], {
+            cwd: target,
+            encoding: 'utf8',
+            stdio: ['ignore', 'pipe', 'ignore'],
+        });
+        if (!status.trim()) {
+            return [];
+        }
+        const dirty = new Set();
+        const trackedCandidates = [...candidatePaths];
+        for (const entry of status.split(/\r?\n/)) {
+            if (!entry.trim()) {
+                continue;
+            }
+            const pathSection = entry.slice(3).trim();
+            const normalized = pathSection.includes(' -> ') ? pathSection.split(' -> ')[1] ?? '' : pathSection;
+            if (!normalized) {
+                continue;
+            }
+            if (trackedCandidates.some((candidate) => normalized === candidate || normalized.startsWith(`${candidate}/`))) {
+                dirty.add(normalized);
+            }
+        }
+        return [...dirty].sort();
+    }
+    catch {
+        return [];
+    }
+}
+function describeDirtyWarning(target, candidatePaths) {
+    const dirtyFiles = detectDirtyGeneratedFiles(target, candidatePaths);
+    if (dirtyFiles.length === 0) {
+        return [];
+    }
+    return [
+        'Warning: the following generated files are dirty and may be overwritten by safe reset:',
+        ...dirtyFiles.map((path) => `- ${path}`),
+    ];
+}
+function readTextForPreview(target, path) {
+    try {
+        return readFileSync(join(target, path), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
 }
 export function renderSafeResetPreview(target, stage) {
+    const options = inferOptionsForPreviewSync(target);
+    const externalAssets = safeResetExternalAssetOptions(options);
+    const changedPaths = safeResetTargetFileDiffs(options, target);
+    const externalAssetLines = [];
+    if (externalAssets.some((asset) => asset.label === 'compose')) {
+        externalAssetLines.push('- External compose template assets');
+    }
+    if (externalAssets.some((asset) => asset.label === 'agent-skills')) {
+        externalAssetLines.push('- External agent skill assets when configured');
+    }
+    const generatedSection = changedPaths.length
+        ? ['Generated files that would change:', ...changedPaths.map((file) => `- ${file}`)]
+        : ['Generated files that would change:', '- No generated files differ from the rendered safe-reset output.'];
     return [
-        'Safe reset will refresh generated WPMoo environment files.',
+        'Safe reset preview (dry-run): generated WPMoo files and source repo protections are listed.',
         '',
         'Target:',
         target,
         '',
-        'Will update:',
-        '- .wpmoo/odoo.json',
-        '- moo',
-        '- .gitignore',
-        '- .env.example',
-        '- README.md',
-        '- AGENTS.md',
-        '- docs/appstore-release.md',
-        '- External compose template assets',
-        '- External agent skill assets when configured',
+        ...generatedSection,
+        ...externalAssetLines,
+        '',
+        'Source repositories that will remain untouched:',
+        ...buildSafeResetSourceRepoLines(options.sourceRepos),
         '',
         'Will not touch:',
         '- source repo folders under odoo/custom/src/private',
@@ -67,6 +292,8 @@ export function renderSafeResetPreview(target, stage) {
         '- custom source layout directories (oca, external, patches, manifests)',
         '- Legacy compose template files may remain until manually removed: docs/assets/, test/, .github/',
         '',
+        ...describeDirtyWarning(target, changedPaths),
+        '',
         'Preview-only output; files are not changed until reset is executed.',
         '',
         stage ? 'Generated changes will be staged with git add .' : 'Generated changes will not be staged.',
@@ -209,7 +436,7 @@ export async function safeResetEnvironment(options, git = realGit) {
     for (const assetOptions of externalAssets) {
         await applyExternalAsset(assetOptions, git);
     }
-    await writeTextFile(join(options.target, '.wpmoo/odoo.json'), await mergeEnvironmentMetadata(options.target, scaffoldOptions));
+    await writeTextFile(join(options.target, '.wpmoo/odoo.json'), mergeEnvironmentMetadataSync(options.target, scaffoldOptions));
     await writeTextFile(join(options.target, '.env.example'), renderComposeEnvExample(scaffoldOptions));
     if (options.stage) {
         await stageAll(git, options.target);