@automaton-labs/aib 0.0.6 → 0.0.8

package/dist/commands/import-specifier-policy.js

@@ -0,0 +1,391 @@
+"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.chooseImportSpecifier = chooseImportSpecifier;
+exports.materializeAutoImportEnding = materializeAutoImportEnding;
+exports.resolveImportSpecifier = resolveImportSpecifier;
+exports.formatRelativeImportSpecifier = formatRelativeImportSpecifier;
+exports.toAliasImportSpecifier = toAliasImportSpecifier;
+exports.readNearestTsConfig = readNearestTsConfig;
+exports.parseJsoncObject = parseJsoncObject;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const SOURCE_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts"];
+const IMPORT_EXTENSIONS = [".ts", ".tsx", ".mts", ".cts", ".js", ".jsx", ".mjs", ".cjs"];
+function chooseImportSpecifier(input) {
+    const relative = formatRelativeImportSpecifier(input.fromFile, input.targetFile, input.config, {
+        ending: input.rule?.ending,
+        allowIndexCollapse: input.allowIndexCollapse ?? false
+    });
+    const preference = input.rule?.specifier;
+    if (!preference || preference === "relative") {
+        return relative;
+    }
+    if (preference === "project-relative") {
+        return toProjectRelativeImportSpecifier(input.targetFile, input.config, input.rule?.ending, input.allowIndexCollapse) ?? relative;
+    }
+    const aliasMode = preference === "shortest" ? "shortestAlias" : "alias";
+    const alias = toAliasImportSpecifier(input.targetFile, input.config, undefined, aliasMode, input.allowIndexCollapse);
+    if (!alias) {
+        return relative;
+    }
+    if (preference === "shortest") {
+        return alias.length <= relative.length ? alias : relative;
+    }
+    return alias;
+}
+function materializeAutoImportEnding(rule, observedSpecifier) {
+    if (rule.ending !== "auto")
+        return rule;
+    return {
+        ...rule,
+        ending: /\.(?:[cm]?js|jsx)$/i.test(observedSpecifier) ? "js" : "minimal"
+    };
+}
+function resolveImportSpecifier(file, specifier, config) {
+    if (specifier.startsWith(".")) {
+        return resolveImportBase(path.resolve(path.dirname(file), specifier));
+    }
+    if (!config) {
+        return null;
+    }
+    for (const mapping of config.mappings) {
+        const wildcard = matchPathPattern(specifier, mapping);
+        if (wildcard === null) {
+            continue;
+        }
+        for (const target of mapping.targets) {
+            const substituted = target.replace("*", wildcard);
+            const resolved = resolveImportBase(path.resolve(mapping.baseUrl, substituted));
+            if (resolved) {
+                return resolved;
+            }
+        }
+    }
+    return null;
+}
+function formatRelativeImportSpecifier(fromFile, targetFile, config, options = {}) {
+    const fromDir = path.dirname(fromFile);
+    let target = withoutSourceExtension(targetFile);
+    if (options.allowIndexCollapse && /[/\\]index$/.test(target)) {
+        target = path.dirname(target);
+    }
+    let relative = path.relative(fromDir, target).replace(/\\/g, "/");
+    if (!relative.startsWith(".")) {
+        relative = `./${relative}`;
+    }
+    return `${relative}${relativeImportExtension(targetFile, config, options.ending)}`;
+}
+function toAliasImportSpecifier(targetFile, config, preferAlias, mode, allowIndexCollapse = false) {
+    if (!config || config.mappings.length === 0) {
+        return null;
+    }
+    const candidates = collectAliasCandidates(targetFile, config, preferAlias, allowIndexCollapse);
+    const sorted = mode === "shortestAlias"
+        ? candidates.sort((left, right) => left.specifier.length - right.specifier.length || left.specifier.localeCompare(right.specifier))
+        : candidates.sort((left, right) => right.specificity - left.specificity || left.specifier.length - right.specifier.length || left.specifier.localeCompare(right.specifier));
+    return sorted[0]?.specifier ?? null;
+}
+function toProjectRelativeImportSpecifier(targetFile, config, ending, allowIndexCollapse = false) {
+    if (!config) {
+        return null;
+    }
+    let target = withoutSourceExtension(targetFile);
+    if (allowIndexCollapse && /[/\\]index$/.test(target)) {
+        target = path.dirname(target);
+    }
+    const relative = path.relative(config.baseUrl, target).replace(/\\/g, "/");
+    if (!relative || relative.startsWith("..") || path.isAbsolute(relative)) {
+        return null;
+    }
+    return `${relative}${relativeImportExtension(targetFile, config, ending)}`;
+}
+function relativeImportExtension(targetFile, config, ending) {
+    const ext = path.extname(targetFile).toLowerCase();
+    if (ext === ".mts") {
+        return ".mjs";
+    }
+    if (ext === ".cts") {
+        return ".cjs";
+    }
+    if (ext === ".js" || ext === ".jsx" || ext === ".mjs" || ext === ".cjs") {
+        return ext;
+    }
+    if (ending === "minimal") {
+        return "";
+    }
+    if (ending === "js") {
+        return ".js";
+    }
+    return usesNodeEsmImportExtensions(config) ? ".js" : "";
+}
+function usesNodeEsmImportExtensions(config) {
+    const moduleResolution = normalizeCompilerOption(config?.moduleResolution);
+    const module = normalizeCompilerOption(config?.module);
+    return moduleResolution === "node16" || moduleResolution === "nodenext" || module === "node16" || module === "nodenext";
+}
+function normalizeCompilerOption(value) {
+    return value?.toLowerCase().replace(/[_\s-]+/g, "") ?? "";
+}
+function collectAliasCandidates(targetFile, config, preferAlias, allowIndexCollapse) {
+    const targetNoExt = withoutSourceExtension(targetFile);
+    const candidates = config.mappings
+        .filter((mapping) => !preferAlias || mapping.pattern === preferAlias)
+        .flatMap((mapping) => mapping.targets.map((target) => {
+        const specifier = aliasCandidate(targetNoExt, mapping, target);
+        return specifier ? { specifier, pattern: mapping.pattern, specificity: mapping.specificity } : null;
+    }).filter((item) => item !== null));
+    if (!allowIndexCollapse || !/[/\\]index$/.test(targetNoExt)) {
+        return candidates;
+    }
+    const collapsedTarget = path.dirname(targetNoExt);
+    return [
+        ...candidates,
+        ...config.mappings
+            .filter((mapping) => !preferAlias || mapping.pattern === preferAlias)
+            .flatMap((mapping) => mapping.targets.map((target) => {
+            const specifier = aliasCandidate(collapsedTarget, mapping, target);
+            return specifier ? { specifier, pattern: mapping.pattern, specificity: mapping.specificity } : null;
+        }).filter((item) => item !== null))
+    ];
+}
+function aliasCandidate(targetNoExt, mapping, rawTarget) {
+    const starIndex = rawTarget.indexOf("*");
+    if (starIndex < 0) {
+        const absoluteTarget = withoutSourceExtension(path.resolve(mapping.baseUrl, rawTarget));
+        return absoluteTarget === targetNoExt && !mapping.pattern.includes("*") ? mapping.pattern : null;
+    }
+    const targetPrefix = withoutSourceExtension(path.resolve(mapping.baseUrl, rawTarget.slice(0, starIndex)));
+    const targetSuffix = withoutSourceExtension(rawTarget.slice(starIndex + 1));
+    if (!targetNoExt.startsWith(targetPrefix) || (targetSuffix && !targetNoExt.endsWith(targetSuffix))) {
+        return null;
+    }
+    const wildcard = targetNoExt.slice(targetPrefix.length, targetSuffix ? -targetSuffix.length : undefined).replace(/^[/\\]/, "");
+    return mapping.pattern.replace("*", wildcard.replace(/\\/g, "/"));
+}
+function readNearestTsConfig(file, cwd, cache) {
+    let current = path.dirname(file);
+    const stop = path.parse(path.resolve(cwd)).root;
+    while (true) {
+        const candidate = path.join(current, "tsconfig.json");
+        if (fs.existsSync(candidate)) {
+            return readTsConfig(candidate, cache);
+        }
+        const parent = path.dirname(current);
+        if (parent === current || current === stop) {
+            return null;
+        }
+        current = parent;
+    }
+}
+function readTsConfig(configPath, cache) {
+    const normalizedPath = path.resolve(configPath);
+    if (cache.has(normalizedPath)) {
+        return cache.get(normalizedPath) ?? null;
+    }
+    cache.set(normalizedPath, null);
+    try {
+        const raw = parseJsoncObject(fs.readFileSync(normalizedPath, "utf8"));
+        const parent = readExtendedTsConfig(normalizedPath, raw, cache);
+        const compilerOptions = isRecord(raw.compilerOptions) ? raw.compilerOptions : {};
+        const baseUrl = typeof compilerOptions.baseUrl === "string"
+            ? path.resolve(path.dirname(normalizedPath), compilerOptions.baseUrl)
+            : parent?.baseUrl ?? path.dirname(normalizedPath);
+        const paths = isRecord(compilerOptions.paths) ? compilerOptions.paths : null;
+        const mappings = (paths
+            ? Object.entries(paths)
+                .flatMap(([pattern, value]) => Array.isArray(value)
+                ? createPathMapping(pattern, value.filter((item) => typeof item === "string"), baseUrl)
+                : [])
+            : parent?.mappings ?? [])
+            .sort((left, right) => right.specificity - left.specificity || left.pattern.localeCompare(right.pattern));
+        const compilerModule = readString(compilerOptions.module) ?? parent?.module;
+        const moduleResolution = readString(compilerOptions.moduleResolution) ?? parent?.moduleResolution;
+        const info = {
+            configPath: normalizedPath,
+            baseUrl,
+            mappings,
+            ...(compilerModule ? { module: compilerModule } : {}),
+            ...(moduleResolution ? { moduleResolution } : {})
+        };
+        cache.set(normalizedPath, info);
+        return info;
+    }
+    catch {
+        cache.set(normalizedPath, null);
+        return null;
+    }
+}
+function readExtendedTsConfig(configPath, raw, cache) {
+    const rawExtends = readString(raw.extends);
+    const extendedPath = rawExtends ? resolveExtendsTsConfig(configPath, rawExtends) : null;
+    return extendedPath ? readTsConfig(extendedPath, cache) : null;
+}
+function resolveExtendsTsConfig(configPath, rawExtends) {
+    const candidates = [];
+    if (rawExtends.startsWith(".") || path.isAbsolute(rawExtends)) {
+        candidates.push(path.resolve(path.dirname(configPath), rawExtends));
+    }
+    else {
+        candidates.push(path.resolve(path.dirname(configPath), "node_modules", rawExtends));
+    }
+    const expanded = candidates.flatMap((candidate) => {
+        const ext = path.extname(candidate);
+        return ext
+            ? [candidate]
+            : [
+                `${candidate}.json`,
+                path.join(candidate, "tsconfig.json")
+            ];
+    });
+    return expanded.find((candidate) => fs.existsSync(candidate) && fs.statSync(candidate).isFile()) ?? null;
+}
+function createPathMapping(pattern, targets, baseUrl) {
+    const specificity = pattern.replace("*", "").length;
+    return targets.map((target) => ({
+        pattern,
+        targets: [target],
+        baseUrl,
+        specificity
+    }));
+}
+function matchPathPattern(specifier, mapping) {
+    const starIndex = mapping.pattern.indexOf("*");
+    if (starIndex < 0) {
+        return specifier === mapping.pattern ? "" : null;
+    }
+    const prefix = mapping.pattern.slice(0, starIndex);
+    const suffix = mapping.pattern.slice(starIndex + 1);
+    return specifier.startsWith(prefix) && specifier.endsWith(suffix)
+        ? specifier.slice(prefix.length, suffix ? -suffix.length : undefined)
+        : null;
+}
+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 IMPORT_EXTENSIONS) {
+            candidates.add(`${base}${candidateExt}`);
+        }
+    }
+    for (const candidateExt of IMPORT_EXTENSIONS) {
+        candidates.add(path.join(base, `index${candidateExt}`));
+    }
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+            return candidate;
+        }
+    }
+    return null;
+}
+function parseJsoncObject(text) {
+    const withoutComments = stripJsonComments(text);
+    const parsed = JSON.parse(withoutComments.replace(/,\s*([}\]])/g, "$1"));
+    return isRecord(parsed) ? parsed : {};
+}
+function stripJsonComments(text) {
+    let result = "";
+    let inString = false;
+    let escaped = false;
+    let inLineComment = false;
+    let inBlockComment = false;
+    for (let index = 0; index < text.length; index += 1) {
+        const char = text[index];
+        const next = text[index + 1];
+        if (inLineComment) {
+            if (char === "\n" || char === "\r") {
+                inLineComment = false;
+                result += char;
+            }
+            continue;
+        }
+        if (inBlockComment) {
+            if (char === "*" && next === "/") {
+                inBlockComment = false;
+                index += 1;
+            }
+            continue;
+        }
+        if (inString) {
+            result += char;
+            if (escaped) {
+                escaped = false;
+            }
+            else if (char === "\\") {
+                escaped = true;
+            }
+            else if (char === "\"") {
+                inString = false;
+            }
+            continue;
+        }
+        if (char === "\"") {
+            inString = true;
+            result += char;
+            continue;
+        }
+        if (char === "/" && next === "/") {
+            inLineComment = true;
+            index += 1;
+            continue;
+        }
+        if (char === "/" && next === "*") {
+            inBlockComment = true;
+            index += 1;
+            continue;
+        }
+        result += char;
+    }
+    return result;
+}
+function withoutSourceExtension(file) {
+    const ext = path.extname(file);
+    return SOURCE_EXTENSIONS.includes(ext) || IMPORT_EXTENSIONS.includes(ext)
+        ? file.slice(0, -ext.length)
+        : file;
+}
+function readString(value) {
+    return typeof value === "string" && value.trim() ? value : null;
+}
+function isRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/dist/commands/imports-command.js

