@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/commands/help.js

@@ -0,0 +1,100 @@
+import * as process from 'node:process';
+import { renderCliError, toCliError, unknownHelpTopic } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+export async function runHelpCommand(argv) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getHelpCommandHelpText());
+        return 0;
+    }
+    try {
+        process.stdout.write(await 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: '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 doctor',
+            'remix new my-remix-app',
+            'remix new my-remix-app --app-name "My Remix App"',
+            'remix routes',
+            '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 test',
+            'remix help version',
+        ],
+        usage: ['remix help [command]'],
+    }, target);
+}
+async 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) {
+        let { getNewCommandHelpText } = await import("./new.js");
+        return getNewCommandHelpText();
+    }
+    if (command === 'completion' && rest.length === 0) {
+        let { getCompletionCommandHelpText } = await import("./completion.js");
+        return getCompletionCommandHelpText();
+    }
+    if (command === 'doctor' && rest.length === 0) {
+        let { getDoctorCommandHelpText } = await import("./doctor.js");
+        return getDoctorCommandHelpText();
+    }
+    if (command === 'routes' && rest.length === 0) {
+        let { getRoutesCommandHelpText } = await import("./routes.js");
+        return getRoutesCommandHelpText();
+    }
+    if (command === 'test' && rest.length === 0) {
+        let { getTestCommandHelpText } = await import("./test.js");
+        return await getTestCommandHelpText();
+    }
+    if (command === 'version' && rest.length === 0) {
+        let { getVersionCommandHelpText } = await import("./version.js");
+        return getVersionCommandHelpText();
+    }
+    throw unknownHelpTopic(argv.join(' '));
+}
+function getNestedHelpText(command, argv) {
+    throw unknownHelpTopic(`${command} ${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"}

package/dist/lib/commands/routes.js

@@ -0,0 +1,161 @@
+import * as process from 'node:process';
+import { invalidFlagCombination, renderCliError, toCliError } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+import { createCommandReporter } from "../reporter.js";
+import { loadRouteMap } from "../route-map.js";
+import { lightRed } from "../terminal.js";
+const CONTROLLERS_PATH_PREFIX = 'app/controllers/';
+export async function runRoutesCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getRoutesCommandHelpText());
+        return 0;
+    }
+    try {
+        let options = parseRoutesCommandArgs(argv);
+        let routeMap = await loadRouteMap(context.cwd);
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify(routeMap, null, 2)}\n`);
+        }
+        else {
+            let reporter = createCommandReporter({ remixVersion: context.remixVersion });
+            writeRouteMap(reporter.out, routeMap, options);
+            reporter.finish();
+        }
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getRoutesCommandHelpText(process.stderr) }));
+        return 1;
+    }
+}
+export function getRoutesCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Show the Remix route tree for the current app.',
+        examples: [
+            'remix routes',
+            'remix routes --table',
+            'remix routes --table --no-headers',
+            'remix routes --verbose',
+            'remix routes --json',
+        ],
+        options: [
+            { description: 'Print the normalized route tree as JSON', label: '--json' },
+            { description: 'Print routes as a flat table', label: '--table' },
+            {
+                description: 'Omit the table header row when using --table',
+                label: '--no-headers',
+            },
+            { description: 'Show full owner paths in tree or table output', label: '--verbose' },
+        ],
+        usage: ['remix routes [--json | --table] [--no-headers] [--verbose] [--no-color]'],
+    }, target);
+}
+function parseRoutesCommandArgs(argv) {
+    let parsed = parseArgs(argv, {
+        json: { flag: '--json', type: 'boolean' },
+        noHeaders: { flag: '--no-headers', type: 'boolean' },
+        table: { flag: '--table', type: 'boolean' },
+        verbose: { flag: '--verbose', type: 'boolean' },
+    }, { maxPositionals: 0 });
+    let json = parsed.options.json;
+    let noHeaders = parsed.options.noHeaders;
+    let table = parsed.options.table;
+    let verbose = parsed.options.verbose;
+    if (json && table) {
+        throw invalidFlagCombination('Cannot combine --json with --table.');
+    }
+    if (json && verbose) {
+        throw invalidFlagCombination('Cannot combine --json with --verbose.');
+    }
+    if (noHeaders && !table) {
+        throw invalidFlagCombination('Cannot use --no-headers without --table.');
+    }
+    return { json, noHeaders, table, verbose };
+}
+function writeRouteMap(out, routeMap, options) {
+    if (routeMap.tree.length === 0) {
+        out.line('No routes.');
+        return;
+    }
+    if (options.table) {
+        writeRouteTable(out, routeMap, options);
+        return;
+    }
+    let lines = [];
+    renderRouteNodes(lines, routeMap.tree, '', true, null, options);
+    for (let line of lines) {
+        out.line(line);
+    }
+}
+function renderRouteNodes(lines, nodes, prefix, isRoot, parentOwnerPath, options) {
+    let leafKeyWidth = getLeafKeyWidth(nodes);
+    nodes.forEach((node, index) => {
+        renderRouteNode(lines, node, prefix, index === nodes.length - 1, isRoot, parentOwnerPath, leafKeyWidth, options);
+    });
+}
+function renderRouteNode(lines, node, prefix, isLast, isRoot, parentOwnerPath, leafKeyWidth, options) {
+    let branch = isRoot ? '' : isLast ? '└─ ' : '├─ ';
+    let line = `${prefix}${branch}${formatRouteNode(node, parentOwnerPath, leafKeyWidth, options)}`;
+    lines.push(colorRouteLine(line, node));
+    if (node.kind !== 'group') {
+        return;
+    }
+    let childPrefix = isRoot ? '' : `${prefix}${isLast ? '   ' : '│  '}`;
+    renderRouteNodes(lines, node.children, childPrefix, false, node.owner.path, options);
+}
+function getLeafKeyWidth(nodes) {
+    let leafNodes = nodes.filter((node) => node.kind === 'route');
+    return leafNodes.reduce((width, node) => Math.max(width, node.key.length), 0);
+}
+function formatRouteNode(node, parentOwnerPath, leafKeyWidth, options) {
+    let owner = formatOwner(node, options);
+    if (node.kind === 'group') {
+        return `${node.key} -> ${owner}`;
+    }
+    let leaf = `${node.key.padEnd(leafKeyWidth)}  ${node.method.padEnd(6)} ${node.pattern}`;
+    if (options.verbose || parentOwnerPath == null || parentOwnerPath !== node.owner.path) {
+        return `${leaf} -> ${owner}`;
+    }
+    return leaf;
+}
+function writeRouteTable(out, routeMap, options) {
+    let rows = flattenRoutes(routeMap.tree).map((node) => ({
+        method: node.method,
+        node,
+        owner: formatOwner(node, options),
+        path: node.pattern,
+        route: node.name,
+    }));
+    out.table({
+        formatRow(line, rowIndex) {
+            return colorRouteLine(line, rows[rowIndex].node);
+        },
+        headers: ['Route', 'Method', 'Path', 'Owner'],
+        noHeaders: options.noHeaders,
+        rows: rows.map((row) => [row.route, row.method, row.path, row.owner]),
+    });
+}
+function flattenRoutes(nodes, routes = []) {
+    for (let node of nodes) {
+        if (node.kind === 'route') {
+            routes.push(node);
+            continue;
+        }
+        flattenRoutes(node.children, routes);
+    }
+    return routes;
+}
+function formatOwner(node, options) {
+    let ownerPath = options.verbose ? node.owner.path : getCompactOwnerPath(node.owner.path);
+    return `${ownerPath}${node.owner.exists ? '' : ' [missing]'}`;
+}
+function colorRouteLine(line, node) {
+    return node.owner.exists ? line : lightRed(line);
+}
+function getCompactOwnerPath(ownerPath) {
+    if (ownerPath.startsWith(CONTROLLERS_PATH_PREFIX)) {
+        return ownerPath.slice(CONTROLLERS_PATH_PREFIX.length);
+    }
+    return ownerPath;
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/test.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAGnD,wBAAsB,cAAc,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAkBzF;AAED,wBAAsB,sBAAsB,CAC1C,MAAM,GAAE,MAAM,CAAC,WAA4B,GAC1C,OAAO,CAAC,MAAM,CAAC,CAGjB"}

package/dist/lib/commands/test.js

@@ -0,0 +1,23 @@
+import * as process from 'node:process';
+import { renderCliError, toCliError } from "../errors.js";
+export async function runTestCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(`${await getTestCommandHelpText()}\n`);
+        return 0;
+    }
+    try {
+        let { runRemixTest } = await import('@remix-run/test/cli');
+        return await runRemixTest({ argv, cwd: context.cwd });
+    }
+    catch (error) {
+        let helpText = await getTestCommandHelpText(process.stderr);
+        process.stderr.write(renderCliError(toCliError(error), {
+            helpText,
+        }));
+        return 1;
+    }
+}
+export async function getTestCommandHelpText(target = process.stdout) {
+    let { getRemixTestHelpText } = await import('@remix-run/test/cli');
+    return getRemixTestHelpText(target);
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/version.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAKnD,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAoB5F;AAED,wBAAgB,yBAAyB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAS7F"}

package/dist/lib/commands/version.js

@@ -0,0 +1,29 @@
+import * as process from 'node:process';
+import { remixVersionUnavailable, renderCliError, toCliError } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+export async function runVersionCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getVersionCommandHelpText());
+        return 0;
+    }
+    try {
+        parseArgs(argv, {}, { maxPositionals: 0 });
+        if (context.remixVersion == null) {
+            throw remixVersionUnavailable();
+        }
+        process.stdout.write(`${context.remixVersion}\n`);
+        return 0;
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getVersionCommandHelpText(process.stderr) }));
+        return 1;
+    }
+}
+export function getVersionCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Show the current Remix version.',
+        examples: ['remix version', 'remix --version'],
+        usage: ['remix version'],
+    }, target);
+}

