mustflow 1.30.0 → 2.11.0

package/dist/cli/commands/run.js

@@ -1,17 +1,8 @@
-import { spawnSync } from 'node:child_process';
-import { runCheck } from './check.js';
-import { runClassify } from './classify.js';
-import { runContext } from './context.js';
-import { runDoctor } from './doctor.js';
-import { runHelp } from './help.js';
-import { runImpact } from './impact.js';
-import { runLineEndings } from './line-endings.js';
-import { runMap } from './map.js';
-import { runStatus } from './status.js';
-import { runUpdate } from './update.js';
-import { runVersionSources } from './version-sources.js';
+import { spawn, spawnSync } from 'node:child_process';
+import { performance } from 'node:perf_hooks';
 import { canRunMustflowBuiltinInProcess, isMustflowBinName } from '../../core/command-classification.js';
 import { createCommandEnv } from '../../core/command-env.js';
+import { BoundedOutputBuffer } from '../../core/bounded-output.js';
 import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
 import { readCommandContract, readMustflowConfigIfExists } from '../../core/config-loading.js';
 import { resolveRunReceiptRetentionPolicy } from '../../core/retention-policy.js';
@@ -20,12 +11,14 @@ import { getPackageVersion } from '../lib/package-info.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { createRunPlan, createRunPreview, isMustflowBuiltinIntent, renderRunPreviewText, } from '../lib/run-plan.js';
 import { createRunReceipt, writeRunReceipt } from '../../core/run-receipt.js';
+import { recordRunPerformanceHistory } from '../../core/run-performance-history.js';
+import { RunProfiler } from '../../core/run-profile.js';
 import { finishRunWriteTracking, startRunWriteTracking } from '../../core/run-write-drift.js';
 function emitOutput(reporter, output, stream) {
     if (!output) {
         return;
     }
-    const text = output.toString().trimEnd();
+    const text = (typeof output === 'object' && 'tail' in output ? output.tail : output.toString()).trimEnd();
     if (text.length === 0) {
         return;
     }
@@ -94,37 +87,37 @@ async function runKnownBuiltinCommand(args, reporter, lang) {
         return undefined;
     }
     if (command === 'check') {
-        return runCheck(commandArgs, reporter, lang);
+        return (await import('./check.js')).runCheck(commandArgs, reporter, lang);
     }
     if (command === 'classify') {
-        return runClassify(commandArgs, reporter, lang);
+        return (await import('./classify.js')).runClassify(commandArgs, reporter, lang);
     }
     if (command === 'context') {
-        return runContext(commandArgs, reporter, lang);
+        return (await import('./context.js')).runContext(commandArgs, reporter, lang);
     }
     if (command === 'doctor') {
-        return runDoctor(commandArgs, reporter, lang);
+        return (await import('./doctor.js')).runDoctor(commandArgs, reporter, lang);
     }
     if (command === 'help') {
-        return runHelp(commandArgs, reporter, lang);
+        return (await import('./help.js')).runHelp(commandArgs, reporter, lang);
     }
     if (command === 'impact') {
-        return runImpact(commandArgs, reporter, lang);
+        return (await import('./impact.js')).runImpact(commandArgs, reporter, lang);
     }
     if (command === 'line-endings') {
-        return runLineEndings(commandArgs, reporter, lang);
+        return (await import('./line-endings.js')).runLineEndings(commandArgs, reporter, lang);
     }
     if (command === 'map') {
-        return runMap(commandArgs, reporter, lang);
+        return (await import('./map.js')).runMap(commandArgs, reporter, lang);
     }
     if (command === 'status') {
-        return runStatus(commandArgs, reporter, lang);
+        return (await import('./status.js')).runStatus(commandArgs, reporter, lang);
     }
     if (command === 'update') {
-        return runUpdate(commandArgs, reporter, lang);
+        return (await import('./update.js')).runUpdate(commandArgs, reporter, lang);
     }
     if (command === 'version-sources') {
-        return runVersionSources(commandArgs, reporter, lang);
+        return (await import('./version-sources.js')).runVersionSources(commandArgs, reporter, lang);
     }
     return undefined;
 }
