mustflow 1.15.97

package/dist/cli/lib/filesystem.js

@@ -0,0 +1,125 @@
+import { closeSync, constants, copyFileSync, existsSync, lstatSync, mkdirSync, openSync, readFileSync, readdirSync, statSync, writeFileSync, } from 'node:fs';
+import path from 'node:path';
+const NOFOLLOW_FLAG = typeof constants.O_NOFOLLOW === 'number' ? constants.O_NOFOLLOW : 0;
+export function toPosixPath(value) {
+    return value.split(path.sep).join('/');
+}
+export function ensureInside(parentPath, childPath) {
+    const parent = path.resolve(parentPath);
+    const child = path.resolve(childPath);
+    const relative = path.relative(parent, child);
+    if (relative === '' || (!relative.startsWith('..') && !path.isAbsolute(relative))) {
+        return;
+    }
+    throw new Error(`Path escapes allowed directory: ${childPath}`);
+}
+function isMissingPathError(error) {
+    return error instanceof Error && 'code' in error && error.code === 'ENOENT';
+}
+export function ensureInsideWithoutSymlinks(parentPath, childPath, options = {}) {
+    ensureInside(parentPath, childPath);
+    const parent = path.resolve(parentPath);
+    const child = path.resolve(childPath);
+    const relative = path.relative(parent, child);
+    const segments = relative === '' ? [] : relative.split(path.sep).filter((segment) => segment.length > 0);
+    let currentPath = parent;
+    const parentStats = lstatSync(parent);
+    if (parentStats.isSymbolicLink()) {
+        throw new Error(`Path must not contain symlinks: ${childPath}`);
+    }
+    for (const [index, segment] of segments.entries()) {
+        currentPath = path.join(currentPath, segment);
+        const isLeaf = index === segments.length - 1;
+        try {
+            const stats = lstatSync(currentPath);
+            if (stats.isSymbolicLink()) {
+                throw new Error(`Path must not contain symlinks: ${childPath}`);
+            }
+            if (!isLeaf && !stats.isDirectory()) {
+                throw new Error(`Path component is not a directory: ${currentPath}`);
+            }
+        }
+        catch (error) {
+            if (isMissingPathError(error) && options.allowMissingLeaf) {
+                return;
+            }
+            throw error;
+        }
+    }
+}
+export function readUtf8FileInsideWithoutSymlinks(parentPath, childPath) {
+    const absoluteChildPath = path.resolve(childPath);
+    ensureInsideWithoutSymlinks(parentPath, absoluteChildPath);
+    const fileDescriptor = openSync(absoluteChildPath, constants.O_RDONLY | NOFOLLOW_FLAG);
+    try {
+        return readFileSync(fileDescriptor, 'utf8');
+    }
+    finally {
+        closeSync(fileDescriptor);
+    }
+}
+export function ensureFileTargetInsideWithoutSymlinks(parentPath, childPath, options = {}) {
+    const absoluteChildPath = path.resolve(childPath);
+    ensureInside(parentPath, absoluteChildPath);
+    ensureInsideWithoutSymlinks(parentPath, path.dirname(absoluteChildPath), { allowMissingLeaf: true });
+    try {
+        const stats = lstatSync(absoluteChildPath);
+        if (stats.isSymbolicLink()) {
+            throw new Error(`Path must not contain symlinks: ${childPath}`);
+        }
+        if (!stats.isFile()) {
+            throw new Error(`Path must be a regular file: ${childPath}`);
+        }
+    }
+    catch (error) {
+        if (isMissingPathError(error) && options.allowMissingLeaf) {
+            return;
+        }
+        throw error;
+    }
+}
+export function writeUtf8FileInsideWithoutSymlinks(parentPath, childPath, content) {
+    const absoluteChildPath = path.resolve(childPath);
+    const directoryPath = path.dirname(absoluteChildPath);
+    ensureInsideWithoutSymlinks(parentPath, directoryPath, { allowMissingLeaf: true });
+    mkdirSync(directoryPath, { recursive: true });
+    ensureFileTargetInsideWithoutSymlinks(parentPath, absoluteChildPath, { allowMissingLeaf: true });
+    const fileDescriptor = openSync(absoluteChildPath, constants.O_WRONLY | constants.O_CREAT | constants.O_TRUNC | NOFOLLOW_FLAG);
+    try {
+        writeFileSync(fileDescriptor, content);
+    }
+    finally {
+        closeSync(fileDescriptor);
+    }
+}
+export function copyFileIfMissing(sourcePath, targetPath, relativePath) {
+    if (existsSync(targetPath)) {
+        return { status: 'skipped', relativePath };
+    }
+    mkdirSync(path.dirname(targetPath), { recursive: true });
+    copyFileSync(sourcePath, targetPath);
+    return { status: 'created', relativePath };
+}
+export function listFilesRecursive(rootPath, options = {}) {
+    const results = [];
+    function visit(currentPath) {
+        for (const entry of readdirSync(currentPath, { withFileTypes: true })) {
+            const entryPath = path.join(currentPath, entry.name);
+            if (entry.isDirectory()) {
+                if (options.ignoredDirectoryNames?.has(entry.name)) {
+                    continue;
+                }
+                visit(entryPath);
+                continue;
+            }
+            if (entry.isFile()) {
+                results.push(toPosixPath(path.relative(rootPath, entryPath)));
+            }
+        }
+    }
+    if (!existsSync(rootPath) || !statSync(rootPath).isDirectory()) {
+        return [];
+    }
+    visit(rootPath);
+    return results.sort();
+}

