fix: reduce high-volume precision false positives

internal/codeguard/checks/design/local_abstraction.go

@@ -117,18 +117,23 @@ func leakFindings(env support.Context, file string, source string) []core.Findin
 		if trimmed == "" || strings.HasPrefix(trimmed, "//") || strings.HasPrefix(trimmed, "#") {
 			continue
 		}
+		codeLine := stripInlineDesignComment(trimmed)
+		if codeLine == "" {
+			continue
+		}
 		lineNo := idx + 1
-		if domainPath && infraLeakPattern.MatchString(trimmed) {
+		if domainPath && infraLeakPattern.MatchString(codeLine) {
 			findings = append(findings, designFinding(env, ruleInfrastructureLeak, file, lineNo,
 				"infrastructure/framework type leaks into a domain or public boundary", core.ConfidenceHigh))
 		}
-		if persistenceBoundaryPath && (apiPath || handlerPath || isPublicDeclaration(trimmed)) && persistenceLeakPattern.MatchString(trimmed) &&
-			!allowedGeneratedPersistenceEnumLine(trimmed) && !allowedTypeScriptRecordUtilityLine(trimmed) &&
-			!allowedUIPropsDerivedTypeLine(file, trimmed) && !allowedFrameworkDTOBoundaryLine(file, trimmed) {
+		if persistenceBoundaryPath && !isPackageAPIImplementationPath(file) && (apiPath || handlerPath || isPublicDeclaration(codeLine)) &&
+			persistenceLeakPattern.MatchString(codeLine) &&
+			!allowedGeneratedPersistenceEnumLine(codeLine) && !allowedTypeScriptRecordUtilityLine(codeLine) &&
+			!allowedUIPropsDerivedTypeLine(file, codeLine) && !allowedFrameworkDTOBoundaryLine(file, codeLine) {
 			findings = append(findings, designFinding(env, rulePersistenceLeak, file, lineNo,
-				fmt.Sprintf("persistence model or ORM concept leaks through boundary at %s:%d: %s", file, lineNo, findingLineExcerpt(trimmed)), core.ConfidenceHigh))
+				fmt.Sprintf("persistence model or ORM concept leaks through boundary at %s:%d: %s", file, lineNo, findingLineExcerpt(codeLine)), core.ConfidenceHigh))
 		}
