@wpmoo/odoo 0.8.34 → 0.8.36

package/README.md

@@ -171,6 +171,12 @@ npx @wpmoo/odoo remove-module \
   --module odoo_sample_module_base
 ```
 
+Check that a generated environment is structurally ready:
+
+```bash
+npx @wpmoo/odoo doctor
+```
+
 Refresh generated environment files without deleting module source code:
 
 ```bash
@@ -180,19 +186,35 @@ npx @wpmoo/odoo reset
 Run daily local development actions from a generated environment root:
 
 ```bash
+npx @wpmoo/odoo start
 npx @wpmoo/odoo logs odoo
 npx @wpmoo/odoo restart
+npx @wpmoo/odoo stop
 npx @wpmoo/odoo shell
 npx @wpmoo/odoo psql devel
 npx @wpmoo/odoo install sale devel
 npx @wpmoo/odoo update sale devel
 npx @wpmoo/odoo test sale --db devel --mode update --tags /sale
+npx @wpmoo/odoo resetdb devel sale
+npx @wpmoo/odoo snapshot devel before-update
+npx @wpmoo/odoo restore-snapshot before-update devel
+npx @wpmoo/odoo lint
+npx @wpmoo/odoo pot sale devel i18n/sale.pot
 ```
 
+The doctor command must be run from a generated environment root containing
+`.wpmoo/odoo.json`. It checks metadata, selected compose files, daily scripts,
+source repo paths, `.env` ports, and Docker CLI access.
+
 Daily actions require `.wpmoo/odoo.json` in the current directory and delegate to
 fixed scripts under `./scripts`; they do not search parent directories or accept
 arbitrary script names.
 
+Generated environments also include a local `./moo` shortcut for local compose
+daily commands such as `./moo start`, `./moo restart`, and `./moo stop`. The
+shortcut supports the same daily action arguments as `npx @wpmoo/odoo`. It also
+falls back to `npx @wpmoo/odoo@latest doctor` for `./moo doctor`.
+
 ## Defaults
 
 Each source repo can contain one or many Odoo modules. For example:

package/dist/args.js

@@ -12,6 +12,7 @@ const commandNames = new Set([
     'add-module',
     'remove-module',
     'reset',
+    'doctor',
     ...dailyActionCommands,
 ]);
 const internalFlags = new Set(['--no-update-check']);

package/dist/cli.js

@@ -6,6 +6,7 @@ import { detectDevelopmentEnvironment } from './environment.js';
 import { commandOdooVersion } from './environment-version.js';
 import { defaultAgentSkillsTemplateUrl } from './external-templates.js';
 import { isDailyActionCommand, runDailyAction } from './daily-actions.js';
