@emeryld/manager 1.4.1 → 1.4.2

package/dist/format-checker/config.js

@@ -5,9 +5,9 @@ import { rootDir } from '../helper-cli/env.js';
 export const REPORTING_MODES = ['group', 'file'];
 export const DEFAULT_LIMITS = {
     maxFunctionLength: 150,
-    maxMethodLength: 200,
+    maxMethodLength: 150,
     maxIndentationDepth: 6,
-    maxFunctionsPerFile: 16,
+    maxFunctionsPerFile: 25,
     maxComponentsPerFile: 8,
     maxFileLength: 500,
     maxDuplicateLineOccurrences: 3,

package/dist/format-checker/scan/analysis.js

@@ -8,13 +8,14 @@ import * as ts from 'typescript';
 export async function analyzeFiles(files, limits) {
     const violations = [];
     const duplicateMap = new Map();
+    const fileSnapshots = new Map();
     for (const file of files) {
-        violations.push(...(await analyzeSingleFile(file, limits, duplicateMap)));
+        violations.push(...(await analyzeSingleFile(file, limits, duplicateMap, fileSnapshots)));
     }
-    violations.push(...collectDuplicateViolations(duplicateMap, limits));
+    violations.push(...collectDuplicateViolations(duplicateMap, limits, fileSnapshots));
     return violations;
 }
-async function analyzeSingleFile(filePath, limits, duplicates) {
+async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
     let content;
     try {
         content = await readFile(filePath, 'utf-8');
@@ -48,7 +49,7 @@ async function analyzeSingleFile(filePath, limits, duplicates) {
         }
     });
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.ESNext, true, resolveScriptKind(filePath));
-    recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines);
+    recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines, fileSnapshots);
     const indentationGroups = groupIndentationViolations(indentationViolations, lines, limits.maxIndentationDepth);
     indentationGroups
         .sort((a, b) => b.severity - a.severity)

package/dist/format-checker/scan/duplicates.js

@@ -1,8 +1,11 @@
 import path from 'node:path';
 import { getLineColumnRange } from './utils.js';
 import { collectRequiredVariables } from './variables.js';
-export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines) {
+export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines, fileSnapshots) {
     const minLines = Math.max(1, limits.minDuplicateLines);
+    const registerSnapshot = () => {
+        ensureFileSnapshot(fileSnapshots, filePath, normalizedLines, lines, sourceFile);
+    };
     if (limits.minDuplicateLines <= 0 || minLines === 1) {
         normalizedLines.forEach((entry, index) => {
             if (!entry.normalized)
@@ -13,6 +16,7 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
             if (entry.isImport)
                 return;
             const { startColumn, endColumn } = getLineColumnRange(entry.raw);
+            registerSnapshot();
             addDuplicateOccurrence(duplicates, entry.normalized, filePath, index + 1, startColumn, index + 1, endColumn, snippet, sourceFile, lines);
         });
         return;
@@ -48,6 +52,7 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         const endLine = i + 1 + lastNonEmptyIndex;
         const { startColumn } = getLineColumnRange(slice[firstNonEmptyIndex].raw);
         const { endColumn } = getLineColumnRange(slice[lastNonEmptyIndex].raw);
+        registerSnapshot();
         addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines);
     }
 }
@@ -88,28 +93,140 @@ function addDuplicateOccurrence(duplicates, key, filePath, startLine, startColum
         ],
     });
 }
