@wpmoo/toolkit 0.9.0

package/dist/cockpit/command-palette.js

@@ -0,0 +1,23 @@
+import { isPromptCancel, searchPrompt } from '../prompts/index.js';
+import { searchCockpitCommands } from './command-registry.js';
+const defaultSearchPrompt = (config) => searchPrompt(config);
+function commandChoice(command) {
+    return {
+        value: command,
+        name: `${command.slashAlias} ${command.label}`,
+        description: command.description,
+        short: command.id,
+    };
+}
+export async function selectCockpitCommandFromPalette(options = {}) {
+    const prompt = options.prompt ?? defaultSearchPrompt;
+    const selected = await prompt({
+        message: 'Search commands',
+        pageSize: 10,
+        source: (term) => searchCockpitCommands(term).map(commandChoice),
+    });
+    if (isPromptCancel(selected)) {
+        throw new Error('Prompt was canceled.');
+    }
+    return selected;
+}

package/dist/cockpit/command-registry.js

@@ -0,0 +1,91 @@
+const riskyCommandIds = new Set(['stop', 'resetdb', 'restore-snapshot', 'remove-repo', 'remove-module', 'safe-reset']);
+function dailyCommand(command, category, label, description, aliases = []) {
+    return {
+        id: command,
+        slashAlias: `/${command}`,
+        category,
+        label,
+        description,
+        isRisky: riskyCommandIds.has(command),
+        target: {
+            kind: 'daily',
+            command,
+        },
+        aliases,
+    };
+}
+function internalCommand(id, category, label, description, aliases = []) {
+    return {
+        id,
+        slashAlias: `/${id}`,
+        category,
+        label,
+        description,
+        isRisky: riskyCommandIds.has(id),
+        target: {
+            kind: 'internal',
+        },
+        aliases,
+    };
+}
+export const cockpitCommands = [
+    dailyCommand('start', 'services', 'Start services', 'Start the Odoo development services.', ['up', 'compose up']),
+    dailyCommand('stop', 'services', 'Stop services', 'Stop the Odoo development services.', ['down', 'compose down']),
+    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']),
+    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('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']),
+    dailyCommand('restore-snapshot', 'database', 'Restore snapshot', 'Restore a database from a named snapshot.', ['restore', 'snapshot restore']),
+    dailyCommand('resetdb', 'database', 'Reset database', 'Reset an environment database.', ['reset db', 'database reset']),
+    internalCommand('status', 'diagnostics', 'Environment status', 'Show a summary of the current environment state.', [
+        'state',
+        'summary',
+    ]),
+    internalCommand('doctor', 'diagnostics', 'Run doctor', 'Run environment diagnostics and report actionable issues.', [
+        'diagnose',
+        'health',
+    ]),
+    internalCommand('add-repo', 'repositories', 'Add source repo', 'Add a source repository as an environment submodule.', [
+        'repository add',
+        'source add',
+    ]),
+    internalCommand('remove-repo', 'repositories', 'Remove source repo', 'Remove a source repository from the environment.', ['repository remove', 'source remove']),
+    internalCommand('add-module', 'modules', 'Add module', 'Add a module folder to a source repository.', ['module add']),
+    internalCommand('remove-module', 'modules', 'Remove module', 'Remove a module folder from a source repository.', ['module remove']),
+    internalCommand('safe-reset', 'maintenance', 'Safe reset environment', 'Refresh generated environment files while preserving source repositories.', ['reset', 'refresh']),
+    internalCommand('exit', 'maintenance', 'Exit', 'Leave the command palette.', ['quit', 'back']),
+];
+const defaultCommandIds = new Set(['start', 'logs', 'test', 'status', 'doctor', 'exit']);
+export function normalizeCockpitSearchTerm(term) {
+    return (term ?? '').trim().toLowerCase().replace(/\s+/g, ' ');
+}
+function commandSearchFields(command) {
+    return [command.slashAlias, command.id, command.label, command.category, command.description, ...command.aliases].map(normalizeCockpitSearchTerm);
+}
+function exactMatchScore(command, term) {
+    const bareTerm = term.startsWith('/') ? term.slice(1) : term;
+    if (normalizeCockpitSearchTerm(command.slashAlias) === term)
+        return 0;
+    if (normalizeCockpitSearchTerm(command.id) === bareTerm)
+        return 0;
+    if (normalizeCockpitSearchTerm(command.label) === term)
+        return 1;
+    if (command.aliases.map(normalizeCockpitSearchTerm).includes(term))
+        return 2;
+    return 10;
+}
+export function searchCockpitCommands(term) {
+    const normalizedTerm = normalizeCockpitSearchTerm(term);
+    if (!normalizedTerm) {
+        return cockpitCommands.filter((command) => defaultCommandIds.has(command.id));
+    }
+    return cockpitCommands
+        .filter((command) => commandSearchFields(command).some((field) => field.includes(normalizedTerm)))
+        .sort((left, right) => exactMatchScore(left, normalizedTerm) - exactMatchScore(right, normalizedTerm));
+}

