@atlashub/smartstack-mcp 1.20.0 → 1.22.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({
@@ -2435,6 +2438,27 @@ Handlebars.registerHelper("camelCase", (str) => {
 Handlebars.registerHelper("kebabCase", (str) => {
   return str.replace(/([a-z])([A-Z])/g, "$1-$2").toLowerCase();
 });
+function resolveHierarchy(navRoute) {
+  if (!navRoute) {
+    return { context: "", application: "", module: "", domainPath: "", infraPath: "", controllerArea: "" };
+  }
+  const segments = navRoute.split(".");
+  const toPascal = (s) => s.split("-").map((p) => p.charAt(0).toUpperCase() + p.slice(1)).join("");
+  const context = segments[0] ? toPascal(segments[0]) : "";
+  const application = segments[1] ? toPascal(segments[1]) : "";
+  const module = segments[2] ? toPascal(segments[2]) : segments[1] ? toPascal(segments[1]) : "";
+  let domainPath = "";
+  if (segments.length >= 3) {
+    domainPath = path8.join(context, application, module);
+  } else if (segments.length === 2) {
+    domainPath = path8.join(context, module);
+  } else if (segments.length === 1) {
+    domainPath = context;
+  }
+  const infraPath = module || "";
+  const controllerArea = context;
+  return { context, application, module, domainPath, infraPath, controllerArea };
+}
 async function handleScaffoldExtension(args, config) {
   const input = ScaffoldExtensionInputSchema.parse(args);
   const dryRun = input.options?.dryRun || false;
@@ -2579,17 +2603,21 @@ async function scaffoldFeature(name, options, structure, config, result, dryRun
   result.instructions.push(`${withRepository ? withValidation ? "5" : "4" : withValidation ? "4" : "3"}. Create migration: \`dotnet ef migrations add ${migrationPrefix}_vX.X.X_XXX_Add${name} --context ${dbContextName}\``);
   result.instructions.push(`${withRepository ? withValidation ? "6" : "5" : withValidation ? "5" : "4"}. Run migration: \`dotnet ef database update --context ${dbContextName}\``);
   if (!skipComponent) {
-    result.instructions.push(`Import component: \`import { ${name} } from './components/${name}';\``);
+    const featureHierarchy = resolveHierarchy(options?.navRoute);
+    const featureComponentPath = featureHierarchy.context && featureHierarchy.module ? `@/components/${featureHierarchy.context.toLowerCase()}/${featureHierarchy.module.toLowerCase()}/${name}` : `./components/${name}`;
+    result.instructions.push(`Import component: \`import { ${name} } from '${featureComponentPath}';\``);
   }
 }
 async function scaffoldService(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.application}.Services`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const interfaceNamespace = options?.namespace || `${config.conventions.namespaces.application}.Common.Interfaces`;
+  const implNamespace = hierarchy.infraPath ? `${config.conventions.namespaces.infrastructure}.Services.${hierarchy.infraPath}` : `${config.conventions.namespaces.infrastructure}.Services`;
   const methods = options?.methods || ["GetByIdAsync", "GetAllAsync", "CreateAsync", "UpdateAsync", "DeleteAsync"];
   const interfaceTemplate = `using System.Threading;
 using System.Threading.Tasks;
 using System.Collections.Generic;
 
-namespace {{namespace}};
+namespace {{interfaceNamespace}};
 
 /// <summary>
 /// Service interface for {{name}} operations
@@ -2610,7 +2638,7 @@ using System.Threading.Tasks;
 using System.Collections.Generic;
 using Microsoft.Extensions.Logging;
 
-namespace {{namespace}};
+namespace {{implNamespace}};
 
 /// <summary>
 /// Service implementation for {{name}} operations
@@ -2640,19 +2668,22 @@ public class {{name}}Service : I{{name}}Service
   const diTemplate = `// Add to DependencyInjection.cs or ServiceCollectionExtensions.cs:
 services.AddScoped<I{{name}}Service, {{name}}Service>();
 `;
-  const context = { namespace, name, methods };
+  const context = { interfaceNamespace, implNamespace, name, methods };
   const interfaceContent = Handlebars.compile(interfaceTemplate)(context);
   const implementationContent = Handlebars.compile(implementationTemplate)(context);
   const diContent = Handlebars.compile(diTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
-  const basePath = structure.application || projectRoot;
-  const servicesPath = path8.join(basePath, "Services");
-  const interfacePath = path8.join(servicesPath, `I${name}Service.cs`);
-  const implementationPath = path8.join(servicesPath, `${name}Service.cs`);
+  const appPath = structure.application || projectRoot;
+  const infraPath = structure.infrastructure || path8.join(projectRoot, "Infrastructure");
+  const interfacesDir = path8.join(appPath, "Common", "Interfaces");
+  const implDir = hierarchy.infraPath ? path8.join(infraPath, "Services", hierarchy.infraPath) : path8.join(infraPath, "Services");
+  const interfacePath = path8.join(interfacesDir, `I${name}Service.cs`);
+  const implementationPath = path8.join(implDir, `${name}Service.cs`);
   validatePathSecurity(interfacePath, projectRoot);
   validatePathSecurity(implementationPath, projectRoot);
   if (!dryRun) {
-    await ensureDirectory(servicesPath);
+    await ensureDirectory(interfacesDir);
+    await ensureDirectory(implDir);
     await writeText(interfacePath, interfaceContent);
     await writeText(implementationPath, implementationContent);
   }
@@ -2662,7 +2693,8 @@ services.AddScoped<I{{name}}Service, {{name}}Service>();
   result.instructions.push(diContent);
 }
 async function scaffoldEntity(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || config.conventions.namespaces.domain;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.domainPath ? `${config.conventions.namespaces.domain}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}` : config.conventions.namespaces.domain);
   const baseEntity = options?.baseEntity;
   const isSystemEntity = options?.isSystemEntity || false;
   const tablePrefix = options?.tablePrefix || "ref_";
@@ -2892,15 +2924,17 @@ public class {{name}}Configuration : IEntityTypeConfiguration<{{name}}>
   const entityContent = Handlebars.compile(entityTemplate)(context);
   const configContent = Handlebars.compile(configTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
-  const domainPath = structure.domain || path8.join(projectRoot, "Domain");
-  const infraPath = structure.infrastructure || path8.join(projectRoot, "Infrastructure");
-  const entityFilePath = path8.join(domainPath, `${name}.cs`);
-  const configFilePath = path8.join(infraPath, "Persistence", "Configurations", `${name}Configuration.cs`);
+  const domainBase = structure.domain || path8.join(projectRoot, "Domain");
+  const infraBase = structure.infrastructure || path8.join(projectRoot, "Infrastructure");
+  const entityDir = hierarchy.domainPath ? path8.join(domainBase, hierarchy.domainPath) : domainBase;
+  const configDir = hierarchy.infraPath ? path8.join(infraBase, "Persistence", "Configurations", hierarchy.infraPath) : path8.join(infraBase, "Persistence", "Configurations");
+  const entityFilePath = path8.join(entityDir, `${name}.cs`);
+  const configFilePath = path8.join(configDir, `${name}Configuration.cs`);
   validatePathSecurity(entityFilePath, projectRoot);
   validatePathSecurity(configFilePath, projectRoot);
   if (!dryRun) {
-    await ensureDirectory(domainPath);
-    await ensureDirectory(path8.join(infraPath, "Persistence", "Configurations"));
+    await ensureDirectory(entityDir);
+    await ensureDirectory(configDir);
     await writeText(entityFilePath, entityContent);
     await writeText(configFilePath, configContent);
   }
@@ -3217,7 +3251,8 @@ GO
   result.instructions.push("- Group memberships (user belongs to parent groups)");
 }
 async function scaffoldController(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.api}.Controllers`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.controllerArea ? `${config.conventions.namespaces.api}.Controllers.${hierarchy.controllerArea}` : `${config.conventions.namespaces.api}.Controllers`);
   const navRoute = options?.navRoute;
   const navRouteSuffix = options?.navRouteSuffix;
   const routeAttribute = navRoute ? navRouteSuffix ? `[NavRoute("${navRoute}", Suffix = "${navRouteSuffix}")]` : `[NavRoute("${navRoute}")]` : `[Route("api/[controller]")]`;
@@ -3313,11 +3348,11 @@ public record Update{{name}}Request();
   const controllerContent = Handlebars.compile(controllerTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
   const apiPath = structure.api || path8.join(projectRoot, "Api");
-  const controllersPath = path8.join(apiPath, "Controllers");
-  const controllerFilePath = path8.join(controllersPath, `${name}Controller.cs`);
+  const controllersDir = hierarchy.controllerArea ? path8.join(apiPath, "Controllers", hierarchy.controllerArea) : path8.join(apiPath, "Controllers");
+  const controllerFilePath = path8.join(controllersDir, `${name}Controller.cs`);
   validatePathSecurity(controllerFilePath, projectRoot);
   if (!dryRun) {
-    await ensureDirectory(controllersPath);
+    await ensureDirectory(controllersDir);
     await writeText(controllerFilePath, controllerContent);
   }
   result.files.push({ path: controllerFilePath, content: controllerContent, type: "created" });
@@ -3343,6 +3378,7 @@ public record Update{{name}}Request();
   }
 }
 async function scaffoldComponent(name, options, structure, config, result, dryRun = false) {
+  const hierarchy = resolveHierarchy(options?.navRoute);
   const componentTemplate = `import React, { useState, useEffect } from 'react';
 
 interface {{name}}Props {
@@ -3495,7 +3531,8 @@ export function use{{name}}(options: Use{{name}}Options = {}) {
   const hookContent = Handlebars.compile(hookTemplate)(context);
   const projectRoot = config.smartstack.projectPath;
   const webPath = structure.web || path8.join(projectRoot, "web");
-  const componentsPath = options?.outputPath || path8.join(webPath, "src", "components");
+  const componentsBase = path8.join(webPath, "src", "components");
+  const componentsPath = options?.outputPath ? options.outputPath : hierarchy.context && hierarchy.module ? path8.join(componentsBase, hierarchy.context.toLowerCase(), hierarchy.module.toLowerCase()) : componentsBase;
   const hooksPath = path8.join(webPath, "src", "hooks");
   const componentFilePath = path8.join(componentsPath, `${name}.tsx`);
   const hookFilePath = path8.join(hooksPath, `use${name}.ts`);
@@ -3510,8 +3547,9 @@ export function use{{name}}(options: Use{{name}}Options = {}) {
   result.files.push({ path: componentFilePath, content: componentContent, type: "created" });
   result.files.push({ path: hookFilePath, content: hookContent, type: "created" });
   result.instructions.push("Import and use the component:");
-  result.instructions.push(`import { ${name} } from './components/${name}';`);
-  result.instructions.push(`import { use${name} } from './hooks/use${name}';`);
+  const componentImportPath = hierarchy.context && hierarchy.module ? `@/components/${hierarchy.context.toLowerCase()}/${hierarchy.module.toLowerCase()}/${name}` : `./components/${name}`;
+  result.instructions.push(`import { ${name} } from '${componentImportPath}';`);
+  result.instructions.push(`import { use${name} } from '@/hooks/use${name}';`);
 }
 async function scaffoldTest(name, options, structure, config, result, dryRun = false) {
   const isSystemEntity = options?.isSystemEntity || false;
@@ -3639,7 +3677,8 @@ public class {{name}}ServiceTests
   result.instructions.push("- FluentAssertions");
 }
 async function scaffoldDtos(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.application}.DTOs`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.domainPath ? `${config.conventions.namespaces.application}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}.DTOs` : `${config.conventions.namespaces.application}.DTOs`);
   const isSystemEntity = options?.isSystemEntity || false;
   const properties = options?.entityProperties || [
     { name: "Name", type: "string", required: true, maxLength: 200 },
@@ -3756,7 +3795,7 @@ public record Update{{name}}Dto
   const createContent = Handlebars.compile(createDtoTemplate)(context);
   const updateContent = Handlebars.compile(updateDtoTemplate)(context);
   const basePath = structure.application || config.smartstack.projectPath;
-  const dtosPath = path8.join(basePath, "DTOs", name);
+  const dtosPath = hierarchy.domainPath ? path8.join(basePath, hierarchy.domainPath, "DTOs") : path8.join(basePath, "DTOs", name);
   const responseFilePath = path8.join(dtosPath, `${name}ResponseDto.cs`);
   const createFilePath = path8.join(dtosPath, `Create${name}Dto.cs`);
   const updateFilePath = path8.join(dtosPath, `Update${name}Dto.cs`);
@@ -3775,7 +3814,8 @@ public record Update{{name}}Dto
   result.instructions.push(`- Update${name}Dto: For PUT requests`);
 }
 async function scaffoldValidator(name, options, structure, config, result, dryRun = false) {
-  const namespace = options?.namespace || `${config.conventions.namespaces.application}.Validators`;
+  const hierarchy = resolveHierarchy(options?.navRoute);
+  const namespace = options?.namespace || (hierarchy.domainPath ? `${config.conventions.namespaces.application}.${hierarchy.domainPath.replace(/[\\/]/g, ".")}.Validators` : `${config.conventions.namespaces.application}.Validators`);
   const properties = options?.entityProperties || [
     { name: "Name", type: "string", required: true, maxLength: 200 },
     { name: "Description", type: "string?", required: false, maxLength: 500 }
@@ -3853,7 +3893,7 @@ public class Update{{name}}DtoValidator : AbstractValidator<Update{{name}}Dto>
   const createValidatorContent = Handlebars.compile(createValidatorTemplate)(context);
   const updateValidatorContent = Handlebars.compile(updateValidatorTemplate)(context);
   const basePath = structure.application || config.smartstack.projectPath;
-  const validatorsPath = path8.join(basePath, "Validators");
+  const validatorsPath = hierarchy.domainPath ? path8.join(basePath, hierarchy.domainPath, "Validators") : path8.join(basePath, "Validators");
   const createValidatorFilePath = path8.join(validatorsPath, `Create${name}DtoValidator.cs`);
   const updateValidatorFilePath = path8.join(validatorsPath, `Update${name}DtoValidator.cs`);
   if (!dryRun) {
@@ -3869,6 +3909,7 @@ public class Update{{name}}DtoValidator : AbstractValidator<Update{{name}}Dto>
   result.instructions.push("Required package: FluentValidation.DependencyInjectionExtensions");
 }
 async function scaffoldRepository(name, options, structure, config, result, dryRun = false) {
+  const hierarchy = resolveHierarchy(options?.navRoute);
   const isSystemEntity = options?.isSystemEntity || false;
   const schema = options?.schema || config.conventions.schemas.platform;
   const dbContextName = schema === "extensions" ? "ExtensionsDbContext" : "CoreDbContext";
@@ -3992,11 +4033,13 @@ public class {{name}}Repository : I{{name}}Repository
   const implementationContent = Handlebars.compile(implementationTemplate)(context);
   const appPath = structure.application || config.smartstack.projectPath;
   const infraPath = structure.infrastructure || path8.join(config.smartstack.projectPath, "Infrastructure");
-  const interfaceFilePath = path8.join(appPath, "Repositories", `I${name}Repository.cs`);
-  const implementationFilePath = path8.join(infraPath, "Repositories", `${name}Repository.cs`);
+  const appRepoDir = hierarchy.infraPath ? path8.join(appPath, "Repositories", hierarchy.infraPath) : path8.join(appPath, "Repositories");
+  const infraRepoDir = hierarchy.infraPath ? path8.join(infraPath, "Repositories", hierarchy.infraPath) : path8.join(infraPath, "Repositories");
+  const interfaceFilePath = path8.join(appRepoDir, `I${name}Repository.cs`);
+  const implementationFilePath = path8.join(infraRepoDir, `${name}Repository.cs`);
   if (!dryRun) {
-    await ensureDirectory(path8.join(appPath, "Repositories"));
-    await ensureDirectory(path8.join(infraPath, "Repositories"));
+    await ensureDirectory(appRepoDir);
+    await ensureDirectory(infraRepoDir);
     await writeText(interfaceFilePath, interfaceContent);
     await writeText(implementationFilePath, implementationContent);
   }
@@ -10866,7 +10909,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 +10929,9 @@ var analyzeCodeQualityTool = {
             "parameter-count",
             "code-duplication",
             "file-size",
+            "unused-members",
+            "duplicated-strings",
+            "unassigned-fields",
             "all"
           ]
         },
@@ -10938,10 +10984,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 +11002,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 +11019,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 +11029,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 +11377,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";