typescript-plugin-scoped-imports 0.1.1 → 0.1.2

package/CHANGELOG.md

@@ -1,5 +1,12 @@
 # Changelog
 
+## 0.1.2 - 2026-02-15
+
+- Refactor: split plugin internals into `utils/` modules and keep `src/index.ts` focused on tsserver interceptor orchestration.
+- Internal API: adopted parameter-signature convention (`3+` args use typed object params, `1-2` args stay positional) across touched utilities and wiring.
+- Tests: added and expanded unit coverage for module resolution, text change parsing edge cases, and path/scope normalization behavior.
+- Behavior: no public API changes and no scope-rule changes (`parent + descendientes` remains intact).
+
 ## 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`).

package/README.md

@@ -1,84 +1,97 @@
-# TypeScript Plugin: Scoped Imports
+# typescript-plugin-scoped-imports
 
-TypeScript Language Server plugin para controlar auto-imports basado en el scope del archivo.
+TypeScript Language Service plugin that filters auto-imports from private folders (`__private__`) based on file scope.
 
-## Estado actual
+## What it does
 
-Regla validada en esta fase:
+When TypeScript proposes imports (completions, quick fixes, refactors), this plugin blocks imports from `__private__` when the current file is out of scope.
 
-- `__private__` es accesible desde su carpeta padre y subdirectorios.
-- Fuera de ese subtree, el plugin bloquea sugerencias y fixes que introduzcan imports privados.
+Current scope rule:
 
-## Instalacion (workspace)
+- Allowed: parent directory of `__private__` and descendants
+- Blocked: any file outside that subtree
+
+## Installation
 
 ```bash
-pnpm install
-pnpm run build
+npm i -D typescript
+npm i typescript-plugin-scoped-imports
 ```
 
-Requiere Node.js 20 o superior.
-
-## Configuracion
+## Configuration
 
-En tu `tsconfig.json`:
+In `tsconfig.json`:
 
 ```json
 {
   "compilerOptions": {
     "plugins": [
       {
-        "name": "typescript-plugin-scoped-imports"
+        "name": "typescript-plugin-scoped-imports",
+        "debug": false
       }
     ]
   }
 }
 ```
 
-Convencion: el plugin considera privados los paths que contengan la carpeta `__private__`.
+`debug` is optional. Set it to `true` to enable verbose plugin debug logs.
+
+## Quick example
+
+Structure:
+
+```text
+src/components/gallery/__private__/Item.ts
+src/components/gallery/silbing/nephew/InScope.ts
+src/views/Home.ts
+```
+
+- In `InScope.ts`: importing `Item` from `__private__` is allowed
+- In `Home.ts`: importing `Item` from `__private__` is blocked
+
+## VS Code
+
+If you use only the npm plugin, VS Code may require using the workspace TypeScript version to load it.
+
+To avoid that, use the wrapper extension:
+
+- `packages/typescript-plugin-scoped-imports-vscode`
+- Marketplace: https://marketplace.visualstudio.com/items?itemName=nicovio.typescript-plugin-scoped-imports-vscode
 
-## Matriz de validacion
+## Compatibility
 
-La suite automatizada vive en:
+- Node.js: `>=20`
+- TypeScript: `>=4.0.0`
+
+## Troubleshooting
+
+If it does not load:
+
+1. Open `TypeScript: Open TS Server log`.
+2. Look for `PLUGIN LOADING: typescript-plugin-scoped-imports`.
+3. If missing, check:
+   - plugin is installed in the project
+   - `tsconfig.json` includes it under `compilerOptions.plugins`
+
+## Known limitations
+
+- Privacy convention is based on folder name `__private__`
+- No custom private-pattern configuration yet
+
+## Automated validation
+
+Main integration coverage lives in:
 
 - `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:
+Run:
 
 ```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
+## Changelog
 
