@wpmoo/odoo 0.8.68 → 0.9.0

package/dist/module-actions.js

@@ -1,114 +0,0 @@
-import { mkdir, readdir, readFile, rm, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { addModuleToSourceRepoInAddonsYaml, removeModuleFromSourceRepoInAddonsYaml, } from './addons-yaml.js';
-import { readEnvironmentMetadata } from './environment.js';
-import { realGit, stageAll } from './git.js';
-import { pathUnderBase, validateModuleName, validateRepoPath } from './path-validation.js';
-import { readAddonsYaml, writeAddonsYaml } from './repo-actions.js';
-const validSourceTypes = ['private', 'oca', 'external'];
-function normalizeSourceType(value) {
-    return validSourceTypes.includes(value) ? value : 'private';
-}
-function sourceRepoPath(target, sourceType, repoPath) {
-    return pathUnderBase(join(target, `odoo/custom/src/${sourceType}`), repoPath, 'repo path');
-}
-function modulePath(target, sourceType, repoPath, moduleName) {
-    return pathUnderBase(sourceRepoPath(target, sourceType, repoPath), moduleName, 'module name');
-}
-function titleizeModule(moduleName) {
-    return moduleName
-        .split(/[_-]+/)
-        .filter(Boolean)
-        .map((part) => part.charAt(0).toUpperCase() + part.slice(1))
-        .join(' ');
-}
-function manifestContent(moduleName, odooVersion) {
-    return `{
-    "name": "${titleizeModule(moduleName)}",
-    "version": "${odooVersion}.1.0.0",
-    "category": "Productivity",
-    "summary": "TODO",
-    "depends": ["base"],
-    "data": [
-        "security/ir.model.access.csv",
-    ],
-    "installable": True,
-    "application": False,
-    "license": "LGPL-3",
-}
-`;
-}
-async function writeIfMissing(path, content) {
-    try {
-        await readFile(path, 'utf8');
-    }
-    catch {
-        await writeFile(path, content, 'utf8');
-    }
-}
-async function usesAddonsYaml(target) {
-    const metadata = await readEnvironmentMetadata(target);
-    return metadata?.engine !== 'compose';
-}
-export async function addModuleToSourceRepo(options, git = realGit) {
-    const repoPath = validateRepoPath(options.repoPath);
-    const moduleName = validateModuleName(options.moduleName);
-    const sourceType = normalizeSourceType(options.sourceType);
-    const destination = modulePath(options.target, sourceType, repoPath, moduleName);
-    await mkdir(join(destination, 'models'), { recursive: true });
-    await mkdir(join(destination, 'security'), { recursive: true });
-    await mkdir(join(destination, 'views'), { recursive: true });
-    await writeIfMissing(join(destination, '__init__.py'), 'from . import models\n');
-    await writeIfMissing(join(destination, '__manifest__.py'), manifestContent(moduleName, options.odooVersion));
-    await writeIfMissing(join(destination, 'models/__init__.py'), '');
-    await writeIfMissing(join(destination, 'security/ir.model.access.csv'), 'id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink\n');
-    await writeIfMissing(join(destination, 'views/.gitkeep'), '');
-    if (sourceType === 'private' && (await usesAddonsYaml(options.target))) {
-        const addonsYaml = await readAddonsYaml(options.target);
-        await writeAddonsYaml(options.target, addModuleToSourceRepoInAddonsYaml(addonsYaml, repoPath, moduleName));
-    }
-    if (options.stage) {
-        await stageAll(git, sourceRepoPath(options.target, sourceType, repoPath));
-        await stageAll(git, options.target);
-    }
-}
-export async function listModulesInSourceRepo(target, repoPath, sourceType) {
-    const safeRepoPath = validateRepoPath(repoPath);
-    const resolvedSourceType = normalizeSourceType(sourceType);
-    try {
-        const entries = await readdir(sourceRepoPath(target, resolvedSourceType, safeRepoPath), { withFileTypes: true });
-        const modules = await Promise.all(entries
-            .filter((entry) => entry.isDirectory())
-            .map(async (entry) => {
-            try {
-                await readFile(join(sourceRepoPath(target, resolvedSourceType, safeRepoPath), entry.name, '__manifest__.py'), 'utf8');
-                return entry.name;
-            }
-            catch {
-                return undefined;
-            }
-        }));
-        return modules.filter((moduleName) => Boolean(moduleName)).sort();
-    }
-    catch {
-        return [];
-    }
-}
-export async function removeModuleFromSourceRepo(options, git = realGit) {
-    const repoPath = validateRepoPath(options.repoPath);
-    const moduleName = validateModuleName(options.moduleName);
-    const sourceType = normalizeSourceType(options.sourceType);
-    if (sourceType === 'private' && (await usesAddonsYaml(options.target))) {
-        const addonsYaml = await readAddonsYaml(options.target);
-        await writeAddonsYaml(options.target, removeModuleFromSourceRepoInAddonsYaml(addonsYaml, repoPath, moduleName));
-    }
-    if (options.deleteFiles) {
-        await rm(modulePath(options.target, sourceType, repoPath, moduleName), { recursive: true, force: true });
-    }
-    if (options.stage) {
-        if (options.deleteFiles) {
-            await stageAll(git, sourceRepoPath(options.target, sourceType, repoPath));
-        }
-        await stageAll(git, options.target);
-    }
-}

package/dist/odoo-versions.js

@@ -1 +0,0 @@
-export const supportedOdooVersions = ['19.0', '18.0', '17.0', '16.0'];

package/dist/path-validation.js

@@ -1,50 +0,0 @@
-import { isAbsolute, relative, resolve } from 'node:path';
-const windowsDrivePattern = /^[a-zA-Z]:/;
-function invalidPathError(label) {
-    return new Error(`Invalid ${label}: use a single path segment without traversal.`);
-}
-export function validatePathSegment(value, label) {
-    const normalized = value.trim();
-    if (!normalized) {
-        throw new Error(`Invalid ${label}: value is required.`);
-    }
-    if (normalized === '.' ||
-        normalized === '..' ||
-        normalized.includes('/') ||
-        normalized.includes('\\') ||
-        normalized.includes('\0') ||
-        normalized.includes(':') ||
-        isAbsolute(normalized) ||
-        windowsDrivePattern.test(normalized)) {
-        throw invalidPathError(label);
-    }
-    return normalized;
-}
-export function isValidPathSegment(value) {
-    try {
-        validatePathSegment(value, 'path');
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-export function validateRepoPath(value) {
-    return validatePathSegment(value, 'repo path');
-}
-export function validateModuleName(value) {
-    return validatePathSegment(value, 'module name');
-}
-export function validateAddonName(value) {
-    return validatePathSegment(value, 'addon name');
-}
-export function pathUnderBase(base, segment, label) {
-    const safeSegment = validatePathSegment(segment, label);
-    const resolvedBase = resolve(base);
-    const destination = resolve(resolvedBase, safeSegment);
-    const relativePath = relative(resolvedBase, destination);
-    if (relativePath === '' || relativePath.startsWith('..') || isAbsolute(relativePath)) {
-        throw invalidPathError(label);
-    }
-    return destination;
-}

package/dist/prompt-copy.js

@@ -1,8 +0,0 @@
-export function renderRepositorySetupNote(product) {
-    return [
-        `Dev repo: ${product}_dev`,
-        `Source repo: ${product}`,
-        `Local folder: ./${product}_dev`,
-        `Submodule path: odoo/custom/src/private/${product}`,
-    ].join('\n');
-}

package/dist/prompt-repositories.js

@@ -1,34 +0,0 @@
-import { confirm, isCancel, text } from '@clack/prompts';
-import { handlePromptCancel, menuPromptMessage } from './menu-navigation.js';
-const defaultPrompt = {
-    confirm,
-    text,
-};
-export async function promptRepositoryUrl({ label, suggestedUrl, placeholder, prompt = defaultPrompt, cancelAction = 'exit', }) {
-    if (suggestedUrl) {
-        const useSuggested = await prompt.confirm({
-            message: `${menuPromptMessage(`Use ${label}? (Y/n)`, cancelAction)}\n${suggestedUrl}`,
-            active: 'Y',
-            inactive: 'n',
-            initialValue: true,
-        });
-        if (isCancel(useSuggested)) {
-            handlePromptCancel(true, cancelAction);
-        }
-        if (useSuggested) {
-            return suggestedUrl;
-        }
-    }
-    const value = await prompt.text({
-        message: menuPromptMessage(label, cancelAction),
-        placeholder,
-        validate: (input) => (input.trim() ? undefined : `Enter the ${label.toLowerCase()}.`),
-    });
-    if (isCancel(value)) {
-        handlePromptCancel(true, cancelAction);
-    }
-    if (typeof value === 'string' && value.trim()) {
-        return value.trim();
-    }
-    throw new Error(`${label} is required`);
-}

package/dist/repo-actions.js

@@ -1,158 +0,0 @@
-import { mkdir, readFile, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
-import { addSourceRepoToAddonsYaml, removeSourceRepoFromAddonsYaml } from './addons-yaml.js';
-import { readEnvironmentMetadata, removeSourceRepoMetadata, upsertSourceRepoMetadata } from './environment.js';
-import { ensureRemoteHasBranch, ensureSubmodule, hasUncommittedChanges, realGit, removeSubmodule, stageAll, } from './git.js';
-import { isValidPathSegment, validateRepoPath } from './path-validation.js';
-import { inferRepoPath } from './repo-url.js';
-import { removeSourceManifestEntry, upsertSourceManifestEntry } from './source-manifest.js';
-export const addonsYamlHeader = `# Addons activated from source submodules.
-#
-# Source repos are managed as Git submodules under odoo/custom/src/private (product code).
-# OCA/external source repos can be placed under odoo/custom/src/oca and odoo/custom/src/external.
-# Do not duplicate these same repos in repos.yaml.
-`;
-const validSourceTypes = ['private', 'oca', 'external'];
-function normalizeSourceType(value) {
-    return validSourceTypes.includes(value) ? value : 'private';
-}
-function sourceSubmodulePath(sourceType, repoPath) {
-    return `odoo/custom/src/${sourceType}/${validateRepoPath(repoPath)}`;
-}
-function resolveSourceTypeFromSubmodulePath(submodulePath) {
-    const match = /^odoo\/custom\/src\/(private|oca|external)\//.exec(submodulePath);
-    if (!match)
-        return undefined;
-    return match[1];
-}
-async function listGitmoduleRepos(target) {
-    try {
-        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
-        return [...gitmodules.matchAll(/^\s*path\s*=\s*odoo\/custom\/src\/(private|oca|external)\/(.+)$/gm)]
-            .map((match) => ({ sourceType: match[1], path: match[2].trim() }))
-            .filter((entry) => isValidPathSegment(entry.path));
-    }
-    catch {
-        return [];
-    }
-}
-async function resolveSubmodulePathFromConfig(target, repoPath, sourceType) {
-    if (sourceType) {
-        return sourceSubmodulePath(sourceType, validateRepoPath(repoPath));
-    }
-    const repoMatches = (await listGitmoduleRepos(target)).filter((repo) => repo.path === repoPath);
-    if (repoMatches.length === 1) {
-        return sourceSubmodulePath(repoMatches[0].sourceType, repoPath);
-    }
-    if (repoMatches.length > 1) {
-        const sorted = repoMatches.map((repo) => repo.sourceType).sort();
-        throw new Error(`Source repo ${repoPath} exists in multiple source directories: ${sorted.join(', ')}. Provide --source-type to disambiguate.`);
-    }
-    return sourceSubmodulePath('private', repoPath);
-}
-export async function readAddonsYaml(target) {
-    try {
-        return await readFile(join(target, 'odoo/custom/src/addons.yaml'), 'utf8');
-    }
-    catch {
-        return `${addonsYamlHeader}\n`;
-    }
-}
-export async function writeAddonsYaml(target, content) {
-    const path = join(target, 'odoo/custom/src/addons.yaml');
-    await mkdir(join(path, '..'), { recursive: true });
-    await writeFile(path, content, 'utf8');
-}
-function composeAddonsPath() {
-    return '/usr/lib/python3/dist-packages/odoo/addons,/mnt/extra-addons,/mnt/wpmoo-addons';
-}
-async function isComposeEnvironment(target) {
-    const metadata = await readEnvironmentMetadata(target);
-    return metadata?.engine === 'compose';
-}
-export async function syncComposeOdooConfAddonsPath(target) {
-    if (!(await isComposeEnvironment(target))) {
-        return;
-    }
-    const configPath = join(target, 'etc/odoo.conf');
-    let content;
-    try {
-        content = await readFile(configPath, 'utf8');
-    }
-    catch {
-        return;
-    }
-    const addonsPathLine = `addons_path = ${composeAddonsPath()}`;
-    const nextContent = /^addons_path\s*=.*$/m.test(content)
-        ? content.replace(/^addons_path\s*=.*$/m, addonsPathLine)
-        : `${content.trimEnd()}\n${addonsPathLine}\n`;
-    if (nextContent !== content) {
-        await writeFile(configPath, nextContent, 'utf8');
-    }
-}
-export async function addModuleRepo(options, git = realGit) {
-    const repoPath = validateRepoPath(options.repoPath?.trim() || inferRepoPath(options.repoUrl));
-    const sourceType = normalizeSourceType(options.sourceType);
-    const submodulePath = sourceSubmodulePath(sourceType, repoPath);
-    await ensureRemoteHasBranch(git, options.target, options.repoUrl, options.odooVersion, options.initEmptyRepos);
-    await mkdir(join(options.target, 'odoo/custom/src', sourceType), { recursive: true });
-    await ensureSubmodule(git, options.target, options.repoUrl, options.odooVersion, submodulePath);
-    const listedRepos = await listModuleRepos(options.target);
-    if (!listedRepos.includes(repoPath)) {
-        throw new Error(`Source repo was added but is not registered in .gitmodules: ${repoPath}`);
-    }
-    await upsertSourceRepoMetadata(options.target, {
-        url: options.repoUrl,
-        path: repoPath,
-        addons: [repoPath],
-        sourceType,
-    });
-    await upsertSourceManifestEntry(options.target, {
-        type: sourceType,
-        path: repoPath,
-        url: options.repoUrl,
-        branch: options.odooVersion,
-        addons: [repoPath],
-    });
-    if (!(await isComposeEnvironment(options.target))) {
-        const addonsYaml = await readAddonsYaml(options.target);
-        if (sourceType === 'private') {
-            await writeAddonsYaml(options.target, addSourceRepoToAddonsYaml(addonsYaml, {
-                path: repoPath,
-                addons: [repoPath],
-            }));
-        }
-    }
-    await syncComposeOdooConfAddonsPath(options.target);
-    if (options.stage) {
-        await stageAll(git, options.target);
-    }
-}
-export async function listModuleRepos(target) {
-    return (await listGitmoduleRepos(target)).map((repo) => repo.path).sort();
-}
-export async function removeModuleRepo(options, git = realGit) {
-    const repoPath = validateRepoPath(options.repoPath);
-    const sourceType = options.sourceType ? normalizeSourceType(options.sourceType) : undefined;
-    const submodulePath = await resolveSubmodulePathFromConfig(options.target, repoPath, sourceType);
-    const fullSubmodulePath = join(options.target, submodulePath);
-    const resolvedSourceType = sourceType ?? resolveSourceTypeFromSubmodulePath(submodulePath);
-    if (await hasUncommittedChanges(git, fullSubmodulePath)) {
-        throw new Error(`Cannot remove ${repoPath}: submodule has uncommitted changes.`);
-    }
-    await removeSubmodule(git, options.target, submodulePath);
-    await removeSourceRepoMetadata(options.target, repoPath, resolvedSourceType);
-    if (resolvedSourceType) {
-        await removeSourceManifestEntry(options.target, resolvedSourceType, repoPath);
-    }
-    if (!(await isComposeEnvironment(options.target))) {
-        const addonsYaml = await readAddonsYaml(options.target);
-        if (resolvedSourceType === 'private') {
-            await writeAddonsYaml(options.target, removeSourceRepoFromAddonsYaml(addonsYaml, repoPath));
-        }
-    }
-    await syncComposeOdooConfAddonsPath(options.target);
-    if (options.stage) {
-        await stageAll(git, options.target);
-    }
-}

package/dist/repo-url.js

@@ -1,27 +0,0 @@
-import { basename } from 'node:path';
-export function normalizeRepositoryUrl(repoUrl) {
-    const trimmed = repoUrl.trim();
-    const withoutSuffix = trimmed.replace(/[?#].*$/, '').replace(/\/+$/, '').replace(/\.git$/, '');
-    const orgPageMatch = withoutSuffix.match(/^https:\/\/github\.com\/orgs\/([^/]+)\/([^/]+)$/);
-    if (orgPageMatch) {
-        return `https://github.com/${orgPageMatch[1]}/${orgPageMatch[2]}.git`;
-    }
-    return trimmed;
-}
-export function inferRepoPath(repoUrl) {
-    const trimmed = normalizeRepositoryUrl(repoUrl).replace(/[?#].*$/, '').replace(/\/+$/, '');
-    const lastSegment = basename(trimmed);
-    const withoutGit = lastSegment.replace(/\.git$/, '');
-    if (!withoutGit) {
-        throw new Error(`Cannot infer repository path from URL: ${repoUrl}`);
-    }
-    return withoutGit;
-}
-export function inferGitHubOwner(repoUrl) {
-    const normalized = normalizeRepositoryUrl(repoUrl);
-    const httpsMatch = normalized.match(/^https:\/\/github\.com\/([^/]+)\//);
-    if (httpsMatch)
-        return httpsMatch[1];
-    const sshMatch = normalized.match(/^git@github\.com:([^/]+)\//);
-    return sshMatch?.[1];
-}

package/dist/repository-preflight.js

@@ -1,46 +0,0 @@
-import { createGitHubRepository, getGitHubRepositoryStatus, githubSlug, isGitHubAuthenticated, isGitHubCliAvailable, realGitHub, } from './github.js';
-export function repositoryRequirements(options) {
-    return [
-        {
-            label: 'Dev environment repo',
-            url: options.devRepoUrl,
-            defaultVisibility: 'private',
-        },
-        ...options.sourceRepos.map((repo) => ({
-            label: `Source repo: ${repo.path}`,
-            url: repo.url,
-            defaultVisibility: 'private',
-        })),
-    ];
-}
-export async function findInaccessibleGitHubRepositories(options, runner = realGitHub) {
-    return (await checkGitHubRepositories(options, runner)).inaccessible;
-}
-export async function checkGitHubRepositories(options, runner = realGitHub) {
-    const accessible = [];
-    const inaccessible = [];
-    for (const requirement of repositoryRequirements(options)) {
-        const status = await getGitHubRepositoryStatus(runner, requirement.url);
-        if (status.status === 'accessible') {
-            accessible.push({ ...requirement, slug: status.slug });
-        }
-        if (status.status === 'inaccessible') {
-            inaccessible.push({ ...requirement, slug: status.slug });
-        }
-    }
-    return { accessible, inaccessible };
-}
-export async function createGitHubRepositories(repositories, visibility, runner = realGitHub) {
-    for (const repository of repositories) {
-        await createGitHubRepository(runner, repository.url, visibility);
-    }
-}
-export async function repositoryPreflightAvailable(runner = realGitHub) {
-    return (await isGitHubCliAvailable(runner)) && (await isGitHubAuthenticated(runner));
-}
-export function manualCreateCommands(repositories) {
-    return repositories.map((repository) => {
-        const slug = githubSlug(repository.url) ?? repository.url;
-        return `gh repo create ${slug} --${repository.defaultVisibility}`;
-    });
-}

package/dist/safe-reset.js

@@ -1,217 +0,0 @@
-import { chmod, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
-import { basename, join } from 'node:path';
-import { environmentMetadata, readEnvironmentMetadata } from './environment.js';
-import { applyExternalAsset, writeTextFile } from './external-assets.js';
-import { plannedExternalAssetOptions, renderComposeEnvExample } from './external-templates.js';
-import { realGit, stageAll } from './git.js';
-import { isValidPathSegment, validateAddonName, validateRepoPath } from './path-validation.js';
-import { readAddonsYaml } from './repo-actions.js';
-import { generatedFiles } from './scaffold.js';
-import { listGitmoduleSources } from './source-manifest.js';
-const safeResetProtectedPaths = [
-    'data',
-    'backups',
-    '.env',
-    '.gitmodules',
-    'odoo/custom/src/private',
-    'odoo/custom/src/oca',
-    'odoo/custom/src/external',
-    'odoo/custom/patches',
-    'odoo/custom/manifests',
-].map((path) => path.replace(/\/$/, ''));
-const safeResetProtectedGeneratedReadmes = new Set([
-    'odoo/custom/src/private/README.md',
-    'odoo/custom/src/oca/README.md',
-    'odoo/custom/src/external/README.md',
-    'odoo/custom/patches/README.md',
-    'odoo/custom/manifests/README.md',
-]);
-function isProtectedGeneratedFile(filePath) {
-    return safeResetProtectedGeneratedReadmes.has(filePath);
-}
-function mergeEnvironmentMetadata(target, options) {
-    const generated = environmentMetadata(options);
-    return readFile(join(target, '.wpmoo/odoo.json'), 'utf8')
-        .then((content) => JSON.parse(content))
-        .then((existing) => {
-        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(() => `${JSON.stringify(generated, null, 2)}\n`);
-}
-export function renderSafeResetPreview(target, stage) {
-    return [
-        'Safe reset will refresh generated WPMoo environment files.',
-        '',
-        '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',
-        '',
-        'Will not touch:',
-        '- source repo folders under odoo/custom/src/private',
-        '- module source code',
-        '- Git history, remotes, or branches',
-        '- .env, data, and backups',
-        '- custom source layout directories (oca, external, patches, manifests)',
-        '- Legacy compose template files may remain until manually removed: docs/assets/, test/, .github/',
-        '',
-        '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.',
-    ].join('\n');
-}
-function titleFromTarget(target) {
-    return basename(target).replace(/_dev$/, '') || 'odoo_sample_module';
-}
-function safeResetExternalAssetOptions(options) {
-    return plannedExternalAssetOptions(options).map((assetOptions) => ({
-        ...assetOptions,
-        exclude: [
-            ...(assetOptions.exclude ?? []),
-            ...safeResetProtectedPaths,
-        ],
-    }));
-}
-function parseAddonsForRepo(addonsYaml, repoPath) {
-    const safeRepoPath = validateRepoPath(repoPath);
-    const lines = addonsYaml.split('\n');
-    const header = `private/${safeRepoPath}:`;
-    const start = lines.findIndex((line) => line.trim() === header);
-    if (start === -1)
-        return [safeRepoPath];
-    const addons = [];
-    for (let index = start + 1; index < lines.length; index += 1) {
-        const line = lines[index];
-        if (!line.startsWith(' '))
-            break;
-        const match = line.trim().match(/^-\s+(.+)$/);
-        const addon = match?.[1]?.trim();
-        if (addon && isValidPathSegment(addon)) {
-            addons.push(validateAddonName(addon));
-        }
-    }
-    return addons.length ? addons : [safeRepoPath];
-}
-function parseRepoPathsFromAddonsYaml(addonsYaml) {
-    return [...addonsYaml.matchAll(/^private\/(.+):$/gm)]
-        .map((match) => match[1].trim())
-        .filter((repoPath) => repoPath && isValidPathSegment(repoPath))
-        .map(validateRepoPath);
-}
-async function readSubmoduleUrl(target, repoPath, sourceType) {
-    const safeRepoPath = validateRepoPath(repoPath);
-    try {
-        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
-        const escapedPath = `odoo/custom/src/${sourceType}/${safeRepoPath}`;
-        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}/${safeRepoPath}`;
-    }
-    catch {
-        return `odoo/custom/src/${sourceType}/${safeRepoPath}`;
-    }
-}
-async function pathExists(path) {
-    try {
-        await stat(path);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-async function inferOptions(target) {
-    const metadata = await readEnvironmentMetadata(target);
-    const addonsYaml = await readAddonsYaml(target);
-    const gitmoduleSources = await listGitmoduleSources(target);
-    const addonRepos = parseRepoPathsFromAddonsYaml(addonsYaml);
-    const sourceByKey = new Map();
-    for (const repo of metadata?.sourceRepos ?? []) {
-        if (isValidPathSegment(repo.path)) {
-            const sourceType = repo.sourceType ?? 'private';
-            const path = validateRepoPath(repo.path);
-            sourceByKey.set(`${sourceType}:${path}`, { sourceType, path });
-        }
-    }
-    for (const repo of gitmoduleSources) {
-        sourceByKey.set(`${repo.type}:${repo.path}`, { sourceType: repo.type, path: repo.path });
-    }
-    for (const repoPath of addonRepos) {
-        sourceByKey.set(`private:${repoPath}`, { sourceType: 'private', path: repoPath });
-    }
-    const sourceLocations = [...sourceByKey.values()];
-    const product = metadata?.product ?? sourceLocations[0]?.path ?? titleFromTarget(target);
-    const sourceRepos = await Promise.all(sourceLocations.map(async ({ sourceType, path }) => ({
-        path,
-        sourceType,
-        url: metadata?.sourceRepos
-            .find((repo) => repo.path === path && (repo.sourceType ?? 'private') === sourceType)
-            ?.url.trim() ||
-            gitmoduleSources.find((repo) => repo.path === path && repo.type === sourceType)?.url ||
-            (await readSubmoduleUrl(target, path, sourceType)),
-        addons: parseAddonsForRepo(addonsYaml, path),
-    })));
-    return {
-        product,
-        odooVersion: metadata?.odooVersion ?? '19.0',
-        devRepo: metadata?.devRepo ?? basename(target),
-        devRepoUrl: metadata?.devRepoUrl ?? target,
-        sourceRepos,
-        engine: 'compose',
-        composeTemplateUrl: metadata?.composeTemplateUrl,
-        composeTemplateRef: metadata?.composeTemplateRef,
-        agentSkillsTemplateUrl: metadata?.agentSkillsTemplateUrl,
-        agentSkillsTemplateRef: metadata?.agentSkillsTemplateRef,
-        postgresVersion: metadata?.postgresVersion,
-        httpPort: metadata?.httpPort,
-        geventPort: metadata?.geventPort,
-        target,
-        dryRun: false,
-        initEmptyRepos: false,
-        stage: false,
-        skipSubmodules: true,
-    };
-}
-export async function safeResetEnvironment(options, git = realGit) {
-    const scaffoldOptions = await inferOptions(options.target);
-    const files = generatedFiles(scaffoldOptions);
-    const externalAssets = safeResetExternalAssetOptions(scaffoldOptions);
-    for (const file of files) {
-        if (file.path === '.wpmoo/odoo.json') {
-            continue;
-        }
-        if (isProtectedGeneratedFile(file.path) && (await pathExists(join(options.target, file.path)))) {
-            continue;
-        }
-        if (file.path === 'odoo/custom/src/addons.yaml') {
-            continue;
-        }
-        const destination = join(options.target, file.path);
-        await mkdir(join(destination, '..'), { recursive: true });
-        await writeFile(destination, file.content, 'utf8');
-        if (file.mode !== undefined) {
-            await chmod(destination, file.mode);
-        }
-    }
-    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, '.env.example'), renderComposeEnvExample(scaffoldOptions));
-    if (options.stage) {
-        await stageAll(git, options.target);
-    }
-}