@wpmoo/odoo 0.8.58 → 0.8.60

package/README.md

@@ -16,7 +16,7 @@ It gives Odoo teams a repeatable environment layout, a guided cockpit for daily
 ## Why WPMoo Odoo
 
 - Create a local Odoo development environment from a dev repository and one or more source repositories.
-- Keep product source repositories under `odoo/custom/src/private` as Git submodules pinned to the selected Odoo branch.
+- Keep product source repositories under `odoo/custom/src/private`, `odoo/custom/src/oca`, or `odoo/custom/src/external` as Git submodules pinned to the selected Odoo branch.
 - Copy Docker Compose resources from the standalone `wpmoo-org/odoo-docker-compose` resource instead of embedding large runtime assets in the TypeScript package.
 - Optionally copy project-local Agent Skills from `wpmoo-org/odoo-skills` into generated environments.
 - Use either a guided terminal cockpit or direct CLI commands for the same lifecycle tasks.
@@ -194,8 +194,9 @@ odoo_sample_module_dev/
 |-- odoo/
 |   `-- custom/
 |       `-- src/
-|           `-- private/
-|               `-- odoo_sample_module/
+|           |-- private/
+|           |-- oca/
+|           `-- external/
 `-- scripts/
 ```
 
@@ -242,6 +243,18 @@ npx @wpmoo/odoo add-repo \
   --init-empty-repos
 ```
 
+Pin source repositories to dedicated source directories:
+
+```bash
+npx @wpmoo/odoo add-repo \
+  --repo-url https://github.com/OCA/sale-workflow.git \
+  --source-type oca
+
+npx @wpmoo/odoo add-repo \
+  --repo-url https://github.com/example-org/odoo_external_tool.git \
+  --source-type external
+```
+
 GitHub CLI is optional for repository setup. When it is available and authenticated, the interactive flow can:
 
 - detect the owner or organization from the current environment;
@@ -283,6 +296,34 @@ npx @wpmoo/odoo remove-repo --repo odoo_sample_module_reports
 
 WPMoo refuses to remove a source repo submodule when that submodule has uncommitted changes.
 
+Generated environments also keep a deterministic source manifest at
+`odoo/custom/manifests/sources.yaml`. It mirrors source submodules from
+`.wpmoo/odoo.json` and `.gitmodules`, including source type, path, URL, branch,
+and addon boundaries.
+
+Inspect configured sources:
+
+```bash
+npx @wpmoo/odoo source list
+```
+
+Regenerate the manifest and metadata from the current metadata/gitmodule state:
+
+```bash
+npx @wpmoo/odoo source sync
+```
+
+`source add` and `source remove` are direct aliases for the same repository
+operations:
+
+```bash
+npx @wpmoo/odoo source add \
+  --repo-url https://github.com/OCA/server-tools.git \
+  --source-type oca
+
+npx @wpmoo/odoo source remove --repo server-tools --source-type oca
+```
+
 ## Status, Doctor, and Recovery
 
 `status` is fast and offline. It reads local metadata and files only:
@@ -299,7 +340,11 @@ It reports whether the environment is detected, which Odoo version is selected,
 npx @wpmoo/odoo doctor
 ```
 
-It validates metadata, engine support, selected compose files, daily scripts, source repo paths, `.env` ports, Docker CLI access, Docker Compose access, Git submodule state, and GitHub CLI authentication when available.
+It validates metadata, engine support, selected compose files, source repo paths,
+source manifest consistency, daily scripts, `.env` settings, Docker CLI access,
+Docker Compose access, GitHub CLI authentication when available, and PostgreSQL
+18 compatibility in compose mount targets (for mounts to
+`/var/lib/postgresql/data` or `/var/lib/postgresql/18/docker`).
 
 Safe reset refreshes generated environment files without deleting product source code:
 
@@ -309,9 +354,19 @@ npx @wpmoo/odoo reset
 
 Safe reset updates generated files such as `.wpmoo/odoo.json`, `moo`,
 `.gitignore`, `.env.example`, generated docs, compose assets, and optional
-Agent Skills. It does not touch source repo folders under
+Agent Skills. Compose overlays like `compose.yaml` and `compose/dev.yaml` are
+also refreshed from the current compose template source.
+
+It does not touch source repo folders under
 `odoo/custom/src/private`, module source code, Git history, remotes, or
-branches. Legacy compose template paths from older scaffolds can remain
+branches. It also preserves local runtime artifacts and custom source layout
+content:
+
+- `.env`, `data`, and `backups`
+- `odoo/custom/src/oca`, `odoo/custom/src/external`, `odoo/custom/patches`,
+  `odoo/custom/manifests`, and their existing contents
+
+Legacy compose template paths from older scaffolds can remain
 (`docs/assets/`, `test/`, `.github/`) until you remove them manually.
 
 Recommended recovery pattern:

package/dist/args.js

@@ -12,6 +12,7 @@ const commandNames = new Set([
     'remove-repo',
     'add-module',
     'remove-module',
+    'source',
     'reset',
     'doctor',
     ...dailyActionCommands,

package/dist/cli.js

@@ -22,6 +22,7 @@ import { promptRepositoryUrl } from './prompt-repositories.js';
 import { inferGitHubOwner, inferRepoPath, normalizeRepositoryUrl } from './repo-url.js';
 import { addModuleRepo, listModuleRepos, removeModuleRepo } from './repo-actions.js';
 import { renderSafeResetPreview, safeResetEnvironment } from './safe-reset.js';
+import { listSources, renderSourceList, syncSources } from './source-actions.js';
 import { checkGitHubRepositories, createGitHubRepositories, manualCreateCommands, repositoryPreflightAvailable, } from './repository-preflight.js';
 import { scaffold } from './scaffold.js';
 import { renderBanner } from './templates.js';
@@ -79,6 +80,19 @@ function stringOption(values, key) {
     const value = values[key];
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }
+function optionalSourceTypeValue(values) {
+    const value = stringOption(values, 'sourceType');
+    if (value === undefined) {
+        return undefined;
+    }
+    if (value === 'private' || value === 'oca' || value === 'external') {
+        return value;
+    }
+    throw new Error(`Invalid value for --source-type: ${value}`);
+}
+function sourceTypeValue(values) {
+    return optionalSourceTypeValue(values) ?? 'private';
+}
 function booleanOption(values, key, fallback) {
     const value = values[key];
     if (value === undefined)
@@ -102,6 +116,12 @@ function shellQuote(value) {
         return value;
     return `'${value.replaceAll("'", "'\\''")}'`;
 }
+function renderedSourceRepoPath(target, sourceType, repoPath) {
+    if (repoPath) {
+        return `${target}/odoo/custom/src/${sourceType}/${repoPath}`;
+    }
+    return `${target}/odoo/custom/src/${sourceType}`;
+}
 function renderPostCreateGuidance(target, cwd) {
     const relativeTarget = relative(cwd, target) || '.';
     return yellow([
@@ -309,6 +329,7 @@ async function addRepoOptionsFromArgs(argv) {
         target,
         repoUrl: normalizeRepositoryUrl(repoUrl),
         repoPath: stringOption(values, 'repo') ?? stringOption(values, 'sourcePath'),
+        sourceType: sourceTypeValue(values),
         odooVersion: await commandOdooVersion(target, stringOption(values, 'odooVersion')),
         initEmptyRepos: booleanOption(values, 'initEmptyRepos', false),
         stage: booleanOption(values, 'stage', true),
@@ -335,6 +356,7 @@ async function addRepoOptionsFromPrompts(showIntro = true, cancelAction = 'exit'
     return {
         target,
         repoUrl,
+        sourceType: 'private',
         odooVersion,
         initEmptyRepos: true,
         stage: true,
@@ -438,6 +460,7 @@ function removeRepoOptionsFromArgs(argv) {
     return {
         target: resolve(stringOption(values, 'target') ?? process.cwd()),
         repoPath,
+        sourceType: optionalSourceTypeValue(values),
         stage: booleanOption(values, 'stage', true),
     };
 }
@@ -448,6 +471,60 @@ function resetOptionsFromArgs(argv) {
         stage: booleanOption(values, 'stage', true),
     };
 }
+function sourceUsage() {
+    return 'Usage: wpmoo source <list|sync|add|remove> [options]';
+}
+function sourceSyncOptionsFromArgs(argv) {
+    const { values } = parseArgs(argv);
+    return {
+        target: resolve(stringOption(values, 'target') ?? process.cwd()),
+        stage: booleanOption(values, 'stage', true),
+    };
+}
+function sourceListTargetFromArgs(argv) {
+    const { values } = parseArgs(argv);
+    return resolve(stringOption(values, 'target') ?? process.cwd());
+}
+async function runSourceCommand(argv) {
+    const [subcommand, ...subcommandArgv] = argv;
+    if (!subcommand) {
+        throw new Error(sourceUsage());
+    }
+    if (subcommand === 'list') {
+        console.log(renderBanner());
+        const target = sourceListTargetFromArgs(subcommandArgv);
+        console.log(renderSourceList(await listSources(target)));
+        return;
+    }
+    if (subcommand === 'sync') {
+        console.log(renderBanner());
+        const options = sourceSyncOptionsFromArgs(subcommandArgv);
+        await syncSources(options);
+        outro(`Synced source manifest in ${options.target}.`);
+        return;
+    }
+    if (subcommand === 'add') {
+        const options = await addRepoOptionsFromArgs(subcommandArgv);
+        if (!options) {
+            throw new Error('Usage: wpmoo source add --repo-url <url> [--source-type private|oca|external]');
+        }
+        console.log(renderBanner());
+        await addModuleRepo(options);
+        outro(`Added source repo under ${renderedSourceRepoPath(options.target, options.sourceType ?? 'private', options.repoPath)}.`);
+        return;
+    }
+    if (subcommand === 'remove') {
+        const options = removeRepoOptionsFromArgs(subcommandArgv);
+        if (!options) {
+            throw new Error('Usage: wpmoo source remove --repo <name> [--source-type private|oca|external]');
+        }
+        console.log(renderBanner());
+        await removeModuleRepo(options);
+        outro(`Removed source repo ${options.repoPath} from ${options.target}.`);
+        return;
+    }
+    throw new Error(sourceUsage());
+}
 async function confirmSafeResetFromMenu(options) {
     note(renderSafeResetPreview(options.target, options.stage), 'Safe reset preview');
     const confirmed = await confirm({
@@ -633,7 +710,7 @@ async function runCockpitCommand(command, cwd) {
         const options = await addRepoOptionsFromPrompts(false, 'back');
         await ensureAddRepoGitHubRepository(options, 'back');
         await addModuleRepo(options);
-        note(`Added source repo under ${options.target}/odoo/custom/src/private.`, 'Done');
+        note(`Added source repo under ${renderedSourceRepoPath(options.target, options.sourceType ?? 'private')}.`, 'Done');
         return 'continue';
     }
     if (command.id === 'remove-repo') {
@@ -724,7 +801,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
         if (options) {
             console.log(renderBanner());
             await addModuleRepo(options);
-            outro(`Added source repo under ${options.target}/odoo/custom/src/private.`);
+            outro(`Added source repo under ${renderedSourceRepoPath(options.target, options.sourceType ?? 'private', options.repoPath)}.`);
             return;
         }
         await showStartup(argv, skipUpdateCheck);
@@ -748,6 +825,10 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
         outro(`Removed source repo ${promptedOptions.repoPath} from ${promptedOptions.target}.`);
         return;
     }
+    if (route.command === 'source') {
+        await runSourceCommand(route.argv);
+        return;
+    }
     if (route.command === 'add-module') {
         const options = await addModuleOptionsFromArgs(route.argv);
         if (options) {

package/dist/doctor.js

@@ -3,7 +3,9 @@ import { join } from 'node:path';
 import { execa } from 'execa';
 import { detectComposeLayout, readEnvFile, selectedComposeEnvironment } from './compose-layout.js';
 import { dailyActionScripts } from './daily-actions.js';
+import { defaultPostgresVersion } from './external-templates.js';
 import { defaultOdooVersion, markerPath } from './environment.js';
+import { listGitmoduleSources, readSourceManifest, sourceManifestPath, } from './source-manifest.js';
 const realCommandRunner = async (command, args, options) => {
     const result = await execa(command, args, { cwd: options.cwd });
     return { stdout: result.stdout, stderr: result.stderr };
@@ -35,19 +37,94 @@ function commandErrorText(error) {
 function isRecord(value) {
     return typeof value === 'object' && value !== null && !Array.isArray(value);
 }
+const incompatiblePostgres18MountTargets = ['/var/lib/postgresql/data', '/var/lib/postgresql/18/docker'];
+function parsePostgresMajorFromValue(value) {
+    if (!value)
+        return undefined;
+    const trimmed = value.trim();
+    if (/^\d{1,3}$/.test(trimmed)) {
+        return trimmed;
+    }
+    const match = trimmed.match(/postgres:([0-9]{1,3})(?:[-._][A-Za-z0-9._-]+)?(?:@[\w:.-]+)?/i);
+    return match?.[1];
+}
+function stripInlineComment(line) {
+    const hashIndex = line.indexOf('#');
+    if (hashIndex === -1)
+        return line;
+    return line.slice(0, hashIndex);
+}
+function hasInvalidPostgres18Mount(line, mountTarget) {
+    const escaped = mountTarget.replaceAll('.', '\\.').replaceAll('/', '\\/');
+    const shortPatterns = [
+        new RegExp(`^\\s*-\\s+.+:\\s*['"]?${escaped}['"]?(?:\\s|:|$)`),
+        new RegExp(`^\\s*-\\s*['"]?${escaped}['"]?(?:\\s|$)`),
+        new RegExp(`^\\s*target:\\s*['"]?${escaped}['"]?(?:\\s|$)`),
+    ];
+    return shortPatterns.some((pattern) => pattern.test(line));
+}
+function invalidPostgres18MountTargetsInCompose(content) {
+    const badTargets = new Set();
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = stripInlineComment(rawLine).trim();
+        if (!line)
+            continue;
+        for (const target of incompatiblePostgres18MountTargets) {
+            if (hasInvalidPostgres18Mount(line, target)) {
+                badTargets.add(target);
+            }
+        }
+    }
+    return [...badTargets];
+}
+function inferPostgresVersion(metadata, odooVersion, env) {
+    const envPostgresImage = env?.get('POSTGRES_IMAGE')?.trim();
+    const envPostgresMajor = parsePostgresMajorFromValue(envPostgresImage);
+    if (envPostgresMajor) {
+        return envPostgresMajor;
+    }
+    const explicitPostgres = parsePostgresMajorFromValue(metadataString(metadata, 'postgresVersion'));
+    if (explicitPostgres) {
+        return explicitPostgres;
+    }
+    return defaultPostgresVersion(odooVersion);
+}
+function normalizeSourceType(value) {
+    if (value === 'oca' || value === 'external' || value === 'private') {
+        return value;
+    }
+    return 'private';
+}
+function sourceRepoPath(type, path) {
+    return `odoo/custom/src/${type}/${path}`;
+}
+function entryKey(type, path) {
+    return `${type}:${path}`;
+}
 function sourceReposFromMetadata(metadata) {
     const sourceRepos = metadata.sourceRepos;
     if (!Array.isArray(sourceRepos))
         return [];
-    return sourceRepos.map((repo, index) => {
+    return sourceRepos
+        .map((repo, index) => {
         if (!isRecord(repo) || typeof repo.path !== 'string' || !repo.path.trim()) {
             throw new Error(`Invalid sourceRepos entry in .wpmoo/odoo.json at index ${index}`);
         }
         return {
             url: typeof repo.url === 'string' ? repo.url : '',
             path: repo.path.trim(),
-            addons: Array.isArray(repo.addons) ? repo.addons.filter((addon) => typeof addon === 'string') : [],
+            addons: Array.isArray(repo.addons)
+                ? repo.addons.filter((addon) => typeof addon === 'string')
+                : [],
+            sourceType: normalizeSourceType(repo.sourceType),
         };
+    })
+        .filter((repo) => repo.path)
+        .sort((left, right) => {
+        const typeOrder = left.sourceType.localeCompare(right.sourceType);
+        if (typeOrder !== 0)
+            return typeOrder;
+        return left.path.localeCompare(right.path);
     });
 }
 async function readMetadata(target) {
@@ -88,7 +165,7 @@ function isNotGitCheckoutError(error) {
 }
 function isSourceRepoSubmodule(path, sourceRepos) {
     return sourceRepos.some((repo) => {
-        const sourcePath = `odoo/custom/src/private/${repo.path}`;
+        const sourcePath = sourceRepoPath(repo.sourceType ?? 'private', repo.path);
         return path === sourcePath || path.startsWith(`${sourcePath}/`);
     });
 }
@@ -112,6 +189,47 @@ function sourceSubmoduleStatusErrors(output, sourceRepos) {
     }
     return errors;
 }
+function manifestEntryToKey(entry) {
+    return entryKey(entry.type, entry.path);
+}
+function manifestRepoToKey(repo) {
+    return entryKey(normalizeSourceType(repo.sourceType), repo.path);
+}
+function formatKeyForPath(key) {
+    const [sourceType, ...pathParts] = key.split(':');
+    return sourceRepoPath(sourceType, pathParts.join(':'));
+}
+function checkSourceConsistency(sourceRepos, manifestEntries, gitmoduleSources, manifestExists) {
+    if (!manifestExists) {
+        return [];
+    }
+    const errors = [];
+    const metadataEntries = new Map();
+    for (const repo of sourceRepos) {
+        metadataEntries.set(manifestRepoToKey(repo), repo);
+    }
+    const manifestMap = new Map();
+    for (const entry of manifestEntries) {
+        manifestMap.set(manifestEntryToKey(entry), entry);
+    }
+    const gitmoduleSet = new Set(gitmoduleSources.map((source) => manifestEntryToKey({ type: source.type, path: source.path })));
+    const sortedMetadataKeys = [...metadataEntries.keys()].sort();
+    const sortedManifestKeys = [...manifestMap.keys()].sort();
+    for (const key of sortedMetadataKeys) {
+        if (!manifestMap.has(key)) {
+            errors.push(`Metadata source entry missing in manifest: ${formatKeyForPath(key)}`);
+        }
+    }
+    for (const key of sortedManifestKeys) {
+        if (!metadataEntries.has(key)) {
+            errors.push(`Manifest source entry missing in metadata: ${formatKeyForPath(key)}`);
+        }
+        if (!gitmoduleSet.has(key)) {
+            errors.push(`Manifest source path missing in .gitmodules: ${formatKeyForPath(key)}`);
+        }
+    }
+    return errors;
+}
 export async function runDoctor(target = process.cwd(), runner = realCommandRunner) {
     const lines = ['WPMoo doctor'];
     const errors = [];
@@ -142,6 +260,24 @@ export async function runDoctor(target = process.cwd(), runner = realCommandRunn
     }
     else {
         lines.push(`OK compose files ${composeLayout.files.join(', ')}`);
+        const postgresVersion = inferPostgresVersion(metadata, odooVersion, env);
+        if (postgresVersion === '18') {
+            for (const file of composeLayout.files) {
+                const composePath = join(target, file);
+                let content;
+                try {
+                    content = await readFile(composePath, 'utf8');
+                }
+                catch (error) {
+                    errors.push(`Cannot read compose file for compatibility check: ${file}: ${errorMessage(error)}`);
+                    continue;
+                }
+                const badMounts = invalidPostgres18MountTargetsInCompose(content);
+                for (const badMount of badMounts) {
+                    errors.push(`PostgreSQL 18 compatibility issue in '${file}': mount target '${badMount}' is invalid; recommend using '/var/lib/postgresql'`);
+                }
+            }
+        }
     }
     const scriptNames = Object.values(dailyActionScripts);
     const scriptErrorCount = errors.length;
@@ -156,12 +292,27 @@ export async function runDoctor(target = process.cwd(), runner = realCommandRunn
     }
     const sourceRepos = sourceReposFromMetadata(metadata);
     for (const repo of sourceRepos) {
-        const relativePath = `odoo/custom/src/private/${repo.path}`;
-        if (!(await exists(join(target, relativePath)))) {
+        const relativePath = sourceRepoPath(normalizeSourceType(repo.sourceType), repo.path);
+        if (!(await exists(join(target, relativePath))) && repo.path) {
             errors.push(`Missing source repo path: ${relativePath}`);
         }
     }
     lines.push(`OK source repos ${sourceRepos.length} checked`);
+    const manifestPath = join(target, sourceManifestPath);
+    const hasManifest = await exists(manifestPath);
+    let manifestEntries = [];
+    if (hasManifest) {
+        try {
+            manifestEntries = (await readSourceManifest(target)).sources;
+        }
+        catch (error) {
+            errors.push(`Failed to read source manifest ${sourceManifestPath}: ${errorMessage(error)}`);
+        }
+    }
+    const gitmoduleSources = await listGitmoduleSources(target);
+    if (errors.length === 0 || manifestEntries.length > 0) {
+        errors.push(...checkSourceConsistency(sourceRepos, manifestEntries, gitmoduleSources, hasManifest));
+    }
     if (env) {
         const httpPort = validatePort('HTTP_PORT', env, errors);
         const geventPort = validatePort('GEVENT_PORT', env, errors);

package/dist/environment.js

@@ -1,6 +1,7 @@
-import { access, readFile } from 'node:fs/promises';
+import { access, readFile, writeFile } from 'node:fs/promises';
 import { join } from 'node:path';
 import { packageName, packageVersion } from './version.js';
+const validSourceTypes = ['private', 'oca', 'external'];
 export const markerPath = '.wpmoo/odoo.json';
 export const defaultOdooVersion = '19.0';
 async function exists(path) {
@@ -34,23 +35,97 @@ export function environmentMetadata(options) {
 export function renderEnvironmentMetadata(options) {
     return `${JSON.stringify(environmentMetadata(options), null, 2)}\n`;
 }
+function normalizeSourceType(sourceType) {
+    const normalized = sourceType ?? 'private';
+    return validSourceTypes.includes(normalized) ? normalized : 'private';
+}
+function normalizeMetadataSourceRepo(repo) {
+    if (!repo || typeof repo !== 'object') {
+        return undefined;
+    }
+    const candidate = repo;
+    const path = typeof candidate.path === 'string' ? candidate.path : '';
+    const url = typeof candidate.url === 'string' ? candidate.url : '';
+    const addons = Array.isArray(candidate.addons) ? candidate.addons.filter((item) => typeof item === 'string') : [];
+    const sourceType = normalizeSourceType(typeof candidate.sourceType === 'string' ? candidate.sourceType : undefined);
+    if (!path) {
+        return undefined;
+    }
+    return { ...candidate, path, url, addons, sourceType };
+}
+function sourceRepoWithType(repo) {
+    return {
+        ...repo,
+        sourceType: normalizeSourceType(repo.sourceType),
+    };
+}
+function withoutPathDuplicates(repos) {
+    const byPath = new Map();
+    repos.forEach((repo) => {
+        const normalized = sourceRepoWithType(repo);
+        byPath.set(`${normalized.sourceType}:${normalized.path}`, normalized);
+    });
+    return Array.from(byPath.values());
+}
 export async function readEnvironmentMetadata(target) {
     try {
         const content = await readFile(join(target, markerPath), 'utf8');
-        return JSON.parse(content);
+        const metadata = JSON.parse(content);
+        if (!metadata?.sourceRepos || !Array.isArray(metadata.sourceRepos)) {
+            return metadata;
+        }
+        metadata.sourceRepos = metadata.sourceRepos
+            .map(normalizeMetadataSourceRepo)
+            .filter((repo) => Boolean(repo));
+        metadata.sourceRepos = withoutPathDuplicates(metadata.sourceRepos);
+        return metadata;
     }
     catch {
         return undefined;
     }
 }
+export async function writeEnvironmentMetadata(target, metadata) {
+    const content = `${JSON.stringify({
+        ...metadata,
+        sourceRepos: metadata.sourceRepos.map(sourceRepoWithType),
+    }, null, 2)}\n`;
+    await writeFile(join(target, markerPath), content, 'utf8');
+}
+export async function replaceSourceRepos(target, sourceRepos) {
+    const metadata = await readEnvironmentMetadata(target);
+    if (!metadata)
+        return;
+    metadata.sourceRepos = withoutPathDuplicates(sourceRepos.map((repo) => sourceRepoWithType(repo)));
+    await writeEnvironmentMetadata(target, metadata);
+}
+export async function upsertSourceRepoMetadata(target, sourceRepo) {
+    const metadata = await readEnvironmentMetadata(target);
+    if (!metadata)
+        return;
+    const normalizedRepo = sourceRepoWithType(sourceRepo);
+    const sources = metadata.sourceRepos.filter((repo) => !(repo.path === normalizedRepo.path && normalizeSourceType(repo.sourceType) === normalizedRepo.sourceType));
+    sources.push(normalizedRepo);
+    metadata.sourceRepos = withoutPathDuplicates(sources);
+    await writeEnvironmentMetadata(target, metadata);
+}
+export async function removeSourceRepoMetadata(target, repoPath, sourceType) {
+    const metadata = await readEnvironmentMetadata(target);
+    if (!metadata)
+        return;
+    const normalizedType = normalizeSourceType(sourceType);
+    metadata.sourceRepos = metadata.sourceRepos.filter((repo) => !(repo.path === repoPath && normalizeSourceType(repo.sourceType) === normalizedType));
+    await writeEnvironmentMetadata(target, metadata);
+}
 export async function detectDevelopmentEnvironment(target) {
     if (await readEnvironmentMetadata(target)) {
         return { isEnvironment: true, source: 'marker' };
     }
     const hasAddonsYaml = await exists(join(target, 'odoo/custom/src/addons.yaml'));
     const hasReposYaml = await exists(join(target, 'odoo/custom/src/repos.yaml'));
-    const hasPrivateDir = await exists(join(target, 'odoo/custom/src/private'));
-    if (hasAddonsYaml && hasReposYaml && hasPrivateDir) {
+    const hasSourceDir = (await exists(join(target, 'odoo/custom/src/private'))) ||
+        (await exists(join(target, 'odoo/custom/src/oca'))) ||
+        (await exists(join(target, 'odoo/custom/src/external')));
+    if (hasAddonsYaml && hasReposYaml && hasSourceDir) {
         return { isEnvironment: true, source: 'layout' };
     }
     return { isEnvironment: false, source: 'none' };

package/dist/help.js

@@ -7,8 +7,12 @@ Usage:
   npx @wpmoo/odoo
   npx @wpmoo/odoo create --product <slug> [--target <path>] --dev-repo-url <url> --source-repo-url <url>
   npx @wpmoo/odoo status
-  npx @wpmoo/odoo add-repo --repo-url <url>
+  npx @wpmoo/odoo add-repo --repo-url <url> [--source-type private|oca|external]
   npx @wpmoo/odoo remove-repo --repo <name>
+  npx @wpmoo/odoo source list
+  npx @wpmoo/odoo source sync
+  npx @wpmoo/odoo source add --repo-url <url> [--source-type private|oca|external]
+  npx @wpmoo/odoo source remove --repo <name> [--source-type private|oca|external]
   npx @wpmoo/odoo add-module --repo <source-repo> --module <module-name>
   npx @wpmoo/odoo remove-module --repo <source-repo> --module <module-name>
   npx @wpmoo/odoo reset
@@ -45,6 +49,7 @@ Options:
   --http-port <port>           Host HTTP port written to .env.example.
   --gevent-port <port>         Host gevent/live chat port written to .env.example.
   --repo-url <url>             Source repo URL for add-repo.
+  --source-type <category>     Source repo category for add-repo/remove-repo. One of private, oca, external. Default: private.
   --repo <name>                Source repo folder name for repo/module actions.
   --module <name>              Odoo module technical name for module actions.
   --delete-files               Also delete module files in remove-module. Default: false.
@@ -90,7 +95,10 @@ Task recipes:
   Create local-only environment:
     npx @wpmoo/odoo
   Add source repo:
-    npx @wpmoo/odoo add-repo --repo-url <url>
+    npx @wpmoo/odoo add-repo --repo-url <url> --source-type oca
+  Inspect and sync source manifest:
+    npx @wpmoo/odoo source list
+    npx @wpmoo/odoo source sync
   Add module:
     npx @wpmoo/odoo add-module --repo <source-repo> --module <module-name>
   Run tests: