@wpmoo/odoo 0.8.63 → 0.8.65

package/README.md

@@ -138,12 +138,15 @@ npx @wpmoo/odoo --help
 npx @wpmoo/odoo --version
 
 npx @wpmoo/odoo status
+npx @wpmoo/odoo status --json
 npx @wpmoo/odoo doctor
+npx @wpmoo/odoo doctor --json
 npx @wpmoo/odoo doctor --fix
+npx @wpmoo/odoo source list --json
 npx @wpmoo/odoo add-repo --repo-url https://github.com/example-org/odoo_sample_module_reports.git
 npx @wpmoo/odoo remove-repo --repo odoo_sample_module_reports
-npx @wpmoo/odoo add-module --repo odoo_sample_module --module odoo_sample_module_base
-npx @wpmoo/odoo remove-module --repo odoo_sample_module --module odoo_sample_module_base
+npx @wpmoo/odoo add-module --repo odoo_sample_module --module odoo_sample_module_base --source-type private
+npx @wpmoo/odoo remove-module --repo odoo_sample_module --module odoo_sample_module_base --source-type private
 npx @wpmoo/odoo reset --dry-run
 npx @wpmoo/odoo reset
 
@@ -275,10 +278,13 @@ GitHub CLI is optional for repository setup. When it is available and authentica
 
 Add a minimal Odoo module skeleton to a source repository:
 
+For module actions, `--source-type` selects the source directory (`private`, `oca`, or `external`). Default is `private`.
+
 ```bash
 npx @wpmoo/odoo add-module \
   --repo odoo_sample_module \
-  --module odoo_sample_module_base
+  --module odoo_sample_module_base \
+  --source-type oca
 ```
 
 Remove a module registration while keeping files:
@@ -286,7 +292,8 @@ Remove a module registration while keeping files:
 ```bash
 npx @wpmoo/odoo remove-module \
   --repo odoo_sample_module \
-  --module odoo_sample_module_base
+  --module odoo_sample_module_base \
+  --source-type oca
 ```
 
 Delete module files as well:
@@ -315,12 +322,14 @@ Inspect configured sources:
 
 ```bash
 npx @wpmoo/odoo source list
+npx @wpmoo/odoo source list --json
 ```
 
 Regenerate the manifest and metadata from the current metadata/gitmodule state:
 
 ```bash
 npx @wpmoo/odoo source sync
+npx @wpmoo/odoo source sync --json
 ```
 
 `source add` and `source remove` are direct aliases for the same repository
@@ -340,10 +349,23 @@ npx @wpmoo/odoo source remove --repo server-tools --source-type oca
 
 ```bash
 npx @wpmoo/odoo status
+npx @wpmoo/odoo status --json
 ```
 
 It reports whether the environment is detected, which Odoo version is selected, how many source repos are configured, how many module candidates are present, which core files are missing, and the recommended next action.
 
+For automation and VS Code cockpit integration, all of these commands also support
+`--json`:
+
+```bash
+npx @wpmoo/odoo status --json
+npx @wpmoo/odoo source list --json
+npx @wpmoo/odoo source sync --json
+npx @wpmoo/odoo doctor --json
+```
+
+JSON output is optional; human-readable output remains the default.
+
 `doctor` performs deeper checks:
 
 ```bash

package/dist/cli.js

@@ -12,7 +12,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 { getDoctorReport, runDoctor } from './doctor.js';
 import { getOriginUrl, realGit } from './git.js';
 import { renderHelp } from './help.js';
 import { addModuleToSourceRepo, listModulesInSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
@@ -22,13 +22,13 @@ import { promptRepositoryUrl } from './prompt-repositories.js';
 import { inferGitHubOwner, inferRepoPath, normalizeRepositoryUrl } from './repo-url.js';
 import { addModuleRepo, listModuleRepos, removeModuleRepo } from './repo-actions.js';
 import { renderSafeResetPreview, safeResetEnvironment } from './safe-reset.js';
-import { listSources, renderSourceList, syncSources } from './source-actions.js';
+import { listSources, renderSourceList, sourceListJson, sourceSyncJson, syncSources, } from './source-actions.js';
 import { checkGitHubRepositories, createGitHubRepositories, manualCreateCommands, repositoryPreflightAvailable, } from './repository-preflight.js';
 import { scaffold } from './scaffold.js';
 import { renderBanner } from './templates.js';
 import { checkForUpdate, installLatestPackage, isUpdateCheckSkipped, restartCli } from './update-check.js';
 import { packageName, packageVersion, renderVersion, renderVersionTag } from './version.js';
-import { getEnvironmentStatus, renderEnvironmentStatusForTarget, renderEnvironmentStatusSummary, } from './status.js';
+import { environmentStatusJson, getEnvironmentStatus, renderEnvironmentStatusForTarget, renderEnvironmentStatusSummary, } from './status.js';
 import { getGitHubAccounts, getGitHubRepositoryStatus, githubRepositoryUrl, realGitHub, createGitHubRepository, } from './github.js';
 import { environmentGitHubOwner } from './environment-context.js';
 import { handlePromptCancel, handleUnavailableMenuChoice, installPromptCancelKeyTracker, isMenuBackSignal, MenuBackSignal, menuIntroTitle, menuPromptMessage, } from './menu-navigation.js';
@@ -106,6 +106,12 @@ function booleanOption(values, key, fallback) {
         return false;
     throw new Error(`Invalid boolean value for --${key}: ${value}`);
 }
+function jsonOption(values) {
+    return booleanOption(values, 'json', false);
+}
+function printJson(value) {
+    console.log(JSON.stringify(value));
+}
 function yellow(value) {
     if (!process.stdout.isTTY || process.env.NO_COLOR !== undefined)
         return value;
@@ -399,21 +405,39 @@ async function ensureAddRepoGitHubRepository(options, cancelAction = 'exit') {
     await createGitHubRepository(realGitHub, options.repoUrl, visibility);
 }
 async function selectSourceRepo(target, cancelAction = 'exit') {
-    const repos = await listModuleRepos(target);
-    if (repos.length === 0) {
+    const repos = await listSources(target);
+    const repoOptions = repos.length > 0
+        ? repos.map((repo) => ({
+            value: { repoPath: repo.path, sourceType: repo.type },
+            label: `${repo.type}/${repo.path}`,
+        }))
+        : (await listModuleRepos(target)).map((repoPath) => ({
+            value: { repoPath, sourceType: 'private' },
+            label: `private/${repoPath}`,
+        }));
+    if (repoOptions.length === 0) {
         if (cancelAction === 'back') {
-            note(`No source repos found under ${target}/odoo/custom/src/private.\nNext: choose "Add source repo" first.`, 'Nothing to select');
+            note(`No source repos found under ${target}/odoo/custom/src.\nNext: choose "Add source repo" first.`, 'Nothing to select');
             handleUnavailableMenuChoice(cancelAction);
         }
-        throw new Error(`No source repos found under ${target}/odoo/custom/src/private`);
+        throw new Error(`No source repos found under ${target}/odoo/custom/src`);
     }
-    const repoPath = await select({
+    const selected = await select({
         message: menuPromptMessage('Source repo', cancelAction),
-        options: repos.map((repo) => ({ value: repo, label: repo })),
-        initialValue: repos[0],
+        options: repoOptions,
+        initialValue: repoOptions[0].value,
     });
-    handleCancel(repoPath, cancelAction);
-    return String(repoPath);
+    handleCancel(selected, cancelAction);
+    if (typeof selected === 'string') {
+        return { repoPath: selected, sourceType: 'private' };
+    }
+    if (typeof selected === 'object' && selected !== null && 'repoPath' in selected && 'sourceType' in selected) {
+        return { repoPath: selected.repoPath, sourceType: selected.sourceType };
+    }
+    return { repoPath: String(selected), sourceType: 'private' };
+}
+function formatSourceRepoPromptPath(target, selected) {
+    return renderedSourceRepoPath(target, selected.sourceType, selected.repoPath);
 }
 function suggestedModuleName(repoPath) {
     return 'odoo_sample_module';
@@ -430,6 +454,7 @@ async function addModuleOptionsFromArgs(argv) {
         target,
         repoPath,
         moduleName,
+        sourceType: optionalSourceTypeValue(values),
         odooVersion: await commandOdooVersion(target, stringOption(values, 'odooVersion')),
         stage: booleanOption(values, 'stage', true),
     };
@@ -437,15 +462,16 @@ async function addModuleOptionsFromArgs(argv) {
 async function addModuleOptionsFromPrompts(showIntro = true, cancelAction = 'exit') {
     showSubmenuIntro('Add module to source repo', showIntro, cancelAction);
     const target = process.cwd();
-    const repoPath = await selectSourceRepo(target, cancelAction);
+    const sourceRepo = await selectSourceRepo(target, cancelAction);
     const moduleName = asString(await text({
         message: menuPromptMessage('Module name', cancelAction),
-        placeholder: suggestedModuleName(repoPath),
+        placeholder: suggestedModuleName(sourceRepo.repoPath),
         validate: (value) => (value.trim() ? undefined : 'Enter the module technical name.'),
-    }), suggestedModuleName(repoPath), cancelAction);
+    }), suggestedModuleName(sourceRepo.repoPath), cancelAction);
     return {
         target,
-        repoPath,
+        repoPath: sourceRepo.repoPath,
+        sourceType: sourceRepo.sourceType,
         moduleName,
         odooVersion: await commandOdooVersion(target),
         stage: true,
@@ -473,17 +499,19 @@ function resetCommandOptionsFromArgs(argv) {
     };
 }
 function doctorOptionsFromArgs(argv) {
-    if (argv.length === 0) {
-        return {};
-    }
     const { values } = parseArgs(argv);
     const keys = Object.keys(values);
-    if (keys.length !== 1 || !Object.hasOwn(values, 'fix')) {
+    const allowedKeys = new Set(['fix', 'json']);
+    if (!keys.every((key) => allowedKeys.has(key))) {
         throw new Error('Usage: wpmoo doctor');
     }
-    return {
-        fix: booleanOption(values, 'fix', false),
+    const options = {
+        json: jsonOption(values),
     };
+    if (Object.hasOwn(values, 'fix')) {
+        options.fix = booleanOption(values, 'fix', false);
+    }
+    return options;
 }
 function sourceUsage() {
     return 'Usage: wpmoo source <list|sync|add|remove> [options]';
@@ -493,11 +521,15 @@ function sourceSyncOptionsFromArgs(argv) {
     return {
         target: resolve(stringOption(values, 'target') ?? process.cwd()),
         stage: booleanOption(values, 'stage', true),
+        json: jsonOption(values),
     };
 }
-function sourceListTargetFromArgs(argv) {
+function sourceListOptionsFromArgs(argv) {
     const { values } = parseArgs(argv);
-    return resolve(stringOption(values, 'target') ?? process.cwd());
+    return {
+        target: resolve(stringOption(values, 'target') ?? process.cwd()),
+        json: jsonOption(values),
+    };
 }
 async function runSourceCommand(argv) {
     const [subcommand, ...subcommandArgv] = argv;
@@ -505,15 +537,24 @@ async function runSourceCommand(argv) {
         throw new Error(sourceUsage());
     }
     if (subcommand === 'list') {
+        const options = sourceListOptionsFromArgs(subcommandArgv);
+        const sources = await listSources(options.target);
+        if (options.json) {
+            printJson(sourceListJson(sources));
+            return;
+        }
         console.log(renderBanner());
-        const target = sourceListTargetFromArgs(subcommandArgv);
-        console.log(renderSourceList(await listSources(target)));
+        console.log(renderSourceList(sources));
         return;
     }
     if (subcommand === 'sync') {
-        console.log(renderBanner());
         const options = sourceSyncOptionsFromArgs(subcommandArgv);
-        await syncSources(options);
+        const sources = await syncSources({ target: options.target, stage: options.stage });
+        if (options.json) {
+            printJson(sourceSyncJson(sources, options.target));
+            return;
+        }
+        console.log(renderBanner());
         outro(`Synced source manifest in ${options.target}.`);
         return;
     }
@@ -587,6 +628,7 @@ function removeModuleOptionsFromArgs(argv) {
         target: resolve(stringOption(values, 'target') ?? process.cwd()),
         repoPath,
         moduleName,
+        sourceType: optionalSourceTypeValue(values),
         deleteFiles: booleanOption(values, 'deleteFiles', false),
         stage: booleanOption(values, 'stage', true),
     };
@@ -594,14 +636,14 @@ function removeModuleOptionsFromArgs(argv) {
 async function removeModuleOptionsFromPrompts(showIntro = true, cancelAction = 'exit') {
     showSubmenuIntro('Remove module from source repo', showIntro, cancelAction);
     const target = process.cwd();
-    const repoPath = await selectSourceRepo(target, cancelAction);
-    const modules = await listModulesInSourceRepo(target, repoPath);
+    const sourceRepo = await selectSourceRepo(target, cancelAction);
+    const modules = await listModulesInSourceRepo(target, sourceRepo.repoPath, sourceRepo.sourceType);
     if (modules.length === 0) {
         if (cancelAction === 'back') {
-            note(`No Odoo modules found under ${target}/odoo/custom/src/private/${repoPath}.\nNext: choose "Add module to source repo" first.`, 'Nothing to remove');
+            note(`No Odoo modules found under ${formatSourceRepoPromptPath(target, sourceRepo)}.\nNext: choose "Add module to source repo" first.`, 'Nothing to remove');
             handleUnavailableMenuChoice(cancelAction);
         }
-        throw new Error(`No Odoo modules found under ${target}/odoo/custom/src/private/${repoPath}`);
+        throw new Error(`No Odoo modules found under ${formatSourceRepoPromptPath(target, sourceRepo)}`);
     }
     const moduleName = await select({
         message: menuPromptMessage('Module to remove', cancelAction),
@@ -618,7 +660,8 @@ async function removeModuleOptionsFromPrompts(showIntro = true, cancelAction = '
     handleCancel(deleteFiles, cancelAction);
     return {
         target,
-        repoPath,
+        repoPath: sourceRepo.repoPath,
+        sourceType: sourceRepo.sourceType,
         moduleName: String(moduleName),
         deleteFiles: Boolean(deleteFiles),
         stage: true,
@@ -885,14 +928,28 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
     }
     if (route.command === 'doctor') {
         const options = doctorOptionsFromArgs(route.argv);
+        const doctorOptions = {};
+        if (options.fix !== undefined) {
+            doctorOptions.fix = options.fix;
+        }
+        if (options.json) {
+            printJson(await getDoctorReport(cwd, doctorOptions));
+            return;
+        }
         console.log(renderBanner());
-        console.log(options.fix === undefined ? await runDoctor(cwd) : await runDoctor(cwd, options));
+        console.log(options.fix === undefined ? await runDoctor(cwd) : await runDoctor(cwd, doctorOptions));
         return;
     }
     if (route.command === 'status') {
-        if (route.argv.length > 0) {
+        const { values } = parseArgs(route.argv);
+        const keys = Object.keys(values);
+        if (!keys.every((key) => key === 'json')) {
             throw new Error('Usage: wpmoo status');
         }
+        if (jsonOption(values)) {
+            printJson(environmentStatusJson(await getEnvironmentStatus(cwd)));
+            return;
+        }
         console.log(renderBanner());
         console.log(await renderEnvironmentStatusForTarget(cwd));
         return;

package/dist/cockpit/daily-prompts.js

@@ -1,6 +1,7 @@
 import { isCancel, select, text } from '@clack/prompts';
 import { listModulesInSourceRepo } from '../module-actions.js';
 import { listModuleRepos } from '../repo-actions.js';
+import { listSources } from '../source-actions.js';
 import { handlePromptCancel, menuPromptMessage, } from '../menu-navigation.js';
 const manualModuleValue = '__wpmoo_manual_module_entry__';
 function defaultCancelHandler(value, action) {
@@ -27,10 +28,13 @@ function requiredString(value, message, deps) {
 }
 async function detectedModules(cwd) {
     try {
-        const repos = await listModuleRepos(cwd);
+        const sources = await listSources(cwd);
+        const repos = sources.length > 0
+            ? sources.map((source) => ({ path: source.path, sourceType: source.type }))
+            : (await listModuleRepos(cwd)).map((path) => ({ path, sourceType: 'private' }));
         const modules = await Promise.all(repos.map(async (repo) => {
             try {
-                return await listModulesInSourceRepo(cwd, repo);
+                return await listModulesInSourceRepo(cwd, repo.path, repo.sourceType);
             }
             catch {
                 return [];

package/dist/doctor.js

@@ -40,6 +40,11 @@ function isRecord(value) {
 function isDoctorOptions(value) {
     return isRecord(value);
 }
+function isMetadataError(message) {
+    return (message.startsWith('Missing metadata file:') ||
+        message.startsWith('Invalid metadata JSON in .wpmoo/odoo.json') ||
+        message.startsWith('Invalid sourceRepos entry in .wpmoo/odoo.json'));
+}
 const incompatiblePostgres18MountTargets = ['/var/lib/postgresql/data', '/var/lib/postgresql/18/docker'];
 function parsePostgresMajorFromValue(value) {
     if (!value)
@@ -280,24 +285,41 @@ async function repairSourceManifestFromDiscoveredState(target, sourceRepos, fall
     await writeSourceManifest(target, entries);
     await replaceSourceRepos(target, sourceReposFromManifest(entries));
 }
-export async function runDoctor(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
+export async function getDoctorReport(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
     const actualRunner = isDoctorOptions(runnerOrOptions) ? realCommandRunner : runnerOrOptions;
     const actualOptions = isDoctorOptions(runnerOrOptions) ? runnerOrOptions : options;
-    const appliedFixes = [];
-    const lines = ['WPMoo doctor'];
     const errors = [];
     const warnings = [];
-    const metadata = await readMetadata(target);
-    lines.push(`OK metadata ${markerPath}`);
+    const checks = [];
+    const appliedFixes = [];
+    const report = {
+        schemaVersion: 1,
+        command: 'doctor',
+        ok: false,
+        target,
+        checks,
+        warnings,
+        errors,
+        appliedFixes,
+    };
+    let metadata;
+    try {
+        metadata = await readMetadata(target);
+    }
+    catch (error) {
+        errors.push(errorMessage(error));
+        return report;
+    }
+    checks.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');
+        checks.push('OK engine compose');
     }
     const odooVersion = metadataString(metadata, 'odooVersion') ?? defaultOdooVersion;
-    lines.push(`OK Odoo version ${odooVersion}`);
+    checks.push(`OK Odoo version ${odooVersion}`);
     const env = await readEnvFile(target);
     const composeVersions = new Set([odooVersion]);
     const envOdooVersion = env?.get('ODOO_VERSION')?.trim();
@@ -312,7 +334,7 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
         errors.push(...composeLayout.errors);
     }
     else {
-        lines.push(`OK compose files ${composeLayout.files.join(', ')}`);
+        checks.push(`OK compose files ${composeLayout.files.join(', ')}`);
         const postgresVersion = inferPostgresVersion(metadata, odooVersion, env);
         if (postgresVersion === '18') {
             for (const file of composeLayout.files) {
@@ -351,16 +373,23 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
         }
     }
     if (errors.length === scriptErrorCount) {
-        lines.push(`OK scripts ${scriptNames.length} checked`);
+        checks.push(`OK scripts ${scriptNames.length} checked`);
+    }
+    let sourceRepos;
+    try {
+        sourceRepos = sourceReposFromMetadata(metadata);
+    }
+    catch (error) {
+        errors.push(errorMessage(error));
+        return report;
     }
-    const sourceRepos = sourceReposFromMetadata(metadata);
     for (const repo of sourceRepos) {
         const relativePath = sourceRepoPath(normalizeSourceType(repo.sourceType), repo.path);
         if (!(await exists(join(target, relativePath))) && repo.path) {
             errors.push(`Missing source repo path: ${relativePath}`);
         }
     }
-    lines.push(`OK source repos ${sourceRepos.length} checked`);
+    checks.push(`OK source repos ${sourceRepos.length} checked`);
     const manifestPath = join(target, sourceManifestPath);
     const hasManifest = await exists(manifestPath);
     let manifestEntries = [];
@@ -409,19 +438,19 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
             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}`);
