@wpmoo/toolkit 0.9.23 → 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';
@@ -1109,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;
@@ -1585,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/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/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.23",
+  "version": "0.9.24",
   "description": "WPMoo Toolkit for development, staging, and production lifecycle workflows.",
   "type": "module",
   "repository": {