@@ -179,6 +172,76 @@ function runArgvCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
         windowsHide: true,
     });
 }
+function writeStreamChunk(reporter, stream, chunk) {
+    if (stream === 'stdout') {
+        if (reporter.writeStdout) {
+            reporter.writeStdout(chunk);
+            return;
+        }
+        reporter.stdout(chunk.toString().trimEnd());
+        return;
+    }
+    if (reporter.writeStderr) {
+        reporter.writeStderr(chunk);
+        return;
+    }
+    reporter.stderr(chunk.toString().trimEnd());
+}
+function runArgvCommandStreaming(command, cwd, env, timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter) {
+    return new Promise((resolve) => {
+        const stdout = new BoundedOutputBuffer(stdoutTailBytes);
+        const stderr = new BoundedOutputBuffer(stderrTailBytes);
+        let settled = false;
+        let timedOut = false;
+        let childError;
+        let childPid;
+        let timeout;
+        const child = spawn(command?.executable ?? '', command?.args ?? [], {
+            cwd,
+            env,
+            shell: command?.shell ?? false,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: process.platform !== 'win32',
+        });
+        childPid = child.pid;
+        const finish = (status, signal) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            resolve({
+                status,
+                signal,
+                error: timedOut ? Object.assign(new Error('Command timed out'), { code: 'ETIMEDOUT' }) : childError,
+                stdout: stdout.toSnapshot(),
+                stderr: stderr.toSnapshot(),
+                pid: childPid,
+            });
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdout.append(chunk);
+            writeStreamChunk(reporter, 'stdout', chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr.append(chunk);
+            writeStreamChunk(reporter, 'stderr', chunk);
+        });
+        child.once('error', (error) => {
+            childError = error;
+        });
+        child.once('close', (status, signal) => {
+            finish(status, signal);
+        });
+        timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(childPid);
+        }, timeoutSeconds * 1000);
+    });
+}
 function runShellCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
     return spawnSync(command ?? '', {
         cwd,
@@ -192,6 +255,61 @@ function runShellCommand(command, cwd, maxOutputBytes, env, timeoutSeconds) {
         windowsHide: true,
     });
 }
