mustflow 1.15.97

package/dist/cli/lib/locale-tags.js

@@ -0,0 +1,4 @@
+const LOCALE_TAG_PATTERN = /^[a-zA-Z]{2,3}(?:-[a-zA-Z0-9]{2,8})*$/u;
+export function isLocaleTag(value) {
+    return LOCALE_TAG_PATTERN.test(value);
+}

package/dist/cli/lib/manifest-lock.js

@@ -0,0 +1,131 @@
+import { createHash } from 'node:crypto';
+import { existsSync, readFileSync, writeFileSync } from 'node:fs';
+import path from 'node:path';
+import { ensureInside } from './filesystem.js';
+import { readTomlFile, stringifyToml } from './toml.js';
+export const MANIFEST_LOCK_RELATIVE_PATH = '.mustflow/config/manifest.lock.toml';
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function readString(table, key, label) {
+    const value = table[key];
+    if (typeof value !== 'string' || value.trim().length === 0) {
+        throw new Error(`${label} must be a non-empty string`);
+    }
+    return value;
+}
+function parseManifestLock(raw) {
+    if (!isRecord(raw)) {
+        throw new Error('manifest lock must contain a TOML table');
+    }
+    const template = raw.template;
+    const files = raw.files;
+    if (!isRecord(template)) {
+        throw new Error('[template] must be a TOML table');
+    }
+    if (!isRecord(files)) {
+        throw new Error('[files] must be a TOML table');
+    }
+    const lockedFiles = [];
+    for (const [relativePath, file] of Object.entries(files)) {
+        if (!isRecord(file)) {
+            throw new Error(`[files.${relativePath}] must be a TOML table`);
+        }
+        lockedFiles.push({
+            relativePath,
+            source: readString(file, 'source', `[files.${relativePath}].source`),
+            lastAction: readString(file, 'last_action', `[files.${relativePath}].last_action`),
+            contentHash: readString(file, 'content_hash', `[files.${relativePath}].content_hash`),
+        });
+    }
+    return {
+        schemaVersion: readString(raw, 'schema_version', 'schema_version'),
+        templateId: readString(template, 'id', '[template].id'),
+        templateVersion: readString(template, 'version', '[template].version'),
+        templateProfile: typeof template.profile === 'string' ? template.profile : undefined,
+        templateLocale: typeof template.locale === 'string' ? template.locale : undefined,
+        files: lockedFiles,
+    };
+}
+export function sha256File(filePath) {
+    return `sha256:${createHash('sha256').update(readFileSync(filePath)).digest('hex')}`;
+}
+export function markManifestLockFileCustomized(projectRoot, relativePath) {
+    const lockPath = path.join(projectRoot, MANIFEST_LOCK_RELATIVE_PATH);
+    const filePath = path.join(projectRoot, relativePath);
+    ensureInside(projectRoot, lockPath);
+    ensureInside(projectRoot, filePath);
+    if (!existsSync(lockPath)) {
+        return false;
+    }
+    if (!existsSync(filePath)) {
+        throw new Error(`Cannot refresh manifest lock for missing file: ${relativePath}`);
+    }
+    const parsed = readTomlFile(lockPath);
+    if (!isRecord(parsed)) {
+        throw new Error(`Invalid manifest lock: ${MANIFEST_LOCK_RELATIVE_PATH} must contain a TOML table`);
+    }
+    const filesTable = isRecord(parsed.files) ? parsed.files : {};
+    const existing = filesTable[relativePath];
+    const existingTable = isRecord(existing) ? existing : {};
+    filesTable[relativePath] = {
+        source: typeof existingTable.source === 'string' ? existingTable.source : 'template_common',
+        last_action: 'customized',
+        content_hash: sha256File(filePath),
+    };
+    parsed.files = filesTable;
+    writeFileSync(lockPath, stringifyToml(parsed));
+    return true;
+}
+export function readManifestLock(projectRoot) {
+    const lockPath = path.join(projectRoot, MANIFEST_LOCK_RELATIVE_PATH);
+    ensureInside(projectRoot, lockPath);
+    if (!existsSync(lockPath)) {
+        return { kind: 'missing', lockPath };
+    }
+    try {
+        return { kind: 'present', lockPath, lock: parseManifestLock(readTomlFile(lockPath)) };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return { kind: 'invalid', lockPath, message };
+    }
+}
+export function inspectManifestLock(projectRoot) {
+    const readResult = readManifestLock(projectRoot);
+    const changedFiles = [];
+    const missingFiles = [];
+    const issues = [];
+    if (readResult.kind === 'missing') {
+        return { readResult, changedFiles, missingFiles, issues };
+    }
+    if (readResult.kind === 'invalid') {
+        return {
+            readResult,
+            changedFiles,
+            missingFiles,
+            issues: [`Invalid manifest lock: ${readResult.message}`],
+        };
+    }
+    for (const lockedFile of readResult.lock.files) {
+        const filePath = path.join(projectRoot, lockedFile.relativePath);
+        try {
+            ensureInside(projectRoot, filePath);
+        }
+        catch {
+            issues.push(`Locked file path escapes project root: ${lockedFile.relativePath}`);
+            continue;
+        }
+        if (!existsSync(filePath)) {
+            missingFiles.push(lockedFile.relativePath);
+            issues.push(`Locked file missing: ${lockedFile.relativePath}`);
+            continue;
+        }
+        const actualHash = sha256File(filePath);
+        if (actualHash !== lockedFile.contentHash) {
+            changedFiles.push(lockedFile.relativePath);
+            issues.push(`Lock hash mismatch: ${lockedFile.relativePath}`);
+        }
+    }
+    return { readResult, changedFiles, missingFiles, issues };
+}