-- [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
+See `CHANGELOG.md`.

package/dist/constants.d.ts

@@ -0,0 +1,4 @@
+export declare const PRIVATE_FOLDER = "__private__";
+export declare const PRIVATE_SEGMENT = "/__private__/";
+export declare const PRIVATE_SEGMENT_START = "/__private__";
+export declare const PRIVATE_IMPORT_PATTERN: RegExp;

package/dist/constants.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PRIVATE_IMPORT_PATTERN = exports.PRIVATE_SEGMENT_START = exports.PRIVATE_SEGMENT = exports.PRIVATE_FOLDER = void 0;
+exports.PRIVATE_FOLDER = "__private__";
+exports.PRIVATE_SEGMENT = `/${exports.PRIVATE_FOLDER}/`;
+exports.PRIVATE_SEGMENT_START = `/${exports.PRIVATE_FOLDER}`;
+const PRIVATE_FOLDER_REGEX = exports.PRIVATE_FOLDER.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+exports.PRIVATE_IMPORT_PATTERN = new RegExp(`from\\s+["']([^"']*${PRIVATE_FOLDER_REGEX}[^"']*)["']`, "g");

package/dist/index.js

@@ -1,31 +1,21 @@
 "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");
+const constants_1 = require("./constants");
+const completion_1 = require("./utils/completion");
+const logging_1 = require("./utils/logging");
+const moduleResolution_1 = require("./utils/moduleResolution");
+const privateScope_1 = require("./utils/privateScope");
+const textChanges_1 = require("./utils/textChanges");
 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("===================================");
+        const config = (info.config ?? {});
+        const { logInfo, logDebug } = (0, logging_1.createPluginLogger)(info.project.projectService.logger, config);
+        logInfo("===================================");
+        logInfo("PLUGIN LOADING: typescript-plugin-scoped-imports");
+        logInfo("===================================");
         try {
-            const config = info.config || {};
-            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Config loaded - ${JSON.stringify(config)}`);
+            logInfo(`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));
-            }
+            const oldLS = info.languageService;
             function getCompilerOptions() {
                 const programOptions = oldLS.getProgram()?.getCompilerOptions();
                 if (programOptions) {
@@ -33,374 +23,157 @@ function init(modules) {
                 }
                 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}`);
+            const resolveImportPath = (importPath, currentFile) => {
+                return (0, moduleResolution_1.resolveImportPathToAbsolute)({
+                    tsApi,
+                    importPath,
+                    currentFile,
+                    compilerOptions: getCompilerOptions(),
+                    currentDirectory: info.project.getCurrentDirectory(),
+                });
+            };
+            const isPrivateImportAllowedForFile = (importPath, currentFile) => {
+                return (0, privateScope_1.isPrivateImportAllowed)({
+                    importPath,
+                    currentFile,
+                    resolveImportPathToAbsolute: resolveImportPath,
+                    logging: {
+                        logInfo,
+                        logDebug,
+                    },
+                });
+            };
+            function shouldAllowChanges(params) {
+                const { changes, currentFile, blockedLogMessage } = params;
+                if (!(0, textChanges_1.containsPrivateImport)(changes)) {
                     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}"`);
+                if ((0, textChanges_1.hasBlockedPrivateImports)({
+                    changes,
+                    currentFile,
+                    isPrivateImportAllowed: isPrivateImportAllowedForFile,
+                })) {
+                    logInfo(blockedLogMessage);
                     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;
-                }));
+                return true;
             }
-            // 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);
+            for (const key in oldLS) {
+                const serviceKey = key;
+                const serviceMember = oldLS[serviceKey];
+                if (typeof serviceMember === "function") {
+                    proxyObject[key] = (...args) => serviceMember.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;
+                    proxyObject[key] = serviceMember;
                 }
             }
-            // 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
+                logDebug(`[DEBUG getCompletionsAtPosition] fileName="${fileName}" entries=${prior.entries.length.toString()}`);
+                const typedPath = (0, completion_1.getImportPathAtPosition)({
+                    languageService: oldLS,
+                    fileName,
+                    position,
+                });
+                logDebug(`[DEBUG] typedPath="${typedPath}"`);
                 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("")}"`);
