mcp-software-design 0.1.5 → 0.1.6

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.6
+
+### Patch Changes
+
+- 25dab4b: `check_smells` no longer reports declarations as duplicated logic: members of `interface`, `type` and `enum` bodies, typed member and parameter lines, fields initialized with a literal or declared with a modifier such as Angular signal inputs, and callback openers whose only argument is the callback (`useEffect(() => {`). Repeated statements, and calls that pass other arguments before a callback, are still reported.
+
 ## 0.1.5
 
 ### Patch Changes

package/build/index.js

@@ -35,7 +35,11 @@ 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.
+state-name lines do not register. It also skips declarations rather than
+logic: members of \`interface\` / \`type\` / \`enum\` bodies, typed member and
+parameter lines (\`depthTest?: boolean;\`), fields initialized with a literal or
+declared with a modifier (\`readonly name = input(undefined);\`), and callback
+openers whose only argument is the callback (\`useEffect(() => {\`).
 `;
 /** Render smells as a compact text report. */
 function renderSmells(smells) {

package/build/smells.js

@@ -492,25 +492,60 @@ function opensBlock(prefix) {
  * 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*;?$/;
+/**
+ * What a `{` opens: a `type` / `interface` / `enum` body (members are
+ * declarations, never duplicated logic), an object literal, or a block.
+ */
+function braceKind(prefix) {
+    if (/^(?:export\s+)?(?:declare\s+)?(?:interface|enum|type)\b/.test(prefix.trim()))
+        return "declaration";
+    return opensBlock(prefix) ? "block" : "literal";
+}
+const MEMBER_MODIFIERS = "(?:(?:readonly|private|protected|public|override|static|declare|abstract)\\s+)";
+/**
+ * A member or parameter declaration: `depthTest?: boolean;`, `worldWind: T,`,
+ * `[key: string]: any;`. The type part may be a function type but never a
+ * block, so a labelled statement or a `default: return x;` is left alone.
+ */
+const TYPED_DECLARATION = new RegExp(`^${MEMBER_MODIFIERS}*(?:\\[[\\w$]+\\s*:\\s*[^\\]]+\\]|[\\w$#]+)\\??\\s*:\\s*([^={}]+?)\\s*[;,]?$`);
+/** A field with an initializer: `enabled = true;`, `readonly name = input<T>(undefined);`. */
+const INITIALIZED_MEMBER = new RegExp(`^${MEMBER_MODIFIERS}+[\\w$#]+\\??\\s*(?::\\s*[^=]+?)?\\s*=\\s*[^;]*;?$`);
+/** A bare field whose initializer is a literal (strings are already blanked): `highlighted = false;`, `label = ;`. */
+const LITERAL_ASSIGNMENT = /^[\w$#]+\s*(?::\s*[^=]+?)?\s*=\s*(?:true|false|null|undefined|-?\d[\d._]*|\[\s*\]|\{\s*\}|new\s+[\w$.]+\(\s*\)|)\s*;?$/;
+/**
+ * A callback opener whose only argument is the callback: `useEffect(() => {`,
+ * `effect((onCleanup) => {`, `.then(async (layer) => {`. The logic is on the
+ * lines that follow; a call with other arguments before the callback still counts.
+ */
+const CALLBACK_OPENER = /^(?:(?:return|await)\s+|(?:const|let|var)\s+[\w$]+\s*=\s*)?[\w$.]+\s*\(\s*(?:async\s+)?(?:\(\s*[\w$,\s]*\)|[\w$]+)\s*=>\s*\{\s*$/;
+/** True for lines that declare rather than do: members, parameters, literal-initialized fields, callback openers. */
+function isDeclarationLine(trimmed) {
+    if (/^(?:case|default)\b/.test(trimmed))
+        return false;
+    const typed = trimmed.match(TYPED_DECLARATION);
+    if (typed && (!typed[1].includes("(") || typed[1].includes("=>")))
+        return true;
+    return INITIALIZED_MEMBER.test(trimmed) || LITERAL_ASSIGNMENT.test(trimmed) || CALLBACK_OPENER.test(trimmed);
+}
 /** 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.
+    // Innermost open `{`/`[` per line: rows of a lookup table and members of
+    // a type declaration are data and shape, not duplicated logic.
     const bracketStack = [];
     for (let lineIndex = 0; lineIndex < sanitized.length; lineIndex++) {
         const line = sanitized[lineIndex];
-        const insideLiteral = bracketStack.length > 0 && bracketStack[bracketStack.length - 1];
+        const enclosing = bracketStack[bracketStack.length - 1] ?? "block";
         for (let charIndex = 0; charIndex < line.length; charIndex++) {
             const char = line[charIndex];
             if (char === "{")
-                bracketStack.push(!opensBlock(line.slice(0, charIndex)));
+                bracketStack.push(braceKind(line.slice(0, charIndex)));
             else if (char === "[")
-                bracketStack.push(true);
+                bracketStack.push("literal");
             else if (char === "}" || char === "]")
                 bracketStack.pop();
         }
-        if (insideLiteral)
+        if (enclosing !== "block")
             continue;
         const trimmed = line.trim();
         if (trimmed.length < 15)
@@ -519,7 +554,7 @@ function detectDuplication(sanitized, options) {
             continue; // pure punctuation
         if (/^(import|from|export|package|using|#include|@)/.test(trimmed))
             continue;
-        if (TRIVIAL_CALL.test(trimmed))
+        if (TRIVIAL_CALL.test(trimmed) || isDeclarationLine(trimmed))
             continue;
         const record = lineCounts.get(trimmed) ?? { count: 0, firstLine: lineIndex + 1 };
         record.count++;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mcp-software-design",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "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",