+import { runDoctor } from './doctor.js';
 import { getOriginUrl, realGit } from './git.js';
 import { renderHelp } from './help.js';
 import { addModuleToSourceRepo, listModulesInSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
@@ -676,6 +677,14 @@ async function main() {
         outro(`Safe reset refreshed generated environment files in ${options.target}.`);
         return;
     }
+    if (route.command === 'doctor') {
+        if (route.argv.length > 0) {
+            throw new Error('Usage: wpmoo doctor');
+        }
+        console.log(renderBanner());
+        console.log(await runDoctor(process.cwd()));
+        return;
+    }
     if (isDailyActionCommand(route.command)) {
         console.log(renderBanner());
         await runDailyAction(route.command, route.argv);

package/dist/daily-actions.js

@@ -2,9 +2,26 @@ import { spawn } from 'node:child_process';
 import { access } from 'node:fs/promises';
 import { join } from 'node:path';
 import { markerPath } from './environment.js';
-export const dailyActionCommands = ['logs', 'restart', 'shell', 'psql', 'install', 'update', 'test'];
+export const dailyActionCommands = [
+    'start',
+    'stop',
+    'logs',
+    'restart',
+    'shell',
+    'psql',
+    'install',
+    'update',
+    'test',
+    'resetdb',
+    'snapshot',
+    'restore-snapshot',
+    'lint',
+    'pot',
+];
 const dailyActionCommandSet = new Set(dailyActionCommands);
-const scripts = {
+export const dailyActionScripts = {
+    start: 'up.sh',
+    stop: 'down.sh',
     logs: 'logs.sh',
     restart: 'restart.sh',
     shell: 'shell.sh',
@@ -12,11 +29,20 @@ const scripts = {
     install: 'install.sh',
     update: 'update.sh',
     test: 'test.sh',
+    resetdb: 'resetdb.sh',
+    snapshot: 'snapshot.sh',
+    'restore-snapshot': 'restore-snapshot.sh',
+    lint: 'lint.sh',
+    pot: 'pot.sh',
 };
 export function isDailyActionCommand(command) {
     return dailyActionCommandSet.has(command);
 }
 function usage(command) {
+    if (command === 'start')
+        return 'Usage: wpmoo start';
+    if (command === 'stop')
+        return 'Usage: wpmoo stop';
     if (command === 'logs')
         return 'Usage: wpmoo logs [service]';
     if (command === 'restart')
@@ -29,7 +55,17 @@ function usage(command) {
         return 'Usage: wpmoo install <module[,module]> [db]';
     if (command === 'update')
         return 'Usage: wpmoo update <module[,module]> [db]';
-    return 'Usage: wpmoo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]';
+    if (command === 'test')
+        return 'Usage: wpmoo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]';
+    if (command === 'resetdb')
+        return 'Usage: wpmoo resetdb [db] [module[,module]]';
+    if (command === 'snapshot')
+        return 'Usage: wpmoo snapshot [db] [snapshot-name]';
+    if (command === 'restore-snapshot')
+        return 'Usage: wpmoo restore-snapshot <snapshot-name> [db]';
+    if (command === 'lint')
+        return 'Usage: wpmoo lint';
+    return 'Usage: wpmoo pot <module[,module]> [db] [output]';
 }
 function ensureNoArgs(command, argv) {
     if (argv.length > 0)
@@ -47,6 +83,12 @@ function moduleArgs(command, argv) {
         throw new Error(usage(command));
     return db ? [modules, db] : [modules];
 }
+function positionalArgs(command, argv, min, max) {
+    if (argv.length < min || argv.length > max || argv.some((arg) => arg.startsWith('-'))) {
+        throw new Error(usage(command));
+    }
+    return argv;
+}
 function testArgs(argv) {
     const [modules, ...rest] = argv;
     if (!modules || modules.startsWith('-'))
@@ -66,6 +108,10 @@ function testArgs(argv) {
     return argv;
 }
 function scriptArgs(command, argv) {
+    if (command === 'start')
+        return ensureNoArgs(command, argv);
+    if (command === 'stop')
+        return ensureNoArgs(command, argv);
     if (command === 'logs')
         return optionalSingleArg(command, argv, 'odoo');
     if (command === 'restart')
@@ -76,7 +122,17 @@ function scriptArgs(command, argv) {
         return optionalSingleArg(command, argv, 'postgres');
     if (command === 'install' || command === 'update')
         return moduleArgs(command, argv);
-    return testArgs(argv);
+    if (command === 'test')
+        return testArgs(argv);
+    if (command === 'resetdb')
+        return positionalArgs(command, argv, 0, 2);
+    if (command === 'snapshot')
+        return positionalArgs(command, argv, 0, 2);
+    if (command === 'restore-snapshot')
+        return positionalArgs(command, argv, 1, 2);
+    if (command === 'lint')
+        return ensureNoArgs(command, argv);
+    return positionalArgs(command, argv, 1, 3);
 }
 async function assertEnvironmentRoot(cwd) {
     try {
@@ -98,7 +154,7 @@ async function assertScriptExists(cwd, script) {
 }
 export async function dailyActionPlan(command, argv, cwd = process.cwd()) {
     await assertEnvironmentRoot(cwd);
-    const scriptPath = await assertScriptExists(cwd, scripts[command]);
+    const scriptPath = await assertScriptExists(cwd, dailyActionScripts[command]);
     return {
         cwd,
         scriptPath,

package/dist/doctor.js

@@ -0,0 +1,168 @@
+import { access, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { execa } from 'execa';
+import { dailyActionScripts } from './daily-actions.js';
+import { defaultOdooVersion, markerPath } from './environment.js';
+const realCommandRunner = async (command, args, options) => {
+    const result = await execa(command, args, { cwd: options.cwd });
+    return { stdout: result.stdout, stderr: result.stderr };
+};
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function sourceReposFromMetadata(metadata) {
+    const sourceRepos = metadata.sourceRepos;
+    if (!Array.isArray(sourceRepos))
+        return [];
+    return sourceRepos.map((repo, index) => {
+        if (!isRecord(repo) || typeof repo.path !== 'string' || !repo.path.trim()) {
+            throw new Error(`Invalid sourceRepos entry in .wpmoo/odoo.json at index ${index}`);
+        }
+        return {
+            url: typeof repo.url === 'string' ? repo.url : '',
+            path: repo.path.trim(),
+            addons: Array.isArray(repo.addons) ? repo.addons.filter((addon) => typeof addon === 'string') : [],
+        };
+    });
+}
+async function readMetadata(target) {
+    let content;
+    try {
+        content = await readFile(join(target, markerPath), 'utf8');
+    }
+    catch {
+        throw new Error(`Missing metadata file: ${markerPath}`);
+    }
+    try {
+        const parsed = JSON.parse(content);
+        if (!isRecord(parsed)) {
+            throw new Error('metadata is not an object');
+        }
+        return parsed;
+    }
+    catch (error) {
+        throw new Error(`Invalid metadata JSON in ${markerPath}: ${errorMessage(error)}`);
+    }
+}
+function metadataString(metadata, key) {
+    const value = metadata[key];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function parseEnv(content) {
+    const values = new Map();
+    for (const rawLine of content.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#'))
+            continue;
+        const separator = line.indexOf('=');
+        if (separator === -1)
+            continue;
+        const key = line.slice(0, separator).trim();
+        let value = line.slice(separator + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        values.set(key, value);
+    }
+    return values;
+}
+async function readEnv(target) {
+    const path = join(target, '.env');
+    if (!(await exists(path)))
+        return undefined;
+    return parseEnv(await readFile(path, 'utf8'));
+}
+function validatePort(name, env, errors) {
+    const value = env.get(name)?.trim() ?? '';
+    if (!/^\d+$/.test(value)) {
+        errors.push(`Invalid ${name} in .env: expected a non-empty numeric value`);
+    }
+    return value;
+}
+function renderFailure(errors) {
+    return ['WPMoo doctor failed:', ...errors.map((error) => `- ${error}`)].join('\n');
+}
+export async function runDoctor(target = process.cwd(), runner = realCommandRunner) {
+    const lines = ['WPMoo doctor'];
+    const errors = [];
+    const metadata = await readMetadata(target);
+    lines.push(`OK metadata ${markerPath}`);
+    const engine = metadataString(metadata, 'engine') ?? 'compose';
+    if (engine !== 'compose') {
+        errors.push(`Unsupported environment engine: ${engine}`);
+    }
+    else {
+        lines.push('OK engine compose');
+    }
+    const odooVersion = metadataString(metadata, 'odooVersion') ?? defaultOdooVersion;
+    lines.push(`OK Odoo version ${odooVersion}`);
+    const env = await readEnv(target);
+    const composeVersions = new Set([odooVersion]);
+    const envOdooVersion = env?.get('ODOO_VERSION')?.trim();
+    if (envOdooVersion) {
+        composeVersions.add(envOdooVersion);
+    }
+    for (const version of composeVersions) {
+        const composeFile = `docker-compose_${version}.yml`;
+        if (await exists(join(target, composeFile))) {
+            lines.push(`OK compose ${composeFile}`);
+        }
+        else {
+            errors.push(`Missing compose file: ${composeFile}`);
+        }
+    }
+    const scriptNames = Object.values(dailyActionScripts);
+    const scriptErrorCount = errors.length;
+    for (const script of scriptNames) {
+        const relativePath = `scripts/${script}`;
+        if (!(await exists(join(target, relativePath)))) {
+            errors.push(`Missing daily action script: ${relativePath}`);
+        }
+    }
+    if (errors.length === scriptErrorCount) {
+        lines.push(`OK scripts ${scriptNames.length} checked`);
+    }
+    const sourceRepos = sourceReposFromMetadata(metadata);
+    for (const repo of sourceRepos) {
+        const relativePath = `odoo/custom/src/private/${repo.path}`;
+        if (!(await exists(join(target, relativePath)))) {
+            errors.push(`Missing source repo path: ${relativePath}`);
+        }
+    }
+    lines.push(`OK source repos ${sourceRepos.length} checked`);
+    if (env) {
+        const httpPort = validatePort('HTTP_PORT', env, errors);
+        const geventPort = validatePort('GEVENT_PORT', env, errors);
+        if (httpPort && geventPort && httpPort === geventPort) {
+            errors.push('HTTP_PORT and GEVENT_PORT in .env must not be equal');
+        }
+        if (/^\d+$/.test(httpPort) && /^\d+$/.test(geventPort) && httpPort !== geventPort) {
+            lines.push(`OK .env ports HTTP_PORT=${httpPort} GEVENT_PORT=${geventPort}`);
+        }
+    }
+    try {
+        await runner('docker', ['version'], { cwd: target });
+        lines.push('OK docker CLI');
+    }
+    catch (error) {
+        errors.push(`Docker CLI check failed: ${errorMessage(error)}`);
+    }
+    if (errors.length > 0) {
+        throw new Error(renderFailure(errors));
+    }
+    lines.push('Doctor checks passed.');
+    return lines.join('\n');
+}

package/dist/help.js

@@ -11,6 +11,9 @@ Usage:
   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
+  npx @wpmoo/odoo doctor
+  npx @wpmoo/odoo start
+  npx @wpmoo/odoo stop
   npx @wpmoo/odoo logs [service]
   npx @wpmoo/odoo restart
   npx @wpmoo/odoo shell
@@ -18,6 +21,11 @@ Usage:
   npx @wpmoo/odoo install <module[,module]> [db]
   npx @wpmoo/odoo update <module[,module]> [db]
   npx @wpmoo/odoo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]
+  npx @wpmoo/odoo resetdb [db] [module[,module]]
+  npx @wpmoo/odoo snapshot [db] [snapshot-name]
+  npx @wpmoo/odoo restore-snapshot <snapshot-name> [db]
+  npx @wpmoo/odoo lint
+  npx @wpmoo/odoo pot <module[,module]> [db] [output]
 
 Options:
   --product <slug>             Product slug, for example my_odoo_module.
@@ -55,6 +63,12 @@ Options:
 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/odoo with the same daily action arguments.
+
+Doctor:
+  Run npx @wpmoo/odoo doctor from a generated environment root to check metadata,
+  compose files, daily scripts, source repo paths, .env ports, and Docker CLI access.
 
 Example:
   npx @wpmoo/odoo create \\

package/dist/safe-reset.js

@@ -1,6 +1,8 @@
 import { chmod, mkdir, readFile, writeFile } from 'node:fs/promises';
 import { basename, join } from 'node:path';
 import { 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';
@@ -16,10 +18,12 @@ export function renderSafeResetPreview(target, stage) {
         '- .wpmoo/odoo.json',
         '- moo',
         '- .gitignore',
+        '- .env.example',
         '- README.md',
         '- AGENTS.md',
         '- docs/appstore-release.md',
-        '- Compose generated files',
+        '- External compose template assets',
+        '- External agent skill assets when configured',
         '',
         'Will not touch:',
         '- source repo folders under odoo/custom/src/private',
@@ -32,6 +36,17 @@ export function renderSafeResetPreview(target, stage) {
 function titleFromTarget(target) {
     return basename(target).replace(/_dev$/, '') || 'odoo_sample_module';
 }
+function safeResetExternalAssetOptions(options) {
+    return plannedExternalAssetOptions(options).map((assetOptions) => ({
+        ...assetOptions,
+        exclude: [
+            ...(assetOptions.exclude ?? []),
+            '.env',
+            '.gitmodules',
+            'odoo/custom/src/private',
+        ],
+    }));
+}
 function parseAddonsForRepo(addonsYaml, repoPath) {
     const safeRepoPath = validateRepoPath(repoPath);
     const lines = addonsYaml.split('\n');
@@ -112,6 +127,7 @@ async function inferOptions(target) {
 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 === 'odoo/custom/src/addons.yaml') {
             continue;
@@ -123,6 +139,10 @@ export async function safeResetEnvironment(options, git = realGit) {
             await chmod(destination, file.mode);
         }
     }
+    for (const assetOptions of externalAssets) {
+        await applyExternalAsset(assetOptions, git);
+    }
+    await writeTextFile(join(options.target, '.env.example'), renderComposeEnvExample(scaffoldOptions));
     if (options.stage) {
         await stageAll(git, options.target);
     }

package/dist/templates.js

@@ -22,6 +22,7 @@ function repositoryLayout(options) {
 ├── docker-compose_17.0.yml
 ├── docker-compose_18.0.yml
 ├── docker-compose_19.0.yml
+├── moo
 ├── scripts/
 ├── etc/
 ├── odoo/
@@ -100,7 +101,7 @@ function repoDuplicationNote() {
 }
 function verificationCommand(options) {
     const firstAddon = allAddons(options)[0] ?? options.product;
-    return `./scripts/test.sh ${firstAddon}`;
+    return `./moo test ${firstAddon}`;
 }
 function environmentUsageDocs(options) {
     return `## Docker Compose Notes
@@ -125,16 +126,22 @@ Source repositories stay under \`odoo/custom/src/private\`. At container startup
 
 \`\`\`bash
 cp .env.example .env
-./scripts/up.sh
-./scripts/logs.sh
-./scripts/shell.sh
-./scripts/down.sh
+./moo start
+./moo logs
+./moo shell
+./moo stop
+./moo doctor
+./moo resetdb devel sale
+./moo snapshot devel before-update
+./moo restore-snapshot before-update devel
+./moo lint
+./moo pot sale devel i18n/sale.pot
 \`\`\`
 
 Run tests for one planned product addon:
 
 \`\`\`bash
-./scripts/test.sh ${allAddons(options)[0] ?? options.product}
+./moo test ${allAddons(options)[0] ?? options.product}
 \`\`\`
 `;
 }
@@ -226,7 +233,191 @@ set -euo pipefail
 script_dir="$(cd -- "$(dirname -- "\${BASH_SOURCE[0]}")" && pwd)"
 cd "$script_dir"
 
-exec npx --yes @wpmoo/odoo@latest "$@"
+usage() {
+  case "$1" in
+    "start") echo "Usage: ./moo start" ;;
+    "stop") echo "Usage: ./moo stop" ;;
+    "logs") echo "Usage: ./moo logs [service]" ;;
+    "restart") echo "Usage: ./moo restart" ;;
+    "shell") echo "Usage: ./moo shell" ;;
+    "psql") echo "Usage: ./moo psql [db]" ;;
+    "install") echo "Usage: ./moo install <module[,module]> [db]" ;;
+    "update") echo "Usage: ./moo update <module[,module]> [db]" ;;
+    "test") echo "Usage: ./moo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]" ;;
+    "resetdb") echo "Usage: ./moo resetdb [db] [module[,module]]" ;;
+    "snapshot") echo "Usage: ./moo snapshot [db] [snapshot-name]" ;;
+    "restore-snapshot") echo "Usage: ./moo restore-snapshot <snapshot-name> [db]" ;;
+    "lint") echo "Usage: ./moo lint" ;;
+    "pot") echo "Usage: ./moo pot <module[,module]> [db] [output]" ;;
+  esac
+}
+
+fail_usage() {
+  usage "$1" >&2
+  exit 2
+}
+
+require_no_args() {
+  local command="$1"
+  shift
+  if [[ "$#" -ne 0 ]]; then
+    fail_usage "$command"
+  fi
+}
+
+optional_single_arg() {
+  local command="$1"
+  local fallback="$2"
+  shift 2
+  if [[ "$#" -gt 1 ]]; then
+    fail_usage "$command"
+  fi
+  printf '%s\\n' "\${1:-$fallback}"
+}
+
+require_module_args() {
+  local command="$1"
+  shift
+  if [[ "$#" -lt 1 || "\${1:-}" == -* || "$#" -gt 2 ]]; then
+    fail_usage "$command"
+  fi
+}
+
+positional_args() {
+  local command="$1"
+  local min="$2"
+  local max="$3"
+  shift 3
+  if [[ "$#" -lt "$min" || "$#" -gt "$max" ]]; then
+    fail_usage "$command"
+  fi
+  for arg in "$@"; do
+    if [[ "$arg" == -* ]]; then
+      fail_usage "$command"
+    fi
+  done
+}
+
+validate_test_args() {
+  if [[ "$#" -lt 1 || "\${1:-}" == -* ]]; then
+    fail_usage "test"
+  fi
+
+  shift
+  while [[ "$#" -gt 0 ]]; do
+    case "$1" in
+      "--db"|"--tags")
+        if [[ "$#" -lt 2 || "\${2:-}" == --* ]]; then
+          echo "Missing value for $1" >&2
+          exit 2
+        fi
+        shift 2
+        ;;
+      "--mode")
+        if [[ "$#" -lt 2 || "\${2:-}" == --* ]]; then
+          echo "Missing value for --mode" >&2
+          exit 2
+        fi
+        if [[ "$2" != "init" && "$2" != "update" ]]; then
+          echo "Invalid value for --mode: expected init or update" >&2
+          exit 2
+        fi
+        shift 2
+        ;;
+      *)
+        echo "Unknown option for ./moo test: $1" >&2
+        exit 2
+        ;;
+    esac
+  done
+}
+
+run_script() {
+  local script="$1"
+  shift
+  if [[ ! -x "$script" ]]; then
+    echo "Missing daily action script: \${script#./}" >&2
+    exit 1
+  fi
+  exec "$script" "$@"
+}
+
+command="\${1:-}"
+case "$command" in
+  "start")
+    shift
+    require_no_args "$command" "$@"
+    run_script ./scripts/up.sh
+    ;;
+  "stop")
+    shift
+    require_no_args "$command" "$@"
+    run_script ./scripts/down.sh
+    ;;
+  "logs")
+    shift
+    service="$(optional_single_arg "$command" "odoo" "$@")"
+    run_script ./scripts/logs.sh "$service"
+    ;;
+  "restart")
+    shift
+    require_no_args "$command" "$@"
+    run_script ./scripts/restart.sh
+    ;;
+  "shell")
+    shift
+    require_no_args "$command" "$@"
+    run_script ./scripts/shell.sh
+    ;;
+  "psql")
+    shift
+    db="$(optional_single_arg "$command" "postgres" "$@")"
+    run_script ./scripts/psql.sh "$db"
+    ;;
+  "install")
+    shift
+    require_module_args "$command" "$@"
+    run_script ./scripts/install.sh "$@"
+    ;;
+  "update")
+    shift
+    require_module_args "$command" "$@"
+    run_script ./scripts/update.sh "$@"
+    ;;
+  "test")
+    shift
+    validate_test_args "$@"
+    run_script ./scripts/test.sh "$@"
+    ;;
+  "resetdb")
+    shift
+    positional_args "$command" 0 2 "$@"
+    run_script ./scripts/resetdb.sh "$@"
+    ;;
+  "snapshot")
+    shift
+    positional_args "$command" 0 2 "$@"
+    run_script ./scripts/snapshot.sh "$@"
+    ;;
+  "restore-snapshot")
+    shift
+    positional_args "$command" 1 2 "$@"
+    run_script ./scripts/restore-snapshot.sh "$@"
+    ;;
+  "lint")
+    shift
+    require_no_args "$command" "$@"
+    run_script ./scripts/lint.sh
+    ;;
+  "pot")
+    shift
+    positional_args "$command" 1 3 "$@"
+    run_script ./scripts/pot.sh "$@"
+    ;;
+  *)
+    exec npx --yes @wpmoo/odoo@latest "$@"
+    ;;
+esac
 `;
 }
 export function renderAddonsYaml(options) {
@@ -291,16 +482,20 @@ git submodule update --init --recursive
 
 ## WPMoo CLI Shortcut
 
-This environment includes a local \`moo\` delegation script. From the repository
+This environment includes a local \`moo\` shortcut script. From the repository
 root:
 
 \`\`\`bash
 ./moo
+./moo start
+./moo stop
+./moo restart
+./moo doctor
 ./moo add-module
 \`\`\`
 
-If this repository root is on your \`PATH\`, you can run \`moo ...\` from
-anywhere and the script will delegate back to this environment.
+Optionally, if this repository root is on your \`PATH\`, you can run \`moo ...\`
+from anywhere and the script will return to this environment root first.
 ${optionalAgentSkillsReadme(options)}
 ## Source Repositories
 
@@ -371,7 +566,17 @@ Use the environment's addon test/update command:
 ${verificationCommand(options)}
 \`\`\`
 
-Only report completion after the relevant update/test command exits cleanly.
+Useful maintenance commands:
+
+\`\`\`bash
+./moo lint
+./moo resetdb [db] [module[,module]]
+./moo snapshot [db] [snapshot-name]
+./moo restore-snapshot <snapshot-name> [db]
+./moo pot <module[,module]> [db] [output]
+\`\`\`
+
+Only report completion after the relevant update/test/lint command exits cleanly.
 `;
 }
 export function renderAppstoreRelease(options) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpmoo/odoo",
-  "version": "0.8.34",
+  "version": "0.8.36",
   "description": "WPMoo Odoo lifecycle tooling for development, staging, and production workflows.",
   "type": "module",
   "repository": {