mcp-software-design 0.1.4 → 0.1.5

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.5
+
+### Patch Changes
+
+- 7f60e6c: `check_smells` no longer reports rows of multi-line object and array literals, or calls and throws whose arguments were all string literals, as duplicated logic. Lookup tables, message lines and state names used to account for a third of duplication findings on real code. A line that starts with a closing brace before a control keyword (`} else if (...) {`, `} catch (error) {`) is no longer mistaken for a method header, which produced phantom long-method and too-many-params findings measured from the middle of a function.
+
 ## 0.1.4
 
 ### Patch Changes

package/build/index.js

@@ -31,6 +31,11 @@ braces, parentheses, and indentation, not a real parser).
 | large-file | > ${DEFAULTS.maxFileLines} lines | separation-of-concerns |
 
 All thresholds are overridable per call on the \`check_smells\` tool.
+
+Duplication skips members of multi-line object and array literals (rows of a
+lookup table are data) and calls or throws whose arguments were all string
+literals (\`lines.push('...')\`, \`throw new Error('...')\`), so message and
+state-name lines do not register.
 `;
 /** Render smells as a compact text report. */
 function renderSmells(smells) {

package/build/smells.js

@@ -173,9 +173,14 @@ function leadingIdentifier(trimmedLine) {
     const match = trimmedLine.match(/^([A-Za-z_$][\w$]*)/);
     return match ? match[1] : "";
 }
-/** True if the (possibly multi-line-joined) text is a function/method header opening a `{`. */
+/**
+ * True if the (possibly multi-line-joined) text is a function/method header
+ * opening a `{`. A closing brace that starts the line (`} else if (x) {`,
+ * `} catch (error) {`) is dropped first so the control keyword behind it is
+ * seen; otherwise such a line has no leading identifier and reads as a header.
+ */
 function isBraceMethodHeader(headerText) {
-    const trimmed = headerText.trim();
+    const trimmed = headerText.trim().replace(/^\}\s*/, "");
     if (!trimmed.endsWith("{"))
         return false;
     if (!trimmed.includes("("))
@@ -446,17 +451,76 @@ function detectLargeClass(sanitized, options) {
     }
     return findings;
 }
+/**
+ * Whether a `{` opens a block (function or control body, type declaration)
+ * rather than an object literal, judged from the sanitized text before it on
+ * its line. A header ends in `)` (optionally followed by a return type) or
+ * `=>`, a bare `else`/`try`/`do`/`finally`, or names a type; anything after
+ * `=`, `(`, `,`, `:`, `return` and the like is a literal. An empty prefix (a
+ * `{` opening the line) counts as a block.
+ */
+function opensBlock(prefix) {
+    const trimmed = prefix.trim();
+    if (trimmed === "")
+        return true;
+    if (/(=>|\belse|\btry|\bdo|\bfinally)$/.test(trimmed))
+        return true;
+    // A header keeps its `(...)` and may add a return type after it
+    // (`foo(): Promise<T | null> {`, `fn f() -> T {`, `func f() error {`);
+    // a literal after a call sits behind `=`, `,`, `(`, `?`, `:` or `||`.
+    const lastParen = trimmed.lastIndexOf(")");
+    if (lastParen !== -1) {
+        const tail = trimmed.slice(lastParen + 1).trim();
+        if (tail === "")
+            return true;
+        if (tail === ":")
+            return false; // `ok ? f(a) : {`
+        if (/^(:|->)\s*\S/.test(tail))
+            return true; // typed return
+        return /^[\w$<>\[\]*. ]*$/.test(tail); // `throws X`, `error`, `*T`
+    }
+    if (/^(case|default)\b/.test(trimmed))
+        return true;
+    const leadingWord = leadingIdentifier(trimmed);
+    if (CONTROL_KEYWORDS.has(leadingWord) || TYPE_KEYWORDS.has(leadingWord))
+        return true;
+    return /\b(class|interface|enum|struct|trait|impl|namespace|module|match)\s+[\w$<>:, ]*$/.test(trimmed);
+}
+/**
+ * A call or throw whose arguments were all string literals (blanked by
+ * `sanitize`): `lines.push(, );`, `throw new RangeError();`, `this.status.set();`.
+ * Such lines are messages and state names, not repeated logic.
+ */
+const TRIVIAL_CALL = /^(?:return\s+|await\s+|throw\s+new\s+)?[\w$.]+\s*\(\s*[,\s]*\)\s*;?$/;
 /** Detect duplicated non-trivial lines (a DRY proxy). */
 function detectDuplication(sanitized, options) {
     const lineCounts = new Map();
+    // Innermost open `{`/`[` per line, true when it opened an object/array
+    // literal: rows of a lookup table are data, not duplicated logic.
+    const bracketStack = [];
     for (let lineIndex = 0; lineIndex < sanitized.length; lineIndex++) {
-        const trimmed = sanitized[lineIndex].trim();
+        const line = sanitized[lineIndex];
+        const insideLiteral = bracketStack.length > 0 && bracketStack[bracketStack.length - 1];
+        for (let charIndex = 0; charIndex < line.length; charIndex++) {
+            const char = line[charIndex];
+            if (char === "{")
+                bracketStack.push(!opensBlock(line.slice(0, charIndex)));
+            else if (char === "[")
+                bracketStack.push(true);
+            else if (char === "}" || char === "]")
+                bracketStack.pop();
+        }
+        if (insideLiteral)
+            continue;
+        const trimmed = line.trim();
         if (trimmed.length < 15)
             continue; // too short to be meaningful
         if (/^[{}()\[\];,]+$/.test(trimmed))
             continue; // pure punctuation
         if (/^(import|from|export|package|using|#include|@)/.test(trimmed))
             continue;
+        if (TRIVIAL_CALL.test(trimmed))
+            continue;
         const record = lineCounts.get(trimmed) ?? { count: 0, firstLine: lineIndex + 1 };
         record.count++;
         lineCounts.set(trimmed, record);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-software-design",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "MCP server that teaches and applies software-design guidance: SOLID/OOP/DRY principles, the 23 GoF design patterns, pattern scaffolding, and heuristic code-smell detection.",
   "type": "module",
   "license": "MIT",