mustflow 1.31.0 → 2.11.0

package/dist/cli/lib/validation/primitives.js

@@ -0,0 +1,198 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { isRecord } from '../command-contract.js';
+import { readTomlFile } from '../toml.js';
+import { REQUIRED_FILES, } from './constants.js';
+import { VERSIONING_CONFIG_PATH } from '../../../core/version-sources.js';
+export function hasOwn(table, key) {
+    return Object.prototype.hasOwnProperty.call(table, key);
+}
+export function isPositiveInteger(value) {
+    return Number.isInteger(value) && Number(value) > 0;
+}
+export function isSafeRelativePath(value) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        return false;
+    }
+    const normalized = value.replace(/\\/g, '/');
+    const segments = normalized.split('/').filter(Boolean);
+    if (path.posix.isAbsolute(normalized) || path.win32.isAbsolute(value)) {
+        return false;
+    }
+    return segments.length > 0 && segments.every((segment) => segment !== '.' && segment !== '..');
+}
+export function validateRequiredFiles(projectRoot, issues) {
+    for (const relativePath of REQUIRED_FILES) {
+        if (!existsSync(path.join(projectRoot, relativePath))) {
+            issues.push({ message: `Missing ${relativePath}` });
+        }
+    }
+}
+export function validateToml(projectRoot, issues) {
+    const parsedFiles = {};
+    for (const relativePath of [
+        '.mustflow/config/mustflow.toml',
+        '.mustflow/config/commands.toml',
+        '.mustflow/config/preferences.toml',
+        VERSIONING_CONFIG_PATH,
+    ]) {
+        const filePath = path.join(projectRoot, relativePath);
+        if (!existsSync(filePath)) {
+            continue;
+        }
+        try {
+            const parsed = readTomlFile(filePath);
+            if (!isRecord(parsed)) {
+                issues.push({ message: `${relativePath} must contain a TOML table` });
+                continue;
+            }
+            if (relativePath.endsWith('mustflow.toml')) {
+                parsedFiles.mustflowToml = parsed;
+            }
+            if (relativePath.endsWith('commands.toml')) {
+                parsedFiles.commandsToml = parsed;
+            }
+            if (relativePath.endsWith('preferences.toml')) {
+                parsedFiles.preferencesToml = parsed;
+            }
+            if (relativePath.endsWith('versioning.toml')) {
+                parsedFiles.versioningToml = parsed;
+            }
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            issues.push({ message: `Invalid TOML in ${relativePath}: ${message}` });
+        }
+    }
+    return parsedFiles;
+}
+export function validateTable(config, tableName, issues) {
+    if (!hasOwn(config, tableName)) {
+        return undefined;
+    }
+    const table = config[tableName];
+    if (!isRecord(table)) {
+        issues.push({ message: `[${tableName}] must be a TOML table` });
+        return undefined;
+    }
+    return table;
+}
+export function validateBooleanField(table, key, label, issues) {
+    if (hasOwn(table, key) && typeof table[key] !== 'boolean') {
+        issues.push({ message: `${label} must be a boolean` });
+    }
+}
+export function validateStringField(table, key, label, issues) {
+    if (hasOwn(table, key) && (typeof table[key] !== 'string' || table[key].trim().length === 0)) {
+        issues.push({ message: `${label} must be a string` });
+    }
+}
+export function validateRequiredStringField(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        issues.push({ message: `${label} must be a string` });
+        return;
+    }
+    validateStringField(table, key, label, issues);
+}
+export function validateStringArrayField(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        return;
+    }
+    const value = table[key];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string' || entry.trim().length === 0)) {
+        issues.push({ message: `${label} must be a string array` });
+    }
+}
+export function validateStringArrayMembers(table, key, label, allowedValues, unsupportedLabel, issues) {
+    if (!hasOwn(table, key)) {
+        return;
+    }
+    const value = table[key];
+    if (!Array.isArray(value) || value.some((entry) => typeof entry !== 'string' || entry.trim().length === 0)) {
+        issues.push({ message: `${label} must be a string array` });
+        return;
+    }
+    for (const entry of value) {
+        if (!allowedValues.has(entry)) {
+            issues.push({ message: `${label} contains unsupported ${unsupportedLabel} "${entry}"` });
+        }
+    }
+}
+export function validateExactStringArrayField(table, key, label, expectedValues, issues) {
+    if (!hasOwn(table, key)) {
+        return;
+    }
+    const value = table[key];
+    if (!Array.isArray(value) || value.length !== expectedValues.length) {
+        issues.push({ message: `${label} must be ${expectedValues.map((entry) => `"${entry}"`).join(', ')}` });
+        return;
+    }
+    const hasExpectedValues = expectedValues.every((entry, index) => value[index] === entry);
+    if (!hasExpectedValues) {
+        issues.push({ message: `${label} must be ${expectedValues.map((entry) => `"${entry}"`).join(', ')}` });
+    }
+}
+export function validatePositiveIntegerField(table, key, label, issues) {
+    if (hasOwn(table, key) && !isPositiveInteger(table[key])) {
+        issues.push({ message: `${label} must be a positive integer` });
+    }
+}
+export function validateNestedTable(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        return undefined;
+    }
+    const value = table[key];
+    if (!isRecord(value)) {
+        issues.push({ message: `${label} must be a TOML table` });
+        return undefined;
+    }
+    return value;
+}
+export function validateAllowedStringField(table, key, label, allowedValues, issues) {
+    if (!hasOwn(table, key)) {
+        return;
+    }
+    if (typeof table[key] !== 'string' || !allowedValues.has(table[key])) {
+        issues.push({ message: `${label} must be ${Array.from(allowedValues).map((value) => `"${value}"`).join(' or ')}` });
+    }
+}
+export function validatePathField(table, key, label, issues) {
+    if (hasOwn(table, key) && !isSafeRelativePath(table[key])) {
+        issues.push({ message: `${label} must be a non-empty relative path` });
+    }
+}
+export function validateRequiredPathField(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        issues.push({ message: `${label} must be a non-empty relative path` });
+        return;
+    }
+    validatePathField(table, key, label, issues);
+}
+export function validatePathArrayField(table, key, label, issues) {
+    if (!hasOwn(table, key)) {
+        return undefined;
+    }
+    const value = table[key];
+    if (!Array.isArray(value) || value.length === 0 || !value.every(isSafeRelativePath)) {
+        issues.push({ message: `${label} entries must be non-empty relative paths` });
+        return undefined;
+    }
+    return value;
+}
+export function validateWorkspaceRoots(table, issues) {
+    if (!hasOwn(table, 'roots')) {
+        return undefined;
+    }
+    const value = table.roots;
+    if (!Array.isArray(value) || !value.every(isSafeRelativePath)) {
+        issues.push({ message: '[workspace].roots entries must be relative paths inside the current root' });
+        return undefined;
+    }
+    return value;
+}
+export function pushStrictIssue(issues, message) {
+    issues.push({ message: `Strict: ${message}` });
+}
+export function pushStrictWarning(issues, message) {
+    issues.push({ message: `Strict warning: ${message}`, severity: 'warning' });
+}