package/dist/cli/lib/npm-version-check.js

@@ -0,0 +1,97 @@
+const DEFAULT_NPM_REGISTRY_URL = 'https://registry.npmjs.org';
+const DEFAULT_VERSION_CHECK_TIMEOUT_MS = 3_000;
+function isRecord(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function parseSemver(version) {
+    const match = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[-0-9A-Za-z.]+)?$/u.exec(version.trim());
+    if (!match) {
+        return null;
+    }
+    return {
+        major: Number(match[1]),
+        minor: Number(match[2]),
+        patch: Number(match[3]),
+        prerelease: match[4] ? match[4].split('.') : null,
+    };
+}
+function comparePrerelease(left, right) {
+    if (!left && !right)
+        return 0;
+    if (!left)
+        return 1;
+    if (!right)
+        return -1;
+    const length = Math.max(left.length, right.length);
+    for (let index = 0; index < length; index += 1) {
+        const leftPart = left[index];
+        const rightPart = right[index];
+        if (leftPart === undefined)
+            return -1;
+        if (rightPart === undefined)
+            return 1;
+        if (leftPart === rightPart)
+            continue;
+        const leftNumber = /^\d+$/u.test(leftPart) ? Number(leftPart) : null;
+        const rightNumber = /^\d+$/u.test(rightPart) ? Number(rightPart) : null;
+        if (leftNumber !== null && rightNumber !== null)
+            return Math.sign(leftNumber - rightNumber);
+        if (leftNumber !== null)
+            return -1;
+        if (rightNumber !== null)
+            return 1;
+        return leftPart.localeCompare(rightPart);
+    }
+    return 0;
+}
+export function comparePackageVersions(left, right) {
+    const leftSemver = parseSemver(left);
+    const rightSemver = parseSemver(right);
+    if (!leftSemver || !rightSemver) {
+        return left.localeCompare(right);
+    }
+    for (const key of ['major', 'minor', 'patch']) {
+        const diff = leftSemver[key] - rightSemver[key];
+        if (diff !== 0)
+            return Math.sign(diff);
+    }
+    return comparePrerelease(leftSemver.prerelease, rightSemver.prerelease);
+}
+function getRegistryUrl() {
+    return process.env.MUSTFLOW_NPM_REGISTRY_URL?.trim() || DEFAULT_NPM_REGISTRY_URL;
+}
+function getTimeoutMs() {
+    const rawValue = process.env.MUSTFLOW_VERSION_CHECK_TIMEOUT_MS;
+    const parsed = rawValue ? Number(rawValue) : DEFAULT_VERSION_CHECK_TIMEOUT_MS;
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : DEFAULT_VERSION_CHECK_TIMEOUT_MS;
+}
+function buildLatestPackageUrl(registryUrl, packageName) {
+    const trimmedRegistryUrl = registryUrl.replace(/\/+$/u, '');
+    const encodedPackageName = packageName.startsWith('@')
+        ? `@${encodeURIComponent(packageName.slice(1))}`
+        : encodeURIComponent(packageName);
+    return `${trimmedRegistryUrl}/${encodedPackageName}/latest`;
+}
+export async function checkNpmLatestVersion(metadata) {
+    const registryUrl = getRegistryUrl();
+    const response = await fetch(buildLatestPackageUrl(registryUrl, metadata.name), {
+        headers: { accept: 'application/json' },
+        signal: AbortSignal.timeout(getTimeoutMs()),
+    });
+    if (!response.ok) {
+        throw new Error(`npm registry returned HTTP ${response.status}`);
+    }
+    const body = await response.json();
+    const latestVersion = isRecord(body) && typeof body.version === 'string' ? body.version : '';
+    if (!latestVersion) {
+        throw new Error('npm registry response did not include a version');
+    }
+    return {
+        packageName: metadata.name,
+        currentVersion: metadata.version,
+        latestVersion,
+        updateAvailable: comparePackageVersions(metadata.version, latestVersion) < 0,
+        registryUrl,
+        updateCommand: `npm install -g ${metadata.name}@latest`,
+    };
+}

