@atlashub/smartstack-mcp 1.19.0 → 1.21.0

package/dist/index.js

@@ -386,6 +386,9 @@ var QualityMetricSchema = z.enum([
   "parameter-count",
   "code-duplication",
   "file-size",
+  "unused-members",
+  "duplicated-strings",
+  "unassigned-fields",
   "all"
 ]);
 var AnalyzeCodeQualityInputSchema = z.object({
@@ -10866,7 +10869,7 @@ function formatFinding(finding, lines) {
 import path21 from "path";
 var analyzeCodeQualityTool = {
   name: "analyze_code_quality",
-  description: "Analyze code quality metrics for SmartStack projects: cognitive complexity, cyclomatic complexity, function size, nesting depth, and maintainability indicators.",
+  description: "Analyze code quality metrics for SmartStack projects: cognitive complexity, cyclomatic complexity, function size, nesting depth, unused members (S1144), duplicated strings (S1192), and unassigned fields (S3459).",
   inputSchema: {
     type: "object",
     properties: {
@@ -10886,6 +10889,9 @@ var analyzeCodeQualityTool = {
             "parameter-count",
             "code-duplication",
             "file-size",
+            "unused-members",
+            "duplicated-strings",
+            "unassigned-fields",
             "all"
           ]
         },
@@ -10938,10 +10944,15 @@ async function handleAnalyzeCodeQuality(args, config) {
   const projectPath = input.path || config.smartstack.projectPath;
   const thresholdLevel = input.threshold;
   const thresholds = THRESHOLDS[thresholdLevel];
+  const requestedMetrics = input.metrics || ["all"];
+  const analyzeAll = requestedMetrics.includes("all");
   logger.info("Analyzing code quality", { projectPath, threshold: thresholdLevel });
   const structure = await findSmartStackStructure(projectPath);
   const allFunctionMetrics = [];
   const fileMetrics = /* @__PURE__ */ new Map();
+  const fileContents = /* @__PURE__ */ new Map();
+  const allUnusedMembers = [];
+  const allUnassignedFields = [];
   const csFiles = await findFiles("**/*.cs", { cwd: structure.root });
   const filteredCsFiles = csFiles.filter((f) => !isExcludedPath(f));
   for (const file of filteredCsFiles) {
@@ -10951,6 +10962,13 @@ async function handleAnalyzeCodeQuality(args, config) {
     const functions = extractCSharpFunctions(content, relPath);
     allFunctionMetrics.push(...functions);
     fileMetrics.set(relPath, { lineCount, functions: functions.length });
+    fileContents.set(relPath, content);
+    if (analyzeAll || requestedMetrics.includes("unused-members")) {
+      allUnusedMembers.push(...detectUnusedMembers(content, relPath));
+    }
+    if (analyzeAll || requestedMetrics.includes("unassigned-fields")) {
+      allUnassignedFields.push(...detectUnassignedFields(content, relPath));
+    }
   }
   const tsFiles = await findFiles("**/*.{ts,tsx}", { cwd: structure.root });
   const filteredTsFiles = tsFiles.filter((f) => !isExcludedPath(f));
@@ -10961,6 +10979,7 @@ async function handleAnalyzeCodeQuality(args, config) {
     const functions = extractTypeScriptFunctions(content, relPath);
     allFunctionMetrics.push(...functions);
     fileMetrics.set(relPath, { lineCount, functions: functions.length });
+    fileContents.set(relPath, content);
   }
   const metrics = calculateMetrics(allFunctionMetrics, fileMetrics, thresholds);
   const hotspots = identifyHotspots(allFunctionMetrics, fileMetrics, thresholds);
@@ -10970,6 +10989,13 @@ async function handleAnalyzeCodeQuality(args, config) {
     metrics,
     hotspots
   };
+  let duplicatedStrings = [];
+  if (analyzeAll || requestedMetrics.includes("duplicated-strings")) {
+    duplicatedStrings = detectDuplicatedStrings(fileContents);
+  }
+  if (allUnusedMembers.length > 0 || duplicatedStrings.length > 0 || allUnassignedFields.length > 0) {
+    return formatExtendedReport(result, thresholds, allUnusedMembers, duplicatedStrings, allUnassignedFields);
+  }
   return formatQualityReport(result, thresholds);
 }
 function extractCSharpFunctions(content, file) {
@@ -11311,6 +11337,174 @@ function formatQualityReport(result, thresholds) {
   }
   return lines.join("\n");
 }
+function detectUnusedMembers(content, file) {
+  const unusedMembers = [];
+  const privateMethodPattern = /\b(private|internal)\s+(?:async\s+)?(?:static\s+)?[\w<>,\s\[\]]+\s+(\w+)\s*\(/gm;
+  let match;
+  while ((match = privateMethodPattern.exec(content)) !== null) {
+    const visibility = match[1];
+    const methodName = match[2];
+    const line = getLineNumber2(content, match.index);
+    if (["get", "set", "Dispose", "InitializeComponent"].includes(methodName)) continue;
+    const regex = new RegExp(`\\b${methodName}\\b`, "g");
+    const occurrences = (content.match(regex) || []).length;
+    if (occurrences === 1) {
+      unusedMembers.push({
+        name: methodName,
+        type: "method",
+        visibility,
+        file,
+        line,
+        rule: "S1144"
+      });
+    }
+  }
+  const privateFieldPattern = /\b(private|internal)\s+(?:readonly\s+)?(?:static\s+)?[\w<>,\[\]]+\s+_?(\w+)\s*[;=]/gm;
+  while ((match = privateFieldPattern.exec(content)) !== null) {
+    const visibility = match[1];
+    const fieldName = match[2];
+    const line = getLineNumber2(content, match.index);
+    const regex = new RegExp(`\\b${fieldName}\\b`, "g");
+    const occurrences = (content.match(regex) || []).length;
+    if (occurrences === 1) {
+      unusedMembers.push({
+        name: fieldName,
+        type: "field",
+        visibility,
+        file,
+        line,
+        rule: "S1144"
+      });
+    }
+  }
+  return unusedMembers;
+}
+function detectDuplicatedStrings(fileContents) {
+  const stringOccurrences = /* @__PURE__ */ new Map();
+  for (const [file, content] of fileContents) {
+    const stringPattern = /"([^"\\]|\\.){5,}"/g;
+    let match;
+    while ((match = stringPattern.exec(content)) !== null) {
+      const literal = match[0];
+      const line = getLineNumber2(content, match.index);
+      if (isIgnoredStringLiteral(literal)) continue;
+      if (!stringOccurrences.has(literal)) {
+        stringOccurrences.set(literal, []);
+      }
+      stringOccurrences.get(literal).push({ file, line });
+    }
+  }
+  const duplicated = [];
+  for (const [literal, locations] of stringOccurrences) {
+    if (locations.length >= 3) {
+      duplicated.push({
+        literal,
+        occurrences: locations.length,
+        locations: locations.slice(0, 5),
+        // Limit to 5 examples
+        suggestedConstantName: suggestConstantName(literal),
+        rule: "S1192"
+      });
+    }
+  }
+  duplicated.sort((a, b) => b.occurrences - a.occurrences);
+  return duplicated.slice(0, 10);
+}
+function isIgnoredStringLiteral(literal) {
+  const ignoredPatterns = [
+    /^"\s*"$/,
+    // Empty or whitespace
+    /^"[,.\-:;\/\\]+"$/,
+    // Punctuation only
+    /^"https?:\/\//,
+    // URLs
+    /^"[a-z]{1,4}:"$/i,
+    // Protocol prefixes
+    /^"\{[0-9]+\}"$/,
+    // Format placeholders
+    /^"[a-z_]+:[a-z_]+"$/i
+    // Resource keys
+  ];
+  return ignoredPatterns.some((p) => p.test(literal));
+}
+function suggestConstantName(literal) {
+  const content = literal.slice(1, -1);
+  const words = content.replace(/[^a-zA-Z0-9\s]/g, " ").split(/\s+/).filter((w) => w.length > 0).slice(0, 4);
+  if (words.length === 0) return "STRING_CONSTANT";
+  return words.map((w) => w.toUpperCase()).join("_");
+}
+function detectUnassignedFields(content, file) {
+  const unassignedFields = [];
+  const fieldPattern = /\b(private|protected|internal|public)\s+(?:readonly\s+)?(\w+(?:<[^>]+>)?)\s+(\w+)\s*;/gm;
+  let match;
+  while ((match = fieldPattern.exec(content)) !== null) {
+    const fieldType = match[2];
+    const fieldName = match[3];
+    const line = getLineNumber2(content, match.index);
+    const assignmentPattern = new RegExp(`\\b${fieldName}\\s*=`, "g");
+    const assignments = content.match(assignmentPattern) || [];
+    const constructorAssignmentPattern = new RegExp(`this\\.${fieldName}\\s*=`, "g");
+    const constructorAssignments = content.match(constructorAssignmentPattern) || [];
+    if (assignments.length === 0 && constructorAssignments.length === 0) {
+      unassignedFields.push({
+        name: fieldName,
+        type: fieldType,
+        file,
+        line,
+        rule: "S3459"
+      });
+    }
+  }
+  return unassignedFields;
+}
+function formatExtendedReport(result, thresholds, unusedMembers, duplicatedStrings, unassignedFields) {
+  let report = formatQualityReport(result, thresholds);
+  if (unusedMembers.length > 0 || duplicatedStrings.length > 0 || unassignedFields.length > 0) {
+    report += "\n\n## SonarCloud-Style Detections\n";
+    if (unusedMembers.length > 0) {
+      report += "\n### \u{1F50D} Unused Private Members (S1144)\n";
+      report += `Found ${unusedMembers.length} unused private members:
+
+`;
+      for (const member of unusedMembers.slice(0, 10)) {
+        report += `- \`${member.name}\` (${member.type}) in \`${member.file}:${member.line}\`
+`;
+      }
+      if (unusedMembers.length > 10) {
+        report += `
+... and ${unusedMembers.length - 10} more
+`;
+      }
+    }
+    if (duplicatedStrings.length > 0) {
+      report += "\n### \u{1F504} Duplicated String Literals (S1192)\n";
+      report += `Found ${duplicatedStrings.length} duplicated strings (3+ occurrences):
+
+`;
+      for (const dup of duplicatedStrings) {
+        const truncated = dup.literal.length > 50 ? dup.literal.slice(0, 47) + '..."' : dup.literal;
+        report += `- ${truncated} (${dup.occurrences}x) \u2192 suggested: \`${dup.suggestedConstantName}\`
+`;
+      }
+    }
+    if (unassignedFields.length > 0) {
+      report += "\n### \u26A0\uFE0F Unassigned Fields (S3459)\n";
+      report += `Found ${unassignedFields.length} fields that are never assigned:
+
+`;
+      for (const field of unassignedFields.slice(0, 10)) {
+        report += `- \`${field.type} ${field.name}\` in \`${field.file}:${field.line}\`
+`;
+      }
+      if (unassignedFields.length > 10) {
+        report += `
+... and ${unassignedFields.length - 10} more
+`;
+      }
+    }
+  }
+  return report;
+}
 
 // src/tools/analyze-hierarchy-patterns.ts
 import path22 from "path";