@remix-run/cli 0.0.0 → 0.1.0

package/dist/lib/cli.js

@@ -0,0 +1,87 @@
+import * as process from 'node:process';
+import { runCompletionCommand } from "./commands/completion.js";
+import { runDoctorCommand } from "./commands/doctor.js";
+import { getCliHelpText, runHelpCommand } from "./commands/help.js";
+import { runNewCommand } from "./commands/new.js";
+import { runRoutesCommand } from "./commands/routes.js";
+import { runSkillsCommand } from "./commands/skills.js";
+import { runTestCommand } from "./commands/test.js";
+import { runVersionCommand } from "./commands/version.js";
+import { resolveCliContext } from "./cli-context.js";
+import { renderCliError, unknownCommand } from "./errors.js";
+import { configureColors, restoreTerminalFormatting } from "./terminal.js";
+export async function runRemix(argv = process.argv.slice(2), options = {}) {
+    let context = await resolveCliContext(options);
+    try {
+        while (argv[0] === '--') {
+            argv = argv.slice(1);
+        }
+        let globalOptions = extractGlobalOptions(argv);
+        argv = globalOptions.argv;
+        configureColors({ disabled: globalOptions.noColor });
+        if (argv.length === 0) {
+            process.stdout.write(getCliHelpText());
+            return 0;
+        }
+        let [command, ...rest] = argv;
+        if (command === '-h' || command === '--help') {
+            process.stdout.write(getCliHelpText());
+            return 0;
+        }
+        return await runCommand(command, rest, context);
+    }
+    finally {
+        restoreTerminalFormatting();
+    }
+}
+async function runCommand(command, argv, context) {
+    if (command === 'help') {
+        return runHelpCommand(argv);
+    }
+    if (command === '-v' || command === '--version') {
+        return runVersionCommand([], context);
+    }
+    if (command === 'new') {
+        return runNewCommand(argv, context);
+    }
+    if (command === 'completion') {
+        return runCompletionCommand(argv);
+    }
+    if (command === 'doctor') {
+        return runDoctorCommand(argv, context);
+    }
+    if (command === 'skills') {
+        return runSkillsCommand(argv, context);
+    }
+    if (command === 'routes') {
+        return runRoutesCommand(argv, context);
+    }
+    if (command === 'test') {
+        return runTestCommand(argv, context);
+    }
+    if (command === 'version') {
+        return runVersionCommand(argv, context);
+    }
+    process.stderr.write(renderCliError(unknownCommand(command), { helpText: getCliHelpText(process.stderr) }));
+    return 1;
+}
+function extractGlobalOptions(argv) {
+    let filteredArgv = [];
+    let noColor = false;
+    for (let index = 0; index < argv.length; index++) {
+        let arg = argv[index];
+        if (arg === '--') {
+            filteredArgv.push(...argv.slice(index));
+            break;
+        }
+        if (arg === '--no-color') {
+            noColor = true;
+            continue;
+        }
+        filteredArgv.push(arg);
+    }
+    return {
+        argv: filteredArgv,
+        noColor,
+    };
+}

package/dist/lib/commands/completion.d.ts

@@ -0,0 +1,3 @@
+export declare function runCompletionCommand(argv: string[]): Promise<number>;
+export declare function getCompletionCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=completion.d.ts.map

package/dist/lib/commands/completion.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/completion.ts"],"names":[],"mappings":"AAiBA,wBAAsB,oBAAoB,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CA6B1E;AAED,wBAAgB,4BAA4B,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAShG"}

package/dist/lib/commands/completion.js