package/dist/cli/lib/git-changes.js

@@ -0,0 +1,13 @@
+import { spawnSync } from 'node:child_process';
+import { parseGitStatusOutput } from '../../core/change-classification.js';
+export function readGitChangedFiles(projectRoot) {
+    const result = spawnSync('git', ['status', '--short', '--untracked-files=all'], {
+        cwd: projectRoot,
+        encoding: 'utf8',
+        windowsHide: true,
+    });
+    if (result.status !== 0 || typeof result.stdout !== 'string') {
+        return [];
+    }
+    return parseGitStatusOutput(result.stdout);
+}

package/dist/cli/lib/i18n.js

@@ -0,0 +1,55 @@
+import { enMessages } from '../i18n/en.js';
+import { esMessages } from '../i18n/es.js';
+import { frMessages } from '../i18n/fr.js';
+import { hiMessages } from '../i18n/hi.js';
+import { koMessages } from '../i18n/ko.js';
+import { zhMessages } from '../i18n/zh.js';
+export const MESSAGE_CATALOGS = {
+    en: enMessages,
+    ko: koMessages,
+    zh: zhMessages,
+    es: esMessages,
+    fr: frMessages,
+    hi: hiMessages,
+};
+export const DEFAULT_CLI_LANG = 'en';
+export const SUPPORTED_CLI_LANGS = Object.keys(MESSAGE_CATALOGS);
+export function isCliLang(value) {
+    return value in MESSAGE_CATALOGS;
+}
+function interpolate(template, params) {
+    return template.replace(/\{([a-zA-Z0-9_]+)\}/g, (match, key) => {
+        const value = params[key];
+        return value === undefined || value === null ? match : String(value);
+    });
+}
+export function t(lang, key, params = {}) {
+    return interpolate(MESSAGE_CATALOGS[lang][key] ?? enMessages[key], params);
+}
+export function localeMessage(locale, key, params = {}) {
+    return t(isCliLang(locale) ? locale : DEFAULT_CLI_LANG, key, params);
+}
+export function getMessageCatalogReport() {
+    const sourceKeys = Object.keys(enMessages);
+    const sourceKeySet = new Set(sourceKeys);
+    const missing = {};
+    const extra = {};
+    for (const [lang, catalog] of Object.entries(MESSAGE_CATALOGS)) {
+        const catalogKeys = Object.keys(catalog);
+        const catalogKeySet = new Set(catalogKeys);
+        const missingKeys = sourceKeys.filter((key) => !catalogKeySet.has(key));
+        const extraKeys = catalogKeys.filter((key) => !sourceKeySet.has(key));
+        if (missingKeys.length > 0) {
+            missing[lang] = missingKeys;
+        }
+        if (extraKeys.length > 0) {
+            extra[lang] = extraKeys;
+        }
+    }
+    return {
+        source: DEFAULT_CLI_LANG,
+        languages: SUPPORTED_CLI_LANGS,
+        missing,
+        extra,
+    };
+}