@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/imports/standalone-import-analysis.js

@@ -0,0 +1,602 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStandaloneImportAnalysis = runStandaloneImportAnalysis;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const file_text_edit_executor_1 = require("../commands/file-text-edit-executor");
+const import_rules_1 = require("../config/import-rules");
+const typescript_preferences_1 = require("../config/typescript-preferences");
+const standalone_ts_project_1 = require("./standalone-ts-project");
+async function runStandaloneImportAnalysis(request) {
+    switch (request.operation) {
+        case "find-importers": return findImporters(request.workspaceRoot, request.payload);
+        case "find-unused": return findUnused(request.workspaceRoot, request.payload);
+        case "add-missing": return addMissing(request.workspaceRoot, request.payload, request.importRules);
+        case "declaration-add-missing": return declarationAddMissing(request.workspaceRoot, request.payload, request.importRules);
+    }
+}
+function findImporters(root, payload) {
+    const targetPath = resolveInside(root, readString(payload.targetPath));
+    if (!targetPath)
+        return { ok: false, error: "targetPath is required." };
+    if (!isPathPresent(targetPath))
+        return { ok: false, error: `targetPath not found: ${targetPath}` };
+    const targetStats = fs.statSync(targetPath);
+    const targetMode = targetStats.isDirectory() ? "directory" : "file";
+    const targetKey = fileKey(targetPath);
+    const directoryPrefix = targetMode === "directory" ? `${targetKey}${path.sep}` : null;
+    const project = (0, standalone_ts_project_1.createStandaloneTsProject)(root, targetPath);
+    try {
+        const matches = [];
+        for (const importerFile of project.parsedConfig.fileNames) {
+            if (!isRegularFile(importerFile) || fileKey(importerFile) === targetKey)
+                continue;
+            const text = fs.readFileSync(importerFile, "utf8");
+            const sourceFile = project.ts.createSourceFile(importerFile, text, project.ts.ScriptTarget.Latest, true);
+            const visit = (node) => {
+                const edge = moduleEdge(project.ts, node);
+                if (edge) {
+                    const resolved = project.ts.resolveModuleName(edge.specifier, importerFile, project.parsedConfig.options, project.ts.sys).resolvedModule;
+                    if (resolved?.resolvedFileName) {
+                        const resolvedKey = fileKey(resolved.resolvedFileName);
+                        const matchesTarget = targetMode === "directory"
+                            ? resolvedKey === targetKey || Boolean(directoryPrefix && resolvedKey.startsWith(directoryPrefix))
+                            : resolvedKey === targetKey;
+                        if (matchesTarget) {
+                            const start = sourceFile.getLineAndCharacterOfPosition(edge.node.getStart());
+                            const end = sourceFile.getLineAndCharacterOfPosition(edge.node.getEnd());
+                            matches.push({
+                                importerFile: path.normalize(importerFile),
+                                specifier: edge.specifier,
+                                resolvedFile: path.normalize(resolved.resolvedFileName),
+                                importKind: edge.kind,
+                                range: {
+                                    start: { line: start.line, character: start.character },
+                                    end: { line: end.line, character: end.character }
+                                }
+                            });
+                        }
+                    }
+                }
+                project.ts.forEachChild(node, visit);
+            };
+            visit(sourceFile);
+        }
+        return {
+            ok: true,
+            targetPath: path.normalize(targetPath),
+            targetMode,
+            configFilePath: project.configFilePath,
+            importerCount: new Set(matches.flatMap((item) => isRecord(item) && typeof item.importerFile === "string" ? [item.importerFile] : [])).size,
+            matchCount: matches.length,
+            importers: matches
+        };
+    }
+    finally {
+        project.dispose();
+    }
+}
+function findUnused(root, payload) {
+    const sourceFile = resolveInside(root, readString(payload.sourceFile));
+    if (!sourceFile)
+        return { ok: false, error: "sourceFile is required." };
+    if (!isRegularFile(sourceFile))
+        return { ok: false, error: `sourceFile not found: ${sourceFile}` };
+    const project = (0, standalone_ts_project_1.createStandaloneTsProject)(root, sourceFile);
+    try {
+        const sourceText = fs.readFileSync(sourceFile, "utf8");
+        const original = parseImportEntries(project.ts, sourceFile, sourceText);
+        const edits = project.languageService.organizeImports({ type: "file", fileName: sourceFile, skipDestructiveCodeActions: false }, (0, standalone_ts_project_1.defaultFormatOptions)(), importPreferences(root, sourceFile, [], false));
+        const fileEdit = edits.find((item) => fileKey(item.fileName) === fileKey(sourceFile));
+        const organizedText = fileEdit ? (0, file_text_edit_executor_1.applyTextChanges)(sourceText, fileEdit.textChanges) : sourceText;
+        const organized = parseImportEntries(project.ts, sourceFile, organizedText);
+        const bySpecifier = new Map();
+        for (const item of organized)
+            bySpecifier.set(item.moduleSpecifier, [...(bySpecifier.get(item.moduleSpecifier) ?? []), item]);
+        const unusedImports = [];
+        for (const item of original) {
+            const remaining = bindingNames(bySpecifier.get(item.moduleSpecifier) ?? []);
+            const removedBindings = [];
+            if (item.defaultImport && !remaining.defaults.has(item.defaultImport))
+                removedBindings.push({ kind: "default", name: item.defaultImport });
+            if (item.namespaceImport && !remaining.namespaces.has(item.namespaceImport))
+                removedBindings.push({ kind: "namespace", name: item.namespaceImport });
+            for (const name of item.namedImports)
+                if (!remaining.named.has(name))
+                    removedBindings.push({ kind: "named", name });
+            if (removedBindings.length > 0) {
+                const matching = bySpecifier.get(item.moduleSpecifier) ?? [];
+                const replacementPreview = matching.map((entry) => entry.text).join("\n");
+                unusedImports.push({
+                    moduleSpecifier: item.moduleSpecifier,
+                    isTypeOnly: item.isTypeOnly,
+                    importRemoved: replacementPreview.length === 0,
+                    removedBindings,
+                    originalText: item.text,
+                    replacementPreview,
+                    range: item.range
+                });
+            }
+        }
+        return {
+            ok: true,
+            sourceFile: path.normalize(sourceFile),
+            configFilePath: project.configFilePath,
+            unusedImportCount: unusedImports.length,
+            unusedImports
+        };
+    }
+    finally {
+        project.dispose();
+    }
+}
+function addMissing(root, payload, rules) {
+    const scope = resolveInside(root, readString(payload.scope));
+    if (!scope)
+        return { ok: false, code: "ADD_MISSING_IMPORTS_SCOPE_REQUIRED", error: "imports addMissing expects scope." };
+    if (!isPathPresent(scope))
+        return { ok: false, code: "ADD_MISSING_IMPORTS_SCOPE_NOT_FOUND", error: `Scope not found: ${scope}` };
+    const execute = payload.execute === true;
+    const files = collectSourceFiles(scope);
+    const rows = files.map((file) => planCombinedFix(root, file, rules));
+    const failed = rows.filter((row) => row.ok === false);
+    if (execute && failed.length === 0) {
+        for (const row of rows) {
+            const edits = readFileTextChanges(row.internalFileTextChanges);
+            if (edits.length === 0)
+                continue;
+            const expected = new Map(edits.map((edit) => [path.normalize(edit.fileName), fs.readFileSync(edit.fileName, "utf8")]));
+            const applied = (0, file_text_edit_executor_1.applyTextOnlyFileCodeEditsDirectly)(edits, fs, expected);
+            if (!applied.ok) {
+                row.ok = false;
+                row.code = applied.code;
+                row.error = applied.error;
+                break;
+            }
+            row.applied = true;
+            row.savedFiles = applied.touchedFiles;
+        }
+    }
+    const changedFiles = rows.filter((row) => numberField(row, "editCount") > 0).map((row) => row.file).filter((file) => typeof file === "string");
+    return {
+        ok: rows.every((row) => row.ok !== false),
+        execute,
+        scope,
+        fileCount: files.length,
+        changedFileCount: changedFiles.length,
+        editCount: rows.reduce((sum, row) => sum + numberField(row, "editCount"), 0),
+        actionCount: rows.reduce((sum, row) => sum + numberField(row, "actionCount"), 0),
+        changedFiles,
+        files: rows.map(stripInternal),
+        ...(failed.length > 0 ? { failedCount: failed.length } : {})
+    };
+}
+function planCombinedFix(root, file, rules) {
+    try {
+        const project = (0, standalone_ts_project_1.createStandaloneTsProject)(root, file);
+        try {
+            const fix = project.languageService.getCombinedCodeFix({ type: "file", fileName: file }, "fixMissingImport", (0, standalone_ts_project_1.defaultFormatOptions)(), importPreferences(root, file, rules));
+            const changes = fix.changes ?? [];
+            return {
+                ok: true,
+                file,
+                actionCount: changes.length > 0 ? 1 : 0,
+                actionTitles: changes.length > 0 ? ["Add all missing imports"] : [],
+                provider: changes.length > 0 ? "typescript-combined-code-fix" : "none",
+                editCount: changes.reduce((sum, item) => sum + item.textChanges.length, 0),
+                touchedFiles: changes.map((item) => path.normalize(item.fileName)),
+                edits: serializeEdits(changes),
+                internalFileTextChanges: serializeInternal(changes)
+            };
+        }
+        finally {
+            project.dispose();
+        }
+    }
+    catch (error) {
+        return { ok: false, file, code: readErrorCode(error, "ADD_MISSING_IMPORTS_FILE_FAILED"), error: errorMessage(error) };
+    }
+}
+function declarationAddMissing(root, payload, rules) {
+    const files = readStrings(payload.files).map((file) => resolveInside(root, file)).filter((file) => Boolean(file));
+    const selectors = readStrings(payload.selectors);
+    const preferFiles = readStrings(payload.preferFiles).map((file) => resolveInside(root, file)).filter((file) => Boolean(file));
+    const excludeFiles = readStrings(payload.excludeFiles).map((file) => resolveInside(root, file)).filter((file) => Boolean(file));
+    const execute = payload.execute === true;
+    const rows = [];
+    const filesWritten = new Set();
+    const selectedSourceFiles = new Set();
+    const cache = new Map();
+    try {
+        for (const file of files) {
+            if (rows.some((row) => row.ok === false))
+                break;
+            const row = planDeclarationFile(root, file, selectors, preferFiles, excludeFiles, rules, cache);
+            rows.push(row);
+            for (const item of addedImportItems(row)) {
+                if (typeof item.source === "string")
+                    selectedSourceFiles.add(item.source);
+            }
+            if (!execute || row.ok === false)
+                continue;
+            const edits = readFileTextChanges(row.internalFileTextChanges);
+            if (edits.length === 0)
+                continue;
+            const expected = new Map(edits.map((edit) => [path.normalize(edit.fileName), fs.readFileSync(edit.fileName, "utf8")]));
+            const applied = (0, file_text_edit_executor_1.applyTextOnlyFileCodeEditsDirectly)(edits, fs, expected);
+            if (!applied.ok) {
+                row.ok = false;
+                row.code = applied.code;
+                row.error = applied.error;
+                break;
+            }
+            for (const touched of applied.touchedFiles)
+                filesWritten.add(touched);
+            for (const service of cache.values())
+                service.refresh();
+        }
+    }
+    finally {
+        for (const service of cache.values())
+            service.dispose();
+    }
+    const cleanup = [];
+    if (execute) {
+        for (const file of filesWritten) {
+            const row = removeConfiguredUnusedImports(file, rules);
+            if (row.editCount !== 0 || row.ok === false)
+                cleanup.push(row);
+        }
+    }
+    return {
+        operation: "declaration.addMissing",
+        execute,
+        fileCount: files.length,
+        rows: rows.map(stripInternal),
+        filesWritten: [...filesWritten],
+        touchedFiles: [...filesWritten],
+        cleanup,
+        scannedFiles: [...new Set([...files, ...preferFiles, ...selectedSourceFiles])],
+        selectedSourceFiles: [...selectedSourceFiles]
+    };
+}
+function removeConfiguredUnusedImports(file, rules) {
+    const rule = (0, import_rules_1.resolveImportRuleForFile)(file, rules);
+    if (rule?.unusedImports !== "remove")
+        return { ok: true, phase: "removeUnusedImports", file, editCount: 0 };
+    try {
+        const text = fs.readFileSync(file, "utf8");
+        const source = typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true);
+        const referenced = new Set();
+        let containsJsx = false;
+        const visit = (node) => {
+            if (typescript_1.default.isImportDeclaration(node))
+                return;
+            if (typescript_1.default.isJsxElement(node) || typescript_1.default.isJsxSelfClosingElement(node) || typescript_1.default.isJsxFragment(node))
+                containsJsx = true;
+            if (typescript_1.default.isIdentifier(node))
+                referenced.add(node.text);
+            typescript_1.default.forEachChild(node, visit);
+        };
+        visit(source);
+        if (containsJsx)
+            referenced.add("React");
+        const changes = [];
+        for (const statement of source.statements) {
+            if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteral(statement.moduleSpecifier) || !statement.importClause)
+                continue;
+            const nextText = renderImportWithoutUnused(source, text, statement, referenced);
+            const start = lineStart(source, statement.getStart(source));
+            const end = nextText === null ? includeTrailingBreak(text, statement.getEnd()) : statement.getEnd();
+            const current = text.slice(start, end);
+            const replacement = nextText ?? "";
+            if (current !== replacement)
+                changes.push({ span: { start, length: end - start }, newText: replacement });
+        }
+        if (changes.length === 0)
+            return { ok: true, phase: "removeUnusedImports", file, editCount: 0 };
+        const applied = (0, file_text_edit_executor_1.applyTextOnlyFileCodeEditsDirectly)([{ fileName: file, textChanges: changes }]);
+        return applied.ok
+            ? { ok: true, phase: "removeUnusedImports", file, editCount: changes.length, savedFiles: applied.touchedFiles }
+            : { ok: false, phase: "removeUnusedImports", file, editCount: changes.length, code: applied.code, error: applied.error };
+    }
+    catch (error) {
+        return { ok: false, phase: "removeUnusedImports", file, editCount: 0, error: errorMessage(error) };
+    }
+}
+function renderImportWithoutUnused(source, text, statement, referenced) {
+    const clause = statement.importClause;
+    const defaultName = clause.name?.text;
+    const keepDefault = defaultName && referenced.has(defaultName) ? defaultName : null;
+    const moduleText = text.slice(statement.moduleSpecifier.getStart(source), statement.moduleSpecifier.getEnd());
+    const semicolon = statement.getText(source).trimEnd().endsWith(";") ? ";" : "";
+    const start = lineStart(source, statement.getStart(source));
+    const indent = text.slice(start, statement.getStart(source));
+    const keyword = clause.isTypeOnly ? "import type" : "import";
+    const bindings = clause.namedBindings;
+    if (bindings && typescript_1.default.isNamespaceImport(bindings)) {
+        const keepNamespace = referenced.has(bindings.name.text) ? `* as ${bindings.name.text}` : null;
+        const parts = [keepDefault, keepNamespace].filter((item) => Boolean(item));
+        return parts.length > 0 ? `${indent}${keyword} ${parts.join(", ")} from ${moduleText}${semicolon}` : null;
+    }
+    const named = bindings && typescript_1.default.isNamedImports(bindings)
+        ? bindings.elements.filter((item) => referenced.has(item.name.text)).map((item) => {
+            const imported = item.propertyName ? `${item.propertyName.getText(source)} as ${item.name.getText(source)}` : item.name.getText(source);
+            return !clause.isTypeOnly && item.isTypeOnly ? `type ${imported}` : imported;
+        })
+        : [];
+    const parts = [keepDefault, named.length > 0 ? `{ ${named.join(", ")} }` : null].filter((item) => Boolean(item));
+    return parts.length > 0 ? `${indent}${keyword} ${parts.join(", ")} from ${moduleText}${semicolon}` : null;
+}
+function lineStart(source, offset) {
+    const { line } = source.getLineAndCharacterOfPosition(offset);
+    return typescript_1.default.getPositionOfLineAndCharacter(source, line, 0);
+}
+function includeTrailingBreak(text, end) {
+    if (text.startsWith("\r\n", end))
+        return end + 2;
+    return text[end] === "\n" || text[end] === "\r" ? end + 1 : end;
+}
+function planDeclarationFile(root, file, requestedSelectors, preferFiles, excludeFiles, rules, cache) {
+    if (!isPathPresent(file))
+        return { file, ok: false, code: "DECLARATION_TARGET_NOT_FOUND", error: "Target file does not exist." };
+    if (!isRegularFile(file))
+        return { file, ok: false, code: "DECLARATION_TARGET_IS_DIRECTORY", error: "Target is a directory." };
+    const text = fs.readFileSync(file, "utf8");
+    if (isCommonJs(file, text))
+        return { file, ok: false, code: "DECLARATION_ADD_MISSING_COMMONJS_UNSUPPORTED", error: "declaration addMissing v1 does not write CommonJS require statements." };
+    const service = cachedProject(root, file, cache);
+    const missing = collectMissing(service.languageService.getSemanticDiagnostics(file));
+    const selectors = requestedSelectors.length > 0 ? [...requestedSelectors] : [...new Set(missing.map((item) => item.selector))];
+    const addedImports = [];
+    const changes = [];
+    const unchangedSelectors = [];
+    for (const selector of selectors) {
+        const diagnostic = missing.find((item) => item.selector === selector);
+        if (!diagnostic) {
+            unchangedSelectors.push(selector);
+            continue;
+        }
+        const candidates = completionCandidates(service, root, file, diagnostic, selector, rules)
+            .filter((item) => item.sourceFile && !excludeFiles.some((excluded) => fileKey(excluded) === fileKey(item.sourceFile)));
+        const selected = selectCandidate(candidates, preferFiles);
+        if (!selected) {
+            if (candidates.length > 1 && preferFiles.length === 0) {
+                return { file, ok: false, selectors, failedSelector: selector, code: "DECLARATION_ADD_MISSING_AMBIGUOUS_SOURCE", error: `Selector ${selector} has several auto-import candidates. Pass prefer=[...] to choose one.`, unchangedSelectors, addedImports };
+            }
+            unchangedSelectors.push(selector);
+            continue;
+        }
+        changes.push(...selected.changes);
+        const items = selected.changes.flatMap((edit) => edit.textChanges.map((change) => ({
+            selector,
+            file,
+            source: selected.sourceFile,
+            moduleSpecifier: selected.moduleSpecifier,
+            start: change.span.start,
+            end: change.span.start + change.span.length,
+            newText: change.newText,
+            editCount: selected.changes.reduce((sum, item) => sum + item.textChanges.length, 0),
+            provider: "ts-completion"
+        })));
+        addedImports.push({ selector, file, source: selected.sourceFile, moduleSpecifier: selected.moduleSpecifier, start: items[0]?.start ?? 0, end: items[0]?.end ?? 0, newText: items.map((item) => item.newText).join(""), items });
+    }
+    return { file, ok: true, selectors, addedImports, unchangedSelectors, internalFileTextChanges: serializeInternal(changes) };
+}
+function cachedProject(root, file, cache) {
+    const created = (0, standalone_ts_project_1.createStandaloneTsProject)(root, file);
+    const cached = cache.get(fileKey(created.configFilePath));
+    if (cached) {
+        created.dispose();
+        return cached;
+    }
+    cache.set(fileKey(created.configFilePath), created);
+    return created;
+}
+function completionCandidates(project, root, file, diagnostic, selector, rules) {
+    const position = diagnostic.start + diagnostic.length;
+    const preferences = importPreferences(root, file, rules);
+    const format = (0, standalone_ts_project_1.defaultFormatOptions)();
+    const completions = project.languageService.getCompletionsAtPosition(file, position, {
+        ...preferences,
+        includeCompletionsForModuleExports: true,
+        includeExternalModuleExports: true,
+        includeCompletionsWithInsertText: true,
+        triggerKind: 1
+    }, format);
+    return (completions?.entries ?? []).filter((entry) => entry.name === selector && entry.hasAction).flatMap((entry) => {
+        const details = project.languageService.getCompletionEntryDetails(file, position, entry.name, format, entry.source, preferences, entry.data);
+        const changes = details?.codeActions?.flatMap((action) => action.changes ?? []) ?? [];
+        if (changes.length === 0)
+            return [];
+        return [{
+                sourceFile: completionData(entry.data, "fileName"),
+                moduleSpecifier: completionData(entry.data, "moduleSpecifier") ?? entry.source ?? null,
+                changes
+            }];
+    });
+}
+function importPreferences(root, file, rules, allowWorkspaceFallback = true) {
+    const base = (0, standalone_ts_project_1.defaultUserPreferences)();
+    const rule = (0, import_rules_1.resolveImportRuleForFile)(file, rules);
+    const workspace = allowWorkspaceFallback && !rule ? (0, typescript_preferences_1.resolveWorkspaceImportPreferences)((0, typescript_preferences_1.readWorkspaceTypeScriptPreferences)(root), file) : {};
+    return {
+        ...base,
+        ...(rule?.specifier ? { importModuleSpecifierPreference: rule.specifier } : workspace.specifier ? { importModuleSpecifierPreference: workspace.specifier } : {}),
+        ...(rule?.ending ? { importModuleSpecifierEnding: rule.ending } : workspace.ending ? { importModuleSpecifierEnding: workspace.ending } : {})
+    };
+}
+function selectCandidate(candidates, preferFiles) {
+    for (const prefer of preferFiles) {
+        const match = candidates.find((item) => item.sourceFile && fileKey(item.sourceFile) === fileKey(prefer));
+        if (match)
+            return match;
+    }
+    return preferFiles.length > 0 ? null : candidates.length === 1 ? candidates[0] : null;
+}
+function collectMissing(diagnostics) {
+    return diagnostics.flatMap((diagnostic) => {
+        if ((diagnostic.code !== 2304 && diagnostic.code !== 2552) || typeof diagnostic.start !== "number" || typeof diagnostic.length !== "number")
+            return [];
+        const message = typescript_1.default.flattenDiagnosticMessageText(diagnostic.messageText, "\n");
+        const selector = message.match(/Cannot find name '([^']+)'/)?.[1] ?? message.match(/Did you mean '([^']+)'/)?.[1] ?? "";
+        return selector ? [{ selector, start: diagnostic.start, length: diagnostic.length }] : [];
+    });
+}
+function moduleEdge(compiler, node) {
+    if (compiler.isImportDeclaration(node) && compiler.isStringLiteral(node.moduleSpecifier))
+        return { specifier: node.moduleSpecifier.text, kind: "import", node: node.moduleSpecifier };
+    if (compiler.isExportDeclaration(node) && node.moduleSpecifier && compiler.isStringLiteral(node.moduleSpecifier))
+        return { specifier: node.moduleSpecifier.text, kind: "export", node: node.moduleSpecifier };
+    if (compiler.isImportEqualsDeclaration(node) && compiler.isExternalModuleReference(node.moduleReference) && node.moduleReference.expression && compiler.isStringLiteral(node.moduleReference.expression))
+        return { specifier: node.moduleReference.expression.text, kind: "importEquals", node: node.moduleReference.expression };
+    return null;
+}
+function parseImportEntries(compiler, file, text) {
+    const source = compiler.createSourceFile(file, text, compiler.ScriptTarget.Latest, true);
+    return source.statements.flatMap((statement) => {
+        if (!compiler.isImportDeclaration(statement) || !compiler.isStringLiteral(statement.moduleSpecifier))
+            return [];
+        const clause = statement.importClause;
+        const start = source.getLineAndCharacterOfPosition(statement.getStart(source));
+        const end = source.getLineAndCharacterOfPosition(statement.getEnd());
+        return [{
+                moduleSpecifier: statement.moduleSpecifier.text,
+                isTypeOnly: clause?.isTypeOnly === true,
+                defaultImport: clause?.name?.text ?? null,
+                namespaceImport: clause?.namedBindings && compiler.isNamespaceImport(clause.namedBindings) ? clause.namedBindings.name.text : null,
+                namedImports: clause?.namedBindings && compiler.isNamedImports(clause.namedBindings) ? clause.namedBindings.elements.map((item) => item.name.text) : [],
+                range: {
+                    start: { line: start.line, character: start.character },
+                    end: { line: end.line, character: end.character }
+                },
+                text: statement.getText(source)
+            }];
+    });
+}
+function bindingNames(entries) {
+    return {
+        defaults: new Set(entries.flatMap((item) => item.defaultImport ? [item.defaultImport] : [])),
+        namespaces: new Set(entries.flatMap((item) => item.namespaceImport ? [item.namespaceImport] : [])),
+        named: new Set(entries.flatMap((item) => item.namedImports))
+    };
+}
+function serializeInternal(changes) {
+    return changes.map((edit) => ({ fileName: path.normalize(edit.fileName), textChanges: edit.textChanges.map((change) => ({ span: { start: change.span.start, length: change.span.length }, newText: change.newText })) }));
+}
+function serializeEdits(changes) {
+    return changes.map((edit) => ({
+        file: path.normalize(edit.fileName),
+        editCount: edit.textChanges.length,
+        textEdits: edit.textChanges.map((change) => ({
+            span: { start: change.span.start, length: change.span.length },
+            newTextPreview: change.newText.length > 300 ? `${change.newText.slice(0, 300)}...` : change.newText
+        }))
+    }));
+}
+function readFileTextChanges(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap((item) => {
+        if (!isRecord(item) || typeof item.fileName !== "string" || !Array.isArray(item.textChanges))
+            return [];
+        const textChanges = item.textChanges.flatMap((change) => {
+            if (!isRecord(change) || !isRecord(change.span) || typeof change.span.start !== "number" || typeof change.span.length !== "number" || typeof change.newText !== "string")
+                return [];
+            return [{ span: { start: change.span.start, length: change.span.length }, newText: change.newText }];
+        });
+        return [{ fileName: path.normalize(item.fileName), textChanges }];
+    });
+}
+function addedImportItems(row) {
+    return Array.isArray(row.addedImports) ? row.addedImports.filter(isRecord).flatMap((group) => Array.isArray(group.items) ? group.items.filter(isRecord) : [group]) : [];
+}
+function stripInternal(row) {
+    return Object.fromEntries(Object.entries(row).filter(([key]) => key !== "internalFileTextChanges"));
+}
+function collectSourceFiles(scope) {
+    const stat = fs.statSync(scope);
+    if (stat.isFile())
+        return isSourceFile(scope) ? [path.normalize(scope)] : [];
+    if (!stat.isDirectory())
+        return [];
+    const files = [];
+    for (const entry of fs.readdirSync(scope, { withFileTypes: true })) {
+        if (["node_modules", ".git", "dist", "out", "build", ".tmp"].includes(entry.name))
+            continue;
+        const child = path.join(scope, entry.name);
+        if (entry.isDirectory())
+            files.push(...collectSourceFiles(child));
+        else if (entry.isFile() && isSourceFile(child))
+            files.push(path.normalize(child));
+    }
+    return files.sort();
+}
+function isSourceFile(file) { return /\.(tsx?|jsx?)$/i.test(file) && !file.endsWith(".d.ts"); }
+function isCommonJs(file, text) { return /\.(?:cjs|cts)$/i.test(file) || /\bmodule\.exports\b|\brequire\s*\(/.test(text); }
+function isPathPresent(file) { try {
+    fs.statSync(file);
+    return true;
+}
+catch {
+    return false;
+} }
+function isRegularFile(file) { try {
+    return fs.statSync(file).isFile();
+}
+catch {
+    return false;
+} }
+function fileKey(file) { const normalized = path.normalize(file); return typescript_1.default.sys.useCaseSensitiveFileNames ? normalized : normalized.toLowerCase(); }
+function readString(value) { return typeof value === "string" && value.trim() ? value : null; }
+function readStrings(value) { return Array.isArray(value) ? value.filter((item) => typeof item === "string" && item.trim().length > 0) : []; }
+function numberField(value, key) { return typeof value[key] === "number" ? value[key] : 0; }
+function isRecord(value) { return Boolean(value && typeof value === "object" && !Array.isArray(value)); }
+function completionData(value, key) { return isRecord(value) && typeof value[key] === "string" ? value[key] : null; }
+function errorMessage(error) { return error instanceof Error ? error.message : String(error); }
+function readErrorCode(error, fallback) { return error instanceof Error && typeof error.code === "string" ? error.code : fallback; }
+function resolveInside(root, value) {
+    if (!value)
+        return null;
+    const workspace = path.resolve(root);
+    const result = path.resolve(workspace, value);
+    const relative = path.relative(workspace, result);
+    return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative)) ? path.normalize(result) : null;
+}