package/dist/cli/lib/validation/test-selection.js

@@ -0,0 +1,95 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+import { isRecord } from '../command-contract.js';
+import { readTomlFile } from '../toml.js';
+import { ALLOWED_TEST_SELECTION_RISKS, FORBIDDEN_TEST_SELECTION_COMMAND_AUTHORITY_FIELDS, TEST_SELECTION_CONFIG_PATH, } from './constants.js';
+import { isConfiguredCommandIntent, isDeclaredCommandIntent } from './command-intents.js';
+import { hasOwn, pushStrictIssue, validateAllowedStringField, validateNestedTable, validatePathArrayField, validateRequiredStringField, validateStringArrayField, } from './primitives.js';
+function validateNoTestSelectionCommandAuthorityFields(label, table, issues) {
+    for (const field of FORBIDDEN_TEST_SELECTION_COMMAND_AUTHORITY_FIELDS) {
+        if (hasOwn(table, field)) {
+            pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label}.${field} cannot define command authority; use .mustflow/config/commands.toml`);
+        }
+    }
+}
+function validateTestSelectionIntentReference(value, label, commandsToml, issues) {
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label} must be a command intent name`);
+        return;
+    }
+    if (!isDeclaredCommandIntent(commandsToml, value)) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label} references unknown command intent "${value}"`);
+        return;
+    }
+    if (!isConfiguredCommandIntent(commandsToml, value)) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label} references command intent "${value}" that is not configured`);
+    }
+}
+function validateTestSelectionRule(rule, index, commandsToml, issues) {
+    const label = `rules[${index}]`;
+    if (!isRecord(rule)) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label} must be a TOML table`);
+        return;
+    }
+    validateNoTestSelectionCommandAuthorityFields(label, rule, issues);
+    validateRequiredStringField(rule, 'id', `${TEST_SELECTION_CONFIG_PATH} ${label}.id`, issues);
+    validateRequiredStringField(rule, 'reason', `${TEST_SELECTION_CONFIG_PATH} ${label}.reason`, issues);
+    validateRequiredStringField(rule, 'risk', `${TEST_SELECTION_CONFIG_PATH} ${label}.risk`, issues);
+    validateAllowedStringField(rule, 'risk', `${TEST_SELECTION_CONFIG_PATH} ${label}.risk`, ALLOWED_TEST_SELECTION_RISKS, issues);
+    const match = validateNestedTable(rule, 'match', `${TEST_SELECTION_CONFIG_PATH} ${label}.match`, issues);
+    if (!hasOwn(rule, 'match')) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label} must define match`);
+    }
+    if (match) {
+        validateNoTestSelectionCommandAuthorityFields(`${label}.match`, match, issues);
+        validatePathArrayField(match, 'paths', `${TEST_SELECTION_CONFIG_PATH} ${label}.match.paths`, issues);
+        validateStringArrayField(match, 'surfaces', `${TEST_SELECTION_CONFIG_PATH} ${label}.match.surfaces`, issues);
+        if (!hasOwn(match, 'paths')) {
+            pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label}.match must define paths`);
+        }
+        if (!hasOwn(match, 'surfaces')) {
+            pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label}.match must define surfaces`);
+        }
+    }
+    const select = validateNestedTable(rule, 'select', `${TEST_SELECTION_CONFIG_PATH} ${label}.select`, issues);
+    if (!hasOwn(rule, 'select')) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} ${label} must define select`);
+    }
+    if (select) {
+        validateNoTestSelectionCommandAuthorityFields(`${label}.select`, select, issues);
+        validateTestSelectionIntentReference(select.intent, `${label}.select.intent`, commandsToml, issues);
+        validateTestSelectionIntentReference(select.fallback_intent, `${label}.select.fallback_intent`, commandsToml, issues);
+        validatePathArrayField(select, 'test_targets', `${TEST_SELECTION_CONFIG_PATH} ${label}.select.test_targets`, issues);
+    }
+}
+export function validateStrictTestSelectionConfig(projectRoot, commandsToml, issues) {
+    const configPath = path.join(projectRoot, ...TEST_SELECTION_CONFIG_PATH.split('/'));
+    if (!existsSync(configPath)) {
+        return;
+    }
+    let parsed;
+    try {
+        parsed = readTomlFile(configPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        pushStrictIssue(issues, `Invalid TOML in ${TEST_SELECTION_CONFIG_PATH}: ${message}`);
+        return;
+    }
+    if (!isRecord(parsed)) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} must contain a TOML table`);
+        return;
+    }
+    validateNoTestSelectionCommandAuthorityFields('root', parsed, issues);
+    validateRequiredStringField(parsed, 'schema_version', `${TEST_SELECTION_CONFIG_PATH}.schema_version`, issues);
+    if (parsed.schema_version !== '1') {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH}.schema_version must be "1"`);
+    }
+    if (!Array.isArray(parsed.rules) || parsed.rules.length === 0) {
+        pushStrictIssue(issues, `${TEST_SELECTION_CONFIG_PATH} must define [[rules]]`);
+        return;
+    }
+    for (const [index, rule] of parsed.rules.entries()) {
+        validateTestSelectionRule(rule, index, commandsToml, issues);
+    }
+}

package/dist/cli/lib/validation/types.js

@@ -0,0 +1 @@
+export {};