typescript-plugin-scoped-imports 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,8 @@
+# Changelog
+
+## 0.1.1 - 2026-02-13
+
+- Fix: alias/private scope validation now resolves canonical module paths, preventing false positives with repeated folder names (e.g. `ScopeTrap`).
+- Tests: expanded `tsserver` integration coverage, including alias in-scope completion and repeated-folder-name protection.
+- Compatibility: Node minimum version aligned to `>=20`.
+- CI: matrix coverage for Node `20` and `24`.

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Nicolas Viotti
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,84 @@
+# TypeScript Plugin: Scoped Imports
+
+TypeScript Language Server plugin para controlar auto-imports basado en el scope del archivo.
+
+## Estado actual
+
+Regla validada en esta fase:
+
+- `__private__` es accesible desde su carpeta padre y subdirectorios.
+- Fuera de ese subtree, el plugin bloquea sugerencias y fixes que introduzcan imports privados.
+
+## Instalacion (workspace)
+
+```bash
+pnpm install
+pnpm run build
+```
+
+Requiere Node.js 20 o superior.
+
+## Configuracion
+
+En tu `tsconfig.json`:
+
+```json
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "typescript-plugin-scoped-imports"
+      }
+    ]
+  }
+}
+```
+
+Convencion: el plugin considera privados los paths que contengan la carpeta `__private__`.
+
+## Matriz de validacion
+
+La suite automatizada vive en:
+
+- `packages/typescript-plugin-scoped-imports/__tests__/integration/tsserver.scoped-imports.spec.ts`
+
+| Caso | Esperado | Resultado |
+| --- | --- | --- |
+| Carga del plugin en tsserver | Debe loguear `PLUGIN LOADING` | Automatizado |
+| Path completion out-of-scope (`Home.tsx` + `@/components/gallery/`) | No sugerir `__private__` | Automatizado |
+| Path completion in-scope padre (`ParentComponent.tsx` + `./`) | Sugerir `__private__` | Automatizado |
+| Path completion in-scope descendiente (`silbing/index.tsx` + `../`) | Sugerir `__private__` | Automatizado |
+| Path completion out-of-scope lateral (`UtilsComponent.tsx` + `../gallery/`) | No sugerir `__private__` | Automatizado |
+| CodeFix missing import out-of-scope (`Home.tsx`) | No proponer imports privados | Automatizado |
+| CodeFix missing import in-scope padre (`ParentComponent.tsx`) | Proponer import privado valido | Automatizado |
+| CodeFix missing import in-scope descendiente (`silbing/nephew/index.tsx`) | Proponer import privado valido | Automatizado |
+| Combined fix out-of-scope (`fixMissingImport`) | Sin cambios con `__private__` | Automatizado |
+| Combined fix in-scope (`fixMissingImport`) | Con cambios privados validos | Automatizado |
+| `getCompletionEntryDetails` bloqueado | Respuesta vacia y log de bloqueo | Automatizado |
+| `getEditsForRefactor` smoke | No romper flujo ni introducir `__private__` fuera de scope | Automatizado |
+| Riesgo alias por nombre repetido (`views/gallery/ScopeTrap.tsx`) | No filtrar incorrectamente por coincidencia de nombre | Automatizado |
+
+## Ejecutar validacion automatizada
+
+Desde la raiz del workspace:
+
+```bash
+pnpm run build
+pnpm run test
+```
+
+## Gaps detectados (priorizados)
+
+No hay gaps abiertos de severidad alta/media en la matriz actual.
+
+## Uso en proyecto de prueba
+
+Ver `examples/test-project/` en la raiz del workspace para un ejemplo de consumo real.
+
+## Roadmap
+
+- [x] Fase 1: POC y validacion de carga
+- [x] Validacion integral de casos de completions y codefixes
+- [ ] Fase 2: Reglas contextuales adicionales
+- [ ] Fase 3: Configuracion flexible
+- [ ] Fase 4: Distribucion y documentacion completa

