@wpmoo/odoo 0.8.30

package/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 WPMoo.org
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

package/README.md

@@ -0,0 +1,231 @@
+# @wpmoo/odoo
+
+![WPMoo Odoo lifecycle tooling across development, staging, and production](https://cdn.jsdelivr.net/npm/@wpmoo/odoo/docs/assets/wpmoo-banner.png)
+
+[![CI](https://github.com/wpmoo-org/wpmoo-odoo/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/wpmoo-org/wpmoo-odoo/actions/workflows/ci.yml)
+
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](LICENSE)
+
+WPMoo Odoo lifecycle tooling for development, staging, and production workflows.
+
+The CLI currently creates Docker Compose based Odoo environments, adds source
+repositories as Git submodules, and stages the result with `git add .`. It does
+not commit. Staging and production workflows will build on the same package and
+command surface.
+
+Compose resources and project-local Agent Skills are copied from standalone
+repositories, so large Docker/skill assets do not need to be embedded in the
+TypeScript CLI. The compose resource uses static version-specific files such as
+`docker-compose_19.0.yml` so it can also be used standalone.
+
+For a product named `odoo_sample_module`, create these repositories first:
+
+```text
+odoo_sample_module_dev  # private development environment repo
+odoo_sample_module      # source repo
+```
+
+The CLI writes into `./odoo_sample_module_dev`. If that directory does not exist
+locally, it clones the dev repo URL you provide.
+
+When GitHub CLI is installed and authenticated, the interactive wizard detects
+your GitHub username and organizations. If multiple accounts are available, it
+asks where the repos should live and uses that owner for the default repo URLs.
+The wizard also checks whether the dev and source repositories are accessible.
+If they are not accessible, it can create them for you after confirmation.
+
+```bash
+brew install gh
+gh auth login
+```
+
+Use cloneable repository URLs such as
+`https://github.com/example-org/odoo_sample_module.git`. If a GitHub
+organization page URL like `https://github.com/orgs/example-org/odoo_sample_module`
+is entered, the CLI normalizes it to the cloneable form.
+
+## Usage
+
+Interactive wizard:
+
+```bash
+npx @wpmoo/odoo
+```
+
+The wizard is context-aware. If the current directory is not already a WPMoo
+Odoo development environment, it starts the create flow directly.
+
+Inside an existing environment, it shows maintenance actions:
+
+```text
+Add source repo
+Remove source repo
+Add module to source repo
+Remove module from source repo
+Safe reset environment
+```
+
+Non-interactive:
+
+```bash
+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 \
+  --create-missing-repos \
+  --init-empty-repos
+```
+
+Multiple source repositories:
+
+```bash
+npx @wpmoo/odoo create \
+  --product odoo_sample_module \
+  --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 \
+  --source-addons odoo_sample_module,odoo_sample_module_portal \
+  --source-repo-url git@github.com:example-org/odoo_sample_module_reports.git \
+  --source-path odoo_sample_module_reports \
+  --source-addons odoo_sample_module_reports
+```
+
+Dry run:
+
+```bash
+npx @wpmoo/odoo create \
+  --product odoo_sample_module \
+  --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 \
+  --dry-run
+```
+
+Default Docker Compose engine through an external standalone compose resource:
+
+```bash
+npx @wpmoo/odoo create \
+  --product odoo_sample_module \
+  --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 \
+  --agent-skills-template
+```
+
+During local resource development, point to local clones of the standalone repos:
+
+```bash
+git clone https://github.com/wpmoo-org/odoo-docker-compose ../odoo-docker-compose
+git clone https://github.com/wpmoo-org/odoo-skills ../odoo-skills
+
+npx @wpmoo/odoo create \
+  --engine compose \
+  --compose-template-url ../odoo-docker-compose \
+  --agent-skills-template \
+  --agent-skills-template-url ../odoo-skills \
+  --product odoo_sample_module \
+  --source-repo-url https://github.com/example-org/odoo_sample_module.git
+```
+
+Add a source repository later from inside the dev environment:
+
+```bash
+npx @wpmoo/odoo
+```
+
+Choose `Add source repo`, then enter only the repository name, such as
+`odoo_sample_module_reports`. The CLI uses the environment's GitHub owner and
+Odoo version, checks whether the repository exists, can create it with GitHub
+CLI when needed, and initializes empty repositories with the environment Odoo
+branch automatically.
+
+Non-interactive URL form:
+
+```bash
+npx @wpmoo/odoo add-repo \
+  --repo-url https://github.com/example-org/odoo_sample_module_reports.git \
+  --odoo-version 19.0 \
+  --init-empty-repos
+```
+
+When run inside a generated environment, maintenance actions use the environment
+Odoo version from `.wpmoo/odoo.json`. Pass `--odoo-version` only when you
+need an explicit override.
+
+Remove a source repository from the dev environment:
+
+```bash
+npx @wpmoo/odoo remove-repo --repo odoo_sample_module_reports
+```
+
+Add a minimal Odoo module skeleton to a selected source repository:
+
+```bash
+npx @wpmoo/odoo add-module \
+  --repo odoo_sample_module \
+  --module odoo_sample_module_base \
+  --odoo-version 19.0
+```
+
+Remove a module registration without deleting source files:
+
+```bash
+npx @wpmoo/odoo remove-module \
+  --repo odoo_sample_module \
+  --module odoo_sample_module_base
+```
+
+Refresh generated environment files without deleting module source code:
+
+```bash
+npx @wpmoo/odoo reset
+```
+
+## Defaults
+
+Each source repo can contain one or many Odoo modules. For example:
+
+```text
+odoo/custom/src/private/odoo_sample_module/
+├── odoo_sample_module_base/
+└── odoo_sample_module_another_module/
+
+odoo/custom/src/private/odoo_sample_module_pro/
+├── odoo_sample_module_payment/
+└── odoo_sample_module_analytics/
+```
+
+If the project has portal, demo, payment, reports, or other addons, pass
+`--source-addons` in non-interactive advanced usage or add modules later with the
+CLI.
+
+## WPMoo Development Guidelines
+
+The CLI keeps environment creation focused on Docker Compose resources, source
+submodules, and WPMoo metadata. It does not install agent tools, editor setup,
+doctor scripts, or other optional development packs.
+
+If you want agent-assisted workflows inside a generated environment, install
+and manage them manually in that environment. For example, Agentic Stack can be
+installed separately:
+
+```bash
+brew tap codejunkie99/agentic-stack https://github.com/codejunkie99/agentic-stack
+brew install agentic-stack
+agentic-stack codex --yes
+```
+
+Keep these files under normal project review, just like any other generated or
+tool-owned development guideline files.
+
+## Notes
+
+- V1 is overlay-first and uses WPMoo's Docker Compose resources by default.
+- Product source repositories are managed as Git submodules under
+  `odoo/custom/src/private`.
+- Product source repositories are discovered from `odoo/custom/src/private` by
+  the compose entrypoint and exposed through `/mnt/wpmoo-addons`.
+- Empty source repos can be initialized with an empty commit and the selected
+  Odoo branch when `--init-empty-repos` is provided.
+- Missing GitHub repositories can be created with GitHub CLI when
+  `--create-missing-repos` is provided, or through the interactive wizard.
+- Legacy `--org`, `--community-repo`, and `--pro-repo` flags are still accepted
+  when no `--source-repo-url` flags are provided.

package/dist/addons-yaml.js

@@ -0,0 +1,59 @@
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+function ensureFinalNewline(value) {
+    return value.endsWith('\n') ? value : `${value}\n`;
+}
+function yamlList(items) {
+    return items.map((item) => `  - ${item}`).join('\n');
+}
+function renderSourceRepoBlock(repo) {
+    return `private/${repo.path}:\n${yamlList(repo.addons)}\n`;
+}
+export function addSourceRepoToAddonsYaml(content, repo) {
+    const blockPattern = new RegExp(`^private/${escapeRegExp(repo.path)}:\\s*$`, 'm');
+    if (blockPattern.test(content)) {
+        return content;
+    }
+    const base = ensureFinalNewline(content.trimEnd());
+    return `${base}\n${renderSourceRepoBlock(repo)}`;
+}
+export function removeSourceRepoFromAddonsYaml(content, repoPath) {
+    const blockPattern = new RegExp(`(^|\\n)private/${escapeRegExp(repoPath)}:\\n(?:[ \\t].*(?:\\n|$))*`, 'g');
+    const updated = content
+        .replace(blockPattern, (match, prefix) => (prefix === '\n' && match.endsWith('\n') ? '\n' : ''))
+        .replace(/\n{3,}/g, '\n\n');
+    return ensureFinalNewline(updated.trimEnd());
+}
+function sourceRepoBlockPattern(repoPath) {
+    return new RegExp(`(^private/${escapeRegExp(repoPath)}:\\n)((?:[ \\t].*(?:\\n|$))*)`, 'm');
+}
+function parseYamlListItems(blockBody) {
+    return blockBody
+        .split('\n')
+        .map((line) => line.trim().match(/^-\s+(.+)$/)?.[1]?.trim())
+        .filter((item) => Boolean(item));
+}
+export function addModuleToSourceRepoInAddonsYaml(content, repoPath, moduleName) {
+    const blockPattern = sourceRepoBlockPattern(repoPath);
+    const match = content.match(blockPattern);
+    if (!match) {
+        return addSourceRepoToAddonsYaml(content, { path: repoPath, addons: [moduleName] });
+    }
+    const addons = parseYamlListItems(match[2]);
+    if (addons.includes(moduleName)) {
+        return content;
+    }
+    const replacement = `${match[1]}${yamlList([...addons, moduleName])}\n`;
+    return content.replace(blockPattern, replacement);
+}
+export function removeModuleFromSourceRepoInAddonsYaml(content, repoPath, moduleName) {
+    const blockPattern = sourceRepoBlockPattern(repoPath);
+    const match = content.match(blockPattern);
+    if (!match) {
+        return content;
+    }
+    const addons = parseYamlListItems(match[2]).filter((addon) => addon !== moduleName);
+    const replacement = `${match[1]}${addons.length ? `${yamlList(addons)}\n` : ''}`;
+    return ensureFinalNewline(content.replace(blockPattern, replacement).trimEnd());
+}

package/dist/args.js

@@ -0,0 +1,247 @@
+import { basename, resolve } from 'node:path';
+import { supportedOdooVersions } from './odoo-versions.js';
+import { defaultAgentSkillsTemplateUrl, defaultComposeTemplateUrl } from './external-templates.js';
+import { defaultCommunityAddons, defaultProAddons } from './templates.js';
+import { validateAddonName, validateRepoPath } from './path-validation.js';
+import { inferGitHubOwner, inferRepoPath, normalizeRepositoryUrl } from './repo-url.js';
+const commandNames = new Set(['create', 'add-repo', 'remove-repo', 'add-module', 'remove-module', 'reset']);
+const internalFlags = new Set(['--no-update-check']);
+export function isUpdateCheckFlag(arg) {
+    return internalFlags.has(arg);
+}
+export function stripInternalFlags(argv) {
+    return argv.filter((arg) => !isUpdateCheckFlag(arg));
+}
+export function commandFromArgs(argv) {
+    if (argv.length === 0) {
+        return { command: 'menu', argv: [] };
+    }
+    const [first, ...rest] = argv;
+    if (commandNames.has(first)) {
+        return { command: first, argv: rest };
+    }
+    if (first.startsWith('--') || first === '-h' || first === '-v') {
+        return { command: 'create', argv };
+    }
+    throw new Error(`Unknown command: ${first}`);
+}
+export function parseArgs(argv) {
+    const values = {};
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg.startsWith('--')) {
+            throw new Error(`Unexpected argument: ${arg}`);
+        }
+        const [rawKey, inlineValue] = arg.slice(2).split('=', 2);
+        const key = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        if (inlineValue !== undefined) {
+            values[key] = inlineValue;
+            continue;
+        }
+        const next = argv[index + 1];
+        if (!next || next.startsWith('--')) {
+            values[key] = true;
+            continue;
+        }
+        values[key] = next;
+        index += 1;
+    }
+    return { values };
+}
+function stringValue(values, key) {
+    const value = values[key];
+    return typeof value === 'string' ? value : undefined;
+}
+function listValue(value, fallback) {
+    if (!value)
+        return fallback;
+    return value
+        .split(',')
+        .map((item) => item.trim())
+        .filter(Boolean);
+}
+function validateAddons(addons) {
+    return addons.map(validateAddonName);
+}
+function valueAfter(argv, index, key) {
+    const arg = argv[index];
+    const inlineValue = arg.includes('=') ? arg.slice(arg.indexOf('=') + 1) : undefined;
+    if (inlineValue !== undefined) {
+        return { value: inlineValue, nextIndex: index };
+    }
+    const next = argv[index + 1];
+    if (!next || next.startsWith('--')) {
+        throw new Error(`Missing value for --${key}`);
+    }
+    return { value: next, nextIndex: index + 1 };
+}
+function parseSourceRepos(argv) {
+    const repos = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg.startsWith('--'))
+            continue;
+        const rawKey = arg.slice(2).split('=', 1)[0];
+        const key = rawKey.replace(/-([a-z])/g, (_, letter) => letter.toUpperCase());
+        if (key === 'sourceRepoUrl') {
+            const parsed = valueAfter(argv, index, rawKey);
+            repos.push({ url: normalizeRepositoryUrl(parsed.value) });
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (key === 'sourcePath') {
+            const current = repos.at(-1);
+            if (!current)
+                throw new Error('--source-path must follow --source-repo-url');
+            const parsed = valueAfter(argv, index, rawKey);
+            current.path = parsed.value;
+            index = parsed.nextIndex;
+            continue;
+        }
+        if (key === 'sourceAddons') {
+            const current = repos.at(-1);
+            if (!current)
+                throw new Error('--source-addons must follow --source-repo-url');
+            const parsed = valueAfter(argv, index, rawKey);
+            current.addons = listValue(parsed.value, []);
+            index = parsed.nextIndex;
+        }
+    }
+    return repos.map((repo) => {
+        const path = validateRepoPath(repo.path?.trim() || inferRepoPath(repo.url));
+        return {
+            url: repo.url,
+            path,
+            addons: validateAddons(repo.addons?.length ? repo.addons : [path]),
+        };
+    });
+}
+function booleanValue(values, key, fallback) {
+    const value = values[key];
+    if (value === undefined)
+        return fallback;
+    if (typeof value === 'boolean')
+        return value;
+    const normalized = value.toLowerCase().trim();
+    if (['true', '1', 'yes', 'y'].includes(normalized))
+        return true;
+    if (['false', '0', 'no', 'n'].includes(normalized))
+        return false;
+    throw new Error(`Invalid boolean value for --${key}: ${value}`);
+}
+function visibilityValue(values) {
+    const value = stringValue(values, 'repoVisibility') ?? 'private';
+    if (value === 'private' || value === 'public') {
+        return value;
+    }
+    throw new Error(`Invalid value for --repo-visibility: ${value}`);
+}
+function engineValue(values) {
+    const value = stringValue(values, 'engine') ?? 'compose';
+    if (value === 'compose') {
+        return value;
+    }
+    throw new Error(`Invalid value for --engine: ${value}`);
+}
+function assertNoRemovedDevelopmentPackFlags(argv) {
+    for (const arg of argv) {
+        const rawKey = arg.startsWith('--') ? arg.slice(2).split('=', 1)[0] : '';
+        if (rawKey === 'pack' || rawKey === 'no-packs') {
+            throw new Error('Optional development packs were removed. See the WPMoo Development Guidelines in README.md.');
+        }
+    }
+}
+export function defaultTargetForProduct(product, cwd = process.cwd()) {
+    const devRepo = `${product}_dev`;
+    return basename(cwd) === devRepo ? cwd : resolve(cwd, devRepo);
+}
+export function optionsFromArgs(argv) {
+    assertNoRemovedDevelopmentPackFlags(argv);
+    const { values } = parseArgs(argv);
+    const product = stringValue(values, 'product');
+    if (!product) {
+        return undefined;
+    }
+    const parsedSourceRepos = parseSourceRepos(argv);
+    const hasLegacySourceConfig = [
+        'org',
+        'communityRepo',
+        'communityRepoUrl',
+        'communityAddons',
+        'proRepo',
+        'proRepoUrl',
+        'proAddons',
+    ].some((key) => values[key] !== undefined);
+    if (parsedSourceRepos.length === 0 && !hasLegacySourceConfig) {
+        throw new Error('Missing --source-repo-url. Provide at least one source repository URL.');
+    }
+    const org = stringValue(values, 'org') ?? inferGitHubOwner(parsedSourceRepos[0]?.url ?? '') ?? 'example-org';
+    const odooVersion = stringValue(values, 'odooVersion') ?? supportedOdooVersions[0];
+    const engine = engineValue(values);
+    const installAgentSkillsTemplate = booleanValue(values, 'agentSkillsTemplate', values.agentSkillsTemplateUrl !== undefined);
+    const devRepoUrl = normalizeRepositoryUrl(stringValue(values, 'devRepoUrl') ?? `https://github.com/${org}/${product}_dev.git`);
+    const devRepo = stringValue(values, 'devRepo') ?? inferRepoPath(devRepoUrl);
+    const communityRepo = validateRepoPath(stringValue(values, 'communityRepo') ?? product);
+    const proRepo = validateRepoPath(stringValue(values, 'proRepo') ?? `${product}_pro`);
+    const targetValue = stringValue(values, 'target');
+    const target = targetValue ? resolve(targetValue) : defaultTargetForProduct(product);
+    const communityRepoUrl = normalizeRepositoryUrl(stringValue(values, 'communityRepoUrl') ?? `https://github.com/${org}/${communityRepo}.git`);
+    const proRepoUrl = normalizeRepositoryUrl(stringValue(values, 'proRepoUrl') ?? `https://github.com/${org}/${proRepo}.git`);
+    const communityAddons = validateAddons(listValue(stringValue(values, 'communityAddons'), defaultCommunityAddons(product)));
+    const proAddons = validateAddons(listValue(stringValue(values, 'proAddons'), defaultProAddons(product)));
+    const hasExplicitProRepo = values.proRepo !== undefined || values.proRepoUrl !== undefined || values.proAddons !== undefined;
+    const sourceRepos = parsedSourceRepos.length > 0
+        ? parsedSourceRepos
+        : [
+            {
+                url: communityRepoUrl,
+                path: communityRepo,
+                addons: communityAddons,
+            },
+            ...(hasExplicitProRepo
+                ? [
+                    {
+                        url: proRepoUrl,
+                        path: proRepo,
+                        addons: proAddons,
+                    },
+                ]
+                : []),
+        ].filter((repo) => repo.url && repo.path && repo.addons.length);
+    return {
+        product,
+        org,
+        odooVersion,
+        engine,
+        composeTemplateUrl: stringValue(values, 'composeTemplateUrl') ?? defaultComposeTemplateUrl,
+        composeTemplateRef: stringValue(values, 'composeTemplateRef'),
+        agentSkillsTemplateUrl: installAgentSkillsTemplate
+            ? stringValue(values, 'agentSkillsTemplateUrl') ?? defaultAgentSkillsTemplateUrl
+            : undefined,
+        agentSkillsTemplateRef: stringValue(values, 'agentSkillsTemplateRef'),
+        postgresVersion: stringValue(values, 'postgresVersion'),
+        httpPort: stringValue(values, 'httpPort'),
+        geventPort: stringValue(values, 'geventPort'),
+        devRepo,
+        devRepoUrl,
+        communityRepo,
+        proRepo,
+        communityRepoUrl,
+        proRepoUrl,
+        communityAddons,
+        proAddons,
+        sourceRepos,
+        target,
+        dryRun: booleanValue(values, 'dryRun', false),
+        initEmptyRepos: booleanValue(values, 'initEmptyRepos', false),
+        stage: booleanValue(values, 'stage', true),
+        createMissingRepos: booleanValue(values, 'createMissingRepos', false),
+        repoVisibility: visibilityValue(values),
+    };
+}
+export function isHelpRequested(argv) {
+    return argv.includes('--help') || argv.includes('-h');
+}
+export function isVersionRequested(argv) {
+    return argv.includes('--version') || argv.includes('-v');
+}