@wpmoo/toolkit 0.9.5 → 0.9.7

package/dist/cli.js

@@ -2,20 +2,25 @@
 import { realpathSync } from 'node:fs';
 import { rm, rename } from 'node:fs/promises';
 import { basename, relative, resolve } from 'node:path';
+import { emitKeypressEvents } from 'node:readline';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { commandFromArgs, isHelpRequested, isVersionRequested, optionsFromArgs, parseArgs, stripInternalFlags, } from './args.js';
+import { cockpitCommands } from './cockpit/command-registry.js';
 import { collectDailyActionArgs } from './cockpit/daily-prompts.js';
+import { selectModuleAction } from './cockpit/module-action-menu.js';
+import { selectModuleFromBrowser } from './cockpit/module-browser.js';
 import { selectCockpitTopLevelMenu } from './cockpit/menu.js';
 import { confirmCockpitCommandRisk } from './cockpit/safety.js';
 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 { listEnvironmentDatabases, normalizeDatabaseListResult } from './databases.js';
+import { isDailyActionCommand, runDailyAction, runDailyActionWithStyledOutput } from './daily-actions.js';
 import { getDoctorReport, runDoctor } from './doctor.js';
 import { getOriginUrl, realGit } from './git.js';
 import { renderHelp } from './help.js';
 import { runLocalCockpit } from './local-cockpit.js';