package/dist/cockpit/daily-prompts.js

@@ -0,0 +1,177 @@
+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';
+import { isPromptCancel, selectPrompt, textPrompt } from '../prompts/index.js';
+const manualModuleValue = '__wpmoo_manual_module_entry__';
+function defaultCancelHandler(value, action) {
+    handlePromptCancel(isPromptCancel(value), action);
+}
+function promptDeps(deps = {}) {
+    return {
+        select: deps.select ?? ((options) => selectPrompt(options)),
+        text: deps.text ?? ((options) => textPrompt(options)),
+        list: deps.list ?? ((options) => selectPrompt(options)),
+        handleCancel: deps.handleCancel ?? defaultCancelHandler,
+    };
+}
+function asString(value, fallback, deps) {
+    deps.handleCancel(value, 'back');
+    return typeof value === 'string' && value.trim() ? value.trim() : fallback;
+}
+function requiredString(value, message, deps) {
+    deps.handleCancel(value, 'back');
+    if (typeof value === 'string' && value.trim()) {
+        return value.trim();
+    }
+    throw new Error(message);
+}
+async function detectedModules(cwd) {
+    try {
+        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.path, repo.sourceType);
+            }
+            catch {
+                return [];
+            }
+        }));
+        return [...new Set(modules.flat())].sort();
+    }
+    catch {
+        return [];
+    }
+}
+async function moduleArg(cwd, deps, message = 'Module(s)') {
+    const modules = await detectedModules(cwd);
+    if (modules.length === 0) {
+        return requiredString(await deps.text({
+            message: menuPromptMessage(message, 'back'),
+            placeholder: 'sale,stock',
+            validate: (value) => (value.trim() ? undefined : 'Enter one or more module technical names.'),
+        }), 'Module is required.', deps);
+    }
+    const selected = await deps.select({
+        message: menuPromptMessage(message, 'back'),
+        options: [
+            ...modules.map((moduleName) => ({ value: moduleName, label: moduleName })),
+            { value: manualModuleValue, label: 'Manual entry' },
+        ],
+        initialValue: modules[0],
+    });
+    deps.handleCancel(selected, 'back');
+    if (selected !== manualModuleValue) {
+        return String(selected);
+    }
+    return requiredString(await deps.text({
+        message: menuPromptMessage('Module(s)', 'back'),
+        placeholder: modules.join(','),
+        validate: (value) => (value.trim() ? undefined : 'Enter one or more module technical names.'),
+    }), 'Module is required.', deps);
+}
+async function optionalTextArg(deps, message, fallback) {
+    return asString(await deps.text({
+        message: menuPromptMessage(message, 'back'),
+        defaultValue: fallback,
+        placeholder: fallback,
+    }), fallback, deps);
+}
+async function optionalModules(cwd, deps) {
+    const modules = await detectedModules(cwd);
+    if (modules.length === 0) {
+        const manualModules = asString(await deps.text({
+            message: menuPromptMessage('Module(s) to include (optional)', 'back'),
+            placeholder: 'sale,stock',
+        }), '', deps);
+        return manualModules || undefined;
+    }
+    const selected = await deps.select({
+        message: menuPromptMessage('Module(s) to include (optional)', 'back'),
+        options: [
+            { value: '', label: 'All modules' },
+            ...modules.map((moduleName) => ({ value: moduleName, label: moduleName })),
+            { value: manualModuleValue, label: 'Manual entry' },
+        ],
+        initialValue: '',
+    });
+    deps.handleCancel(selected, 'back');
+    if (selected === '') {
+        return undefined;
+    }
+    if (selected !== manualModuleValue) {
+        return String(selected);
+    }
+    const manualModules = asString(await deps.text({
+        message: menuPromptMessage('Module(s) to include', 'back'),
+        placeholder: modules.join(','),
+    }), '', deps);
+    return manualModules || undefined;
+}
+export async function collectDailyActionArgs(command, cwd, promptDepsArg = {}) {
+    const deps = promptDeps(promptDepsArg);
+    if (['start', 'restart', 'shell', 'lint', 'stop'].includes(command)) {
+        return [];
+    }
+    if (command === 'logs') {
+        return [await optionalTextArg(deps, 'Service', 'odoo')];
+    }
+    if (command === 'psql') {
+        return [await optionalTextArg(deps, 'Database', 'postgres')];
+    }
+    if (command === 'install' || command === 'update') {
+        const modules = await moduleArg(cwd, deps);
+        const db = asString(await deps.text({
+            message: menuPromptMessage('Database (optional)', 'back'),
+            placeholder: 'devel',
+        }), '', deps);
+        return db ? [modules, db] : [modules];
+    }
+    if (command === 'test') {
+        const modules = await moduleArg(cwd, deps);
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const mode = asString(await deps.list({
+            message: menuPromptMessage('Mode', 'back'),
+            options: [
+                { value: 'update', label: 'update' },
+                { value: 'init', label: 'init' },
+            ],
+            initialValue: 'update',
+        }), 'update', deps);
+        const tags = asString(await deps.text({
+            message: menuPromptMessage('Tags (optional)', 'back'),
+            placeholder: '/sale',
+        }), '', deps);
+        return tags
+            ? [modules, '--db', db, '--mode', mode, '--tags', tags]
+            : [modules, '--db', db, '--mode', mode];
+    }
+    if (command === 'pot') {
+        const modules = await moduleArg(cwd, deps);
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const output = await optionalTextArg(deps, 'Output file', `i18n/${modules}.pot`);
+        return [modules, db, output];
+    }
+    if (command === 'resetdb') {
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const modules = await optionalModules(cwd, deps);
+        return modules ? [db, modules] : [db];
+    }
+    if (command === 'snapshot') {
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        const snapshotName = await optionalTextArg(deps, 'Snapshot name', 'before-update');
+        return [db, snapshotName];
+    }
+    if (command === 'restore-snapshot') {
+        const snapshotName = requiredString(await deps.text({
+            message: menuPromptMessage('Snapshot name', 'back'),
+            validate: (value) => (value.trim() ? undefined : 'Enter the snapshot name.'),
+        }), 'Snapshot name is required.', deps);
+        const db = await optionalTextArg(deps, 'Database', 'devel');
+        return [snapshotName, db];
+    }
+    return [];
+}

