@remix-run/cli 0.0.0 → 0.2.0

package/dist/lib/completion.js

@@ -0,0 +1,310 @@
+const COMPLETION_SHELLS = ['bash', 'zsh'];
+const HELP_COMMANDS = ['completion', 'doctor', 'help', 'new', 'routes', 'test', 'version'];
+const ROOT_COMMANDS = ['completion', 'doctor', 'help', 'new', 'routes', 'test', 'version'];
+export function isCompletionShell(value) {
+    return COMPLETION_SHELLS.includes(value);
+}
+export function getCompletionResult(words, currentIndex) {
+    let resolvedIndex = Math.max(0, currentIndex);
+    let currentWord = words[resolvedIndex] ?? '';
+    let tokens = getTokensBeforeCursor(words, resolvedIndex);
+    return completeTopLevel(tokens, currentWord);
+}
+export function renderCompletionResult(result) {
+    let lines = [`mode:${result.mode}`];
+    if (result.mode === 'values') {
+        lines.push(...(result.values ?? []));
+    }
+    return `${lines.join('\n')}\n`;
+}
+export function getCompletionScript() {
+    return `###-begin-remix-completion-###
+#
+# Remix command completion script
+#
+# Installation:
+#   remix completion bash >> ~/.bashrc
+#   remix completion zsh >> ~/.zshrc
+#
+
+if type complete &>/dev/null; then
+  _remix_completion() {
+    local words cword current output mode si
+    local lines
+
+    if type _get_comp_words_by_ref &>/dev/null; then
+      _get_comp_words_by_ref -w words -i cword
+    else
+      cword="$COMP_CWORD"
+      words=("\${COMP_WORDS[@]}")
+    fi
+
+    current="\${words[cword]}"
+    output=$(remix completion -- "$cword" "\${words[@]}" 2>/dev/null) || return 0
+    si="$IFS"
+    IFS=$'\\n' lines=($output)
+    IFS="$si"
+    mode="\${lines[0]}"
+
+    if [[ "$mode" == "mode:values" ]]; then
+      COMPREPLY=("\${lines[@]:1}")
+      return 0
+    fi
+
+    if [[ "$mode" == "mode:files" ]]; then
+      COMPREPLY=($(compgen -f -- "$current"))
+      return 0
+    fi
+
+    COMPREPLY=()
+  }
+
+  complete -o default -F _remix_completion remix
+elif type compdef &>/dev/null; then
+  _remix_completion() {
+    local output mode
+    local -a lines values
+
+    output=$(remix completion -- "$((CURRENT - 1))" "\${words[@]}" 2>/dev/null) || return 0
+    lines=("\${(@f)output}")
+    mode="\${lines[1]}"
+
+    if [[ "$mode" == "mode:values" ]]; then
+      values=("\${(@)lines[2,-1]}")
+      if (( \${#values[@]} > 0 )); then
+        compadd -- "\${values[@]}"
+      fi
+      return 0
+    fi
+
+    if [[ "$mode" == "mode:files" ]]; then
+      if autoload -U +X _files 2>/dev/null; then
+        _files
+      else
+        compadd -f
+      fi
+      return 0
+    fi
+
+    return 0
+  }
+
+  compdef _remix_completion remix
+fi
+###-end-remix-completion-###
+`;
+}
+function completeTopLevel(tokens, currentWord) {
+    let usedFlags = new Set();
+    let index = 0;
+    while (index < tokens.length) {
+        let token = tokens[index];
+        if (token === '--no-color') {
+            usedFlags.add('--no-color');
+            index++;
+            continue;
+        }
+        if (token === '-h' || token === '--help') {
+            usedFlags.add('-h');
+            return completeValues([], currentWord);
+        }
+        if (token === '-v' || token === '--version') {
+            usedFlags.add('-v');
+            return completeValues([], currentWord);
+        }
+        return completeCommand(token, tokens.slice(index + 1), currentWord, usedFlags);
+    }
+    return completeValues(getTopLevelSuggestions(currentWord, usedFlags), currentWord);
+}
+function completeCommand(command, tokens, currentWord, usedGlobalFlags) {
+    if (command === 'help') {
+        return completeHelp(tokens, currentWord, usedGlobalFlags);
+    }
+    if (command === 'new') {
+        return completeNew(tokens, currentWord, usedGlobalFlags);
+    }
+    if (command === 'doctor') {
+        return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, [
+            '--fix',
+            '--json',
+            '--strict',
+        ]);
+    }
+    if (command === 'routes') {
+        return completeRoutes(tokens, currentWord, usedGlobalFlags);
+    }
+    if (command === 'version') {
+        return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, []);
+    }
+    if (command === 'test') {
+        return completeSimpleFlags(tokens, currentWord, usedGlobalFlags, [
+            '--coverage',
+            '--watch',
+            '--help',
+        ]);
+    }
+    if (command === 'completion') {
+        return completeCompletionCommand(tokens, currentWord, usedGlobalFlags);
+    }
+    return completeValues([], currentWord);
+}
+function completeHelp(tokens, currentWord, usedGlobalFlags) {
+    let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags);
+    if (filteredTokens == null) {
+        return completeValues([], currentWord);
+    }
+    if (filteredTokens.length === 0) {
+        return completeValues(withHelpFlags([...HELP_COMMANDS], usedGlobalFlags), currentWord);
+    }
+    let [, ...rest] = filteredTokens;
+    if (rest.length === 0) {
+        return completeValues([], currentWord);
+    }
+    return completeValues([], currentWord);
+}
+function completeNew(tokens, currentWord, usedGlobalFlags) {
+    let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags);
+    if (filteredTokens == null) {
+        return completeValues([], currentWord);
+    }
+    let hasAppName = false;
+    let hasForce = false;
+    let hasTargetDir = false;
+    let expectsAppName = false;
+    for (let token of filteredTokens) {
+        if (expectsAppName) {
+            expectsAppName = false;
+            continue;
+        }
+        if (token === '--app-name') {
+            hasAppName = true;
+            expectsAppName = true;
+            continue;
+        }
+        if (token === '--force') {
+            hasForce = true;
+            continue;
+        }
+        if (token.startsWith('-')) {
+            return completeValues([], currentWord);
+        }
+        if (!hasTargetDir) {
+            hasTargetDir = true;
+            continue;
+        }
+        return completeValues([], currentWord);
+    }
+    if (expectsAppName) {
+        return { mode: 'none' };
+    }
+    let flags = withHelpFlags([...(!hasAppName ? ['--app-name'] : []), ...(!hasForce ? ['--force'] : [])], usedGlobalFlags);
+    if (!hasTargetDir && !currentWord.startsWith('-')) {
+        return { mode: 'files' };
+    }
+    return completeValues(flags, currentWord);
+}
+function completeRoutes(tokens, currentWord, usedGlobalFlags) {
+    let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags);
+    if (filteredTokens == null) {
+        return completeValues([], currentWord);
+    }
+    let hasJson = false;
+    let hasNoHeaders = false;
+    let hasTable = false;
+    let hasVerbose = false;
+    for (let token of filteredTokens) {
+        if (token === '--json') {
+            hasJson = true;
+            continue;
+        }
+        if (token === '--table') {
+            hasTable = true;
+            continue;
+        }
+        if (token === '--no-headers') {
+            hasNoHeaders = true;
+            continue;
+        }
+        if (token === '--verbose') {
+            hasVerbose = true;
+            continue;
+        }
+        return completeValues([], currentWord);
+    }
+    let flags = withHelpFlags([
+        ...(!hasJson && !hasTable && !hasVerbose ? ['--json'] : []),
+        ...(!hasTable && !hasJson ? ['--table'] : []),
+        ...(!hasNoHeaders && hasTable ? ['--no-headers'] : []),
+        ...(!hasVerbose && !hasJson ? ['--verbose'] : []),
+    ], usedGlobalFlags);
+    return completeValues(flags, currentWord);
+}
+function completeCompletionCommand(tokens, currentWord, usedGlobalFlags) {
+    let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags);
+    if (filteredTokens == null) {
+        return completeValues([], currentWord);
+    }
+    if (filteredTokens.length === 0) {
+        return completeValues(withHelpFlags([...COMPLETION_SHELLS], usedGlobalFlags), currentWord);
+    }
+    return completeValues([], currentWord);
+}
+function completeSimpleFlags(tokens, currentWord, usedGlobalFlags, commandFlags) {
+    let filteredTokens = filterGlobalCommandTokens(tokens, usedGlobalFlags);
+    if (filteredTokens == null) {
+        return completeValues([], currentWord);
+    }
+    let usedFlags = new Set();
+    for (let token of filteredTokens) {
+        if (!commandFlags.includes(token)) {
+            return completeValues([], currentWord);
+        }
+        usedFlags.add(token);
+    }
+    let availableFlags = commandFlags.filter((flag) => !usedFlags.has(flag));
+    return completeValues(withHelpFlags(availableFlags, usedGlobalFlags), currentWord);
+}
+function getTopLevelSuggestions(currentWord, usedFlags) {
+    let flags = [
+        ...(!usedFlags.has('-h') ? ['-h', '--help'] : []),
+        ...(!usedFlags.has('--no-color') ? ['--no-color'] : []),
+        ...(!usedFlags.has('-v') ? ['-v', '--version'] : []),
+    ];
+    if (currentWord.startsWith('-')) {
+        return flags;
+    }
+    return [...ROOT_COMMANDS, ...flags];
+}
+function withHelpFlags(values, usedGlobalFlags) {
+    return [
+        ...values,
+        ...(!usedGlobalFlags.has('-h') ? ['-h', '--help'] : []),
+        ...(!usedGlobalFlags.has('--no-color') ? ['--no-color'] : []),
+    ];
+}
+function filterGlobalCommandTokens(tokens, usedGlobalFlags) {
+    let filtered = [];
+    for (let token of tokens) {
+        if (token === '--no-color') {
+            usedGlobalFlags.add('--no-color');
+            continue;
+        }
+        if (token === '-h' || token === '--help') {
+            usedGlobalFlags.add('-h');
+            return null;
+        }
+        filtered.push(token);
+    }
+    return filtered;
+}
+function completeValues(values, currentWord) {
+    return {
+        mode: 'values',
+        values: values.filter((value) => value.startsWith(currentWord)),
+    };
+}
+function getTokensBeforeCursor(words, currentIndex) {
+    let startIndex = words[0] === 'remix' ? 1 : 0;
+    let endIndex = Math.max(startIndex, Math.min(currentIndex, words.length));
+    return words.slice(startIndex, endIndex);
+}

