mustflow 1.15.97

package/dist/cli/index.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import { realpathSync } from 'node:fs';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { runCheck } from './commands/check.js';
+import { runClassify } from './commands/classify.js';
+import { runContractLint } from './commands/contract-lint.js';
+import { runContext } from './commands/context.js';
+import { runDashboard } from './commands/dashboard.js';
+import { runDoctor } from './commands/doctor.js';
+import { runDocs } from './commands/docs.js';
+import { runExplain } from './commands/explain.js';
+import { runHelp } from './commands/help.js';
+import { runImpact } from './commands/impact.js';
+import { runInit } from './commands/init.js';
+import { runIndex } from './commands/index.js';
+import { runLineEndings } from './commands/line-endings.js';
+import { runMap } from './commands/map.js';
+import { runRun } from './commands/run.js';
+import { runSearch } from './commands/search.js';
+import { runStatus } from './commands/status.js';
+import { runUpdate } from './commands/update.js';
+import { runVerify } from './commands/verify.js';
+import { runVersion } from './commands/version.js';
+import { runVersionSources } from './commands/version-sources.js';
+import { COMMAND_DEFINITIONS } from './lib/command-registry.js';
+import { renderCliError, renderHelp } from './lib/cli-output.js';
+import { DEFAULT_CLI_LANG, SUPPORTED_CLI_LANGS, isCliLang, t } from './lib/i18n.js';
+import { consoleReporter } from './lib/reporter.js';
+function getTopLevelHelp(lang) {
+    return renderHelp({
+        usage: 'mf [--lang <lang>] <command> [options]',
+        commands: COMMAND_DEFINITIONS.map((command) => ({
+            label: command.usage,
+            description: t(lang, command.summaryKey),
+        })),
+        options: [
+            {
+                label: '--lang <lang>',
+                description: t(lang, 'top.help.option.lang', { languages: SUPPORTED_CLI_LANGS.join(', ') }),
+            },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+            { label: '-v, --version', description: t(lang, 'top.help.option.version') },
+        ],
+        examples: [
+            'mf --lang ko help',
+            'mf init --dry-run',
+            'mf doctor --json',
+            'mf docs review list',
+            'mf check --json',
+            'mf classify --changed',
+            'mf contract-lint --json',
+            'mf context --json',
+            'mf map --write',
+            'mf search mustflow_check',
+            'mf explain authority AGENTS.md',
+            'mf impact --changed',
+            'mf verify --reason code_change',
+            'mf line-endings check',
+            'mf version --check',
+            'mf version-sources --json',
+        ],
+        exitCodes: [
+            {
+                label: '0',
+                description: t(lang, 'top.help.exit.ok'),
+            },
+            {
+                label: '1',
+                description: t(lang, 'top.help.exit.fail'),
+            },
+        ],
+    }, lang);
+}
+function getErrorMessage(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function parseGlobalOptions(argv) {
+    let lang = DEFAULT_CLI_LANG;
+    const args = [];
+    for (let index = 0; index < argv.length; index += 1) {
+        const arg = argv[index];
+        if (!arg) {
+            continue;
+        }
+        if (arg === '--lang') {
+            const value = argv[index + 1];
+            if (!value || value.startsWith('-')) {
+                return { lang, args, error: t(lang, 'cli.error.missingLangValue') };
+            }
+            if (!isCliLang(value)) {
+                return { lang, args, error: t(lang, 'cli.error.unsupportedLanguage', { language: value }) };
+            }
+            lang = value;
+            index += 1;
+            continue;
+        }
+        if (arg.startsWith('--lang=')) {
+            const value = arg.slice('--lang='.length);
+            if (!isCliLang(value)) {
+                return { lang, args, error: t(lang, 'cli.error.unsupportedLanguage', { language: value }) };
+            }
+            lang = value;
+            continue;
+        }
+        args.push(arg);
+    }
+    return { lang, args };
+}
+export async function runCli(argv, reporter = consoleReporter) {
+    const parsed = parseGlobalOptions(argv);
+    const [command, ...args] = parsed.args;
+    if (parsed.error) {
+        reporter.stderr(renderCliError(parsed.error, 'mf --help', parsed.lang));
+        reporter.stdout(getTopLevelHelp(parsed.lang));
+        return 1;
+    }
+    if (!command || command === '--help' || command === '-h') {
+        reporter.stdout(getTopLevelHelp(parsed.lang));
+        return 0;
+    }
+    if (command === '--version' || command === '-v' || command === 'version') {
+        return runVersion(args, reporter, parsed.lang);
+    }
+    if (command === 'init') {
+        return runInit(args, reporter, parsed.lang);
+    }
+    if (command === 'check') {
+        return runCheck(args, reporter, parsed.lang);
+    }
+    if (command === 'classify') {
+        return runClassify(args, reporter, parsed.lang);
+    }
+    if (command === 'contract-lint') {
+        return runContractLint(args, reporter, parsed.lang);
+    }
+    if (command === 'status') {
+        return runStatus(args, reporter, parsed.lang);
+    }
+    if (command === 'update') {
+        return runUpdate(args, reporter, parsed.lang);
+    }
+    if (command === 'map') {
+        return runMap(args, reporter, parsed.lang);
+    }
+    if (command === 'line-endings') {
+        return runLineEndings(args, reporter, parsed.lang);
+    }
+    if (command === 'run') {
+        return runRun(args, reporter, parsed.lang);
+    }
+    if (command === 'context') {
+        return runContext(args, reporter, parsed.lang);
+    }
+    if (command === 'doctor') {
+        return runDoctor(args, reporter, parsed.lang);
+    }
+    if (command === 'docs') {
+        return runDocs(args, reporter, parsed.lang);
+    }
+    if (command === 'index') {
+        return runIndex(args, reporter, parsed.lang);
+    }
+    if (command === 'search') {
+        return runSearch(args, reporter, parsed.lang);
+    }
+    if (command === 'dashboard') {
+        return runDashboard(args, reporter, parsed.lang);
+    }
+    if (command === 'version-sources') {
+        return runVersionSources(args, reporter, parsed.lang);
+    }
+    if (command === 'verify') {
+        return runVerify(args, reporter, parsed.lang);
+    }
+    if (command === 'explain') {
+        return runExplain(args, reporter, parsed.lang);
+    }
+    if (command === 'impact') {
+        return runImpact(args, reporter, parsed.lang);
+    }
+    if (command === 'help') {
+        return runHelp(args, reporter, parsed.lang);
+    }
+    reporter.stderr(renderCliError(t(parsed.lang, 'cli.error.unknownCommand', { command }), 'mf --help', parsed.lang));
+    reporter.stdout(getTopLevelHelp(parsed.lang));
+    return 1;
+}
+function isDirectRun() {
+    const entrypoint = process.argv[1];
+    if (!entrypoint) {
+        return false;
+    }
+    const currentFile = fileURLToPath(import.meta.url);
+    const resolvedEntrypoint = path.resolve(entrypoint);
+    const resolvedCurrentFile = path.resolve(currentFile);
+    if (resolvedEntrypoint === resolvedCurrentFile) {
+        return true;
+    }
+    try {
+        return realpathSync.native(resolvedEntrypoint) === realpathSync.native(resolvedCurrentFile);
+    }
+    catch {
+        return false;
+    }
+}
+async function main() {
+    try {
+        process.exitCode = await runCli(process.argv.slice(2));
+    }
+    catch (error) {
+        consoleReporter.stderr(renderCliError(getErrorMessage(error), 'mf --help'));
+        process.exitCode = 1;
+    }
+}
+if (isDirectRun()) {
+    void main();
+}

package/dist/cli/lib/agent-context.js

@@ -0,0 +1,342 @@
+import { existsSync, readFileSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import path from 'node:path';
+import { isRecord, readPositiveInteger, readString, readStringArray, } from './command-contract.js';
+import { readRetentionStore } from '../../core/retention-policy.js';
+import { toPosixPath } from './filesystem.js';
+import { inspectManifestLock } from './manifest-lock.js';
+import { readTomlFile } from './toml.js';
+const CONTEXT_SCHEMA_VERSION = '1';
+const COMMANDS_RELATIVE_PATH = '.mustflow/config/commands.toml';
+const MUSTFLOW_RELATIVE_PATH = '.mustflow/config/mustflow.toml';
+const PREFERENCES_RELATIVE_PATH = '.mustflow/config/preferences.toml';
+const LATEST_RUN_RELATIVE_PATH = '.mustflow/state/runs/latest.json';
+const CACHE_RELATIVE_PATH = '.mustflow/cache/';
+const STATE_RELATIVE_PATH = '.mustflow/state/';
+const DEFAULT_PROMPT_CACHE_STABLE_READ = [
+    'AGENTS.md',
+    '.mustflow/docs/agent-workflow.md',
+    '.mustflow/config/mustflow.toml',
+    '.mustflow/config/commands.toml',
+    '.mustflow/skills/INDEX.md',
+];
+const DEFAULT_PROMPT_CACHE_TASK_SOURCES = [
+    '.mustflow/context/INDEX.md',
+    'REPO_MAP.md',
+    'matching_skill',
+    'relevant_source_files',
+];
+const DEFAULT_PROMPT_CACHE_VOLATILE_SOURCES = [
+    '.mustflow/state/runs/latest.json',
+    'changed_files',
+    'command_output_tail',
+    'current_user_task',
+];
+const BLOCKED_ACTIONS = [
+    'unconfigured_project_command',
+    'unmanaged_long_running_process',
+    'auto_push',
+    'raw_transcript_storage',
+];
+function safeExists(projectRoot, relativePath) {
+    const resolved = path.resolve(projectRoot, ...relativePath.split('/'));
+    const root = path.resolve(projectRoot);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative)) {
+        return false;
+    }
+    return existsSync(resolved);
+}
+function safeRead(projectRoot, relativePath) {
+    const resolved = path.resolve(projectRoot, ...relativePath.split('/'));
+    const root = path.resolve(projectRoot);
+    const relative = path.relative(root, resolved);
+    if (relative.startsWith('..') || path.isAbsolute(relative) || !existsSync(resolved)) {
+        return null;
+    }
+    return readFileSync(resolved, 'utf8');
+}
+function readTomlTableIfExists(projectRoot, relativePath) {
+    const filePath = path.join(projectRoot, ...relativePath.split('/'));
+    if (!existsSync(filePath)) {
+        return undefined;
+    }
+    const parsed = readTomlFile(filePath);
+    return isRecord(parsed) ? parsed : undefined;
+}
+function readNestedTable(table, key) {
+    if (!table || !isRecord(table[key])) {
+        return undefined;
+    }
+    return table[key];
+}
+function readBoolean(table, key, fallback) {
+    const value = table?.[key];
+    return typeof value === 'boolean' ? value : fallback;
+}
+function readOptionalString(table, key) {
+    return table ? readString(table, key) ?? null : null;
+}
+function readOptionalStringArray(table, key) {
+    return table ? readStringArray(table, key) ?? null : null;
+}
+function readNumber(table, key) {
+    const value = table?.[key];
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+function readPathContext(projectRoot, paths) {
+    return paths.map((relativePath) => ({
+        path: toPosixPath(relativePath),
+        exists: safeExists(projectRoot, relativePath),
+    }));
+}
+function readScalarObject(table) {
+    if (!table) {
+        return {};
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(table)) {
+        if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean' || value === null) {
+            result[key] = value;
+            continue;
+        }
+        if (Array.isArray(value) && value.every((entry) => typeof entry === 'string')) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function sha256(content) {
+    return `sha256:${createHash('sha256').update(content).digest('hex')}`;
+}
+function isRunnableIntent(intent) {
+    return (readString(intent, 'status') === 'configured' &&
+        readString(intent, 'lifecycle') === 'oneshot' &&
+        readString(intent, 'run_policy') === 'agent_allowed' &&
+        intent.stdin === 'closed' &&
+        Boolean(readPositiveInteger(intent, 'timeout_seconds')));
+}
+function readCommandContractContext(projectRoot) {
+    const commands = readTomlTableIfExists(projectRoot, COMMANDS_RELATIVE_PATH);
+    if (!commands || !isRecord(commands.intents)) {
+        return {
+            path: COMMANDS_RELATIVE_PATH,
+            exists: safeExists(projectRoot, COMMANDS_RELATIVE_PATH),
+            intents: [],
+            runnable_intents: [],
+        };
+    }
+    const intents = [];
+    const runnableIntents = [];
+    for (const [name, intent] of Object.entries(commands.intents).sort(([left], [right]) => left.localeCompare(right))) {
+        if (!isRecord(intent)) {
+            continue;
+        }
+        const status = readString(intent, 'status') ?? 'unknown';
+        const lifecycle = readString(intent, 'lifecycle') ?? null;
+        const runPolicy = readString(intent, 'run_policy') ?? null;
+        intents.push({
+            name,
+            status,
+            lifecycle,
+            run_policy: runPolicy,
+            description: readString(intent, 'description') ?? null,
+        });
+        if (isRunnableIntent(intent)) {
+            runnableIntents.push(name);
+        }
+    }
+    return {
+        path: COMMANDS_RELATIVE_PATH,
+        exists: true,
+        intents,
+        runnable_intents: runnableIntents,
+    };
+}
+function readEffectivePolicyContext(mustflow, preferences) {
+    const verification = readNestedTable(mustflow, 'verification');
+    const retention = readNestedTable(mustflow, 'retention');
+    const git = readNestedTable(preferences, 'git');
+    const allowInferredCommands = readBoolean(verification, 'allow_inferred_commands', false);
+    const requireConfiguredIntents = readBoolean(verification, 'require_configured_intents', true);
+    const rawEventsStore = readRetentionStore(retention, 'raw_events') ?? 'none';
+    return {
+        entrypoint: 'AGENTS.md',
+        nearest_agents: 'AGENTS.md',
+        command_contract: COMMANDS_RELATIVE_PATH,
+        project_commands_require_mf_run: requireConfiguredIntents && !allowInferredCommands,
+        allow_inferred_commands: allowInferredCommands,
+        auto_stage: readBoolean(git, 'auto_stage', false),
+        auto_commit: readBoolean(git, 'auto_commit', false),
+        auto_push: readBoolean(git, 'auto_push', false),
+        state_is_versioned: false,
+        raw_logs_allowed: rawEventsStore !== 'none',
+    };
+}
+function readStatePolicyContext() {
+    return {
+        cache_path: CACHE_RELATIVE_PATH,
+        state_path: STATE_RELATIVE_PATH,
+        versioned: false,
+        safe_to_delete: true,
+        stores_raw_conversation: false,
+        stores_full_terminal_output: false,
+        stores_hidden_chain_of_thought: false,
+    };
+}
+function readLatestRunContext(projectRoot) {
+    const latestPath = path.join(projectRoot, ...LATEST_RUN_RELATIVE_PATH.split('/'));
+    if (!existsSync(latestPath)) {
+        return {
+            path: LATEST_RUN_RELATIVE_PATH,
+            exists: false,
+        };
+    }
+    try {
+        const parsed = JSON.parse(readFileSync(latestPath, 'utf8'));
+        if (!isRecord(parsed)) {
+            throw new Error('latest run receipt must contain a JSON object');
+        }
+        return {
+            path: LATEST_RUN_RELATIVE_PATH,
+            exists: true,
+            valid: true,
+            intent: typeof parsed.intent === 'string' ? parsed.intent : 'unknown',
+            status: typeof parsed.status === 'string' ? parsed.status : 'unknown',
+            timed_out: parsed.timed_out === true,
+            exit_code: typeof parsed.exit_code === 'number' ? parsed.exit_code : null,
+            finished_at: typeof parsed.finished_at === 'string' ? parsed.finished_at : null,
+            duration_ms: typeof parsed.duration_ms === 'number' ? parsed.duration_ms : null,
+        };
+    }
+    catch (error) {
+        return {
+            path: LATEST_RUN_RELATIVE_PATH,
+            exists: true,
+            valid: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+function readPromptCacheSettings(mustflow) {
+    const promptCache = readNestedTable(mustflow, 'prompt_cache');
+    return {
+        enabled: readBoolean(promptCache, 'enabled', false),
+        strategy: readOptionalString(promptCache, 'strategy'),
+        stable_prefix_policy: readOptionalString(promptCache, 'stable_prefix_policy'),
+        prefer_references_when_unchanged: readBoolean(promptCache, 'prefer_references_when_unchanged', false),
+        exclude_volatile_state_from_prefix: readBoolean(promptCache, 'exclude_volatile_state_from_prefix', false),
+        include_content_hashes: readBoolean(promptCache, 'include_content_hashes', false),
+        max_stable_prefix_kb: readNumber(promptCache, 'max_stable_prefix_kb'),
+        max_task_context_kb: readNumber(promptCache, 'max_task_context_kb'),
+        max_volatile_suffix_kb: readNumber(promptCache, 'max_volatile_suffix_kb'),
+    };
+}
+function readPromptCacheLayer(mustflow, name) {
+    const promptCache = readNestedTable(mustflow, 'prompt_cache');
+    const layers = readNestedTable(promptCache, 'layers');
+    return readNestedTable(layers, name);
+}
+function readStablePromptCacheLayer(projectRoot, mustflow) {
+    const promptCache = readNestedTable(mustflow, 'prompt_cache');
+    const layer = readPromptCacheLayer(mustflow, 'stable');
+    const volatileLayer = readPromptCacheLayer(mustflow, 'volatile');
+    const read = readOptionalStringArray(layer, 'read') ?? [...DEFAULT_PROMPT_CACHE_STABLE_READ];
+    const documents = read.map((relativePath) => {
+        const content = safeRead(projectRoot, relativePath);
+        return {
+            path: toPosixPath(relativePath),
+            exists: content !== null,
+            content_hash: content === null ? null : sha256(content),
+        };
+    });
+    const cacheMaterial = documents
+        .map((document) => `${document.path}\0${document.content_hash ?? 'missing'}`)
+        .join('\n');
+    return {
+        cache_layer: 'stable',
+        cache_key: documents.length === 0 ? null : sha256(cacheMaterial),
+        policy: readOptionalString(promptCache, 'stable_prefix_policy'),
+        documents,
+        volatile_excluded: readOptionalStringArray(volatileLayer, 'sources') ?? [...DEFAULT_PROMPT_CACHE_VOLATILE_SOURCES],
+    };
+}
+function readTaskPromptCacheLayer(mustflow) {
+    const layer = readPromptCacheLayer(mustflow, 'task');
+    return {
+        cache_layer: 'task',
+        read_policy: readOptionalString(layer, 'read_policy'),
+        sources: readOptionalStringArray(layer, 'sources') ?? [...DEFAULT_PROMPT_CACHE_TASK_SOURCES],
+    };
+}
+function readVolatilePromptCacheLayer(mustflow) {
+    const layer = readPromptCacheLayer(mustflow, 'volatile');
+    return {
+        cache_layer: 'volatile',
+        sources: readOptionalStringArray(layer, 'sources') ?? [...DEFAULT_PROMPT_CACHE_VOLATILE_SOURCES],
+        never_place_before_stable_prefix: readBoolean(layer, 'never_place_before_stable_prefix', false),
+        include_absolute_root: false,
+        include_latest_run: false,
+    };
+}
+export function getPromptCacheProfileContext(projectRoot, profile) {
+    const mustflow = readTomlTableIfExists(projectRoot, MUSTFLOW_RELATIVE_PATH);
+    const lockInspection = inspectManifestLock(projectRoot);
+    const output = {
+        schema_version: CONTEXT_SCHEMA_VERSION,
+        command: 'context',
+        cache_profile: profile,
+        prompt_cache: readPromptCacheSettings(mustflow),
+        issues: lockInspection.issues,
+    };
+    if (profile === 'stable' || profile === 'all') {
+        return {
+            ...output,
+            stable_prefix: readStablePromptCacheLayer(projectRoot, mustflow),
+            ...(profile === 'all'
+                ? {
+                    task_context: readTaskPromptCacheLayer(mustflow),
+                    volatile_suffix: readVolatilePromptCacheLayer(mustflow),
+                }
+                : {}),
+        };
+    }
+    if (profile === 'task') {
+        return {
+            ...output,
+            task_context: readTaskPromptCacheLayer(mustflow),
+        };
+    }
+    return {
+        ...output,
+        volatile_suffix: readVolatilePromptCacheLayer(mustflow),
+    };
+}
+export function getAgentContext(projectRoot) {
+    const mustflow = readTomlTableIfExists(projectRoot, MUSTFLOW_RELATIVE_PATH);
+    const preferences = readTomlTableIfExists(projectRoot, PREFERENCES_RELATIVE_PATH);
+    const authority = isRecord(mustflow?.authority) ? mustflow.authority : undefined;
+    const capabilities = isRecord(mustflow?.capabilities) ? mustflow.capabilities : undefined;
+    const readOrder = mustflow ? readStringArray(mustflow, 'read_order') ?? [] : [];
+    const optionalReadOrder = mustflow ? readStringArray(mustflow, 'optional_read_order') ?? [] : [];
+    const lockInspection = inspectManifestLock(projectRoot);
+    const lock = lockInspection.readResult.kind === 'present' ? lockInspection.readResult.lock : undefined;
+    return {
+        schema_version: CONTEXT_SCHEMA_VERSION,
+        command: 'context',
+        mustflow_root: path.resolve(projectRoot),
+        installed: safeExists(projectRoot, 'AGENTS.md') && safeExists(projectRoot, '.mustflow'),
+        manifest_lock: lockInspection.readResult.kind,
+        template: lock ? { id: lock.templateId, version: lock.templateVersion } : null,
+        authority: readScalarObject(authority),
+        capabilities: readScalarObject(capabilities),
+        read_order: readPathContext(projectRoot, readOrder),
+        optional_read_order: readPathContext(projectRoot, optionalReadOrder),
+        command_contract: readCommandContractContext(projectRoot),
+        effective_policy: readEffectivePolicyContext(mustflow, preferences),
+        state_policy: readStatePolicyContext(),
+        blocked_actions: BLOCKED_ACTIONS,
+        latest_run: readLatestRunContext(projectRoot),
+        issues: lockInspection.issues,
+    };
+}

package/dist/cli/lib/browser-open.js

@@ -0,0 +1,58 @@
+import { spawn } from 'node:child_process';
+function spawnDetached(bin, args) {
+    return spawn(bin, [...args], {
+        detached: true,
+        stdio: 'ignore',
+        windowsHide: true,
+    });
+}
+export function getBrowserOpenCommand(url, platform = process.platform) {
+    if (platform === 'win32') {
+        return { bin: 'cmd', args: ['/c', 'start', '', url] };
+    }
+    if (platform === 'darwin') {
+        return { bin: 'open', args: [url] };
+    }
+    if (platform === 'linux' || platform === 'freebsd' || platform === 'openbsd') {
+        return { bin: 'xdg-open', args: [url] };
+    }
+    return undefined;
+}
+export function getFileManagerOpenCommand(targetPath, platform = process.platform) {
+    if (platform === 'win32') {
+        return { bin: 'cmd', args: ['/c', 'start', '', targetPath] };
+    }
+    if (platform === 'darwin') {
+        return { bin: 'open', args: [targetPath] };
+    }
+    if (platform === 'linux' || platform === 'freebsd' || platform === 'openbsd') {
+        return { bin: 'xdg-open', args: [targetPath] };
+    }
+    return undefined;
+}
+export function openUrlInBrowser(url, options = {}) {
+    const command = getBrowserOpenCommand(url, options.platform);
+    if (!command) {
+        return false;
+    }
+    const spawnProcess = options.spawnProcess ?? spawnDetached;
+    const child = spawnProcess(command.bin, command.args);
+    child.once('error', () => {
+        // The dashboard URL is still printed, so browser-open failure must not stop the server.
+    });
+    child.unref();
+    return true;
+}
+export function openPathInFileManager(targetPath, options = {}) {
+    const command = getFileManagerOpenCommand(targetPath, options.platform);
+    if (!command) {
+        return false;
+    }
+    const spawnProcess = options.spawnProcess ?? spawnDetached;
+    const child = spawnProcess(command.bin, command.args);
+    child.once('error', () => {
+        // The dashboard can report the failure through the API response path.
+    });
+    child.unref();
+    return true;
+}

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

@@ -0,0 +1,36 @@
+import { t } from './i18n.js';
+function renderEntries(entries) {
+    const width = Math.max(...entries.map((entry) => entry.label.length));
+    return entries.map((entry) => `  ${entry.label.padEnd(width)}  ${entry.description}`).join('\n');
+}
+function pushEntrySection(lines, title, entries) {
+    if (!entries || entries.length === 0) {
+        return;
+    }
+    lines.push(`${title}:`, renderEntries(entries), '');
+}
+function pushExamples(lines, title, examples) {
+    if (!examples || examples.length === 0) {
+        return;
+    }
+    lines.push(`${title}:`, ...examples.map((example) => `  ${example}`), '');
+}
+export function renderHelp(spec, lang = 'en') {
+    const lines = [`${t(lang, 'cli.heading.usage')}: ${spec.usage}`, ''];
+    if (spec.summary) {
+        lines.push(spec.summary, '');
+    }
+    pushEntrySection(lines, t(lang, 'cli.heading.commands'), spec.commands);
+    pushEntrySection(lines, t(lang, 'cli.heading.topics'), spec.topics);
+    pushEntrySection(lines, t(lang, 'cli.heading.options'), spec.options);
+    pushExamples(lines, t(lang, 'cli.heading.examples'), spec.examples);
+    pushEntrySection(lines, t(lang, 'cli.heading.exitCodes'), spec.exitCodes);
+    return `${lines.join('\n').trimEnd()}\n`;
+}
+export function renderCliError(message, helpCommand, lang = 'en') {
+    return t(lang, 'cli.error.withUsage', { message, helpCommand });
+}
+export function printUsageError(reporter, message, helpCommand, helpText, lang = 'en') {
+    reporter.stderr(renderCliError(message, helpCommand, lang));
+    reporter.stdout(helpText);
+}

package/dist/cli/lib/command-contract.js

@@ -0,0 +1 @@
+export { COMMAND_LIFECYCLES, COMMAND_RUN_POLICIES, LONG_RUNNING_LIFECYCLES, readCommandContract, readPositiveInteger, readString, readStringArray, resolveMustflowConfigPath, isRecord, } from '../../core/config-loading.js';