@emeryld/manager 1.4.4 → 1.4.6

package/dist/format-checker/report.js

@@ -23,18 +23,12 @@ export function reportViolations(violations, reportingMode) {
         return false;
     }
     console.log(colors.bold('Format checker violations:'));
-    console.log('');
     if (reportingMode === 'group') {
-        let hasPrintedGroupBlock = false;
         for (const type of TYPE_ORDER) {
             const entries = violations.filter((violation) => violation.type === type);
             if (!entries.length)
                 continue;
             entries.sort((a, b) => b.severity - a.severity);
-            if (hasPrintedGroupBlock) {
-                console.log('');
-            }
-            hasPrintedGroupBlock = true;
             console.log(colors.bold(`- ${TYPE_LABELS[type]} (${entries.length})`));
             for (const entry of entries) {
                 const relativePath = path.relative(rootDir, entry.file) || entry.file;
@@ -59,10 +53,10 @@ export function reportViolations(violations, reportingMode) {
                     });
                 }
             }
+            console.log('');
         }
     }
     else {
-        let hasPrintedFileBlock = false;
         const violationsByFile = new Map();
         for (const entry of violations) {
             const bucket = violationsByFile.get(entry.file);
@@ -76,10 +70,6 @@ export function reportViolations(violations, reportingMode) {
         const sortedFiles = [...violationsByFile.entries()].sort(([a], [b]) => a.localeCompare(b));
         for (const [file, entries] of sortedFiles) {
             const relativePath = path.relative(rootDir, file) || file;
-            if (hasPrintedFileBlock) {
-                console.log('');
-            }
-            hasPrintedFileBlock = true;
             console.log(colors.bold(relativePath));
             const sortedEntries = [...entries].sort((a, b) => (a.line ?? 0) - (b.line ?? 0));
             for (const entry of sortedEntries) {
@@ -107,6 +97,8 @@ export function reportViolations(violations, reportingMode) {
                 }
                 logViolationEntry(entry, '  ', locationDescriptor);
             }
+            console.log('');
+            console.log('');
         }
     }
     return true;

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

@@ -1,8 +1,9 @@
+// analysis/analysis.ts
 import { readFile } from 'node:fs/promises';
 import { collectDuplicateViolations, recordDuplicateLines, } from './duplicates.js';
 import { countIndentation, groupIndentationViolations, } from './indentation.js';
 import { collectFunctionRecords } from './functions.js';
-import { markImportLines, normalizeLine, resolveScriptKind } from './utils.js';
+import { isPunctuationOnlyLine, markImportLines, normalizeLine, resolveScriptKind, } from './utils.js';
 import { collectRequiredVariables } from './variables.js';
 import * as ts from 'typescript';
 export async function analyzeFiles(files, limits) {
@@ -29,6 +30,7 @@ async function analyzeSingleFile(filePath, limits, duplicates, fileSnapshots) {
         normalized: normalizeLine(line),
         trimmed: line.trim(),
         isImport: Boolean(importFlags[index]),
+        isPunctuationOnly: isPunctuationOnlyLine(line),
         raw: line,
     }));
     const violations = [];

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

@@ -1,6 +1,11 @@
+// analysis/duplicates.ts
 import path from 'node:path';
 import { getLineColumnRange } from './utils.js';
 import { collectRequiredVariables } from './variables.js';
+function trimRightKeepIndent(line) {
+    // Preserve leading indentation exactly; remove trailing whitespace only.
+    return line.replace(/[ \t]+$/g, '');
+}
 export function recordDuplicateLines(normalizedLines, filePath, limits, duplicates, sourceFile, lines, fileSnapshots) {
     const minLines = Math.max(1, limits.minDuplicateLines);
     const registerSnapshot = () => {
@@ -10,8 +15,11 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         normalizedLines.forEach((entry, index) => {
             if (!entry.normalized)
                 return;
-            const snippet = entry.trimmed.replace(/\s+/g, ' ');
-            if (!snippet)
+            // Do not treat punctuation-only lines as standalone duplicate lines.
+            if (entry.isPunctuationOnly)
+                return;
+            const snippet = trimRightKeepIndent(entry.raw);
+            if (!snippet.trim())
                 return;
             if (entry.isImport)
                 return;
@@ -26,18 +34,14 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         if (slice.some((entry) => !entry.normalized))
             continue;
         const key = slice.map((entry) => entry.normalized).join('\n');
-        const snippetLines = slice
-            .map((entry) => entry.trimmed)
-            .filter(Boolean);
-        if (!snippetLines.length)
+        // Require at least one non-empty, non-punctuation-only line to consider this a meaningful duplicate.
+        const meaningfulLineCount = slice.filter((entry) => entry.trimmed.length > 0 && !entry.isPunctuationOnly).length;
+        if (meaningfulLineCount === 0)
             continue;
         if (slice.some((entry) => entry.isImport))
             continue;
-        const snippet = snippetLines
-            .map((line) => line.replace(/\s+/g, ' '))
-            .join('\n');
-        if (!snippet)
-            continue;
+        // Determine the first/last non-empty lines (we still include punctuation-only lines
+        // inside that non-empty span when building the snippet).
         const firstNonEmptyIndex = slice.findIndex((entry) => entry.trimmed.length > 0);
         let lastNonEmptyIndex = -1;
         for (let offset = slice.length - 1; offset >= 0; offset -= 1) {
@@ -52,6 +56,11 @@ export function recordDuplicateLines(normalizedLines, filePath, limits, duplicat
         const endLine = i + 1 + lastNonEmptyIndex;
         const { startColumn } = getLineColumnRange(slice[firstNonEmptyIndex].raw);
         const { endColumn } = getLineColumnRange(slice[lastNonEmptyIndex].raw);
+        // Keep real indentation in the reported snippet; remove trailing whitespace only.
+        const snippet = slice
+            .slice(firstNonEmptyIndex, lastNonEmptyIndex + 1)
+            .map((entry) => trimRightKeepIndent(entry.raw))
+            .join('\n');
         registerSnapshot();
         addDuplicateOccurrence(duplicates, key, filePath, startLine, startColumn, endLine, endColumn, snippet, sourceFile, lines);
     }
@@ -103,13 +112,13 @@ function ensureFileSnapshot(fileSnapshots, filePath, normalizedLines, lines, sou
     });
 }
 function fingerprintLine(entry) {
+    if (entry.isImport)
+        return undefined;
     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) {
@@ -136,14 +145,22 @@ function expandDuplicateTracker(tracker, fileSnapshots) {
     if (infos.length < 2)
         return undefined;
     expandRangeAcrossOccurrences(infos);
-    const primary = infos[0];
-    const lines = primary.snapshot.normalizedLines
+    const primary = infos.reduce((current, info) => {
+        if (!current)
+            return info;
+        const pathComparison = current.file.localeCompare(info.file);
+        if (pathComparison > 0)
+            return info;
+        if (pathComparison === 0 && info.startIndex < current.startIndex) {
+            return info;
+        }
+        return current;
+    }, infos[0]);
+    const snippetLines = 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');
+        .map((entry) => trimRightKeepIndent(entry.raw));
+    // Preserve indentation; do not collapse whitespace.
+    const snippet = snippetLines.join('\n');
     const startLine = primary.startIndex + 1;
     const endLine = primary.endIndex + 1;
     const startColumn = getLineColumnRange(primary.snapshot.normalizedLines[primary.startIndex].raw).startColumn;
@@ -154,9 +171,16 @@ function expandDuplicateTracker(tracker, fileSnapshots) {
         endLine,
         endColumn,
     });
+    const detailInfos = [...infos].sort((a, b) => {
+        const pathComparison = a.file.localeCompare(b.file);
+        if (pathComparison !== 0)
+            return pathComparison;
+        return a.startIndex - b.startIndex;
+    });
+    const detail = detailInfos.map(formatOccurrenceDetail).join('\n');
     return {
         snippet,
-        detail: infos.map(formatOccurrenceDetail).join('\n'),
+        detail,
         requiredVariables,
     };
 }
@@ -194,12 +218,8 @@ function formatOccurrenceDetail(info) {
     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 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}`;
 }

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

@@ -1,11 +1,24 @@
+// analysis/utils.ts
 import path from 'node:path';
 import * as ts from 'typescript';
+// Lines that are only punctuation should still participate in duplicate matching/expansion,
+// but should NOT be treated as "fully duplicate lines" on their own.
+export function isPunctuationOnlyLine(line) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return false;
+    // Only these punctuation characters: {}();,<>[]
+    return /^[\{\}\(\);,<>[\]]+$/.test(trimmed);
+}
 export function normalizeLine(line) {
     const trimmed = line.trim();
     if (!trimmed)
         return undefined;
-    if (/^[};()]+$/.test(trimmed))
-        return undefined;
+    // Keep punctuation-only lines in the duplicate fingerprint (so blocks that include them match),
+    // but they'll be excluded from single-line duplicate violations in duplicates.ts.
+    if (isPunctuationOnlyLine(trimmed)) {
+        return `__punct__:${trimmed}`;
+    }
     const collapse = trimmed.replace(/\s+/g, ' ');
     const noNumbers = collapse.replace(/\d+/g, '#');
     return noNumbers.toLowerCase();

package/package.json

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