@wpmoo/toolkit 0.9.0

package/dist/source-manifest.js

@@ -0,0 +1,338 @@
+import { mkdir, readFile, writeFile } from 'node:fs/promises';
+import { join } from 'node:path';
+import { isValidPathSegment, validateRepoPath } from './path-validation.js';
+const validSourceTypes = ['private', 'oca', 'external'];
+export const sourceManifestPath = 'odoo/custom/manifests/sources.yaml';
+function fail(message) {
+    throw new Error(`Invalid source manifest ${sourceManifestPath}: ${message}`);
+}
+export function normalizeSourceType(value) {
+    return validSourceTypes.includes(value) ? value : 'private';
+}
+function dedupeAndSort(entries) {
+    const uniqueByTypePath = new Map();
+    for (const entry of entries) {
+        uniqueByTypePath.set(`${entry.type}:${entry.path}`, entry);
+    }
+    return [...uniqueByTypePath.values()].sort((left, right) => {
+        const typeOrder = left.type.localeCompare(right.type);
+        if (typeOrder !== 0)
+            return typeOrder;
+        return left.path.localeCompare(right.path);
+    });
+}
+function stripInlineComment(raw) {
+    let inSingle = false;
+    let inDouble = false;
+    let escaped = false;
+    for (let index = 0; index < raw.length; index += 1) {
+        const char = raw[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (char === '\\') {
+            escaped = true;
+            continue;
+        }
+        if (char === "'" && !inDouble) {
+            inSingle = !inSingle;
+        }
+        else if (char === '"' && !inSingle) {
+            inDouble = !inDouble;
+        }
+        else if (char === '#' && !inSingle && !inDouble) {
+            return raw.slice(0, index).trimEnd();
+        }
+    }
+    return raw;
+}
+function parseScalar(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return '';
+    if (trimmed.startsWith('"') && trimmed.endsWith('"')) {
+        return JSON.parse(trimmed);
+    }
+    if (trimmed.startsWith("'") && trimmed.endsWith("'")) {
+        return trimmed.slice(1, -1).replace(/\\'/g, "'");
+    }
+    return trimmed;
+}
+function leadingSpaces(line) {
+    return line.length - line.trimStart().length;
+}
+function parseSourcesBlock(content) {
+    const lines = content.split(/\r?\n/).map((line, index) => ({
+        lineNumber: index + 1,
+        line: line.replace(/\t/g, '  '),
+        trimmedLine: line.replace(/\t/g, '  ').trim(),
+    }));
+    const sourcesKeywordLine = lines.find((line) => /^\s*sources\s*:\s*(?:\[[^\]]*\])?\s*$/.test(stripInlineComment(line.line)));
+    if (!sourcesKeywordLine) {
+        fail('Missing top-level sources entry.');
+    }
+    const rawSourcesValue = stripInlineComment(sourcesKeywordLine.line).replace(/^\s*sources\s*:\s*/, '');
+    if (rawSourcesValue === '[]') {
+        return { sources: [] };
+    }
+    if (rawSourcesValue && rawSourcesValue !== '') {
+        fail(`Unexpected non-list value on line ${sourcesKeywordLine.lineNumber}: sources`);
+    }
+    const sourceLines = lines.slice(sourcesKeywordLine.lineNumber);
+    const parsed = [];
+    let index = 0;
+    while (index < sourceLines.length) {
+        const headerLine = sourceLines[index];
+        const noCommentHeader = stripInlineComment(headerLine.line);
+        if (!noCommentHeader.trim()) {
+            index += 1;
+            continue;
+        }
+        const itemMatch = /^\s*-\s*type:\s*(.+)\s*$/.exec(noCommentHeader);
+        if (!itemMatch) {
+            index += 1;
+            continue;
+        }
+        const item = {
+            type: normalizeSourceType(parseScalar(itemMatch[1])),
+            path: '',
+            url: '',
+            addons: [],
+        };
+        index += 1;
+        while (index < sourceLines.length) {
+            const rawLine = sourceLines[index];
+            const noComment = stripInlineComment(rawLine.line);
+            const trimmed = noComment.trim();
+            if (!trimmed) {
+                index += 1;
+                continue;
+            }
+            if (/^\s*-\s*type:\s*/.test(noComment)) {
+                break;
+            }
+            const pathMatch = /^\s*path:\s*(.+)\s*$/.exec(noComment);
+            if (pathMatch) {
+                item.path = validateRepoPath(parseScalar(pathMatch[1]));
+                index += 1;
+                continue;
+            }
+            const urlMatch = /^\s*url:\s*(.+)\s*$/.exec(noComment);
+            if (urlMatch) {
+                item.url = parseScalar(urlMatch[1]);
+                index += 1;
+                continue;
+            }
+            const branchMatch = /^\s*branch:\s*(.+)\s*$/.exec(noComment);
+            if (branchMatch) {
+                item.branch = parseScalar(branchMatch[1]);
+                index += 1;
+                continue;
+            }
+            const addonsLine = /^\s*addons:\s*$/.exec(noComment);
+            if (addonsLine) {
+                const baseIndent = leadingSpaces(rawLine.line) + 2;
+                index += 1;
+                while (index < sourceLines.length) {
+                    const addonRaw = stripInlineComment(sourceLines[index].line);
+                    const addonTrimmed = addonRaw.trim();
+                    if (!addonTrimmed) {
+                        index += 1;
+                        continue;
+                    }
+                    const addonMatch = /^\s*-\s*(.+)\s*$/.exec(addonRaw);
+                    if (!addonMatch) {
+                        break;
+                    }
+                    if (leadingSpaces(addonRaw) < baseIndent) {
+                        break;
+                    }
+                    const addon = parseScalar(addonMatch[1]);
+                    if (addon) {
+                        item.addons.push(addon);
+                    }
+                    index += 1;
+                }
+                continue;
+            }
+            fail(`Unexpected source entry field on line ${rawLine.lineNumber}: ${trimmed}`);
+        }
+        if (!item.path) {
+            fail(`Manifest entry missing path at line ${headerLine.lineNumber}`);
+        }
+        if (!item.url) {
+            fail(`Manifest entry missing url for ${item.type}:${item.path} at line ${headerLine.lineNumber}`);
+        }
+        if (!isValidPathSegment(item.path)) {
+            fail(`Invalid manifest path at line ${headerLine.lineNumber}: ${item.path}`);
+        }
+        if (item.addons.length === 0) {
+            item.addons.push(item.path);
+        }
+        item.addons = [...new Set(item.addons.map((addon) => validateRepoPath(addon)))].sort();
+        parsed.push(item);
+    }
+    return { sources: dedupeAndSort(parsed.filter((entry) => isValidPathSegment(entry.path))) };
+}
+export async function readSourceManifest(target) {
+    try {
+        const content = await readFile(join(target, sourceManifestPath), 'utf8');
+        return parseSourcesBlock(content);
+    }
+    catch (error) {
+        if (error.code === 'ENOENT') {
+            return { sources: [] };
+        }
+        throw error;
+    }
+}
+function renderQuoted(value) {
+    return JSON.stringify(value);
+}
+export function renderSourceManifest(entries) {
+    const normalized = dedupeAndSort(entries).map((entry) => {
+        const addons = [...new Set(entry.addons.map((addon) => validateRepoPath(addon)))].sort();
+        return {
+            type: entry.type,
+            path: validateRepoPath(entry.path),
+            url: entry.url.trim(),
+            branch: entry.branch?.trim(),
+            addons: addons.length ? addons : [validateRepoPath(entry.path)],
+        };
+    });
+    if (normalized.length === 0) {
+        return 'sources: []\n';
+    }
+    const body = normalized
+        .map((entry) => {
+        const lines = [
+            `  - type: ${renderQuoted(entry.type)}`,
+            `    path: ${renderQuoted(entry.path)}`,
+            `    url: ${renderQuoted(entry.url)}`,
+        ];
+        lines.push(`    branch: ${renderQuoted(entry.branch ?? '')}`);
+        lines.push('    addons:');
+        for (const addon of entry.addons) {
+            lines.push(`      - ${renderQuoted(addon)}`);
+        }
+        return lines.join('\n');
+    })
+        .join('\n');
+    return `sources:\n${body}\n`;
+}
+export async function writeSourceManifest(target, entries) {
+    const content = renderSourceManifest(entries);
+    const path = join(target, sourceManifestPath);
+    await mkdir(join(path, '..'), { recursive: true });
+    await writeFile(path, content, 'utf8');
+}
+function entryKey(type, path) {
+    return `${type}:${path}`;
+}
+export async function upsertSourceManifestEntry(target, entry) {
+    const manifest = await readSourceManifest(target);
+    const normalized = {
+        ...entry,
+        type: normalizeSourceType(entry.type),
+        path: validateRepoPath(entry.path),
+    };
+    const next = dedupeAndSort(manifest.sources.filter((current) => entryKey(current.type, current.path) !== entryKey(normalized.type, normalized.path)));
+    next.push(normalized);
+    await writeSourceManifest(target, next);
+}
+export async function removeSourceManifestEntry(target, type, path) {
+    const manifest = await readSourceManifest(target);
+    const key = entryKey(normalizeSourceType(type), validateRepoPath(path));
+    const next = manifest.sources.filter((entry) => entryKey(entry.type, entry.path) !== key);
+    await writeSourceManifest(target, next);
+}
+export function sourceManifestEntriesFromMetadata(sourceRepos, fallbackBranch) {
+    return sourceRepos.map((repo) => ({
+        type: normalizeSourceType(repo.sourceType),
+        path: validateRepoPath(repo.path),
+        url: repo.url.trim(),
+        branch: fallbackBranch,
+        addons: repo.addons.length ? [...new Set(repo.addons.map((addon) => validateRepoPath(addon)))] : [validateRepoPath(repo.path)],
+    }));
+}
+export async function listGitmoduleSources(target) {
+    try {
+        const gitmodules = await readFile(join(target, '.gitmodules'), 'utf8');
+        const lines = gitmodules.split(/\r?\n/);
+        const locations = [];
+        const pathRegex = /^\s*path\s*=\s*odoo\/custom\/src\/(private|oca|external)\/(.+)\s*$/;
+        const urlRegex = /^\s*url\s*=\s*(.+)\s*$/;
+        let pending;
+        for (const line of lines) {
+            const parsedPath = line.match(pathRegex);
+            if (parsedPath) {
+                const sourceType = parsedPath[1];
+                const repoPath = parsedPath[2]?.trim() ?? '';
+                if (!repoPath || !isValidPathSegment(repoPath)) {
+                    pending = undefined;
+                    continue;
+                }
+                pending = {
+                    type: sourceType,
+                    path: validateRepoPath(repoPath),
+                    url: '',
+                };
+                continue;
+            }
+            const parsedUrl = line.match(urlRegex);
+            if (!parsedUrl || !pending) {
+                continue;
+            }
+            const url = parseScalar(parsedUrl[1]);
+            if (url) {
+                locations.push({ ...pending, url });
+            }
+            pending = undefined;
+        }
+        return locations;
+    }
+    catch {
+        return [];
+    }
+}
+export function syncManifestFromMetadataAndGitmodules(sourceRepos, fallbackBranch, gitmodules = []) {
+    const byGitmodule = new Map();
+    for (const location of gitmodules) {
+        byGitmodule.set(`${normalizeSourceType(location.type)}:${location.path}`, location);
+    }
+    const entries = [];
+    for (const repo of sourceRepos) {
+        const normalized = {
+            type: normalizeSourceType(repo.sourceType),
+            path: validateRepoPath(repo.path),
+            url: repo.url.trim() || byGitmodule.get(`${normalizeSourceType(repo.sourceType)}:${repo.path}`)?.url || '',
+            branch: fallbackBranch,
+            addons: repo.addons.map(validateRepoPath),
+        };
+        entries.push(normalized);
+    }
+    for (const location of gitmodules) {
+        const key = `${location.type}:${location.path}`;
+        if (entries.some((entry) => `${entry.type}:${entry.path}` === key)) {
+            continue;
+        }
+        entries.push({
+            type: location.type,
+            path: location.path,
+            url: location.url,
+            branch: fallbackBranch,
+            addons: [location.path],
+        });
+    }
+    return dedupeAndSort(entries);
+}
+export function sourceReposFromManifest(entries) {
+    const normalized = dedupeAndSort(entries);
+    return normalized.map((entry) => ({
+        sourceType: entry.type,
+        path: validateRepoPath(entry.path),
+        url: entry.url,
+        addons: entry.addons.length ? [...new Set(entry.addons.map((addon) => validateRepoPath(addon)))] : [validateRepoPath(entry.path)],
+    }));
+}

package/dist/status.js

@@ -0,0 +1,239 @@
+import { access, readdir, readFile, stat } from 'node:fs/promises';
+import { join } from 'node:path';
+import { detectComposeLayout, readEnvFile, selectedComposeEnvironment } from './compose-layout.js';
+import { defaultOdooVersion, markerPath } from './environment.js';
+import { isValidPathSegment, validateRepoPath } from './path-validation.js';
+const validSourceTypes = ['private', 'oca', 'external'];
+function normalizeSourceType(sourceType) {
+    if (typeof sourceType === 'string' && validSourceTypes.includes(sourceType)) {
+        return sourceType;
+    }
+    return 'private';
+}
+function sourceRepoPath(target, sourceType, path) {
+    return join(target, 'odoo/custom/src', sourceType, path);
+}
+async function pathExists(path) {
+    try {
+        await access(path);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function errorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseMetadata(content) {
+    const parsed = JSON.parse(content);
+    if (!isRecord(parsed)) {
+        throw new Error('metadata is not an object');
+    }
+    return parsed;
+}
+function sourceRepoPathsFromMetadata(metadata) {
+    const sourceRepoPaths = [];
+    const sourceRepoLocations = [];
+    const invalidSourceRepoPaths = [];
+    if (!Array.isArray(metadata.sourceRepos)) {
+        return { sourceRepoPaths, sourceRepoLocations, invalidSourceRepoPaths };
+    }
+    for (const repo of metadata.sourceRepos) {
+        const path = repo && typeof repo.path === 'string' ? repo.path.trim() : '';
+        if (!path)
+            continue;
+        if (!isValidPathSegment(path)) {
+            invalidSourceRepoPaths.push(path);
+            continue;
+        }
+        const sourceType = normalizeSourceType(typeof repo.sourceType === 'string' ? repo.sourceType : undefined);
+        const normalizedPath = validateRepoPath(path);
+        sourceRepoPaths.push(normalizedPath);
+        sourceRepoLocations.push({ sourceType, path: normalizedPath });
+    }
+    return { sourceRepoPaths, sourceRepoLocations, invalidSourceRepoPaths };
+}
+async function missingCoreFiles(target, odooVersion) {
+    const missing = [];
+    const checks = [
+        { label: 'moo', path: join(target, 'moo') },
+        { label: 'README.md', path: join(target, 'README.md') },
+        { label: 'AGENTS.md', path: join(target, 'AGENTS.md') },
+        { label: 'scripts/', path: join(target, 'scripts'), mustBeDirectory: true },
+    ];
+    for (const check of checks) {
+        if (!(await pathExists(check.path))) {
+            missing.push(check.label);
+            continue;
+        }
+        if (check.mustBeDirectory) {
+            const fileStat = await stat(check.path);
+            if (!fileStat.isDirectory())
+                missing.push(check.label);
+        }
+    }
+    const env = await readEnvFile(target);
+    const composeLayout = await detectComposeLayout(target, {
+        odooVersions: [odooVersion],
+        envName: selectedComposeEnvironment(env),
+    });
+    missing.push(...composeLayout.missingFiles);
+    return { missing, composeFiles: composeLayout.files, composeErrors: composeLayout.errors };
+}
+async function countModuleCandidatesInRepoPath(path) {
+    if (!(await pathExists(path)))
+        return 0;
+    const rootStat = await stat(path);
+    if (!rootStat.isDirectory())
+        return 0;
+    let count = 0;
+    const stack = [path];
+    while (stack.length > 0) {
+        const current = stack.pop();
+        if (!current)
+            continue;
+        const entries = await readdir(current, { withFileTypes: true });
+        let hasManifest = false;
+        for (const entry of entries) {
+            if (entry.isFile() && entry.name === '__manifest__.py') {
+                hasManifest = true;
+            }
+            else if (entry.isDirectory()) {
+                stack.push(join(current, entry.name));
+            }
+        }
+        if (hasManifest)
+            count += 1;
+    }
+    return count;
+}
+function summaryText(status) {
+    if (status.kind === 'no_environment')
+        return 'No WPMoo environment detected.';
+    if (status.kind === 'invalid_metadata')
+        return 'Environment metadata is invalid.';
+    const prefix = status.missingCoreFiles.length > 0 ||
+        status.invalidSourceRepoPaths.length > 0 ||
+        status.composeErrors.length > 0
+        ? 'Environment needs attention'
+        : 'Environment ready';
+    return `${prefix}: Odoo ${status.odooVersion}, source repos ${status.sourceRepoCount}, module candidates ${status.moduleCandidateCount}.`;
+}
+function isStatusHealthy(status) {
+    if (status.kind !== 'environment')
+        return false;
+    return (status.missingCoreFiles.length === 0 &&
+        status.invalidSourceRepoPaths.length === 0 &&
+        status.composeErrors.length === 0);
+}
+export function environmentStatusJson(status) {
+    return {
+        schemaVersion: 1,
+        command: 'status',
+        ok: isStatusHealthy(status),
+        status,
+    };
+}
+export async function getEnvironmentStatus(target) {
+    const metadataFullPath = join(target, markerPath);
+    if (!(await pathExists(metadataFullPath))) {
+        return {
+            kind: 'no_environment',
+            target,
+            metadataPath: markerPath,
+            recommendedNextAction: 'Run npx @wpmoo/toolkit create ...',
+        };
+    }
+    let metadata;
+    try {
+        const content = await readFile(metadataFullPath, 'utf8');
+        metadata = parseMetadata(content);
+    }
+    catch (error) {
+        return {
+            kind: 'invalid_metadata',
+            target,
+            metadataPath: markerPath,
+            metadataError: errorMessage(error),
+            recommendedNextAction: 'Fix .wpmoo/odoo.json or run npx @wpmoo/toolkit reset from a valid environment.',
+        };
+    }
+    const odooVersion = typeof metadata.odooVersion === 'string' && metadata.odooVersion.trim()
+        ? metadata.odooVersion.trim()
+        : defaultOdooVersion;
+    const { sourceRepoPaths, sourceRepoLocations, invalidSourceRepoPaths } = sourceRepoPathsFromMetadata(metadata);
+    const repoRoots = sourceRepoLocations.map(({ sourceType, path }) => sourceRepoPath(target, sourceType, path));
+    let moduleCandidateCount = 0;
+    for (const repoRoot of repoRoots) {
+        moduleCandidateCount += await countModuleCandidatesInRepoPath(repoRoot);
+    }
+    const { missing: missingFiles, composeFiles, composeErrors, } = await missingCoreFiles(target, odooVersion);
+    let recommendedNextAction = 'Run npx @wpmoo/toolkit doctor for deep checks or ./moo start.';
+    if (invalidSourceRepoPaths.length > 0) {
+        recommendedNextAction =
+            'Fix invalid source repo paths in .wpmoo/odoo.json, then run npx @wpmoo/toolkit doctor.';
+    }
+    else if (missingFiles.length > 0) {
+        recommendedNextAction = 'Run npx @wpmoo/toolkit reset, then npx @wpmoo/toolkit doctor.';
+    }
+    else if (composeErrors.length > 0) {
+        recommendedNextAction = 'Fix compose layout errors, then run npx @wpmoo/toolkit doctor.';
+    }
+    else if (sourceRepoPaths.length === 0) {
+        recommendedNextAction = 'Run npx @wpmoo/toolkit add-repo ...';
+    }
+    return {
+        kind: 'environment',
+        target,
+        metadataPath: markerPath,
+        odooVersion,
+        sourceRepoCount: sourceRepoPaths.length,
+        sourceRepoPaths,
+        invalidSourceRepoPaths,
+        moduleCandidateCount,
+        composeFiles,
+        composeErrors,
+        missingCoreFiles: missingFiles,
+        recommendedNextAction,
+    };
+}
+export function renderEnvironmentStatusSummary(status) {
+    return summaryText(status);
+}
+export function renderEnvironmentStatus(status) {
+    const lines = [`Status: ${summaryText(status)}`];
+    if (status.kind === 'no_environment') {
+        lines.push(`Metadata: missing ${status.metadataPath}`);
+        lines.push(`Next: ${status.recommendedNextAction}`);
+        return lines.join('\n');
+    }
+    if (status.kind === 'invalid_metadata') {
+        lines.push(`Metadata: invalid ${status.metadataPath}`);
+        lines.push(`Error: ${status.metadataError}`);
+        lines.push(`Next: ${status.recommendedNextAction}`);
+        return lines.join('\n');
+    }
+    lines.push(`Metadata: ${status.metadataPath}`);
+    lines.push(`Odoo: ${status.odooVersion}`);
+    lines.push(`Compose files: ${status.composeFiles.length > 0 ? status.composeFiles.join(', ') : '(missing)'}`);
+    if (status.composeErrors.length > 0) {
+        lines.push(`Compose errors: ${status.composeErrors.join(', ')}`);
+    }
+    lines.push(`Source repos: ${status.sourceRepoCount}`);
+    lines.push(`Source repo paths: ${status.sourceRepoPaths.length > 0 ? status.sourceRepoPaths.join(', ') : '(none configured)'}`);
+    if (status.invalidSourceRepoPaths.length > 0) {
+        lines.push(`Invalid source repo paths: ${status.invalidSourceRepoPaths.join(', ')}`);
+    }
+    lines.push(`Module candidates: ${status.moduleCandidateCount}`);
+    lines.push(`Missing core files: ${status.missingCoreFiles.length > 0 ? status.missingCoreFiles.join(', ') : '(none)'}`);
+    lines.push(`Next: ${status.recommendedNextAction}`);
+    return lines.join('\n');
+}
+export async function renderEnvironmentStatusForTarget(target) {
+    const status = await getEnvironmentStatus(target);
+    return renderEnvironmentStatus(status);
+}