@@ -0,0 +1,51 @@
+import * as process from 'node:process';
+import { getCompletionResult, getCompletionScript, isCompletionShell, renderCompletionResult, } from "../completion.js";
+import { invalidCompletionRequest, renderCliError, toCliError, unknownCompletionShell, } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+export async function runCompletionCommand(argv) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        process.stdout.write(getCompletionCommandHelpText());
+        return 0;
+    }
+    if (argv[0] === '--') {
+        return runCompletionPlumbing(argv.slice(1));
+    }
+    let [shell, ...rest] = argv;
+    try {
+        parseArgs(rest, {}, { maxPositionals: 0 });
+        if (!isCompletionShell(shell)) {
+            throw unknownCompletionShell(shell);
+        }
+        process.stdout.write(getCompletionScript());
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), {
+            helpText: getCompletionCommandHelpText(process.stderr),
+        }));
+        return 1;
+    }
+}
+export function getCompletionCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Print a shell completion script for Remix.',
+        examples: ['remix completion bash >> ~/.bashrc', 'remix completion zsh >> ~/.zshrc'],
+        usage: ['remix completion <bash|zsh>'],
+    }, target);
+}
+function runCompletionPlumbing(argv) {
+    try {
+        let [currentIndexArg, ...words] = argv;
+        if (currentIndexArg == null || !/^\d+$/.test(currentIndexArg)) {
+            throw invalidCompletionRequest();
+        }
+        let currentIndex = Number(currentIndexArg);
+        process.stdout.write(renderCompletionResult(getCompletionResult(words, currentIndex)));
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error)));
+        return 1;
+    }
+}

package/dist/lib/commands/doctor.d.ts

@@ -0,0 +1,4 @@
+import type { CliContext } from '../cli-context.ts';
+export declare function runDoctorCommand(argv: string[], context: CliContext): Promise<number>;
+export declare function getDoctorCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=doctor.d.ts.map

package/dist/lib/commands/doctor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doctor.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/doctor.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AA4CnD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CA6C3F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAsB5F"}

package/dist/lib/commands/doctor.js