package/dist/lib/contained-path.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveContainedPath(rootDir: string, relativePath: string): string;
+//# sourceMappingURL=contained-path.d.ts.map

package/dist/lib/contained-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"contained-path.d.ts","sourceRoot":"","sources":["../../src/lib/contained-path.ts"],"names":[],"mappings":"AAEA,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,GAAG,MAAM,CAUlF"}

package/dist/lib/contained-path.js

@@ -0,0 +1,10 @@
+import * as path from 'node:path';
+export function resolveContainedPath(rootDir, relativePath) {
+    let resolvedRootDir = path.resolve(rootDir);
+    let resolvedPath = path.resolve(resolvedRootDir, relativePath);
+    let pathFromRoot = path.relative(resolvedRootDir, resolvedPath);
+    if (pathFromRoot === '' || (!pathFromRoot.startsWith('..') && !path.isAbsolute(pathFromRoot))) {
+        return resolvedPath;
+    }
+    throw new Error(`Resolved path escapes the allowed root: ${relativePath}`);
+}

package/dist/lib/controller-files.d.ts

@@ -0,0 +1,14 @@
+declare const OWNER_FILE_EXTENSIONS: readonly [".ts", ".tsx", ".js", ".jsx"];
+export type OwnerFileExtension = (typeof OWNER_FILE_EXTENSIONS)[number];
+export declare function getActionOwnerCandidates(segments: string[]): string[];
+export declare function getControllerOwnerCandidates(segments: string[]): string[];
+export declare function getRouteSubtreePath(segments: string[]): string;
+export declare function getPreferredOwnerDisplayPath(candidates: string[]): string;
+export declare function getOwnerCandidateForExtension(candidates: string[], extension: OwnerFileExtension): string | null;
+export declare function getOwnerFileExtension(filePath: string): OwnerFileExtension | null;
+export declare function toDiskSegment(segment: string): string;
+export declare function isControllerEntryFileName(fileName: string): boolean;
+export declare function getOwnerModuleBaseName(fileName: string): string | null;
+export declare function isActionFileName(fileName: string): boolean;
+export {};
+//# sourceMappingURL=controller-files.d.ts.map

