@automaton-labs/aib 0.0.7 → 0.0.8

package/dist/inspect/inspect-duplicates-service.js

@@ -0,0 +1,526 @@
+"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.buildDuplicatesPayload = buildDuplicatesPayload;
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const node_crypto_1 = require("node:crypto");
+const typescript_1 = __importDefault(require("typescript"));
+const inspect_source_shape_1 = require("./inspect-source-shape");
+function buildDuplicatesPayload(firstScopePath, request) {
+    const scopes = (request.duplicateScopes.length > 0 ? request.duplicateScopes : [firstScopePath])
+        .map((scope) => path.resolve(request.cwd ?? process.cwd(), scope));
+    const pathExclude = request.duplicatePathExclude.map((item) => item.replace(/\\/g, "/"));
+    const files = collectDuplicateInspectFiles(scopes, pathExclude);
+    const kindFilter = new Set(request.duplicateKinds);
+    const declarations = files
+        .flatMap((file) => collectDuplicateDeclarations(file, kindFilter, request.duplicateDetail))
+        .filter((declaration) => matchesDuplicateEntityFilters(declaration, request));
+    const declarationsByName = groupBy(declarations, (declaration) => declaration.symbol.name);
+    const allItems = Array.from(declarationsByName.entries())
+        .map(([name, nameDeclarations]) => buildDuplicateItem(name, nameDeclarations, request))
+        .filter((item) => shouldIncludeDuplicateItem(item, request))
+        .sort(compareDuplicateItems);
+    const items = allItems.slice(request.duplicateOffset, request.duplicateOffset + request.duplicateLimit);
+    const declarationCount = items.reduce((sum, item) => sum + numberFromJson(item.declarationCount), 0);
+    const exactCopyCount = items.reduce((sum, item) => sum + numberFromJson(item.exactCopyCount), 0);
+    const totalDeclarationCount = allItems.reduce((sum, item) => sum + numberFromJson(item.declarationCount), 0);
+    const totalExactCopyCount = allItems.reduce((sum, item) => sum + numberFromJson(item.exactCopyCount), 0);
+    return {
+        id: request.id ?? null,
+        op: request.op,
+        ok: true,
+        targetPaths: scopes,
+        ...(pathExclude.length > 0 ? { pathExclude } : {}),
+        scannedFileCount: files.length,
+        itemCount: allItems.length,
+        returnedItemCount: items.length,
+        declarationCount: totalDeclarationCount,
+        exactCopyCount: totalExactCopyCount,
+        returnedDeclarationCount: declarationCount,
+        returnedExactCopyCount: exactCopyCount,
+        offset: request.duplicateOffset,
+        limit: request.duplicateLimit,
+        hiddenItemCount: Math.max(0, allItems.length - request.duplicateOffset - items.length),
+        summary: `${allItems.length} names, ${totalDeclarationCount} declarations, exact x${totalExactCopyCount}`,
+        detail: request.duplicateDetail,
+        mode: request.duplicateMode,
+        items,
+        hiddenDuplicateItems: allItems.slice(request.duplicateOffset + items.length)
+    };
+}
+function collectDuplicateInspectFiles(scopes, pathExclude) {
+    const files = new Set();
+    for (const scope of scopes) {
+        if (!fs.existsSync(scope)) {
+            continue;
+        }
+        const stat = fs.statSync(scope);
+        if (stat.isFile() && isInspectableSourceFile(scope) && !isDuplicatePathExcluded(scope, pathExclude)) {
+            files.add(path.normalize(scope));
+            continue;
+        }
+        if (!stat.isDirectory() || isDuplicatePathExcluded(scope, pathExclude)) {
+            continue;
+        }
+        for (const file of walkSourceFiles(scope, pathExclude)) {
+            files.add(path.normalize(file));
+        }
+    }
+    return Array.from(files).sort((left, right) => left.localeCompare(right));
+}
+function walkSourceFiles(dir, pathExclude) {
+    const files = [];
+    for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+        if (entry.name === "node_modules" || entry.name === ".git" || entry.name === ".tmp" || entry.name === "dist" || entry.name === "out") {
+            continue;
+        }
+        const absolute = path.join(dir, entry.name);
+        if (isDuplicatePathExcluded(absolute, pathExclude)) {
+            continue;
+        }
+        if (entry.isDirectory()) {
+            files.push(...walkSourceFiles(absolute, pathExclude));
+            continue;
+        }
+        if (entry.isFile() && isInspectableSourceFile(absolute)) {
+            files.push(absolute);
+        }
+    }
+    return files;
+}
+function isDuplicatePathExcluded(candidate, pathExclude) {
+    if (pathExclude.length === 0) {
+        return false;
+    }
+    const normalized = path.normalize(candidate).replace(/\\/g, "/");
+    return pathExclude.some((pattern) => matchesDuplicatePathExclude(normalized, pattern));
+}
+function matchesDuplicatePathExclude(normalizedPath, rawPattern) {
+    const pattern = path.normalize(rawPattern).replace(/\\/g, "/");
+    if (!containsGlob(pattern)) {
+        return normalizedPath === pattern || normalizedPath.startsWith(`${pattern}/`);
+    }
+    return globToRegExp(pattern).test(normalizedPath);
+}
+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 escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function isInspectableSourceFile(file) {
+    return [".ts", ".tsx", ".js", ".jsx", ".mts", ".cts", ".mjs", ".cjs"].includes(path.extname(file).toLowerCase()) &&
+        !file.endsWith(".d.ts");
+}
+function collectDuplicateDeclarations(file, kindFilter, detail) {
+    const sourceText = fs.readFileSync(file, "utf8");
+    const profile = detectDuplicateAnalysisProfile(file, sourceText);
+    return profile === "commonjsLike"
+        ? collectCommonJsLikeDuplicateDeclarations(file, sourceText, kindFilter, detail)
+        : collectTypeScriptLikeDuplicateDeclarations(file, sourceText, kindFilter, detail);
+}
+function collectTypeScriptLikeDuplicateDeclarations(file, sourceText, kindFilter, detail) {
+    const ts = typescript_1.default;
+    return collectDuplicateDeclarationsFromSymbols(file, sourceText, kindFilter, detail, (symbol) => shouldIncludeTypeScriptLikeDuplicateSymbol(ts, symbol));
+}
+function collectCommonJsLikeDuplicateDeclarations(file, sourceText, kindFilter, detail) {
+    const ts = typescript_1.default;
+    return collectDuplicateDeclarationsFromSymbols(file, sourceText, kindFilter, detail, (symbol) => shouldIncludeCommonJsLikeDuplicateSymbol(ts, symbol), (symbol) => normalizeCommonJsLikeDuplicateSymbol(ts, symbol));
+}
+function shouldIncludeTypeScriptLikeDuplicateSymbol(ts, symbol) {
+    if (ts.isExportDeclaration(symbol.node)) {
+        return false;
+    }
+    if (ts.isExportAssignment(symbol.node) && symbol.exportTarget) {
+        return false;
+    }
+    if (ts.isImportDeclaration(symbol.node) && !symbol.node.importClause && ts.isStringLiteral(symbol.node.moduleSpecifier)) {
+        return false;
+    }
+    return true;
+}
+function shouldIncludeCommonJsLikeDuplicateSymbol(ts, symbol) {
+    if (ts.isVariableStatement(symbol.node)) {
+        const firstDeclaration = symbol.node.declarationList.declarations[0];
+        if (firstDeclaration && (ts.isObjectBindingPattern(firstDeclaration.name) || ts.isArrayBindingPattern(firstDeclaration.name))) {
+            return false;
+        }
+    }
+    if (isCommonJsInteropExportSymbol(ts, symbol)) {
+        return false;
+    }
+    return true;
+}
+function normalizeCommonJsLikeDuplicateSymbol(ts, symbol) {
+    const definePropertyExportName = getCommonJsDefinePropertyExportName(ts, symbol.node);
+    if (!definePropertyExportName || definePropertyExportName === "exports.__esModule") {
+        const assignmentDisplay = getCommonJsAssignmentDuplicateName(ts, symbol.node);
+        return assignmentDisplay ? renameDuplicateSymbol(symbol, assignmentDisplay) : symbol;
+    }
+    const definePropertyDisplay = formatCommonJsDefinePropertyExportCall(ts, symbol.node, definePropertyExportName);
+    return renameDuplicateSymbol(symbol, definePropertyDisplay);
+}
+function renameDuplicateSymbol(symbol, name) {
+    return {
+        ...symbol,
+        name,
+        exported: true,
+        path: [name],
+        selector: name,
+        display: name,
+        exportKind: "commonjs"
+    };
+}
+function isCommonJsInteropExportSymbol(ts, symbol) {
+    if (symbol.name === "exports.__esModule") {
+        return true;
+    }
+    if (getCommonJsDefinePropertyExportName(ts, symbol.node) === "exports.__esModule") {
+        return true;
+    }
+    return isExportsDefaultVoidInitializer(ts, symbol.node);
+}
+function isExportsDefaultVoidInitializer(ts, node) {
+    if (!ts.isExpressionStatement(node)) {
+        return false;
+    }
+    const expression = (0, inspect_source_shape_1.unwrapVoidExpression)(ts, node.expression);
+    return ts.isBinaryExpression(expression) &&
+        (0, inspect_source_shape_1.isAssignmentOperator)(ts, expression.operatorToken.kind) &&
+        expression.left.getText() === "exports.default" &&
+        isVoidZeroExpression(ts, expression.right);
+}
+function isVoidZeroExpression(ts, expression) {
+    return ts.isVoidExpression(expression) && expression.expression.getText() === "0";
+}
+function getCommonJsDefinePropertyExportName(ts, node) {
+    if (!ts.isExpressionStatement(node)) {
+        return null;
+    }
+    const expression = (0, inspect_source_shape_1.unwrapVoidExpression)(ts, node.expression);
+    if (!ts.isCallExpression(expression) || expression.expression.getText() !== "Object.defineProperty") {
+        return null;
+    }
+    const [target, property] = expression.arguments;
+    if (!target || !property || !ts.isStringLiteralLike(property)) {
+        return null;
+    }
+    const targetText = target.getText();
+    if (targetText !== "exports" && targetText !== "module.exports") {
+        return null;
+    }
+    return formatCommonJsExportName(targetText, property.text);
+}
+function getCommonJsAssignmentDuplicateName(ts, node) {
+    if (!ts.isExpressionStatement(node)) {
+        return null;
+    }
+    const expression = (0, inspect_source_shape_1.unwrapVoidExpression)(ts, node.expression);
+    if (!ts.isBinaryExpression(expression) || !(0, inspect_source_shape_1.isAssignmentOperator)(ts, expression.operatorToken.kind)) {
+        return null;
+    }
+    const leftText = getCommonJsAssignmentLeftText(ts, expression.left);
+    if (!leftText) {
+        return null;
+    }
+    return `${leftText} = ${describeCommonJsAssignmentRightHandSide(ts, expression.right)}`;
+}
+function describeCommonJsAssignmentRightHandSide(ts, expression) {
+    if (ts.isObjectLiteralExpression(expression)) {
+        return formatObjectLiteralShape(ts, expression);
+    }
+    if (ts.isFunctionExpression(expression)) {
+        return expression.name ? `function ${expression.name.text}` : "function";
+    }
+    if (ts.isArrowFunction(expression)) {
+        return "function";
+    }
+    if (ts.isClassExpression(expression)) {
+        return expression.name ? `class ${expression.name.text}` : "class";
+    }
+    if (ts.isCallExpression(expression) && expression.expression.getText() === "require") {
+        const [specifier] = expression.arguments;
+        return specifier && ts.isStringLiteralLike(specifier)
+            ? `require(${specifier.getText()})`
+            : "require(...)";
+    }
+    if (ts.isIdentifier(expression) || ts.isPropertyAccessExpression(expression) || ts.isElementAccessExpression(expression)) {
+        return expression.getText();
+    }
+    if (ts.isStringLiteralLike(expression) || ts.isNumericLiteral(expression) || expression.kind === ts.SyntaxKind.TrueKeyword || expression.kind === ts.SyntaxKind.FalseKeyword) {
+        return expression.getText();
+    }
+    return (0, inspect_source_shape_1.shortenExpressionText)(expression.getText());
+}
+function getCommonJsAssignmentLeftText(ts, expression) {
+    const text = expression.getText();
+    if (text === "module.exports") {
+        return text;
+    }
+    if (ts.isPropertyAccessExpression(expression)) {
+        const owner = expression.expression.getText();
+        if (owner === "exports" || owner === "module.exports") {
+            return `${owner}.${expression.name.text}`;
+        }
+    }
+    if (ts.isElementAccessExpression(expression)) {
+        const owner = expression.expression.getText();
+        if (owner !== "exports" && owner !== "module.exports") {
+            return null;
+        }
+        const argument = expression.argumentExpression;
+        return argument ? `${owner}[${argument.getText()}]` : null;
+    }
+    return null;
+}
+function formatObjectLiteralShape(ts, expression) {
+    const parts = expression.properties.map((property) => getObjectLiteralPropertyIdentity(ts, property)).filter((name) => Boolean(name));
+    return parts.length > 0 ? `{ ${parts.join(", ")} }` : "{ ... }";
+}
+function getObjectLiteralPropertyName(ts, property) {
+    if (ts.isSpreadAssignment(property)) {
+        return "...";
+    }
+    const name = property.name;
+    if (!name) {
+        return null;
+    }
+    if (ts.isIdentifier(name) || ts.isPrivateIdentifier(name) || ts.isStringLiteralLike(name) || ts.isNumericLiteral(name)) {
+        return name.getText();
+    }
+    if (ts.isComputedPropertyName(name)) {
+        return `[${(0, inspect_source_shape_1.shortenExpressionText)(name.expression.getText())}]`;
+    }
+    return name.getText();
+}
+function getObjectLiteralPropertyIdentity(ts, property) {
+    if (ts.isSpreadAssignment(property)) {
+        return `...${(0, inspect_source_shape_1.shortenExpressionText)(property.expression.getText())}`;
+    }
+    const name = getObjectLiteralPropertyName(ts, property);
+    if (!name) {
+        return null;
+    }
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return name;
+    }
+    if (ts.isPropertyAssignment(property)) {
+        return `${name}: ${describeCommonJsAssignmentRightHandSide(ts, property.initializer)}`;
+    }
+    if (ts.isMethodDeclaration(property)) {
+        return `${name}()`;
+    }
+    if (ts.isGetAccessorDeclaration(property)) {
+        return `get ${name}`;
+    }
+    if (ts.isSetAccessorDeclaration(property)) {
+        return `set ${name}`;
+    }
+    return name;
+}
+function formatCommonJsExportName(targetText, propertyName) {
+    return /^[A-Za-z_$][\w$]*$/.test(propertyName)
+        ? `${targetText}.${propertyName}`
+        : `${targetText}[${JSON.stringify(propertyName)}]`;
+}
+function formatCommonJsDefinePropertyExportCall(ts, node, exportName) {
+    const descriptor = getCommonJsDefinePropertyDescriptor(ts, node);
+    const descriptorSuffix = descriptor ? `, ${descriptor}` : "";
+    const match = /^(exports|module\.exports)\.([A-Za-z_$][\w$]*)$/.exec(exportName);
+    if (match) {
+        return `Object.defineProperty(${match[1]}, ${JSON.stringify(match[2])}${descriptorSuffix})`;
+    }
+    const bracketMatch = /^(exports|module\.exports)\[(.+)\]$/.exec(exportName);
+    return bracketMatch
+        ? `Object.defineProperty(${bracketMatch[1]}, ${bracketMatch[2]}${descriptorSuffix})`
+        : `Object.defineProperty(...${descriptorSuffix})`;
+}
+function getCommonJsDefinePropertyDescriptor(ts, node) {
+    if (!ts.isExpressionStatement(node)) {
+        return null;
+    }
+    const expression = (0, inspect_source_shape_1.unwrapVoidExpression)(ts, node.expression);
+    if (!ts.isCallExpression(expression) || expression.expression.getText() !== "Object.defineProperty") {
+        return null;
+    }
+    const descriptor = expression.arguments[2];
+    if (!descriptor || !ts.isObjectLiteralExpression(descriptor)) {
+        return null;
+    }
+    const getter = descriptor.properties.find((property) => getObjectLiteralPropertyName(ts, property) === "get");
+    if (getter && ts.isPropertyAssignment(getter) && ts.isFunctionExpression(getter.initializer) && getter.initializer.name) {
+        return `get ${getter.initializer.name.text}`;
+    }
+    const keys = descriptor.properties.map((property) => getObjectLiteralPropertyName(ts, property)).filter((name) => Boolean(name));
+    return keys.length > 0 ? `{ ${keys.join(", ")} }` : "{ ... }";
+}
+function collectDuplicateDeclarationsFromSymbols(file, sourceText, kindFilter, detail, includeSymbol = () => true, normalizeSymbol = (symbol) => symbol) {
+    return (0, inspect_source_shape_1.collectInspectSymbols)(file, sourceText)
+        .filter(includeSymbol)
+        .map(normalizeSymbol)
+        .filter((symbol) => kindFilter.size === 0 || kindFilter.has(symbol.kind))
+        .map((symbol) => {
+        const code = sourceText.slice(symbol.node.getStart(), symbol.node.getEnd());
+        return {
+            file,
+            symbol,
+            code: detail === "code" ? code : "",
+            hash: hashDuplicateCode(code)
+        };
+    });
+}
+function detectDuplicateAnalysisProfile(file, sourceText) {
+    const extension = path.extname(file).toLowerCase();
+    if (extension === ".cjs" || extension === ".cts") {
+        return "commonjsLike";
+    }
+    if ((extension === ".js" || extension === ".jsx") && hasCommonJsSurface(sourceText)) {
+        return "commonjsLike";
+    }
+    return "typescriptLike";
+}
+function hasCommonJsSurface(sourceText) {
+    return /\bmodule\.exports\b|\bexports\./.test(sourceText);
+}
+function buildDuplicateItem(name, declarations, request) {
+    const variants = Array.from(groupBy(declarations, (declaration) => declaration.hash).entries())
+        .map(([hash, variantDeclarations]) => {
+        const representative = variantDeclarations[0];
+        return {
+            hash,
+            count: variantDeclarations.length,
+            ...(request.duplicateDetail === "code" ? { code: representative.code } : {}),
+            declarations: variantDeclarations.map((declaration, index) => duplicateDeclarationToPayload(declaration, index === 0 ? null : representative))
+        };
+    })
+        .sort((left, right) => numberFromJson(right.count) - numberFromJson(left.count));
+    const exactCopyCount = variants.reduce((sum, variant) => {
+        const count = numberFromJson(variant.count);
+        return count > 1 ? sum + count : sum;
+    }, 0);
+    return {
+        name,
+        declarationCount: declarations.length,
+        variantCount: variants.length,
+        exactCopyCount,
+        variants
+    };
+}
+function duplicateDeclarationToPayload(declaration, sameAs) {
+    return {
+        file: declaration.file,
+        symbol: (0, inspect_source_shape_1.symbolToPayload)(declaration.symbol, true),
+        ...(sameAs ? { sameAs: { file: sameAs.file, symbol: (0, inspect_source_shape_1.symbolToPayload)(sameAs.symbol, true) } } : {})
+    };
+}
+function shouldIncludeDuplicateItem(item, request) {
+    const declarationCount = numberFromJson(item.declarationCount);
+    const exactCopyCount = numberFromJson(item.exactCopyCount);
+    if (request.duplicateMode === "exact") {
+        return exactCopyCount > 0;
+    }
+    if (request.duplicateMode === "names") {
+        return declarationCount > 1;
+    }
+    return declarationCount > 1;
+}
+function matchesDuplicateEntityFilters(declaration, request) {
+    if (request.duplicateEntities.length > 0 && !request.duplicateEntities.some((entity) => matchesDuplicateEntity(declaration, entity))) {
+        return false;
+    }
+    if (request.duplicateExclude.some((entity) => matchesDuplicateEntity(declaration, entity))) {
+        return false;
+    }
+    return true;
+}
+function matchesDuplicateEntity(declaration, entity) {
+    if (declaration.symbol.name !== entity.symbolName) {
+        return false;
+    }
+    return !entity.symbolKind || declaration.symbol.kind === entity.symbolKind;
+}
+function compareDuplicateItems(left, right) {
+    const copyDiff = numberFromJson(right.exactCopyCount) - numberFromJson(left.exactCopyCount);
+    if (copyDiff !== 0) {
+        return copyDiff;
+    }
+    const declarationDiff = numberFromJson(right.declarationCount) - numberFromJson(left.declarationCount);
+    if (declarationDiff !== 0) {
+        return declarationDiff;
+    }
+    return String(left.name ?? "").localeCompare(String(right.name ?? ""));
+}
+function hashDuplicateCode(code) {
+    return (0, node_crypto_1.createHash)("sha256").update(code.replace(/\r\n/g, "\n").trim()).digest("hex").slice(0, 12);
+}
+function groupBy(items, key) {
+    const grouped = new Map();
+    for (const item of items) {
+        const value = key(item);
+        const bucket = grouped.get(value) ?? [];
+        bucket.push(item);
+        grouped.set(value, bucket);
+    }
+    return grouped;
+}
+function numberFromJson(value) {
+    return typeof value === "number" ? value : 0;
+}