@wpmoo/odoo 0.8.30

package/dist/environment-context.js

@@ -0,0 +1,10 @@
+import { readEnvironmentMetadata } from './environment.js';
+import { inferGitHubOwner } from './repo-url.js';
+export async function environmentGitHubOwner(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return inferGitHubOwner(metadata?.devRepoUrl ?? '');
+}
+export async function environmentProduct(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return metadata?.product;
+}

package/dist/environment-version.js

@@ -0,0 +1,5 @@
+import { environmentOdooVersion } from './environment.js';
+export async function commandOdooVersion(target, explicitVersion) {
+    const normalizedVersion = explicitVersion?.trim();
+    return normalizedVersion || environmentOdooVersion(target);
+}

package/dist/environment.js

@@ -0,0 +1,61 @@
+import { access, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { packageName, packageVersion } from './version.js';
+export const markerPath = '.wpmoo/odoo.json';
+export const defaultOdooVersion = '19.0';
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function environmentMetadata(options) {
+    return {
+        tool: packageName(),
+        version: packageVersion(),
+        product: options.product,
+        odooVersion: options.odooVersion,
+        devRepo: options.devRepo,
+        devRepoUrl: options.devRepoUrl,
+        sourceRepos: options.sourceRepos,
+        engine: options.engine ?? 'compose',
+        composeTemplateUrl: options.composeTemplateUrl,
+        composeTemplateRef: options.composeTemplateRef,
+        agentSkillsTemplateUrl: options.agentSkillsTemplateUrl,
+        agentSkillsTemplateRef: options.agentSkillsTemplateRef,
+        postgresVersion: options.postgresVersion,
+        httpPort: options.httpPort,
+        geventPort: options.geventPort,
+    };
+}
+export function renderEnvironmentMetadata(options) {
+    return `${JSON.stringify(environmentMetadata(options), null, 2)}\n`;
+}
+export async function readEnvironmentMetadata(target) {
+    try {
+        const content = await readFile(join(target, markerPath), 'utf8');
+        return JSON.parse(content);
+    }
+    catch {
+        return undefined;
+    }
+}
+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) {
+        return { isEnvironment: true, source: 'layout' };
+    }
+    return { isEnvironment: false, source: 'none' };
+}
+export async function environmentOdooVersion(target) {
+    const metadata = await readEnvironmentMetadata(target);
+    return metadata?.odooVersion || defaultOdooVersion;
+}

package/dist/external-assets.js

@@ -0,0 +1,113 @@
+import { cp, mkdir, mkdtemp, 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;
+    }
+}
+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 copyDirectory(options, checkedOut) {
+    const sourcePath = options.sourceSubdir ? join(checkedOut.root, options.sourceSubdir) : 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 cp(sourcePath, destinationPath, {
+        recursive: true,
+        force: true,
+        filter: (source) => {
+            const rel = relative(sourcePath, source);
+            return !rel || !isExcluded(rel, excludes);
+        },
+    });
+    if (options.readmeDestination) {
+        const readmePath = 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 });
+        }
+    }
+}
+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,69 @@
+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)}`,
+        '',
+    ].join('\n');
+}
+export function composeTemplateOptions(options) {
+    return {
+        label: 'compose',
+        source: options.composeTemplateUrl ?? defaultComposeTemplateUrl,
+        destination: options.target,
+        ref: options.composeTemplateRef,
+        exclude: ['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,62 @@
+export function renderHelp() {
+    return `@wpmoo/odoo
+
+WPMoo Odoo lifecycle tooling.
+
+Usage:
+  npx @wpmoo/odoo
+  npx @wpmoo/odoo create --product <slug> --dev-repo-url <url> --source-repo-url <url>
+  npx @wpmoo/odoo add-repo --repo-url <url>
+  npx @wpmoo/odoo remove-repo --repo <name>
+  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
+
+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>         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.
+  --repo-url <url>             Source repo URL for add-repo.
+  --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.
+
+Example:
+  npx @wpmoo/odoo create \\
+    --product odoo_sample_module \\
+    --odoo-version 19.0 \\
+    --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/odoo 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();
+    }
+}