package/dist/lib/controller-files.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-files.d.ts","sourceRoot":"","sources":["../../src/lib/controller-files.ts"],"names":[],"mappings":"AAEA,QAAA,MAAM,qBAAqB,yCAA0C,CAAA;AACrE,MAAM,MAAM,kBAAkB,GAAG,CAAC,OAAO,qBAAqB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEvE,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAIrE;AAED,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,CAIzE;AAED,wBAAgB,mBAAmB,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,MAAM,CAE9D;AAED,wBAAgB,4BAA4B,CAAC,UAAU,EAAE,MAAM,EAAE,GAAG,MAAM,CAGzE;AAED,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,MAAM,EAAE,EACpB,SAAS,EAAE,kBAAkB,GAC5B,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,GAAG,kBAAkB,GAAG,IAAI,CAEjF;AAED,wBAAgB,aAAa,CAAC,OAAO,EAAE,MAAM,GAAG,MAAM,CAYrD;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAEnE;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQtE;AAED,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAS1D"}

package/dist/lib/controller-files.js

@@ -0,0 +1,53 @@
+import * as path from 'node:path';
+const OWNER_FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx'];
+export function getActionOwnerCandidates(segments) {
+    return OWNER_FILE_EXTENSIONS.map((extension) => normalizeRelativePath(path.join('app', 'controllers', `${path.join(...segments)}${extension}`)));
+}
+export function getControllerOwnerCandidates(segments) {
+    return OWNER_FILE_EXTENSIONS.map((extension) => normalizeRelativePath(path.join('app', 'controllers', ...segments, `controller${extension}`)));
+}
+export function getRouteSubtreePath(segments) {
+    return normalizeRelativePath(path.join('app', 'controllers', ...segments));
+}
+export function getPreferredOwnerDisplayPath(candidates) {
+    let tsxCandidate = candidates.find((candidate) => candidate.endsWith('.tsx'));
+    return tsxCandidate ?? candidates[0] ?? '';
+}
+export function getOwnerCandidateForExtension(candidates, extension) {
+    return candidates.find((candidate) => candidate.endsWith(extension)) ?? null;
+}
+export function getOwnerFileExtension(filePath) {
+    return OWNER_FILE_EXTENSIONS.find((extension) => filePath.endsWith(extension)) ?? null;
+}
+export function toDiskSegment(segment) {
+    let diskSegment = segment
+        .replace(/[\\/]+/g, '-')
+        .replace(/\.+/g, '-')
+        .replace(/([a-z0-9])([A-Z])/g, '$1-$2')
+        .replace(/([A-Z])([A-Z][a-z])/g, '$1-$2')
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/-+/g, '-')
+        .replace(/^-+|-+$/g, '');
+    return diskSegment.length === 0 ? 'route' : diskSegment;
+}
+export function isControllerEntryFileName(fileName) {
+    return OWNER_FILE_EXTENSIONS.some((extension) => fileName === `controller${extension}`);
+}
+export function getOwnerModuleBaseName(fileName) {
+    let extension = OWNER_FILE_EXTENSIONS.find((ownerExtension) => fileName.endsWith(ownerExtension));
+    if (extension == null) {
+        return null;
+    }
+    return fileName.slice(0, -extension.length);
+}
+export function isActionFileName(fileName) {
+    let baseName = getOwnerModuleBaseName(fileName);
+    return (baseName != null &&
+        baseName !== 'controller' &&
+        !baseName.endsWith('.test') &&
+        !baseName.endsWith('.spec'));
+}
+function normalizeRelativePath(filePath) {
+    return filePath.split(path.sep).join('/');
+}