package/dist/lib/completion.d.ts

@@ -0,0 +1,12 @@
+export interface CompletionResult {
+    mode: 'files' | 'none' | 'values';
+    values?: string[];
+}
+declare const COMPLETION_SHELLS: readonly ["bash", "zsh"];
+export type CompletionShell = (typeof COMPLETION_SHELLS)[number];
+export declare function isCompletionShell(value: string): value is CompletionShell;
+export declare function getCompletionResult(words: string[], currentIndex: number): CompletionResult;
+export declare function renderCompletionResult(result: CompletionResult): string;
+export declare function getCompletionScript(): string;
+export {};
+//# sourceMappingURL=completion.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"completion.d.ts","sourceRoot":"","sources":["../../src/lib/completion.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,gBAAgB;IAC/B,IAAI,EAAE,OAAO,GAAG,MAAM,GAAG,QAAQ,CAAA;IACjC,MAAM,CAAC,EAAE,MAAM,EAAE,CAAA;CAClB;AAED,QAAA,MAAM,iBAAiB,0BAA2B,CAAA;AAIlD,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEhE,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,MAAM,GAAG,KAAK,IAAI,eAAe,CAEzE;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE,YAAY,EAAE,MAAM,GAAG,gBAAgB,CAM3F;AAED,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,gBAAgB,GAAG,MAAM,CAQvE;AAED,wBAAgB,mBAAmB,IAAI,MAAM,CA4E5C"}