-import { addModuleToSourceRepo, listModulesInSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
+import { addModuleToSourceRepo, removeModuleFromSourceRepo, } from './module-actions.js';
 import { supportedOdooVersions } from './odoo-versions.js';
 import { renderRepositorySetupNote } from './prompt-copy.js';
 import { promptRepositoryUrl } from './prompt-repositories.js';
@@ -28,6 +33,7 @@ import { backupTargetPath, expectedTargetConfirmation, inspectEnvironmentTarget,
 import { getGitHubPrerequisiteStatus, renderGitHubPrerequisiteGuidance, } from './github-prerequisites.js';
 import { checkGitHubRepositories, createGitHubRepositories, manualCreateCommands, } from './repository-preflight.js';
 import { scaffold } from './scaffold.js';
+import { getSystemPrerequisiteStatus, renderSystemPrerequisiteGuidance, } from './system-prerequisites.js';
 import { confirmPrompt, introPrompt, isPromptCancel, notePrompt, outroPrompt, selectPrompt, textPrompt } from './prompts/index.js';
 import { renderBanner } from './templates.js';
 import { checkForUpdate, isUpdateCheckSkipped, restartCli } from './update-check.js';
@@ -211,6 +217,29 @@ function clearCockpitScreen() {
         process.stdout.write('\u001B[2J\u001B[H');
     }
 }
+function clearPrerequisiteScreen() {
+    if (process.stdout.isTTY) {
+        process.stdout.write('\u001B[3J\u001B[2J\u001B[H');
+    }
+}
+const ANSI_ACTION = '\u001B[38;2;226;184;96m';
+const ANSI_SUCCESS = '\u001B[32m';
+const ANSI_DEFAULT_FOREGROUND = '\u001B[39m';
+const ANSI_DIM_INFO = '\u001B[2m\u001B[38;2;120;157;181m';
+const ANSI_RESET = '\u001B[0m';
+function renderActionText(value) {
+    return ansi(value, ANSI_ACTION, ANSI_DEFAULT_FOREGROUND);
+}
+function renderCompletedText(action) {
+    if (!supportsAnsi()) {
+        return `✓ ${action} completed.`;
+    }
+    return `${ANSI_SUCCESS}✓${ANSI_DEFAULT_FOREGROUND} ${action} ${ANSI_SUCCESS}completed${ANSI_DEFAULT_FOREGROUND}.`;
+}
+function renderBackHelp() {
+    return ansi('Esc to go back', ANSI_DIM_INFO, ANSI_RESET);
+}
+const manualDatabaseValue = '__wpmoo_manual_database_entry__';
 async function showStartup(argv, skipUpdateCheck, details) {
     if (skipUpdateCheck) {
         console.log(renderStartupBanner(details));
@@ -603,9 +632,6 @@ async function selectSourceRepo(target, cancelAction = 'exit') {
     }
     return { repoPath: String(selected), sourceType: 'private' };
 }
-function formatSourceRepoPromptPath(target, selected) {
-    return renderedSourceRepoPath(target, selected.sourceType, selected.repoPath);
-}
 function suggestedModuleName(repoPath) {
     return 'odoo_sample_module';
 }
@@ -801,25 +827,20 @@ function removeModuleOptionsFromArgs(argv) {
     };
 }
 async function removeModuleOptionsFromPrompts(showIntro = true, cancelAction = 'exit') {
-    showSubmenuIntro('Remove module from source repo', showIntro, cancelAction);
+    if (showIntro) {
+        introPrompt('Remove module');
+    }
     const target = process.cwd();
-    const sourceRepo = await selectSourceRepo(target, cancelAction);
-    const modules = await listModulesInSourceRepo(target, sourceRepo.repoPath, sourceRepo.sourceType);
-    if (modules.length === 0) {
+    const selectedModule = await selectModuleFromBrowser(target, { cancelAction });
+    if (!selectedModule) {
         if (cancelAction === 'back') {
-            notePrompt(`No Odoo modules found under ${formatSourceRepoPromptPath(target, sourceRepo)}.\nNext: choose "Add module to source repo" first.`, 'Nothing to remove');
+            notePrompt('No Odoo modules found.\nNext: choose "Add module" or "Add source repo" first.', 'Nothing to remove');
             handleUnavailableMenuChoice(cancelAction);
         }
-        throw new Error(`No Odoo modules found under ${formatSourceRepoPromptPath(target, sourceRepo)}`);
+        throw new Error('No Odoo modules found');
     }
-    const moduleName = await selectPrompt({
-        message: menuPromptMessage('Module to remove', cancelAction),
-        options: modules.map((module) => ({ value: module, label: module })),
-        initialValue: modules[0],
-    });
-    handleCancel(moduleName, cancelAction);
     const deleteFiles = await confirmPrompt({
-        message: menuPromptMessage('Delete module files too? (y/N)', cancelAction),
+        message: menuPromptMessage('Delete module files too?', cancelAction),
         active: 'Y',
         inactive: 'n',
         initialValue: false,
@@ -827,9 +848,9 @@ async function removeModuleOptionsFromPrompts(showIntro = true, cancelAction = '
     handleCancel(deleteFiles, cancelAction);
     return {
         target,
-        repoPath: sourceRepo.repoPath,
-        sourceType: sourceRepo.sourceType,
-        moduleName: String(moduleName),
+        repoPath: selectedModule.repoPath,
+        sourceType: selectedModule.sourceType,
+        moduleName: selectedModule.moduleName,
         deleteFiles: Boolean(deleteFiles),
         stage: true,
     };
@@ -912,6 +933,40 @@ async function ensureGitHubRepositories(options, interactive) {
     handleCancel(visibility, 'exit');
     await createGitHubRepositories(missing, visibility);
 }
+async function ensureSystemPrerequisites(interactive) {
+    while (true) {
+        const status = await getSystemPrerequisiteStatus();
+        if (status.ok) {
+            return true;
+        }
+        const guidance = renderSystemPrerequisiteGuidance(status);
+        if (!interactive) {
+            throw new Error(guidance);
+        }
+        clearPrerequisiteScreen();
+        console.log(renderStartupBanner());
+        console.log(renderVersionTag());
+        console.log();
+        console.log(guidance);
+        console.log();
+        const action = await selectPrompt({
+            message: 'If you have installed the prerequisites',
+            options: [
+                {
+                    value: 'check-again',
+                    label: `${renderActionText('Check again')}${dim(' (Enter to re-check again)')}`,
+                },
+            ],
+            initialValue: 'check-again',
+            loop: false,
+            navigationHelp: 'exit',
+        });
+        handleCancel(action, 'exit');
+        if (action === 'check-again') {
+            continue;
+        }
+    }
+}
 async function ensureNonInteractiveCreateTarget(options) {
     if (options.dryRun) {
         return;
@@ -928,7 +983,7 @@ async function ensureNonInteractiveCreateTarget(options) {
     }
     throw new Error(renderForeignEnvironmentTargetWarning(state));
 }
-async function finishCreateFlow(result, cwd, interactive) {
+async function finishCreateFlow(result, cwd, interactive, checkSystemPrerequisites = true) {
     if (result.kind === 'cancelled') {
         outroPrompt('Create flow cancelled.');
         return;
@@ -942,6 +997,9 @@ async function finishCreateFlow(result, cwd, interactive) {
         return;
     }
     const { options } = result;
+    if (!options.dryRun && checkSystemPrerequisites && !(await ensureSystemPrerequisites(interactive))) {
+        return;
+    }
     await ensureGitHubRepositories(options, interactive);
     const scaffoldResult = await scaffold(options);
     if (options.dryRun) {
@@ -968,18 +1026,328 @@ async function finishCreateFlow(result, cwd, interactive) {
     }
     outroPrompt(`Created Odoo dev overlay in ${options.target}. Review staged changes, then commit.`);
 }
-async function runCockpitCommand(command, cwd) {
-    if (command.id === 'exit') {
-        return 'exit';
+function selectedModuleRemovalOptions(module, cwd, deleteFiles) {
+    return {
+        target: cwd,
+        repoPath: module.repoPath,
+        sourceType: module.sourceType,
+        moduleName: module.moduleName,
+        deleteFiles,
+        stage: true,
+    };
+}
+function moduleDailyAction(action) {
+    if (action === 'update')
+        return 'update';
+    if (action === 'test')
+        return 'test';
+    if (action === 'lint')
+        return 'lint';
+    return undefined;
+}
+function moduleDailyActionArgs(action, module) {
+    if (action === 'update' || action === 'test') {
+        return [module.moduleName];
     }
-    if (command.target.kind === 'daily') {
-        const argv = await collectDailyActionArgs(command.target.command, cwd);
+    return [];
+}
+function moduleActionTitle(action) {
+    if (action === 'update')
+        return 'Update module';
+    if (action === 'test')
+        return 'Test module';
+    if (action === 'lint')
+        return 'Run environment lint';
+    if (action === 'delete')
+        return 'Delete module';
+    return 'Module action';
+}
+function moduleActionCompletedLabel(action) {
+    if (action === 'update')
+        return 'Update';
+    if (action === 'test')
+        return 'Test';
+    if (action === 'lint')
+        return 'Environment lint';
+    return 'Action';
+}
+function commandActionTitle(command) {
+    if (command === 'update')
+        return 'Update module';
+    if (command === 'test')
+        return 'Test module';
+    if (command === 'lint')
+        return 'Run environment lint';
+    if (command === 'pot')
+        return 'Generate POT';
+    return command;
+}
+function commandCompletedLabel(command) {
+    if (command === 'install')
+        return 'Install';
+    if (command === 'update')
+        return 'Update';
+    if (command === 'test')
+        return 'Test';
+    if (command === 'lint')
+        return 'Environment lint';
+    if (command === 'pot')
+        return 'Generate POT';
+    return command;
+}
+function shouldReturnToDailySelection(command) {
+    return ['install', 'update', 'test', 'pot'].includes(command);
+}
+function shouldUseModuleBrowserForDailySelection(command) {
+    return ['update', 'test', 'lint', 'pot'].includes(command);
+}
+function dailyActionSelectedLabel(command, argv) {
+    if (['install', 'update', 'test', 'pot'].includes(command)) {
+        return argv[0];
+    }
+    return undefined;
+}
+async function selectDatabaseArg(cwd, message, fallback, options = {}) {
+    const databaseResult = normalizeDatabaseListResult(await listEnvironmentDatabases(cwd, options));
+    const databases = databaseResult.databases;
+    if (databases.length > 0) {
+        const selected = await selectPrompt({
+            message: menuPromptMessage(message, 'back'),
+            options: [
+                ...databases.map((database) => ({ value: database, label: database })),
+                { value: manualDatabaseValue, label: 'Manual entry' },
+            ],
+            initialValue: databases.includes(fallback) ? fallback : databases[0],
+        });
+        handleCancel(selected, 'back');
+        if (selected !== manualDatabaseValue) {
+            return String(selected);
+        }
+    }
+    return asString(await textPrompt({
+        message: menuPromptMessage(databaseResult.ok ? message : `${message} (database list unavailable; enter manually)`, 'back'),
+        defaultValue: fallback,
+        placeholder: fallback,
+    }), fallback, 'back');
+}
+async function collectCockpitModuleDailyActionArgs(command, module, cwd) {
+    const moduleName = module.moduleName;
+    if (command === 'update') {
+        return [moduleName];
+    }
+    if (command === 'test') {
+        return [moduleName];
+    }
+    if (command === 'lint') {
+        return [];
+    }
+    if (command === 'pot') {
+        return [moduleName];
+    }
+    throw new Error(`Unsupported module action command: ${command}`);
+}
+async function renderDailyActionResultPageHeader(title, selectedLabel, cwd) {
+    await renderCockpitSubmenuPage(title, cwd);
+    if (selectedLabel) {
+        console.log(renderActionText(selectedLabel));
+        console.log('');
+    }
+}
+async function renderCockpitSubmenuPage(title, cwd) {
+    const status = await getEnvironmentStatus(cwd);
+    const serviceStatus = await getServiceRuntimeStatus(cwd, status);
+    clearCockpitScreen();
+    console.log(renderBanner(renderCockpitStatusLines(status, serviceStatus, `Last: ${title}`), { version: startupVersionLine() }));
+    console.log();
+    introPrompt(title);
+}
+async function waitForModuleActionBack() {
+    console.log(renderBackHelp());
+    if (!process.stdin.isTTY) {
+        return false;
+    }
+    await new Promise((resolve) => {
+        emitKeypressEvents(process.stdin);
+        const input = process.stdin;
+        const wasRaw = input.isRaw;
+        const listener = (_value, key) => {
+            if (key.ctrl && key.name === 'c') {
+                process.exit(1);
+            }
+            if (key.name === 'escape' || key.sequence === '\u001B') {
+                cleanup();
+                resolve();
+            }
+        };
+        const cleanup = () => {
+            input.off('keypress', listener);
+            if (typeof input.setRawMode === 'function') {
+                input.setRawMode(Boolean(wasRaw));
+            }
+            input.pause();
+        };
+        if (typeof input.setRawMode === 'function') {
+            input.setRawMode(true);
+        }
+        input.resume();
+        input.on('keypress', listener);
+    });
+    return true;
+}
+async function runDailyActionResultPage(command, argv, cwd, title = commandActionTitle(command), selectedLabel = dailyActionSelectedLabel(command, argv), completedLabel = commandCompletedLabel(command)) {
+    await renderDailyActionResultPageHeader(title, selectedLabel, cwd);
+    try {
+        await runDailyActionWithStyledOutput(command, argv, cwd);
+        notePrompt(renderCompletedText(completedLabel), 'Done');
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        notePrompt(message, 'Error');
+        await waitForModuleActionBack();
+        throw error;
+    }
+    return waitForModuleActionBack();
+}
+async function runSelectedModuleDailyAction(action, module, cwd) {
+    const command = moduleDailyAction(action);
+    if (!command) {
+        return false;
+    }
+    return runDailyActionResultPage(command, moduleDailyActionArgs(action, module), cwd, moduleActionTitle(action), action === 'lint' ? undefined : module.moduleName, moduleActionCompletedLabel(action));
+}
+async function runSelectedModuleAction(action, module, cwd) {
+    if (action === 'delete') {
+        const deleteFiles = await confirmPrompt({
+            message: menuPromptMessage('Delete module files too?', 'back'),
+            active: 'Y',
+            inactive: 'n',
+            initialValue: false,
+        });
+        handleCancel(deleteFiles, 'back');
+        const removeCommand = cockpitCommands.find((entry) => entry.id === 'remove-module');
+        if (removeCommand && !(await confirmCockpitCommandRisk(removeCommand))) {
+            notePrompt(`Module ${module.moduleName} was not removed.`, 'Action skipped');
+            return false;
+        }
+        await removeModuleFromSourceRepo(selectedModuleRemovalOptions(module, cwd, Boolean(deleteFiles)));
+        notePrompt(`Removed module ${module.moduleName} from source repo ${module.repoPath}.`, 'Done');
+        return false;
+    }
+    return runSelectedModuleDailyAction(action, module, cwd);
+}
+async function runCockpitModuleDailyCommand(command, cwd) {
+    if (command.target.kind !== 'daily') {
+        return;
+    }
+    const dailyCommand = command.target.command;
+    while (true) {
+        let selectedModule;
+        let argv;
+        try {
+            await renderCockpitSubmenuPage(command.label, cwd);
+            const module = await selectModuleFromBrowser(cwd);
+            if (!module) {
+                notePrompt('No Odoo modules found.\nNext: choose "Add module" or "Add source repo" first.', command.label);
+                return;
+            }
+            selectedModule = module;
+            argv = await collectCockpitModuleDailyActionArgs(dailyCommand, selectedModule, cwd);
+        }
+        catch (error) {
+            if (isMenuBackSignal(error)) {
+                return;
+            }
+            throw error;
+        }
         if (!(await confirmCockpitCommandRisk(command))) {
             notePrompt(`${command.slashAlias} was not run.`, 'Action skipped');
-            return 'continue';
+            return;
+        }
+        const returnedByBack = await runDailyActionResultPage(dailyCommand, argv, cwd, command.label, selectedModule.moduleName, commandCompletedLabel(dailyCommand));
+        if (!returnedByBack) {
+            return;
+        }
+    }
+}
+async function runCockpitDailyCommand(command, cwd) {
+    if (command.target.kind !== 'daily') {
+        return;
+    }
+    const dailyCommand = command.target.command;
+    if (shouldUseModuleBrowserForDailySelection(dailyCommand)) {
+        await runCockpitModuleDailyCommand(command, cwd);
+        return;
+    }
+    if (!shouldReturnToDailySelection(dailyCommand)) {
+        const argv = await collectDailyActionArgs(dailyCommand, cwd);
+        if (!(await confirmCockpitCommandRisk(command))) {
+            notePrompt(`${command.slashAlias} was not run.`, 'Action skipped');
+            return;
         }
-        await runDailyAction(command.target.command, argv, cwd);
+        await runDailyAction(dailyCommand, argv, cwd);
         notePrompt(`${command.slashAlias} completed.`, 'Done');
+        return;
+    }
+    while (true) {
+        let argv;
+        try {
+            await renderCockpitSubmenuPage(command.label, cwd);
+            argv = await collectDailyActionArgs(dailyCommand, cwd);
+        }
+        catch (error) {
+            if (isMenuBackSignal(error)) {
+                return;
+            }
+            throw error;
+        }
+        if (!(await confirmCockpitCommandRisk(command))) {
+            notePrompt(`${command.slashAlias} was not run.`, 'Action skipped');
+            return;
+        }
+        const returnedByBack = await runDailyActionResultPage(dailyCommand, argv, cwd, command.label);
+        if (!returnedByBack) {
+            return;
+        }
+    }
+}
+async function runListModulesCommand(cwd) {
+    while (true) {
+        await renderCockpitSubmenuPage('List modules', cwd);
+        const selectedModule = await selectModuleFromBrowser(cwd);
+        if (!selectedModule) {
+            notePrompt('No Odoo modules found.\nNext: choose "Add module" or "Add source repo" first.', 'List modules');
+            return;
+        }
+        while (true) {
+            let moduleAction;
+            try {
+                await renderCockpitSubmenuPage('List modules', cwd);
+                console.log(renderActionText(selectedModule.moduleName));
+                console.log('');
+                moduleAction = await selectModuleAction(selectedModule);
+            }
+            catch (error) {
+                if (isMenuBackSignal(error)) {
+                    break;
+                }
+                throw error;
+            }
+            if (!moduleAction) {
+                break;
+            }
+            const returnedByBack = await runSelectedModuleAction(moduleAction, selectedModule, cwd);
+            if (!returnedByBack) {
+                return;
+            }
+        }
+    }
+}
+async function runCockpitCommand(command, cwd) {
+    if (command.id === 'exit') {
+        return 'exit';
+    }
+    if (command.target.kind === 'daily') {
+        await runCockpitDailyCommand(command, cwd);
         return 'continue';
     }
     if (command.id === 'status') {
@@ -990,6 +1358,10 @@ async function runCockpitCommand(command, cwd) {
         notePrompt(await runDoctor(cwd), 'Doctor');
         return 'continue';
     }
+    if (command.id === 'list-modules') {
+        await runListModulesCommand(cwd);
+        return 'continue';
+    }
     if (command.id === 'add-repo') {
         const options = await addRepoOptionsFromPrompts(false, 'back');
         await ensureAddRepoGitHubRepository(options, 'back');
@@ -1014,7 +1386,7 @@ async function runCockpitCommand(command, cwd) {
         return 'continue';
     }
     if (command.id === 'remove-module') {
-        const options = await removeModuleOptionsFromPrompts(false, 'back');
+        const options = await removeModuleOptionsFromPrompts(true, 'back');
         if (!(await confirmCockpitCommandRisk(command))) {
             notePrompt(`Module ${options.moduleName} was not removed.`, 'Action skipped');
             return 'continue';
@@ -1051,13 +1423,21 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
         const detection = await detectDevelopmentEnvironment(cwd);
         if (!detection.isEnvironment) {
             await showStartup(argv, skipUpdateCheck);
-            await finishCreateFlow(await optionsFromPrompts(), cwd, true);
+            if (!(await ensureSystemPrerequisites(true))) {
+                return;
+            }
+            await finishCreateFlow(await optionsFromPrompts(), cwd, true, false);
             return;
         }
         let lastStatus = 'Last: Ready';
         let status = await getEnvironmentStatus(cwd);
         let serviceStatus = await getServiceRuntimeStatus(cwd, status);
         await showStartup(argv, skipUpdateCheck, () => renderCockpitStatusLines(status, serviceStatus, lastStatus));
+        const renderCockpitMenuShell = () => {
+            clearCockpitScreen();
+            console.log(renderBanner(renderCockpitStatusLines(status, serviceStatus, lastStatus), { version: startupVersionLine() }));
+            console.log();
+        };
         while (true) {
             try {
                 const command = await selectCockpitCommandFromMenu(serviceStatus);
@@ -1071,6 +1451,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
                 }
                 catch (error) {
                     if (isMenuBackSignal(error)) {
+                        renderCockpitMenuShell();
                         continue;
                     }
                     commandFailed = true;
@@ -1084,9 +1465,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
                 }
                 status = await getEnvironmentStatus(cwd);
                 serviceStatus = await getServiceRuntimeStatus(cwd, status);
-                clearCockpitScreen();
-                console.log(renderBanner(renderCockpitStatusLines(status, serviceStatus, lastStatus), { version: startupVersionLine() }));
-                console.log();
+                renderCockpitMenuShell();
             }
             catch (error) {
                 if (isMenuBackSignal(error)) {
@@ -1214,7 +1593,10 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
         await finishCreateFlow({ kind: 'create', options }, cwd, false);
         return;
     }
-    await finishCreateFlow(await optionsFromPrompts(), cwd, true);
+    if (!(await ensureSystemPrerequisites(true))) {
+        return;
+    }
+    await finishCreateFlow(await optionsFromPrompts(), cwd, true, false);
 }
 export function isCliEntrypoint(metaUrl, argvPath = process.argv[1]) {
     if (!argvPath)

package/dist/cockpit/command-registry.js

@@ -34,10 +34,14 @@ export const cockpitCommands = [
     dailyCommand('restart', 'services', 'Restart services', 'Restart the Odoo development services.', ['reload']),
     dailyCommand('logs', 'services', 'View logs', 'Stream logs for an Odoo environment service.', ['log', 'tail']),
     dailyCommand('shell', 'services', 'Open shell', 'Open a shell inside the Odoo service container.', ['bash', 'terminal']),
+    internalCommand('list-modules', 'modules', 'List modules', 'Browse detected Odoo modules by source category.', [
+        'modules list',
+        'browse modules',
+    ]),
     dailyCommand('install', 'modules', 'Install module', 'Install one or more Odoo modules into a database.', ['install module']),
     dailyCommand('update', 'modules', 'Update module', 'Update one or more Odoo modules in a database.', ['upgrade']),
     dailyCommand('test', 'modules', 'Run tests', 'Run Odoo tests for one or more modules.', ['tests', 'pytest']),
-    dailyCommand('lint', 'modules', 'Run lint', 'Run the configured module lint checks.', ['check', 'quality']),
+    dailyCommand('lint', 'modules', 'Run environment lint', 'Run the configured environment lint checks.', ['check', 'quality']),
     dailyCommand('pot', 'modules', 'Generate POT', 'Generate translation template files for a module.', ['translation', 'i18n']),
     dailyCommand('psql', 'database', 'Open psql', 'Open a PostgreSQL prompt for an environment database.', ['postgres', 'sql']),
     dailyCommand('snapshot', 'database', 'Create snapshot', 'Create a database snapshot.', ['backup', 'dump']),