+                    if (entry.name?.includes(constants_1.PRIVATE_FOLDER) ||
+                        entry.source?.includes(constants_1.PRIVATE_FOLDER) ||
+                        entry.sourceDisplay?.some((part) => part.text.includes(constants_1.PRIVATE_FOLDER))) {
+                        logDebug(`[DEBUG entry] name="${entry.name}" source="${entry.source}" kind="${entry.kind}" sourceDisplay="${entry.sourceDisplay?.map((part) => part.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);
-                        }
+                    if (source?.includes(constants_1.PRIVATE_FOLDER) &&
+                        !isPrivateImportAllowedForFile(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})`);
+                const filteredEntries = prior.entries.filter((entry) => (0, completion_1.shouldAllowCompletionEntry)({
+                    entry,
+                    typedPath,
+                    fileName,
+                    blockedNames,
+                    isPrivateImportAllowed: isPrivateImportAllowedForFile,
+                    logInfo,
+                }));
+                if (prior.entries.length !== filteredEntries.length) {
+                    logInfo(`typescript-plugin-scoped-imports: Filtered ${(prior.entries.length - filteredEntries.length).toString()} completions (${prior.entries.length.toString()} -> ${filteredEntries.length.toString()})`);
                 }
                 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;
-                    }
+                if (source?.includes(constants_1.PRIVATE_FOLDER) &&
+                    !isPrivateImportAllowedForFile(source, fileName)) {
+                    logInfo(`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;
-                });
+                const filteredFixes = fixes.filter((fix) => shouldAllowChanges({
+                    changes: fix.changes,
+                    currentFile: fileName,
+                    blockedLogMessage: `typescript-plugin-scoped-imports: BLOCKING code fix "${fix.fixName}"`,
+                }));
                 if (fixes.length !== filteredFixes.length) {
-                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${fixes.length - filteredFixes.length} code fixes`);
+                    logInfo(`typescript-plugin-scoped-imports: Filtered ${(fixes.length - filteredFixes.length).toString()} 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;
-                });
+                const filteredChanges = result.changes.filter((change) => shouldAllowChanges({
+                    changes: [change],
+                    currentFile: scope.fileName,
+                    blockedLogMessage: "typescript-plugin-scoped-imports: BLOCKING combined fix change",
+                }));
                 if (result.changes.length !== filteredChanges.length) {
-                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${result.changes.length - filteredChanges.length} combined fix changes`);
+                    logInfo(`typescript-plugin-scoped-imports: Filtered ${(result.changes.length - filteredChanges.length).toString()} 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;
-                });
+                const filteredEdits = result.edits.filter((edit) => shouldAllowChanges({
+                    changes: [edit],
+                    currentFile: fileName,
+                    blockedLogMessage: "typescript-plugin-scoped-imports: BLOCKING refactor edit",
+                }));
                 if (result.edits.length !== filteredEdits.length) {
-                    info.project.projectService.logger.info(`typescript-plugin-scoped-imports: Filtered ${result.edits.length - filteredEdits.length} refactor edits`);
+                    logInfo(`typescript-plugin-scoped-imports: Filtered ${(result.edits.length - filteredEdits.length).toString()} refactor edits`);
                 }
                 return {
                     ...result,
                     edits: filteredEdits,
                 };
             };
-            info.project.projectService.logger.info("typescript-plugin-scoped-imports: Plugin proxy created successfully");
-            info.project.projectService.logger.info("===================================");
+            logInfo("typescript-plugin-scoped-imports: Plugin proxy created successfully");
+            logInfo("===================================");
             return proxy;
         }
         catch (error) {
-            info.project.projectService.logger.info(`typescript-plugin-scoped-imports: ERROR loading plugin: ${error}`);
-            info.project.projectService.logger.info("===================================");
+            logInfo(`typescript-plugin-scoped-imports: ERROR loading plugin: ${error}`);
+            logInfo("===================================");
             throw error;
         }
     }

package/dist/utils/completion.d.ts

@@ -0,0 +1,22 @@
+import type * as ts from "typescript/lib/tsserverlibrary";
+export type GetImportPathAtPositionParams = {
+    languageService: ts.LanguageService;
+    fileName: string;
+    position: number;
+};
+export type IsPathPrefixValidForPrivateParams = {
+    pathPrefix: string;
+    currentFile: string;
+    isPrivateImportAllowed: (importPath: string, currentFile: string) => boolean;
+};
+export declare function getImportPathAtPosition(params: GetImportPathAtPositionParams): string | null;
+export declare function isPathPrefixValidForPrivate(params: IsPathPrefixValidForPrivateParams): boolean;
+export type CompletionDecisionOptions = {
+    entry: ts.CompletionEntry;
+    typedPath: string | null;
+    fileName: string;
+    blockedNames: ReadonlySet<string>;
+    isPrivateImportAllowed: (importPath: string, currentFile: string) => boolean;
+    logInfo: (message: string) => void;
+};
+export declare function shouldAllowCompletionEntry({ entry, typedPath, fileName, blockedNames, isPrivateImportAllowed, logInfo, }: CompletionDecisionOptions): boolean;

package/dist/utils/completion.js

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImportPathAtPosition = getImportPathAtPosition;
+exports.isPathPrefixValidForPrivate = isPathPrefixValidForPrivate;
+exports.shouldAllowCompletionEntry = shouldAllowCompletionEntry;
+const constants_1 = require("../constants");
+const path_1 = require("./path");
+function getImportPathAtPosition(params) {
+    const { languageService, fileName, position } = params;
+    try {
+        const program = languageService.getProgram();
+        if (!program) {
+            return null;
+        }
+        const sourceFile = program.getSourceFile(fileName);
+        if (!sourceFile) {
+            return null;
+        }
+        const text = sourceFile.getFullText();
+        let start = position - 1;
+        while (start >= 0 && text[start] !== '"' && text[start] !== "'") {
+            start -= 1;
+        }
+        if (start < 0) {
+            return null;
+        }
+        return text.substring(start + 1, position);
+    }
+    catch {
+        return null;
+    }
+}
+function isPathPrefixValidForPrivate(params) {
+    const { pathPrefix, currentFile, isPrivateImportAllowed } = params;
+    const normalizedPath = (0, path_1.normalizePath)(pathPrefix);
+    if (!normalizedPath) {
+        return false;
+    }
+    let basePath = normalizedPath;
+    if (basePath === ".") {
+        basePath = "./";
+    }
+    else if (basePath === "..") {
+        basePath = "../";
+    }
+    if (!basePath.endsWith("/")) {
+        basePath += "/";
+    }
+    const candidateImportPath = `${basePath}${constants_1.PRIVATE_FOLDER}`;
+    return isPrivateImportAllowed(candidateImportPath, currentFile);
+}
+function shouldAllowCompletionEntry({ entry, typedPath, fileName, blockedNames, isPrivateImportAllowed, logInfo, }) {
+    if (entry.name?.toLowerCase().includes(constants_1.PRIVATE_FOLDER)) {
+        if (entry.source) {
+            return isPrivateImportAllowed(entry.source, fileName);
+        }
+        if (entry.kind === "directory") {
+            if (typedPath !== null &&
+                isPathPrefixValidForPrivate({
+                    pathPrefix: typedPath,
+                    currentFile: fileName,
+                    isPrivateImportAllowed,
+                })) {
+                logInfo(`typescript-plugin-scoped-imports: ALLOWING ${constants_1.PRIVATE_FOLDER} directory (valid path: "${typedPath}")`);
+                return true;
+            }
+            logInfo(`typescript-plugin-scoped-imports: BLOCKING ${constants_1.PRIVATE_FOLDER} directory (invalid path: "${typedPath}")`);
+            return false;
+        }
+        logInfo(`typescript-plugin-scoped-imports: BLOCKING entry by name (no source): ${entry.name}`);
+        return false;
+    }
+    if (entry.kind === "directory" && blockedNames.has(entry.name)) {
+        logInfo(`typescript-plugin-scoped-imports: BLOCKING directory: ${entry.name}`);
+        return false;
+    }
+    if (!entry.source) {
+        const sourceDisplayText = entry.sourceDisplay?.map((p) => p.text).join("") || "";
+        const entryText = (entry.name +
+            (entry.insertText || "") +
+            sourceDisplayText +
+            JSON.stringify(entry.data || {})).toLowerCase();
+        if (entryText.includes(constants_1.PRIVATE_FOLDER)) {
+            if (sourceDisplayText.includes(constants_1.PRIVATE_FOLDER)) {
+                return isPrivateImportAllowed(sourceDisplayText, fileName);
+            }
+            logInfo(`typescript-plugin-scoped-imports: BLOCKING entry without source: ${entry.name} (${entryText})`);
+            return false;
+        }
+        return true;
+    }
+    if (entry.source.includes(constants_1.PRIVATE_FOLDER)) {
+        return isPrivateImportAllowed(entry.source, fileName);
+    }
+    return true;
+}

package/dist/utils/logging.d.ts

@@ -0,0 +1,8 @@
+import type * as ts from "typescript/lib/tsserverlibrary";
+export type PluginConfig = {
+    debug?: boolean;
+};
+export declare function createPluginLogger(logger: ts.server.Logger, config: PluginConfig | undefined): {
+    logInfo: (message: string) => void;
+    logDebug: (message: string) => void;
+};

package/dist/utils/logging.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createPluginLogger = createPluginLogger;
+function createPluginLogger(logger, config) {
+    const debugEnabled = config?.debug === true;
+    const logInfo = (message) => {
+        logger.info(message);
+    };
+    const logDebug = (message) => {
+        if (debugEnabled) {
+            logger.info(message);
+        }
+    };
+    return {
+        logInfo,
+        logDebug,
+    };
+}

package/dist/utils/moduleResolution.d.ts

@@ -0,0 +1,19 @@
+import type * as ts from "typescript/lib/tsserverlibrary";
+type TsApiForResolution = Pick<typeof ts, "resolveModuleName" | "sys">;
+type ResolveWithPathsMappingParams = {
+    modulePath: string;
+    compilerOptions: ts.CompilerOptions;
+    projectBaseDir: string;
+};
+export type ResolveImportPathToAbsoluteParams = {
+    tsApi: TsApiForResolution;
+    importPath: string;
+    currentFile: string;
+    compilerOptions: ts.CompilerOptions;
+    currentDirectory: string;
+};
+export declare function buildPathPatternRegex(pattern: string): RegExp;
+export declare function getProjectBaseDir(currentDirectory: string, compilerOptions: ts.CompilerOptions): string;
+export declare function tryResolveWithPathsMapping(params: ResolveWithPathsMappingParams): string | null;
+export declare function resolveImportPathToAbsolute(params: ResolveImportPathToAbsoluteParams): string | null;
+export {};

package/dist/utils/moduleResolution.js

@@ -0,0 +1,79 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.buildPathPatternRegex = buildPathPatternRegex;
+exports.getProjectBaseDir = getProjectBaseDir;
+exports.tryResolveWithPathsMapping = tryResolveWithPathsMapping;
+exports.resolveImportPathToAbsolute = resolveImportPathToAbsolute;
+const node_path_1 = __importDefault(require("node:path"));
+const path_1 = require("./path");
+function buildPathPatternRegex(pattern) {
+    const escaped = pattern.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    const wildcardRegex = escaped.replace(/\*/g, "(.*)");
+    return new RegExp(`^${wildcardRegex}$`);
+}
+function getProjectBaseDir(currentDirectory, compilerOptions) {
+    const baseDir = compilerOptions.baseUrl
+        ? node_path_1.default.resolve(currentDirectory, compilerOptions.baseUrl)
+        : currentDirectory;
+    return (0, path_1.toPosixAbsolute)(baseDir);
+}
+function tryResolveWithPathsMapping(params) {
+    const { modulePath, compilerOptions, projectBaseDir } = params;
+    const paths = compilerOptions.paths;
+    if (!paths) {
+        return null;
+    }
+    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)
+                ? (0, path_1.toPosixAbsolute)(replaced)
+                : (0, path_1.toPosixAbsolute)(node_path_1.default.join(projectBaseDir, replaced));
+            return absolute;
+        }
+    }
+    return null;
+}
+function resolveImportPathToAbsolute(params) {
+    const { tsApi, importPath, currentFile, compilerOptions, currentDirectory } = params;
+    const normalizedImportPath = (0, path_1.normalizePath)(importPath);
+    const normalizedCurrentFile = (0, path_1.normalizePath)(currentFile);
+    if (normalizedImportPath.startsWith(".")) {
+        const currentDir = node_path_1.default.dirname(normalizedCurrentFile);
+        return (0, path_1.toPosixAbsolute)(node_path_1.default.resolve(currentDir, normalizedImportPath));
+    }
+    if (normalizedImportPath.startsWith("/")) {
+        return (0, path_1.toPosixAbsolute)(normalizedImportPath);
+    }
+    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 (0, path_1.normalizePath)(resolved);
+    }
+    const projectBaseDir = getProjectBaseDir(currentDirectory, compilerOptions);
+    return tryResolveWithPathsMapping({
+        modulePath: normalizedImportPath,
+        compilerOptions,
+        projectBaseDir,
+    });
+}

package/dist/utils/path.d.ts

@@ -0,0 +1,3 @@
+export declare function normalizePath(value: string): string;
+export declare function toDirectoryPath(value: string): string;
+export declare function toPosixAbsolute(value: string): string;

package/dist/utils/path.js

@@ -0,0 +1,18 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePath = normalizePath;
+exports.toDirectoryPath = toDirectoryPath;
+exports.toPosixAbsolute = toPosixAbsolute;
+const node_path_1 = __importDefault(require("node:path"));
+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));
+}

package/dist/utils/privateScope.d.ts

@@ -0,0 +1,19 @@
+type ResolveImportPath = (importPath: string, currentFile: string) => string | null;
+type ScopeLogging = {
+    logInfo: (message: string) => void;
+    logDebug: (message: string) => void;
+};
+export type GetPrivateParentDirectoryParams = {
+    importPath: string;
+    currentFile: string;
+    resolveImportPathToAbsolute: ResolveImportPath;
+};
+export type IsPrivateImportAllowedParams = {
+    importPath: string;
+    currentFile: string;
+    resolveImportPathToAbsolute: ResolveImportPath;
+    logging: ScopeLogging;
+};
+export declare function getPrivateParentDirectory(params: GetPrivateParentDirectoryParams): string | null;
+export declare function isPrivateImportAllowed(params: IsPrivateImportAllowedParams): boolean;
+export {};

package/dist/utils/privateScope.js

@@ -0,0 +1,51 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getPrivateParentDirectory = getPrivateParentDirectory;
+exports.isPrivateImportAllowed = isPrivateImportAllowed;
+const node_path_1 = __importDefault(require("node:path"));
+const constants_1 = require("../constants");
+const path_1 = require("./path");
+function getPrivateParentDirectory(params) {
+    const { importPath, currentFile, resolveImportPathToAbsolute } = params;
+    const resolvedImportPath = resolveImportPathToAbsolute(importPath, currentFile);
+    if (!resolvedImportPath) {
+        return null;
+    }
+    const privateSegmentIndex = resolvedImportPath.indexOf(constants_1.PRIVATE_SEGMENT_START);
+    if (privateSegmentIndex === -1) {
+        return null;
+    }
+    return (0, path_1.toDirectoryPath)(resolvedImportPath.substring(0, privateSegmentIndex + 1));
+}
+function isPrivateImportAllowed(params) {
+    const { importPath, currentFile, resolveImportPathToAbsolute, logging } = params;
+    const normalizedImportPath = (0, path_1.normalizePath)(importPath);
+    const normalizedCurrentFile = (0, path_1.normalizePath)(currentFile);
+    logging.logDebug(`[DEBUG isPrivateImportAllowed] importPath="${normalizedImportPath}" currentFile="${normalizedCurrentFile}"`);
+    if (!normalizedImportPath.includes(constants_1.PRIVATE_FOLDER)) {
+        return true;
+    }
+    if (normalizedCurrentFile.includes(constants_1.PRIVATE_SEGMENT)) {
+        logging.logInfo(`typescript-plugin-scoped-imports: ALLOWING (file inside ${constants_1.PRIVATE_FOLDER}): ${normalizedCurrentFile}`);
+        return true;
+    }
+    const privateParentDir = getPrivateParentDirectory({
+        importPath: normalizedImportPath,
+        currentFile: normalizedCurrentFile,
+        resolveImportPathToAbsolute,
+    });
+    if (!privateParentDir) {
+        logging.logInfo(`typescript-plugin-scoped-imports: BLOCKING import (cannot resolve private parent): "${normalizedImportPath}" from "${normalizedCurrentFile}"`);
+        return false;
+    }
+    const currentFileDir = (0, path_1.toDirectoryPath)(node_path_1.default.dirname(normalizedCurrentFile));
+    if (currentFileDir.startsWith(privateParentDir)) {
+        logging.logInfo(`typescript-plugin-scoped-imports: ALLOWING import (in scope): "${normalizedImportPath}" from "${normalizedCurrentFile}"`);
+        return true;
+    }
+    logging.logInfo(`typescript-plugin-scoped-imports: BLOCKING import (out of scope): "${normalizedImportPath}" from "${normalizedCurrentFile}"`);
+    return false;
+}

package/dist/utils/textChanges.d.ts

@@ -0,0 +1,9 @@
+import type * as ts from "typescript/lib/tsserverlibrary";
+export type HasBlockedPrivateImportsParams = {
+    changes: readonly ts.FileTextChanges[];
+    currentFile: string;
+    isPrivateImportAllowed: (importPath: string, currentFile: string) => boolean;
+};
+export declare function extractPrivateImportPaths(changes: readonly ts.FileTextChanges[]): string[];
+export declare function containsPrivateImport(changes: readonly ts.FileTextChanges[]): boolean;
+export declare function hasBlockedPrivateImports(params: HasBlockedPrivateImportsParams): boolean;

package/dist/utils/textChanges.js

@@ -0,0 +1,36 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractPrivateImportPaths = extractPrivateImportPaths;
+exports.containsPrivateImport = containsPrivateImport;
+exports.hasBlockedPrivateImports = hasBlockedPrivateImports;
+const constants_1 = require("../constants");
+function extractPrivateImportPaths(changes) {
+    const paths = [];
+    const importPattern = new RegExp(constants_1.PRIVATE_IMPORT_PATTERN.source, constants_1.PRIVATE_IMPORT_PATTERN.flags);
+    for (const change of changes) {
+        for (const textChange of change.textChanges || []) {
+            const newText = textChange.newText;
+            if (!newText) {
+                continue;
+            }
+            importPattern.lastIndex = 0;
+            let match = importPattern.exec(newText);
+            while (match !== null) {
+                paths.push(match[1]);
+                match = importPattern.exec(newText);
+            }
+        }
+    }
+    return paths;
+}
+function containsPrivateImport(changes) {
+    return changes.some((change) => change.textChanges?.some((textChange) => {
+        const newText = textChange.newText;
+        return newText?.includes(constants_1.PRIVATE_FOLDER) ?? false;
+    }));
+}
+function hasBlockedPrivateImports(params) {
+    const { changes, currentFile, isPrivateImportAllowed } = params;
+    const privatePaths = extractPrivateImportPaths(changes);
+    return privatePaths.some((importPath) => !isPrivateImportAllowed(importPath, currentFile));
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typescript-plugin-scoped-imports",
-  "version": "0.1.1",
+  "version": "0.1.2",
   "description": "TypeScript Language Server plugin para controlar auto-imports basado en scope",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",