-export function collectDuplicateViolations(duplicates, limits) {
+function ensureFileSnapshot(fileSnapshots, filePath, normalizedLines, lines, sourceFile) {
+    if (fileSnapshots.has(filePath))
+        return;
+    fileSnapshots.set(filePath, {
+        sourceFile,
+        normalizedLines,
+        lines,
+    });
+}
+function fingerprintLine(entry) {
+    if (entry.normalized)
+        return entry.normalized;
+    const collapsed = entry.trimmed.replace(/\s+/g, ' ');
+    if (!collapsed)
+        return undefined;
+    if (!/[A-Za-z0-9]/.test(collapsed))
+        return undefined;
+    return collapsed.toLowerCase();
+}
+function buildOccurrenceInfo(occurrence, fileSnapshots) {
+    const snapshot = fileSnapshots.get(occurrence.file);
+    if (!snapshot)
+        return undefined;
+    const totalLines = snapshot.normalizedLines.length;
+    if (totalLines === 0)
+        return undefined;
+    const clampIndex = (value) => Math.max(0, Math.min(totalLines - 1, value));
+    const rawStart = clampIndex(occurrence.line - 1);
+    const rawEnd = clampIndex(occurrence.endLine - 1);
+    return {
+        file: occurrence.file,
+        snapshot,
+        startIndex: Math.min(rawStart, rawEnd),
+        endIndex: Math.max(rawStart, rawEnd),
+    };
+}
+function expandDuplicateTracker(tracker, fileSnapshots) {
+    const infos = tracker.occurrences
+        .map((occurrence) => buildOccurrenceInfo(occurrence, fileSnapshots))
+        .filter((info) => Boolean(info));
+    if (infos.length < 2)
+        return undefined;
+    expandRangeAcrossOccurrences(infos);
+    const primary = infos[0];
+    const lines = primary.snapshot.normalizedLines
+        .slice(primary.startIndex, primary.endIndex + 1)
+        .map((entry) => entry.trimmed)
+        .filter(Boolean);
+    if (!lines.length)
+        return undefined;
+    const snippet = lines.map((line) => line.replace(/\s+/g, ' ')).join('\n');
+    const startLine = primary.startIndex + 1;
+    const endLine = primary.endIndex + 1;
+    const startColumn = getLineColumnRange(primary.snapshot.normalizedLines[primary.startIndex].raw).startColumn;
+    const endColumn = getLineColumnRange(primary.snapshot.normalizedLines[primary.endIndex].raw).endColumn;
+    const requiredVariables = collectRequiredVariables(primary.snapshot.sourceFile, primary.snapshot.lines, {
+        startLine,
+        startColumn,
+        endLine,
+        endColumn,
+    });
+    return {
+        snippet,
+        detail: infos.map(formatOccurrenceDetail).join('\n'),
+        requiredVariables,
+    };
+}
+function expandRangeAcrossOccurrences(infos) {
+    while (tryExpandRange(infos, 'left')) { }
+    while (tryExpandRange(infos, 'right')) { }
+}
+function tryExpandRange(infos, direction) {
+    const fingerprints = [];
+    for (const info of infos) {
+        const nextIndex = direction === 'left' ? info.startIndex - 1 : info.endIndex + 1;
+        if (nextIndex < 0 || nextIndex >= info.snapshot.normalizedLines.length) {
+            return false;
+        }
+        const fingerprint = fingerprintLine(info.snapshot.normalizedLines[nextIndex]);
+        if (!fingerprint)
+            return false;
+        fingerprints.push(fingerprint);
+    }
+    if (fingerprints.some((value) => value !== fingerprints[0])) {
+        return false;
+    }
+    for (const info of infos) {
+        if (direction === 'left') {
+            info.startIndex -= 1;
+        }
+        else {
+            info.endIndex += 1;
+        }
+    }
+    return true;
+}
+function formatOccurrenceDetail(info) {
+    const startLine = info.startIndex + 1;
+    const endLine = info.endIndex + 1;
+    const startEntry = info.snapshot.normalizedLines[info.startIndex];
+    const endEntry = info.snapshot.normalizedLines[info.endIndex];
+    const startColumn = startEntry
+        ? getLineColumnRange(startEntry.raw).startColumn
+        : 1;
+    const endColumn = endEntry
+        ? getLineColumnRange(endEntry.raw).endColumn
+        : 1;
+    const relativePath = path.relative(process.cwd(), info.file);
+    return `${relativePath}:${startLine}:${startColumn}/${endLine}:${endColumn}`;
+}
+export function collectDuplicateViolations(duplicates, limits, fileSnapshots) {
     const violations = [];
     for (const tracker of duplicates.values()) {
         if (tracker.count <= limits.maxDuplicateLineOccurrences)
             continue;
         if (tracker.occurrences.length === 0)
             continue;
+        const expanded = expandDuplicateTracker(tracker, fileSnapshots);
         violations.push({
             type: 'duplicateLine',
             file: tracker.occurrences[0].file,
             line: tracker.occurrences[0].line,
             severity: tracker.count - limits.maxDuplicateLineOccurrences,
             message: `Repeated ${tracker.count} times (max ${limits.maxDuplicateLineOccurrences})`,
-            detail: tracker.occurrences
-                .map((occurrence) => {
-                const relativePath = path.relative(process.cwd(), occurrence.file);
-                return `${relativePath}:${occurrence.line}:${occurrence.startColumn}/${occurrence.endLine}:${occurrence.endColumn}`;
-            })
-                .join('\n'),
-            snippet: tracker.snippet,
+            detail: expanded?.detail ??
+                tracker.occurrences
+                    .map((occurrence) => {
+                    const relativePath = path.relative(process.cwd(), occurrence.file);
+                    return `${relativePath}:${occurrence.line}:${occurrence.startColumn}/${occurrence.endLine}:${occurrence.endColumn}`;
+                })
+                    .join('\n'),
+            snippet: expanded?.snippet ?? tracker.snippet,
             repeatCount: tracker.count,
-            requiredVariables: tracker.requiredVariables,
+            requiredVariables: expanded?.requiredVariables ?? tracker.requiredVariables,
         });
     }
     return violations;

package/dist/format-checker/scan/utils.js

@@ -2,9 +2,11 @@ import path from 'node:path';
 import * as ts from 'typescript';
 export function normalizeLine(line) {
     const trimmed = line.trim();
-    if (trimmed.length < 12)
+    if (!trimmed)
         return undefined;
     const collapse = trimmed.replace(/\s+/g, ' ');
+    const letterCount = (collapse.match(/[A-Za-z]/g) ?? []).length;
+    // if (collapse.length < 12 && letterCount < 3) return undefined
     const noNumbers = collapse.replace(/\d+/g, '#');
     return noNumbers.toLowerCase();
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@emeryld/manager",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",