package/dist/lib/controller-ownership.d.ts

@@ -0,0 +1,41 @@
+import type { RouteOwnerKind, RouteTreeNodeKind } from './route-map.ts';
+export interface OwnershipRouteNode {
+    children: OwnershipRouteNode[];
+    key: string;
+    kind: RouteTreeNodeKind;
+    method?: string;
+    name: string;
+}
+export interface ControllerDirectoryScan {
+    actionEntryPaths: Set<string>;
+    controllerEntryPaths: Set<string>;
+    rootDirectoryPaths: Set<string>;
+    routeLocalFilePaths: Set<string>;
+}
+export interface OwnedSubtreePlan {
+    alternateCandidates: string[];
+    alternateDisplayPath: string;
+    entryCandidates: string[];
+    entryDisplayPath: string;
+    kind: RouteOwnerKind;
+    routeName: string;
+    subtreePath: string;
+}
+export interface OwnedSubtree extends OwnedSubtreePlan {
+    actualAlternatePath: string | null;
+    actualAlternatePaths: string[];
+    actualEntryPath: string | null;
+    actualEntryPaths: string[];
+    claimedFilePaths: string[];
+    claimedRouteLocalFilePaths: string[];
+}
+export interface ControllerOwnership {
+    orphanActionPaths: string[];
+    orphanControllerPaths: string[];
+    orphanRouteDirectoryPaths: string[];
+    scan: ControllerDirectoryScan;
+    subtrees: OwnedSubtree[];
+}
+export declare function inspectControllerOwnership(appRoot: string, tree: OwnershipRouteNode[]): Promise<ControllerOwnership>;
+export declare function buildOwnedSubtrees(tree: OwnershipRouteNode[], parentSegments?: string[], subtrees?: OwnedSubtreePlan[]): OwnedSubtreePlan[];
+//# sourceMappingURL=controller-ownership.d.ts.map

