@wpmoo/toolkit 0.9.0

package/dist/safe-reset.js

@@ -0,0 +1,217 @@
+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);
+    }
+}

package/dist/scaffold.js

@@ -0,0 +1,161 @@
+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';
+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,
+        sourceRepos: options.sourceRepos.map(validateSourceRepo),
+    };
+}
+export function generatedFiles(options) {
+    const safeOptions = validateScaffoldOptions(options);
+    const sourceDirReadmes = [
+        {
+            path: 'odoo/custom/src/private/README.md',
+            title: 'private',
+            body: 'Project-owned/private addon repositories go here.',
+        },
+        {
+            path: 'odoo/custom/src/oca/README.md',
+            title: 'oca',
+            body: 'OCA repositories go here, for example server-tools, web, queue.',
+        },
+        {
+            path: 'odoo/custom/src/external/README.md',
+            title: 'external',
+            body: 'Non-OCA third-party, vendor, and community addon repositories go here.',
+        },
+        {
+            path: 'odoo/custom/patches/README.md',
+            title: 'patches',
+            body: 'Local patches for upstream/vendor/OCA repositories go here.',
+        },
+        {
+            path: 'odoo/custom/manifests/README.md',
+            title: 'manifests',
+            body: 'Manifest/lock/list files for external sources and pinned revisions go here.',
+        },
+    ];
+    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) },
+        {
+            path: 'odoo/custom/manifests/sources.yaml',
+            content: renderSourceManifest(sourceManifestEntriesFromMetadata(safeOptions.sourceRepos, safeOptions.odooVersion)),
+        },
+    ];
+    return [
+        ...files,
+        ...sourceDirReadmes.map((readme) => ({
+            path: readme.path,
+            content: renderPlaceholder(readme.title, readme.body),
+        })),
+    ];
+}
+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} ${sourceRepoSubmodulePath(repo)}`),
+    ];
+    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);
+        }
+        for (const repo of safeOptions.sourceRepos) {
+            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);
+    }
+    if (safeOptions.stage) {
+        await stageAll(git, safeOptions.target);
+    }
+    return {
+        plannedFiles: files.map((file) => file.path),
+        plannedCommands,
+    };
+}

package/dist/source-actions.js

@@ -0,0 +1,65 @@
+import { defaultOdooVersion, readEnvironmentMetadata, replaceSourceRepos } from './environment.js';
+import { realGit, stageAll } from './git.js';
+import { listGitmoduleSources, readSourceManifest, sourceManifestEntriesFromMetadata, sourceReposFromManifest, syncManifestFromMetadataAndGitmodules, writeSourceManifest, } from './source-manifest.js';
+function cloneSourceEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        addons: [...entry.addons],
+    }));
+}
+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 function sourceListJson(entries) {
+    return {
+        schemaVersion: 1,
+        command: 'source list',
+        ok: true,
+        sources: cloneSourceEntries(entries),
+    };
+}
+export function sourceSyncJson(entries, target) {
+    return {
+        schemaVersion: 1,
+        command: 'source sync',
+        ok: true,
+        target,
+        sources: cloneSourceEntries(entries),
+    };
+}
+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;
+}