@dailephd/my-dev-kit-lab 0.3.2 → 0.3.4

package/dist/src/audits/codeRot/detectors/testRotDetector.js

@@ -1,10 +1,13 @@
 import fs from "node:fs";
 import path from "node:path";
 import { collectPythonProjectMetadata } from "../../core/pythonProjectMetadata.js";
+import { collectJvmProjectMetadata } from "../../core/jvmProjectMetadata.js";
 import { readBoundedFileText } from "../utils/boundedRead.js";
+import { baseNameNoExt } from "../utils/filePatternUtils.js";
 import { deduplicateIssuesById, makeCodeRotIssue } from "../utils/issueFactories.js";
 import { getParsedSourceFacts, indexSourceFactsByPath } from "../utils/sourceFactsLookup.js";
 import { splitLines } from "../utils/textLines.js";
+import { jvmImportCandidatePaths, jvmImportLooksPossiblyLocal, jvmImportSimpleName, } from "../utils/jvmSourceFactsUtils.js";
 // ---------------------------------------------------------------------------
 // v0.3.0 Batch 4 — test-rot detector.
 //
@@ -51,6 +54,9 @@ export const TEST_ROT_DETECTOR = {
         // required condition -- its absence must not change whether a finding
         // is emitted, only add or omit one extra evidence line.
         const pythonMetadata = collectPythonProjectMetadata(ctx.target.rootPath, ctx.inventory);
+        // v0.3.3 Batch 2 -- same "computed once, weak supporting context only"
+        // treatment as pythonMetadata above.
+        const jvmMetadata = collectJvmProjectMetadata(ctx.target.rootPath, ctx.inventory);
         for (const testFile of ctx.inventory.testFiles) {
             const content = readBoundedFileText(ctx.target.rootPath, testFile.relativePath, testFile.sizeBytes, MAX_READ_BYTES);
             if (content === null)
@@ -87,6 +93,15 @@ export const TEST_ROT_DETECTOR = {
                 // this guard is the fix for that latent cross-language bug.
                 issues.push(...findMissingPythonSourceImports(ctx, testFile.relativePath, parsedFacts, pythonMetadata));
             }
+            else if (parsedFacts?.language === "java" || parsedFacts?.language === "kotlin") {
+                // v0.3.3 Batch 2 -- Java/Kotlin imports are fully-qualified dotted
+                // package names ("com.example.Foo"), neither TS/JS's path-like
+                // "./module" syntax nor Python's dotted-relative-import syntax.
+                // Routing them through either existing resolver would misresolve
+                // every import -- this guard is the JVM analogue of the Python
+                // guard immediately above.
+                issues.push(...findMissingJvmSourceImports(ctx, testFile.relativePath, parsedFacts, jvmMetadata));
+            }
             else if (parsedFacts) {
                 issues.push(...findMissingSourceImportsFromSourceFacts(ctx, testFile.relativePath, parsedFacts));
             }
@@ -291,6 +306,117 @@ function findMissingPythonSourceImports(ctx, testRelativePath, facts, pythonMeta
     }
     return issues;
 }
+// v0.3.3 Batch 2 -- Java/Kotlin-specific counterpart to
+// findMissingSourceImportsFromSourceFacts()/findMissingPythonSourceImports()
+// above. Only ever called for facts with `language === "java"` or
+// `"kotlin"` (see caller) -- kept fully separate from both existing
+// resolvers for the same reason the Python resolver is kept separate from
+// the TS/JS one: the resolution algorithm (fully-qualified dotted package
+// names -> conventional Gradle/Maven source-set paths) is genuinely
+// different from either.
+//
+// Deliberately lower severity/confidence than the TS/JS counterpart, same
+// tier as the Python counterpart: this scan has no real classpath/build
+// awareness (no Gradle/Maven execution, no compiler), so it is weaker
+// evidence than the TS/JS analyzer's near-exact relative-path resolution.
+// Standard-library, common third-party test-framework, and wildcard
+// imports are skipped entirely via jvmImportLooksPossiblyLocal() -- see
+// jvmSourceFactsUtils.ts for the full skip-prefix list and rationale.
+function findMissingJvmSourceImports(ctx, testRelativePath, facts, jvmMetadata) {
+    const issues = [];
+    const isKotlin = facts.language === "kotlin";
+    const languageLabel = isKotlin ? "Kotlin" : "Java";
+    // Kotlin may legitimately import Java source in a mixed JVM project;
+    // Java never imports Kotlin-only source through a plain `import`
+    // statement in the way this conservative scan can see, so a Java test
+    // only ever checks .java candidates.
+    const extensions = isKotlin ? ["kt", "java"] : ["java"];
+    // Both recognized main and test source-set directories are checked --
+    // the latter specifically covers the "importing a test-scoped helper
+    // from another test-set file" case (the importing file here is, by
+    // definition, already test-scoped, since this function is only ever
+    // called from the per-test-file loop above).
+    const candidateDirs = [...jvmMetadata.recognizedSourceDirectories, ...jvmMetadata.recognizedTestDirectories];
+    const inventoryBasenameIndex = buildJvmInventoryBasenameIndex(ctx, extensions);
+    for (const imp of facts.imports) {
+        if (!jvmImportLooksPossiblyLocal(imp))
+            continue;
+        // A Java `import static com.example.Foo.bar;` (or a Kotlin top-level
+        // member import) has its *member* name as the last dotted segment, not
+        // a class name -- this analyzer's ImportFact model (shared across
+        // every language) does not distinguish "static import of a member"
+        // from "plain class import", so both interpretations are tried: the
+        // full dotted path as-is (the common, plain-class-import case), and
+        // with its last segment dropped (the static/member-import case). This
+        // is a detector-side fix, not a change to javaAnalyzer.ts/
+        // kotlinAnalyzer.ts's ImportFact shape.
+        const parentSource = imp.source.includes(".") ? imp.source.slice(0, imp.source.lastIndexOf(".")) : null;
+        const conventionalCandidates = [
+            ...jvmImportCandidatePaths(imp.source, candidateDirs, extensions),
+            ...(parentSource ? jvmImportCandidatePaths(parentSource, candidateDirs, extensions) : []),
+        ];
+        const resolved = conventionalCandidates.some((candidate) => fs.existsSync(path.join(ctx.target.rootPath, candidate))) ||
+            inventoryBasenameIndex.has(jvmImportSimpleName(imp.source)) ||
+            (parentSource !== null && inventoryBasenameIndex.has(jvmImportSimpleName(parentSource)));
+        if (resolved)
+            continue;
+        const evidence = [
+            {
+                kind: "file",
+                message: `Analyzer-recorded ${languageLabel} import does not resolve to a candidate local source file under a recognized source-set directory, nor to any inventoried file with a matching basename. This is a best-effort, path-based check -- no compiler/classpath analysis was performed, and no Gradle/Maven execution was performed, so confirm manually before treating it as stale.`,
+                filePath: testRelativePath,
+                excerpt: imp.source,
+                source: DETECTOR_ID,
+                confidence: "low",
+            },
+        ];
+        if (candidateDirs.length > 0) {
+            evidence.push({
+                kind: "observation",
+                message: `Weak supporting context: recognized source-set directories for this project are: ${candidateDirs.join(", ")}.`,
+                source: DETECTOR_ID,
+                confidence: "low",
+            });
+        }
+        issues.push(makeCodeRotIssue({
+            auditType: "code-rot",
+            detectorId: DETECTOR_ID,
+            idCues: [testRelativePath, `missing-${facts.language}-source-import`, imp.source],
+            title: `Test "${testRelativePath}" imports a ${languageLabel} class that may not exist: "${imp.source}"`,
+            description: `${testRelativePath} imports "${imp.source}" (source-facts-derived via the ${languageLabel} analyzer). No candidate local source file was found under a recognized source-set directory, and no inventoried file shares its simple name. This is a deterministic source-facts signal from a conservative, non-semantic scan -- no compiler/classpath analysis was performed, and no Gradle/Maven execution was performed, so this does not resolve the real classpath, package visibility, or multi-module project layout. It may indicate a stale import but is not proof.`,
+            severity: "low",
+            confidence: "low",
+            falsePositiveRisk: "medium",
+            category: "test-rot",
+            recommendedAction: "Confirm the imported class exists (it may resolve via a module/classpath this scan cannot see) before treating this as stale.",
+            suggestedFixStrategy: `Update or remove the import "${imp.source}" in ${testRelativePath} if confirmed stale.`,
+            validationCommands: [`npx vitest run ${testRelativePath}`],
+            releaseBlocking: false,
+            implementationBlocking: false,
+            autoFixEligible: false,
+            evidence,
+            affectedFiles: [testRelativePath],
+        }));
+    }
+    return issues;
+}
+// Lowercased-basename index (without extension) of every inventoried
+// Java/Kotlin file matching the given extensions -- the lenient,
+// last-resort fallback used by findMissingJvmSourceImports() above so a
+// real (if unconventionally placed) local file is never flagged as
+// missing merely because the project doesn't follow the conventional
+// src/main/{java,kotlin} source-set layout (mirrors
+// jvmProjectMetadata.ts's own "non-conventional layout" reasoning).
+function buildJvmInventoryBasenameIndex(ctx, extensions) {
+    const extSet = new Set(extensions.map((e) => `.${e}`));
+    const basenames = new Set();
+    for (const file of ctx.inventory.files) {
+        if (!extSet.has(file.extension))
+            continue;
+        basenames.add(baseNameNoExt(file.relativePath));
+    }
+    return basenames;
+}
 function findStaleNpmRunReferences(testRelativePath, content, scriptNames) {
     const issues = [];
     const seen = new Set();

package/dist/src/audits/codeRot/utils/jvmSourceFactsUtils.js

@@ -0,0 +1,153 @@
+// ---------------------------------------------------------------------------
+// v0.3.3 Batch 2 -- shared JVM (Java/Kotlin) source-facts helpers reused by
+// deadCodeCandidateDetector.ts, duplicateImplementationDetector.ts, and
+// testRotDetector.ts.
+//
+// Deterministic and dependency-free: no Gradle/Maven execution, no
+// classpath resolution, no Java/Kotlin compiler, no traversal outside the
+// target root. Everything here operates purely on already-collected
+// SourceFacts/inventory data (see javaAnalyzer.ts/kotlinAnalyzer.ts/
+// jvmProjectMetadata.ts from v0.3.3 Batch 1).
+// ---------------------------------------------------------------------------
+// Import prefixes considered standard-library or common third-party test
+// framework noise -- never treated as "possibly a local project import" by
+// testRotDetector.ts's JVM resolver, regardless of whether a local file
+// happens to share a path segment. Matched against the import source's
+// leading dotted segments so "java.util.List" matches "java." but a
+// hypothetical local package literally named "javautils.Foo" (no dot after
+// "java") would not.
+const JVM_SKIPPABLE_IMPORT_PREFIXES = [
+    "java.",
+    "javax.",
+    "jakarta.",
+    "kotlin.",
+    "kotlinx.",
+    "org.junit.",
+    "org.assertj.",
+    "org.mockito.",
+    "org.hamcrest.",
+    "io.kotest.",
+];
+export function isJvmSkippableImportSource(source) {
+    return JVM_SKIPPABLE_IMPORT_PREFIXES.some((prefix) => source.startsWith(prefix));
+}
+// True for a wildcard-style import (`import com.example.*` or, for Java
+// static imports, `import static com.example.Foo.*`). Deliberately treated
+// as never "safely local" by testRotDetector.ts's JVM resolver -- there is
+// no way to derive a single candidate file from a wildcard without real
+// classpath/package-member awareness, so guessing would either miss real
+// stale imports (if resolved unconditionally) or produce high-noise false
+// positives (if flagged unconditionally). Skipping entirely is the
+// conservative choice.
+export function isJvmWildcardImportSource(source) {
+    return source.endsWith(".*");
+}
+// The simple (unqualified) name a dotted JVM import source resolves to --
+// the last segment after the final ".". For a Java static import
+// (`static com.example.Foo.bar`), this is the imported static member name,
+// not the enclosing class -- an accepted, documented conflation for this
+// conservative, best-effort scan (see javaAnalyzer.ts's own header comment
+// on why `import static` is not modeled any more precisely than a plain
+// import).
+export function jvmImportSimpleName(source) {
+    const idx = source.lastIndexOf(".");
+    return idx === -1 ? source : source.slice(idx + 1);
+}
+// Converts a dotted JVM import source (e.g. "com.example.Foo") into a
+// package-shaped relative path segment (e.g. "com/example/Foo"), dropping
+// any trailing wildcard/member segment handling -- callers are responsible
+// for skipping wildcards via isJvmWildcardImportSource() first.
+export function jvmImportToPackagePath(source) {
+    return source.split(".").join("/");
+}
+// Candidate on-disk relative paths for a (non-wildcard, non-skippable)
+// import, given the project's recognized Java/Kotlin source-set
+// directories (see jvmProjectMetadata.ts's recognizedSourceDirectories).
+// Conservative and path-based only: this never resolves the real classpath,
+// only checks the conventional Gradle/Maven `src/main/{java,kotlin}/...`
+// layout. `extensions` lets a Kotlin importer also check `.java` (Kotlin
+// can legitimately import Java source in a mixed JVM project) while a Java
+// importer only ever checks `.java`.
+export function jvmImportCandidatePaths(source, recognizedSourceDirectories, extensions) {
+    const packagePath = jvmImportToPackagePath(source);
+    const candidates = [];
+    for (const dir of recognizedSourceDirectories) {
+        for (const ext of extensions) {
+            candidates.push(`${dir}/${packagePath}.${ext}`);
+        }
+    }
+    return candidates;
+}
+// True when an ImportFact looks worth checking for local-file existence at
+// all -- i.e. not a standard-library/common-test-framework import and not a
+// wildcard. Callers still need their own existence check; this only
+// filters out imports this conservative scan should never second-guess.
+export function jvmImportLooksPossiblyLocal(imp) {
+    if (isJvmWildcardImportSource(imp.source))
+        return false;
+    if (isJvmSkippableImportSource(imp.source))
+        return false;
+    // A bare, undotted import (e.g. a same-package reference, or a malformed
+    // scan artifact) has no package path to resolve against -- not
+    // checkable by this path-based resolver.
+    if (!imp.source.includes("."))
+        return false;
+    return true;
+}
+// ---------------------------------------------------------------------------
+// Declaration-name conservatism helpers.
+// ---------------------------------------------------------------------------
+// Common JVM class/type names that legitimately repeat across unrelated
+// projects/modules (a "Main" class, an "App" entrypoint, a "Config" class
+// per module, etc.) -- excluded from duplicateImplementationDetector.ts's
+// JVM duplicate-declaration-candidate check the same way
+// GENERIC_DECLARATION_NAMES/GENERIC_INFRA_BASENAMES already exclude their
+// TS/JS/Python/file-basename equivalents.
+const JVM_COMMON_TYPE_NAMES = new Set([
+    "main",
+    "app",
+    "application",
+    "config",
+    "configuration",
+    "utils",
+    "helper",
+    "factory",
+    "builder",
+    "manager",
+    "service",
+    "controller",
+    "repository",
+]);
+export function isJvmCommonLowSignalDeclarationName(name) {
+    const lower = name.toLowerCase();
+    if (JVM_COMMON_TYPE_NAMES.has(lower))
+        return true;
+    if (lower.startsWith("test"))
+        return true;
+    return lower === "setup" || lower === "teardown";
+}
+// Java/Kotlin lifecycle, `Object`-override, and bean-accessor-shaped names
+// -- excluded from deadCodeCandidateDetector.ts's JVM dead-code-candidate
+// check, the same way isGenericOrTestPrefixedDeclarationName() already
+// excludes TS/JS/Python's equivalents. `get*`/`set*`/`is*` in particular
+// cover the extremely common JavaBean accessor convention, where a
+// "no detected cross-file reference" signal is essentially meaningless
+// (framework/reflection-based access is invisible to this static scan).
+const JVM_LIFECYCLE_EXACT_NAMES = new Set([
+    "main",
+    "tostring",
+    "equals",
+    "hashcode",
+    "compareto",
+    "clone",
+    "setup",
+    "teardown",
+    "copy", // Kotlin data class synthesized-like member
+]);
+const JVM_LIFECYCLE_PREFIXES = ["get", "set", "is", "can", "should", "before", "after", "test", "component"];
+export function isJvmLifecycleOrConventionalDeclarationName(name) {
+    const lower = name.toLowerCase();
+    if (JVM_LIFECYCLE_EXACT_NAMES.has(lower))
+        return true;
+    return JVM_LIFECYCLE_PREFIXES.some((prefix) => lower.startsWith(prefix));
+}

package/dist/src/audits/core/collectSourceFacts.js

@@ -41,17 +41,18 @@ export async function collectSourceFacts(targetRoot, inventory, registry = DEFAU
     // filtering preserves that order, so no re-sort is needed here.
     const eligible = inventory.files.filter((entry) => ANALYZABLE_ROLES.has(entry.role));
     for (const entry of eligible) {
+        const relativePath = normalizeRelativePath(entry.relativePath);
         const analyzer = selectLanguageAnalyzer(registry, entry.language, entry.extension);
         if (!analyzer) {
-            files.push(buildFallbackFacts(entry));
+            files.push(buildFallbackFacts(entry, relativePath));
             continue;
         }
-        const absolutePath = path.join(resolvedRoot, entry.relativePath);
+        const absolutePath = resolveInventoryFilePath(resolvedRoot, relativePath);
         try {
             const content = fs.readFileSync(absolutePath, "utf8");
             const facts = await analyzer.analyzeFile({
                 targetRoot: resolvedRoot,
-                relativePath: entry.relativePath,
+                relativePath,
                 absolutePath,
                 content,
                 inventoryEntry: entry,
@@ -65,13 +66,13 @@ export async function collectSourceFacts(targetRoot, inventory, registry = DEFAU
             const diagnostic = {
                 severity: "error",
                 code: "analyzer-error",
-                message: `Analyzer "${analyzer.id}" failed on "${entry.relativePath}": ${message}`,
-                path: entry.relativePath,
+                message: `Analyzer "${analyzer.id}" failed on "${relativePath}": ${message}`,
+                path: relativePath,
                 analyzerId: analyzer.id,
             };
             analyzerDiagnostics.push(diagnostic);
             files.push({
-                relativePath: entry.relativePath,
+                relativePath,
                 language: entry.language,
                 role: entry.role,
                 parseStatus: "parse-error",
@@ -94,7 +95,7 @@ export async function collectSourceFacts(targetRoot, inventory, registry = DEFAU
         warnings,
     };
 }
-function buildFallbackFacts(entry) {
+function buildFallbackFacts(entry, relativePath) {
     const known = KNOWN_LANGUAGES.has(entry.language);
     const parseStatus = known ? "file-level-only" : "unsupported";
     const diagnostic = known
@@ -102,18 +103,18 @@ function buildFallbackFacts(entry) {
             severity: "info",
             code: "no-analyzer-registered",
             message: `No language analyzer is registered for "${entry.language}" yet; only inventory-level facts are available.`,
-            path: entry.relativePath,
+            path: relativePath,
             analyzerId: null,
         }
         : {
             severity: "info",
             code: "unsupported-language",
             message: `Language "${entry.language}" is not supported for source-fact extraction.`,
-            path: entry.relativePath,
+            path: relativePath,
             analyzerId: null,
         };
     return {
-        relativePath: entry.relativePath,
+        relativePath,
         language: entry.language,
         role: entry.role,
         parseStatus,
@@ -126,6 +127,16 @@ function buildFallbackFacts(entry) {
         diagnostics: [diagnostic],
     };
 }
+function normalizeRelativePath(relativePath) {
+    const normalized = path.posix.normalize(relativePath.replace(/\\/g, "/"));
+    if (normalized === ".")
+        return "";
+    return normalized.replace(/^\/+/, "").replace(/^\.\//, "");
+}
+function resolveInventoryFilePath(root, relativePath) {
+    const parts = relativePath.split("/").filter((part) => part.length > 0);
+    return parts.length === 0 ? root : path.resolve(root, ...parts);
+}
 function countByLanguage(files) {
     const counts = Object.fromEntries(NORMALIZED_LANGUAGES.map((l) => [l, 0]));
     for (const file of files) {