@@ -0,0 +1,293 @@
+import * as path from 'node:path';
+import * as process from 'node:process';
+import { checkControllerConventions } from "../doctor/controllers.js";
+import { checkEnvironment, getEnvironmentFixPlans } from "../doctor/environment.js";
+import { applyDoctorFixPlans } from "../doctor/fixes.js";
+import { checkProject, getProjectFixPlans } from "../doctor/project.js";
+import { createDoctorSuite, createSkippedDoctorSuite, } from "../doctor/types.js";
+import { renderCliError, toCliError } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+import { createCommandReporter, createStepProgressReporter, } from "../reporter.js";
+const DOCTOR_SUITE_LABELS = {
+    controllers: {
+        complete: 'controllers',
+        running: 'Checking controllers',
+    },
+    environment: {
+        complete: 'environment',
+        running: 'Checking environment',
+    },
+    project: {
+        complete: 'project',
+        running: 'Checking project',
+    },
+};
+export async function runDoctorCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getDoctorCommandHelpText());
+        return 0;
+    }
+    let reporter = null;
+    let progress = null;
+    try {
+        let options = parseDoctorCommandArgs(argv);
+        reporter = options.json
+            ? null
+            : createCommandReporter({
+                remixVersion: context.remixVersion,
+                stderr: process.stdout,
+                stdout: process.stdout,
+            });
+        progress = reporter == null ? null : createDoctorProgressReporter(reporter);
+        if (reporter != null) {
+            await reporter.status.commandHeader('doctor');
+        }
+        let report = await collectDoctorReport(progress, options, reporter, context);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(report, null, 2)}\n`);
+        }
+        else if (reporter != null) {
+            writeDoctorReport(reporter, report);
+            reporter.finish();
+        }
+        if ((options.fix || options.strict) && hasWarningFindings(report.findings)) {
+            return 1;
+        }
+        return 0;
+    }
+    catch (error) {
+        progress?.writeSummaryGap();
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getDoctorCommandHelpText(process.stderr) }));
+        reporter?.finish();
+        return 1;
+    }
+}
+export function getDoctorCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Check project environment and Remix app conventions for the current project.',
+        examples: [
+            'remix doctor',
+            'remix doctor --json',
+            'remix doctor --strict',
+            'remix doctor --fix',
+        ],
+        options: [
+            { description: 'Print doctor findings as JSON', label: '--json' },
+            {
+                description: 'Exit with status 1 when warning-level findings are present',
+                label: '--strict',
+            },
+            { description: 'Apply low-risk project and controller fixes', label: '--fix' },
+        ],
+        usage: ['remix doctor [--json] [--strict] [--fix] [--no-color]'],
+    }, target);
+}
+function parseDoctorCommandArgs(argv) {
+    let parsed = parseArgs(argv, {
+        fix: { flag: '--fix', type: 'boolean' },
+        json: { flag: '--json', type: 'boolean' },
+        strict: { flag: '--strict', type: 'boolean' },
+    }, { maxPositionals: 0 });
+    return {
+        fix: parsed.options.fix,
+        json: parsed.options.json,
+        strict: parsed.options.strict,
+    };
+}
+async function collectDoctorReport(progress, options, reporter, context) {
+    let cwd = context.cwd;
+    let appliedFixes = [];
+    let environment = await runDoctorSuite(progress, 'environment', async () => {
+        let result = await checkEnvironment(cwd);
+        let suiteAppliedFixes = [];
+        let finalResult = result;
+        if (options.fix && result.projectRoot != null) {
+            let fixPlans = getEnvironmentFixPlans(result, context.remixVersion);
+            if (fixPlans.length > 0) {
+                suiteAppliedFixes = await applyDoctorFixPlans(result.projectRoot, fixPlans);
+                finalResult = await checkEnvironment(result.projectRoot);
+            }
+        }
+        let suite = finalResult.suite;
+        if (suiteAppliedFixes.length > 0) {
+            suite = {
+                ...suite,
+                appliedFixes: suiteAppliedFixes,
+            };
+        }
+        return {
+            appliedFixes: suiteAppliedFixes,
+            projectRoot: finalResult.projectRoot ?? result.projectRoot,
+            suite,
+        };
+    });
+    let findings = [...environment.suite.findings];
+    appliedFixes.push(...(environment.appliedFixes ?? []));
+    let suites = [environment.suite];
+    let routesFile = environment.projectRoot == null
+        ? undefined
+        : path.join(environment.projectRoot, 'app', 'routes.ts');
+    writeDoctorSuiteDetails(reporter, environment.suite);
+    progress?.writeSummaryGap();
+    if (hasWarningFindings(environment.suite.findings)) {
+        let projectSuite = createSkippedDoctorSuite('project', 'Blocked by environment warnings.');
+        let controllersSuite = createSkippedDoctorSuite('controllers', 'Blocked by environment warnings.');
+        suites.push(projectSuite, controllersSuite);
+        progress?.skip(projectSuite.name, projectSuite.reason);
+        writeDoctorSuiteDetails(reporter, projectSuite);
+        progress?.writeSummaryGap();
+        progress?.skip(controllersSuite.name, controllersSuite.reason);
+        writeDoctorSuiteDetails(reporter, controllersSuite);
+        progress?.writeSummaryGap();
+        return {
+            appRoot: environment.projectRoot,
+            appliedFixes,
+            findings,
+            remainingFindings: findings,
+            routesFile,
+            suites,
+        };
+    }
+    let project = await runDoctorSuite(progress, 'project', async () => {
+        let result = await checkProject(environment.projectRoot);
+        let suiteAppliedFixes = [];
+        let finalResult = result;
+        if (options.fix) {
+            let fixPlans = await getProjectFixPlans(environment.projectRoot);
+            if (fixPlans.length > 0) {
+                suiteAppliedFixes = await applyDoctorFixPlans(environment.projectRoot, fixPlans);
+                finalResult = await checkProject(environment.projectRoot);
+            }
+        }
+        let suite = finalResult.suite;
+        if (suiteAppliedFixes.length > 0) {
+            suite = {
+                ...suite,
+                appliedFixes: suiteAppliedFixes,
+            };
+        }
+        return {
+            appliedFixes: suiteAppliedFixes,
+            routeManifest: finalResult.routeManifest,
+            routesFile: finalResult.routesFile,
+            suite,
+        };
+    });
+    findings.push(...project.suite.findings);
+    appliedFixes.push(...(project.appliedFixes ?? []));
+    routesFile = project.routesFile;
+    suites.push(project.suite);
+    writeDoctorSuiteDetails(reporter, project.suite);
+    progress?.writeSummaryGap();
+    if (hasWarningFindings(project.suite.findings)) {
+        let controllersSuite = createSkippedDoctorSuite('controllers', 'Blocked by project warnings.');
+        suites.push(controllersSuite);
+        progress?.skip(controllersSuite.name, controllersSuite.reason);
+        writeDoctorSuiteDetails(reporter, controllersSuite);
+        progress?.writeSummaryGap();
+        return {
+            appRoot: environment.projectRoot,
+            appliedFixes,
+            findings,
+            remainingFindings: findings,
+            routesFile,
+            suites,
+        };
+    }
+    let controllers = await runDoctorSuite(progress, 'controllers', async () => {
+        let controllerResult = await checkControllerConventions(project.routeManifest.appRoot, project.routeManifest.tree);
+        let remainingFindings = controllerResult.suite.findings;
+        let suiteAppliedFixes = [];
+        if (options.fix && controllerResult.fixPlans.length > 0) {
+            suiteAppliedFixes = await applyDoctorFixPlans(project.routeManifest.appRoot, controllerResult.fixPlans);
+            let finalControllerResult = await checkControllerConventions(project.routeManifest.appRoot, project.routeManifest.tree);
+            remainingFindings = finalControllerResult.suite.findings;
+        }
+        let suite = createDoctorSuite('controllers', remainingFindings);
+        if (suiteAppliedFixes.length > 0) {
+            suite.appliedFixes = suiteAppliedFixes;
+        }
+        return { appliedFixes: suiteAppliedFixes, suite };
+    });
+    findings.push(...controllers.suite.findings);
+    appliedFixes.push(...(controllers.appliedFixes ?? []));
+    suites.push(controllers.suite);
+    writeDoctorSuiteDetails(reporter, controllers.suite);
+    progress?.writeSummaryGap();
+    let report = {
+        appRoot: environment.projectRoot,
+        findings,
+        routesFile,
+        suites,
+    };
+    if (options.fix) {
+        report.appliedFixes = appliedFixes;
+        report.remainingFindings = findings;
+    }
+    return report;
+}
+function hasWarningFindings(findings) {
+    return findings.some((finding) => finding.severity === 'warn');
+}
+function formatAppliedFix(appliedFix) {
+    if (appliedFix.kind === 'update-file') {
+        return `Updated ${appliedFix.path}`;
+    }
+    return `Created ${appliedFix.path}`;
+}
+async function runDoctorSuite(progress, label, callback) {
+    progress?.start(label);
+    try {
+        let result = await callback();
+        if (result.suite.status === 'ok') {
+            progress?.succeed(label);
+        }
+        else if (result.suite.status === 'issues') {
+            progress?.fail(label);
+        }
+        else {
+            progress?.skip(label, result.suite.reason);
+        }
+        return result;
+    }
+    catch (error) {
+        progress?.fail(label);
+        throw error;
+    }
+}
+function createDoctorProgressReporter(reporter) {
+    return createStepProgressReporter(reporter.status, DOCTOR_SUITE_LABELS);
+}
+function writeDoctorReport(reporter, report) {
+    let warningCount = report.findings.filter((finding) => finding.severity === 'warn').length;
+    let adviceCount = report.findings.length - warningCount;
+    if ((report.appliedFixes?.length ?? 0) > 0) {
+        let fixCount = report.appliedFixes.length;
+        reporter.out.line(`Applied ${fixCount} ${fixCount === 1 ? 'fix' : 'fixes'}.`);
+    }
+    if (report.findings.length === 0) {
+        reporter.out.line('Doctor found no issues.');
+    }
+    reporter.out.line(`Summary: ${warningCount} warnings, ${adviceCount} advice.`);
+}
+function writeDoctorSuiteDetails(reporter, suite) {
+    if (reporter == null) {
+        return;
+    }
+    if (suite.findings.length === 0 && (suite.appliedFixes?.length ?? 0) === 0) {
+        return;
+    }
+    reporter.out.withIndent(() => {
+        for (let finding of suite.findings) {
+            reporter.out.bullet(reporter.out.label(finding.severity.toUpperCase(), finding.message, {
+                tone: finding.severity === 'warn' ? 'warn' : undefined,
+            }));
+        }
+        if ((suite.appliedFixes?.length ?? 0) > 0) {
+            reporter.out.section('Applied fixes:', () => {
+                reporter.out.bullets((suite.appliedFixes ?? []).map(formatAppliedFix));
+            });
+        }
+    });
+}

package/dist/lib/commands/help.d.ts

@@ -0,0 +1,4 @@
+export declare function runHelpCommand(argv: string[]): Promise<number>;
+export declare function getCliHelpText(target?: NodeJS.WriteStream): string;
+export declare function getHelpCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=help.d.ts.map

package/dist/lib/commands/help.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"help.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/help.ts"],"names":[],"mappings":"AAgBA,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAepE;AAED,wBAAgB,cAAc,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAoClF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAkB1F"}

package/dist/lib/commands/help.js

@@ -0,0 +1,124 @@
+import * as process from 'node:process';
+import { getCompletionCommandHelpText } from "./completion.js";
+import { renderCliError, toCliError, unknownHelpTopic } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { getDoctorCommandHelpText } from "./doctor.js";
+import { getNewCommandHelpText } from "./new.js";
+import { getRoutesCommandHelpText } from "./routes.js";
+import { getSkillsCommandHelpText, getSkillsInstallCommandHelpText, getSkillsListCommandHelpText, } from "./skills.js";
+import { getTestCommandHelpText } from "./test.js";
+import { getVersionCommandHelpText } from "./version.js";
+export async function runHelpCommand(argv) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getHelpCommandHelpText());
+        return 0;
+    }
+    try {
+        process.stdout.write(getCommandHelpText(argv));
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getCliHelpText(process.stderr) }));
+        return 1;
+    }
+}
+export function getCliHelpText(target = process.stdout) {
+    return formatHelpText({
+        commands: [
+            { description: 'Print shell completion scripts for Remix', label: 'completion' },
+            { description: 'Show help for Remix commands', label: 'help [command]' },
+            { description: 'Create a new Remix project', label: 'new <name>' },
+            { description: 'Check project health for the current project', label: 'doctor' },
+            { description: 'Show the route tree for the current project', label: 'routes' },
+            { description: 'Manage Remix skills for the current project', label: 'skills' },
+            { description: 'Run tests for the current project', label: 'test [glob]' },
+            { description: 'Show the current Remix version', label: 'version' },
+        ],
+        examples: [
+            'remix completion bash',
+            'remix help',
+            'remix help completion',
+            'remix help doctor',
+            'remix help skills install',
+            'remix doctor',
+            'remix new my-remix-app',
+            'remix new my-remix-app --app-name "My Remix App"',
+            'remix routes',
+            'remix skills install',
+            'remix test',
+            'remix version',
+        ],
+        options: [
+            { description: 'Show help', label: '-h, --help' },
+            { description: 'Disable ANSI color output', label: '--no-color' },
+            { description: 'Show version', label: '-v, --version' },
+        ],
+        usage: ['remix <command> [options]'],
+    }, target);
+}
+export function getHelpCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Show help for Remix commands.',
+        examples: [
+            'remix help',
+            'remix help completion',
+            'remix help doctor',
+            'remix help new',
+            'remix help routes',
+            'remix help skills install',
+            'remix help test',
+            'remix help version',
+        ],
+        usage: ['remix help [command]'],
+    }, target);
+}
+function getCommandHelpText(argv) {
+    if (argv.length === 0) {
+        return getCliHelpText();
+    }
+    let [command, ...rest] = argv;
+    if (command === 'help') {
+        return rest.length === 0 ? getHelpCommandHelpText() : getNestedHelpText(command, rest);
+    }
+    if (command === 'new' && rest.length === 0) {
+        return getNewCommandHelpText();
+    }
+    if (command === 'completion' && rest.length === 0) {
+        return getCompletionCommandHelpText();
+    }
+    if (command === 'doctor' && rest.length === 0) {
+        return getDoctorCommandHelpText();
+    }
+    if (command === 'routes' && rest.length === 0) {
+        return getRoutesCommandHelpText();
+    }
+    if (command === 'skills') {
+        return getSkillsHelpText(rest);
+    }
+    if (command === 'test' && rest.length === 0) {
+        return getTestCommandHelpText();
+    }
+    if (command === 'version' && rest.length === 0) {
+        return getVersionCommandHelpText();
+    }
+    throw unknownHelpTopic(argv.join(' '));
+}
+function getNestedHelpText(command, argv) {
+    throw unknownHelpTopic(`${command} ${argv.join(' ')}`);
+}
+function getSkillsHelpText(argv) {
+    if (argv.length === 0) {
+        return getSkillsCommandHelpText();
+    }
+    let [subcommand, ...rest] = argv;
+    if (rest.length > 0) {
+        throw unknownHelpTopic(`skills ${argv.join(' ')}`);
+    }
+    if (subcommand === 'install') {
+        return getSkillsInstallCommandHelpText();
+    }
+    if (subcommand === 'list') {
+        return getSkillsListCommandHelpText();
+    }
+    throw unknownHelpTopic(`skills ${argv.join(' ')}`);
+}

package/dist/lib/commands/new.d.ts

@@ -0,0 +1,4 @@
+import type { CliContext } from '../cli-context.ts';
+export declare function runNewCommand(argv: string[], context: CliContext): Promise<number>;
+export declare function getNewCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=new.d.ts.map

package/dist/lib/commands/new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"new.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/new.ts"],"names":[],"mappings":"AAQA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAiBnD,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAqCxF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAazF"}

package/dist/lib/commands/new.js

@@ -0,0 +1,70 @@
+import * as process from 'node:process';
+import { bootstrapProject } from "../bootstrap-project.js";
+import { renderCliError, missingTargetDirectory, toCliError } from "../errors.js";
+import { getDisplayPath } from "../display-path.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+import { createCommandReporter, createStepProgressReporter, } from "../reporter.js";
+const NEW_PROGRESS_LABELS = {
+    'finalize-package-json': 'Finalize package.json',
+    'generate-scaffold-files': 'Generate scaffold files',
+    'prepare-target-directory': 'Prepare target directory',
+};
+export async function runNewCommand(argv, context) {
+    if (argv.length === 0 || argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getNewCommandHelpText());
+        return 0;
+    }
+    let reporter = null;
+    let progress = null;
+    try {
+        let options = parseNewCommandArgs(argv);
+        reporter = createCommandReporter({ remixVersion: context.remixVersion });
+        progress = createNewProgressReporter(reporter);
+        await reporter.status.commandHeader('new');
+        let result = await bootstrapProject({
+            ...options,
+            cwd: context.cwd,
+            remixVersion: context.remixVersion,
+        }, progress);
+        progress.writeSummaryGap();
+        reporter.out.line(`Created ${result.appDisplayName} at ${getDisplayPath(result.targetDir, context.cwd)}`);
+        reporter.finish();
+        return 0;
+    }
+    catch (error) {
+        progress?.writeSummaryGap();
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getNewCommandHelpText(process.stderr) }));
+        reporter?.finish();
+        return 1;
+    }
+}
+export function getNewCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Create a new Remix project in the target directory.',
+        examples: [
+            'remix new ./my-remix-app',
+            'remix new ./my-remix-app --app-name "My Remix App"',
+            'remix new ./my-remix-app --force',
+        ],
+        usage: ['remix new <target-dir> [--app-name <name>] [--force]'],
+    }, target);
+}
+function parseNewCommandArgs(argv) {
+    let parsed = parseArgs(argv, {
+        appName: { flag: '--app-name', type: 'string' },
+        force: { flag: '--force', type: 'boolean' },
+    }, { maxPositionals: 1 });
+    let targetDir = parsed.positionals[0] ?? null;
+    if (targetDir == null) {
+        throw missingTargetDirectory();
+    }
+    return {
+        appName: parsed.options.appName ?? null,
+        force: parsed.options.force,
+        targetDir,
+    };
+}
+function createNewProgressReporter(reporter) {
+    return createStepProgressReporter(reporter.status, NEW_PROGRESS_LABELS);
+}

package/dist/lib/commands/routes.d.ts

@@ -0,0 +1,4 @@
+import type { CliContext } from '../cli-context.ts';
+export declare function runRoutesCommand(argv: string[], context: CliContext): Promise<number>;
+export declare function getRoutesCommandHelpText(target?: NodeJS.WriteStream): string;
+//# sourceMappingURL=routes.d.ts.map

package/dist/lib/commands/routes.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"routes.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/routes.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAUnD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAyB3F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAwB5F"}