@remix-run/cli 0.0.0 → 0.1.0

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/skills.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"skills.d.ts","sourceRoot":"","sources":["../../../src/lib/commands/skills.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAsBnD,wBAAsB,gBAAgB,CAAC,IAAI,EAAE,MAAM,EAAE,EAAE,OAAO,EAAE,UAAU,GAAG,OAAO,CAAC,MAAM,CAAC,CAwB3F;AAED,wBAAgB,wBAAwB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAwB5F;AAED,wBAAgB,+BAA+B,CAC7C,MAAM,GAAE,MAAM,CAAC,WAA4B,GAC1C,MAAM,CAeR;AAED,wBAAgB,4BAA4B,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAqBhG"}

package/dist/lib/commands/skills.js

@@ -0,0 +1,222 @@
+import * as process from 'node:process';
+import { getDisplayPath } from "../display-path.js";
+import { renderCliError, toCliError, unknownSkillsCommand } from "../errors.js";
+import { formatHelpText } from "../help-text.js";
+import { parseArgs } from "../parse-args.js";
+import { getSkillsOverview, installRemixSkills } from "../skills.js";
+import { createCommandReporter, createStepProgressReporter, } from "../reporter.js";
+const SKILLS_PROGRESS_LABELS = {
+    'compare-local-skills': 'Compare local skills',
+    'download-remix-skills-archive': 'Download Remix skills archive',
+    'fetch-remix-skills-metadata': 'Fetch Remix skills metadata from GitHub',
+    'read-local-skills-cache': 'Read local skills cache',
+    'resolve-project-root': 'Resolve project root',
+    'write-updated-skills': 'Write updated skills',
+};
+export async function runSkillsCommand(argv, context) {
+    if (argv.length === 0 || argv[0] === '-h' || argv[0] === '--help') {
+        process.stdout.write(getSkillsCommandHelpText());
+        return 0;
+    }
+    let [subcommand, ...rest] = argv;
+    try {
+        if (subcommand === 'install') {
+            return await runSkillsInstallCommand(rest, context);
+        }
+        if (subcommand === 'list') {
+            return await runSkillsListCommand(rest, context);
+        }
+        throw unknownSkillsCommand(subcommand);
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getSkillsCommandHelpText(process.stderr) }));
+        return 1;
+    }
+}
+export function getSkillsCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        commands: [
+            {
+                description: 'Install Remix skills into a local directory',
+                label: 'install [--dir <path>]',
+            },
+            {
+                description: 'List Remix skills and local status',
+                label: 'list [--dir <path>] [--json]',
+            },
+        ],
+        description: 'Manage Remix skills for the current project.',
+        examples: [
+            'remix skills install',
+            'remix skills install --dir custom/skills',
+            'remix skills list --dir custom/skills',
+            'remix skills list --json',
+        ],
+        usage: ['remix skills <command>'],
+    }, target);
+}
+export function getSkillsInstallCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'Install or refresh Remix skills in .agents/skills for the current project.',
+        examples: ['remix skills install', 'remix skills install --dir custom/skills'],
+        options: [
+            {
+                description: 'Install skills into a custom directory relative to the project root',
+                label: '--dir <path>',
+            },
+        ],
+        usage: ['remix skills install [--dir <path>]'],
+    }, target);
+}
+export function getSkillsListCommandHelpText(target = process.stdout) {
+    return formatHelpText({
+        description: 'List Remix skills and show whether each one is installed, outdated, or missing locally.',
+        examples: [
+            'remix skills list',
+            'remix skills list --dir custom/skills',
+            'remix skills list --json',
+        ],
+        options: [
+            {
+                description: 'Read local skills from a custom directory relative to the project root',
+                label: '--dir <path>',
+            },
+            { description: 'Print skill state as JSON', label: '--json' },
+        ],
+        usage: ['remix skills list [--dir <path>] [--json]'],
+    }, target);
+}
+async function runSkillsInstallCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getSkillsInstallCommandHelpText());
+        return 0;
+    }
+    let reporter = null;
+    let progress = null;
+    try {
+        let options = parseSkillsInstallCommandArgs(argv);
+        reporter = createCommandReporter({ remixVersion: context.remixVersion });
+        progress = createSkillsProgressReporter(reporter);
+        let cwd = context.cwd;
+        await reporter.status.commandHeader('skills install');
+        let result = await installRemixSkills(cwd, globalThis.fetch, {
+            progress,
+            skillsDir: options.dir ?? undefined,
+        });
+        let skillsDir = getDisplayPath(result.skillsDir, cwd);
+        progress.writeSummaryGap();
+        if (result.appliedChanges.length === 0) {
+            reporter.out.line(`No changes. ${skillsDir} is up to date.`);
+            reporter.finish();
+            return 0;
+        }
+        reporter.out.line(`Synced Remix skills into ${skillsDir}:`);
+        reporter.out.bullets(formatAppliedChanges(result.appliedChanges));
+        reporter.finish();
+        return 0;
+    }
+    catch (error) {
+        progress?.writeSummaryGap();
+        process.stderr.write(renderCliError(toCliError(error), {
+            helpText: getSkillsInstallCommandHelpText(process.stderr),
+        }));
+        reporter?.finish();
+        return 1;
+    }
+}
+async function runSkillsListCommand(argv, context) {
+    if (argv.includes('-h') || argv.includes('--help')) {
+        process.stdout.write(getSkillsListCommandHelpText());
+        return 0;
+    }
+    let reporter = null;
+    let progress = null;
+    try {
+        let options = parseSkillsDirArgs(argv, { allowJson: true });
+        let cwd = context.cwd;
+        reporter = options.json ? null : createCommandReporter({ remixVersion: context.remixVersion });
+        if (reporter != null) {
+            progress = createSkillsProgressReporter(reporter);
+            await reporter.status.commandHeader('skills list');
+        }
+        let result = await getSkillsOverview(cwd, globalThis.fetch, {
+            progress: progress ?? undefined,
+            skillsDir: options.dir ?? undefined,
+        });
+        if (options.json) {
+            process.stdout.write(`${JSON.stringify({
+                entries: result.entries,
+                projectRoot: result.projectRoot,
+                skillsDir: result.skillsDir,
+            }, null, 2)}\n`);
+            return 0;
+        }
+        progress?.writeSummaryGap();
+        if (reporter == null) {
+            return 0;
+        }
+        let listReporter = reporter;
+        listReporter.out.line(formatSkillsListSummary(result.entries, getDisplayPath(result.skillsDir, cwd)));
+        listReporter.out.bullets(result.entries.map((entry) => formatSkillListEntry(listReporter, entry)));
+        listReporter.finish();
+        return 0;
+    }
+    catch (error) {
+        progress?.writeSummaryGap();
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getSkillsListCommandHelpText(process.stderr) }));
+        reporter?.finish();
+        return 1;
+    }
+}
+function createSkillsProgressReporter(reporter) {
+    return createStepProgressReporter(reporter.status, SKILLS_PROGRESS_LABELS);
+}
+function formatAppliedChanges(changes) {
+    let showAction = changes.some((change) => change.action !== 'add');
+    return changes.map((change) => showAction ? `${toPastTense(change.action)} ${change.name}` : change.name);
+}
+function formatSkillListEntry(reporter, entry) {
+    if (entry.state === 'installed') {
+        return entry.name;
+    }
+    let tone = entry.state === 'missing' ? 'error' : 'warn';
+    return `${entry.name} ${reporter.out.label(entry.state, '', { tone })}`;
+}
+function formatSkillsListSummary(entries, skillsDir) {
+    let installedCount = entries.filter((entry) => entry.state === 'installed').length;
+    let outdatedCount = entries.filter((entry) => entry.state === 'outdated').length;
+    let missingCount = entries.filter((entry) => entry.state === 'missing').length;
+    let detailParts = [
+        installedCount > 0 ? `${installedCount} installed` : null,
+        outdatedCount > 0 ? `${outdatedCount} outdated` : null,
+        missingCount > 0 ? `${missingCount} missing` : null,
+    ].filter((part) => part != null);
+    let detail = detailParts.length === 0 ? '0 installed' : detailParts.join(', ');
+    return `Checked Remix skills against ${skillsDir}: ${detail}.`;
+}
+function parseSkillsInstallCommandArgs(argv) {
+    let { dir } = parseSkillsDirArgs(argv);
+    return { dir };
+}
+function parseSkillsDirArgs(argv, options = {}) {
+    if (options.allowJson) {
+        let parsed = parseArgs(argv, {
+            dir: { flag: '--dir', type: 'string' },
+            json: { flag: '--json', type: 'boolean' },
+        }, { maxPositionals: 0 });
+        return {
+            dir: parsed.options.dir ?? null,
+            json: parsed.options.json,
+        };
+    }
+    let parsed = parseArgs(argv, {
+        dir: { flag: '--dir', type: 'string' },
+    }, { maxPositionals: 0 });
+    return {
+        dir: parsed.options.dir ?? null,
+        json: false,
+    };
+}
+function toPastTense(action) {
+    return action === 'add' ? 'added' : 'replaced';
+}

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): 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":"AAGA,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,CAczF;AAED,wBAAgB,sBAAsB,CAAC,MAAM,GAAE,MAAM,CAAC,WAA4B,GAAG,MAAM,CAE1F"}

package/dist/lib/commands/test.js

@@ -0,0 +1,19 @@
+import { getRemixTestHelpText, runRemixTest } from '@remix-run/test/cli';
+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(`${getTestCommandHelpText()}\n`);
+        return 0;
+    }
+    try {
+        return await runRemixTest({ argv, cwd: context.cwd });
+    }
+    catch (error) {
+        process.stderr.write(renderCliError(toCliError(error), { helpText: getTestCommandHelpText(process.stderr) }));
+        return 1;
+    }
+}
+export function getTestCommandHelpText(target = process.stdout) {
+    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;AAuBlD,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"}