@wpmoo/toolkit 0.9.29 → 0.9.31

package/dist/help.js

@@ -32,7 +32,7 @@ Usage:
   npx @wpmoo/toolkit update <module[,module]> [db]
   npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode auto|init|update] [--tags <tags>]
   npx @wpmoo/toolkit resetdb [db] [module[,module]]
-  npx @wpmoo/toolkit snapshot [db] [snapshot-name]
+  npx @wpmoo/toolkit snapshot [--list] [db] [snapshot-name]
   npx @wpmoo/toolkit restore-snapshot [--dry-run] <snapshot-name> [db]
   npx @wpmoo/toolkit lint
   npx @wpmoo/toolkit pot <module[,module]> [db] [output]
@@ -87,15 +87,17 @@ Daily actions:
   Use ./moo or npx @wpmoo/toolkit with the same daily action arguments.
 
 Lifecycle command guards:
-  In WPMOO_ENV=stage, install/update require WPMOO_ALLOW_STAGE_LIFECYCLE=1.
-  In WPMOO_ENV=prod, install/update/test require WPMOO_ALLOW_PROD_LIFECYCLE=1.
+  In WPMOO_ENV=stage, install/update/stop/restart require WPMOO_ALLOW_STAGE_LIFECYCLE=1.
+  In WPMOO_ENV=prod, install/update/test/stop/restart require WPMOO_ALLOW_PROD_LIFECYCLE=1.
   resetdb and real restore-snapshot require WPMOO_ALLOW_DESTRUCTIVE=1 in stage/prod.
   restore-snapshot --dry-run remains allowed for preview.
+  Time-bounded local approvals may also be recorded in .wpmoo/approvals.jsonl.
 
 Cockpit:
   Run npx @wpmoo/toolkit inside a generated environment to open the cockpit.
-  Use Command palette / to search slash commands across services, modules, database,
-  diagnostics, repositories, and maintenance categories.
+  Use Command palette / to search slash commands such as /test, /modules,
+  /install-module, /doctor, and /safe-reset.
+  Large module lists switch to searchable selection by module, repo, or source type.
   Direct commands such as npx @wpmoo/toolkit status and npx @wpmoo/toolkit test remain available.
 
 Wizard local-only path:
@@ -140,7 +142,7 @@ Task recipes:
   Run tests:
     npx @wpmoo/toolkit test <module[,module]> [--db <db>] [--mode auto|init|update] [--tags <tags>]
   Safe reset and recover:
-    npx @wpmoo/toolkit snapshot [db] [snapshot-name]
+    npx @wpmoo/toolkit snapshot [--list] [db] [snapshot-name]
     npx @wpmoo/toolkit reset --dry-run
     npx @wpmoo/toolkit reset
     npx @wpmoo/toolkit restore-snapshot --dry-run <snapshot-name> [db]

package/dist/module-actions.js

