mustflow 1.18.16 → 1.31.0

package/dist/cli/commands/update.js

@@ -8,6 +8,7 @@ import { t } from '../lib/i18n.js';
 import { resolveMustflowRoot } from '../lib/project-root.js';
 import { getDefaultTemplate, getTemplateFiles, skillNameForTemplatePath } from '../lib/templates.js';
 import { readTomlFile, stringifyToml } from '../lib/toml.js';
+import { createUpdateDiffPreview, shouldPreviewUpdateDiff } from '../lib/update-diff-preview.js';
 const UPDATE_SCHEMA_VERSION = '1';
 const CUSTOMIZED_LOCK_ACTION = 'customized';
 const UPDATE_POLICY = {
@@ -25,6 +26,7 @@ export function getUpdateHelp(lang = 'en') {
         summary: t(lang, 'update.help.summary'),
         options: [
             { label: '--dry-run', description: t(lang, 'update.help.option.dryRun') },
+            { label: '--diff', description: t(lang, 'update.help.option.diff') },
             {
                 label: '--apply',
                 description: t(lang, 'update.help.option.apply'),
@@ -32,7 +34,7 @@ export function getUpdateHelp(lang = 'en') {
             { label: '--json', description: t(lang, 'cli.option.json') },
             { label: '-h, --help', description: t(lang, 'cli.option.help') },
         ],
-        examples: ['mf update --dry-run', 'mf update --dry-run --json', 'mf update --apply'],
+        examples: ['mf update --dry-run', 'mf update --dry-run --diff', 'mf update --dry-run --diff --json', 'mf update --apply'],
         exitCodes: [
             {
                 label: '0',
@@ -86,7 +88,27 @@ function templateTargetSafetyIssue(projectRoot, targetPath, allowMissingLeaf) {
         return error instanceof Error ? error.message : String(error);
     }
 }
-export function planUpdate(projectRoot) {
+function createPlanItem(source, action, reason) {
+    return {
+        relativePath: source.relativePath,
+        sourceKind: source.sourceKind,
+        source,
+        action,
+        reason,
+    };
+}
+function publicPlanItem(item) {
+    return {
+        relativePath: item.relativePath,
+        sourceKind: item.sourceKind,
+        action: item.action,
+        reason: item.reason,
+    };
+}
+function publicPlanItems(items) {
+    return items.map((item) => publicPlanItem(item));
+}
+function createUpdatePlan(projectRoot) {
     const lockResult = readManifestLock(projectRoot);
     if (lockResult.kind === 'missing') {
         return { items: [], error: `Missing ${MANIFEST_LOCK_RELATIVE_PATH}` };
@@ -111,94 +133,68 @@ export function planUpdate(projectRoot) {
         ensureInside(projectRoot, targetPath);
         const unsafeTargetReason = templateTargetSafetyIssue(projectRoot, targetPath, true);
         if (unsafeTargetReason) {
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'blocked-local-change',
-                reason: unsafeTargetReason,
-            });
+            items.push(createPlanItem(source, 'blocked-local-change', unsafeTargetReason));
             continue;
         }
         if (!existsSync(targetPath)) {
             if (lockedFile) {
-                items.push({
-                    relativePath: source.relativePath,
-                    sourceKind: source.sourceKind,
-                    action: 'blocked-local-change',
-                    reason: 'target file is missing but tracked by the manifest lock',
-                });
+                items.push(createPlanItem(source, 'blocked-local-change', 'target file is missing but tracked by the manifest lock'));
                 continue;
             }
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'create',
-                reason: 'target file is missing',
-            });
+            items.push(createPlanItem(source, 'create', 'target file is missing'));
             continue;
         }
         const currentHash = sha256File(targetPath);
         const templateHash = templateFileHash(source);
         if (!lockedFile && currentHash !== templateHash) {
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'blocked-local-change',
-                reason: 'target file exists but is not tracked by the manifest lock',
-            });
+            items.push(createPlanItem(source, 'blocked-local-change', 'target file exists but is not tracked by the manifest lock'));
             continue;
         }
         if (lockedFile && currentHash !== lockedFile.contentHash) {
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'blocked-local-change',
-                reason: 'current file differs from the manifest lock baseline',
-            });
+            items.push(createPlanItem(source, 'blocked-local-change', 'current file differs from the manifest lock baseline'));
             continue;
         }
         if (lockedFile?.lastAction === CUSTOMIZED_LOCK_ACTION && currentHash !== templateHash) {
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'unchanged',
-                reason: 'manifest lock marks this file as customized and current file matches that baseline',
-            });
+            items.push(createPlanItem(source, 'unchanged', 'manifest lock marks this file as customized and current file matches that baseline'));
             continue;
         }
         if (lockedFile?.source === 'managed_block' && currentHash !== templateHash) {
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'manual-review',
-                reason: 'managed block requires a block-level manifest baseline',
-            });
+            items.push(createPlanItem(source, 'manual-review', 'managed block requires a block-level manifest baseline'));
             continue;
         }
         if (currentHash !== templateHash) {
-            items.push({
-                relativePath: source.relativePath,
-                sourceKind: source.sourceKind,
-                action: 'update',
-                reason: 'template content differs from current file',
-            });
+            items.push(createPlanItem(source, 'update', 'template content differs from current file'));
             continue;
         }
-        items.push({
-            relativePath: source.relativePath,
-            sourceKind: source.sourceKind,
-            action: 'unchanged',
-            reason: 'current file matches the bundled template',
-        });
+        items.push(createPlanItem(source, 'unchanged', 'current file matches the bundled template'));
     }
     return { items };
 }