-		if domainPath && configLeakPattern.MatchString(trimmed) {
+		if domainPath && configLeakPattern.MatchString(codeLine) {
 			findings = append(findings, designFinding(env, ruleConfigurationLeak, file, lineNo,
 				"configuration or environment concern leaks into domain code", core.ConfidenceMedium))
 		}
@@ -481,6 +486,11 @@ func isAPIPath(file string) bool {
 	return strings.Contains(normalized, "/contract/")
 }
 
+func isPackageAPIImplementationPath(file string) bool {
+	normalized := strings.ToLower(filepathSlash(file))
+	return strings.Contains(normalized, "/packages/api/src/") || strings.HasPrefix(normalized, "packages/api/src/")
+}
+
 func isContractBoundaryPath(file string) bool {
 	normalized := strings.ToLower(filepathSlash(file))
 	if isFrontendUIPath(file) {
@@ -522,6 +532,16 @@ func filepathSlash(path string) string {
 	return strings.ReplaceAll(path, "\\", "/")
 }
 
+func stripInlineDesignComment(line string) string {
+	if idx := strings.Index(line, "//"); idx >= 0 {
+		line = line[:idx]
+	}
+	if idx := strings.Index(line, "#"); idx >= 0 {
+		line = line[:idx]
+	}
+	return strings.TrimSpace(line)
+}
+
 func isPublicDeclaration(line string) bool {
 	return strings.HasPrefix(line, "export ") || strings.HasPrefix(line, "public ") ||
 		strings.HasPrefix(line, "func ") || strings.HasPrefix(line, "type ") ||

internal/codeguard/checks/quality/quality_precision.go

@@ -7,7 +7,6 @@ import (
 	"go/printer"
 	"go/token"
 	"regexp"
-	"strconv"
 	"strings"
 
 	"github.com/devr-tools/codeguard/internal/codeguard/checks/support"
@@ -469,7 +468,7 @@ func primitiveObsession(fn precisionFunction) bool {
 }
 
 func hiddenSideEffect(file string, fn precisionFunction) bool {
-	if isFrameworkOrchestrationBoundary(file, fn) {
+	if isFrameworkOrchestrationBoundary(file, fn) || isReactComponentOrNamedHookBoundary(file, fn) || explicitMutationName(fn.Name) {
 		return false
 	}
 	if !queryFunctionPrefixPattern.MatchString(strings.ToLower(fn.Name)) {
@@ -511,7 +510,7 @@ func isDomainLevelCall(callee string) bool {
 }
 
 func commandQueryMix(file string, fn precisionFunction) bool {
-	if isFrameworkOrchestrationBoundary(file, fn) || isReactComponentOrHookBoundary(file, fn) {
+	if isFrameworkOrchestrationBoundary(file, fn) || isReactComponentOrNamedHookBoundary(file, fn) || explicitMutationName(fn.Name) {
 		return false
 	}
 	if !fn.Returns {
@@ -631,23 +630,6 @@ func parsedMutableGlobalFindings(env support.Context, file string, parsed *suppo
 	return findings
 }
 
-func parsedDuplicatedKnowledgeFindings(env support.Context, file string, parsed *support.ParsedFile) []core.Finding {
-	if isQualityFixturePath(file) {
-		return nil
-	}
-	seen := map[string]int{}
-	for _, statement := range parsed.Module.Statements {
-		for _, literal := range domainKnowledgeLiterals(statement.Raw) {
-			if first, exists := seen[literal]; exists {
-				return []core.Finding{precisionWarnFinding(env, qualityDuplicatedKnowledgeRuleID, file, statement.Line,
-					fmt.Sprintf("business literal %s is duplicated near line %d; centralize shared domain knowledge", literal, first), core.ConfidenceLow)}
-			}
-			seen[literal] = statement.Line
-		}
-	}
-	return nil
-}
-
 func redundantCommentFindings(env support.Context, file string, source string) []core.Finding {
 	if isQualityFixturePath(file) {
 		return nil
@@ -689,26 +671,6 @@ func sourceMutableGlobalFindings(env support.Context, file string, source string
 	return nil
 }
 
-func sourceDuplicatedKnowledgeFindings(env support.Context, file string, source string) []core.Finding {
-	if isQualityFixturePath(file) {
-		return nil
-	}
-	seen := map[string]int{}
-	for idx, line := range strings.Split(strings.ReplaceAll(source, "\r\n", "\n"), "\n") {
-		if strings.TrimSpace(line) == "" {
-			continue
-		}
-		for _, literal := range domainKnowledgeLiterals(line) {
-			if first, exists := seen[literal]; exists {
-				return []core.Finding{precisionWarnFinding(env, qualityDuplicatedKnowledgeRuleID, file, idx+1,
-					fmt.Sprintf("business literal %s is duplicated near line %d; centralize shared domain knowledge", literal, first), core.ConfidenceLow)}
-			}
-			seen[literal] = idx + 1
-		}
-	}
-	return nil
-}
-
 func redundantCommentVerb(comment string) string {
 	match := redundantCommentPattern.FindStringSubmatch(comment)
 	if len(match) < 3 {
@@ -717,74 +679,6 @@ func redundantCommentVerb(comment string) string {
 	return strings.ToLower(match[2])
 }
 
-func domainKnowledgeLiterals(line string) []string {
-	if duplicatedKnowledgeLineIsDisplayOnly(line) {
-		return nil
-	}
-	matches := regexp.MustCompile(`"([^"]{2,80})"|'([^']{2,80})'|\b\d+(?:\.\d+)?\b`).FindAllString(line, -1)
-	out := make([]string, 0, len(matches))
-	for _, match := range matches {
-		if domainKnowledgeLiteral(match) {
-			out = append(out, match)
-		}
-	}
-	return out
-}
-
-func duplicatedKnowledgeLineIsDisplayOnly(line string) bool {
-	lowered := strings.ToLower(line)
-	if strings.Contains(lowered, "classname") || strings.Contains(lowered, "clasname") || strings.Contains(lowered, "class:") {
-		return true
-	}
-	if strings.Contains(line, "<") && strings.Contains(line, ">") {
-		return true
-	}
-	if strings.Contains(lowered, "label:") || strings.Contains(lowered, "placeholder:") || strings.Contains(lowered, "title:") ||
-		strings.Contains(lowered, "aria-label") {
-		return true
-	}
-	return false
-}
-
-func domainKnowledgeLiteral(value string) bool {
-	trimmed := strings.Trim(value, `"'`)
-	if trimmed == "" || len(trimmed) > 80 {
-		return false
-	}
-	if len(trimmed) < 4 && !strings.ContainsAny(trimmed, "0123456789") {
-		return false
-	}
-	if numeric, ok := duplicatedKnowledgeNumber(trimmed); ok {
-		return numeric >= 10
-	}
-	if likelyDisplayLabel(trimmed) {
-		return false
-	}
-	return domainPrimitiveNamePattern.MatchString(trimmed) || strings.Contains(trimmed, "_")
-}
-
-func duplicatedKnowledgeNumber(value string) (int, bool) {
-	number, err := strconv.Atoi(value)
-	if err != nil {
-		return 0, false
-	}
-	if number < 0 {
-		number = -number
-	}
-	return number, true
-}
-
-func likelyDisplayLabel(value string) bool {
-	if strings.Contains(value, "_") {
-		return false
-	}
-	if strings.ContainsAny(value, "-/:.") {
-		return false
-	}
-	words := strings.Fields(value)
-	return len(words) > 0 && len(words) <= 3
-}
-
 func unsafeScriptNumericConversion(text string) bool {
 	lowered := strings.ToLower(text)
 	return strings.Contains(lowered, "static_cast<int8_t>") ||

internal/codeguard/checks/quality/quality_precision_duplication.go

@@ -0,0 +1,159 @@
+package quality
+
+import (
+	"fmt"
+	"regexp"
+	"strconv"
+	"strings"
+
+	"github.com/devr-tools/codeguard/internal/codeguard/checks/support"
+	"github.com/devr-tools/codeguard/internal/codeguard/core"
+)
+
+func parsedDuplicatedKnowledgeFindings(env support.Context, file string, parsed *support.ParsedFile) []core.Finding {
+	if isQualityFixturePath(file) {
+		return nil
+	}
+	seen := map[string]int{}
+	for _, statement := range parsed.Module.Statements {
+		for _, literal := range domainKnowledgeLiterals(statement.Raw) {
+			if first, exists := seen[literal]; exists {
+				return []core.Finding{precisionWarnFinding(env, qualityDuplicatedKnowledgeRuleID, file, statement.Line,
+					fmt.Sprintf("business literal %s is duplicated near line %d; centralize shared domain knowledge", literal, first), core.ConfidenceLow)}
+			}
+			seen[literal] = statement.Line
+		}
+	}
+	return nil
+}
+
+func sourceDuplicatedKnowledgeFindings(env support.Context, file string, source string) []core.Finding {
+	if isQualityFixturePath(file) {
+		return nil
+	}
+	seen := map[string]int{}
+	for idx, line := range strings.Split(strings.ReplaceAll(source, "\r\n", "\n"), "\n") {
+		if strings.TrimSpace(line) == "" {
+			continue
+		}
+		for _, literal := range domainKnowledgeLiterals(line) {
+			if first, exists := seen[literal]; exists {
+				return []core.Finding{precisionWarnFinding(env, qualityDuplicatedKnowledgeRuleID, file, idx+1,
+					fmt.Sprintf("business literal %s is duplicated near line %d; centralize shared domain knowledge", literal, first), core.ConfidenceLow)}
+			}
+			seen[literal] = idx + 1
+		}
+	}
+	return nil
+}
+
+func domainKnowledgeLiterals(line string) []string {
+	if duplicatedKnowledgeLineIsDisplayOnly(line) {
+		return nil
+	}
+	matches := regexp.MustCompile(`"([^"]{2,80})"|'([^']{2,80})'|\b\d+(?:\.\d+)?\b`).FindAllString(line, -1)
+	out := make([]string, 0, len(matches))
+	for _, match := range matches {
+		if domainKnowledgeLiteralInLine(match, line) {
+			out = append(out, match)
+		}
+	}
+	return out
+}
+
+func duplicatedKnowledgeLineIsDisplayOnly(line string) bool {
+	lowered := strings.ToLower(line)
+	if strings.Contains(lowered, "classname") || strings.Contains(lowered, "clasname") || strings.Contains(lowered, "class:") {
+		return true
+	}
+	if strings.Contains(line, "<") && strings.Contains(line, ">") {
+		return true
+	}
+	if strings.Contains(lowered, "label:") || strings.Contains(lowered, "placeholder:") || strings.Contains(lowered, "title:") ||
+		strings.Contains(lowered, "aria-label") {
+		return true
+	}
+	return false
+}
+
+func domainKnowledgeLiteral(value string) bool {
+	return domainKnowledgeLiteralInLine(value, "")
+}
+
+func domainKnowledgeLiteralInLine(value string, line string) bool {
+	trimmed := strings.Trim(value, `"'`)
+	if trimmed == "" || len(trimmed) > 80 {
+		return false
+	}
+	if len(trimmed) < 4 && !strings.ContainsAny(trimmed, "0123456789") {
+		return false
+	}
+	if numeric, ok := duplicatedKnowledgeNumber(trimmed); ok {
+		return duplicatedKnowledgeNumericLiteral(numeric, line)
+	}
+	if duplicatedKnowledgeEnumStatusLiteral(trimmed, line) {
+		return false
+	}
+	if likelyDisplayLabel(trimmed) {
+		return false
+	}
+	return domainPrimitiveNamePattern.MatchString(trimmed) || strings.Contains(trimmed, "_")
+}
+
+func duplicatedKnowledgeNumericLiteral(number int, line string) bool {
+	if number < 0 {
+		number = -number
+	}
+	if number < 100 {
+		return false
+	}
+	lowered := strings.ToLower(line)
+	return line == "" ||
+		domainPrimitiveNamePattern.MatchString(lowered) ||
+		durationNamePattern.MatchString(lowered) ||
+		sizeNamePattern.MatchString(lowered) ||
+		moneyNamePattern.MatchString(lowered)
+}
+
+func duplicatedKnowledgeEnumStatusLiteral(value string, line string) bool {
+	if line == "" {
+		return false
+	}
+	trimmed := strings.TrimSpace(value)
+	if trimmed == "" {
+		return false
+	}
+	enumLike := strings.Contains(trimmed, "_") || strings.ToUpper(trimmed) == trimmed
+	if !enumLike {
+		return false
+	}
+	loweredLine := strings.ToLower(line)
+	for _, marker := range []string{"enum", "status", "type:", "kind:", "value:", "option", "label", "as const", "satisfies"} {
+		if strings.Contains(loweredLine, marker) {
+			return true
+		}
+	}
+	return false
+}
+
+func duplicatedKnowledgeNumber(value string) (int, bool) {
+	number, err := strconv.Atoi(value)
+	if err != nil {
+		return 0, false
+	}
+	if number < 0 {
+		number = -number
+	}
+	return number, true
+}
+
+func likelyDisplayLabel(value string) bool {
+	if strings.Contains(value, "_") {
+		return false
+	}
+	if strings.ContainsAny(value, "-/:.") {
+		return false
+	}
+	words := strings.Fields(value)
+	return len(words) > 0 && len(words) <= 3
+}