package/dist/index.d.ts

@@ -0,0 +1,5 @@
+import type * as ts from "typescript/lib/tsserverlibrary";
+declare function init(modules: {
+    typescript: typeof ts;
+}): ts.server.PluginModule;
+export = init;

package/dist/index.js

@@ -0,0 +1,409 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+const node_path_1 = __importDefault(require("node:path"));
+const PRIVATE_FOLDER = "__private__";
+const PRIVATE_SEGMENT = `/${PRIVATE_FOLDER}/`;
+const PRIVATE_SEGMENT_START = `/${PRIVATE_FOLDER}`;
+const PRIVATE_FOLDER_REGEX = PRIVATE_FOLDER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const PRIVATE_IMPORT_PATTERN = new RegExp(`from\\s+["']([^"']*${PRIVATE_FOLDER_REGEX}[^"']*)["']`, "g");
+function init(modules) {
+    function create(info) {
+        info.project.projectService.logger.info("===================================");
+        info.project.projectService.logger.info("PLUGIN LOADING: typescript-plugin-scoped-imports");
+        info.project.projectService.logger.info("===================================");
+        try {
+            const config = info.config || {};
+            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Config loaded - ${JSON.stringify(config)}`);
+            const tsApi = modules.typescript;
+            function normalizePath(value) {
+                return value.replace(/\\/g, "/");
+            }
+            function toDirectoryPath(value) {
+                return value.endsWith("/") ? value : `${value}/`;
+            }
+            function toPosixAbsolute(value) {
+                return normalizePath(node_path_1.default.resolve(value));
+            }
+            function getCompilerOptions() {
+                const programOptions = oldLS.getProgram()?.getCompilerOptions();
+                if (programOptions) {
+                    return programOptions;
+                }
+                return info.project.getCompilerOptions();
+            }
+            function getProjectBaseDir(compilerOptions) {
+                const baseDir = compilerOptions.baseUrl
+                    ? node_path_1.default.resolve(info.project.getCurrentDirectory(), compilerOptions.baseUrl)
+                    : info.project.getCurrentDirectory();
+                return toPosixAbsolute(baseDir);
+            }
+            function buildPathPatternRegex(pattern) {
+                const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+                const wildcardRegex = escaped.replace(/\*/g, "(.*)");
+                return new RegExp(`^${wildcardRegex}$`);
+            }
+            function tryResolveWithPathsMapping(modulePath, compilerOptions) {
+                const paths = compilerOptions.paths;
+                if (!paths) {
+                    return null;
+                }
+                const baseDir = getProjectBaseDir(compilerOptions);
+                for (const [pattern, targets] of Object.entries(paths)) {
+                    const matcher = buildPathPatternRegex(pattern);
+                    const match = modulePath.match(matcher);
+                    if (!match) {
+                        continue;
+                    }
+                    const captures = match.slice(1);
+                    for (const target of targets) {
+                        let captureIndex = 0;
+                        const replaced = target.replace(/\*/g, () => {
+                            const value = captures[captureIndex] ?? "";
+                            captureIndex += 1;
+                            return value;
+                        });
+                        const absolute = node_path_1.default.isAbsolute(replaced)
+                            ? toPosixAbsolute(replaced)
+                            : toPosixAbsolute(node_path_1.default.join(baseDir, replaced));
+                        return absolute;
+                    }
+                }
+                return null;
+            }
+            function resolveImportPathToAbsolute(importPath, currentFile) {
+                const normalizedImportPath = normalizePath(importPath);
+                const normalizedCurrentFile = normalizePath(currentFile);
+                if (normalizedImportPath.startsWith(".")) {
+                    const currentDir = node_path_1.default.dirname(normalizedCurrentFile);
+                    return toPosixAbsolute(node_path_1.default.resolve(currentDir, normalizedImportPath));
+                }
+                if (normalizedImportPath.startsWith("/")) {
+                    return toPosixAbsolute(normalizedImportPath);
+                }
+                const compilerOptions = getCompilerOptions();
+                const host = {
+                    fileExists: tsApi.sys.fileExists,
+                    readFile: tsApi.sys.readFile,
+                    directoryExists: tsApi.sys.directoryExists,
+                    getDirectories: tsApi.sys.getDirectories,
+                    realpath: tsApi.sys.realpath,
+                };
+                const resolved = tsApi.resolveModuleName(normalizedImportPath, normalizedCurrentFile, compilerOptions, host).resolvedModule?.resolvedFileName;
+                if (resolved) {
+                    return normalizePath(resolved);
+                }
+                return tryResolveWithPathsMapping(normalizedImportPath, compilerOptions);
+            }
+            function getPrivateParentDirectory(importPath, currentFile) {
+                const resolvedImportPath = resolveImportPathToAbsolute(importPath, currentFile);
+                if (!resolvedImportPath) {
+                    return null;
+                }
+                const privateSegmentIndex = resolvedImportPath.indexOf(PRIVATE_SEGMENT_START);
+                if (privateSegmentIndex === -1) {
+                    return null;
+                }
+                return toDirectoryPath(resolvedImportPath.substring(0, privateSegmentIndex + 1));
+            }
+            // Helper: Check if a file can access a __private__ folder
+            // Rule: A file can access __private__ only if it's in the "scope" of that __private__ folder
+            // The scope is: the parent directory of __private__ and all its subdirectories
+            function isPrivateImportAllowed(importPath, currentFile) {
+                const normalizedImportPath = normalizePath(importPath);
+                const normalizedCurrentFile = normalizePath(currentFile);
+                // DEBUG: Log all calls to understand what TypeScript sends
+                info.project.projectService.logger.info(`[DEBUG isPrivateImportAllowed] importPath="${normalizedImportPath}" currentFile="${normalizedCurrentFile}"`);
+                // If import doesn't contain __private__, allow
+                if (!normalizedImportPath.includes(PRIVATE_FOLDER)) {
+                    return true;
+                }
+                // Case 1: Current file is inside __private__ - allow all
+                if (normalizedCurrentFile.includes(PRIVATE_SEGMENT)) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: ALLOWING (file inside ${PRIVATE_FOLDER}): ${normalizedCurrentFile}`);
+                    return true;
+                }
+                const privateParentDir = getPrivateParentDirectory(normalizedImportPath, normalizedCurrentFile);
+                if (!privateParentDir) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING import (cannot resolve private parent): "${normalizedImportPath}" from "${normalizedCurrentFile}"`);
+                    return false;
+                }
+                const currentFileDir = toDirectoryPath(node_path_1.default.dirname(normalizedCurrentFile));
+                if (currentFileDir.startsWith(privateParentDir)) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: ALLOWING import (in scope): "${normalizedImportPath}" from "${normalizedCurrentFile}"`);
+                    return true;
+                }
+                info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING import (out of scope): "${normalizedImportPath}" from "${normalizedCurrentFile}"`);
+                return false;
+            }
+            // Helper: Extract import paths containing __private__ from text changes
+            function extractPrivateImportPaths(changes) {
+                const paths = [];
+                const importPattern = new RegExp(PRIVATE_IMPORT_PATTERN.source, PRIVATE_IMPORT_PATTERN.flags);
+                for (const change of changes) {
+                    for (const textChange of change.textChanges || []) {
+                        const newText = textChange.newText;
+                        if (!newText)
+                            continue;
+                        // Reset regex state
+                        importPattern.lastIndex = 0;
+                        let match = importPattern.exec(newText);
+                        while (match !== null) {
+                            paths.push(match[1]);
+                            match = importPattern.exec(newText);
+                        }
+                    }
+                }
+                return paths;
+            }
+            // Helper: Check if changes contain blocked private imports for a given file
+            function hasBlockedPrivateImports(changes, currentFile) {
+                const privatePaths = extractPrivateImportPaths(changes);
+                return privatePaths.some((path) => !isPrivateImportAllowed(path, currentFile));
+            }
+            // Helper: Simple check if changes contain any __private__ import
+            function containsPrivateImport(changes) {
+                return changes.some((change) => change.textChanges?.some((textChange) => {
+                    const newText = textChange.newText;
+                    return newText?.includes(PRIVATE_FOLDER) ?? false;
+                }));
+            }
+            // Create language service proxy
+            const proxy = Object.create(null);
+            const proxyObject = proxy;
+            const oldLS = info.languageService;
+            // Copy all methods from original LS
+            for (const k in oldLS) {
+                const key = k;
+                const x = oldLS[key];
+                if (typeof x === "function") {
+                    proxyObject[k] = (...args) => x.apply(oldLS, args);
+                }
+                else {
+                    proxyObject[k] = x;
+                }
+            }
+            // Helper: Extract the import path being typed at the given position
+            function getImportPathAtPosition(fileName, position) {
+                try {
+                    const program = oldLS.getProgram();
+                    if (!program)
+                        return null;
+                    const sourceFile = program.getSourceFile(fileName);
+                    if (!sourceFile)
+                        return null;
+                    const text = sourceFile.getFullText();
+                    // Find the string literal containing the position
+                    // Look backwards from position to find the opening quote
+                    let start = position - 1;
+                    while (start >= 0 && text[start] !== '"' && text[start] !== "'") {
+                        start--;
+                    }
+                    if (start < 0)
+                        return null;
+                    const quote = text[start];
+                    // Extract the path from after the quote to the position
+                    const path = text.substring(start + 1, position);
+                    return path;
+                }
+                catch {
+                    return null;
+                }
+            }
+            // Helper: Check if a typed path prefix allows access to __private__
+            function isPathPrefixValidForPrivate(pathPrefix, currentFile) {
+                const normalizedPath = pathPrefix.replace(/\\/g, "/");
+                if (!normalizedPath) {
+                    return false;
+                }
+                let basePath = normalizedPath;
+                if (basePath === ".") {
+                    basePath = "./";
+                }
+                else if (basePath === "..") {
+                    basePath = "../";
+                }
+                if (!basePath.endsWith("/")) {
+                    basePath += "/";
+                }
+                const candidateImportPath = `${basePath}${PRIVATE_FOLDER}`;
+                return isPrivateImportAllowed(candidateImportPath, currentFile);
+            }
+            // Intercept getCompletionsAtPosition
+            proxy.getCompletionsAtPosition = (fileName, position, options) => {
+                const prior = oldLS.getCompletionsAtPosition(fileName, position, options);
+                if (!prior) {
+                    return prior;
+                }
+                info.project.projectService.logger.info(`[DEBUG getCompletionsAtPosition] fileName="${fileName}" entries=${prior.entries.length}`);
+                const originalCount = prior.entries.length;
+                // Get the path being typed (for directory completion validation)
+                const typedPath = getImportPathAtPosition(fileName, position);
+                info.project.projectService.logger.info(`[DEBUG] typedPath="${typedPath}"`);
+                // Log entries that contain __private__ for debugging
+                for (const entry of prior.entries) {
+                    if (entry.name?.includes(PRIVATE_FOLDER) ||
+                        entry.source?.includes(PRIVATE_FOLDER) ||
+                        entry.sourceDisplay?.some((p) => p.text.includes(PRIVATE_FOLDER))) {
+                        info.project.projectService.logger.info(`[DEBUG entry] name="${entry.name}" source="${entry.source}" kind="${entry.kind}" sourceDisplay="${entry.sourceDisplay?.map((p) => p.text).join("")}"`);
+                    }
+                }
+                // Find blocked names (from __private__ sources that are not allowed)
+                const blockedNames = new Set();
+                for (const entry of prior.entries) {
+                    const source = entry.source;
+                    if (source?.includes(PRIVATE_FOLDER)) {
+                        if (!isPrivateImportAllowed(source, fileName)) {
+                            blockedNames.add(entry.name);
+                        }
+                    }
+                }
+                // Filter entries
+                const filteredEntries = prior.entries.filter((entry) => {
+                    // Handle entries with __private__ in the name (usually directory suggestions)
+                    if (entry.name?.toLowerCase().includes(PRIVATE_FOLDER)) {
+                        // If there's a source, use isPrivateImportAllowed
+                        if (entry.source) {
+                            return isPrivateImportAllowed(entry.source, fileName);
+                        }
+                        // No source - this is a directory suggestion in path completion
+                        if (entry.kind === "directory") {
+                            // Check if the typed path allows access to __private__
+                            if (typedPath !== null &&
+                                isPathPrefixValidForPrivate(typedPath, fileName)) {
+                                info.project.projectService.logger.info(`typescript-plugin-scoped-imports: ALLOWING ${PRIVATE_FOLDER} directory (valid path: "${typedPath}")`);
+                                return true;
+                            }
+                            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING ${PRIVATE_FOLDER} directory (invalid path: "${typedPath}")`);
+                            return false;
+                        }
+                        // For other kinds without source, block
+                        info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING entry by name (no source): ${entry.name}`);
+                        return false;
+                    }
+                    // Block directories that match blocked import sources
+                    if (entry.kind === "directory" && blockedNames.has(entry.name)) {
+                        info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING directory: ${entry.name}`);
+                        return false;
+                    }
+                    // If no source, check other fields for __private__
+                    if (!entry.source) {
+                        const entryText = (entry.name +
+                            (entry.insertText || "") +
+                            (entry.sourceDisplay?.map((p) => p.text).join("") || "") +
+                            JSON.stringify(entry.data || {})).toLowerCase();
+                        if (entryText.includes(PRIVATE_FOLDER)) {
+                            // Try to extract a path from sourceDisplay to validate
+                            const sourceDisplayText = entry.sourceDisplay?.map((p) => p.text).join("") || "";
+                            if (sourceDisplayText.includes(PRIVATE_FOLDER)) {
+                                // Use sourceDisplay as the import path for validation
+                                return isPrivateImportAllowed(sourceDisplayText, fileName);
+                            }
+                            // Can't determine scope, block to be safe
+                            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING entry without source: ${entry.name} (${entryText})`);
+                            return false;
+                        }
+                        return true;
+                    }
+                    // Check source path
+                    const source = entry.source;
+                    if (source?.includes(PRIVATE_FOLDER)) {
+                        return isPrivateImportAllowed(source, fileName);
+                    }
+                    return true;
+                });
+                const filteredCount = filteredEntries.length;
+                if (originalCount !== filteredCount) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${originalCount - filteredCount} completions (${originalCount} -> ${filteredCount})`);
+                }
+                return {
+                    ...prior,
+                    entries: filteredEntries,
+                };
+            };
+            // Intercept getCompletionEntryDetails
+            proxy.getCompletionEntryDetails = (fileName, position, entryName, formatOptions, source, preferences, data) => {
+                if (source?.includes(PRIVATE_FOLDER)) {
+                    if (!isPrivateImportAllowed(source, fileName)) {
+                        info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING completion details for source: ${source}`);
+                        return undefined;
+                    }
+                }
+                return oldLS.getCompletionEntryDetails(fileName, position, entryName, formatOptions, source, preferences, data);
+            };
+            // Intercept getCodeFixesAtPosition
+            proxy.getCodeFixesAtPosition = (fileName, start, end, errorCodes, formatOptions, preferences) => {
+                const fixes = oldLS.getCodeFixesAtPosition(fileName, start, end, errorCodes, formatOptions, preferences);
+                const filteredFixes = fixes.filter((fix) => {
+                    if (containsPrivateImport(fix.changes)) {
+                        if (hasBlockedPrivateImports(fix.changes, fileName)) {
+                            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: BLOCKING code fix "${fix.fixName}"`);
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                if (fixes.length !== filteredFixes.length) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${fixes.length - filteredFixes.length} code fixes`);
+                }
+                return filteredFixes;
+            };
+            // Intercept getCombinedCodeFix
+            proxy.getCombinedCodeFix = (scope, fixId, formatOptions, preferences) => {
+                const getCombinedCodeFix = oldLS.getCombinedCodeFix;
+                const result = getCombinedCodeFix(scope, fixId, formatOptions, preferences);
+                const fileName = scope.fileName;
+                const filteredChanges = result.changes.filter((change) => {
+                    if (containsPrivateImport([change])) {
+                        if (hasBlockedPrivateImports([change], fileName)) {
+                            info.project.projectService.logger.info("typescript-plugin-scoped-imports: BLOCKING combined fix change");
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                if (result.changes.length !== filteredChanges.length) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${result.changes.length - filteredChanges.length} combined fix changes`);
+                }
+                return {
+                    ...result,
+                    changes: filteredChanges,
+                };
+            };
+            // Intercept getEditsForRefactor
+            proxy.getEditsForRefactor = (fileName, formatOptions, positionOrRange, refactorName, actionName, preferences, interactiveRefactorArguments) => {
+                const result = oldLS.getEditsForRefactor(fileName, formatOptions, positionOrRange, refactorName, actionName, preferences, interactiveRefactorArguments);
+                if (!result) {
+                    return result;
+                }
+                const filteredEdits = result.edits.filter((edit) => {
+                    if (containsPrivateImport([edit])) {
+                        if (hasBlockedPrivateImports([edit], fileName)) {
+                            info.project.projectService.logger.info("typescript-plugin-scoped-imports: BLOCKING refactor edit");
+                            return false;
+                        }
+                    }
+                    return true;
+                });
+                if (result.edits.length !== filteredEdits.length) {
+                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${result.edits.length - filteredEdits.length} refactor edits`);
+                }
+                return {
+                    ...result,
+                    edits: filteredEdits,
+                };
+            };
+            info.project.projectService.logger.info("typescript-plugin-scoped-imports: Plugin proxy created successfully");
+            info.project.projectService.logger.info("===================================");
+            return proxy;
+        }
+        catch (error) {
+            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: ERROR loading plugin: ${error}`);
+            info.project.projectService.logger.info("===================================");
+            throw error;
+        }
+    }
+    return { create };
+}
+module.exports = init;

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "typescript-plugin-scoped-imports",
+  "version": "0.1.1",
+  "description": "TypeScript Language Server plugin para controlar auto-imports basado en scope",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "CHANGELOG.md"
+  ],
+  "keywords": [
+    "typescript",
+    "plugin",
+    "imports",
+    "scoped"
+  ],
+  "author": "Nicolas Viotti",
+  "license": "MIT",
+  "engines": {
+    "node": ">=20"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "typescript": "^5.0.0",
+    "jest": "^29.0.0",
+    "@types/jest": "^29.0.0",
+    "ts-jest": "^29.0.0",
+    "@biomejs/biome": "^1.8.3"
+  },
+  "peerDependencies": {
+    "typescript": ">=4.0.0"
+  },
+  "scripts": {
+    "build": "tsc",
+    "typecheck": "tsc --noEmit",
+    "watch": "tsc --watch",
+    "test": "jest",
+    "biome:lint": "biome lint .",
+    "biome:lint:fix": "biome lint --write .",
+    "biome:format": "biome format .",
+    "biome:format:fix": "biome format --write .",
+    "biome:check": "biome check .",
+    "biome:check:fix": "biome check --write ."
+  }
+}