@wpmoo/odoo 0.8.30

package/dist/module-actions.js

@@ -0,0 +1,107 @@
+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';
+function sourceRepoPath(target, repoPath) {
+    return pathUnderBase(join(target, 'odoo/custom/src/private'), repoPath, 'repo path');
+}
+function modulePath(target, repoPath, moduleName) {
+    return pathUnderBase(sourceRepoPath(target, 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 destination = modulePath(options.target, 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 (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, repoPath));
+        await stageAll(git, options.target);
+    }
+}
+export async function listModulesInSourceRepo(target, repoPath) {
+    const safeRepoPath = validateRepoPath(repoPath);
+    try {
+        const entries = await readdir(sourceRepoPath(target, safeRepoPath), { withFileTypes: true });
+        const modules = await Promise.all(entries
+            .filter((entry) => entry.isDirectory())
+            .map(async (entry) => {
+            try {
+                await readFile(join(sourceRepoPath(target, 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);
+    if (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, repoPath, moduleName), { recursive: true, force: true });
+    }
+    if (options.stage) {
+        if (options.deleteFiles) {
+            await stageAll(git, sourceRepoPath(options.target, repoPath));
+        }
+        await stageAll(git, options.target);
+    }
+}

package/dist/odoo-versions.js

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

package/dist/path-validation.js

@@ -0,0 +1,50 @@
+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

@@ -0,0 +1,8 @@
+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

@@ -0,0 +1,34 @@
+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

@@ -0,0 +1,106 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { addSourceRepoToAddonsYaml, removeSourceRepoFromAddonsYaml } from './addons-yaml.js';
+import { readEnvironmentMetadata } 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';
+export const addonsYamlHeader = `# Addons activated from source submodules.
+#
+# Source repos are managed as Git submodules under odoo/custom/src/private.
+# Do not duplicate these same repos in repos.yaml.
+`;
+function privateSubmodulePath(repoPath) {
+    return `odoo/custom/src/private/${validateRepoPath(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 submodulePath = privateSubmodulePath(repoPath);
+    await ensureRemoteHasBranch(git, options.target, options.repoUrl, options.odooVersion, options.initEmptyRepos);
+    await mkdir(join(options.target, 'odoo/custom/src/private'), { 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}`);
+    }
+    if (!(await isComposeEnvironment(options.target))) {
+        const addonsYaml = await readAddonsYaml(options.target);
+        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) {
+    try {
+        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
+        return [...gitmodules.matchAll(/^\s*path\s*=\s*odoo\/custom\/src\/private\/(.+)$/gm)]
+            .map((match) => match[1].trim())
+            .filter((repoPath) => repoPath && isValidPathSegment(repoPath))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+export async function removeModuleRepo(options, git = realGit) {
+    const repoPath = validateRepoPath(options.repoPath);
+    const submodulePath = privateSubmodulePath(repoPath);
+    const fullSubmodulePath = join(options.target, submodulePath);
+    if (await hasUncommittedChanges(git, fullSubmodulePath)) {
+        throw new Error(`Cannot remove ${repoPath}: submodule has uncommitted changes.`);
+    }
+    await removeSubmodule(git, options.target, submodulePath);
+    if (!(await isComposeEnvironment(options.target))) {
+        const addonsYaml = await readAddonsYaml(options.target);
+        await writeAddonsYaml(options.target, removeSourceRepoFromAddonsYaml(addonsYaml, repoPath));
+    }
+    await syncComposeOdooConfAddonsPath(options.target);
+    if (options.stage) {
+        await stageAll(git, options.target);
+    }
+}

package/dist/repo-url.js

@@ -0,0 +1,27 @@
+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

@@ -0,0 +1,46 @@
+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

@@ -0,0 +1,129 @@
+import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { basename, join } from 'node:path';
+import { readEnvironmentMetadata } from './environment.js';
+import { realGit, stageAll } from './git.js';
+import { isValidPathSegment, validateAddonName, validateRepoPath } from './path-validation.js';
+import { listModuleRepos, readAddonsYaml } from './repo-actions.js';
+import { generatedFiles } from './scaffold.js';
+export function renderSafeResetPreview(target, stage) {
+    return [
+        'Safe reset will refresh generated WPMoo environment files.',
+        '',
+        'Target:',
+        target,
+        '',
+        'Will update:',
+        '- .wpmoo/odoo.json',
+        '- moo',
+        '- .gitignore',
+        '- README.md',
+        '- AGENTS.md',
+        '- docs/appstore-release.md',
+        '- Compose generated files',
+        '',
+        'Will not touch:',
+        '- source repo folders under odoo/custom/src/private',
+        '- module source code',
+        '- Git history, remotes, or branches',
+        '',
+        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 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) {
+    const safeRepoPath = validateRepoPath(repoPath);
+    try {
+        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
+        const escapedPath = `odoo/custom/src/private/${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/private/${safeRepoPath}`;
+    }
+    catch {
+        return `odoo/custom/src/private/${safeRepoPath}`;
+    }
+}
+async function inferOptions(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    const addonsYaml = await readAddonsYaml(target);
+    const moduleRepos = await listModuleRepos(target);
+    const addonRepos = parseRepoPathsFromAddonsYaml(addonsYaml);
+    const metadataRepoPaths = metadata?.sourceRepos.map((repo) => repo.path).filter((repoPath) => isValidPathSegment(repoPath)).map(validateRepoPath) ??
+        [];
+    const repoPaths = [
+        ...new Set([...metadataRepoPaths, ...moduleRepos, ...addonRepos]),
+    ];
+    const product = metadata?.product ?? repoPaths[0] ?? titleFromTarget(target);
+    const sourceRepos = await Promise.all(repoPaths.map(async (repoPath) => ({
+        path: repoPath,
+        url: metadata?.sourceRepos.find((repo) => repo.path === repoPath)?.url ?? (await readSubmoduleUrl(target, repoPath)),
+        addons: parseAddonsForRepo(addonsYaml, repoPath),
+    })));
+    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);
+    for (const file of files) {
+        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);
+        }
+    }
+    if (options.stage) {
+        await stageAll(git, options.target);
+    }
+}

package/dist/scaffold.js

@@ -0,0 +1,125 @@
+import { chmod, mkdir, stat, writeFile } from 'node:fs/promises';
+import { dirname, join } from 'node:path';
+import { applyExternalAsset, renderExternalAssetCommand, writeTextFile } from './external-assets.js';
+import { markerPath, renderEnvironmentMetadata } from './environment.js';
+import { plannedExternalAssetOptions, renderComposeEnvExample } from './external-templates.js';
+import { cloneRepository, ensureSubmodule, ensureRemoteHasBranch, realGit, stageAll, syncSubmodules, } from './git.js';
+import { renderAgents, renderAppstoreRelease, renderGitignore, renderMooDelegationScript, renderPlaceholder, renderReadme, } from './templates.js';
+import { validateAddonName, validateRepoPath } from './path-validation.js';
+function validateSourceRepo(repo) {
+    const path = validateRepoPath(repo.path);
+    return {
+        ...repo,
+        path,
+        addons: repo.addons.map(validateAddonName),
+    };
+}
+function validateScaffoldOptions(options) {
+    return {
+        ...options,
+        sourceRepos: options.sourceRepos.map(validateSourceRepo),
+    };
+}
+export function generatedFiles(options) {
+    const safeOptions = validateScaffoldOptions(options);
+    const files = [
+        { path: markerPath, content: renderEnvironmentMetadata(safeOptions) },
+        { path: 'moo', content: renderMooDelegationScript(), mode: 0o755 },
+        { path: '.gitignore', content: renderGitignore() },
+        { path: 'README.md', content: renderReadme(safeOptions) },
+        { path: 'AGENTS.md', content: renderAgents(safeOptions) },
+        { path: 'docs/appstore-release.md', content: renderAppstoreRelease(safeOptions) },
+    ];
+    return [
+        ...files,
+        {
+            path: 'odoo/custom/src/private/README.md',
+            content: renderPlaceholder('private', 'WPMoo source repositories are added here as Git submodules.'),
+        },
+    ];
+}
+async function writeGeneratedFiles(target, files) {
+    for (const file of files) {
+        const destination = join(target, file.path);
+        await mkdir(join(destination, '..'), { recursive: true });
+        await writeFile(destination, file.content, 'utf8');
+        if (file.mode !== undefined) {
+            await chmod(destination, file.mode);
+        }
+    }
+}
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function isGitRepository(git, target) {
+    if (!(await pathExists(target))) {
+        return false;
+    }
+    try {
+        const result = await git.run(target, ['rev-parse', '--is-inside-work-tree']);
+        return result.stdout.trim() === 'true';
+    }
+    catch {
+        return false;
+    }
+}
+async function prepareTargetRepository(options, git) {
+    if (await isGitRepository(git, options.target)) {
+        return;
+    }
+    if (await pathExists(options.target)) {
+        throw new Error(`Target exists but is not a Git repository: ${options.target}\n` +
+            'Clone the dev environment repository first, or remove the directory and run the CLI again.');
+    }
+    await mkdir(dirname(options.target), { recursive: true });
+    await cloneRepository(git, dirname(options.target), options.devRepoUrl, options.target);
+}
+export async function scaffold(options, git = realGit) {
+    const safeOptions = validateScaffoldOptions(options);
+    const files = generatedFiles(safeOptions);
+    const externalAssets = plannedExternalAssetOptions(safeOptions);
+    const plannedCommands = [
+        ...externalAssets.map((assetOptions) => renderExternalAssetCommand(assetOptions)),
+        ...safeOptions.sourceRepos.map((repo) => `git submodule add -b ${safeOptions.odooVersion} ${repo.url} odoo/custom/src/private/${repo.path}`),
+    ];
+    if (safeOptions.stage) {
+        plannedCommands.push('git add .');
+    }
+    if (safeOptions.dryRun) {
+        return {
+            plannedFiles: files.map((file) => file.path),
+            plannedCommands,
+        };
+    }
+    if (!safeOptions.skipSubmodules || safeOptions.stage) {
+        await prepareTargetRepository(safeOptions, git);
+    }
+    await writeGeneratedFiles(safeOptions.target, files);
+    for (const assetOptions of externalAssets) {
+        await applyExternalAsset(assetOptions, git);
+    }
+    await writeTextFile(join(safeOptions.target, '.env.example'), renderComposeEnvExample(safeOptions));
+    if (!safeOptions.skipSubmodules) {
+        for (const repo of safeOptions.sourceRepos) {
+            await ensureRemoteHasBranch(git, safeOptions.target, repo.url, safeOptions.odooVersion, safeOptions.initEmptyRepos);
+        }
+        await mkdir(join(safeOptions.target, 'odoo/custom/src/private'), { recursive: true });
+        for (const repo of safeOptions.sourceRepos) {
+            await ensureSubmodule(git, safeOptions.target, repo.url, safeOptions.odooVersion, `odoo/custom/src/private/${repo.path}`);
+        }
+        await syncSubmodules(git, safeOptions.target);
+    }
+    if (safeOptions.stage) {
+        await stageAll(git, safeOptions.target);
+    }
+    return {
+        plannedFiles: files.map((file) => file.path),
+        plannedCommands,
+    };
+}