@emeryld/manager 1.4.5 → 1.4.6

package/dist/format-checker/report.js

@@ -98,6 +98,7 @@ export function reportViolations(violations, reportingMode) {
                 logViolationEntry(entry, '  ', locationDescriptor);
             }
             console.log('');
+            console.log('');
         }
     }
     return true;
@@ -115,5 +116,4 @@ function logViolationEntry(entry, messagePrefix, locationDescriptor) {
     if (locationDescriptor) {
         console.log(`    ${colors.dim(locationDescriptor)}`);
     }
-    console.log('');
 }

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);
     }
@@ -147,13 +156,11 @@ function expandDuplicateTracker(tracker, fileSnapshots) {
         }
         return current;
     }, infos[0]);
-    const lines = primary.snapshot.normalizedLines
+    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;
@@ -211,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.5",
+  "version": "1.4.6",
   "description": "Interactive manager for pnpm monorepos (update/test/build/publish).",
   "license": "MIT",
   "type": "module",