package/dist/cockpit/menu.js

@@ -0,0 +1,99 @@
+import { styleText } from 'node:util';
+import { cockpitCommands, } from './command-registry.js';
+import { handlePromptCancel } from '../menu-navigation.js';
+import { isPromptCancel, promptSeparator, selectPrompt, } from '../prompts/index.js';
+const categoryLabels = {
+    services: 'Services',
+    modules: 'Modules',
+    database: 'Database',
+    diagnostics: 'Diagnostics',
+    repositories: 'Repositories',
+    maintenance: 'Maintenance',
+};
+const topLevelCategoryOrder = [
+    'services',
+    'modules',
+    'database',
+    'diagnostics',
+    'repositories',
+    'maintenance',
+];
+const topLevelCommands = topLevelCategoryOrder.flatMap((category) => cockpitCommands.filter((command) => command.category === category && command.id !== 'exit'));
+const topLevelCommandLabelWidth = Math.max(...topLevelCommands.map((command) => command.label.length));
+function rgb(red, green, blue, value) {
+    return `\u001B[38;2;${red};${green};${blue}m${value}\u001B[39m`;
+}
+function dim(value) {
+    return styleText('dim', value, { validateStream: false });
+}
+function categoryHeading(category) {
+    return `\u001B[1D${rgb(143, 211, 255, categoryLabels[category])}`;
+}
+function commandName(command) {
+    return `${rgb(226, 184, 96, ` ${command.label.padEnd(topLevelCommandLabelWidth)}`)}${dim(`  ${command.description}`)}`;
+}
+function categoryChoices(category, index) {
+    const choices = [
+        promptSeparator(categoryHeading(category)),
+        ...topLevelCommands
+            .filter((command) => command.category === category)
+            .map((command) => ({
+            value: command,
+            name: commandName(command),
+            short: command.label,
+        })),
+    ];
+    if (index < topLevelCategoryOrder.length - 1) {
+        choices.push(promptSeparator(' '));
+    }
+    return choices;
+}
+const topLevelChoices = [
+    ...topLevelCategoryOrder.flatMap(categoryChoices),
+];
+const minimumTopLevelPageSize = 8;
+const startupViewportReservedRows = 11;
+function topLevelPageSize(choiceCount) {
+    const terminalRows = process.stdout.rows;
+    if (!terminalRows || terminalRows <= 0) {
+        return Math.min(choiceCount, 12);
+    }
+    return Math.min(choiceCount, Math.max(minimumTopLevelPageSize, terminalRows - startupViewportReservedRows));
+}
+function defaultSelect(options) {
+    return selectPrompt(options);
+}
+function defaultCancelHandler(value, action) {
+    handlePromptCancel(isPromptCancel(value), action);
+}
+function menuDeps(deps = {}) {
+    return {
+        select: deps.select ?? defaultSelect,
+        handleCancel: deps.handleCancel ?? defaultCancelHandler,
+    };
+}
+function isCockpitCommand(value) {
+    return typeof value === 'object' && value !== null && 'id' in value && 'slashAlias' in value;
+}
+export async function selectCockpitTopLevelMenu(options = {}) {
+    const deps = menuDeps(options);
+    const selected = await deps.select({
+        message: '',
+        choices: [...topLevelChoices],
+        default: topLevelCommands[0],
+        pageSize: topLevelPageSize(topLevelChoices.length),
+        loop: false,
+        hideMessage: true,
+    });
+    deps.handleCancel(selected, 'exit');
+    if (selected === 'exit') {
+        return { kind: 'exit' };
+    }
+    if (isCockpitCommand(selected)) {
+        return {
+            kind: 'command',
+            command: selected,
+        };
+    }
+    return { kind: 'exit' };
+}

