@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/imports-rebase.js

@@ -0,0 +1,1138 @@
+"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.runImportsRebase = runImportsRebase;
+const crypto = __importStar(require("node:crypto"));
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const typescript_1 = __importDefault(require("typescript"));
+const import_rules_1 = require("../config/import-rules");
+const path_aliases_1 = require("../config/path-aliases");
+const workspace_root_1 = require("../config/workspace-root");
+const agent_text_1 = require("../shared/agent-text");
+const errors_1 = require("../shared/errors");
+const targeted_import_canonicalizer_1 = require("../mutation/targeted-import-canonicalizer");
+const workspace_cache_1 = require("./workspace-cache");
+const SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+const BARREL_INDEX_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+const EXCLUDED_DIRS = new Set(["node_modules", ".git", "dist", "out", "build", ".tmp"]);
+function runImportsRebase(cwd, restArgs, payload) {
+    const action = readAction(restArgs[0]);
+    if (action === "apply") {
+        const planId = restArgs[1];
+        if (!planId || planId.startsWith("--")) {
+            throw new errors_1.CliError("IMPORT_REBASE_PLAN_REQUIRED", "imports rebase apply expects a preview id.");
+        }
+        return applyImportRebasePlan(cwd, planId);
+    }
+    const request = normalizeImportRebaseRequest(payload, action);
+    const response = runImportRebaseRequest(cwd, request);
+    return (0, agent_text_1.attachAgentText)(response, formatImportRebaseText(response));
+}
+function runImportRebaseRequest(cwd, request) {
+    const barrel = resolveBarrel(cwd, request.barrel, request.displayBarrel);
+    const files = request.files.length > 0
+        ? request.files.map((file) => resolveInputPath(cwd, file)).filter((file) => isSourceFile(file))
+        : collectSourceFiles(resolveInputPath(cwd, request.scope ?? ""), cwd, request.pathExclude);
+    const programContext = createImportRebaseProgram(cwd, [barrel.file, ...files]);
+    const barrelGraphFiles = collectBarrelGraphFiles(cwd, barrel.file, programContext);
+    const exports = collectBarrelExports(cwd, barrel.file, request.symbols, programContext);
+    const plan = buildImportRebasePlan(cwd, request, barrel, exports, files, barrelGraphFiles, programContext);
+    if (request.operation === "imports.useBarrel" && plan.exports.length === 0) {
+        throw new errors_1.CliError("IMPORT_REBASE_BARREL_EXPORTS_NOT_FOUND", "Barrel has no usable named exports for this request.", {
+            barrel: toDisplayPath(cwd, barrel.file),
+            ...(request.symbols.length > 0 ? { symbols: request.symbols } : {})
+        });
+    }
+    if (request.operation === "imports.useDirect" && plan.exports.length === 0) {
+        throw new errors_1.CliError("IMPORT_REBASE_DIRECT_EXPORTS_NOT_FOUND", "Barrel has no usable source exports for this request.", {
+            barrel: toDisplayPath(cwd, barrel.file),
+            ...(request.symbols.length > 0 ? { symbols: request.symbols } : {})
+        });
+    }
+    if (request.operation === "imports.useBarrel" || request.operation === "imports.useDirect") {
+        const missingSymbols = request.symbols.filter((symbol) => !plan.exports.some((item) => item.name === symbol));
+        for (const symbol of missingSymbols) {
+            plan.skipped.push({ selector: symbol, reason: "not exported by barrel" });
+        }
+    }
+    if (request.action === "execute") {
+        applyImportRebaseEdits(cwd, plan.edits);
+    }
+    const response = buildImportRebaseResponse(cwd, request, plan);
+    if (request.action === "preview" && plan.edits.length > 0) {
+        const planId = buildImportRebasePlanId(cwd, plan);
+        writeImportRebasePlan(cwd, {
+            planId,
+            createdAt: new Date().toISOString(),
+            cwd,
+            request,
+            barrel,
+            exports: plan.exports,
+            barrelGraphFiles: plan.barrelGraphFiles,
+            files: hashPlanFiles(cwd, plan),
+            edits: plan.edits,
+            skipped: plan.skipped,
+            scannedFiles: plan.scannedFiles
+        });
+        response.planId = planId;
+        response.next = `aib mutate apply ${planId}`;
+    }
+    return response;
+}
+function applyImportRebasePlan(cwd, planId) {
+    const record = readImportRebasePlan(cwd, planId);
+    const staleFiles = Object.entries(record.files)
+        .filter(([file, hash]) => {
+        const fullPath = path.resolve(cwd, file);
+        return !fs.existsSync(fullPath) || sha256(fs.readFileSync(fullPath)) !== hash;
+    })
+        .map(([file]) => file);
+    if (staleFiles.length > 0) {
+        throw new errors_1.CliError("IMPORT_REBASE_PLAN_STALE", `imports rebase plan is stale: ${planId}`, {
+            planId,
+            staleFiles: staleFiles.slice(0, 20),
+            ...(staleFiles.length > 20 ? { hidden: `+ ${staleFiles.length - 20} more stale files` } : {})
+        });
+    }
+    applyImportRebaseEdits(cwd, record.edits);
+    const response = buildImportRebaseResponse(cwd, { ...record.request, action: "apply" }, {
+        barrel: record.barrel,
+        exports: record.exports,
+        barrelGraphFiles: record.barrelGraphFiles,
+        edits: record.edits,
+        skipped: record.skipped,
+        scannedFiles: record.scannedFiles
+    });
+    response.planId = planId;
+    return (0, agent_text_1.attachAgentText)(response, formatImportRebaseText(response));
+}
+function buildImportRebasePlan(cwd, request, barrel, exports, files, barrelGraphFiles, programContext) {
+    const barrelGraphKeys = new Set(barrelGraphFiles.map((file) => path.resolve(file)));
+    const byName = groupExportsByName(exports);
+    const sourceToExports = new Map();
+    for (const item of exports) {
+        if (item.importKind !== "named") {
+            continue;
+        }
+        const byImportedName = sourceToExports.get(path.resolve(item.sourceFile)) ?? new Map();
+        byImportedName.set(item.importedName, item);
+        sourceToExports.set(path.resolve(item.sourceFile), byImportedName);
+    }
+    const edits = [];
+    const skipped = [];
+    for (const file of files) {
+        if (request.operation === "imports.useBarrel" && barrelGraphKeys.has(path.resolve(file))) {
+            skipped.push({
+                file: toDisplayPath(cwd, file),
+                reason: path.resolve(file) === path.resolve(barrel.file)
+                    ? "barrel file skipped"
+                    : "inside barrel export graph"
+            });
+            continue;
+        }
+        const fileEdits = collectFileRebaseEdits(cwd, file, request, barrel, byName, sourceToExports, skipped, programContext);
+        edits.push(...fileEdits);
+    }
+    return {
+        barrel,
+        exports,
+        barrelGraphFiles: barrelGraphFiles.map((file) => toDisplayPath(cwd, file)),
+        edits,
+        skipped,
+        scannedFiles: files.map((file) => toDisplayPath(cwd, file))
+    };
+}
+function collectFileRebaseEdits(cwd, file, request, barrel, byName, sourceToExports, skipped, programContext) {
+    const text = fs.readFileSync(file, "utf8");
+    const parsed = createSourceFile(file, text);
+    const edits = [];
+    for (const statement of parsed.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)) {
+            continue;
+        }
+        const importClause = statement.importClause;
+        const specifier = statement.moduleSpecifier.text;
+        if (!importClause) {
+            if (importMayBeRelevant(cwd, file, specifier, request, barrel, sourceToExports, programContext)) {
+                skipped.push({ file: toDisplayPath(cwd, file), specifier, reason: "side-effect import unsupported" });
+            }
+            continue;
+        }
+        if (importClause.name && !importClause.namedBindings) {
+            if (importMayBeRelevant(cwd, file, specifier, request, barrel, sourceToExports, programContext)) {
+                skipped.push({ file: toDisplayPath(cwd, file), specifier, reason: "default import unsupported" });
+            }
+            continue;
+        }
+        if (importClause.name && importClause.namedBindings) {
+            if (importMayBeRelevant(cwd, file, specifier, request, barrel, sourceToExports, programContext)) {
+                skipped.push({ file: toDisplayPath(cwd, file), specifier, reason: "default import unsupported" });
+            }
+            continue;
+        }
+        const bindings = importClause.namedBindings;
+        if (!bindings || typescript_1.default.isNamespaceImport(bindings)) {
+            if (importMayBeRelevant(cwd, file, specifier, request, barrel, sourceToExports, programContext)) {
+                skipped.push({ file: toDisplayPath(cwd, file), specifier, reason: "namespace import unsupported" });
+            }
+            continue;
+        }
+        if (hasAmbiguousTargetImportComments(text, parsed, statement) && importMayBeRelevant(cwd, file, specifier, request, barrel, sourceToExports, programContext)) {
+            skipped.push({ file: toDisplayPath(cwd, file), specifier, reason: "import comments require preserving this declaration" });
+            continue;
+        }
+        if (request.operation === "imports.useBarrel") {
+            edits.push(...collectUseBarrelImportEdits(cwd, file, text, statement, bindings, specifier, barrel, sourceToExports, request, skipped, programContext));
+        }
+        else {
+            edits.push(...collectUseDirectImportEdits(cwd, file, text, statement, bindings, specifier, barrel, byName, request, skipped, programContext));
+        }
+    }
+    return edits;
+}
+function collectUseBarrelImportEdits(cwd, file, text, statement, bindings, specifier, barrel, sourceToExports, request, skipped, programContext) {
+    const resolved = resolveSpecifier(cwd, file, specifier, programContext);
+    if (!resolved) {
+        return [];
+    }
+    const exportsByImportedName = sourceToExports.get(path.resolve(resolved));
+    if (!exportsByImportedName || path.resolve(resolved) === path.resolve(barrel.file)) {
+        return [];
+    }
+    const eligible = bindings.elements
+        .map((element) => {
+        const importedName = element.propertyName?.text ?? element.name.text;
+        const barrelExport = exportsByImportedName.get(importedName);
+        return barrelExport ? { element, barrelExport } : null;
+    })
+        .filter((item) => Boolean(item));
+    if (eligible.length === 0) {
+        return [];
+    }
+    const eligibleElements = new Set(eligible.map((item) => item.element));
+    const ineligible = bindings.elements.filter((element) => !eligibleElements.has(element));
+    const targetSpecifier = barrel.importSpecifierHint ?? (0, targeted_import_canonicalizer_1.chooseTargetedImportSpecifier)({
+        cwd,
+        fromFile: file,
+        targetFile: barrel.file,
+        allowIndexCollapse: true,
+        importRules: programContext.importRules,
+        tsConfigCache: programContext.tsConfigCache
+    });
+    const replacement = buildReplacementImportTextWithPreparedElements(text, statement, importClauseIsTypeOnly(statement), eligible.map((item) => ({
+        selector: item.barrelExport.name,
+        text: formatBarrelImportSpecifier(item.element, item.barrelExport)
+    })), ineligible, targetSpecifier, specifier);
+    return [{
+            file: toDisplayPath(cwd, file),
+            from: specifier,
+            to: targetSpecifier,
+            symbols: eligible.map((item) => item.barrelExport.name),
+            matchSymbols: eligible.map((item) => item.element.propertyName?.text ?? item.element.name.text),
+            declarationText: replacement
+        }];
+}
+function collectUseDirectImportEdits(cwd, file, text, statement, bindings, specifier, barrel, byName, request, skipped, programContext) {
+    const resolved = resolveSpecifier(cwd, file, specifier, programContext);
+    if (!resolved || path.resolve(resolved) !== path.resolve(barrel.file)) {
+        return [];
+    }
+    const byTarget = new Map();
+    const remaining = [];
+    for (const element of bindings.elements) {
+        const name = element.propertyName?.text ?? element.name.text;
+        if (!symbolAllowed(request, name)) {
+            remaining.push(element);
+            continue;
+        }
+        const candidates = byName.get(name) ?? [];
+        if (candidates.length === 0) {
+            skipped.push({ file: toDisplayPath(cwd, file), selector: name, specifier, reason: "not exported by barrel" });
+            remaining.push(element);
+            continue;
+        }
+        const directCandidates = uniqueBy(candidates.filter((item) => path.resolve(item.sourceFile) !== path.resolve(barrel.file)), (item) => path.resolve(item.sourceFile));
+        if (directCandidates.length !== 1) {
+            skipped.push({
+                file: toDisplayPath(cwd, file),
+                selector: name,
+                specifier,
+                reason: directCandidates.length > 1 ? "ambiguous barrel source" : "direct source unavailable",
+                ...(directCandidates.length > 1 ? { candidates: directCandidates.map((candidate) => toDisplayPath(cwd, candidate.sourceFile)) } : {})
+            });
+            remaining.push(element);
+            continue;
+        }
+        const targetFile = directCandidates[0].sourceFile;
+        const directExport = directCandidates[0];
+        if (directExport.importKind === "default") {
+            skipped.push({ file: toDisplayPath(cwd, file), selector: name, specifier, reason: "default re-export unsupported" });
+            remaining.push(element);
+            continue;
+        }
+        byTarget.set(targetFile, [...(byTarget.get(targetFile) ?? []), {
+                selector: name,
+                text: formatDirectImportSpecifier(element, directExport)
+            }]);
+    }
+    if (byTarget.size === 0) {
+        return [];
+    }
+    const imports = Array.from(byTarget.entries()).map(([targetFile, elements]) => ({
+        targetFile,
+        elements,
+        specifier: (0, targeted_import_canonicalizer_1.chooseTargetedImportSpecifier)({
+            cwd,
+            fromFile: file,
+            targetFile,
+            allowIndexCollapse: false,
+            importRules: programContext.importRules,
+            tsConfigCache: programContext.tsConfigCache
+        })
+    }));
+    const parts = [];
+    if (remaining.length > 0) {
+        parts.push(formatImportDeclaration(text, statement, importClauseIsTypeOnly(statement), remaining, specifier));
+    }
+    for (const item of imports) {
+        parts.push(formatDirectImportDeclaration(text, statement, importClauseIsTypeOnly(statement), item.elements, item.specifier));
+    }
+    return [{
+            file: toDisplayPath(cwd, file),
+            from: specifier,
+            to: imports.map((item) => item.specifier).join(", "),
+            symbols: imports.flatMap((item) => item.elements.map((element) => element.selector)),
+            declarationText: parts.join("\n")
+        }];
+}
+function buildReplacementImportText(fullText, statement, typeOnly, eligible, ineligible, targetSpecifier, originalSpecifier) {
+    const parts = [];
+    if (ineligible.length > 0) {
+        parts.push(formatImportDeclaration(fullText, statement, typeOnly, ineligible, originalSpecifier));
+    }
+    if (eligible.length > 0) {
+        parts.push(formatImportDeclaration(fullText, statement, typeOnly, eligible, targetSpecifier));
+    }
+    return parts.join(detectNewline(fullText));
+}
+function buildReplacementImportTextWithPreparedElements(fullText, statement, typeOnly, eligible, ineligible, targetSpecifier, originalSpecifier) {
+    const parts = [];
+    if (ineligible.length > 0) {
+        parts.push(formatImportDeclaration(fullText, statement, typeOnly, ineligible, originalSpecifier));
+    }
+    if (eligible.length > 0) {
+        parts.push(formatDirectImportDeclaration(fullText, statement, typeOnly, eligible, targetSpecifier));
+    }
+    return parts.join(detectNewline(fullText));
+}
+function formatImportDeclaration(fullText, statement, typeOnly, elements, specifier) {
+    const sourceFile = statement.getSourceFile();
+    return (0, targeted_import_canonicalizer_1.renderTargetedNamedImportLike)({
+        sourceText: fullText,
+        sourceFile,
+        statement,
+        clauseTypeOnly: typeOnly,
+        specifier,
+        elements: elements.map((element) => ({
+            text: element.getText(sourceFile).replace(/^type\s+/, ""),
+            isTypeOnly: typeOnly || element.isTypeOnly
+        }))
+    });
+}
+function formatDirectImportDeclaration(fullText, statement, typeOnly, elements, specifier) {
+    return (0, targeted_import_canonicalizer_1.renderTargetedNamedImportLike)({
+        sourceText: fullText,
+        sourceFile: statement.getSourceFile(),
+        statement,
+        clauseTypeOnly: typeOnly,
+        specifier,
+        elements: elements.map((element) => ({
+            text: element.text.replace(/^type\s+/, ""),
+            isTypeOnly: typeOnly || /^type\s+/.test(element.text)
+        }))
+    });
+}
+function formatDirectImportSpecifier(element, barrelExport) {
+    const localName = element.name.text;
+    const exportedName = barrelExport.name;
+    const importedName = barrelExport.importedName;
+    const prefix = element.isTypeOnly ? "type " : "";
+    if (importedName === exportedName) {
+        return element.getText();
+    }
+    return `${prefix}${importedName}${localName === importedName ? "" : ` as ${localName}`}`;
+}
+function formatBarrelImportSpecifier(element, barrelExport) {
+    const localName = element.name.text;
+    const directImportedName = element.propertyName?.text ?? element.name.text;
+    const exportedName = barrelExport.name;
+    const prefix = element.isTypeOnly ? "type " : "";
+    if (exportedName === directImportedName) {
+        return element.getText();
+    }
+    return `${prefix}${exportedName}${localName === exportedName ? "" : ` as ${localName}`}`;
+}
+function importMayBeRelevant(cwd, file, specifier, request, barrel, sourceToExports, programContext) {
+    const resolved = resolveSpecifier(cwd, file, specifier, programContext);
+    if (!resolved) {
+        return false;
+    }
+    if (request.operation === "imports.useDirect") {
+        return path.resolve(resolved) === path.resolve(barrel.file);
+    }
+    return sourceToExports.has(path.resolve(resolved));
+}
+function detectNewline(text) {
+    return text.includes("\r\n") ? "\r\n" : "\n";
+}
+function hasAmbiguousTargetImportComments(sourceText, sourceFile, statement) {
+    if (/\/\/|\/\*/.test(statement.getText(sourceFile))) {
+        return true;
+    }
+    const lineStart = sourceText.lastIndexOf("\n", Math.max(0, statement.getStart(sourceFile) - 1)) + 1;
+    if (sourceText.slice(lineStart, statement.getStart(sourceFile)).trim().length > 0) {
+        return true;
+    }
+    const lineEnd = sourceText.indexOf("\n", statement.end);
+    return /\/\/|\/\*/.test(sourceText.slice(statement.end, lineEnd < 0 ? sourceText.length : lineEnd));
+}
+function applyImportRebaseEdits(cwd, edits) {
+    const byFile = new Map();
+    for (const edit of edits) {
+        byFile.set(edit.file, [...(byFile.get(edit.file) ?? []), edit]);
+    }
+    for (const [relativeFile, fileEdits] of byFile.entries()) {
+        const fullPath = path.resolve(cwd, relativeFile);
+        let text = fs.readFileSync(fullPath, "utf8");
+        const parsed = createSourceFile(fullPath, text);
+        const replacements = fileEdits.map((edit) => findImportDeclarationReplacement(parsed, edit.from, edit.matchSymbols ?? edit.symbols, edit.declarationText)).filter((item) => Boolean(item));
+        for (const replacement of replacements.sort((left, right) => right.start - left.start)) {
+            text = `${text.slice(0, replacement.start)}${replacement.text}${text.slice(replacement.end)}`;
+        }
+        text = (0, targeted_import_canonicalizer_1.canonicalizeTargetedNamedImports)(text, fullPath).text;
+        fs.writeFileSync(fullPath, text, "utf8");
+    }
+}
+function findImportDeclarationReplacement(parsed, from, symbols, text) {
+    for (const statement of parsed.statements) {
+        if (!typescript_1.default.isImportDeclaration(statement) || !typescript_1.default.isStringLiteralLike(statement.moduleSpecifier) || statement.moduleSpecifier.text !== from) {
+            continue;
+        }
+        const elements = statement.importClause?.namedBindings && typescript_1.default.isNamedImports(statement.importClause.namedBindings)
+            ? statement.importClause.namedBindings.elements.map((element) => element.propertyName?.text ?? element.name.text)
+            : [];
+        if (symbols.every((symbol) => elements.includes(symbol))) {
+            return { start: statement.getStart(parsed), end: statement.end, text };
+        }
+    }
+    return null;
+}
+function buildImportRebaseResponse(cwd, request, plan) {
+    const filesChanged = new Set(plan.edits.map((edit) => edit.file)).size;
+    const response = {
+        ok: true,
+        operation: request.operation,
+        mode: request.action,
+        barrel: toDisplayPath(cwd, plan.barrel.file),
+        requestedBarrel: request.displayBarrel ?? request.barrel,
+        filesScanned: plan.scannedFiles.length,
+        filesChanged,
+        edits: plan.edits.length,
+        symbolsUpdated: plan.edits.reduce((count, edit) => count + edit.symbols.length, 0),
+        exportsConsidered: plan.exports.length,
+        barrelGraphFiles: plan.barrelGraphFiles,
+        ...(request.scope ? { scope: request.scope } : {}),
+        ...(request.files.length > 0 ? { files: request.files } : {}),
+        ...(request.pathExclude.length > 0 ? { pathExclude: request.pathExclude } : {}),
+        ...(request.symbols.length > 0 ? { symbols: request.symbols } : {}),
+        exports: plan.exports.map((item) => ({
+            name: item.name,
+            importedName: item.importedName,
+            sourceFile: toDisplayPath(cwd, item.sourceFile),
+            kind: item.kind,
+            importKind: item.importKind
+        })),
+        skipped: plan.skipped,
+        importEdits: plan.edits.map((edit) => ({
+            file: edit.file,
+            from: edit.from,
+            to: edit.to,
+            symbols: edit.symbols,
+            ...(edit.matchSymbols ? { matchSymbols: edit.matchSymbols } : {})
+        })),
+        samples: plan.edits.slice(0, request.showAll ? plan.edits.length : 12).map((edit) => `${edit.file}: ${edit.from} -> ${edit.to} (${edit.symbols.join(", ")})`),
+        ...(!request.showAll && plan.edits.length > 12 ? { hidden: `+ ${plan.edits.length - 12} more edits` } : {}),
+        filesWritten: request.action === "preview" ? [] : Array.from(new Set(plan.edits.map((edit) => edit.file))),
+        filesTouched: Array.from(new Set(plan.edits.map((edit) => edit.file))),
+        next: request.action === "preview"
+            ? plan.edits.length > 0
+                ? "Apply this mutate preview if the import rebase matches intent."
+                : plan.skipped.length > 0
+                    ? "Review skipped imports; adjust scope/barrel/symbols and rerun if needed."
+                    : "No action needed unless the scope/barrel/symbols are wrong."
+            : "Run typecheck or targeted validation for the affected project."
+    };
+    return response;
+}
+function formatImportRebaseText(response) {
+    const mode = readString(response.mode) ?? "execute";
+    const operation = readString(response.operation) ?? "imports.rebase";
+    const planId = readString(response.planId);
+    const filesChanged = readNumber(response.filesChanged) ?? 0;
+    const edits = readNumber(response.edits) ?? 0;
+    const symbolsUpdated = readNumber(response.symbolsUpdated) ?? 0;
+    const skipped = readObjectArray(response.skipped).length;
+    const barrel = readString(response.barrel);
+    const lines = [];
+    lines.push(mode === "preview" && planId ? `${operation}.preview ${planId}` : mode === "apply" ? `${operation}.apply` : `${operation}.execute`);
+    const action = mode === "preview" ? "planned" : "updated";
+    lines.push(edits === 0 && filesChanged === 0
+        ? "no import boundary changes"
+        : `${action}: ${symbolsUpdated} ${symbolsUpdated === 1 ? "symbol" : "symbols"} in ${edits} ${edits === 1 ? "import" : "imports"}, ${filesChanged} ${filesChanged === 1 ? "file" : "files"}`);
+    if (barrel) {
+        lines.push(`barrel: ${barrel}`);
+    }
+    const exportsConsidered = readNumber(response.exportsConsidered);
+    if (exportsConsidered !== null) {
+        lines.push(`exports: ${exportsConsidered} considered`);
+    }
+    if (skipped > 0) {
+        appendImportRebaseSkippedSummary(lines, readObjectArray(response.skipped));
+    }
+    const samples = readStringArray(response.samples);
+    if (samples.length > 0) {
+        lines.push("samples:");
+        for (const sample of samples.slice(0, 8)) {
+            lines.push(sample);
+        }
+    }
+    const hidden = readString(response.hidden);
+    if (hidden) {
+        lines.push(hidden);
+    }
+    const filesWritten = readStringArray(response.filesWritten);
+    if (filesWritten.length > 0) {
+        lines.push("filesWritten:");
+        for (const file of filesWritten.slice(0, 12)) {
+            lines.push(file);
+        }
+    }
+    const next = readString(response.next);
+    if (next) {
+        lines.push(`next: ${next}`);
+    }
+    return lines.join("\n");
+}
+function resolveBarrel(cwd, rawInput, displayInput) {
+    const hintInput = displayInput ?? rawInput;
+    const importSpecifierHint = hintInput.startsWith("@") ? normalizeAliasImportHint(hintInput) : null;
+    const resolved = resolveInputPath(cwd, rawInput);
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isDirectory()) {
+        const candidates = BARREL_INDEX_EXTENSIONS
+            .map((ext) => path.join(resolved, `index${ext}`))
+            .filter((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile());
+        if (candidates.length !== 1) {
+            throw new errors_1.CliError("IMPORT_REBASE_BARREL_AMBIGUOUS", candidates.length === 0 ? "Barrel directory has no index barrel." : "Barrel directory is ambiguous.", {
+                barrel: rawInput,
+                candidates: candidates.map((candidate) => toDisplayPath(cwd, candidate)),
+                next: "Pass the exact barrel file path."
+            });
+        }
+        const file = candidates[0];
+        return { input: rawInput, file, importSpecifierHint: importSpecifierHint ?? aliasHintForResolvedFile(cwd, file), candidates: candidates.map((candidate) => toDisplayPath(cwd, candidate)) };
+    }
+    const file = resolveImportBase(resolved);
+    if (!file) {
+        throw new errors_1.CliError("IMPORT_REBASE_BARREL_NOT_FOUND", `Barrel file not found: ${rawInput}`, {
+            barrel: rawInput,
+            resolved
+        });
+    }
+    return { input: rawInput, file, importSpecifierHint: importSpecifierHint ?? aliasHintForResolvedFile(cwd, file), candidates: [toDisplayPath(cwd, file)] };
+}
+function collectBarrelExports(cwd, barrelFile, symbols, programContext) {
+    const allowed = new Set(symbols);
+    const all = collectProgramBarrelExports(cwd, barrelFile, programContext);
+    return all.filter((item) => allowed.size === 0 || allowed.has(item.name));
+}
+function appendImportRebaseSkippedSummary(lines, skipped) {
+    lines.push(`skipped: ${skipped.length}`);
+    const barrelGraph = skipped.filter((item) => {
+        const reason = readString(item.reason);
+        return reason === "barrel file skipped" || reason === "inside barrel export graph";
+    });
+    if (barrelGraph.length > 0) {
+        const files = barrelGraph
+            .map((item) => readString(item.file))
+            .filter((file) => file !== null);
+        lines.push(`barrel graph consumers: ${barrelGraph.length} ${barrelGraph.length === 1 ? "file" : "files"}${files.length > 0 ? ` under ${formatCommonPathGlob(files)}` : ""}`);
+    }
+    const other = skipped.filter((item) => !barrelGraph.includes(item));
+    for (const item of other.slice(0, 8)) {
+        const selector = readString(item.selector);
+        const file = readString(item.file);
+        const reason = readString(item.reason) ?? "skipped";
+        lines.push(selector ? `${selector}: ${reason}${file ? ` in ${file}` : ""}` : `${file ?? "item"}: ${reason}`);
+    }
+    if (other.length > 8) {
+        lines.push(`+ ${other.length - 8} more skipped`);
+    }
+}
+function formatCommonPathGlob(files) {
+    if (files.length === 0) {
+        return "**";
+    }
+    const parts = files.map((file) => file.replace(/\\/g, "/").split("/"));
+    const common = [];
+    for (let index = 0;; index += 1) {
+        const value = parts[0]?.[index];
+        if (!value || parts.some((part) => part[index] !== value)) {
+            break;
+        }
+        common.push(value);
+    }
+    if (common.length === 0) {
+        return "**";
+    }
+    const last = common[common.length - 1] ?? "";
+    const hasExtension = /\.[^/.]+$/.test(last);
+    return `${(hasExtension ? common.slice(0, -1) : common).join("/") || "."}/**`;
+}
+function collectProgramBarrelExports(cwd, barrelFile, context) {
+    const sourceFile = context.program.getSourceFile(path.resolve(barrelFile));
+    const moduleSymbol = sourceFile ? context.checker.getSymbolAtLocation(sourceFile) : undefined;
+    if (!sourceFile || !moduleSymbol) {
+        return [];
+    }
+    const exports = [];
+    for (const exportSymbol of context.checker.getExportsOfModule(moduleSymbol)) {
+        const name = exportSymbol.getName();
+        if (name === "default") {
+            continue;
+        }
+        const targetSymbol = isAliasSymbol(exportSymbol)
+            ? context.checker.getAliasedSymbol(exportSymbol)
+            : exportSymbol;
+        const declaration = pickSymbolDeclaration(targetSymbol) ?? pickSymbolDeclaration(exportSymbol);
+        if (!declaration) {
+            continue;
+        }
+        const importedName = readImportedNameForExportSymbol(targetSymbol, declaration);
+        const source = declaration.getSourceFile();
+        exports.push({
+            name,
+            importedName,
+            sourceFile: path.resolve(source.fileName),
+            kind: readExportKind(sourceFile, source),
+            importKind: isDefaultExportSymbol(targetSymbol, declaration) ? "default" : "named",
+            exportText: name
+        });
+    }
+    return uniqueBy(exports, (item) => `${item.name}:${item.importedName}:${path.resolve(item.sourceFile)}`);
+}
+function readExportKind(barrelSourceFile, sourceFile) {
+    return path.resolve(barrelSourceFile.fileName) === path.resolve(sourceFile.fileName) ? "local" : "named";
+}
+function isAliasSymbol(symbol) {
+    return (symbol.flags & typescript_1.default.SymbolFlags.Alias) !== 0;
+}
+function pickSymbolDeclaration(symbol) {
+    return symbol.valueDeclaration ?? symbol.declarations?.[0] ?? null;
+}
+function readImportedNameForExportSymbol(symbol, declaration) {
+    if (isDefaultExportSymbol(symbol, declaration)) {
+        return "default";
+    }
+    const name = symbol.getName();
+    if (name && name !== "__function" && name !== "__class") {
+        return name;
+    }
+    const named = declaration.name;
+    return named && typescript_1.default.isIdentifier(named) ? named.text : name;
+}
+function isDefaultExportSymbol(symbol, declaration) {
+    if (symbol.getName() === "default") {
+        return true;
+    }
+    if (typescript_1.default.canHaveModifiers(declaration) && typescript_1.default.getModifiers(declaration)?.some((modifier) => modifier.kind === typescript_1.default.SyntaxKind.DefaultKeyword)) {
+        return true;
+    }
+    return false;
+}
+function collectBarrelGraphFiles(cwd, barrelFile, programContext) {
+    return Array.from(collectBarrelGraphFileSet(cwd, barrelFile, new Set(), programContext)).sort();
+}
+function collectBarrelGraphFileSet(cwd, sourceFile, seen, programContext) {
+    const normalized = path.resolve(sourceFile);
+    if (seen.has(normalized) || !fs.existsSync(normalized)) {
+        return seen;
+    }
+    seen.add(normalized);
+    const text = fs.readFileSync(normalized, "utf8");
+    const parsed = createSourceFile(normalized, text);
+    const localExportNames = collectLocalExportNames(parsed);
+    for (const statement of parsed.statements) {
+        if (typescript_1.default.isExportDeclaration(statement)) {
+            const targetFile = statement.moduleSpecifier && typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)
+                ? resolveSpecifier(cwd, normalized, statement.moduleSpecifier.text, programContext)
+                : null;
+            if (targetFile) {
+                collectBarrelGraphFileSet(cwd, targetFile, seen, programContext);
+            }
+            continue;
+        }
+        if (localExportNames.size > 0 && typescript_1.default.isImportDeclaration(statement)) {
+            const importedBindings = collectImportBindingNames(statement);
+            if (importedBindings.some((name) => localExportNames.has(name))) {
+                const targetFile = statement.moduleSpecifier && typescript_1.default.isStringLiteralLike(statement.moduleSpecifier)
+                    ? resolveSpecifier(cwd, normalized, statement.moduleSpecifier.text, programContext)
+                    : null;
+                if (targetFile) {
+                    collectBarrelGraphFileSet(cwd, targetFile, seen, programContext);
+                }
+            }
+        }
+    }
+    return seen;
+}
+function collectLocalExportNames(sourceFile) {
+    const names = new Set();
+    for (const statement of sourceFile.statements) {
+        if (!typescript_1.default.isExportDeclaration(statement) || statement.moduleSpecifier || !statement.exportClause) {
+            continue;
+        }
+        if (typescript_1.default.isNamedExports(statement.exportClause)) {
+            for (const element of statement.exportClause.elements) {
+                names.add((element.propertyName ?? element.name).text);
+            }
+        }
+    }
+    return names;
+}
+function collectImportBindingNames(statement) {
+    const bindings = statement.importClause;
+    if (!bindings) {
+        return [];
+    }
+    const names = [];
+    if (bindings.name) {
+        names.push(bindings.name.text);
+    }
+    const namedBindings = bindings.namedBindings;
+    if (namedBindings && typescript_1.default.isNamespaceImport(namedBindings)) {
+        names.push(namedBindings.name.text);
+    }
+    if (namedBindings && typescript_1.default.isNamedImports(namedBindings)) {
+        for (const element of namedBindings.elements) {
+            names.push(element.name.text);
+        }
+    }
+    return names;
+}
+function normalizeImportRebaseRequest(payload, action) {
+    if (!isJsonObject(payload)) {
+        throw new errors_1.CliError("IMPORT_REBASE_PAYLOAD_REQUIRED", "imports.useBarrel/useDirect expects an object payload.");
+    }
+    const operation = readString(payload.operation);
+    if (operation !== "imports.useBarrel" && operation !== "imports.useDirect") {
+        throw new errors_1.CliError("IMPORT_REBASE_OPERATION_UNSUPPORTED", "imports rebase expects operation imports.useBarrel or imports.useDirect.");
+    }
+    const barrel = readString(payload.barrel) ?? readString(payload.target) ?? readString(payload.path);
+    const displayBarrel = readString(payload.displayBarrel);
+    if (!barrel) {
+        throw new errors_1.CliError("IMPORT_REBASE_BARREL_REQUIRED", `${operation} expects a barrel path.`);
+    }
+    const scope = readString(payload.scope);
+    const files = readStringArray(payload.files);
+    if (!scope && files.length === 0) {
+        throw new errors_1.CliError("IMPORT_REBASE_SCOPE_REQUIRED", `${operation} expects @scope or @files.`);
+    }
+    return {
+        operation,
+        barrel,
+        ...(displayBarrel ? { displayBarrel } : {}),
+        ...(scope ? { scope } : {}),
+        files,
+        pathExclude: uniqueStrings([...readStringArray(payload.pathExclude), ...readStringArray(payload.exclude), ...readStringArray(payload.excludes)]),
+        symbols: readStringArray(payload.symbols),
+        showAll: payload.all === true || payload.details === true || payload.details === "all",
+        action
+    };
+}
+function readAction(value) {
+    if (value === "apply" || value === "execute" || value === "preview") {
+        return value;
+    }
+    return "preview";
+}
+function resolveInputPath(cwd, input) {
+    const expanded = (0, path_aliases_1.expandPathAliasValue)(cwd, input, (0, path_aliases_1.readConfigPathAliases)(cwd));
+    if (path.isAbsolute(expanded)) {
+        return path.normalize(expanded);
+    }
+    const workspace = (0, workspace_root_1.resolveWorkspaceRoot)(cwd);
+    return path.resolve(workspace?.root ?? cwd, expanded);
+}
+function createImportRebaseProgram(cwd, focusFiles) {
+    const tsconfig = findNearestTsconfig(cwd, focusFiles[0] ?? cwd);
+    const parsed = tsconfig ? readParsedTsconfig(tsconfig) : null;
+    const options = {
+        ...(parsed?.options ?? {}),
+        allowJs: true,
+        checkJs: false,
+        noEmit: true,
+        skipLibCheck: true,
+        moduleResolution: parsed?.options.moduleResolution ?? typescript_1.default.ModuleResolutionKind.Node10
+    };
+    const rootNames = uniqueStrings([
+        ...focusFiles.map((file) => path.resolve(file)).filter((file) => fs.existsSync(file))
+    ]);
+    const program = typescript_1.default.createProgram(rootNames, options);
+    return {
+        program,
+        checker: program.getTypeChecker(),
+        options,
+        importRules: (0, import_rules_1.readConfigImportRules)(cwd),
+        tsConfigCache: new Map()
+    };
+}
+function findNearestTsconfig(cwd, fromFile) {
+    let current = fs.existsSync(fromFile) && fs.statSync(fromFile).isFile()
+        ? path.dirname(path.resolve(fromFile))
+        : path.resolve(fromFile);
+    const root = path.resolve(cwd);
+    while (current.startsWith(root)) {
+        const candidate = path.join(current, "tsconfig.json");
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return candidate;
+        }
+        const parent = path.dirname(current);
+        if (parent === current) {
+            break;
+        }
+        current = parent;
+    }
+    const rootConfig = path.join(root, "tsconfig.json");
+    return fs.existsSync(rootConfig) ? rootConfig : null;
+}
+function readParsedTsconfig(tsconfig) {
+    const config = typescript_1.default.readConfigFile(tsconfig, typescript_1.default.sys.readFile);
+    if (config.error) {
+        return null;
+    }
+    return typescript_1.default.parseJsonConfigFileContent(config.config, typescript_1.default.sys, path.dirname(tsconfig), {
+        allowJs: true,
+        checkJs: false,
+        noEmit: true
+    }, tsconfig);
+}
+function normalizeAliasImportHint(input) {
+    return input
+        .replace(/\\/g, "/")
+        .replace(/\.(tsx?|jsx?|mjs|cjs|cts|mts)$/i, "")
+        .replace(/\/index$/i, "");
+}
+function aliasHintForResolvedFile(cwd, file) {
+    const workspace = (0, workspace_root_1.resolveWorkspaceRoot)(cwd);
+    const baseDir = workspace?.root ?? cwd;
+    const aliases = (0, path_aliases_1.readConfigPathAliases)(cwd);
+    const fileNoExt = withoutSourceExtension(path.resolve(file));
+    const candidates = Object.entries(aliases).flatMap(([alias, target]) => {
+        const targetNoExt = withoutSourceExtension(path.resolve(baseDir, target));
+        if (fileNoExt === targetNoExt) {
+            return [`@${alias}`];
+        }
+        if (fileNoExt === path.join(targetNoExt, "index")) {
+            return [`@${alias}`];
+        }
+        if (fileNoExt.startsWith(`${targetNoExt}${path.sep}`)) {
+            const suffix = path.relative(targetNoExt, fileNoExt).replace(/\\/g, "/");
+            return [`@${alias}/${suffix.replace(/\/index$/i, "")}`];
+        }
+        return [];
+    });
+    return candidates.sort((left, right) => left.length - right.length || left.localeCompare(right))[0] ?? null;
+}
+function collectSourceFiles(scope, cwd, exclude) {
+    if (!fs.existsSync(scope)) {
+        throw new errors_1.CliError("IMPORT_REBASE_SCOPE_NOT_FOUND", `Scope does not exist: ${scope}`);
+    }
+    if (isExcludedPath(cwd, scope, exclude)) {
+        return [];
+    }
+    const stat = fs.statSync(scope);
+    if (stat.isFile()) {
+        return isSourceFile(scope) ? [scope] : [];
+    }
+    if (!stat.isDirectory()) {
+        return [];
+    }
+    const files = [];
+    for (const entry of fs.readdirSync(scope, { withFileTypes: true })) {
+        const child = path.join(scope, entry.name);
+        if (entry.isDirectory()) {
+            if (!EXCLUDED_DIRS.has(entry.name) && !isExcludedPath(cwd, child, exclude)) {
+                files.push(...collectSourceFiles(child, cwd, exclude));
+            }
+            continue;
+        }
+        if (entry.isFile() && isSourceFile(child) && !isExcludedPath(cwd, child, exclude)) {
+            files.push(child);
+        }
+    }
+    return files.sort();
+}
+function resolveSpecifier(cwd, file, specifier, programContext) {
+    if (programContext) {
+        const resolved = typescript_1.default.resolveModuleName(specifier, path.resolve(file), programContext.options, typescript_1.default.sys).resolvedModule?.resolvedFileName;
+        if (resolved) {
+            const file = resolveImportBase(resolved);
+            if (file) {
+                return file;
+            }
+        }
+    }
+    if (!specifier.startsWith(".")) {
+        if (specifier.startsWith("@")) {
+            try {
+                return resolveImportBase((0, path_aliases_1.expandPathAliasValue)(cwd, specifier, (0, path_aliases_1.readConfigPathAliases)(cwd)));
+            }
+            catch {
+                return null;
+            }
+        }
+        return null;
+    }
+    return resolveImportBase(path.resolve(path.dirname(file), specifier));
+}
+function resolveImportBase(base) {
+    const candidates = new Set();
+    candidates.add(base);
+    const ext = path.extname(base);
+    if (ext && [".js", ".jsx", ".mjs", ".cjs"].includes(ext)) {
+        const withoutExt = base.slice(0, -ext.length);
+        for (const sourceExt of SOURCE_EXTENSIONS) {
+            candidates.add(`${withoutExt}${sourceExt}`);
+        }
+    }
+    if (!ext) {
+        for (const candidateExt of SOURCE_EXTENSIONS) {
+            candidates.add(`${base}${candidateExt}`);
+        }
+    }
+    for (const candidateExt of SOURCE_EXTENSIONS) {
+        candidates.add(path.join(base, `index${candidateExt}`));
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile() && isSourceFile(candidate)) {
+            return path.resolve(candidate);
+        }
+    }
+    return null;
+}
+function createSourceFile(file, text) {
+    return typescript_1.default.createSourceFile(file, text, typescript_1.default.ScriptTarget.Latest, true, scriptKindForFile(file));
+}
+function scriptKindForFile(file) {
+    if (file.endsWith(".tsx"))
+        return typescript_1.default.ScriptKind.TSX;
+    if (file.endsWith(".jsx"))
+        return typescript_1.default.ScriptKind.JSX;
+    if (file.endsWith(".js") || file.endsWith(".mjs") || file.endsWith(".cjs"))
+        return typescript_1.default.ScriptKind.JS;
+    return typescript_1.default.ScriptKind.TS;
+}
+function importClauseIsTypeOnly(statement) {
+    return statement.importClause?.isTypeOnly === true;
+}
+function symbolAllowed(request, name) {
+    return request.symbols.length === 0 || request.symbols.includes(name);
+}
+function groupExportsByName(exports) {
+    const map = new Map();
+    for (const item of exports) {
+        map.set(item.name, [...(map.get(item.name) ?? []), item]);
+    }
+    return map;
+}
+function isSourceFile(file) {
+    return SOURCE_EXTENSIONS.includes(path.extname(file)) && !file.endsWith(".d.ts");
+}
+function withoutSourceExtension(file) {
+    const ext = path.extname(file);
+    return SOURCE_EXTENSIONS.includes(ext) ? file.slice(0, -ext.length) : file;
+}
+function isExcludedPath(cwd, candidate, exclude) {
+    if (exclude.length === 0) {
+        return false;
+    }
+    const relative = toDisplayPath(cwd, path.resolve(candidate));
+    return exclude.some((pattern) => matchesExcludePattern(cwd, relative, pattern));
+}
+function matchesExcludePattern(cwd, relativePath, pattern) {
+    const normalizedPattern = toDisplayPath(cwd, path.isAbsolute(pattern) ? pattern : path.resolve(cwd, pattern));
+    if (!containsGlob(pattern)) {
+        return relativePath === normalizedPattern || relativePath.startsWith(`${normalizedPattern}/`);
+    }
+    return globToRegExp(pattern.replace(/\\/g, "/")).test(relativePath);
+}
+function containsGlob(value) {
+    return /[*?]/.test(value);
+}
+function globToRegExp(pattern) {
+    let source = "";
+    for (let index = 0; index < pattern.length; index += 1) {
+        const char = pattern[index];
+        if (char === "*") {
+            if (pattern[index + 1] === "*") {
+                source += ".*";
+                index += 1;
+            }
+            else {
+                source += "[^/]*";
+            }
+        }
+        else if (char === "?") {
+            source += "[^/]";
+        }
+        else {
+            source += escapeRegExp(char ?? "");
+        }
+    }
+    return new RegExp(`^${source}$`);
+}
+function buildImportRebasePlanId(cwd, plan) {
+    return `imports_rebase_${sha256(stableStringify({ cwd, plan })).slice(0, 8)}`;
+}
+function writeImportRebasePlan(cwd, record) {
+    const filePath = importRebasePlanPath(cwd, record.planId);
+    fs.mkdirSync(path.dirname(filePath), { recursive: true });
+    fs.writeFileSync(filePath, `${JSON.stringify(record, null, 2)}\n`, "utf8");
+}
+function readImportRebasePlan(cwd, planId) {
+    const filePath = importRebasePlanPath(cwd, planId);
+    if (!fs.existsSync(filePath)) {
+        throw new errors_1.CliError("IMPORT_REBASE_PLAN_NOT_FOUND", `imports rebase plan not found: ${planId}`, { planId, expectedPath: filePath });
+    }
+    return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+function importRebasePlanPath(cwd, planId) {
+    return (0, workspace_cache_1.workspaceCachePath)(cwd, "imports-rebase", `${planId.replace(/[^a-z0-9_-]+/gi, "-")}.json`);
+}
+function hashPlanFiles(cwd, plan) {
+    const hashes = {};
+    const files = new Set();
+    files.add(toDisplayPath(cwd, plan.barrel.file));
+    for (const item of plan.exports) {
+        files.add(toDisplayPath(cwd, item.sourceFile));
+    }
+    for (const file of plan.barrelGraphFiles) {
+        files.add(toDisplayPath(cwd, path.resolve(cwd, file)));
+    }
+    for (const edit of plan.edits) {
+        files.add(edit.file);
+    }
+    for (const file of files) {
+        const fullPath = path.resolve(cwd, file);
+        if (fs.existsSync(fullPath)) {
+            hashes[file] = sha256(fs.readFileSync(fullPath));
+        }
+    }
+    return hashes;
+}
+function sha256(value) {
+    return crypto.createHash("sha256").update(value).digest("hex");
+}
+function stableStringify(value) {
+    if (value === null || typeof value !== "object") {
+        return JSON.stringify(value);
+    }
+    if (Array.isArray(value)) {
+        return `[${value.map((item) => stableStringify(item)).join(",")}]`;
+    }
+    return `{${Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, item]) => `${JSON.stringify(key)}:${stableStringify(item)}`)
+        .join(",")}}`;
+}
+function uniqueBy(items, key) {
+    const seen = new Set();
+    const unique = [];
+    for (const item of items) {
+        const value = key(item);
+        if (!seen.has(value)) {
+            seen.add(value);
+            unique.push(item);
+        }
+    }
+    return unique;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() !== "" ? value.trim() : null;
+}
+function readNumber(value) {
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+}
+function readStringArray(value) {
+    if (typeof value === "string" && value.trim() !== "") {
+        return [value.trim()];
+    }
+    if (!Array.isArray(value)) {
+        return [];
+    }
+    return value
+        .filter((item) => typeof item === "string")
+        .map((item) => item.trim())
+        .filter((item) => item.length > 0);
+}
+function readObjectArray(value) {
+    return Array.isArray(value) ? value.filter(isJsonObject) : [];
+}
+function uniqueStrings(items) {
+    return Array.from(new Set(items));
+}
+function isJsonObject(value) {
+    return Boolean(value) && typeof value === "object" && !Array.isArray(value);
+}
+function toDisplayPath(cwd, file) {
+    return path.relative(cwd, file).replace(/\\/g, "/");
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}