@wpmoo/toolkit 0.9.22 → 0.9.24

package/dist/cli.js

@@ -20,7 +20,8 @@ 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, removeModuleFromSourceRepo, } from './module-actions.js';
+import { addModuleToSourceRepo, listModulesInEnvironment, removeModuleFromSourceRepo, } from './module-actions.js';
+import { resolveModuleTarget } from './module-target-resolver.js';
 import { supportedOdooVersions } from './odoo-versions.js';
 import { renderRepositorySetupNote } from './prompt-copy.js';
 import { promptRepositoryUrl } from './prompt-repositories.js';
@@ -38,7 +39,7 @@ import { confirmPrompt, introPrompt, isPromptCancel, notePrompt, outroPrompt, se
 import { renderBanner } from './templates.js';
 import { checkForUpdate, isUpdateCheckSkipped, restartCli } from './update-check.js';
 import { packageName, packageVersion, renderVersion, renderVersionTag } from './version.js';
-import { environmentStatusJson, getEnvironmentStatus, renderEnvironmentStatusForTarget, renderEnvironmentStatusSummary, } from './status.js';
+import { environmentStatusJson, getEnvironmentStatus, environmentBannerSummaryLine, renderEnvironmentStatusForTarget, } 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';
@@ -184,27 +185,16 @@ function validateRepoName(value) {
 function startupVersionLine(latestVersion) {
     return `v${packageVersion()}${latestVersion ? ` -> v${latestVersion} available` : ''}`;
 }
-function pluralize(count, singular, plural) {
-    return `${count} ${count === 1 ? singular : plural}`;
-}
-function renderStartupEnvironmentLine(status) {
-    if (status.kind !== 'environment') {
-        return `Environment: ${renderEnvironmentStatusSummary(status)}`;
-    }
-    const issueCount = status.composeErrors.length + status.invalidSourceRepoPaths.length + status.missingCoreFiles.length;
-    const issueSuffix = issueCount > 0 ? ` · ${pluralize(issueCount, 'issue', 'issues')}` : '';
-    return [
-        `Environment: Odoo ${status.odooVersion}`,
-        pluralize(status.sourceRepoCount, 'repo', 'repos'),
-        pluralize(status.moduleCandidateCount, 'module', 'modules'),
-    ].join(' · ') + issueSuffix;
-}
 function renderStartupBanner(details, latestVersion) {
     const versionLine = startupVersionLine(latestVersion);
     return renderBanner(details?.(versionLine), details ? { version: versionLine } : undefined);
 }
 function renderCockpitStatusLines(status, serviceStatus, lastStatus) {
-    return [renderStartupEnvironmentLine(status), renderServiceRuntimeStatusLine(serviceStatus), lastStatus];
+    return [
+        environmentBannerSummaryLine(status),
+        renderServiceRuntimeStatusLine(serviceStatus),
+        lastStatus,
+    ];
 }
 function renderLastCommandStatus(command) {
     return `Last: ${command.label} ✓ completed`;
@@ -1120,6 +1110,46 @@ function dailyActionSelectedLabel(command, argv) {
     }
     return undefined;
 }
+function dailyActionModuleArgIndex(command) {
+    return ['install', 'update', 'test', 'pot'].includes(command) ? 0 : undefined;
+}
+function moduleTargetLabel(module) {
+    return `${module.moduleName} (${module.sourceType}/${module.repoPath})`;
+}
+function moduleTargetResolutionError(resolution) {
+    const candidates = resolution.candidates.map(moduleTargetLabel).join(', ');
+    if (resolution.kind === 'ambiguous') {
+        return new Error(`Ambiguous module target "${resolution.query}": ${candidates}.`);
+    }
+    return new Error(candidates
+        ? `No module matches "${resolution.query}". Did you mean: ${candidates}?`
+        : `No module matches "${resolution.query}".`);
+}
+async function resolveDailyActionModuleTargets(command, argv, cwd) {
+    const moduleArgIndex = dailyActionModuleArgIndex(command);
+    if (moduleArgIndex === undefined) {
+        return [...argv];
+    }
+    const moduleArg = argv[moduleArgIndex];
+    if (!moduleArg || moduleArg.startsWith('-')) {
+        return [...argv];
+    }
+    const modules = await listModulesInEnvironment(cwd);
+    if (modules.length === 0) {
+        return [...argv];
+    }
+    const resolvedModuleNames = moduleArg.split(',').map((query) => {
+        const trimmedQuery = query.trim();
+        const resolution = resolveModuleTarget(trimmedQuery, modules);
+        if (resolution.kind !== 'exact') {
+            throw moduleTargetResolutionError(resolution);
+        }
+        return resolution.module.moduleName;
+    });
+    const resolvedArgv = [...argv];
+    resolvedArgv[moduleArgIndex] = resolvedModuleNames.join(',');
+    return resolvedArgv;
+}
 async function selectDatabaseArg(cwd, message, fallback, options = {}) {
     const databaseResult = normalizeDatabaseListResult(await listEnvironmentDatabases(cwd, options));
     const databases = databaseResult.databases;
@@ -1596,7 +1626,7 @@ export async function runCli(cliArgv = process.argv.slice(2), cwd = process.cwd(
     }
     if (isDailyActionCommand(route.command)) {
         console.log(renderBanner());
-        await runDailyAction(route.command, route.argv, cwd);
+        await runDailyAction(route.command, await resolveDailyActionModuleTargets(route.command, route.argv, cwd), cwd);
         return;
     }
     const options = optionsFromArgs(route.argv);

package/dist/cockpit/command-registry.js

@@ -29,41 +29,40 @@ function internalCommand(id, category, label, description, 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('start', 'services', 'Start services', 'Start Odoo services.', ['up', 'compose up']),
+    dailyCommand('stop', 'services', 'Stop services', 'Stop Odoo services.', ['down', 'compose down']),
+    dailyCommand('restart', 'services', 'Restart services', 'Restart Odoo services.', ['reload']),
+    dailyCommand('logs', 'services', 'View logs', 'Tail service logs.', ['log', 'tail']),
+    dailyCommand('shell', 'services', 'Open shell', 'Open a service shell.', ['bash', 'terminal']),
     internalCommand('list-modules', 'modules', 'List modules', 'Browse detected Odoo modules by source category.', [
         'modules list',
         'browse modules',
+        '/module',
+        'module',
     ]),
-    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 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']),
-    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']),
+    dailyCommand('install', 'modules', 'Install module', 'Install modules in the database.', ['install module', 'module']),
+    dailyCommand('update', 'modules', 'Update module', 'Update modules in the database.', ['upgrade', 'module']),
+    dailyCommand('test', 'modules', 'Run tests', 'Run tests for selected modules.', ['tests', 'pytest', 'module']),
+    dailyCommand('lint', 'modules', 'Run environment lint', 'Run environment lint checks.', ['check', 'quality']),
+    dailyCommand('pot', 'modules', 'Generate POT', 'Generate module translation templates.', ['translation', 'i18n']),
+    dailyCommand('psql', 'database', 'Open psql', 'Open PostgreSQL prompt.', ['postgres', 'sql', '/db']),
+    dailyCommand('snapshot', 'database', 'Create snapshot', 'Create a database snapshot.', ['backup', 'dump', '/snapshot']),
+    dailyCommand('restore-snapshot', 'database', 'Restore snapshot', 'Restore a named snapshot.', ['restore', 'snapshot restore']),
+    dailyCommand('resetdb', 'database', 'Reset database', 'Reset the 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.', [
+    internalCommand('doctor', 'diagnostics', 'Run doctor', 'Run environment diagnostics.', ['diagnose', 'health']),
+    internalCommand('add-repo', 'repositories', 'Add source repo', 'Add a source repository.', [
         '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']),
+    internalCommand('remove-repo', 'repositories', 'Remove source repo', 'Remove a source repository.', ['repository remove', 'source remove']),
+    internalCommand('add-module', 'modules', 'Add module', 'Add a module to a source repository.', ['module add']),
+    internalCommand('remove-module', 'modules', 'Remove module', 'Remove a module from a source repository.', ['module remove']),
+    internalCommand('safe-reset', 'maintenance', 'Safe reset environment', 'Refresh generated files only.', ['reset', 'refresh', '/safe']),
+    internalCommand('exit', 'maintenance', 'Exit', 'Close the command palette.', ['quit', 'back']),
 ];
 const defaultCommandIds = new Set(['start', 'logs', 'test', 'status', 'doctor', 'exit']);
 export function normalizeCockpitSearchTerm(term) {

package/dist/cockpit/menu.js

@@ -33,6 +33,21 @@ function categoryHeading(category) {
 function commandName(command) {
     return `${rgb(226, 184, 96, ` ${command.label.padEnd(topLevelCommandLabelWidth)}`)}${dim(`  ${command.description}`)}`;
 }
+const disabledReasonNextStep = {
+    'No modules found.': 'Next: choose "Add module" first.',
+    'Services stopped.': 'Next: choose "Start services" first.',
+    'Already running.': 'Next: choose "Stop services" or "Restart services".',
+    'Docker not running.': 'Next: start Docker, then choose "Start services".',
+    'No source repos found.': 'Next: choose "Add source repo" first.',
+};
+function disabledError(reason) {
+    const base = 'This option is disabled and cannot be selected.';
+    if (!reason) {
+        return base;
+    }
+    const nextStep = disabledReasonNextStep[reason];
+    return nextStep ? `${base}\nReason: ${reason}\n${nextStep}` : `${base}\nReason: ${reason}`;
+}
 function serviceDisabledReason(command, serviceStatus) {
     if (command.category !== 'services' || !serviceStatus)
         return undefined;
@@ -56,9 +71,6 @@ function disabledReason(command, serviceStatus, moduleCount, sourceRepoCount) {
         moduleDisabledReason(command, moduleCount) ??
         sourceRepoDisabledReason(command, sourceRepoCount));
 }
-function disabledError() {
-    return 'This option is disabled and cannot be selected.';
-}
 function commandDisabledValue(reason) {
     if (!reason) {
         return undefined;
@@ -131,7 +143,7 @@ export async function selectCockpitTopLevelMenu(options = {}) {
         pageSize: topLevelPageSize(choices.length),
         loop: false,
         hideMessage: true,
-        disabledError: disabledError(),
+        disabledError,
         navigationWarning: options.navigationWarning,
         escapeBehavior: 'ignore',
     });

package/dist/module-manifest.js

@@ -0,0 +1,298 @@
+function createParserState(content) {
+    return {
+        content,
+        parser: {
+            index: 0,
+            line: 1,
+            column: 1,
+        },
+    };
+}
+function makeError(state, message) {
+    return { message, index: state.index, line: state.line, column: state.column };
+}
+function throwParseError(state, message) {
+    const { line, column } = makeError(state, message);
+    throw new Error(`Parse error at ${line}:${column}: ${message}`);
+}
+function isWhitespace(char) {
+    return /\s/u.test(char);
+}
+function peek(state, content, offset = 0) {
+    return content[state.index + offset] ?? '';
+}
+function consumeChar(state, content) {
+    const char = peek(state, content);
+    if (char === '') {
+        return '';
+    }
+    state.index += 1;
+    if (char === '\n') {
+        state.line += 1;
+        state.column = 1;
+    }
+    else {
+        state.column += 1;
+    }
+    return char;
+}
+function skipWhitespaceAndComments(state, content) {
+    while (state.index < content.length) {
+        const char = peek(state, content);
+        if (isWhitespace(char)) {
+            consumeChar(state, content);
+            continue;
+        }
+        if (char === '#') {
+            while (state.index < content.length && peek(state, content) !== '\n') {
+                consumeChar(state, content);
+            }
+            continue;
+        }
+        break;
+    }
+}
+function parseString(state, content) {
+    const quote = consumeChar(state, content);
+    const chars = [];
+    while (state.index < content.length) {
+        const char = consumeChar(state, content);
+        if (char === '\\') {
+            const escaped = consumeChar(state, content);
+            if (!escaped) {
+                throwParseError(state, 'unterminated string escape');
+            }
+            if (escaped === 'n') {
+                chars.push('\n');
+            }
+            else if (escaped === 'r') {
+                chars.push('\r');
+            }
+            else if (escaped === 't') {
+                chars.push('\t');
+            }
+            else if (escaped === quote) {
+                chars.push(quote);
+            }
+            else if (escaped === '\\') {
+                chars.push('\\');
+            }
+            else {
+                chars.push(escaped);
+            }
+            continue;
+        }
+        if (char === quote) {
+            return chars.join('');
+        }
+        if (char === '\n' || char === '\r') {
+            throwParseError(state, 'unterminated string literal');
+        }
+        chars.push(char);
+    }
+    throwParseError(state, 'unterminated string literal');
+}
+function parseIdentifier(state, content) {
+    const chars = [];
+    const start = state.index;
+    const first = peek(state, content);
+    if (!/[A-Za-z_]/u.test(first)) {
+        throwParseError(state, 'expected identifier');
+    }
+    chars.push(consumeChar(state, content));
+    while (state.index < content.length) {
+        const char = peek(state, content);
+        if (/[A-Za-z0-9_]/u.test(char)) {
+            chars.push(consumeChar(state, content));
+            continue;
+        }
+        break;
+    }
+    if (chars.length === 0) {
+        throwParseError(state, 'expected identifier at ' + start);
+    }
+    return chars.join('');
+}
+function parseNumber(state, content) {
+    const chars = [];
+    if (peek(state, content) === '-') {
+        chars.push(consumeChar(state, content));
+    }
+    while (/[0-9]/u.test(peek(state, content))) {
+        chars.push(consumeChar(state, content));
+    }
+    if (peek(state, content) === '.') {
+        chars.push(consumeChar(state, content));
+        if (!/[0-9]/u.test(peek(state, content))) {
+            throwParseError(state, 'invalid numeric literal');
+        }
+        while (/[0-9]/u.test(peek(state, content))) {
+            chars.push(consumeChar(state, content));
+        }
+    }
+    const value = Number(chars.join(''));
+    if (!Number.isFinite(value)) {
+        throwParseError(state, 'invalid numeric literal');
+    }
+    return value;
+}
+function parseValue(state, content) {
+    skipWhitespaceAndComments(state, content);
+    const char = peek(state, content);
+    if (char === '{') {
+        return parseObject(state, content);
+    }
+    if (char === '[') {
+        return parseList(state, content);
+    }
+    if (char === '"' || char === "'") {
+        return parseString(state, content);
+    }
+    if (char === '-' || /[0-9]/u.test(char)) {
+        return parseNumber(state, content);
+    }
+    if (/[A-Za-z_]/u.test(char)) {
+        const identifier = parseIdentifier(state, content);
+        if (identifier === 'True')
+            return true;
+        if (identifier === 'False')
+            return false;
+        if (identifier === 'None')
+            return undefined;
+        throwParseError(state, `unsupported identifier '${identifier}'`);
+    }
+    throwParseError(state, `unexpected character '${char || 'EOF'}'`);
+}
+function expectChar(state, content, expected) {
+    skipWhitespaceAndComments(state, content);
+    const char = consumeChar(state, content);
+    if (char !== expected) {
+        throwParseError(state, `expected '${expected}' but found '${char || 'EOF'}'`);
+    }
+}
+function parseList(state, content) {
+    expectChar(state, content, '[');
+    const values = [];
+    skipWhitespaceAndComments(state, content);
+    if (peek(state, content) === ']') {
+        consumeChar(state, content);
+        return values;
+    }
+    while (state.index < content.length) {
+        const value = parseValue(state, content);
+        values.push(value);
+        skipWhitespaceAndComments(state, content);
+        if (peek(state, content) === ',') {
+            consumeChar(state, content);
+            skipWhitespaceAndComments(state, content);
+            if (peek(state, content) === ']') {
+                consumeChar(state, content);
+                return values;
+            }
+            continue;
+        }
+        if (peek(state, content) === ']') {
+            consumeChar(state, content);
+            return values;
+        }
+        throwParseError(state, "expected ',' or ']'");
+    }
+    throwParseError(state, 'unterminated list literal');
+}
+function parseObject(state, content) {
+    expectChar(state, content, '{');
+    const manifest = {};
+    skipWhitespaceAndComments(state, content);
+    if (peek(state, content) === '}') {
+        consumeChar(state, content);
+        return manifest;
+    }
+    while (state.index < content.length) {
+        skipWhitespaceAndComments(state, content);
+        const key = parseManifestKey(state, content);
+        skipWhitespaceAndComments(state, content);
+        expectChar(state, content, ':');
+        const value = parseValue(state, content);
+        manifest[key] = value;
+        skipWhitespaceAndComments(state, content);
+        if (peek(state, content) === ',') {
+            consumeChar(state, content);
+            skipWhitespaceAndComments(state, content);
+            if (peek(state, content) === '}') {
+                consumeChar(state, content);
+                return manifest;
+            }
+            continue;
+        }
+        if (peek(state, content) === '}') {
+            consumeChar(state, content);
+            return manifest;
+        }
+        throwParseError(state, "expected ',' or '}'");
+    }
+    throwParseError(state, 'unterminated object literal');
+}
+function parseManifestKey(state, content) {
+    skipWhitespaceAndComments(state, content);
+    const char = peek(state, content);
+    if (char !== '"' && char !== "'") {
+        throwParseError(state, 'manifest keys must be quoted');
+    }
+    return parseString(state, content);
+}
+function validateManifest(manifest) {
+    if (manifest.name !== undefined && typeof manifest.name !== 'string') {
+        throw new Error('invalid manifest: name must be a string');
+    }
+    if (manifest.version !== undefined && typeof manifest.version !== 'string') {
+        throw new Error('invalid manifest: version must be a string');
+    }
+    if (manifest.license !== undefined && typeof manifest.license !== 'string') {
+        throw new Error('invalid manifest: license must be a string');
+    }
+    if (manifest.application !== undefined && typeof manifest.application !== 'boolean') {
+        throw new Error('invalid manifest: application must be a boolean');
+    }
+    if (manifest.installable !== undefined && typeof manifest.installable !== 'boolean') {
+        throw new Error('invalid manifest: installable must be a boolean');
+    }
+    if (manifest.depends !== undefined && !Array.isArray(manifest.depends)) {
+        throw new Error('invalid manifest: depends must be a list of strings');
+    }
+    if (manifest.data !== undefined && !Array.isArray(manifest.data)) {
+        throw new Error('invalid manifest: data must be a list of strings');
+    }
+    if (Array.isArray(manifest.depends) && !manifest.depends.every((entry) => typeof entry === 'string')) {
+        throw new Error('invalid manifest: depends must be a list of strings');
+    }
+    if (Array.isArray(manifest.data) && !manifest.data.every((entry) => typeof entry === 'string')) {
+        throw new Error('invalid manifest: data must be a list of strings');
+    }
+    return manifest;
+}
+export function parseOdooManifest(content) {
+    try {
+        const { content: sourceContent, parser } = createParserState(content);
+        const manifest = parseValue(parser, sourceContent);
+        if (!manifest || typeof manifest !== 'object' || Array.isArray(manifest)) {
+            return { ok: false, error: 'Invalid manifest: top-level value must be a dictionary literal' };
+        }
+        skipWhitespaceAndComments(parser, sourceContent);
+        if (parser.index < sourceContent.length) {
+            return {
+                ok: false,
+                error: `Invalid manifest: trailing content after top-level object at line ${parser.line}, column ${parser.column}`,
+            };
+        }
+        return {
+            ok: true,
+            manifest: validateManifest(manifest),
+        };
+    }
+    catch (error) {
+        if (error instanceof Error) {
+            return { ok: false, error: error.message };
+        }
+        return { ok: false, error: 'Invalid manifest content' };
+    }
+}

package/dist/module-quality.js

@@ -1,5 +1,6 @@
 import { readdir, readFile, stat } from 'node:fs/promises';
 import { basename, join, relative } from 'node:path';
+import { parseOdooManifest } from './module-manifest.js';
 export function emptyModuleQualitySummary() {
     return {
         totalModules: 0,
@@ -11,7 +12,8 @@ export function emptyModuleQualitySummary() {
     };
 }
 export function isInstallableManifest(content) {
-    return /["']installable["']\s*:\s*(?:True|true)\b/u.test(content);
+    const parsed = parseOdooManifest(content);
+    return parsed.ok && parsed.manifest.installable !== false;
 }
 export function hasActionableMenuXml(content, moduleName) {
     const actionId = `action_${moduleName}`;
@@ -31,32 +33,144 @@ async function readMenusXml(modulePath) {
         return [];
     }
 }
+async function readPythonModelFiles(modulePath) {
+    try {
+        const entries = await readdir(join(modulePath, 'models'), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.py') && entry.name !== '__init__.py')
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function readViewXmlFiles(modulePath) {
+    try {
+        const entries = await readdir(join(modulePath, 'views'), { withFileTypes: true });
+        return entries
+            .filter((entry) => entry.isFile() && entry.name.endsWith('.xml') && !entry.name.endsWith('_menus.xml'))
+            .map((entry) => entry.name);
+    }
+    catch {
+        return [];
+    }
+}
+async function directoryExists(path) {
+    try {
+        return (await stat(path)).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}
+async function fileExists(path) {
+    try {
+        return (await stat(path)).isFile();
+    }
+    catch {
+        return false;
+    }
+}
+async function readOptionalFile(path) {
+    try {
+        return await readFile(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+}
+function moduleIssue(moduleName, path, issue) {
+    return { moduleName, path, issue };
+}
+function manifestData(manifest) {
+    return Array.isArray(manifest?.data) ? manifest.data : [];
+}
+function manifestDepends(manifest) {
+    return Array.isArray(manifest?.depends) ? manifest.depends : [];
+}
+function dataIncludesAccessCsv(data) {
+    return data.includes('security/ir.model.access.csv');
+}
+function dataIncludesViewXml(data) {
+    return data.some((entry) => entry.startsWith('views/') && entry.endsWith('.xml') && !entry.endsWith('_menus.xml'));
+}
+function moduleHasOdooStructures(modelFiles, viewFiles, menuXml, data) {
+    return (modelFiles.length > 0 ||
+        viewFiles.length > 0 ||
+        menuXml.length > 0 ||
+        data.some((entry) => entry.startsWith('security/') || entry.startsWith('views/')));
+}
+function pythonImportPresent(content, importName) {
+    if (!content)
+        return false;
+    return new RegExp(`^\\s*from\\s+\\.\\s+import\\s+.*\\b${importName}\\b`, 'mu').test(content);
+}
 export async function analyzeModuleDirectory(modulePath, moduleName = basename(modulePath), relativePath = modulePath) {
     const issues = [];
+    let manifest;
     let installable = false;
-    try {
-        installable = isInstallableManifest(await readFile(join(modulePath, '__manifest__.py'), 'utf8'));
+    const manifestContent = await readOptionalFile(join(modulePath, '__manifest__.py'));
+    if (!manifestContent) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing __manifest__.py'));
     }
-    catch {
-        installable = false;
+    else {
+        const parsedManifest = parseOdooManifest(manifestContent);
+        if (parsedManifest.ok) {
+            manifest = parsedManifest.manifest;
+            installable = manifest.installable !== false;
+        }
+        else {
+            issues.push(moduleIssue(moduleName, relativePath, `invalid manifest syntax: ${parsedManifest.error}`));
+        }
     }
-    if (!installable) {
-        issues.push({
-            moduleName,
-            path: relativePath,
-            issue: 'missing installable=True in __manifest__.py',
-        });
+    if (manifest?.installable === false) {
+        issues.push(moduleIssue(moduleName, relativePath, 'installable is false in __manifest__.py'));
+    }
+    if (manifest && !manifest.license) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing license in __manifest__.py'));
+    }
+    if (manifest && manifest.depends === undefined) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing depends in __manifest__.py'));
     }
     const menuXml = await readMenusXml(modulePath);
+    const modelFiles = await readPythonModelFiles(modulePath);
+    const viewFiles = await readViewXmlFiles(modulePath);
+    const depends = manifestDepends(manifest);
+    const data = manifestData(manifest);
+    const hasOdooStructures = moduleHasOdooStructures(modelFiles, viewFiles, menuXml, data);
+    if (hasOdooStructures && !depends.includes('base')) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing base dependency for model-based module'));
+    }
+    if (modelFiles.length > 0) {
+        const rootInit = await readOptionalFile(join(modulePath, '__init__.py'));
+        if (!pythonImportPresent(rootInit, 'models')) {
+            issues.push(moduleIssue(moduleName, relativePath, 'missing __init__.py models import'));
+        }
+        const modelsInit = await readOptionalFile(join(modulePath, 'models/__init__.py'));
+        const missingModelImport = modelFiles
+            .map((fileName) => fileName.replace(/\.py$/u, ''))
+            .some((modelImport) => !pythonImportPresent(modelsInit, modelImport));
+        if (missingModelImport) {
+            issues.push(moduleIssue(moduleName, relativePath, 'missing models/__init__.py model import'));
+        }
+        if (!(await fileExists(join(modulePath, 'security/ir.model.access.csv')))) {
+            issues.push(moduleIssue(moduleName, relativePath, 'missing security/ir.model.access.csv'));
+        }
+    }
+    if (hasOdooStructures && !dataIncludesAccessCsv(data)) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing security/ir.model.access.csv in manifest data'));
+    }
+    if (hasOdooStructures && viewFiles.length === 0 && !dataIncludesViewXml(data)) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing views XML under views/'));
+    }
+    if (!(await directoryExists(join(modulePath, 'tests')))) {
+        issues.push(moduleIssue(moduleName, relativePath, 'missing tests directory'));
+    }
     const hasMenuAction = menuXml.some((content) => hasActionableMenuXml(content, moduleName));
     if (!hasMenuAction) {
-        issues.push({
-            moduleName,
-            path: relativePath,
-            issue: 'missing actionable menu XML',
-        });
+        issues.push(moduleIssue(moduleName, relativePath, 'missing actionable menu XML'));
     }
-    return { moduleName, relativePath, installable, hasMenuAction, issues };
+    return { moduleName, relativePath, installable, hasMenuAction, depends, ...(manifest ? { manifest } : {}), issues };
 }
 export function addModuleQualityResult(summary, result) {
     return {
@@ -69,15 +183,86 @@ export function addModuleQualityResult(summary, result) {
     };
 }
 export function mergeModuleQualitySummaries(left, right) {
+    const missingDependencies = [
+        ...(left.dependencyGraph?.missingDependencies ?? []),
+        ...(right.dependencyGraph?.missingDependencies ?? []),
+    ];
+    const dependencies = [...(left.dependencyGraph?.dependencies ?? []), ...(right.dependencyGraph?.dependencies ?? [])];
+    const cycles = [...(left.dependencyGraph?.cycles ?? []), ...(right.dependencyGraph?.cycles ?? [])];
+    const dependencyGraph = dependencies.length > 0 || missingDependencies.length > 0 || cycles.length > 0
+        ? { dependencies, missingDependencies, cycles }
+        : undefined;
     return {
         totalModules: left.totalModules + right.totalModules,
         installableModules: left.installableModules + right.installableModules,
         nonInstallableModules: left.nonInstallableModules + right.nonInstallableModules,
         modulesWithMenuActions: left.modulesWithMenuActions + right.modulesWithMenuActions,
         modulesMissingMenuActions: left.modulesMissingMenuActions + right.modulesMissingMenuActions,
+        ...(dependencyGraph ? { dependencyGraph } : {}),
         issues: [...left.issues, ...right.issues],
     };
 }
+function firstToken(value) {
+    return value.split(/[_-]+/u, 1)[0] ?? value;
+}
+function looksLikeMissingLocalDependency(moduleName, dependency) {
+    if (dependency === 'base')
+        return false;
+    const namespace = firstToken(moduleName);
+    const generatedOrProjectNamespaces = new Set(['custom', 'demo', 'module', 'odoo', 'wpmoo']);
+    return Boolean(namespace) && generatedOrProjectNamespaces.has(namespace) && dependency.startsWith(`${namespace}_`);
+}
+function findCycleFrom(start, current, graph, path = [start]) {
+    for (const dependency of graph.get(current) ?? []) {
+        if (dependency === start) {
+            return [...path, start];
+        }
+        if (path.includes(dependency)) {
+            continue;
+        }
+        const found = findCycleFrom(start, dependency, graph, [...path, dependency]);
+        if (found)
+            return found;
+    }
+    return undefined;
+}
+function moduleDependencyGraph(results) {
+    const byName = new Map(results.map((result) => [result.moduleName, result]));
+    const localModuleNames = new Set(byName.keys());
+    const dependencyEdges = new Map();
+    const missingDependencies = [];
+    const dependencies = [];
+    const issues = [];
+    for (const result of results) {
+        const localDependencies = result.depends.filter((dependency) => localModuleNames.has(dependency));
+        dependencyEdges.set(result.moduleName, localDependencies);
+        for (const dependency of result.depends) {
+            if (localModuleNames.has(dependency)) {
+                dependencies.push({ moduleName: result.moduleName, dependency, kind: 'local' });
+                continue;
+            }
+            if (looksLikeMissingLocalDependency(result.moduleName, dependency)) {
+                dependencies.push({ moduleName: result.moduleName, dependency, kind: 'unresolved' });
+                missingDependencies.push({ moduleName: result.moduleName, dependency });
+                issues.push(moduleIssue(result.moduleName, result.relativePath, `missing local dependency ${dependency}`));
+                continue;
+            }
+            dependencies.push({ moduleName: result.moduleName, dependency, kind: 'external' });
+        }
+    }
+    const cycles = [];
+    for (const moduleName of localModuleNames) {
+        const cycle = findCycleFrom(moduleName, moduleName, dependencyEdges);
+        if (cycle) {
+            cycles.push(cycle);
+            const result = byName.get(moduleName);
+            if (result) {
+                issues.push(moduleIssue(moduleName, result.relativePath, `dependency cycle detected: ${cycle.join(' -> ')}`));
+            }
+        }
+    }
+    return { graph: { dependencies, missingDependencies, cycles }, issues };
+}
 export async function scanModuleQuality(root, target) {
     try {
         const rootStat = await stat(root);
@@ -89,6 +274,7 @@ export async function scanModuleQuality(root, target) {
     }
     let summary = emptyModuleQualitySummary();
     const stack = [root];
+    const results = [];
     while (stack.length > 0) {
         const current = stack.pop();
         if (!current)
@@ -104,8 +290,16 @@ export async function scanModuleQuality(root, target) {
             }
         }
         if (hasManifest) {
-            summary = addModuleQualityResult(summary, await analyzeModuleDirectory(current, basename(current), relative(target, current)));
+            const result = await analyzeModuleDirectory(current, basename(current), relative(target, current));
+            results.push(result);
+            summary = addModuleQualityResult(summary, result);
         }
     }
-    return summary;
+    const dependencyGraph = moduleDependencyGraph(results);
+    const hasDependencyGraphIssues = dependencyGraph.graph.missingDependencies.length > 0 || dependencyGraph.graph.cycles.length > 0;
+    return {
+        ...summary,
+        ...(hasDependencyGraphIssues ? { dependencyGraph: dependencyGraph.graph } : {}),
+        issues: [...summary.issues, ...dependencyGraph.issues],
+    };
 }

package/dist/module-target-resolver.js

@@ -0,0 +1,91 @@
+function normalizeQuery(query) {
+    return query.trim().toLowerCase();
+}
+function moduleMatchesExact(query, module) {
+    return module.moduleName.toLowerCase() === query;
+}
+function moduleMatchesPartial(query, module) {
+    return module.moduleName.toLowerCase().includes(query);
+}
+function tokenizeModuleName(moduleName) {
+    return moduleName.toLowerCase().split(/[_-]+/g).filter(Boolean);
+}
+function levenshteinDistance(a, b) {
+    if (a === b) {
+        return 0;
+    }
+    if (!a) {
+        return b.length;
+    }
+    if (!b) {
+        return a.length;
+    }
+    const rows = a.length + 1;
+    const cols = b.length + 1;
+    const matrix = Array.from({ length: rows }, (_, rowIndex) => {
+        const row = new Array(cols);
+        if (rowIndex === 0) {
+            for (let col = 0; col < cols; col += 1) {
+                row[col] = col;
+            }
+        }
+        else {
+            row[0] = rowIndex;
+        }
+        return row;
+    });
+    for (let row = 1; row < rows; row += 1) {
+        for (let col = 1; col < cols; col += 1) {
+            const cost = a[row - 1] === b[col - 1] ? 0 : 1;
+            const substitutions = matrix[row - 1][col - 1] + cost;
+            const insertions = matrix[row][col - 1] + 1;
+            const deletions = matrix[row - 1][col] + 1;
+            matrix[row][col] = Math.min(substitutions, insertions, deletions);
+        }
+    }
+    return matrix[a.length][b.length];
+}
+function nearestCandidates(query, modules, maxItems = 3) {
+    const queryNormalized = query;
+    const scoredModules = modules
+        .map((module) => {
+        const fullMatchDistance = levenshteinDistance(module.moduleName.toLowerCase(), queryNormalized);
+        const tokenMatchDistance = tokenizeModuleName(module.moduleName).reduce((best, token) => Math.min(best, levenshteinDistance(token, queryNormalized)), Number.POSITIVE_INFINITY);
+        const distance = Math.min(fullMatchDistance, tokenMatchDistance);
+        return { module, distance };
+    })
+        .filter((entry) => entry.distance <= 4);
+    const scoredWithIndex = scoredModules.map((entry, index) => ({ ...entry, index }));
+    scoredWithIndex.sort((left, right) => {
+        if (left.distance !== right.distance) {
+            return left.distance - right.distance;
+        }
+        return left.index - right.index;
+    });
+    const topDistance = scoredWithIndex[0]?.distance ?? Number.POSITIVE_INFINITY;
+    return scoredWithIndex
+        .filter((entry) => entry.distance <= topDistance + 1)
+        .slice(0, maxItems)
+        .map((entry) => entry.module);
+}
+export function resolveModuleTarget(query, modules) {
+    const normalizedQuery = normalizeQuery(query);
+    if (!normalizedQuery) {
+        return { kind: 'no-match', query, candidates: [] };
+    }
+    const exactMatches = modules.filter((module) => moduleMatchesExact(normalizedQuery, module));
+    if (exactMatches.length === 1) {
+        return { kind: 'exact', query, module: exactMatches[0] };
+    }
+    if (exactMatches.length > 1) {
+        return { kind: 'ambiguous', query, candidates: exactMatches };
+    }
+    const partialMatches = normalizedQuery.length >= 3 ? modules.filter((module) => moduleMatchesPartial(normalizedQuery, module)) : [];
+    if (partialMatches.length === 1) {
+        return { kind: 'exact', query, module: partialMatches[0] };
+    }
+    if (partialMatches.length > 1) {
+        return { kind: 'ambiguous', query, candidates: partialMatches };
+    }
+    return { kind: 'no-match', query, candidates: nearestCandidates(normalizedQuery, modules) };
+}

package/dist/prompts/index.js

@@ -171,10 +171,13 @@ function hiddenSelectTheme(disabledError, navigationHelp = 'exit', navigationWar
     };
 }
 function disabledErrorI18n(disabledError, activeReason) {
-    const i18n = { disabledError };
+    const i18n = typeof disabledError === 'string' ? { disabledError } : { disabledError: disabledError(undefined) };
     Object.defineProperty(i18n, 'disabledError', {
         get: () => {
             const reason = activeReason();
+            if (typeof disabledError === 'function') {
+                return disabledError(reason);
+            }
             return reason ? `${disabledError}\nReason: ${reason}` : disabledError;
         },
     });

package/dist/status.js

@@ -5,6 +5,10 @@ import { defaultOdooVersion, markerPath } from './environment.js';
 import { emptyModuleQualitySummary, mergeModuleQualitySummaries, scanModuleQuality, } from './module-quality.js';
 import { isValidPathSegment, validateRepoPath } from './path-validation.js';
 const validSourceTypes = ['private', 'oca', 'external'];
+const summarySeparator = ' \u00B7 ';
+function pluralize(count, singular, plural) {
+    return `${count} ${count === 1 ? singular : plural}`;
+}
 function normalizeSourceType(sourceType) {
     if (typeof sourceType === 'string' && validSourceTypes.includes(sourceType)) {
         return sourceType;
@@ -85,6 +89,18 @@ async function missingCoreFiles(target, odooVersion) {
     missing.push(...composeLayout.missingFiles);
     return { missing, composeFiles: composeLayout.files, composeErrors: composeLayout.errors };
 }
+export function environmentBannerSummaryLine(status) {
+    if (status.kind !== 'environment') {
+        return `Environment: ${summaryText(status)}`;
+    }
+    const issueCount = status.composeErrors.length + status.invalidSourceRepoPaths.length + status.missingCoreFiles.length;
+    const issueSuffix = issueCount > 0 ? `${summarySeparator}${pluralize(issueCount, 'issue', 'issues')}` : '';
+    return [
+        `Environment: Odoo ${status.odooVersion}`,
+        pluralize(status.sourceRepoCount, 'repo', 'repos'),
+        pluralize(status.moduleCandidateCount, 'module', 'modules'),
+    ].join(summarySeparator) + issueSuffix;
+}
 function summaryText(status) {
     if (status.kind === 'no_environment')
         return 'No WPMoo environment detected.';

package/dist/templates.js

@@ -828,7 +828,7 @@ function emptyModuleQuality() {
 }
 
 function manifestIsInstallable(content) {
-  return /["']installable["']\\s*:\\s*(?:True|true)\\b/.test(content);
+  return !/["']installable["']\\s*:\\s*(?:False|false)\\b/.test(content);
 }
 
 function menuXmlHasAction(content, moduleName) {
@@ -867,7 +867,7 @@ async function analyzeModule(modulePath) {
     issues.push({
       moduleName,
       path: moduleRelativePath,
-      issue: 'missing installable=True in __manifest__.py',
+      issue: 'installable is false in __manifest__.py',
     });
   }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpmoo/toolkit",
-  "version": "0.9.22",
+  "version": "0.9.24",
   "description": "WPMoo Toolkit for development, staging, and production lifecycle workflows.",
   "type": "module",
   "repository": {