package/dist/imports/standalone-import-model.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/imports/standalone-import-process.js

@@ -0,0 +1,66 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runStandaloneImportWorker = runStandaloneImportWorker;
+const node_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
+const owned_one_shot_process_1 = require("../workers/owned-one-shot-process");
+async function runStandaloneImportWorker(input) {
+    const request = {
+        type: "standaloneImportRequest",
+        id: `imports_${(0, node_crypto_1.randomUUID)().replace(/-/g, "")}`,
+        operation: input.operation,
+        workspaceRoot: path.resolve(input.workspaceRoot),
+        payload: input.payload,
+        importRules: [...(input.importRules ?? [])]
+    };
+    const result = await (0, owned_one_shot_process_1.runOwnedOneShotWorker)({
+        request,
+        workerPath: input.workerPath ?? path.join(__dirname, "standalone-import-worker.js"),
+        deadlineMs: input.deadlineMs ?? 180_000,
+        errorPrefix: "STANDALONE_IMPORT",
+        label: "Standalone import worker",
+        lifecycleReason: "standalone-import-worker",
+        validateResult: (raw, pid) => isResult(raw, request, pid) ? raw : null
+    });
+    return result.result;
+}
+function isResult(raw, request, pid) {
+    if (!raw || typeof raw !== "object" || Array.isArray(raw))
+        return false;
+    const value = raw;
+    return value.type === "standaloneImportResult" && value.id === request.id && value.operation === request.operation && value.pid === pid &&
+        typeof value.ok === "boolean" && Boolean(value.result && typeof value.result === "object" && !Array.isArray(value.result));
+}