proteum 2.1.0 → 2.1.2

package/cli/compiler/client/index.ts

@@ -27,6 +27,24 @@ const hmrClientEntry = path.join(cli.paths.core.root, 'client', 'dev', 'hmr.ts')
 const normalizeModulePath = (value?: string) => (value || '').replace(/\\/g, '/');
 const resolveFromAppOrCore = (app: App, request: string) =>
     require.resolve(request, { paths: [app.paths.root, cli.paths.core.root] });
+const rewriteFrameworkAliasTargets = (app: App, aliases: Record<string, string | string[]>) => {
+    const installedCoreRoot = normalizeModulePath(path.join(app.paths.root, 'node_modules', 'proteum'));
+    const activeCoreRoot = normalizeModulePath(cli.paths.core.root);
+
+    if (installedCoreRoot === activeCoreRoot) return aliases;
+
+    const rewriteCandidate = (candidate: string) =>
+        normalizeModulePath(candidate).startsWith(installedCoreRoot + '/')
+            ? activeCoreRoot + normalizeModulePath(candidate).substring(installedCoreRoot.length)
+            : candidate;
+
+    return Object.fromEntries(
+        Object.entries(aliases).map(([alias, value]) => [
+            alias,
+            Array.isArray(value) ? value.map(rewriteCandidate) : rewriteCandidate(value),
+        ]),
+    );
+};
 
 const getModulePath = (module: Module) => {
     const resource = typeof module.nameForCondition === 'function' ? module.nameForCondition() : undefined;
@@ -58,6 +76,8 @@ export default function createCompiler(
     logVerbose(`Creating compiler for client (${mode}).`);
     const dev = mode === 'dev';
     const outputPath = app.outputPath(outputTarget);
+    const installedCoreRoot = path.join(app.paths.root, 'node_modules', 'proteum');
+    const frameworkRoots = [cli.paths.core.root, installedCoreRoot];
 
     const commonConfig = createCommonConfig(app, 'client', mode, outputTarget);
 
@@ -73,11 +93,12 @@ export default function createCompiler(
 
     // Convert tsconfig paths into bundler aliases.
     const { aliases } = app.aliases.client.forWebpack({ modulesPath: app.paths.root + '/node_modules' });
+    const resolvedAliases = rewriteFrameworkAliasTargets(app, aliases);
 
     // We're not supposed in any case to import server libs from client
-    delete aliases['@server'];
-    delete aliases['@/server'];
-    const rspackAliases = toRspackAliases(aliases);
+    delete resolvedAliases['@server'];
+    delete resolvedAliases['@/server'];
+    const rspackAliases = toRspackAliases(resolvedAliases);
     rspackAliases['@/client/router$'] = cli.paths.core.root + '/client/router.ts';
     rspackAliases['preact/jsx-runtime$'] = resolveFromAppOrCore(app, 'preact/jsx-runtime');
     rspackAliases['react/jsx-runtime$'] = resolveFromAppOrCore(app, 'preact/jsx-runtime');
@@ -133,16 +154,16 @@ export default function createCompiler(
                     test: ssrScriptPattern,
                     include: [
                         app.paths.root + '/client',
-                        cli.paths.core.root + '/client',
                         app.paths.client.generated,
 
                         app.paths.root + '/common',
-                        cli.paths.core.root + '/common',
                         app.paths.common.generated,
 
                         app.paths.root + '/server',
-                        cli.paths.core.root + '/server',
                         app.paths.server.generated,
+                        ...frameworkRoots.map((rootPath) => rootPath + '/client'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/common'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/server'),
                     ],
                     loader: path.join(
                         cli.paths.core.root,
@@ -157,17 +178,18 @@ export default function createCompiler(
                     test: regex.scripts,
                     include: [
                         app.paths.root + '/client',
-                        cli.paths.core.root + '/client',
                         app.paths.client.generated,
 
                         app.paths.root + '/common',
-                        cli.paths.core.root + '/common',
                         app.paths.common.generated,
 
                         // Prisma 7 generates browser-safe TypeScript entrypoints under var/prisma.
                         app.paths.root + '/var/prisma',
 
                         app.paths.server.generated + '/models.ts',
+                        ...frameworkRoots.map((rootPath) => rootPath + '/client'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/common'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/server'),
                     ],
                     rules: require('../common/scripts')({ app, side: 'client', dev }),
                 },
@@ -199,6 +221,19 @@ export default function createCompiler(
         plugins: [
             ...(commonConfig.plugins || []),
 
+            ...(dev
+                ? []
+                : [
+                      new rspack.NormalModuleReplacementPlugin(
+                          /^@client\/dev\/profiler$/,
+                          cli.paths.core.root + '/client/dev/profiler/noop.tsx',
+                      ),
+                      new rspack.NormalModuleReplacementPlugin(
+                          /^@client\/dev\/profiler\/runtime$/,
+                          cli.paths.core.root + '/client/dev/profiler/runtime.noop.ts',
+                      ),
+                  ]),
+
             // Extract CSS in dev too so SSR emits the same stylesheet links as production.
             new rspack.CssExtractRspackPlugin({}),
 

package/cli/compiler/common/commands.ts

@@ -0,0 +1,175 @@
+import fs from 'fs-extra';
+import path from 'path';
+import ts from 'typescript';
+
+export type TCommandSourceLocation = { line: number; column: number };
+
+export type TCommandMethodMeta = {
+    name: string;
+    path: string;
+    sourceLocation: TCommandSourceLocation;
+};
+
+export type TCommandFileMeta = {
+    importPath: string;
+    filepath: string;
+    className: string;
+    commandBasePath: string;
+    methods: TCommandMethodMeta[];
+};
+
+type TCommandSearchDir = { importPrefix: string; root: string };
+
+const getCommandSegments = (relativePath: string) => {
+    const segments = relativePath
+        .replace(/\.ts$/, '')
+        .split('/')
+        .filter(Boolean);
+
+    if (segments[segments.length - 1] === 'index') {
+        segments.pop();
+    }
+
+    return segments;
+};
+
+const getCommandBasePathFromFilepath = (filepath: string, root: string) =>
+    getCommandSegments(path.relative(root, filepath).replace(/\\/g, '/')).join('/');
+
+const getGeneratedClassName = (filepath: string) => {
+    const filename = path.basename(filepath, '.ts').replace(/[^A-Za-z0-9_$]+/g, '_');
+    const normalized = filename.length ? filename : 'Commands';
+
+    return normalized[0].toUpperCase() + normalized.substring(1);
+};
+
+const buildImportPath = (searchDir: TCommandSearchDir, filepath: string) =>
+    searchDir.importPrefix + path.relative(searchDir.root, filepath).replace(/\\/g, '/').replace(/\.ts$/, '');
+
+const findCommandFiles = (dir: string): string[] => {
+    if (!fs.existsSync(dir)) return [];
+
+    const files: string[] = [];
+
+    for (const dirent of fs.readdirSync(dir, { withFileTypes: true })) {
+        const filepath = path.join(dir, dirent.name);
+
+        if (dirent.isDirectory()) {
+            files.push(...findCommandFiles(filepath));
+            continue;
+        }
+
+        if (!dirent.isFile()) continue;
+        if (!dirent.name.endsWith('.ts')) continue;
+        if (dirent.name.endsWith('.d.ts')) continue;
+
+        files.push(filepath);
+    }
+
+    return files;
+};
+
+const parseSourceFile = (filepath: string, code: string) =>
+    ts.createSourceFile(
+        filepath,
+        code,
+        ts.ScriptTarget.Latest,
+        true,
+        filepath.endsWith('.tsx') ? ts.ScriptKind.TSX : ts.ScriptKind.TS,
+    );
+
+const getNodeLocation = (sourceFile: ts.SourceFile, node: ts.Node): TCommandSourceLocation => {
+    const { line, character } = sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile));
+
+    return { line: line + 1, column: character + 1 };
+};
+
+const hasModifier = (node: ts.Node, kind: ts.SyntaxKind) =>
+    !!node.modifiers?.some((modifier) => modifier.kind === kind);
+
+const getDefaultExportClass = (sourceFile: ts.SourceFile) => {
+    const classes = new Map<string, ts.ClassDeclaration>();
+
+    for (const statement of sourceFile.statements) {
+        if (ts.isClassDeclaration(statement) && statement.name) {
+            classes.set(statement.name.text, statement);
+
+            if (hasModifier(statement, ts.SyntaxKind.DefaultKeyword)) {
+                return statement;
+            }
+        }
+    }
+
+    for (const statement of sourceFile.statements) {
+        if (!ts.isExportAssignment(statement) || statement.isExportEquals) continue;
+
+        if (ts.isIdentifier(statement.expression)) {
+            return classes.get(statement.expression.text);
+        }
+    }
+
+    return undefined;
+};
+
+const getExportedString = (sourceFile: ts.SourceFile, exportName: string) => {
+    for (const statement of sourceFile.statements) {
+        if (!ts.isVariableStatement(statement)) continue;
+        if (!hasModifier(statement, ts.SyntaxKind.ExportKeyword)) continue;
+
+        for (const declaration of statement.declarationList.declarations) {
+            if (!ts.isIdentifier(declaration.name)) continue;
+            if (declaration.name.text !== exportName) continue;
+            if (!declaration.initializer || !ts.isStringLiteral(declaration.initializer)) continue;
+
+            return declaration.initializer.text;
+        }
+    }
+
+    return undefined;
+};
+
+export const indexCommands = (searchDirs: TCommandSearchDir[]) => {
+    const commands: TCommandFileMeta[] = [];
+
+    for (const searchDir of searchDirs) {
+        const commandFiles = findCommandFiles(searchDir.root);
+
+        for (const filepath of commandFiles.sort((a, b) => a.localeCompare(b))) {
+            const code = fs.readFileSync(filepath, 'utf8');
+            const sourceFile = parseSourceFile(filepath, code);
+
+            const commandPathOverride = getExportedString(sourceFile, 'commandPath');
+            const defaultClass = getDefaultExportClass(sourceFile);
+
+            if (!defaultClass) continue;
+
+            const className = defaultClass.name?.text || getGeneratedClassName(filepath);
+            const commandBasePath = commandPathOverride || getCommandBasePathFromFilepath(filepath, searchDir.root);
+            const methods: TCommandMethodMeta[] = [];
+
+            for (const member of defaultClass.members) {
+                if (!ts.isMethodDeclaration(member)) continue;
+                if (!member.body) continue;
+                if (!member.name || !ts.isIdentifier(member.name)) continue;
+
+                methods.push({
+                    name: member.name.text,
+                    path: [commandBasePath, member.name.text].filter(Boolean).join('/'),
+                    sourceLocation: getNodeLocation(sourceFile, member.name),
+                });
+            }
+
+            if (!methods.length) continue;
+
+            commands.push({
+                filepath,
+                importPath: buildImportPath(searchDir, filepath),
+                className,
+                commandBasePath,
+                methods,
+            });
+        }
+    }
+
+    return commands.sort((a, b) => a.filepath.localeCompare(b.filepath));
+};

package/cli/compiler/common/index.ts

@@ -80,7 +80,7 @@ export default function createCommonConfig(
                 APP_NAME: JSON.stringify(app.identity.web.title),
                 APP_OUTPUT_DIR: JSON.stringify(path.basename(app.outputPath(outputTarget))),
                 PROTEUM_DEV_EVENT_PORT: JSON.stringify(dev ? (app.devEventPort ?? null) : null),
-                PROTEUM_ROUTER_PORT_OVERRIDE: JSON.stringify(app.routerPortOverride ?? null),
+                PROTEUM_PORT_OVERRIDE: JSON.stringify(app.routerPortOverride ?? null),
             }),
 
             ...(dev ? [] : []),

package/cli/compiler/common/proteumManifest.ts

@@ -2,120 +2,21 @@ import path from 'path';
 import fs from 'fs-extra';
 
 import writeIfChanged from '../writeIfChanged';
-
-export type TProteumManifestScope = 'app' | 'framework';
-export type TProteumManifestSourceLocation = { line: number; column: number };
-export type TProteumManifestRouteTargetResolution = 'literal' | 'static-expression' | 'dynamic-expression';
-export type TProteumManifestDiagnosticLevel = 'warning' | 'error';
-
-export type TProteumManifestDiagnostic = {
-    level: TProteumManifestDiagnosticLevel;
-    code: string;
-    message: string;
-    filepath: string;
-    sourceLocation?: TProteumManifestSourceLocation;
-    relatedFilepaths?: string[];
-};
-
-export type TProteumManifestService = {
-    kind: 'service' | 'ref';
-    id?: string;
-    registeredName: string;
-    metaName?: string;
-    parent: string;
-    priority: number;
-    importPath?: string;
-    sourceDir?: string;
-    metasFilepath?: string;
-    refTo?: string;
-    scope: TProteumManifestScope;
-};
-
-export type TProteumManifestController = {
-    className: string;
-    importPath: string;
-    filepath: string;
-    sourceLocation: TProteumManifestSourceLocation;
-    routeBasePath: string;
-    methodName: string;
-    inputCallsCount: number;
-    hasInput: boolean;
-    routePath: string;
-    httpPath: string;
-    clientAccessor: string;
-    scope: TProteumManifestScope;
-};
-
-export type TProteumManifestRoute = {
-    kind: 'client-page' | 'client-error' | 'server-route';
-    methodName: string;
-    serviceLocalName: string;
-    filepath: string;
-    sourceLocation: TProteumManifestSourceLocation;
-    targetResolution: TProteumManifestRouteTargetResolution;
-    path?: string;
-    pathRaw?: string;
-    code?: number;
-    codeRaw?: string;
-    optionKeys: string[];
-    normalizedOptionKeys: string[];
-    invalidOptionKeys: string[];
-    reservedOptionKeys: string[];
-    optionsRaw?: string;
-    hasSetup: boolean;
-    chunkId?: string;
-    chunkFilepath?: string;
-    scope: TProteumManifestScope;
-};
-
-export type TProteumManifestLayout = {
-    chunkId: string;
-    filepath: string;
-    importPath: string;
-    depth: number;
-    scope: TProteumManifestScope;
-};
-
-export type TProteumManifest = {
-    version: 1;
-    app: {
-        root: string;
-        coreRoot: string;
-        identityFilepath: string;
-        identity: {
-            name: string;
-            identifier: string;
-            description: string;
-            language?: string;
-            locale?: string;
-            title?: string;
-            titleSuffix?: string;
-            fullTitle?: string;
-            webDescription?: string;
-            version?: string;
-        };
-    };
-    conventions: {
-        routeSetupOptionKeys: string[];
-        reservedRouteSetupKeys: string[];
-    };
-    env: {
-        sourceFilepath: string;
-        loadedTopLevelKeys: string[];
-        requiredTopLevelKeys: string[];
-    };
-    services: {
-        app: TProteumManifestService[];
-        routerPlugins: TProteumManifestService[];
-    };
-    controllers: TProteumManifestController[];
-    routes: {
-        client: TProteumManifestRoute[];
-        server: TProteumManifestRoute[];
-    };
-    layouts: TProteumManifestLayout[];
-    diagnostics: TProteumManifestDiagnostic[];
-};
+import type { TProteumManifest } from '@common/dev/proteumManifest';
+
+export type {
+    TProteumManifest,
+    TProteumManifestCommand,
+    TProteumManifestController,
+    TProteumManifestDiagnostic,
+    TProteumManifestDiagnosticLevel,
+    TProteumManifestLayout,
+    TProteumManifestRoute,
+    TProteumManifestRouteTargetResolution,
+    TProteumManifestScope,
+    TProteumManifestService,
+    TProteumManifestSourceLocation,
+} from '@common/dev/proteumManifest';
 
 export const getProteumManifestPath = (appRoot: string) => path.join(appRoot, '.proteum', 'manifest.json');
 

package/cli/compiler/index.ts

@@ -16,6 +16,7 @@ import { writeClientManifest } from './common/clientManifest';
 import { logVerbose } from '../runtime/verbose';
 import { createCompileReporter, type TCompileReporter } from '../presentation/compileReporter';
 import { generateRoutingArtifacts } from './artifacts/routing';
+import { generateCommandArtifacts } from './artifacts/commands';
 import { generateControllerArtifacts } from './artifacts/controllers';
 import { generateServiceArtifacts } from './artifacts/services';
 import { writeCurrentProteumManifest } from './artifacts/manifest';
@@ -32,6 +33,7 @@ export default class Compiler {
     public compiling: { [compiler: string]: Promise<void> } = {};
     private recentCompilationResults: { [compiler: string]: TRecentCompilationResult } = {};
     private recentModifiedFiles: { [compiler: string]: string[] } = {};
+    private manualModifiedFiles: { [compiler: string]: Set<string> } = {};
     private refreshingGeneratedArtifacts?: Promise<void>;
     private compileReporter?: TCompileReporter;
 
@@ -140,11 +142,13 @@ export default class Compiler {
             this.refreshingGeneratedArtifacts = (async () => {
                 const services = generateServiceArtifacts();
                 const controllers = generateControllerArtifacts();
+                const commands = generateCommandArtifacts();
                 const { clientRoutes, serverRoutes, layouts } = generateRoutingArtifacts();
 
                 writeCurrentProteumManifest({
                     services,
                     controllers,
+                    commands,
                     routes: { client: clientRoutes, server: serverRoutes },
                     layouts,
                 });
@@ -172,6 +176,21 @@ export default class Compiler {
         return recentCompilationResults;
     }
 
+    public noteManualModifiedFiles(compilerNames: string[] | string, filepaths: string[]) {
+        const normalizedCompilerNames = Array.isArray(compilerNames) ? compilerNames : [compilerNames];
+        const normalizedFilepaths = filepaths.map((filepath) => normalizePath(path.resolve(filepath)));
+
+        for (const compilerName of normalizedCompilerNames) {
+            const pendingFiles = this.manualModifiedFiles[compilerName] || new Set<string>();
+
+            for (const filepath of normalizedFilepaths) {
+                pendingFiles.add(filepath);
+            }
+
+            this.manualModifiedFiles[compilerName] = pendingFiles;
+        }
+    }
+
     public async create() {
         await this.warmupApp();
 
@@ -204,9 +223,13 @@ export default class Compiler {
             compiler.hooks.compile.tap(name, (compilation) => {
                 this.callbacks.before && this.callbacks.before(compiler);
 
-                this.recentModifiedFiles[name] = [...(compiler.modifiedFiles ? [...compiler.modifiedFiles] : [])].map(
-                    (filepath) => normalizePath(path.resolve(filepath)),
+                const compilerModifiedFiles = [...(compiler.modifiedFiles ? [...compiler.modifiedFiles] : [])].map((filepath) =>
+                    normalizePath(path.resolve(filepath)),
                 );
+                const manualModifiedFiles = [...(this.manualModifiedFiles[name] || [])];
+                delete this.manualModifiedFiles[name];
+
+                this.recentModifiedFiles[name] = [...new Set([...compilerModifiedFiles, ...manualModifiedFiles])];
 
                 this.compiling[name] = new Promise((resolve) => (finished = resolve));
 

package/cli/compiler/server/index.ts

@@ -49,6 +49,25 @@ const getDevGeneratedRuntimeEntries = (app: App) => ({
     __proteum_dev_routes: [app.paths.server.generated + '/routes.ts'],
     __proteum_dev_controllers: [app.paths.server.generated + '/controllers.ts'],
 });
+const normalizeModulePath = (value?: string) => (value || '').replace(/\\/g, '/');
+const rewriteFrameworkAliasTargets = (app: App, aliases: Record<string, string | string[]>) => {
+    const installedCoreRoot = normalizeModulePath(app.paths.root + '/node_modules/proteum');
+    const activeCoreRoot = normalizeModulePath(cli.paths.core.root);
+
+    if (installedCoreRoot === activeCoreRoot) return aliases;
+
+    const rewriteCandidate = (candidate: string) =>
+        normalizeModulePath(candidate).startsWith(installedCoreRoot + '/')
+            ? activeCoreRoot + normalizeModulePath(candidate).substring(installedCoreRoot.length)
+            : candidate;
+
+    return Object.fromEntries(
+        Object.entries(aliases).map(([alias, value]) => [
+            alias,
+            Array.isArray(value) ? value.map(rewriteCandidate) : rewriteCandidate(value),
+        ]),
+    );
+};
 
 /*----------------------------------
 - CONFIG
@@ -61,14 +80,17 @@ export default function createCompiler(
     debug && console.info(`Creating compiler for server (${mode}).`);
     const dev = mode === 'dev';
     const outputPath = app.outputPath(outputTarget);
+    const installedCoreRoot = app.paths.root + '/node_modules/proteum';
+    const frameworkRoots = [cli.paths.core.root, installedCoreRoot];
 
     const commonConfig = createCommonConfig(app, 'server', mode, outputTarget);
     const { aliases } = app.aliases.server.forWebpack({ modulesPath: app.paths.root + '/node_modules' });
+    const resolvedAliases = rewriteFrameworkAliasTargets(app, aliases);
 
     // We're not supposed in any case to import client services from server
-    delete aliases['@client/services'];
-    delete aliases['@/client/services'];
-    const rspackAliases = toRspackAliases(aliases);
+    delete resolvedAliases['@client/services'];
+    delete resolvedAliases['@/client/services'];
+    const rspackAliases = toRspackAliases(resolvedAliases);
     rspackAliases['@/client/router$'] = cli.paths.core.root + '/client/router.ts';
 
     debug &&
@@ -154,20 +176,23 @@ export default function createCompiler(
                     test: regex.scripts,
                     include: [
                         app.paths.root + '/client',
-                        cli.paths.core.root + '/client',
                         app.paths.client.generated,
 
                         app.paths.root + '/common',
-                        cli.paths.core.root + '/common',
                         app.paths.common.generated,
 
                         // Prisma 7 generates TypeScript entrypoints under var/prisma.
                         app.paths.root + '/var/prisma',
 
+                        app.paths.root + '/commands',
+
                         // Dossiers server uniquement pour le bundle server
                         app.paths.root + '/server',
-                        cli.paths.core.root + '/server',
                         app.paths.server.generated,
+                        ...frameworkRoots.map((rootPath) => rootPath + '/commands'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/client'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/common'),
+                        ...frameworkRoots.map((rootPath) => rootPath + '/server'),
 
                         // Complle 5HTP modules so they can refer to the framework instance and aliases
                         // Temp disabled because compile issue on vercel

package/cli/index.ts

@@ -1,6 +1,5 @@
 process.traceDeprecation = true;
 
-import fs from 'fs';
 import { Cli } from 'clipanion';
 
 import cli from './context';
@@ -9,12 +8,10 @@ import { renderCliOverview, renderCommandHelp, resolveCustomHelpRequest } from '
 import { normalizeHelpArgv, normalizeLegacyArgv } from './runtime/argv';
 import { createCli, registeredCommands } from './runtime/commands';
 
-const hasInitScaffold = () => fs.existsSync(`${cli.paths.core.cli}/skeleton`);
-
 export const runCli = async (argv: string[] = process.argv.slice(2)) => {
     const normalizedArgv = normalizeHelpArgv(normalizeLegacyArgv(argv), proteumCommandNames);
     const clipanion = createCli(String(cli.packageJson.version || ''));
-    const initAvailable = hasInitScaffold();
+    const initAvailable = true;
     const helpRequest = resolveCustomHelpRequest(normalizedArgv);
 
     if (helpRequest.kind === 'overview') {

package/cli/paths.ts

@@ -43,13 +43,28 @@ export const staticAssetName = /*isDebug ? '[name].[ext].[hash:8]' :*/ '[hash:8]
 
 const pathInfosDefaultOpts = { shortenExtensions: ['ts', 'js', 'tsx', 'jsx'], trimIndex: true };
 
+const safeRealpath = (filepath: string) => {
+    try {
+        return fs.realpathSync(filepath);
+    } catch {
+        return path.resolve(filepath);
+    }
+};
+
 const resolveCoreRoot = (appRoot: string) => {
+    const currentPackageRoot = path.resolve(__dirname, '..');
+    const currentBin = path.join(currentPackageRoot, 'cli', 'bin.js');
+    const invokedScript = process.argv[1] ? safeRealpath(process.argv[1]) : '';
+    const invokedCurrentPackage = invokedScript === safeRealpath(currentBin);
+
+    if (invokedCurrentPackage) return currentPackageRoot;
+
     const localInstall = path.join(appRoot, 'node_modules', 'proteum');
     if (fs.existsSync(localInstall)) return localInstall;
 
     // When running `npx`/global installs, there may be no local `node_modules/proteum` yet.
     // Fall back to the installed package root (this file lives in `<root>/cli`).
-    return path.resolve(__dirname, '..');
+    return currentPackageRoot;
 };
 
 const normalizeImportPath = (value: string) => value.replace(/\\/g, '/');