package/dist/cli/lib/package-info.js

@@ -0,0 +1,13 @@
+import { readFileSync } from 'node:fs';
+export function readPackageMetadata() {
+    const packageUrl = new URL('../../../package.json', import.meta.url);
+    const rawPackageJson = readFileSync(packageUrl, 'utf8');
+    const parsed = JSON.parse(rawPackageJson);
+    return {
+        name: typeof parsed.name === 'string' ? parsed.name : 'mustflow',
+        version: typeof parsed.version === 'string' ? parsed.version : '0.0.0',
+    };
+}
+export function getPackageVersion() {
+    return readPackageMetadata().version;
+}

package/dist/cli/lib/preferences-options.js

@@ -0,0 +1,8 @@
+export const COMMIT_MESSAGE_STYLES = ['conventional', 'descriptive', 'gitmoji'];
+export const TEST_AUTHORING_POLICIES = ['evidence_required', 'manual_approval', 'broad'];
+export function isCommitMessageStyle(value) {
+    return COMMIT_MESSAGE_STYLES.includes(value);
+}
+export function isTestAuthoringPolicy(value) {
+    return TEST_AUTHORING_POLICIES.includes(value);
+}

package/dist/cli/lib/project-root.js

@@ -0,0 +1,23 @@
+import { existsSync } from 'node:fs';
+import path from 'node:path';
+function hasMustflowMarker(directoryPath) {
+    return (existsSync(path.join(directoryPath, '.mustflow', 'config', 'mustflow.toml')) ||
+        existsSync(path.join(directoryPath, '.mustflow', 'config', 'commands.toml')) ||
+        existsSync(path.join(directoryPath, '.mustflow')));
+}
+export function findMustflowRoot(startPath = process.cwd()) {
+    let current = path.resolve(startPath);
+    while (true) {
+        if (hasMustflowMarker(current)) {
+            return current;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            return undefined;
+        }
+        current = parent;
+    }
+}
+export function resolveMustflowRoot(startPath = process.cwd()) {
+    return findMustflowRoot(startPath) ?? path.resolve(startPath);
+}