@@ -1 +1,68 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0}),exports.runImportsCommand=_;const o=require("../shared/errors"),d=require("./add-missing-imports"),u=require("./find-importers"),l=require("./find-unused-imports"),c=require("./normalize-imports");async function _(e,p,a,s={},m){const[n="help",...i]=p;switch(n){case"--help":case"help":return f();case"normalize":return(0,c.runNormalizeImports)(e,i,a);case"addMissing":case"add-missing":return(0,d.runAddMissingImports)(e,a,s,i);case"unused":{const r=i.find(t=>!t.startsWith("--"));if(!r)throw new o.CliError("MISSING_FILE_PATH","imports unused expects a source file path.");return(0,l.runFindUnusedImports)(e,r,s,m)}case"importers":{const r=i.find(t=>!t.startsWith("--"));if(!r)throw new o.CliError("MISSING_TARGET_PATH","imports importers expects a target file or directory path.");return(0,u.runFindImporters)(e,r,s)}default:throw new o.CliError("UNKNOWN_IMPORTS_COMMAND",`Unknown imports command: ${n}`,{availableCommands:["normalize","addMissing","unused","importers","help"]})}}function f(){return{ok:!0,command:"imports",usage:["aib imports normalize preview <file-or-dir> --to alias|shortestAlias|relative","aib imports normalize show <previewId> [--all]","aib imports normalize apply <previewId>","aib imports normalize execute <file-or-dir> --to alias|shortestAlias|relative","aib imports addMissing preview <file-or-dir>","aib imports addMissing apply <previewId>","aib imports addMissing execute <file-or-dir>","aib imports unused <file>","aib imports importers <file-or-directory>"],notes:["normalize is local and can preview/apply/execute path rewrites.","addMissing, unused, and importers are IDE-backed TypeScript/project queries."]}}
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runImportsCommand = runImportsCommand;
+const errors_1 = require("../shared/errors");
+const add_missing_imports_1 = require("./add-missing-imports");
+const find_importers_1 = require("./find-importers");
+const find_unused_imports_1 = require("./find-unused-imports");
+async function runImportsCommand(cwd, restArgs, rawPayload, options = {}, metricsSpans) {
+    const [action = "help", ...actionArgs] = restArgs;
+    switch (action) {
+        case "--help":
+        case "help":
+            return importsHelp();
+        case "normalize":
+            throw new errors_1.CliError("IMPORTS_NORMALIZE_MUTATE_ONLY", "imports.normalize is available through aib mutate, not aib imports normalize.", {
+                example: [
+                    "Input:",
+                    "@scope src/features",
+                    "imports.normalize to=alias",
+                    "",
+                    "Run:",
+                    "aib mutate preview --stdin",
+                    "aib mutate execute --stdin"
+                ].join("\n")
+            });
+        case "addMissing":
+        case "add-missing":
+            return (0, add_missing_imports_1.runAddMissingImports)(cwd, rawPayload, options, actionArgs);
+        case "unused": {
+            const sourceFile = actionArgs.find((item) => !item.startsWith("--"));
+            if (!sourceFile) {
+                throw new errors_1.CliError("MISSING_FILE_PATH", "imports unused expects a source file path.");
+            }
+            return (0, find_unused_imports_1.runFindUnusedImports)(cwd, sourceFile, options, metricsSpans);
+        }
+        case "importers": {
+            const targetPath = actionArgs.find((item) => !item.startsWith("--"));
+            if (!targetPath) {
+                throw new errors_1.CliError("MISSING_TARGET_PATH", "imports importers expects a target file or directory path.");
+            }
+            return (0, find_importers_1.runFindImporters)(cwd, targetPath, options);
+        }
+        default:
+            throw new errors_1.CliError("UNKNOWN_IMPORTS_COMMAND", `Unknown imports command: ${action}`, {
+                availableCommands: ["normalize", "addMissing", "unused", "importers", "help"]
+            });
+    }
+}
+function importsHelp() {
+    return {
+        ok: true,
+        command: "imports",
+        usage: [
+            "Use aib mutate for imports.normalize:",
+            "@scope <file-or-dir>",
+            "imports.normalize to=alias|shortestAlias|relative",
+            "aib imports addMissing preview <file-or-dir>",
+            "aib imports addMissing apply <previewId>",
+            "aib imports addMissing execute <file-or-dir>",
+            "aib imports unused <file>",
+            "aib imports importers <file-or-directory>"
+        ],
+        notes: [
+            "imports.normalize is canonical mutate DSL, not a standalone imports subcommand.",
+            "addMissing, unused, and importers are CLI-owned TypeScript/project queries."
+        ]
+    };
+}