+export function planUpdate(projectRoot) {
+    const plan = createUpdatePlan(projectRoot);
+    return {
+        items: publicPlanItems(plan.items),
+        ...(plan.error ? { error: plan.error } : {}),
+    };
+}
 function printItems(title, items, reporter) {
     reporter.stdout(`${title}: ${items.length}`);
     for (const item of items) {
         reporter.stdout(`- ${item.relativePath} (${item.reason})`);
     }
 }
+function withDiffPreviews(projectRoot, items) {
+    return items.map((item) => {
+        const publicItem = publicPlanItem(item);
+        if (!shouldPreviewUpdateDiff(item.action)) {
+            return publicItem;
+        }
+        return {
+            ...publicItem,
+            diff_preview: createUpdateDiffPreview(projectRoot, item),
+        };
+    });
+}
 export function summarizePlan(items) {
     return {
         blockedLocalChanges: items.filter((item) => item.action === 'blocked-local-change').length,
@@ -369,16 +365,37 @@ function printPlan(output, reporter, lang) {
         reporter.stdout(t(lang, 'update.plan.noUpdates'));
     }
 }
+function printDiffPreviews(items, reporter, lang) {
+    const itemsWithDiff = items.filter((item) => item.diff_preview);
+    if (itemsWithDiff.length === 0) {
+        return;
+    }
+    reporter.stdout(t(lang, 'update.diff.title'));
+    for (const item of itemsWithDiff) {
+        const preview = item.diff_preview;
+        if (!preview) {
+            continue;
+        }
+        if (!preview.available) {
+            reporter.stdout(`# ${item.relativePath}: ${t(lang, 'update.diff.unavailable', { reason: preview.reason ?? 'unknown' })}`);
+            continue;
+        }
+        for (const line of preview.lines) {
+            reporter.stdout(line);
+        }
+    }
+}
 export function runUpdate(args, reporter, lang = 'en') {
     if (args.includes('--help') || args.includes('-h')) {
         reporter.stdout(getUpdateHelp(lang));
         return 0;
     }
-    const supported = new Set(['--dry-run', '--apply', '--json']);
+    const supported = new Set(['--dry-run', '--apply', '--json', '--diff']);
     const unsupported = args.filter((arg) => !supported.has(arg));
     const wantsJson = args.includes('--json');
     const wantsDryRun = args.includes('--dry-run');
     const wantsApply = args.includes('--apply');
+    const wantsDiff = args.includes('--diff');
     const requestedMode = getRequestedMode(wantsDryRun, wantsApply);
     if (unsupported.length > 0) {
         printUsageError(reporter, t(lang, 'cli.error.unknownOption', { option: unsupported[0] }), 'mf update --help', getUpdateHelp(lang), lang);
@@ -393,6 +410,15 @@ export function runUpdate(args, reporter, lang = 'en') {
         printUsageError(reporter, error, 'mf update --help', getUpdateHelp(lang), lang);
         return 1;
     }
+    if (wantsDiff && !wantsDryRun) {
+        const error = t(lang, 'update.error.diffRequiresDryRun');
+        if (wantsJson) {
+            reporter.stdout(JSON.stringify(withMode(planOutput([], error, false), requestedMode), null, 2));
+            return 1;
+        }
+        printUsageError(reporter, error, 'mf update --help', getUpdateHelp(lang), lang);
+        return 1;
+    }
     if (!wantsDryRun && !wantsApply) {
         const error = t(lang, 'update.error.missingMode');
         if (wantsJson) {
@@ -403,22 +429,26 @@ export function runUpdate(args, reporter, lang = 'en') {
         return 1;
     }
     const projectRoot = resolveMustflowRoot();
-    const plan = planUpdate(projectRoot);
+    const plan = createUpdatePlan(projectRoot);
     if (plan.error) {
         if (wantsJson) {
-            reporter.stdout(JSON.stringify(withMode(planOutput(plan.items, plan.error, false), requestedMode), null, 2));
+            reporter.stdout(JSON.stringify(withMode(planOutput(publicPlanItems(plan.items), plan.error, false), requestedMode), null, 2));
             return 1;
         }
         reporter.stderr(plan.error);
         return 1;
     }
-    const dryRunOutput = withMode(planOutput(plan.items, undefined, false), requestedMode);
+    const outputItems = wantsDiff ? withDiffPreviews(projectRoot, plan.items) : publicPlanItems(plan.items);
+    const dryRunOutput = withMode(planOutput(outputItems, undefined, false), requestedMode);
     if (wantsDryRun) {
         if (wantsJson) {
             reporter.stdout(JSON.stringify(dryRunOutput, null, 2));
             return dryRunOutput.ok ? 0 : 1;
         }
         printPlan(dryRunOutput, reporter, lang);
+        if (wantsDiff) {
+            printDiffPreviews(dryRunOutput.items, reporter, lang);
+        }
         reporter.stdout(t(lang, 'update.plan.noFilesWritten'));
         return dryRunOutput.ok ? 0 : 1;
     }
@@ -437,7 +467,7 @@ export function runUpdate(args, reporter, lang = 'en') {
             stdout: () => undefined,
             stderr: (message) => reporter.stderr(message),
         }, lang);
-        reporter.stdout(JSON.stringify(withMode(planOutput(plan.items, undefined, applyResult.wroteFiles), 'apply'), null, 2));
+        reporter.stdout(JSON.stringify(withMode(planOutput(publicPlanItems(plan.items), undefined, applyResult.wroteFiles), 'apply'), null, 2));
         return 0;
     }
     const applyResult = applyUpdate(projectRoot, plan.items, reporter, lang);

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);
+}