@nifrajs/cli 3.3.0 → 4.0.0

package/dist/command-catalog.js

@@ -7,8 +7,14 @@
  */
 import { resolve } from "node:path";
 import { formatAssuranceReport } from "./assure.js";
+import { cdnCheckSpec } from "./cdn-check.js";
 import { renderCheckReport } from "./check.js";
+import { dbAuditSpec, dbQuerySpec, dbRoleSpec, dbSchemaSpec } from "./db-tool.js";
+import { errorsSpec, logsSpec } from "./dev-feed-tool.js";
+import { diagnostic, normalizeSeverity, toSarifLog } from "./diagnostics.js";
+import { i18nCheckPassed, renderI18nCheck } from "./i18n-check.js";
 import { collectPortResult, renderReport } from "./port.js";
+import { reviewSpec } from "./review.js";
 import { collectProjectWorkGraph, renderWorkGraphText, } from "./work-graph.js";
 function freezeJson(value) {
     if (value !== null && typeof value === "object" && !Object.isFrozen(value)) {
@@ -27,6 +33,17 @@ export function toCommandCatalogEntry(spec) {
         outputVersion: spec.output.version,
         transports: Object.freeze([...spec.transports]),
         stability: spec.stability,
+        cliOnlyFields: Object.freeze([...(spec.cliOnlyFields ?? [])]),
+    });
+}
+/** The input schema a command's MCP tool advertises: its catalog schema without CLI-only fields. */
+export function commandMcpInputSchema(entry) {
+    const properties = entry.inputSchema.properties;
+    if (entry.cliOnlyFields.length === 0 || typeof properties !== "object" || properties === null)
+        return entry.inputSchema;
+    return freezeJson({
+        ...entry.inputSchema,
+        properties: Object.fromEntries(Object.entries(properties).filter(([key]) => !entry.cliOnlyFields.includes(key))),
     });
 }
 function record(value) {
@@ -143,6 +160,7 @@ function parseBooleanFlags(raw, fields) {
 const CHECK_SCHEMA = input(objectSchema({
     lintsOnly: { type: "boolean" },
     json: { type: "boolean" },
+    sarif: { type: "boolean" },
     maxDiagnostics: { type: "integer", minimum: 1 },
     dir: { type: "string" },
 }), (value) => {
@@ -151,7 +169,7 @@ const CHECK_SCHEMA = input(objectSchema({
     if (maxDiagnostics !== undefined && (!Number.isInteger(maxDiagnostics) || maxDiagnostics < 1))
         throw new TypeError("maxDiagnostics must be a positive integer");
     return {
-        ...parseBooleanFlags(raw, ["lintsOnly", "json"]),
+        ...parseBooleanFlags(raw, ["lintsOnly", "json", "sarif"]),
         ...(maxDiagnostics === undefined ? {} : { maxDiagnostics }),
         ...(raw.dir === undefined ? {} : { dir: raw.dir }),
     };
@@ -311,23 +329,45 @@ const FIX_SCHEMA = input(objectSchema({ code: { type: "string" }, json: { type:
     };
 });
 const MIGRATE_SCHEMA = input(objectSchema({
+    kind: { type: "string", enum: ["layout"] },
     from: { type: "string", enum: ["tailwind"] },
     to: { type: "string", enum: ["stylex"] },
     write: { type: "boolean" },
     json: { type: "boolean" },
     dir: { type: "string" },
-}, ["from", "to"]), (value) => {
+}), (value) => {
     const raw = withDir(record(value));
+    const flags = {
+        ...parseBooleanFlags(raw, ["write", "json"]),
+        ...(raw.dir === undefined ? {} : { dir: raw.dir }),
+    };
+    const kind = optionalString(raw.kind, "kind");
+    if (kind !== undefined) {
+        if (kind !== "layout")
+            throw new TypeError("the migration must be `layout` (or --from tailwind --to stylex)");
+        return { kind, ...flags };
+    }
     const from = optionalString(raw.from, "from");
     const to = optionalString(raw.to, "to");
     if (from !== "tailwind")
         throw new TypeError("from must be tailwind");
     if (to !== "stylex")
         throw new TypeError("to must be stylex");
+    return { from, to, ...flags };
+});
+const TARGET_SCHEMA = input(objectSchema({ target: { type: "string" }, json: { type: "boolean" }, dir: { type: "string" } }), (value) => {
+    const raw = withDir(record(value));
+    const target = optionalString(raw.target, "target");
     return {
-        from,
-        to,
-        ...parseBooleanFlags(raw, ["write", "json"]),
+        ...parseBooleanFlags(raw, ["json"]),
+        ...(raw.dir === undefined ? {} : { dir: raw.dir }),
+        ...(target === undefined ? {} : { target }),
+    };
+});
+const TYPES_SCHEMA = input(objectSchema({ check: { type: "boolean" }, json: { type: "boolean" }, dir: { type: "string" } }), (value) => {
+    const raw = withDir(record(value));
+    return {
+        ...parseBooleanFlags(raw, ["check", "json"]),
         ...(raw.dir === undefined ? {} : { dir: raw.dir }),
     };
 });
@@ -418,15 +458,62 @@ const PORT_SCHEMA = input(objectSchema({
         ...(raw.dir === undefined ? {} : { dir: raw.dir }),
     };
 });
+const SMOKE_SCHEMA = input(objectSchema({
+    fixture: { type: "string" },
+    inProcess: { type: "boolean" },
+    json: { type: "boolean" },
+    dir: { type: "string" },
+}), (value) => {
+    const raw = withDir(record(value));
+    return {
+        fixture: optionalString(raw.fixture, "fixture"),
+        ...parseBooleanFlags(raw, ["inProcess", "json"]),
+        ...(raw.dir === undefined ? {} : { dir: raw.dir }),
+    };
+});
+const I18N_SCHEMA = input(objectSchema({
+    action: { type: "string", enum: ["check"] },
+    entry: { type: "string" },
+    json: { type: "boolean" },
+    strict: { type: "boolean" },
+    dir: { type: "string" },
+}, ["action"]), (value) => {
+    const raw = withDir(record(value));
+    if (raw.action !== "check") {
+        throw new TypeError(raw.action === undefined
+            ? "i18n needs an action: nifra i18n check [entry]"
+            : `unknown i18n action: ${String(raw.action)} (the one action is check)`);
+    }
+    return {
+        action: "check",
+        entry: optionalString(raw.entry, "entry"),
+        ...parseBooleanFlags(raw, ["json", "strict"]),
+        ...(raw.dir === undefined ? {} : { dir: raw.dir }),
+    };
+});
 function loadAppFor(ctx) {
     if (ctx.loadApp !== undefined)
         return ctx.loadApp();
     return import("./load.js").then(({ loadApp }) => loadApp(ctx.cwd));
 }
-function checkJson(out) {
-    return out.structuredDiagnostics === undefined
-        ? out
-        : { ...out, diagnostics: out.structuredDiagnostics };
+function structuredDiagnostics(out) {
+    if (out.structuredDiagnostics !== undefined)
+        return out.structuredDiagnostics;
+    return out.diagnostics.map((value) => diagnostic({
+        code: value.code ?? value.rule,
+        severity: normalizeSeverity(value.severity),
+        message: value.message,
+        ...(value.file === undefined ? {} : { file: value.file }),
+        ...(value.line === undefined ? {} : { line: value.line }),
+        ...(value.evidence === undefined ? {} : { evidence: value.evidence }),
+        ...(value.fix === undefined ? {} : { fix: { recipe: value.fix } }),
+        ...(value.verify === undefined ? {} : { verify: value.verify }),
+    }));
+}
+function checkJson(out, input) {
+    if (input?.sarif === true)
+        return toSarifLog(structuredDiagnostics(out));
+    return { ...out, diagnostics: structuredDiagnostics(out) };
 }
 const checkSpec = {
     name: "check",
@@ -443,6 +530,7 @@ const checkSpec = {
         flags: [
             { name: "lints-only", field: "lintsOnly", type: "boolean" },
             { name: "json", field: "json", type: "boolean" },
+            { name: "sarif", field: "sarif", type: "boolean" },
         ],
     },
     async run(value, ctx) {
@@ -453,9 +541,11 @@ const checkSpec = {
             ...(value.maxDiagnostics === undefined ? {} : { maxDiagnostics: value.maxDiagnostics }),
         })).check();
     },
-    render: (out) => renderCheckReport(out),
+    render: (out, input) => input?.sarif === true
+        ? JSON.stringify(checkJson(out, input), null, 2).split("\n")
+        : renderCheckReport(out),
     success: (out) => out.ok,
-    json: (out) => checkJson(out),
+    json: (out, input) => checkJson(out, input),
 };
 const assureSpec = {
     name: "assure",
@@ -580,6 +670,8 @@ const manifestSpec = {
     output: output({ type: "object" }),
     transports: ["cli", "mcp"],
     stability: "stable",
+    // The signer is the operator's KMS/HSM callback; an agent signing its own manifest defeats it.
+    cliOnlyFields: ["sign"],
     argv: {
         positionals: ["action", "before", "after"],
         flags: [
@@ -704,7 +796,9 @@ const openApiSpec = {
         ],
     },
     async run(value, ctx) {
-        const app = await loadAppFor(ctx);
+        const app = ctx.loadApp !== undefined
+            ? await ctx.loadApp()
+            : await import("./load.js").then(({ loadBackendApp }) => loadBackendApp(ctx.cwd));
         const { renderOpenApiWithTypes } = await import("./openapi-tool.js");
         const format = value.format ?? "json";
         return {
@@ -818,12 +912,13 @@ const fixSpec = {
 };
 const migrateSpec = {
     name: "migrate",
-    summary: "Migrate safe static Tailwind className utilities to native StyleX props.",
+    summary: "Move an app onto the frontend/backend split (`migrate layout`), or migrate static Tailwind utilities to StyleX.",
     input: MIGRATE_SCHEMA,
     output: output({
         type: "object",
         properties: {
             ok: { type: "boolean" },
+            kind: { type: "string" },
             from: { type: "string" },
             to: { type: "string" },
             write: { type: "boolean" },
@@ -832,12 +927,16 @@ const migrateSpec = {
             written: { type: "array" },
             issues: { type: "array" },
             files: { type: "array" },
+            splits: { type: "array" },
+            moves: { type: "array" },
+            rewritten: { type: "array" },
         },
-        required: ["ok", "from", "to", "write", "scanned", "changed", "written", "issues", "files"],
+        required: ["ok", "write", "issues"],
     }),
     transports: ["cli"],
     stability: "stable",
     argv: {
+        positionals: ["kind"],
         flags: [
             { name: "from", field: "from", type: "string" },
             { name: "to", field: "to", type: "string" },
@@ -847,27 +946,134 @@ const migrateSpec = {
         ],
     },
     async run(value, ctx) {
+        const dir = resolve(ctx.cwd, value.dir ?? ".");
+        const write = value.write === undefined ? {} : { write: value.write };
+        if (value.kind === "layout") {
+            const { migrateLayout } = await import("./migrate-layout.js");
+            return { kind: "layout", ...(await migrateLayout(dir, write)) };
+        }
         const { migrateTailwindToStylex } = await import("./stylex-migrate.js");
-        return migrateTailwindToStylex(resolve(ctx.cwd, value.dir ?? "."), {
-            ...(value.write === undefined ? {} : { write: value.write }),
-        });
+        return migrateTailwindToStylex(dir, write);
     },
-    render: (out) => [
-        out.ok
-            ? `✓ migrated ${out.changed.length} file${out.changed.length === 1 ? "" : "s"}`
-            : `⚠ migrated ${out.changed.length} safe file${out.changed.length === 1 ? "" : "s"}; ${out.issues.length} manual issue${out.issues.length === 1 ? "" : "s"} remain`,
-        `  scanned ${out.scanned} source file${out.scanned === 1 ? "" : "s"}`,
-        ...(out.write
-            ? [`  wrote ${out.written.length} file${out.written.length === 1 ? "" : "s"}`]
-            : out.changed.length > 0
-                ? ["  dry run: pass --write to apply the safe changes"]
+    render: (out) => {
+        if (out.kind === "layout") {
+            return [
+                out.ok
+                    ? `✓ ${out.splits.length} route file${out.splits.length === 1 ? "" : "s"} split, ${out.moves.length} file${out.moves.length === 1 ? "" : "s"} moved`
+                    : `⚠ ${out.issues.length} issue${out.issues.length === 1 ? "" : "s"} need a decision; everything else is planned`,
+                ...out.splits.map((split) => `  split ${split.file} → ${split.backend} (${split.moved.join(", ")})`),
+                ...out.moves.map((move) => `  move  ${move.from} → ${move.to}`),
+                ...out.rewritten.map((file) => `  edit  ${file} (imports)`),
+                ...out.issues.map((issue) => `  ⚠ ${issue.file}: ${issue.reason}`),
+                ...(out.write ? [] : ["  dry run: pass --write to apply"]),
+            ];
+        }
+        return [
+            out.ok
+                ? `✓ migrated ${out.changed.length} file${out.changed.length === 1 ? "" : "s"}`
+                : `⚠ migrated ${out.changed.length} safe file${out.changed.length === 1 ? "" : "s"}; ${out.issues.length} manual issue${out.issues.length === 1 ? "" : "s"} remain`,
+            `  scanned ${out.scanned} source file${out.scanned === 1 ? "" : "s"}`,
+            ...(out.write
+                ? [`  wrote ${out.written.length} file${out.written.length === 1 ? "" : "s"}`]
+                : out.changed.length > 0
+                    ? ["  dry run: pass --write to apply the safe changes"]
+                    : []),
+            ...out.issues
+                .slice(0, 30)
+                .map((issue) => `  ${issue.file}:${issue.line} ${issue.token} — ${issue.reason}`),
+            ...(out.issues.length > 30
+                ? [`  … ${out.issues.length - 30} more issue${out.issues.length - 30 === 1 ? "" : "s"}`]
                 : []),
-        ...out.issues
-            .slice(0, 30)
-            .map((issue) => `  ${issue.file}:${issue.line} ${issue.token} — ${issue.reason}`),
-        ...(out.issues.length > 30
-            ? [`  … ${out.issues.length - 30} more issue${out.issues.length - 30 === 1 ? "" : "s"}`]
-            : []),
+        ];
+    },
+    success: (out) => out.ok,
+};
+const targetSpec = {
+    name: "target",
+    summary: "Show the app's deploy target, or switch it (`nifra target cloudflare`): the `target` `nifra build` emits, kept in nifra.config.ts.",
+    input: TARGET_SCHEMA,
+    output: output({
+        type: "object",
+        properties: {
+            ok: { type: "boolean" },
+            target: { type: "string" },
+            previous: { type: "string" },
+            changed: { type: "boolean" },
+            run: { type: "string" },
+        },
+        required: ["ok", "target", "changed", "run"],
+    }),
+    transports: ["cli"],
+    stability: "stable",
+    argv: {
+        positionals: ["target"],
+        flags: [
+            { name: "json", field: "json", type: "boolean" },
+            { name: "dir", field: "dir", type: "string" },
+        ],
+    },
+    async run(value, ctx) {
+        const dir = resolve(ctx.cwd, value.dir ?? ".");
+        const { parseBuildTarget, planBuildTarget } = await import("@nifrajs/web/build");
+        const { readConfigTarget, writeConfigTarget } = await import("./config-target.js");
+        const current = readConfigTarget(dir);
+        const target = parseBuildTarget(value.target ?? current ?? "bun", value.target === undefined ? "target in nifra.config.ts" : "target");
+        const changed = value.target !== undefined && value.target !== current;
+        if (changed)
+            writeConfigTarget(dir, target);
+        return {
+            ok: true,
+            target,
+            ...(changed && current !== undefined ? { previous: current } : {}),
+            changed,
+            run: planBuildTarget(target, "dist").run,
+        };
+    },
+    render: (out) => [
+        out.changed
+            ? `✓ target: ${out.target}${out.previous === undefined ? "" : ` (was ${out.previous})`}`
+            : `target: ${out.target}`,
+        `  nifra build → ${out.run}`,
+    ],
+    success: (out) => out.ok,
+};
+const typesSpec = {
+    name: "types",
+    summary: "Generate each route's `./+types` module (params, schema-typed data, typed `api`); `--check` fails when one is stale.",
+    input: TYPES_SCHEMA,
+    output: output({
+        type: "object",
+        properties: {
+            ok: { type: "boolean" },
+            check: { type: "boolean" },
+            written: { type: "array" },
+            removed: { type: "array" },
+            stale: { type: "array" },
+            tsconfig: { type: "string" },
+        },
+        required: ["ok", "check", "written", "removed", "stale"],
+    }),
+    transports: ["cli"],
+    stability: "stable",
+    argv: {
+        flags: [
+            { name: "check", field: "check", type: "boolean" },
+            { name: "json", field: "json", type: "boolean" },
+            { name: "dir", field: "dir", type: "string" },
+        ],
+    },
+    async run(value, ctx) {
+        const { routeTypes } = await import("./route-types.js");
+        return routeTypes(resolve(ctx.cwd, value.dir ?? "."), { check: value.check === true });
+    },
+    render: (out) => [
+        out.check
+            ? out.ok
+                ? "✓ route types are up to date"
+                : `✖ ${out.stale.length} route type file${out.stale.length === 1 ? " is" : "s are"} stale - run \`nifra types\``
+            : `✓ route types: ${out.written.length} written, ${out.removed.length} removed`,
+        ...out.stale.map((file) => `  stale ${file}`),
+        ...(out.tsconfig === undefined ? [] : [`  ⚠ ${out.tsconfig}`]),
     ],
     success: (out) => out.ok,
 };
@@ -1048,6 +1254,28 @@ const replaySpec = {
     render: (out) => [JSON.stringify(out, null, 2)],
     success: (out) => out.ok,
 };
+const smokeSpec = {
+    name: "smoke",
+    summary: "Run the declared production SSR, mounted-API, 404, header, auth, contract, and hydration smoke checks.",
+    input: SMOKE_SCHEMA,
+    output: output({ type: "object" }),
+    transports: ["cli", "mcp"],
+    stability: "stable",
+    argv: {
+        flags: [
+            { name: "fixture", field: "fixture", type: "string" },
+            { name: "in-process", field: "inProcess", type: "boolean" },
+            { name: "json", field: "json", type: "boolean" },
+        ],
+    },
+    async run(value, ctx) {
+        const { loadSmokeFixture, runSmoke } = await import("./smoke.js");
+        const fixture = await loadSmokeFixture(ctx.cwd, value.fixture);
+        return runSmoke(fixture, { inProcess: value.inProcess === true });
+    },
+    render: (out) => out.checks.map((check) => `${check.status === "pass" ? "✓" : check.status === "skip" ? "•" : "✖"} ${check.id}${check.message === undefined ? "" : ` - ${check.message}`}`),
+    success: (out) => out.ok,
+};
 const portSpec = {
     name: "port",
     summary: "Print a feature by deploy-target portability matrix with file:line evidence and gate against an unsupported target.",
@@ -1076,7 +1304,7 @@ const portSpec = {
             return [
                 report,
                 "",
-                "[nifra] --ci needs a deploy target to gate against, and none was detected. Pass --target <bun|node|deno|cf-pages|vercel>.",
+                "[nifra] --ci needs a deploy target to gate against, and none was detected. Pass --target <bun|node|deno|cloudflare|vercel>.",
             ];
         return [report];
     },
@@ -1090,8 +1318,34 @@ const portSpec = {
     },
     json: (out) => out.json,
 };
+// CLI only: it imports app code (the catalogs), which a long-lived MCP server process would cache.
+const i18nSpec = {
+    name: "i18n",
+    summary: "Check i18n catalogs (imports the module exporting `locales` and `catalogs`): coverage, missing and unused keys, ICU syntax, placeholder and tag parity, plural cases, script purity, untranslated messages.",
+    input: I18N_SCHEMA,
+    output: output({ type: "object" }),
+    transports: ["cli"],
+    stability: "stable",
+    argv: {
+        positionals: ["action", "entry"],
+        flags: [
+            { name: "json", field: "json", type: "boolean" },
+            { name: "strict", field: "strict", type: "boolean" },
+        ],
+    },
+    async run(value, ctx) {
+        const { runI18nCheck } = await import("./i18n-check.js");
+        return runI18nCheck(value.dir === undefined ? ctx.cwd : resolve(ctx.cwd, value.dir), {
+            entry: value.entry,
+        });
+    },
+    render: (out) => renderI18nCheck(out),
+    success: (out, input) => i18nCheckPassed(out, input.strict === true),
+    json: (out) => out,
+};
 export const commandSpecs = Object.freeze([
     checkSpec,
+    reviewSpec,
     assureSpec,
     levelsSpec,
     capabilitiesSpec,
@@ -1102,6 +1356,8 @@ export const commandSpecs = Object.freeze([
     doctorSpec,
     fixSpec,
     migrateSpec,
+    targetSpec,
+    typesSpec,
     snapshotSpec,
     diffSpec,
     contractsSpec,
@@ -1109,7 +1365,16 @@ export const commandSpecs = Object.freeze([
     syncRoutesSpec,
     proveSpec,
     replaySpec,
+    smokeSpec,
     portSpec,
+    i18nSpec,
+    errorsSpec,
+    logsSpec,
+    cdnCheckSpec,
+    dbSchemaSpec,
+    dbQuerySpec,
+    dbRoleSpec,
+    dbAuditSpec,
 ]);
 const commandByName = new Map(commandSpecs.map((spec) => [spec.name, spec]));
 export function findCommandSpec(name) {