package/dist/lib/controller-ownership.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"controller-ownership.d.ts","sourceRoot":"","sources":["../../src/lib/controller-ownership.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAE,cAAc,EAAE,iBAAiB,EAAE,MAAM,gBAAgB,CAAA;AAEvE,MAAM,WAAW,kBAAkB;IACjC,QAAQ,EAAE,kBAAkB,EAAE,CAAA;IAC9B,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,iBAAiB,CAAA;IACvB,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,uBAAuB;IACtC,gBAAgB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC7B,oBAAoB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IACjC,kBAAkB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;IAC/B,mBAAmB,EAAE,GAAG,CAAC,MAAM,CAAC,CAAA;CACjC;AAED,MAAM,WAAW,gBAAgB;IAC/B,mBAAmB,EAAE,MAAM,EAAE,CAAA;IAC7B,oBAAoB,EAAE,MAAM,CAAA;IAC5B,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,gBAAgB,EAAE,MAAM,CAAA;IACxB,IAAI,EAAE,cAAc,CAAA;IACpB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB;AAED,MAAM,WAAW,YAAa,SAAQ,gBAAgB;IACpD,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAA;IAClC,oBAAoB,EAAE,MAAM,EAAE,CAAA;IAC9B,eAAe,EAAE,MAAM,GAAG,IAAI,CAAA;IAC9B,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,gBAAgB,EAAE,MAAM,EAAE,CAAA;IAC1B,0BAA0B,EAAE,MAAM,EAAE,CAAA;CACrC;AAED,MAAM,WAAW,mBAAmB;IAClC,iBAAiB,EAAE,MAAM,EAAE,CAAA;IAC3B,qBAAqB,EAAE,MAAM,EAAE,CAAA;IAC/B,yBAAyB,EAAE,MAAM,EAAE,CAAA;IACnC,IAAI,EAAE,uBAAuB,CAAA;IAC7B,QAAQ,EAAE,YAAY,EAAE,CAAA;CACzB;AAED,wBAAsB,0BAA0B,CAC9C,OAAO,EAAE,MAAM,EACf,IAAI,EAAE,kBAAkB,EAAE,GACzB,OAAO,CAAC,mBAAmB,CAAC,CAY9B;AAED,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,kBAAkB,EAAE,EAC1B,cAAc,GAAE,MAAM,EAAO,EAC7B,QAAQ,GAAE,gBAAgB,EAAO,GAChC,gBAAgB,EAAE,CAwCpB"}

