@wpmoo/odoo 0.8.58 → 0.8.60

package/dist/repo-actions.js

@@ -1,17 +1,54 @@
 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 { 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.
+# 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.
 `;
-function privateSubmodulePath(repoPath) {
-    return `odoo/custom/src/private/${validateRepoPath(repoPath)}`;
+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 {
@@ -55,20 +92,36 @@ export async function syncComposeOdooConfAddonsPath(target) {
 }
 export async function addModuleRepo(options, git = realGit) {
     const repoPath = validateRepoPath(options.repoPath?.trim() || inferRepoPath(options.repoUrl));
-    const submodulePath = privateSubmodulePath(repoPath);
+    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/private'), { recursive: true });
+    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);
-        await writeAddonsYaml(options.target, addSourceRepoToAddonsYaml(addonsYaml, {
-            path: repoPath,
-            addons: [repoPath],
-        }));
+        if (sourceType === 'private') {
+            await writeAddonsYaml(options.target, addSourceRepoToAddonsYaml(addonsYaml, {
+                path: repoPath,
+                addons: [repoPath],
+            }));
+        }
     }
     await syncComposeOdooConfAddonsPath(options.target);
     if (options.stage) {
@@ -76,28 +129,27 @@ export async function addModuleRepo(options, git = realGit) {
     }
 }
 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 [];
-    }
+    return (await listGitmoduleRepos(target)).map((repo) => repo.path).sort();
 }
 export async function removeModuleRepo(options, git = realGit) {
     const repoPath = validateRepoPath(options.repoPath);
-    const submodulePath = privateSubmodulePath(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);
-        await writeAddonsYaml(options.target, removeSourceRepoFromAddonsYaml(addonsYaml, repoPath));
+        if (resolvedSourceType === 'private') {
+            await writeAddonsYaml(options.target, removeSourceRepoFromAddonsYaml(addonsYaml, repoPath));
+        }
     }
     await syncComposeOdooConfAddonsPath(options.target);
     if (options.stage) {

package/dist/safe-reset.js

@@ -1,12 +1,46 @@
-import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
+import { chmod, mkdir, readFile, stat, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
-import { readEnvironmentMetadata } from './environment.js';
+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 { listModuleRepos, readAddonsYaml } from './repo-actions.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.',
@@ -29,8 +63,12 @@ export function renderSafeResetPreview(target, stage) {
         '- 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');
 }
@@ -42,9 +80,7 @@ function safeResetExternalAssetOptions(options) {
         ...assetOptions,
         exclude: [
             ...(assetOptions.exclude ?? []),
-            '.env',
-            '.gitmodules',
-            'odoo/custom/src/private',
+            ...safeResetProtectedPaths,
         ],
     }));
 }
@@ -74,35 +110,59 @@ function parseRepoPathsFromAddonsYaml(addonsYaml) {
         .filter((repoPath) => repoPath && isValidPathSegment(repoPath))
         .map(validateRepoPath);
 }
-async function readSubmoduleUrl(target, repoPath) {
+async function readSubmoduleUrl(target, repoPath, sourceType) {
     const safeRepoPath = validateRepoPath(repoPath);
     try {
         const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
-        const escapedPath = `odoo/custom/src/private/${safeRepoPath}`;
+        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/private/${safeRepoPath}`;
+        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 `odoo/custom/src/private/${safeRepoPath}`;
+        return false;
     }
 }
 async function inferOptions(target) {
     const metadata = await readEnvironmentMetadata(target);
     const addonsYaml = await readAddonsYaml(target);
-    const moduleRepos = await listModuleRepos(target);
+    const gitmoduleSources = await listGitmoduleSources(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),
+    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,
@@ -130,6 +190,12 @@ export async function safeResetEnvironment(options, git = realGit) {
     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;
         }
@@ -143,6 +209,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, '.env.example'), renderComposeEnvExample(scaffoldOptions));
     if (options.stage) {
         await stageAll(git, options.target);

package/dist/scaffold.js

@@ -6,14 +6,19 @@ import { plannedExternalAssetOptions, renderComposeEnvExample } from './external
 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';
+import { renderSourceManifest, sourceManifestEntriesFromMetadata } from './source-manifest.js';
 function validateSourceRepo(repo) {
     const path = validateRepoPath(repo.path);
     return {
         ...repo,
         path,
+        sourceType: repo.sourceType ?? 'private',
         addons: repo.addons.map(validateAddonName),
     };
 }
+function sourceRepoSubmodulePath(repo) {
+    return `odoo/custom/src/${repo.sourceType ?? 'private'}/${repo.path}`;
+}
 function validateScaffoldOptions(options) {
     return {
         ...options,
@@ -56,6 +61,10 @@ export function generatedFiles(options) {
         { path: 'README.md', content: renderReadme(safeOptions) },
         { path: 'AGENTS.md', content: renderAgents(safeOptions) },
         { path: 'docs/appstore-release.md', content: renderAppstoreRelease(safeOptions) },
+        {
+            path: 'odoo/custom/manifests/sources.yaml',
+            content: renderSourceManifest(sourceManifestEntriesFromMetadata(safeOptions.sourceRepos, safeOptions.odooVersion)),
+        },
     ];
     return [
         ...files,
@@ -113,7 +122,7 @@ export async function scaffold(options, git = realGit) {
     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}`),
+        ...safeOptions.sourceRepos.map((repo) => `git submodule add -b ${safeOptions.odooVersion} ${repo.url} ${sourceRepoSubmodulePath(repo)}`),
     ];
     if (safeOptions.stage) {
         plannedCommands.push('git add .');
@@ -136,9 +145,9 @@ export async function scaffold(options, git = realGit) {
         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 mkdir(join(safeOptions.target, 'odoo/custom/src', repo.sourceType ?? 'private'), { recursive: true });
+            await ensureSubmodule(git, safeOptions.target, repo.url, safeOptions.odooVersion, sourceRepoSubmodulePath(repo));
         }
         await syncSubmodules(git, safeOptions.target);
     }

package/dist/source-actions.js

@@ -0,0 +1,42 @@
+import { defaultOdooVersion, readEnvironmentMetadata, replaceSourceRepos } from './environment.js';
+import { realGit, stageAll } from './git.js';
+import { listGitmoduleSources, readSourceManifest, sourceManifestEntriesFromMetadata, sourceReposFromManifest, syncManifestFromMetadataAndGitmodules, writeSourceManifest, } from './source-manifest.js';
+export async function listSources(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    const manifest = await readSourceManifest(target);
+    if (manifest.sources.length > 0) {
+        return manifest.sources;
+    }
+    if (metadata?.sourceRepos.length) {
+        return sourceManifestEntriesFromMetadata(metadata.sourceRepos, metadata.odooVersion);
+    }
+    return syncManifestFromMetadataAndGitmodules([], metadata?.odooVersion ?? defaultOdooVersion, await listGitmoduleSources(target));
+}
+export function renderSourceList(entries) {
+    if (entries.length === 0) {
+        return 'No source repositories configured.';
+    }
+    return entries
+        .map((entry) => {
+        const branch = entry.branch ? ` @ ${entry.branch}` : '';
+        const addons = entry.addons.length ? ` addons: ${entry.addons.join(', ')}` : '';
+        return `${entry.type}/${entry.path}${branch} -> ${entry.url}${addons}`;
+    })
+        .join('\n');
+}
+export async function syncSources(options, git = realGit) {
+    const metadata = await readEnvironmentMetadata(options.target);
+    const manifest = await readSourceManifest(options.target);
+    const gitmodules = await listGitmoduleSources(options.target);
+    const fallbackBranch = metadata?.odooVersion ?? defaultOdooVersion;
+    const baseRepos = metadata?.sourceRepos.length ? metadata.sourceRepos : sourceReposFromManifest(manifest.sources);
+    const entries = syncManifestFromMetadataAndGitmodules(baseRepos, fallbackBranch, gitmodules);
+    await writeSourceManifest(options.target, entries);
+    if (metadata) {
+        await replaceSourceRepos(options.target, sourceReposFromManifest(entries));
+    }
+    if (options.stage) {
+        await stageAll(git, options.target);
+    }
+    return entries;
+}