@wpmoo/toolkit 0.9.0

package/dist/external-assets.js

@@ -0,0 +1,153 @@
+import { cp, mkdir, mkdtemp, readdir, rm, stat, writeFile } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { dirname, join, relative, resolve } from 'node:path';
+import { realGit } from './git.js';
+const defaultExcludes = ['.git', 'node_modules', '.DS_Store'];
+async function pathExists(path) {
+    try {
+        await stat(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function statIfExists(path) {
+    try {
+        return await stat(path);
+    }
+    catch {
+        return undefined;
+    }
+}
+function expandHome(path) {
+    if (path === '~')
+        return process.env.HOME ?? path;
+    if (path.startsWith('~/'))
+        return join(process.env.HOME ?? '~', path.slice(2));
+    return path;
+}
+export function gitUrlFromSource(source) {
+    if (source.startsWith('gh:')) {
+        return `https://github.com/${source.slice(3).replace(/\.git$/, '')}.git`;
+    }
+    if (source.startsWith('git:github.com/')) {
+        return `https://github.com/${source.slice('git:github.com/'.length).replace(/\.git$/, '')}.git`;
+    }
+    if (/^(https?:|ssh:|git:)/.test(source) || /^[^\s@]+@[^\s:]+:.+/.test(source)) {
+        return source;
+    }
+    return undefined;
+}
+async function checkoutSource(git, source, ref) {
+    const gitUrl = gitUrlFromSource(source);
+    if (!gitUrl) {
+        return { root: resolve(expandHome(source)) };
+    }
+    const tempRoot = await mkdtemp(join(tmpdir(), 'wpmoo-external-'));
+    const cloneDir = join(tempRoot, 'source');
+    const cloneArgs = ['clone', '--depth', '1'];
+    if (ref) {
+        cloneArgs.push('--branch', ref);
+    }
+    cloneArgs.push(gitUrl, cloneDir);
+    try {
+        await git.run(tempRoot, cloneArgs);
+    }
+    catch (error) {
+        if (!ref) {
+            await rm(tempRoot, { recursive: true, force: true });
+            throw error;
+        }
+        await rm(cloneDir, { recursive: true, force: true });
+        await git.run(tempRoot, ['clone', gitUrl, cloneDir]);
+        await git.run(cloneDir, ['checkout', ref]);
+    }
+    return { root: cloneDir, cleanup: tempRoot };
+}
+function isExcluded(relativePath, excludes) {
+    const normalized = relativePath.split('\\').join('/');
+    return excludes.some((pattern) => normalized === pattern || normalized.startsWith(`${pattern}/`));
+}
+async function removeDestinationTypeConflicts(sourcePath, destinationPath, excludes) {
+    async function visit(source) {
+        const rel = relative(sourcePath, source);
+        if (rel && isExcluded(rel, excludes))
+            return;
+        const sourceStat = await stat(source);
+        const destination = rel ? join(destinationPath, rel) : destinationPath;
+        const destinationStat = await statIfExists(destination);
+        if (destinationStat && sourceStat.isDirectory() !== destinationStat.isDirectory()) {
+            await rm(destination, { recursive: true, force: true });
+        }
+        if (!sourceStat.isDirectory()) {
+            return;
+        }
+        const entries = await readdir(source);
+        await Promise.all(entries.map((entry) => visit(join(source, entry))));
+    }
+    await visit(sourcePath);
+}
+async function copyDirectory(options, checkedOut) {
+    const selectedSourceSubdir = await selectSourceSubdir(options, checkedOut.root);
+    const sourcePath = selectedSourceSubdir ? join(checkedOut.root, selectedSourceSubdir) : checkedOut.root;
+    const destinationPath = options.destinationSubdir
+        ? join(options.destination, options.destinationSubdir)
+        : options.destination;
+    if (!(await pathExists(sourcePath))) {
+        throw new Error(`External asset source path does not exist: ${sourcePath}`);
+    }
+    const excludes = [...defaultExcludes, ...(options.exclude ?? [])];
+    await mkdir(destinationPath, { recursive: true });
+    await removeDestinationTypeConflicts(sourcePath, destinationPath, excludes);
+    await cp(sourcePath, destinationPath, {
+        recursive: true,
+        force: true,
+        filter: (source) => {
+            const rel = relative(sourcePath, source);
+            return !rel || !isExcluded(rel, excludes);
+        },
+    });
+    if (options.readmeDestination) {
+        const selectedReadmePath = selectedSourceSubdir ? join(checkedOut.root, selectedSourceSubdir, 'README.md') : undefined;
+        const readmePath = selectedReadmePath && (await pathExists(selectedReadmePath))
+            ? selectedReadmePath
+            : join(checkedOut.root, 'README.md');
+        if (await pathExists(readmePath)) {
+            const destination = join(options.destination, options.readmeDestination);
+            await mkdir(dirname(destination), { recursive: true });
+            await cp(readmePath, destination, { force: true });
+        }
+    }
+}
+async function selectSourceSubdir(options, root) {
+    for (const candidate of options.sourceSubdirCandidates ?? []) {
+        if (await pathExists(join(root, candidate))) {
+            return candidate;
+        }
+    }
+    return options.sourceSubdir;
+}
+export function renderExternalAssetCommand(options) {
+    const sourcePath = options.sourceSubdir ? `${options.source}/${options.sourceSubdir}` : options.source;
+    const destinationPath = options.destinationSubdir
+        ? `${options.destination}/${options.destinationSubdir}`
+        : options.destination;
+    const ref = options.ref ? `#${options.ref}` : '';
+    return `copy external ${options.label}: ${sourcePath}${ref} -> ${destinationPath}`;
+}
+export async function applyExternalAsset(options, git = realGit) {
+    const checkedOut = await checkoutSource(git, options.source, options.ref);
+    try {
+        await copyDirectory(options, checkedOut);
+    }
+    finally {
+        if (checkedOut.cleanup) {
+            await rm(checkedOut.cleanup, { recursive: true, force: true });
+        }
+    }
+}
+export async function writeTextFile(path, content) {
+    await mkdir(dirname(path), { recursive: true });
+    await writeFile(path, content, 'utf8');
+}

package/dist/external-templates.js

@@ -0,0 +1,86 @@
+export const defaultComposeTemplateUrl = 'gh:wpmoo-org/odoo-docker-compose';
+export const defaultAgentSkillsTemplateUrl = 'gh:wpmoo-org/odoo-skills';
+function odooMajorVersion(odooVersion) {
+    return odooVersion.split('.', 1)[0] || odooVersion;
+}
+export function defaultPostgresVersion(odooVersion) {
+    const major = odooMajorVersion(odooVersion);
+    if (major === '19')
+        return '18';
+    if (major === '18')
+        return '17';
+    if (major === '17')
+        return '15';
+    if (major === '16')
+        return '14';
+    return '17';
+}
+export function defaultHttpPort(odooVersion) {
+    const major = odooMajorVersion(odooVersion).padStart(2, '0');
+    return `100${major}`;
+}
+export function defaultGeventPort(odooVersion) {
+    const major = odooMajorVersion(odooVersion).padStart(2, '0');
+    return `200${major}`;
+}
+export function defaultTestModule(options) {
+    return options.sourceRepos.flatMap((repo) => repo.addons)[0] ?? options.product;
+}
+export function renderComposeEnvExample(options) {
+    return [
+        '# Copy to .env and edit for local development.',
+        `ODOO_VERSION=${options.odooVersion}`,
+        `ODOO_IMAGE=odoo:${odooMajorVersion(options.odooVersion)}`,
+        `POSTGRES_IMAGE=postgres:${options.postgresVersion ?? defaultPostgresVersion(options.odooVersion)}`,
+        `HTTP_PORT=${options.httpPort ?? defaultHttpPort(options.odooVersion)}`,
+        `GEVENT_PORT=${options.geventPort ?? defaultGeventPort(options.odooVersion)}`,
+        'POSTGRES_PASSWORD=odoo',
+        'ODOO_MASTER_PASSWORD=admin',
+        `ODOO_TEST_MODULE=${defaultTestModule(options)}`,
+        'WPMOO_ENV=dev',
+        'WPMOO_SNAPSHOT_RETENTION_COUNT=0',
+        '',
+        '# Required only when intentionally running destructive database actions',
+        '# such as resetdb or restore-snapshot with WPMOO_ENV=stage or WPMOO_ENV=prod.',
+        '# WPMOO_ALLOW_DESTRUCTIVE=1',
+        '',
+    ].join('\n');
+}
+export function composeTemplateOptions(options) {
+    return {
+        label: 'compose',
+        source: options.composeTemplateUrl ?? defaultComposeTemplateUrl,
+        destination: options.target,
+        ref: options.composeTemplateRef,
+        sourceSubdirCandidates: ['resources/generated-env'],
+        exclude: [
+            '.github',
+            'docs/assets',
+            'test',
+            'README.md',
+            'README-template.md',
+            '.gitignore',
+            'LICENSE',
+            'package.json',
+            'package-lock.json',
+        ],
+        readmeDestination: 'docs/compose.md',
+    };
+}
+export function agentSkillsTemplateOptions(options) {
+    if (!options.agentSkillsTemplateUrl) {
+        return undefined;
+    }
+    return {
+        label: 'agent-skills',
+        source: options.agentSkillsTemplateUrl,
+        destination: options.target,
+        ref: options.agentSkillsTemplateRef,
+        sourceSubdir: 'skills',
+        destinationSubdir: '.agents/skills',
+        exclude: ['package.json', 'package-lock.json'],
+    };
+}
+export function plannedExternalAssetOptions(options) {
+    return [composeTemplateOptions(options), agentSkillsTemplateOptions(options)].filter((assetOptions) => Boolean(assetOptions));
+}

package/dist/git.js

@@ -0,0 +1,98 @@
+import { mkdtemp, rm } from 'node:fs/promises';
+import { tmpdir } from 'node:os';
+import { basename, join } from 'node:path';
+import { execa } from 'execa';
+export const realGit = {
+    async run(cwd, args) {
+        const result = await execa('git', args, {
+            cwd,
+            env: {
+                ...process.env,
+                GIT_ALLOW_PROTOCOL: 'file:https:ssh:git',
+            },
+        });
+        return { stdout: result.stdout, stderr: result.stderr };
+    },
+};
+export async function hasRemoteHeads(git, cwd, repoUrl) {
+    const result = await git.run(cwd, ['ls-remote', '--heads', repoUrl]);
+    return result.stdout.trim().length > 0;
+}
+export async function initializeEmptyRemote(git, cwd, repoUrl, branch) {
+    const tempRoot = await mkdtemp(join(tmpdir(), 'wpmoo-init-'));
+    const cloneDir = join(tempRoot, basename(repoUrl).replace(/\.git$/, '') || 'repo');
+    try {
+        await git.run(tempRoot, ['clone', repoUrl, cloneDir]);
+        await git.run(cloneDir, ['config', 'user.name', 'Create Odoo Dev Bot']);
+        await git.run(cloneDir, ['config', 'user.email', 'dev@example.com']);
+        await git.run(cloneDir, ['commit', '--allow-empty', '-m', 'Initial commit']);
+        await git.run(cloneDir, ['push', 'origin', `HEAD:${branch}`]);
+    }
+    finally {
+        await rm(tempRoot, { recursive: true, force: true });
+    }
+}
+export async function ensureRemoteHasBranch(git, cwd, repoUrl, branch, initEmptyRepos) {
+    const hasHeads = await hasRemoteHeads(git, cwd, repoUrl);
+    if (!hasHeads) {
+        if (!initEmptyRepos) {
+            throw new Error(`Repository has no commits: ${repoUrl}`);
+        }
+        await initializeEmptyRemote(git, cwd, repoUrl, branch);
+        return;
+    }
+    const branchResult = await git.run(cwd, ['ls-remote', '--heads', repoUrl, branch]);
+    if (!branchResult.stdout.trim()) {
+        throw new Error(`Repository ${repoUrl} does not have branch ${branch}`);
+    }
+}
+export async function addSubmodule(git, target, repoUrl, branch, path) {
+    await git.run(target, ['-c', 'protocol.file.allow=always', 'submodule', 'add', '-b', branch, repoUrl, path]);
+}
+export async function isTrackedPath(git, target, path) {
+    try {
+        await git.run(target, ['ls-files', '--error-unmatch', path]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function ensureSubmodule(git, target, repoUrl, branch, path) {
+    if (await isTrackedPath(git, target, path)) {
+        await git.run(target, ['-c', 'protocol.file.allow=always', 'submodule', 'update', '--init', '--recursive', path]);
+        return;
+    }
+    await addSubmodule(git, target, repoUrl, branch, path);
+}
+export async function hasUncommittedChanges(git, cwd) {
+    const result = await git.run(cwd, ['status', '--porcelain']);
+    return result.stdout.trim().length > 0;
+}
+export async function removeSubmodule(git, target, path) {
+    try {
+        await git.run(target, ['submodule', 'deinit', '-f', path]);
+    }
+    catch {
+        // `git rm` below is the authoritative removal; deinit can fail for partially initialized submodules.
+    }
+    await git.run(target, ['rm', '-f', path]);
+}
+export async function cloneRepository(git, cwd, repoUrl, target) {
+    await git.run(cwd, ['clone', repoUrl, target]);
+}
+export async function syncSubmodules(git, target) {
+    await git.run(target, ['submodule', 'sync', '--recursive']);
+}
+export async function stageAll(git, target) {
+    await git.run(target, ['add', '.']);
+}
+export async function getOriginUrl(git, target) {
+    try {
+        const result = await git.run(target, ['remote', 'get-url', 'origin']);
+        return result.stdout.trim() || undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/github.js

@@ -0,0 +1,87 @@
+import { execa } from 'execa';
+export const realGitHub = {
+    async run(args) {
+        const result = await execa('gh', args);
+        return { stdout: result.stdout, stderr: result.stderr };
+    },
+};
+export function parseGitHubRepoUrl(repoUrl) {
+    const normalized = repoUrl.trim().replace(/[?#].*$/, '').replace(/\/+$/, '').replace(/\.git$/, '');
+    const httpsMatch = normalized.match(/^https:\/\/github\.com\/([^/]+)\/([^/]+)$/);
+    if (httpsMatch) {
+        return { owner: httpsMatch[1], name: httpsMatch[2] };
+    }
+    const sshMatch = normalized.match(/^git@github\.com:([^/]+)\/([^/]+)$/);
+    if (sshMatch) {
+        return { owner: sshMatch[1], name: sshMatch[2] };
+    }
+    return undefined;
+}
+export function githubSlug(repoUrl) {
+    const repo = parseGitHubRepoUrl(repoUrl);
+    return repo ? `${repo.owner}/${repo.name}` : undefined;
+}
+export function githubRepositoryUrl(owner, repo) {
+    return `https://github.com/${owner}/${repo}.git`;
+}
+export async function isGitHubCliAvailable(runner = realGitHub) {
+    try {
+        await runner.run(['--version']);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function getAuthenticatedGitHubLogin(runner = realGitHub) {
+    const result = await runner.run(['api', 'user', '--jq', '.login']);
+    const login = result.stdout.trim();
+    if (!login) {
+        throw new Error('GitHub CLI is not authenticated');
+    }
+    return login;
+}
+export async function isGitHubAuthenticated(runner = realGitHub) {
+    try {
+        await getAuthenticatedGitHubLogin(runner);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function listGitHubOrganizations(runner = realGitHub) {
+    const result = await runner.run(['api', 'user/orgs', '--jq', '.[].login']);
+    return result.stdout
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+}
+export async function getGitHubAccounts(runner = realGitHub) {
+    const user = await getAuthenticatedGitHubLogin(runner);
+    const organizations = await listGitHubOrganizations(runner);
+    return [
+        { login: user, type: 'user' },
+        ...organizations.map((login) => ({ login, type: 'organization' })),
+    ];
+}
+export async function getGitHubRepositoryStatus(runner, repoUrl) {
+    const slug = githubSlug(repoUrl);
+    if (!slug) {
+        return { status: 'unsupported' };
+    }
+    try {
+        await runner.run(['repo', 'view', slug, '--json', 'name']);
+        return { status: 'accessible', slug };
+    }
+    catch {
+        return { status: 'inaccessible', slug };
+    }
+}
+export async function createGitHubRepository(runner, repoUrl, visibility) {
+    const slug = githubSlug(repoUrl);
+    if (!slug) {
+        throw new Error(`Only GitHub repository URLs can be created automatically: ${repoUrl}`);
+    }
+    await runner.run(['repo', 'create', slug, visibility === 'private' ? '--private' : '--public']);
+}

package/dist/help.js

@@ -0,0 +1,157 @@
+export function renderHelp() {
+    return `@wpmoo/toolkit
+
+WPMoo Toolkit for Odoo lifecycle workflows.
+
+Usage:
+  npx @wpmoo/toolkit
+  npx wpmoo
+  npx @wpmoo/toolkit create --product <slug> [--target <path>] --dev-repo-url <url> --source-repo-url <url>
+  npx @wpmoo/toolkit status
+  npx @wpmoo/toolkit status --json
+  npx @wpmoo/toolkit add-repo --repo-url <url> [--source-type private|oca|external]
+  npx @wpmoo/toolkit remove-repo --repo <name>
+  npx @wpmoo/toolkit source list
+  npx @wpmoo/toolkit source list --json
+  npx @wpmoo/toolkit source sync
+  npx @wpmoo/toolkit source sync --json
+  npx @wpmoo/toolkit source add --repo-url <url> [--source-type private|oca|external]
+  npx @wpmoo/toolkit source remove --repo <name> [--source-type private|oca|external]
+  npx @wpmoo/toolkit add-module --repo <source-repo> --module <module-name> [--source-type <category>]
+  npx @wpmoo/toolkit remove-module --repo <source-repo> --module <module-name> [--source-type <category>]
+  npx @wpmoo/toolkit reset [--dry-run]
+  npx @wpmoo/toolkit doctor [--fix]
+  npx @wpmoo/toolkit doctor --json
+  npx @wpmoo/toolkit start
+  npx @wpmoo/toolkit stop
+  npx @wpmoo/toolkit logs [service]
+  npx @wpmoo/toolkit restart
+  npx @wpmoo/toolkit shell
+  npx @wpmoo/toolkit psql [db]
+  npx @wpmoo/toolkit install <module[,module]> [db]
+  npx @wpmoo/toolkit update <module[,module]> [db]
+  npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]
+  npx @wpmoo/toolkit resetdb [db] [module[,module]]
+  npx @wpmoo/toolkit snapshot [db] [snapshot-name]
+  npx @wpmoo/toolkit restore-snapshot [--dry-run] <snapshot-name> [db]
+  npx @wpmoo/toolkit lint
+  npx @wpmoo/toolkit pot <module[,module]> [db] [output]
+
+Options:
+  --product <slug>             Product slug, for example my_odoo_module.
+  --odoo-version <branch>      Odoo branch to pin submodules to. Default: 19.0.
+  --dev-repo-url <url>         Optional development environment repository URL for docs.
+  --target <path>              Target dev repo directory. Default: ./<product>_dev.
+  --engine <value>             Environment engine: compose. Default: compose.
+  --compose-template-url <url> Standalone compose resource source. Default: gh:wpmoo-org/odoo-docker-compose.
+  --compose-template-ref <ref> Git ref for the compose resource.
+  --agent-skills-template      Install project Agent Skills from a standalone skills resource.
+  --agent-skills-template-url <url>
+                               Agent Skills resource source. Default: gh:wpmoo-org/odoo-skills.
+  --agent-skills-template-ref <ref>
+                               Git ref for the Agent Skills resource.
+  --postgres-version <value>   PostgreSQL image version written to compose .env.example.
+  --http-port <port>           Host HTTP port written to .env.example.
+  --gevent-port <port>         Host gevent/live chat port written to .env.example.
+  --json                      Emit machine-readable JSON. Human-readable output remains the default.
+  --repo-url <url>             Source repo URL for add-repo.
+  --source-type <category>     Source repo category for add-repo/remove-repo/add-module/remove-module. 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.
+  --odoo-version <branch>      Override the environment Odoo branch for add-repo/add-module.
+  --source-repo-url <url>      Source repo URL. Repeat for multiple repos.
+  --source-path <path>         Advanced: local folder for the preceding source repo.
+  --source-addons <list>       Advanced: comma-separated addons for the preceding source repo.
+  --create-missing-repos       Create inaccessible GitHub repos with gh CLI.
+  --repo-visibility <value>    Visibility for created repos: private or public. Default: private.
+  --init-empty-repos           Initialize empty source repos with the selected branch.
+  --dry-run                    Print planned files and commands without writing.
+  --stage=false                Do not run git add .
+  --no-update-check            Skip the startup npm update check.
+  --version, -v                Show the package version.
+  --help, -h                   Show this help.
+
+Package aliases:
+  npx @wpmoo/toolkit is the official package path.
+  npx wpmoo is the short alias.
+  npx @wpmoo/odoo and npx @wpmoo/odoo-dev remain legacy compatibility paths.
+
+Daily actions:
+  Daily actions must be run from a generated environment root containing .wpmoo/odoo.json.
+  They delegate to the fixed scripts copied from the compose resource under ./scripts.
+  Generated environments also include ./moo for local compose commands such as ./moo start.
+  Use ./moo or npx @wpmoo/toolkit with the same daily action arguments.
+
+Cockpit:
+  Run npx @wpmoo/toolkit inside a generated environment to open the cockpit.
+  Use Command palette / to search slash commands across services, modules, database,
+  diagnostics, repositories, and maintenance categories.
+  Direct commands such as npx @wpmoo/toolkit status and npx @wpmoo/toolkit test remain available.
+
+Wizard local-only path:
+  Run npx @wpmoo/toolkit from a workspace directory to open the create wizard.
+  Choose any environment folder; the default is ./<product>_dev.
+  Skip Git/GitHub connection to create a local-only environment.
+  Add source repos later from the cockpit or with add-repo.
+
+Status and doctor:
+  status: fast and offline. Reads local environment metadata and files only.
+  doctor: deeper health check. May check Docker CLI access and GitHub workflows.
+  doctor --fix: applies safe file-level repairs. Runs doctor again after fixes.
+
+Task recipes:
+  Create environment:
+    npx @wpmoo/toolkit
+    npx @wpmoo/toolkit create --product <slug> --dev-repo-url <url> --source-repo-url <url>
+  Create local-only environment:
+    npx @wpmoo/toolkit
+  Add source repo:
+    npx @wpmoo/toolkit add-repo --repo-url <url> --source-type oca
+  Inspect and sync source manifest:
+    npx @wpmoo/toolkit source list
+    npx @wpmoo/toolkit source sync
+  Add module:
+    npx @wpmoo/toolkit add-module --repo <source-repo> --module <module-name> --source-type private|oca|external
+  Remove module:
+    npx @wpmoo/toolkit remove-module --repo <source-repo> --module <module-name> --source-type private|oca|external
+  Add OCA module:
+    npx @wpmoo/toolkit add-module --repo sale-workflow --module sale_order_line_no_discount --source-type oca
+  Run tests:
+    npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]
+  Safe reset and recover:
+    npx @wpmoo/toolkit snapshot [db] [snapshot-name]
+    npx @wpmoo/toolkit reset --dry-run
+    npx @wpmoo/toolkit reset
+    npx @wpmoo/toolkit restore-snapshot --dry-run <snapshot-name> [db]
+    npx @wpmoo/toolkit restore-snapshot <snapshot-name> [db]
+  Daily command checks:
+    npx @wpmoo/toolkit status
+    npx @wpmoo/toolkit doctor
+    npx @wpmoo/toolkit doctor --fix
+    npx @wpmoo/toolkit logs [service]
+    npx @wpmoo/toolkit restart
+
+Machine-readable JSON output:
+  for automation and VS Code cockpit integration while keeping default human-readable output.
+    npx @wpmoo/toolkit status --json
+    npx @wpmoo/toolkit source list --json
+    npx @wpmoo/toolkit source sync --json
+    npx @wpmoo/toolkit doctor --json
+
+Example:
+  npx @wpmoo/toolkit create \\
+    --product odoo_sample_module \\
+    --odoo-version 19.0 \\
+    --target ./custom_odoo_dev \\
+    --dev-repo-url https://github.com/example-org/odoo_sample_module_dev.git \\
+    --source-repo-url https://github.com/example-org/odoo_sample_module.git
+
+Compose resource example:
+  npx @wpmoo/toolkit create \\
+    --engine compose \\
+    --product odoo_sample_module \\
+    --source-repo-url https://github.com/example-org/odoo_sample_module.git \\
+    --agent-skills-template
+`;
+}

package/dist/menu-navigation.js

@@ -0,0 +1,67 @@
+import { emitKeypressEvents } from 'node:readline';
+let lastPromptCancelKey;
+export class MenuBackSignal extends Error {
+    constructor() {
+        super('Return to previous menu');
+        this.name = 'MenuBackSignal';
+    }
+}
+export function isMenuBackSignal(error) {
+    return error instanceof MenuBackSignal;
+}
+export function menuIntroTitle(title, action) {
+    return action === 'back' ? `${title} · Back (Esc)` : title;
+}
+export function menuPromptMessage(message, action) {
+    return action === 'back' ? `${message} · Esc to go back` : message;
+}
+export function promptCancelOutcome(cancelled, action, key) {
+    if (!cancelled) {
+        return 'continue';
+    }
+    if (action === 'back' && key !== 'interrupt') {
+        return 'back';
+    }
+    return 'exit';
+}
+export function recordPromptCancelKey(key) {
+    if (key.ctrl && key.name === 'c') {
+        lastPromptCancelKey = 'interrupt';
+        return;
+    }
+    if (key.name === 'escape' || key.sequence === '\u001B') {
+        lastPromptCancelKey = 'escape';
+        return;
+    }
+    lastPromptCancelKey = 'other';
+}
+export function consumePromptCancelKey() {
+    const key = lastPromptCancelKey;
+    lastPromptCancelKey = undefined;
+    return key;
+}
+export function installPromptCancelKeyTracker(input = process.stdin) {
+    emitKeypressEvents(input);
+    const listener = (_value, key) => {
+        if (key.ctrl || key.name === 'escape' || key.sequence === '\u001B') {
+            recordPromptCancelKey(key);
+        }
+    };
+    input.on('keypress', listener);
+    return () => input.off('keypress', listener);
+}
+export function handlePromptCancel(cancelled, action) {
+    const outcome = promptCancelOutcome(cancelled, action, consumePromptCancelKey());
+    if (outcome === 'continue') {
+        return;
+    }
+    if (outcome === 'back') {
+        throw new MenuBackSignal();
+    }
+    process.exit(1);
+}
+export function handleUnavailableMenuChoice(action) {
+    if (action === 'back') {
+        throw new MenuBackSignal();
+    }
+}