+function runShellCommandStreaming(command, cwd, env, timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter) {
+    return new Promise((resolve) => {
+        const stdout = new BoundedOutputBuffer(stdoutTailBytes);
+        const stderr = new BoundedOutputBuffer(stderrTailBytes);
+        let settled = false;
+        let timedOut = false;
+        let childError;
+        let childPid;
+        let timeout;
+        const child = spawn(command ?? '', {
+            cwd,
+            env,
+            shell: true,
+            stdio: ['ignore', 'pipe', 'pipe'],
+            windowsHide: true,
+            detached: process.platform !== 'win32',
+        });
+        childPid = child.pid;
+        const finish = (status, signal) => {
+            if (settled) {
+                return;
+            }
+            settled = true;
+            if (timeout) {
+                clearTimeout(timeout);
+            }
+            resolve({
+                status,
+                signal,
+                error: timedOut ? Object.assign(new Error('Command timed out'), { code: 'ETIMEDOUT' }) : childError,
+                stdout: stdout.toSnapshot(),
+                stderr: stderr.toSnapshot(),
+                pid: childPid,
+            });
+        };
+        child.stdout?.on('data', (chunk) => {
+            stdout.append(chunk);
+            writeStreamChunk(reporter, 'stdout', chunk);
+        });
+        child.stderr?.on('data', (chunk) => {
+            stderr.append(chunk);
+            writeStreamChunk(reporter, 'stderr', chunk);
+        });
+        child.once('error', (error) => {
+            childError = error;
+        });
+        child.once('close', (status, signal) => {
+            finish(status, signal);
+        });
+        timeout = setTimeout(() => {
+            timedOut = true;
+            terminateProcessTree(childPid);
+        }, timeoutSeconds * 1000);
+    });
+}
 function getRunStatus(error, exitCode, successExitCodes) {
     const errorWithCode = error;
     if (errorWithCode?.code === 'ETIMEDOUT') {
@@ -249,6 +367,9 @@ function reportRunPlanFailure(plan, reporter, lang) {
             message = t(lang, 'run.error.unknownIntent', { intent: plan.intentName });
             break;
     }
+    if (plan.suggestedIntentSnippet) {
+        message = `${message}\n\n${t(lang, 'run.label.suggestedIntentSnippet')}:\n${plan.suggestedIntentSnippet}`;
+    }
     reporter.stderr(renderCliError(message, 'mf help commands', lang));
 }
 export function getRunHelp(lang = 'en') {
@@ -281,7 +402,9 @@ export function getRunHelp(lang = 'en') {
  * invariant: Execution requires configured status, oneshot lifecycle, agent_allowed policy, and closed stdin.
  * risk: config, security, state
  */
-export async function runRun(args, reporter, lang = 'en') {
+export async function runRun(args, reporter, lang = 'en', options = {}) {
+    const executorStartedAtMs = performance.now();
+    const profiler = new RunProfiler();
     if (args.includes('--help') || args.includes('-h')) {
         reporter.stdout(getRunHelp(lang));
         return 0;
@@ -310,36 +433,69 @@ export async function runRun(args, reporter, lang = 'en') {
         printUsageError(reporter, t(lang, 'cli.error.unexpectedArgument', { argument: extra[0] }), 'mf run --help', getRunHelp(lang), lang);
         return 1;
     }
-    const projectRoot = resolveMustflowRoot();
-    const contract = readCommandContract(projectRoot);
-    const plan = createRunPlan(projectRoot, contract, intentName);
+    const projectRoot = profiler.measure('root_detection', () => resolveMustflowRoot());
+    const contract = profiler.measure('command_contract', () => readCommandContract(projectRoot));
+    const plan = profiler.measure('plan_creation', () => createRunPlan(projectRoot, contract, intentName, { testTargets: options.testTargets }));
     if (previewMode) {
-        if (json) {
-            reporter.stdout(JSON.stringify(createRunPreview(plan, previewMode), null, 2));
-        }
-        else {
-            reporter.stdout(renderRunPreviewText(plan, previewMode));
-        }
+        profiler.measure('preview_render', () => {
+            if (json) {
+                reporter.stdout(JSON.stringify(createRunPreview(plan, previewMode), null, 2));
+            }
+            else {
+                reporter.stdout(renderRunPreviewText(plan, previewMode, lang));
+            }
+        });
+        profiler.writeLatest({
+            projectRoot,
+            intent: intentName,
+            status: plan.ok ? 'previewed' : 'blocked',
+            previewMode,
+        });
         return plan.ok ? 0 : 1;
     }
     if (!plan.ok) {
         reportRunPlanFailure(plan, reporter, lang);
+        profiler.writeLatest({
+            projectRoot,
+            intent: intentName,
+            status: 'blocked',
+            previewMode: null,
+        });
         return 1;
     }
-    const runReceiptPolicy = resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot));
-    const env = createCommandEnv(projectRoot, { policy: plan.envPolicy, allowlist: plan.envAllowlist });
+    const runReceiptPolicy = profiler.measure('retention_policy', () => resolveRunReceiptRetentionPolicy(readMustflowConfigIfExists(projectRoot)));
+    const env = profiler.measure('environment', () => createCommandEnv(projectRoot, { policy: plan.envPolicy, allowlist: plan.envAllowlist }));
     const lifecycleValue = plan.lifecycle ?? 'oneshot';
     const runPolicyValue = plan.runPolicy ?? 'agent_allowed';
-    const writeTracker = startRunWriteTracking(projectRoot, contract, intentName);
+    const writeTracker = profiler.measure('write_drift_before', () => startRunWriteTracking(projectRoot, contract, intentName));
+    const stdoutTailBytes = Math.min(runReceiptPolicy.stdoutTailBytes, plan.maxOutputBytes);
+    const stderrTailBytes = Math.min(runReceiptPolicy.stderrTailBytes, plan.maxOutputBytes);
+    let streamedOutput = false;
+    const childStartedAtMs = performance.now();
     const startedAt = new Date();
-    const result = plan.commandArgv && isMustflowBuiltinIntent(plan.intent)
-        ? ((await runBuiltinArgvInProcess(plan.commandArgv, plan.cwd, lang)) ??
-            runArgvCommand(plan.argvCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds))
-        : plan.commandArgv
-            ? runArgvCommand(plan.argvCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds)
-            : runShellCommand(plan.shellCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds);
+    const result = await profiler.measureAsync('child_command', async () => {
+        if (plan.commandArgv && isMustflowBuiltinIntent(plan.intent)) {
+            const builtinResult = await runBuiltinArgvInProcess(plan.commandArgv, plan.cwd, lang);
+            if (builtinResult) {
+                return builtinResult;
+            }
+        }
+        if (plan.commandArgv) {
+            if (!json) {
+                streamedOutput = true;
+                return runArgvCommandStreaming(plan.argvCommand, plan.cwd, env, plan.timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter);
+            }
+            return runArgvCommand(plan.argvCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds);
+        }
+        if (!json) {
+            streamedOutput = true;
+            return runShellCommandStreaming(plan.shellCommand, plan.cwd, env, plan.timeoutSeconds, stdoutTailBytes, stderrTailBytes, reporter);
+        }
+        return runShellCommand(plan.shellCommand, plan.cwd, plan.maxOutputBytes, env, plan.timeoutSeconds);
+    });
+    const childDurationMs = performance.now() - childStartedAtMs;
     const finishedAt = new Date();
-    const writeDrift = finishRunWriteTracking(writeTracker);
+    const writeDrift = profiler.measure('write_drift_after', () => finishRunWriteTracking(writeTracker));
     const exitCode = typeof result.status === 'number' ? result.status : null;
     const runStatus = getRunStatus(result.error, exitCode, plan.successExitCodes);
     let killMethod = null;
@@ -347,7 +503,7 @@ export async function runRun(args, reporter, lang = 'en') {
         killMethod = getKillMethod();
         terminateProcessTree(result.pid);
     }
-    const receipt = createRunReceipt({
+    const receipt = profiler.measure('receipt_create', () => createRunReceipt({
         intent: intentName,
         status: runStatus,
         timedOut: runStatus === 'timed_out',
@@ -372,16 +528,36 @@ export async function runRun(args, reporter, lang = 'en') {
         stdout: result.stdout,
         stderr: result.stderr,
         writeDrift,
+        executorOverheadMs: Math.max(0, Math.round((performance.now() - executorStartedAtMs - childDurationMs) * 1000) / 1000),
+        phaseTimings: profiler.getReceiptPhases(),
+        selectionSummary: {
+            strategy: plan.testTargets.length > 0 ? 'project_test_selection' : 'direct_intent',
+            changed_file_count: 0,
+            changed_surface_counts: {},
+            selected_target_count: Math.max(1, plan.testTargets.length),
+            fallback_used: false,
+        },
         stdoutTailBytes: runReceiptPolicy.stdoutTailBytes,
         stderrTailBytes: runReceiptPolicy.stderrTailBytes,
+    }));
+    if (options.writeLatestReceipt !== false) {
+        profiler.measure('receipt_write', () => writeRunReceipt(projectRoot, receipt));
+    }
+    profiler.measure('performance_history_write', () => recordRunPerformanceHistory(projectRoot, receipt));
+    profiler.writeLatest({
+        projectRoot,
+        intent: intentName,
+        status: runStatus,
+        previewMode: null,
     });
-    writeRunReceipt(projectRoot, receipt);
     if (json) {
         reporter.stdout(JSON.stringify(receipt, null, 2));
         return runStatus === 'passed' ? 0 : 1;
     }
-    emitOutput(reporter, result.stdout, 'stdout');
-    emitOutput(reporter, result.stderr, 'stderr');
+    if (!streamedOutput) {
+        emitOutput(reporter, result.stdout, 'stdout');
+        emitOutput(reporter, result.stderr, 'stderr');
+    }
     if (result.error) {
         const errorWithCode = result.error;
         if (errorWithCode.code === 'ETIMEDOUT') {

package/dist/cli/commands/upgrade.js

@@ -0,0 +1,65 @@
+import { printUsageError, renderCliError, renderHelp } from '../lib/cli-output.js';
+import { t } from '../lib/i18n.js';
+import { checkNpmLatestVersion } from '../lib/npm-version-check.js';
+import { readPackageMetadata } from '../lib/package-info.js';
+import { runUpdate } from './update.js';
+export function getUpgradeHelp(lang = 'en') {
+    return renderHelp({
+        usage: 'mf upgrade [options]',
+        summary: t(lang, 'upgrade.help.summary'),
+        options: [
+            { label: '--dry-run', description: t(lang, 'upgrade.help.option.dryRun') },
+            { label: '-h, --help', description: t(lang, 'cli.option.help') },
+        ],
+        examples: ['mf upgrade', 'mf upgrade --dry-run'],
+        exitCodes: [
+            { label: '0', description: t(lang, 'upgrade.help.exit.ok') },
+            { label: '1', description: t(lang, 'upgrade.help.exit.fail') },
+        ],
+    }, lang);
+}
+function printPackageCheck(check, reporter, lang) {
+    reporter.stdout(`${check.packageName} ${check.currentVersion}`);
+    reporter.stdout(check.updateAvailable
+        ? t(lang, 'version.check.latestAvailable', { version: check.latestVersion })
+        : t(lang, 'version.check.upToDate', { version: check.latestVersion }));
+    if (check.updateAvailable) {
+        reporter.stdout('');
+        reporter.stdout(t(lang, 'version.check.updateCommand'));
+        reporter.stdout(check.updateCommand);
+    }
+}
+export async function runUpgrade(args, reporter, lang = 'en') {
+    if (args.includes('--help') || args.includes('-h')) {
+        reporter.stdout(getUpgradeHelp(lang));
+        return 0;
+    }
+    const supported = new Set(['--dry-run']);
+    const unsupported = args.filter((arg) => !supported.has(arg));
+    if (unsupported.length > 0) {
+        printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf upgrade --help', getUpgradeHelp(lang), lang);
+        return 1;
+    }
+    const dryRun = args.includes('--dry-run');
+    reporter.stdout(t(lang, 'upgrade.title'));
+    reporter.stdout('');
+    reporter.stdout(t(lang, 'upgrade.packageSection'));
+    try {
+        const packageCheck = await checkNpmLatestVersion(readPackageMetadata());
+        printPackageCheck(packageCheck, reporter, lang);
+        if (packageCheck.updateAvailable) {
+            reporter.stdout('');
+            reporter.stdout(t(lang, 'upgrade.packageUpdateRequired'));
+            reporter.stdout(t(lang, 'upgrade.noFilesWritten'));
+            return 1;
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        reporter.stderr(renderCliError(t(lang, 'upgrade.warning.versionCheckFailed', { message }), 'mf version --check', lang));
+        reporter.stderr(t(lang, 'upgrade.warning.continueWithBundledTemplate'));
+    }
+    reporter.stdout('');
+    reporter.stdout(t(lang, 'upgrade.projectSection'));
+    return runUpdate([dryRun ? '--dry-run' : '--apply'], reporter, lang);
+}