package/dist/lib/controller-ownership.js

@@ -0,0 +1,224 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { getActionOwnerCandidates, getControllerOwnerCandidates, getOwnerModuleBaseName, getPreferredOwnerDisplayPath, getRouteSubtreePath, isActionFileName, isControllerEntryFileName, toDiskSegment, } from "./controller-files.js";
+export async function inspectControllerOwnership(appRoot, tree) {
+    let subtreePlans = buildOwnedSubtrees(tree);
+    let scan = await scanControllersDirectory(appRoot);
+    let subtrees = applyScanToSubtrees(subtreePlans, scan);
+    return {
+        orphanActionPaths: getOrphanActionPaths(subtreePlans, scan),
+        orphanControllerPaths: getOrphanControllerPaths(subtreePlans, scan),
+        orphanRouteDirectoryPaths: getOrphanRouteDirectoryPaths(subtreePlans, scan),
+        scan,
+        subtrees,
+    };
+}
+export function buildOwnedSubtrees(tree, parentSegments = [], subtrees = []) {
+    for (let node of tree) {
+        let segments = [...parentSegments, toDiskSegment(node.key)];
+        if (node.kind === 'group') {
+            let alternateCandidates = getActionOwnerCandidates(segments);
+            let entryCandidates = getControllerOwnerCandidates(segments);
+            subtrees.push({
+                alternateCandidates,
+                alternateDisplayPath: getPreferredOwnerDisplayPath(alternateCandidates),
+                entryCandidates,
+                entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
+                kind: 'controller',
+                routeName: node.name,
+                subtreePath: getRouteSubtreePath(segments),
+            });
+            buildOwnedSubtrees(node.children, segments, subtrees);
+            continue;
+        }
+        if (parentSegments.length > 0) {
+            continue;
+        }
+        let alternateCandidates = getControllerOwnerCandidates(segments);
+        let entryCandidates = getActionOwnerCandidates(segments);
+        subtrees.push({
+            alternateCandidates,
+            alternateDisplayPath: getPreferredOwnerDisplayPath(alternateCandidates),
+            entryCandidates,
+            entryDisplayPath: getPreferredOwnerDisplayPath(entryCandidates),
+            kind: 'action',
+            routeName: node.name,
+            subtreePath: getRouteSubtreePath(segments),
+        });
+    }
+    return subtrees;
+}
+async function scanControllersDirectory(appRoot) {
+    let controllersDir = path.join(appRoot, 'app', 'controllers');
+    let controllerEntryPaths = new Set();
+    let actionEntryPaths = new Set();
+    let rootDirectoryPaths = new Set();
+    let routeLocalFilePaths = new Set();
+    async function walk(currentDir, isRoot) {
+        let entries;
+        try {
+            entries = await fs.readdir(currentDir, { withFileTypes: true });
+        }
+        catch (error) {
+            let nodeError = error;
+            if (nodeError.code === 'ENOENT' && isRoot) {
+                return;
+            }
+            throw error;
+        }
+        for (let entry of entries) {
+            let entryPath = path.join(currentDir, entry.name);
+            let relativePath = normalizeRelativePath(path.relative(appRoot, entryPath));
+            if (entry.isDirectory()) {
+                if (isRoot) {
+                    rootDirectoryPaths.add(relativePath);
+                }
+                await walk(entryPath, false);
+                continue;
+            }
+            if (!entry.isFile()) {
+                continue;
+            }
+            if (isControllerEntryFileName(entry.name)) {
+                controllerEntryPaths.add(relativePath);
+                continue;
+            }
+            if (isRoot && isActionCandidate(entry.name)) {
+                actionEntryPaths.add(relativePath);
+                continue;
+            }
+            if (!isRoot && isRouteLocalFileName(entry.name)) {
+                routeLocalFilePaths.add(relativePath);
+            }
+        }
+    }
+    await walk(controllersDir, true);
+    return {
+        actionEntryPaths,
+        controllerEntryPaths,
+        rootDirectoryPaths,
+        routeLocalFilePaths,
+    };
+}
+function applyScanToSubtrees(subtreePlans, scan) {
+    let claimedRouteLocalPaths = claimFilesToDeepestSubtree([...scan.routeLocalFilePaths], subtreePlans);
+    let claimedContentPaths = claimFilesToDeepestSubtree(getNestedContentPaths(scan), subtreePlans);
+    return subtreePlans.map((subtree) => {
+        let actualAlternatePaths = findOwnerPaths(scan, invertOwnerKind(subtree.kind), subtree.alternateCandidates);
+        let actualEntryPaths = findOwnerPaths(scan, subtree.kind, subtree.entryCandidates);
+        return {
+            ...subtree,
+            actualAlternatePath: actualAlternatePaths[0] ?? null,
+            actualAlternatePaths,
+            actualEntryPath: actualEntryPaths[0] ?? null,
+            actualEntryPaths,
+            claimedFilePaths: claimedContentPaths.get(subtree.routeName) ?? [],
+            claimedRouteLocalFilePaths: claimedRouteLocalPaths.get(subtree.routeName) ?? [],
+        };
+    });
+}
+function getNestedContentPaths(scan) {
+    let nestedControllerPaths = [...scan.controllerEntryPaths].filter((filePath) => isNestedControllerPath(filePath));
+    return [...new Set([...nestedControllerPaths, ...scan.routeLocalFilePaths])].sort();
+}
+function claimFilesToDeepestSubtree(filePaths, subtreePlans) {
+    let subtreesByDepth = [...subtreePlans].sort((left, right) => {
+        if (right.subtreePath.length !== left.subtreePath.length) {
+            return right.subtreePath.length - left.subtreePath.length;
+        }
+        return left.routeName.localeCompare(right.routeName);
+    });
+    let claims = new Map();
+    for (let filePath of filePaths.sort()) {
+        let matchingSubtree = subtreesByDepth.find((subtree) => isWithinDirectory(filePath, subtree.subtreePath));
+        if (matchingSubtree == null) {
+            continue;
+        }
+        let claimedPaths = claims.get(matchingSubtree.routeName);
+        if (claimedPaths == null) {
+            claims.set(matchingSubtree.routeName, [filePath]);
+            continue;
+        }
+        claimedPaths.push(filePath);
+    }
+    return claims;
+}
+function getOrphanActionPaths(subtreePlans, scan) {
+    let expectedActionPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'action')
+        .flatMap((subtree) => subtree.entryCandidates));
+    let alternateActionPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'controller')
+        .flatMap((subtree) => subtree.alternateCandidates));
+    return [...scan.actionEntryPaths]
+        .filter((filePath) => !expectedActionPaths.has(filePath))
+        .filter((filePath) => !alternateActionPaths.has(filePath))
+        .sort();
+}
+function getOrphanControllerPaths(subtreePlans, scan) {
+    let expectedControllerPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'controller')
+        .flatMap((subtree) => subtree.entryCandidates));
+    let alternateControllerPaths = new Set(subtreePlans
+        .filter((subtree) => subtree.kind === 'action')
+        .flatMap((subtree) => subtree.alternateCandidates));
+    return [...scan.controllerEntryPaths]
+        .filter((filePath) => !expectedControllerPaths.has(filePath))
+        .filter((filePath) => !alternateControllerPaths.has(filePath))
+        .sort();
+}
+function getOrphanRouteDirectoryPaths(subtreePlans, scan) {
+    let expectedRootDirectories = new Set(subtreePlans.map((subtree) => getTopLevelSubtreePath(subtree.subtreePath)));
+    let actualControllerDirectories = [...scan.controllerEntryPaths].map((controllerPath) => normalizeRelativePath(path.dirname(controllerPath)));
+    return [...scan.rootDirectoryPaths]
+        .filter((directoryPath) => !expectedRootDirectories.has(directoryPath))
+        .filter((directoryPath) => !actualControllerDirectories.some((controllerPath) => isDirectoryWithinDirectory(controllerPath, directoryPath)))
+        .sort();
+}
+function hasOwnerPath(scan, kind, filePath) {
+    return kind === 'action'
+        ? scan.actionEntryPaths.has(filePath)
+        : scan.controllerEntryPaths.has(filePath);
+}
+function invertOwnerKind(kind) {
+    return kind === 'action' ? 'controller' : 'action';
+}
+function isActionCandidate(fileName) {
+    return isActionFileName(fileName);
+}
+function isRouteLocalFileName(fileName) {
+    let baseName = getOwnerModuleBaseName(fileName);
+    return (baseName != null &&
+        baseName !== 'controller' &&
+        !baseName.endsWith('.test') &&
+        !baseName.endsWith('.spec'));
+}
+function findOwnerPath(scan, kind, candidatePaths) {
+    return findOwnerPaths(scan, kind, candidatePaths)[0] ?? null;
+}
+function findOwnerPaths(scan, kind, candidatePaths) {
+    let existingPaths = [];
+    for (let candidatePath of candidatePaths) {
+        if (hasOwnerPath(scan, kind, candidatePath)) {
+            existingPaths.push(candidatePath);
+        }
+    }
+    return existingPaths;
+}
+function isNestedControllerPath(filePath) {
+    return (filePath.startsWith('app/controllers/') &&
+        filePath.slice('app/controllers/'.length).includes('/'));
+}
+function isWithinDirectory(filePath, directoryPath) {
+    return filePath.startsWith(`${directoryPath}/`);
+}
+function isDirectoryWithinDirectory(directoryPath, parentDirectoryPath) {
+    return (directoryPath === parentDirectoryPath || isWithinDirectory(directoryPath, parentDirectoryPath));
+}
+function getTopLevelSubtreePath(subtreePath) {
+    let subtreeSegments = subtreePath.slice('app/controllers/'.length).split('/');
+    return getRouteSubtreePath([subtreeSegments[0]]);
+}
+function normalizeRelativePath(filePath) {
+    return filePath.split(path.sep).join('/');
+}

package/dist/lib/display-path.d.ts

@@ -0,0 +1,2 @@
+export declare function getDisplayPath(filePath: string, cwd?: string): string;
+//# sourceMappingURL=display-path.d.ts.map

package/dist/lib/display-path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"display-path.d.ts","sourceRoot":"","sources":["../../src/lib/display-path.ts"],"names":[],"mappings":"AAGA,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,GAAG,GAAE,MAAsB,GAAG,MAAM,CAYpF"}