+            checks.push(`OK .env ports HTTP_PORT=${httpPort} GEVENT_PORT=${geventPort}`);
         }
     }
     try {
         await actualRunner('docker', ['version'], { cwd: target });
-        lines.push('OK docker CLI');
+        checks.push('OK docker CLI');
     }
     catch (error) {
         errors.push(`Docker CLI check failed: ${errorMessage(error)}`);
     }
     try {
         await actualRunner('docker', ['compose', 'version'], { cwd: target });
-        lines.push('OK docker compose');
+        checks.push('OK docker compose');
     }
     catch (error) {
         errors.push(`Docker Compose check failed: ${errorMessage(error)}`);
@@ -432,12 +461,12 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
             const submoduleErrors = sourceSubmoduleStatusErrors(result.stdout, sourceRepos);
             errors.push(...submoduleErrors);
             if (submoduleErrors.length === 0) {
-                lines.push(`OK git submodules ${sourceRepos.length} checked`);
+                checks.push(`OK git submodules ${sourceRepos.length} checked`);
             }
         }
         catch (error) {
             if (isNotGitCheckoutError(error)) {
-                lines.push('OK git submodules skipped (not a git checkout)');
+                checks.push('OK git submodules skipped (not a git checkout)');
             }
             else {
                 errors.push(`Git submodule status check failed: ${errorMessage(error)}`);
@@ -446,32 +475,45 @@ export async function runDoctor(target = process.cwd(), runnerOrOptions = realCo
     }
     try {
         await actualRunner('gh', ['auth', 'status'], { cwd: target });
-        lines.push('OK GitHub CLI auth');
+        checks.push('OK GitHub CLI auth');
     }
     catch (error) {
-        warnings.push(`WARN GitHub CLI auth: ${errorMessage(error)}`);
+        warnings.push(`GitHub CLI auth: ${errorMessage(error)}`);
     }
-    if (errors.length > 0) {
-        if (actualOptions.fix && appliedFixes.length > 0) {
+    report.ok = errors.length === 0;
+    return report;
+}
+export async function runDoctor(target = process.cwd(), runnerOrOptions = realCommandRunner, options = {}) {
+    const report = await getDoctorReport(target, runnerOrOptions, options);
+    const actualRunner = isDoctorOptions(runnerOrOptions) ? realCommandRunner : runnerOrOptions;
+    const actualOptions = isDoctorOptions(runnerOrOptions) ? runnerOrOptions : options;
+    if (!report.ok) {
+        if (report.errors.some(isMetadataError)) {
+            throw new Error(report.errors[0]);
+        }
+        if (actualOptions.fix && report.appliedFixes.length > 0) {
             return [
                 'Doctor auto-fixes were not enough to satisfy all checks.',
-                ...appliedFixes.map((fix) => `- ${fix}`),
-                renderFailure(errors),
+                ...report.appliedFixes.map((fix) => `- ${fix}`),
+                renderFailure(report.errors),
             ].join('\n');
         }
-        throw new Error(renderFailure(errors));
+        throw new Error(renderFailure(report.errors));
     }
-    lines.push(...warnings);
-    lines.push('Doctor checks passed.');
-    const report = lines.join('\n');
-    if (actualOptions.fix && appliedFixes.length > 0) {
+    const renderedReport = [
+        'WPMoo doctor',
+        ...report.checks,
+        ...report.warnings.map((warning) => `WARN ${warning}`),
+        'Doctor checks passed.',
+    ];
+    if (report.appliedFixes.length > 0) {
         const postFixReport = await runDoctor(target, actualRunner, { ...actualOptions, fix: false });
         return [
             'Applied safe doctor fixes:',
-            ...appliedFixes.map((fix) => `- ${fix}`),
+            ...report.appliedFixes.map((fix) => `- ${fix}`),
             '',
             postFixReport,
         ].join('\n');
     }
-    return report;
+    return renderedReport.join('\n');
 }

package/dist/help.js

@@ -7,16 +7,20 @@ Usage:
   npx @wpmoo/odoo
   npx @wpmoo/odoo create --product <slug> [--target <path>] --dev-repo-url <url> --source-repo-url <url>
   npx @wpmoo/odoo status
+  npx @wpmoo/odoo status --json
   npx @wpmoo/odoo add-repo --repo-url <url> [--source-type private|oca|external]
   npx @wpmoo/odoo remove-repo --repo <name>
   npx @wpmoo/odoo source list
+  npx @wpmoo/odoo source list --json
   npx @wpmoo/odoo source sync
+  npx @wpmoo/odoo source sync --json
   npx @wpmoo/odoo source add --repo-url <url> [--source-type private|oca|external]
   npx @wpmoo/odoo source remove --repo <name> [--source-type private|oca|external]
-  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 add-module --repo <source-repo> --module <module-name> [--source-type <category>]
+  npx @wpmoo/odoo remove-module --repo <source-repo> --module <module-name> [--source-type <category>]
   npx @wpmoo/odoo reset [--dry-run]
   npx @wpmoo/odoo doctor [--fix]
+  npx @wpmoo/odoo doctor --json
   npx @wpmoo/odoo start
   npx @wpmoo/odoo stop
   npx @wpmoo/odoo logs [service]
@@ -48,8 +52,9 @@ Options:
   --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. One of private, oca, external. Default: private.
+  --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.
@@ -101,7 +106,11 @@ Task recipes:
     npx @wpmoo/odoo source list
     npx @wpmoo/odoo source sync
   Add module:
-    npx @wpmoo/odoo add-module --repo <source-repo> --module <module-name>
+    npx @wpmoo/odoo add-module --repo <source-repo> --module <module-name> --source-type private|oca|external
+  Remove module:
+    npx @wpmoo/odoo remove-module --repo <source-repo> --module <module-name> --source-type private|oca|external
+  Add OCA module:
+    npx @wpmoo/odoo add-module --repo sale-workflow --module sale_order_line_no_discount --source-type oca
   Run tests:
     npx @wpmoo/odoo test <module[,module]> [--db <db>] [--mode init|update] [--tags <tags>]
   Safe reset and recover:
@@ -117,6 +126,13 @@ Task recipes:
     npx @wpmoo/odoo logs [service]
     npx @wpmoo/odoo restart
 
+Machine-readable JSON output:
+  for automation and VS Code cockpit integration while keeping default human-readable output.
+    npx @wpmoo/odoo status --json
+    npx @wpmoo/odoo source list --json
+    npx @wpmoo/odoo source sync --json
+    npx @wpmoo/odoo doctor --json
+
 Example:
   npx @wpmoo/odoo create \\
     --product odoo_sample_module \\

package/dist/module-actions.js

@@ -5,11 +5,15 @@ import { readEnvironmentMetadata } from './environment.js';
 import { realGit, stageAll } from './git.js';
 import { pathUnderBase, validateModuleName, validateRepoPath } from './path-validation.js';
 import { readAddonsYaml, writeAddonsYaml } from './repo-actions.js';
-function sourceRepoPath(target, repoPath) {
-    return pathUnderBase(join(target, 'odoo/custom/src/private'), repoPath, 'repo path');
+const validSourceTypes = ['private', 'oca', 'external'];
+function normalizeSourceType(value) {
+    return validSourceTypes.includes(value) ? value : 'private';
 }
-function modulePath(target, repoPath, moduleName) {
-    return pathUnderBase(sourceRepoPath(target, repoPath), moduleName, 'module name');
+function sourceRepoPath(target, sourceType, repoPath) {
+    return pathUnderBase(join(target, `odoo/custom/src/${sourceType}`), repoPath, 'repo path');
+}
+function modulePath(target, sourceType, repoPath, moduleName) {
+    return pathUnderBase(sourceRepoPath(target, sourceType, repoPath), moduleName, 'module name');
 }
 function titleizeModule(moduleName) {
     return moduleName
@@ -49,7 +53,8 @@ async function usesAddonsYaml(target) {
 export async function addModuleToSourceRepo(options, git = realGit) {
     const repoPath = validateRepoPath(options.repoPath);
     const moduleName = validateModuleName(options.moduleName);
-    const destination = modulePath(options.target, repoPath, moduleName);
+    const sourceType = normalizeSourceType(options.sourceType);
+    const destination = modulePath(options.target, sourceType, repoPath, moduleName);
     await mkdir(join(destination, 'models'), { recursive: true });
     await mkdir(join(destination, 'security'), { recursive: true });
     await mkdir(join(destination, 'views'), { recursive: true });
@@ -58,24 +63,25 @@ export async function addModuleToSourceRepo(options, git = realGit) {
     await writeIfMissing(join(destination, 'models/__init__.py'), '');
     await writeIfMissing(join(destination, 'security/ir.model.access.csv'), 'id,name,model_id:id,group_id:id,perm_read,perm_write,perm_create,perm_unlink\n');
     await writeIfMissing(join(destination, 'views/.gitkeep'), '');
-    if (await usesAddonsYaml(options.target)) {
+    if (sourceType === 'private' && (await usesAddonsYaml(options.target))) {
         const addonsYaml = await readAddonsYaml(options.target);
         await writeAddonsYaml(options.target, addModuleToSourceRepoInAddonsYaml(addonsYaml, repoPath, moduleName));
     }
     if (options.stage) {
-        await stageAll(git, sourceRepoPath(options.target, repoPath));
+        await stageAll(git, sourceRepoPath(options.target, sourceType, repoPath));
         await stageAll(git, options.target);
     }
 }
-export async function listModulesInSourceRepo(target, repoPath) {
+export async function listModulesInSourceRepo(target, repoPath, sourceType) {
     const safeRepoPath = validateRepoPath(repoPath);
+    const resolvedSourceType = normalizeSourceType(sourceType);
     try {
-        const entries = await readdir(sourceRepoPath(target, safeRepoPath), { withFileTypes: true });
+        const entries = await readdir(sourceRepoPath(target, resolvedSourceType, safeRepoPath), { withFileTypes: true });
         const modules = await Promise.all(entries
             .filter((entry) => entry.isDirectory())
             .map(async (entry) => {
             try {
-                await readFile(join(sourceRepoPath(target, safeRepoPath), entry.name, '__manifest__.py'), 'utf8');
+                await readFile(join(sourceRepoPath(target, resolvedSourceType, safeRepoPath), entry.name, '__manifest__.py'), 'utf8');
                 return entry.name;
             }
             catch {
@@ -91,16 +97,17 @@ export async function listModulesInSourceRepo(target, repoPath) {
 export async function removeModuleFromSourceRepo(options, git = realGit) {
     const repoPath = validateRepoPath(options.repoPath);
     const moduleName = validateModuleName(options.moduleName);
-    if (await usesAddonsYaml(options.target)) {
+    const sourceType = normalizeSourceType(options.sourceType);
+    if (sourceType === 'private' && (await usesAddonsYaml(options.target))) {
         const addonsYaml = await readAddonsYaml(options.target);
         await writeAddonsYaml(options.target, removeModuleFromSourceRepoInAddonsYaml(addonsYaml, repoPath, moduleName));
     }
     if (options.deleteFiles) {
-        await rm(modulePath(options.target, repoPath, moduleName), { recursive: true, force: true });
+        await rm(modulePath(options.target, sourceType, repoPath, moduleName), { recursive: true, force: true });
     }
     if (options.stage) {
         if (options.deleteFiles) {
-            await stageAll(git, sourceRepoPath(options.target, repoPath));
+            await stageAll(git, sourceRepoPath(options.target, sourceType, repoPath));
         }
         await stageAll(git, options.target);
     }

package/dist/source-actions.js

@@ -1,6 +1,12 @@
 import { defaultOdooVersion, readEnvironmentMetadata, replaceSourceRepos } from './environment.js';
 import { realGit, stageAll } from './git.js';
 import { listGitmoduleSources, readSourceManifest, sourceManifestEntriesFromMetadata, sourceReposFromManifest, syncManifestFromMetadataAndGitmodules, writeSourceManifest, } from './source-manifest.js';
+function cloneSourceEntries(entries) {
+    return entries.map((entry) => ({
+        ...entry,
+        addons: [...entry.addons],
+    }));
+}
 export async function listSources(target) {
     const metadata = await readEnvironmentMetadata(target);
     const manifest = await readSourceManifest(target);
@@ -24,6 +30,23 @@ export function renderSourceList(entries) {
     })
         .join('\n');
 }
+export function sourceListJson(entries) {
+    return {
+        schemaVersion: 1,
+        command: 'source list',
+        ok: true,
+        sources: cloneSourceEntries(entries),
+    };
+}
+export function sourceSyncJson(entries, target) {
+    return {
+        schemaVersion: 1,
+        command: 'source sync',
+        ok: true,
+        target,
+        sources: cloneSourceEntries(entries),
+    };
+}
 export async function syncSources(options, git = realGit) {
     const metadata = await readEnvironmentMetadata(options.target);
     const manifest = await readSourceManifest(options.target);

package/dist/status.js

@@ -3,6 +3,16 @@ import { join } from 'node:path';
 import { detectComposeLayout, readEnvFile, selectedComposeEnvironment } from './compose-layout.js';
 import { defaultOdooVersion, markerPath } from './environment.js';
 import { isValidPathSegment, validateRepoPath } from './path-validation.js';
+const validSourceTypes = ['private', 'oca', 'external'];
+function normalizeSourceType(sourceType) {
+    if (typeof sourceType === 'string' && validSourceTypes.includes(sourceType)) {
+        return sourceType;
+    }
+    return 'private';
+}
+function sourceRepoPath(target, sourceType, path) {
+    return join(target, 'odoo/custom/src', sourceType, path);
+}
 async function pathExists(path) {
     try {
         await access(path);
@@ -27,9 +37,11 @@ function parseMetadata(content) {
 }
 function sourceRepoPathsFromMetadata(metadata) {
     const sourceRepoPaths = [];
+    const sourceRepoLocations = [];
     const invalidSourceRepoPaths = [];
-    if (!Array.isArray(metadata.sourceRepos))
-        return { sourceRepoPaths, invalidSourceRepoPaths };
+    if (!Array.isArray(metadata.sourceRepos)) {
+        return { sourceRepoPaths, sourceRepoLocations, invalidSourceRepoPaths };
+    }
     for (const repo of metadata.sourceRepos) {
         const path = repo && typeof repo.path === 'string' ? repo.path.trim() : '';
         if (!path)
@@ -38,9 +50,12 @@ function sourceRepoPathsFromMetadata(metadata) {
             invalidSourceRepoPaths.push(path);
             continue;
         }
-        sourceRepoPaths.push(validateRepoPath(path));
+        const sourceType = normalizeSourceType(typeof repo.sourceType === 'string' ? repo.sourceType : undefined);
+        const normalizedPath = validateRepoPath(path);
+        sourceRepoPaths.push(normalizedPath);
+        sourceRepoLocations.push({ sourceType, path: normalizedPath });
     }
-    return { sourceRepoPaths, invalidSourceRepoPaths };
+    return { sourceRepoPaths, sourceRepoLocations, invalidSourceRepoPaths };
 }
 async function missingCoreFiles(target, odooVersion) {
     const missing = [];
@@ -108,6 +123,21 @@ function summaryText(status) {
         : 'Environment ready';
     return `${prefix}: Odoo ${status.odooVersion}, source repos ${status.sourceRepoCount}, module candidates ${status.moduleCandidateCount}.`;
 }
+function isStatusHealthy(status) {
+    if (status.kind !== 'environment')
+        return false;
+    return (status.missingCoreFiles.length === 0 &&
+        status.invalidSourceRepoPaths.length === 0 &&
+        status.composeErrors.length === 0);
+}
+export function environmentStatusJson(status) {
+    return {
+        schemaVersion: 1,
+        command: 'status',
+        ok: isStatusHealthy(status),
+        status,
+    };
+}
 export async function getEnvironmentStatus(target) {
     const metadataFullPath = join(target, markerPath);
     if (!(await pathExists(metadataFullPath))) {
@@ -135,8 +165,8 @@ export async function getEnvironmentStatus(target) {
     const odooVersion = typeof metadata.odooVersion === 'string' && metadata.odooVersion.trim()
         ? metadata.odooVersion.trim()
         : defaultOdooVersion;
-    const { sourceRepoPaths, invalidSourceRepoPaths } = sourceRepoPathsFromMetadata(metadata);
-    const repoRoots = sourceRepoPaths.map((path) => join(target, 'odoo/custom/src/private', path));
+    const { sourceRepoPaths, sourceRepoLocations, invalidSourceRepoPaths } = sourceRepoPathsFromMetadata(metadata);
+    const repoRoots = sourceRepoLocations.map(({ sourceType, path }) => sourceRepoPath(target, sourceType, path));
     let moduleCandidateCount = 0;
     for (const repoRoot of repoRoots) {
         moduleCandidateCount += await countModuleCandidatesInRepoPath(repoRoot);

package/package.json

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