@@ -41,6 +41,26 @@ function validateSupportedOdooVersion(value) {
 function sourceRepoPath(target, sourceType, repoPath) {
     return pathUnderBase(join(target, `odoo/custom/src/${sourceType}`), repoPath, 'repo path');
 }
+async function readableSourceRepoPath(target, sourceType, repoPath) {
+    const primary = sourceRepoPath(target, sourceType, repoPath);
+    try {
+        await readdir(primary);
+        return primary;
+    }
+    catch {
+        if (sourceType !== 'private') {
+            return primary;
+        }
+    }
+    const legacy = pathUnderBase(join(target, 'odoo/custom/src'), repoPath, 'repo path');
+    try {
+        await readdir(legacy);
+        return legacy;
+    }
+    catch {
+        return primary;
+    }
+}
 function modulePath(target, sourceType, repoPath, moduleName) {
     return pathUnderBase(sourceRepoPath(target, sourceType, repoPath), moduleName, 'module name');
 }
@@ -233,8 +253,12 @@ async function moduleScaffoldChecks(target, sourceType, repoPath, moduleName, in
             id: 'tests',
             label: 'tests',
             ok: (await fileContains(join(destination, 'tests/__init__.py'), `from . import test_${moduleName}`)) &&
-                (await fileContains(join(destination, `tests/test_${moduleName}.py`), '')),
-            details: 'missing generated test file',
+                (await fileContains(join(destination, `tests/test_${moduleName}.py`), 'TransactionCase')) &&
+                (await fileContains(join(destination, `tests/test_${moduleName}.py`), '@tagged("post_install", "-at_install")')) &&
+                (await fileContains(join(destination, `tests/test_${moduleName}.py`), `class Test${moduleClassName(moduleName)}(TransactionCase):`)) &&
+                (await fileContains(join(destination, `tests/test_${moduleName}.py`), 'def test_create_record(self):')) &&
+                (await fileContains(join(destination, `tests/test_${moduleName}.py`), `self.env["${technicalName}"]`)),
+            details: 'missing generated TransactionCase test markers',
         },
     ];
     if (includeRegistration) {
@@ -355,23 +379,20 @@ async function assertModuleCleanBeforeDelete(target, sourceType, repoPath, modul
     const repoRoot = sourceRepoPath(target, sourceType, repoPath);
     try {
         const result = await git.run(repoRoot, ['status', '--short', '--', moduleName]);
-        if (result.stdout.trim() && (await moduleHasCommittedFiles(repoRoot, moduleName, git))) {
-            throw new Error(`Refusing to delete module ${moduleName} because it has dirty git changes in source repo ${repoPath}.`);
+        const status = result.stdout.trimEnd();
+        if (status.trim()) {
+            const hasUntrackedOrStaged = status
+                .split(/\r?\n/u)
+                .some((line) => line.startsWith('??') || /^[A-Z][A-Z ]\s/u.test(line));
+            const reason = hasUntrackedOrStaged ? 'uncommitted git changes' : 'dirty git changes';
+            throw new Error(`Refusing to delete module ${moduleName} because it has ${reason} in source repo ${repoPath}.`);
         }
     }
     catch (error) {
         if (error instanceof Error && error.message.startsWith('Refusing to delete module ')) {
             throw error;
         }
-    }
-}
-async function moduleHasCommittedFiles(repoRoot, moduleName, git) {
-    try {
-        const result = await git.run(repoRoot, ['ls-tree', '-r', '--name-only', 'HEAD', '--', moduleName]);
-        return Boolean(result.stdout.trim());
-    }
-    catch {
-        return false;
+        throw new Error(`Refusing to delete module ${moduleName} because git status could not be verified in source repo ${repoPath}.`);
     }
 }
 export async function addModuleToSourceRepo(options, git = realGit) {
@@ -410,12 +431,13 @@ export async function listModulesInSourceRepo(target, repoPath, sourceType) {
     const safeRepoPath = validateRepoPath(repoPath);
     const resolvedSourceType = normalizeSourceType(sourceType);
     try {
-        const entries = await readdir(sourceRepoPath(target, resolvedSourceType, safeRepoPath), { withFileTypes: true });
+        const repoRoot = await readableSourceRepoPath(target, resolvedSourceType, safeRepoPath);
+        const entries = await readdir(repoRoot, { withFileTypes: true });
         const modules = await Promise.all(entries
             .filter((entry) => entry.isDirectory())
             .map(async (entry) => {
             try {
-                await readFile(join(sourceRepoPath(target, resolvedSourceType, safeRepoPath), entry.name, '__manifest__.py'), 'utf8');
+                await readFile(join(repoRoot, entry.name, '__manifest__.py'), 'utf8');
                 return entry.name;
             }
             catch {
@@ -462,6 +484,19 @@ export async function removeModuleFromSourceRepo(options, git = realGit) {
     const repoPath = validateRepoPath(options.repoPath);
     const moduleName = validateModuleName(options.moduleName);
     const sourceType = normalizeSourceType(options.sourceType);
+    const destination = modulePath(options.target, sourceType, repoPath, moduleName);
+    if (options.dryRun) {
+        return {
+            moduleName,
+            repoPath,
+            sourceType,
+            path: destination,
+            deleteFiles: options.deleteFiles,
+            dryRun: true,
+            ...(options.deleteFiles ? { wouldDeletePath: destination } : {}),
+            summary: `Previewed removal of module ${moduleName} from source repo ${repoPath}.`,
+        };
+    }
     if (options.deleteFiles) {
         await assertModuleCleanBeforeDelete(options.target, sourceType, repoPath, moduleName, git);
     }
@@ -471,7 +506,7 @@ export async function removeModuleFromSourceRepo(options, git = realGit) {
     }
     await updateModuleRegistration(options.target, sourceType, repoPath, moduleName, 'remove');
     if (options.deleteFiles) {
-        await rm(modulePath(options.target, sourceType, repoPath, moduleName), { recursive: true, force: true });
+        await rm(destination, { recursive: true, force: true });
     }
     if (options.stage) {
         if (options.deleteFiles) {
@@ -479,4 +514,14 @@ export async function removeModuleFromSourceRepo(options, git = realGit) {
         }
         await stageAll(git, options.target);
     }
+    return {
+        moduleName,
+        repoPath,
+        sourceType,
+        path: destination,
+        deleteFiles: options.deleteFiles,
+        dryRun: false,
+        ...(options.deleteFiles ? { wouldDeletePath: destination } : {}),
+        summary: `Removed module ${moduleName} from source repo ${repoPath}.`,
+    };
 }

package/dist/module-manifest.js

@@ -262,12 +262,18 @@ function validateManifest(manifest) {
     if (manifest.data !== undefined && !Array.isArray(manifest.data)) {
         throw new Error('invalid manifest: data must be a list of strings');
     }
+    if (manifest.demo !== undefined && !Array.isArray(manifest.demo)) {
+        throw new Error('invalid manifest: demo 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');
     }
+    if (Array.isArray(manifest.demo) && !manifest.demo.every((entry) => typeof entry === 'string')) {
+        throw new Error('invalid manifest: demo must be a list of strings');
+    }
     return manifest;
 }
 export function parseOdooManifest(content) {

package/dist/module-quality.js

@@ -82,9 +82,15 @@ async function readOptionalFile(path) {
 function moduleIssue(moduleName, path, issue) {
     return { moduleName, path, issue };
 }
+function moduleQualityIssue(moduleName, path, issue, severity) {
+    return { moduleName, path, issue, severity };
+}
 function manifestData(manifest) {
     return Array.isArray(manifest?.data) ? manifest.data : [];
 }
+function manifestDemo(manifest) {
+    return Array.isArray(manifest?.demo) ? manifest.demo : [];
+}
 function manifestDepends(manifest) {
     return Array.isArray(manifest?.depends) ? manifest.depends : [];
 }
@@ -105,6 +111,113 @@ function pythonImportPresent(content, importName) {
         return false;
     return new RegExp(`^\\s*from\\s+\\.\\s+import\\s+.*\\b${importName}\\b`, 'mu').test(content);
 }
+function xmlAttributeValues(content, attributeName) {
+    const values = [];
+    const pattern = new RegExp(`\\b${attributeName}=(["'])(.*?)\\1`, 'gsu');
+    let match;
+    while ((match = pattern.exec(content))) {
+        const value = match[2]?.trim();
+        if (value)
+            values.push(value);
+    }
+    return values;
+}
+function declaredActionIds(xmlFiles) {
+    const ids = new Set();
+    for (const content of xmlFiles) {
+        for (const record of content.matchAll(/<record\b[^>]*\bmodel=(["'])ir\.actions\.act_window\1[^>]*>/gsu)) {
+            for (const id of xmlAttributeValues(record[0], 'id')) {
+                ids.add(id);
+            }
+        }
+    }
+    return ids;
+}
+function menuActionReferences(xmlFiles) {
+    const refs = [];
+    for (const content of xmlFiles) {
+        for (const menu of content.matchAll(/<menuitem\b[^>]*>/gsu)) {
+            refs.push(...xmlAttributeValues(menu[0], 'action'));
+        }
+    }
+    return refs;
+}
+function declaredModelIds(modelFileContents) {
+    const modelIds = new Set();
+    for (const content of modelFileContents) {
+        for (const match of content.matchAll(/^\s*_name\s*=\s*["']([^"']+)["']/gmu)) {
+            const modelName = match[1]?.trim();
+            if (modelName) {
+                modelIds.add(`model_${modelName.replace(/\./gu, '_')}`);
+            }
+        }
+    }
+    return modelIds;
+}
+function declaredModelNames(modelFileContents) {
+    const modelNames = new Set();
+    for (const content of modelFileContents) {
+        for (const match of content.matchAll(/^\s*_name\s*=\s*["']([^"']+)["']/gmu)) {
+            const modelName = match[1]?.trim();
+            if (modelName) {
+                modelNames.add(modelName);
+            }
+        }
+        for (const match of content.matchAll(/^\s*_inherit\s*=\s*["']([^"']+)["']/gmu)) {
+            const modelName = match[1]?.trim();
+            if (modelName) {
+                modelNames.add(modelName);
+            }
+        }
+    }
+    return modelNames;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/gu, '\\$&');
+}
+function xmlRecordFieldValues(xmlFiles, recordModel, fieldName) {
+    const values = [];
+    const recordPattern = new RegExp(`<record\\b[^>]*\\bmodel=(["'])${escapeRegExp(recordModel)}\\1[^>]*>(.*?)</record>`, 'gsu');
+    const fieldPattern = new RegExp(`<field\\b[^>]*\\bname=(["'])${escapeRegExp(fieldName)}\\1[^>]*>(.*?)</field>`, 'gsu');
+    for (const content of xmlFiles) {
+        let recordMatch;
+        while ((recordMatch = recordPattern.exec(content))) {
+            const body = recordMatch[2] ?? '';
+            let fieldMatch;
+            while ((fieldMatch = fieldPattern.exec(body))) {
+                const value = fieldMatch[2]?.replace(/<[^>]+>/gu, '').trim();
+                if (value) {
+                    values.push(value);
+                }
+            }
+        }
+    }
+    return values;
+}
+function looksLikePlainModelName(value) {
+    return /^[a-zA-Z_][\w]*(?:\.[a-zA-Z_][\w]*)+$/u.test(value);
+}
+function accessCsvModelIds(content) {
+    if (!content)
+        return [];
+    const lines = content
+        .split(/\r?\n/u)
+        .map((line) => line.trim())
+        .filter((line) => line && !line.startsWith('#'));
+    if (lines.length < 2)
+        return [];
+    const header = lines[0]?.split(',').map((value) => value.trim()) ?? [];
+    const modelColumn = header.findIndex((value) => value === 'model_id:id' || value === 'model_id');
+    if (modelColumn < 0)
+        return [];
+    return lines
+        .slice(1)
+        .map((line) => line.split(',')[modelColumn]?.trim())
+        .filter((value) => Boolean(value));
+}
+async function readModelFileContents(modulePath, modelFiles) {
+    return Promise.all(modelFiles.map(async (fileName) => (await readOptionalFile(join(modulePath, 'models', fileName))) ?? ''));
+}
 export async function analyzeModuleDirectory(modulePath, moduleName = basename(modulePath), relativePath = modulePath) {
     const issues = [];
     let manifest;
@@ -135,9 +248,22 @@ export async function analyzeModuleDirectory(modulePath, moduleName = basename(m
     const menuXml = await readMenusXml(modulePath);
     const modelFiles = await readPythonModelFiles(modulePath);
     const viewFiles = await readViewXmlFiles(modulePath);
+    const viewXml = await Promise.all(viewFiles.map(async (fileName) => (await readOptionalFile(join(modulePath, 'views', fileName))) ?? ''));
+    const allViewXml = [...viewXml, ...menuXml];
     const depends = manifestDepends(manifest);
     const data = manifestData(manifest);
+    const demo = manifestDemo(manifest);
     const hasOdooStructures = moduleHasOdooStructures(modelFiles, viewFiles, menuXml, data);
+    for (const entry of data) {
+        if (!(await fileExists(join(modulePath, entry)))) {
+            issues.push(moduleQualityIssue(moduleName, relativePath, `missing manifest data file: ${entry}`, 'error'));
+        }
+    }
+    for (const entry of demo) {
+        if (!(await fileExists(join(modulePath, entry)))) {
+            issues.push(moduleQualityIssue(moduleName, relativePath, `missing manifest demo file: ${entry}`, 'warning'));
+        }
+    }
     if (hasOdooStructures && !depends.includes('base')) {
         issues.push(moduleIssue(moduleName, relativePath, 'missing base dependency for model-based module'));
     }
@@ -157,6 +283,28 @@ export async function analyzeModuleDirectory(modulePath, moduleName = basename(m
             issues.push(moduleIssue(moduleName, relativePath, 'missing security/ir.model.access.csv'));
         }
     }
+    const modelFileContents = await readModelFileContents(modulePath, modelFiles);
+    const modelIds = declaredModelIds(modelFileContents);
+    const modelNames = declaredModelNames(modelFileContents);
+    if (modelIds.size > 0) {
+        for (const modelId of accessCsvModelIds(await readOptionalFile(join(modulePath, 'security/ir.model.access.csv')))) {
+            if (!modelIds.has(modelId)) {
+                issues.push(moduleQualityIssue(moduleName, relativePath, `access CSV references unknown model id: ${modelId}`, 'error'));
+            }
+        }
+    }
+    if (modelNames.size > 0) {
+        for (const modelName of new Set(xmlRecordFieldValues(viewXml, 'ir.ui.view', 'model'))) {
+            if (looksLikePlainModelName(modelName) && !modelNames.has(modelName)) {
+                issues.push(moduleQualityIssue(moduleName, relativePath, `view XML references unknown model name: ${modelName}`, 'error'));
+            }
+        }
+        for (const modelName of new Set(xmlRecordFieldValues(allViewXml, 'ir.actions.act_window', 'res_model'))) {
+            if (looksLikePlainModelName(modelName) && !modelNames.has(modelName)) {
+                issues.push(moduleQualityIssue(moduleName, relativePath, `action XML references unknown res_model: ${modelName}`, 'error'));
+            }
+        }
+    }
     if (hasOdooStructures && !dataIncludesAccessCsv(data)) {
         issues.push(moduleIssue(moduleName, relativePath, 'missing security/ir.model.access.csv in manifest data'));
     }
@@ -166,6 +314,12 @@ export async function analyzeModuleDirectory(modulePath, moduleName = basename(m
     if (!(await directoryExists(join(modulePath, 'tests')))) {
         issues.push(moduleIssue(moduleName, relativePath, 'missing tests directory'));
     }
+    const actionIds = declaredActionIds(allViewXml);
+    for (const actionRef of menuActionReferences(menuXml)) {
+        if (!actionIds.has(actionRef)) {
+            issues.push(moduleQualityIssue(moduleName, relativePath, `menu XML references missing action id: ${actionRef}`, 'error'));
+        }
+    }
     const hasMenuAction = menuXml.some((content) => hasActionableMenuXml(content, moduleName));
     if (!hasMenuAction) {
         issues.push(moduleIssue(moduleName, relativePath, 'missing actionable menu XML'));

package/dist/postgres-diagnostics.js

@@ -124,13 +124,10 @@ index_health AS (
 wal_health AS (
   SELECT
     COALESCE((SELECT setting FROM pg_settings WHERE name = 'wal_level'), 'unavailable')::text AS wal_level,
-    COALESCE((SELECT setting FROM pg_settings WHERE name = 'archive_mode'), 'unavailable')::text AS wal_archive_mode,
-    COALESCE((SELECT COUNT(*) FROM pg_ls_waldir()), 0)::text AS wal_file_count,
-    COALESCE((SELECT SUM(size) FROM pg_ls_waldir()), 0)::text AS wal_directory_size_bytes
+    COALESCE((SELECT setting FROM pg_settings WHERE name = 'archive_mode'), 'unavailable')::text AS wal_archive_mode
 ),
 capacity_health AS (
   SELECT
-    COALESCE((SELECT pg_tablespace_size('pg_default')), 0)::text AS default_tablespace_size_bytes,
     COALESCE(
       (SELECT SUM(n_tup_ins + n_tup_upd + n_tup_del) FROM pg_stat_database WHERE datname IS NOT NULL),
       0
@@ -214,6 +211,21 @@ FROM (
     'unavailable'
   )
   UNION ALL
+  SELECT 'work_mem', COALESCE(
+    (SELECT setting || COALESCE(unit, '') FROM pg_settings WHERE name = 'work_mem'),
+    'unavailable'
+  )
+  UNION ALL
+  SELECT 'maintenance_work_mem', COALESCE(
+    (SELECT setting || COALESCE(unit, '') FROM pg_settings WHERE name = 'maintenance_work_mem'),
+    'unavailable'
+  )
+  UNION ALL
+  SELECT 'effective_cache_size', COALESCE(
+    (SELECT setting || COALESCE(unit, '') FROM pg_settings WHERE name = 'effective_cache_size'),
+    'unavailable'
+  )
+  UNION ALL
   SELECT 'long_transaction_count', long_transaction_count FROM transaction_health
   UNION ALL
   SELECT 'oldest_long_transaction_age_seconds', oldest_long_transaction_age_seconds FROM transaction_health
@@ -240,16 +252,30 @@ FROM (
   UNION ALL
   SELECT 'wal_archive_mode', wal_archive_mode FROM wal_health
   UNION ALL
-  SELECT 'wal_file_count', wal_file_count FROM wal_health
-  UNION ALL
-  SELECT 'wal_directory_size_bytes', wal_directory_size_bytes FROM wal_health
-  UNION ALL
-  SELECT 'default_tablespace_size_bytes', default_tablespace_size_bytes FROM capacity_health
-  UNION ALL
   SELECT 'database_write_activity_rows', database_write_activity_rows FROM capacity_health
 ) metrics
 ORDER BY metric;
 `.trim();
+export const POSTGRES_DIAGNOSTICS_OPTIONAL_QUERIES = [
+    {
+        id: 'wal-directory',
+        query: `
+SELECT metric || '|' || value
+FROM (
+  SELECT 'wal_file_count'::text AS metric, COALESCE((SELECT COUNT(*) FROM pg_ls_waldir()), 0)::text AS value
+  UNION ALL
+  SELECT 'wal_directory_size_bytes', COALESCE((SELECT SUM(size) FROM pg_ls_waldir()), 0)::text
+) metrics
+ORDER BY metric;
+`.trim(),
+    },
+    {
+        id: 'default-tablespace',
+        query: `
+SELECT 'default_tablespace_size_bytes'::text || '|' || COALESCE((SELECT pg_tablespace_size('pg_default')), 0)::text;
+`.trim(),
+    },
+];
 export const POSTGRES_DIAGNOSTIC_KEYS = [
     'database_count',
     'active_connections',
@@ -264,6 +290,9 @@ export const POSTGRES_DIAGNOSTIC_KEYS = [
     'pg_stat_statements_installed_version',
     'shared_preload_libraries',
     'shared_buffers',
+    'work_mem',
+    'maintenance_work_mem',
+    'effective_cache_size',
     'long_transaction_count',
     'oldest_long_transaction_age_seconds',
     'idle_in_transaction_count',
@@ -591,6 +620,15 @@ export function structuredPostgresDiagnostics(diagnostics) {
     if (diagnostics.shared_buffers) {
         structured.sharedBuffers = diagnostics.shared_buffers;
     }
+    if (diagnostics.work_mem) {
+        structured.workMem = diagnostics.work_mem;
+    }
+    if (diagnostics.maintenance_work_mem) {
+        structured.maintenanceWorkMem = diagnostics.maintenance_work_mem;
+    }
+    if (diagnostics.effective_cache_size) {
+        structured.effectiveCacheSize = diagnostics.effective_cache_size;
+    }
     if (longTransactionCount !== undefined) {
         structured.longTransactionCount = longTransactionCount;
     }

package/dist/repo-url.js

@@ -1,4 +1,6 @@
 import { basename } from 'node:path';
+import { validateRepoPath } from './path-validation.js';
+import { parseGitHubRepoUrl } from './github.js';
 export function normalizeRepositoryUrl(repoUrl) {
     const trimmed = repoUrl.trim();
     const withoutSuffix = trimmed.replace(/[?#].*$/, '').replace(/\/+$/, '').replace(/\.git$/, '');
@@ -15,13 +17,8 @@ export function inferRepoPath(repoUrl) {
     if (!withoutGit) {
         throw new Error(`Cannot infer repository path from URL: ${repoUrl}`);
     }
-    return withoutGit;
+    return validateRepoPath(withoutGit);
 }
 export function inferGitHubOwner(repoUrl) {
-    const normalized = normalizeRepositoryUrl(repoUrl);
-    const httpsMatch = normalized.match(/^https:\/\/github\.com\/([^/]+)\//);
-    if (httpsMatch)
-        return httpsMatch[1];
-    const sshMatch = normalized.match(/^git@github\.com:([^/]+)\//);
-    return sshMatch?.[1];
+    return parseGitHubRepoUrl(normalizeRepositoryUrl(repoUrl))?.owner;
 }

package/dist/safe-reset.js

@@ -70,7 +70,7 @@ function parseGitmodules(target) {
         const gitmodules = readFileSync(join(target, '.gitmodules'), 'utf8');
         const sections = gitmodules.split(/\n(?=\[submodule )/);
         return sections.flatMap((section) => {
-            const pathMatch = section.match(/^\s*path\s*=\s*odoo\/custom\/src\/(private|oca|external)\/([^\s]+)\s*$/m);
+            const pathMatch = section.match(/^\s*path\s*=\s*odoo\/custom\/src\/(?:(private|oca|external)\/)?([^\s/]+)\s*$/m);
             if (!pathMatch) {
                 return [];
             }
@@ -78,7 +78,7 @@ function parseGitmodules(target) {
             if (!source) {
                 return [];
             }
-            const sourceType = pathMatch[1];
+            const sourceType = (pathMatch[1] ?? 'private');
             return [{ path: pathMatch[2], sourceType, url: source }];
         });
     }
@@ -150,7 +150,7 @@ function inferOptionsForPreviewSync(target) {
                 url: metadataMatch?.url?.trim() ||
                     gitmoduleMatch?.url ||
                     readSubmoduleUrlFromPath(target, path, sourceType),
-                addons: parseAddonsForRepo(addonsYaml, path),
+                addons: parseAddonsForRepo(addonsYaml, path, sourceType),
             };
         }),
         engine: 'compose',
@@ -171,9 +171,12 @@ function inferOptionsForPreviewSync(target) {
 function readSubmoduleUrlFromPath(target, repoPath, sourceType) {
     try {
         const gitmodules = readFileSync(join(target, '.gitmodules'), 'utf8');
-        const escapedPath = `odoo/custom/src/${sourceType}/${repoPath}`;
+        const expectedPaths = [`odoo/custom/src/${sourceType}/${repoPath}`];
+        if (sourceType === 'private') {
+            expectedPaths.push(`odoo/custom/src/${repoPath}`);
+        }
         const sections = gitmodules.split(/\n(?=\[submodule )/);
-        const section = sections.find((value) => value.includes(`path = ${escapedPath}`));
+        const section = sections.find((value) => expectedPaths.some((path) => value.includes(`path = ${path}`)));
         const url = section?.match(/^\s*url\s*=\s*(.+)$/m)?.[1]?.trim();
         return url || `odoo/custom/src/${sourceType}/${repoPath}`;
     }
@@ -311,11 +314,14 @@ function safeResetExternalAssetOptions(options) {
         ],
     }));
 }
-function parseAddonsForRepo(addonsYaml, repoPath) {
+function parseAddonsForRepo(addonsYaml, repoPath, sourceType = 'private') {
     const safeRepoPath = validateRepoPath(repoPath);
     const lines = addonsYaml.split('\n');
-    const header = `private/${safeRepoPath}:`;
-    const start = lines.findIndex((line) => line.trim() === header);
+    const headers = [`${sourceType}/${safeRepoPath}:`];
+    if (sourceType === 'private') {
+        headers.push(`${safeRepoPath}:`);
+    }
+    const start = lines.findIndex((line) => headers.includes(line.trim()));
     if (start === -1)
         return [safeRepoPath];
     const addons = [];
@@ -332,7 +338,7 @@ function parseAddonsForRepo(addonsYaml, repoPath) {
     return addons.length ? addons : [safeRepoPath];
 }
 function parseRepoPathsFromAddonsYaml(addonsYaml) {
-    return [...addonsYaml.matchAll(/^private\/(.+):$/gm)]
+    return [...addonsYaml.matchAll(/^(?:private\/)?([^/\s][^/:]*):$/gm)]
         .map((match) => match[1].trim())
         .filter((repoPath) => repoPath && isValidPathSegment(repoPath))
         .map(validateRepoPath);
@@ -341,9 +347,12 @@ async function readSubmoduleUrl(target, repoPath, sourceType) {
     const safeRepoPath = validateRepoPath(repoPath);
     try {
         const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
-        const escapedPath = `odoo/custom/src/${sourceType}/${safeRepoPath}`;
+        const expectedPaths = [`odoo/custom/src/${sourceType}/${safeRepoPath}`];
+        if (sourceType === 'private') {
+            expectedPaths.push(`odoo/custom/src/${safeRepoPath}`);
+        }
         const sections = gitmodules.split(/\n(?=\[submodule )/);
-        const section = sections.find((value) => value.includes(`path = ${escapedPath}`));
+        const section = sections.find((value) => expectedPaths.some((path) => value.includes(`path = ${path}`)));
         const url = section?.match(/^\s*url\s*=\s*(.+)$/m)?.[1]?.trim();
         return url || `odoo/custom/src/${sourceType}/${safeRepoPath}`;
     }
@@ -389,7 +398,7 @@ async function inferOptions(target) {
             ?.url.trim() ||
             gitmoduleSources.find((repo) => repo.path === path && repo.type === sourceType)?.url ||
             (await readSubmoduleUrl(target, path, sourceType)),
-        addons: parseAddonsForRepo(addonsYaml, path),
+        addons: parseAddonsForRepo(addonsYaml, path, sourceType),
     })));
     return {
         product,