@beignet/cli 0.0.1

package/dist/index.js

@@ -0,0 +1,735 @@
+#!/usr/bin/env node
+import { realpathSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { buildApplication, buildCommand, buildRouteMap, run, text_en, } from "@stricli/core";
+import { createProject } from "./create.js";
+import { applyDoctorFixes, formatDoctor, formatRoutes, inspectApp, } from "./inspect.js";
+import { formatLint, lintApp } from "./lint.js";
+import { makeAdapter, makeContract, makeEvent, makeJob, makeListener, makePolicy, makePort, makeResource, makeSchedule, makeTest, makeUseCase, } from "./make.js";
+import { featureChoices, integrationChoices, presetChoices, } from "./templates.js";
+export { applyDoctorFixes, createProject, formatDoctor, formatLint, formatRoutes, inspectApp, lintApp, makeAdapter, makeContract, makeEvent, makeJob, makeListener, makePolicy, makePort, makeResource, makeSchedule, makeTest, makeUseCase, };
+const templateChoices = ["next"];
+const packageManagerChoices = [
+    "bun",
+    "npm",
+    "pnpm",
+    "yarn",
+];
+const parseString = (input) => input;
+const forceFlag = {
+    kind: "boolean",
+    optional: true,
+    withNegated: false,
+    brief: "Overwrite conflicting files or write into a non-empty directory.",
+};
+const dryRunFlag = {
+    kind: "boolean",
+    optional: true,
+    withNegated: false,
+    brief: "Preview generated changes without writing files.",
+};
+const jsonFlag = {
+    kind: "boolean",
+    optional: true,
+    withNegated: false,
+    brief: "Print machine-readable JSON.",
+};
+const parsedStringFlag = (brief) => ({
+    kind: "parsed",
+    parse: parseString,
+    optional: true,
+    brief,
+});
+const makeFlagParameters = {
+    force: forceFlag,
+    dryRun: dryRunFlag,
+    json: jsonFlag,
+};
+const jsonFlagParameters = {
+    json: jsonFlag,
+};
+const namePositional = {
+    kind: "tuple",
+    parameters: [
+        {
+            parse: parseString,
+            placeholder: "name",
+            brief: "Name for the generated artifact.",
+        },
+    ],
+};
+const createCommand = buildCommand({
+    docs: {
+        brief: "Create a new Beignet app.",
+        fullDescription: `Available features: ${featureChoices.join(", ")}
+
+Available integrations: ${integrationChoices.join(", ")}`,
+    },
+    parameters: {
+        flags: {
+            template: {
+                kind: "enum",
+                values: templateChoices,
+                default: "next",
+                brief: "Template to use.",
+            },
+            preset: {
+                kind: "enum",
+                values: presetChoices,
+                default: "standard",
+                brief: "Starter preset to generate.",
+            },
+            packageManager: {
+                kind: "enum",
+                values: packageManagerChoices,
+                optional: true,
+                brief: "Package manager to use in next-step commands.",
+            },
+            feature: {
+                kind: "enum",
+                values: featureChoices,
+                optional: true,
+                variadic: true,
+                brief: "Add a starter feature. Repeatable.",
+            },
+            features: {
+                kind: "enum",
+                values: featureChoices,
+                optional: true,
+                variadic: ",",
+                brief: "Add comma-separated starter features.",
+            },
+            integration: {
+                kind: "enum",
+                values: integrationChoices,
+                optional: true,
+                variadic: true,
+                brief: "Add a first-party integration. Repeatable.",
+            },
+            integrations: {
+                kind: "enum",
+                values: integrationChoices,
+                optional: true,
+                variadic: ",",
+                brief: "Add comma-separated first-party integrations.",
+            },
+            force: forceFlag,
+        },
+        positional: {
+            kind: "tuple",
+            parameters: [
+                {
+                    parse: parseString,
+                    placeholder: "directory",
+                    brief: "Project directory to create.",
+                },
+            ],
+        },
+    },
+    async func(flags, directory) {
+        const integrations = uniqueValues([
+            ...(flags.integration ?? []),
+            ...(flags.integrations ?? []),
+        ]);
+        const result = await createProject({
+            name: directory,
+            template: flags.template,
+            preset: flags.preset,
+            features: uniqueValues([
+                ...(flags.feature ?? []),
+                ...(flags.features ?? []),
+            ]),
+            packageManager: flags.packageManager,
+            integrations,
+            force: Boolean(flags.force),
+        });
+        writeOutput(this, nextSteps(result, { integrations }));
+    },
+});
+const routesCommand = buildCommand({
+    docs: {
+        brief: "Inspect registered Beignet routes.",
+    },
+    parameters: {
+        flags: jsonFlagParameters,
+    },
+    async func(flags) {
+        const result = await inspectApp();
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatRoutes(result));
+    },
+});
+const doctorCommand = buildCommand({
+    docs: {
+        brief: "Inspect app wiring and framework conventions.",
+    },
+    parameters: {
+        flags: {
+            json: jsonFlag,
+            strict: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Include CI-oriented warnings and fail on warnings.",
+            },
+            fix: {
+                kind: "boolean",
+                optional: true,
+                withNegated: false,
+                brief: "Apply low-risk fixes before reporting.",
+            },
+        },
+    },
+    async func(flags) {
+        const fixes = flags.fix
+            ? await applyDoctorFixes({ strict: Boolean(flags.strict) })
+            : [];
+        const result = await inspectApp({ strict: Boolean(flags.strict) });
+        result.fixes = fixes;
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatDoctor(result));
+        if (result.diagnostics.some((diagnostic) => diagnostic.severity === "error" ||
+            (flags.strict && diagnostic.severity === "warning"))) {
+            this.process.exitCode = 1;
+        }
+    },
+});
+const lintCommand = buildCommand({
+    docs: {
+        brief: "Check Beignet dependency direction conventions.",
+    },
+    parameters: {
+        flags: jsonFlagParameters,
+    },
+    async func(flags) {
+        const result = await lintApp();
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : formatLint(result));
+        if (result.diagnostics.length > 0) {
+            this.process.exitCode = 1;
+        }
+    },
+});
+const makeResourceCommand = buildCommand({
+    docs: {
+        brief: "Generate a feature resource.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeResource({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makeResourceNextSteps(result));
+    },
+});
+const makeContractCommand = buildCommand({
+    docs: {
+        brief: "Generate a contract group.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeContract({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makeContractNextSteps(result));
+    },
+});
+const makeUseCaseCommand = buildCommand({
+    docs: {
+        brief: "Generate a use case.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeUseCase({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makeUseCaseNextSteps(result));
+    },
+});
+const makeTestCommand = buildCommand({
+    docs: {
+        brief: "Generate a use case test.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeTest({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makeTestNextSteps(result));
+    },
+});
+const makePortCommand = buildCommand({
+    docs: {
+        brief: "Generate an application port.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makePort({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makePortNextSteps(result));
+    },
+});
+const makeAdapterCommand = buildCommand({
+    docs: {
+        brief: "Generate a port adapter.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeAdapter({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makeAdapterNextSteps(result));
+    },
+});
+const makePolicyCommand = buildCommand({
+    docs: {
+        brief: "Generate an authorization policy.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makePolicy({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makePolicyNextSteps(result));
+    },
+});
+const makeEventCommand = buildCommand({
+    docs: {
+        brief: "Generate a feature event.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeEvent({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makeEventNextSteps(result));
+    },
+});
+const makeJobCommand = buildCommand({
+    docs: {
+        brief: "Generate a feature job.",
+    },
+    parameters: {
+        flags: makeFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeJob({
+            name,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json ? JSON.stringify(result, null, 2) : makeJobNextSteps(result));
+    },
+});
+const makeListenerFlagParameters = {
+    ...makeFlagParameters,
+    event: parsedStringFlag("Event to listen to, for example posts/published."),
+};
+const makeListenerCommand = buildCommand({
+    docs: {
+        brief: "Generate a feature event listener.",
+    },
+    parameters: {
+        flags: makeListenerFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        if (!flags.event) {
+            throw new Error("beignet make listener requires --event feature/name, for example --event posts/published.");
+        }
+        const result = await makeListener({
+            name,
+            event: flags.event,
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makeListenerNextSteps(result));
+    },
+});
+const makeScheduleFlagParameters = {
+    ...makeFlagParameters,
+    cron: parsedStringFlag("Cron expression. Defaults to 0 9 * * *."),
+    timezone: parsedStringFlag("IANA timezone, for example America/Chicago."),
+    route: {
+        kind: "boolean",
+        optional: true,
+        withNegated: false,
+        brief: "Generate a Next.js cron route for this schedule.",
+    },
+};
+const makeScheduleCommand = buildCommand({
+    docs: {
+        brief: "Generate a feature schedule.",
+    },
+    parameters: {
+        flags: makeScheduleFlagParameters,
+        positional: namePositional,
+    },
+    async func(flags, name) {
+        const result = await makeSchedule({
+            name,
+            cron: flags.cron,
+            timezone: flags.timezone,
+            route: Boolean(flags.route),
+            force: Boolean(flags.force),
+            dryRun: Boolean(flags.dryRun),
+        });
+        writeOutput(this, flags.json
+            ? JSON.stringify(result, null, 2)
+            : makeScheduleNextSteps(result));
+    },
+});
+const makeRoutes = buildRouteMap({
+    docs: {
+        brief: "Generate Beignet app files.",
+    },
+    routes: {
+        adapter: makeAdapterCommand,
+        contract: makeContractCommand,
+        event: makeEventCommand,
+        job: makeJobCommand,
+        listener: makeListenerCommand,
+        policy: makePolicyCommand,
+        port: makePortCommand,
+        resource: makeResourceCommand,
+        schedule: makeScheduleCommand,
+        test: makeTestCommand,
+        useCase: makeUseCaseCommand,
+    },
+});
+const rootRoutes = buildRouteMap({
+    docs: {
+        brief: "Beignet CLI",
+        fullDescription: `Create apps, generate framework files, inspect routes, and check Beignet conventions.
+
+create-beignet <directory> is equivalent to beignet create <directory>.`,
+    },
+    routes: {
+        create: createCommand,
+        doctor: doctorCommand,
+        lint: lintCommand,
+        make: makeRoutes,
+        routes: routesCommand,
+    },
+});
+const cli = buildApplication(rootRoutes, {
+    name: "beignet",
+    scanner: {
+        caseStyle: "allow-kebab-for-camel",
+    },
+    documentation: {
+        disableAnsiColor: true,
+    },
+    localization: {
+        text: {
+            ...text_en,
+            exceptionWhileRunningCommand: formatCliException,
+            commandErrorResult: (error) => error.message,
+        },
+    },
+    determineExitCode: () => 1,
+});
+function uniqueValues(values) {
+    return [...new Set(values)];
+}
+function writeOutput(context, output) {
+    context.process.stdout.write(`${output}\n`);
+}
+function formatCliException(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+function nextSteps(result, options = {}) {
+    const pm = result.packageManager;
+    const run = pm === "npm" ? "npm run" : `${pm} run`;
+    const envFileStep = result.files.includes(".env.example")
+        ? "  cp .env.example .env.local\n"
+        : "";
+    const envRequiredIntegrations = options.integrations?.filter(isEnvRequiredProviderIntegration) ?? [];
+    const envStep = envRequiredIntegrations.length > 0
+        ? "  Fill .env.local for selected provider integrations before starting the app.\n"
+        : "";
+    return `Created ${result.name} at ${result.targetDir}
+
+Next steps:
+  cd ${result.targetDir}
+  ${pm} install
+${envFileStep}${envStep}\
+  ${run} dev`;
+}
+function isEnvRequiredProviderIntegration(integration) {
+    return (integration === "inngest" ||
+        integration === "resend" ||
+        integration === "upstash-rate-limit");
+}
+function makeResourceNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} resource in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Review the generated schemas and repository fields.
+  Run your app's typecheck and test commands.`;
+}
+function makeContractNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} contract in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Add route handlers for the generated contracts.
+  Register the exported contract list with OpenAPI if this app publishes docs.`;
+}
+function makeUseCaseNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} use case in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter input and output schemas with domain-specific shapes.
+  Add a focused use case test before wiring it to an HTTP route.`;
+}
+function makeTestNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} test in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter input, context, and assertion with behavior-specific coverage.
+  Run your app's test command.`;
+}
+function makePortNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} port in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter execute method with domain-specific operations.
+  Replace the generated infrastructure stub with a real port adapter.`;
+}
+function makePolicyNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} policy in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter abilities with domain-specific authorization rules.
+  Register the policy with createGate(...) and bind it in request context.`;
+}
+function makeAdapterNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} port adapter in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the generated throwing implementation with real infrastructure code.
+  Keep the adapter behind the port interface so use cases stay infrastructure-agnostic.`;
+}
+function makeEventNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} event in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter payload schema with the domain fact shape.
+  Emit the event from a use case with .emits(...) and events.record(...).`;
+}
+function makeJobNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} job in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter payload and handler with the real background work.
+  Dispatch the job through ctx.ports.jobs from a use case, listener, or schedule.`;
+}
+function makeListenerNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} listener in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter handler with the event reaction.
+  Register the listener collection from infrastructure startup.`;
+}
+function makeScheduleNextSteps(result) {
+    const changedFiles = [...result.createdFiles, ...result.updatedFiles]
+        .map((file) => `  ${file}`)
+        .join("\n");
+    const skippedFiles = result.skippedFiles
+        .map((file) => `  ${file}`)
+        .join("\n");
+    return `${result.dryRun ? "Would create" : "Created"} ${result.name} schedule in ${result.targetDir}
+
+Changed files:
+${changedFiles || "  none"}
+${skippedFiles ? `\nSkipped identical files:\n${skippedFiles}` : ""}
+
+Next steps:
+  Replace the starter payload and handler with the scheduled workflow.
+  Trigger it from a cron route, worker, or provider adapter.`;
+}
+export async function main(inputs = process.argv.slice(2), context = { process }) {
+    if (inputs.length === 0) {
+        await run(cli, ["--help"], context);
+        context.process.exitCode = 1;
+        return;
+    }
+    await run(cli, inputs, context);
+    normalizeExitCode(context.process);
+}
+function normalizeExitCode(proc) {
+    if (typeof proc.exitCode === "number" &&
+        (proc.exitCode < 0 || proc.exitCode > 127)) {
+        proc.exitCode = 1;
+    }
+}
+function isCliEntrypoint() {
+    const argvPath = process.argv[1];
+    if (!argvPath) {
+        return false;
+    }
+    try {
+        return (realpathSync(fileURLToPath(import.meta.url)) === realpathSync(argvPath));
+    }
+    catch {
+        return false;
+    }
+}
+if (isCliEntrypoint()) {
+    main().catch((error) => {
+        console.error(error instanceof Error ? error.message : String(error));
+        process.exitCode = 1;
+    });
+}
+//# sourceMappingURL=index.js.map