package/dist/cockpit/safety.js

@@ -0,0 +1,22 @@
+import { handlePromptCancel, menuPromptMessage } from '../menu-navigation.js';
+import { confirmPrompt, isPromptCancel } from '../prompts/index.js';
+function defaultHandleCancel(value, action) {
+    handlePromptCancel(isPromptCancel(value), action);
+}
+function riskConfirmationMessage(command, action) {
+    return menuPromptMessage(`Run ${command.slashAlias} ${command.label}? This can change or remove environment state.`, action);
+}
+export async function confirmCockpitCommandRisk(command, deps = {}) {
+    if (!command.isRisky) {
+        return true;
+    }
+    const prompt = deps.confirm ?? confirmPrompt;
+    const cancelAction = deps.cancelAction ?? 'back';
+    const approved = await prompt({
+        message: riskConfirmationMessage(command, cancelAction),
+        initialValue: false,
+    });
+    const handleCancel = deps.handleCancel ?? defaultHandleCancel;
+    handleCancel(approved, cancelAction);
+    return approved === true;
+}

package/dist/compose-layout.js

@@ -0,0 +1,118 @@
+import { access, readFile } from 'node:fs/promises';
+import { join } from 'node:path';
+async function exists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export function parseEnvContent(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;
+}
+export async function readEnvFile(target) {
+    const path = join(target, '.env');
+    if (!(await exists(path)))
+        return undefined;
+    return parseEnvContent(await readFile(path, 'utf8'));
+}
+export function selectedComposeEnvironment(env) {
+    return env?.get('WPMOO_ENV')?.trim() || 'dev';
+}
+function uniqueStrings(values) {
+    return [...new Set(values.filter((value) => value.trim()).map((value) => value.trim()))];
+}
+function isValidComposeEnvironmentName(value) {
+    return /^[A-Za-z0-9_-]+$/.test(value);
+}
+function isValidOdooVersion(value) {
+    return /^\d+\.\d+$/.test(value);
+}
+function compactOverlayError(envName, overlayFile) {
+    if (envName === 'dev')
+        return `Missing compact compose overlay: ${overlayFile}`;
+    return `Missing compact compose overlay for WPMOO_ENV=${envName}: ${overlayFile}`;
+}
+export async function detectComposeLayout(target, options) {
+    const envName = options.envName?.trim() || 'dev';
+    if (!isValidComposeEnvironmentName(envName)) {
+        return {
+            kind: 'missing',
+            files: [],
+            missingFiles: [],
+            errors: [`Invalid WPMOO_ENV in .env: expected a simple compose overlay name, got ${envName}`],
+        };
+    }
+    const compactBase = 'compose.yaml';
+    const compactOverlay = `compose/${envName}.yaml`;
+    const hasCompactBase = await exists(join(target, compactBase));
+    const hasCompactOverlay = await exists(join(target, compactOverlay));
+    if (hasCompactBase && hasCompactOverlay) {
+        return {
+            kind: 'compact',
+            envName,
+            files: [compactBase, compactOverlay],
+            missingFiles: [],
+            errors: [],
+        };
+    }
+    if (hasCompactBase || hasCompactOverlay) {
+        const errors = [];
+        const missingFiles = [];
+        if (!hasCompactBase) {
+            missingFiles.push(compactBase);
+            errors.push(`Missing compact compose base: ${compactBase}`);
+        }
+        if (!hasCompactOverlay) {
+            missingFiles.push(compactOverlay);
+            errors.push(compactOverlayError(envName, compactOverlay));
+        }
+        return { kind: 'missing', files: [], missingFiles, errors };
+    }
+    const odooVersions = uniqueStrings(options.odooVersions);
+    const invalidOdooVersions = odooVersions.filter((version) => !isValidOdooVersion(version));
+    if (invalidOdooVersions.length > 0) {
+        return {
+            kind: 'missing',
+            files: [],
+            missingFiles: [],
+            errors: invalidOdooVersions.map((version) => `Invalid Odoo version for compose file: ${version}`),
+        };
+    }
+    const legacyFiles = odooVersions.map((version) => `docker-compose_${version}.yml`);
+    const missingLegacyFiles = [];
+    for (const file of legacyFiles) {
+        if (!(await exists(join(target, file)))) {
+            missingLegacyFiles.push(file);
+        }
+    }
+    if (legacyFiles.length > 0 && missingLegacyFiles.length === 0) {
+        return { kind: 'legacy', files: legacyFiles, missingFiles: [], errors: [] };
+    }
+    return {
+        kind: 'missing',
+        files: [],
+        missingFiles: missingLegacyFiles,
+        errors: legacyFiles.length > 0
+            ? missingLegacyFiles.map((file) => `Missing compose file: ${file}`)
+            : ['Missing compose layout: expected compose.yaml with compose/dev.yaml or a versioned docker-compose file'],
+    };
+}