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

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/javaAnalyzer.js

@@ -0,0 +1,282 @@
+// ---------------------------------------------------------------------------
+// v0.3.3 Batch 1 -- conservative, dependency-free Java source analyzer.
+//
+// There is no Java compiler/parser available in this Node/TypeScript
+// project, and per this batch's scope this analyzer must not add a new
+// parser dependency (no javac, no javaparser-style library). Facts are
+// extracted with a deliberately narrow, brace-depth-tracking line scan --
+// not a real tokenizer, not an AST, and not a syntax validator. Same
+// LanguageAnalyzer contract, same SourceFileFacts shape, and the same
+// size-bounding philosophy as typescriptJavaScriptAnalyzer.ts/
+// pythonAnalyzer.ts, but confidence is necessarily lower since nothing here
+// proves the file is syntactically valid Java.
+//
+// What this DOES extract:
+//   - a single `package foo.bar;` declaration
+//   - `import foo.bar.Baz;` and `import static foo.bar.Baz.member;` (both
+//     recorded via the existing generic ImportFactKind "static" -- the same
+//     "resolved through a static, syntactic import statement" meaning
+//     already used by every other analyzer in this project, not a claim
+//     about Java's specific "import static" keyword)
+//   - top-level and nested class/interface/enum declarations
+//   - method and constructor declarations directly inside a class/
+//     interface/enum body (both recorded as DeclarationFactKind "method" --
+//     there is no dedicated constructor kind in the shared model, and
+//     "method" is a safe, non-overclaiming fit)
+//   - visibility (public/protected/private/package-private), folded into
+//     the existing `exported` boolean: `exported: true` only for an
+//     explicit `public` modifier, `false` for protected/private/
+//     package-private -- see "Visibility mapping" below for why no new
+//     schema field was added
+//   - line counts, parse/analyze status, and diagnostics for degraded
+//     parsing
+//
+// What this explicitly does NOT do: real Java compilation, type resolution,
+// symbol/overload resolution, inheritance analysis, annotation/framework
+// lifecycle understanding, runtime behavior, Gradle/Maven source-set
+// validation, semantic duplicate-implementation proof, or dead-code proof.
+// Field/property declarations are not extracted (out of this batch's
+// required scope, and harder to distinguish conservatively from local
+// variable declarations via regex alone). Java text blocks (`"""..."""`,
+// Java 15+) are not given special multi-line handling the way Kotlin's raw
+// strings are in kotlinAnalyzer.ts -- if present, a `{`/`}`/quote character
+// inside one could be slightly miscounted, which is an accepted, narrow
+// limitation of a regex/brace-counting scanner rather than a crash risk.
+//
+// Visibility mapping (no SourceFacts schema change):
+//   DeclarationFact has no dedicated visibility field, and per this batch's
+//   "prefer no schema change" guidance, none is added here. Java's four
+//   visibility levels collapse onto the existing boolean `exported` the
+//   same way the Python analyzer already folds its own export heuristic
+//   into that field: `public` -> true, everything else (protected/private/
+//   package-private) -> false. This intentionally loses the
+//   protected-vs-private-vs-package-private distinction; callers that need
+//   finer detail must re-derive it from source, which this analyzer does
+//   not claim to make unnecessary.
+// ---------------------------------------------------------------------------
+export const JAVA_ANALYZER_ID = "java-analyzer";
+const SUPPORTED_EXTENSIONS = [".java"];
+// Mirrors typescriptJavaScriptAnalyzer.ts/pythonAnalyzer.ts's bound.
+const MAX_ANALYZABLE_BYTES = 1_000_000;
+const PACKAGE_LINE_PATTERN = /^\s*package\s+([\w.]+)\s*;/;
+const IMPORT_LINE_PATTERN = /^\s*import\s+(static\s+)?([\w.]+(?:\.\*)?)\s*;/;
+// Requires an explicit visibility modifier to be captured separately so
+// "no modifier present" (package-private) is distinguishable from an
+// explicit one -- see MODIFIER_PATTERN below.
+const MODIFIER_WORDS = "(?:public|protected|private|static|final|abstract|sealed|non-sealed|strictfp|synchronized|native|default)";
+const TYPE_DECL_PATTERN = new RegExp(`^\\s*(?:${MODIFIER_WORDS}\\s+)*(class|interface|enum|record)\\s+(\\w+)`);
+// Two separate word-tokens (a return-type-like token, then the method name)
+// before the parameter list -- this is what keeps `if (...)`, `for (...)`,
+// `while (...)`, `switch (...)`, and plain method-call statements
+// (`foo.bar(x);`, a single dotted token with no preceding space) from ever
+// matching: those all have only one space-separated token before `(`.
+// The trailing group accepts either just an opening brace (multi-line
+// body), a semicolon (abstract/interface method declaration), or a full
+// one-liner body with no nested braces (e.g. `{ return true; }`, `{}`) --
+// without the last alternative, a common one-liner accessor/getter would
+// never be recognized as a declaration at all.
+const METHOD_LINE_PATTERN = new RegExp(`^\\s*(?:${MODIFIER_WORDS}\\s+)*[\\w<>\\[\\],.?]+\\s+(\\w+)\\s*\\(([^()]*)\\)\\s*(?:throws\\s+[\\w.,\\s<>]+)?\\s*(?:\\{[^{}]*\\}|\\{|;)\\s*$`);
+// A constructor has no return-type token: just an optional visibility
+// modifier, the identifier, then the parameter list. The caller only
+// accepts a match here when the identifier equals the enclosing class/
+// enum/record name, which is what actually distinguishes a real
+// constructor from a stray call-like statement (see analyzeFile below).
+const CONSTRUCTOR_LINE_PATTERN = /^\s*(?:(?:public|protected|private)\s+)?(\w+)\s*\(([^()]*)\)\s*(?:throws\s+[\w.,\s<>]+)?\s*(?:\{[^{}]*\}|\{)\s*$/;
+const EXPLICIT_MODIFIER_PATTERN = /(?:^|\s)(public|protected|private)(?:\s|$)/;
+export const JAVA_ANALYZER = {
+    id: JAVA_ANALYZER_ID,
+    supportedLanguages: ["java"],
+    supportedExtensions: SUPPORTED_EXTENSIONS,
+    analyzeFile,
+};
+function analyzeFile(input) {
+    const { relativePath, language, role, content, inventoryEntry } = input;
+    if (Buffer.byteLength(content, "utf8") > MAX_ANALYZABLE_BYTES) {
+        return {
+            relativePath,
+            language,
+            role,
+            parseStatus: "file-level-only",
+            analyzerId: JAVA_ANALYZER_ID,
+            lineCount: inventoryEntry.lineCount,
+            imports: [],
+            exports: [],
+            declarations: [],
+            references: [],
+            diagnostics: [
+                {
+                    severity: "info",
+                    code: "file-too-large-for-analysis",
+                    message: `File exceeds the ${MAX_ANALYZABLE_BYTES}-byte analyzer bound; only inventory-level facts are available.`,
+                    path: relativePath,
+                    analyzerId: JAVA_ANALYZER_ID,
+                },
+            ],
+        };
+    }
+    const diagnostics = [];
+    const { logical, hadUnterminatedBlockComment } = buildLogicalLines(content);
+    const imports = [];
+    const declarations = [];
+    const scopeStack = [];
+    let depth = 0;
+    let packageSeen = false;
+    for (let i = 0; i < logical.length; i++) {
+        const line = logical[i];
+        const lineNumber = i + 1;
+        if (line.trim().length === 0) {
+            continue;
+        }
+        if (!packageSeen) {
+            const packageMatch = line.match(PACKAGE_LINE_PATTERN);
+            if (packageMatch)
+                packageSeen = true;
+        }
+        const importMatch = line.match(IMPORT_LINE_PATTERN);
+        if (importMatch) {
+            imports.push({ source: importMatch[2], kind: "static", line: lineNumber });
+        }
+        const typeMatch = line.match(TYPE_DECL_PATTERN);
+        // "record" (a restricted, implicitly-final class variant) is folded
+        // into the existing "class" DeclarationFactKind/ScopeKind -- there is
+        // no dedicated record kind in the shared model, and "class" is a safe,
+        // non-overclaiming fit (a record's synthesized accessor/constructor
+        // methods are not separately modeled).
+        const normalizedKind = typeMatch ? (typeMatch[1] === "record" ? "class" : typeMatch[1]) : null;
+        if (typeMatch && normalizedKind) {
+            const name = typeMatch[2];
+            declarations.push({
+                name,
+                kind: normalizedKind,
+                exported: EXPLICIT_MODIFIER_PATTERN.exec(line.slice(0, typeMatch.index + typeMatch[0].length))?.[1] === "public",
+                line: lineNumber,
+            });
+        }
+        else if (scopeStack.length > 0 && depth === scopeStack[scopeStack.length - 1].bodyDepth) {
+            const currentScope = scopeStack[scopeStack.length - 1];
+            const methodMatch = line.match(METHOD_LINE_PATTERN);
+            if (methodMatch) {
+                pushMethodDeclaration(declarations, methodMatch[1], line, lineNumber);
+            }
+            else {
+                const ctorMatch = line.match(CONSTRUCTOR_LINE_PATTERN);
+                if (ctorMatch && ctorMatch[1] === currentScope.name) {
+                    pushMethodDeclaration(declarations, ctorMatch[1], line, lineNumber);
+                }
+            }
+        }
+        const depthBefore = depth;
+        depth += countChar(line, "{") - countChar(line, "}");
+        if (typeMatch && normalizedKind) {
+            // Always push assuming depth+1 is the body -- whether the opening
+            // brace was on this same line (K&R style, the common case) or a
+            // subsequent line (Allman style), the actual `{` character
+            // eventually seen will bump `depth` to exactly `depthBefore + 1`,
+            // matching this assumption either way.
+            scopeStack.push({ kind: normalizedKind, name: typeMatch[2], bodyDepth: depthBefore + 1 });
+        }
+        while (scopeStack.length > 0 && depth < scopeStack[scopeStack.length - 1].bodyDepth) {
+            scopeStack.pop();
+        }
+    }
+    if (hadUnterminatedBlockComment) {
+        diagnostics.push({
+            severity: "error",
+            code: "unterminated-block-comment",
+            message: "File appears to contain an unterminated /* block comment; facts from this best-effort scan may be incomplete.",
+            path: relativePath,
+            analyzerId: JAVA_ANALYZER_ID,
+        });
+    }
+    const parseStatus = hadUnterminatedBlockComment ? "parse-error" : "parsed";
+    return {
+        relativePath,
+        language,
+        role,
+        parseStatus,
+        analyzerId: JAVA_ANALYZER_ID,
+        lineCount: inventoryEntry.lineCount,
+        imports,
+        exports: [],
+        declarations,
+        references: [],
+        diagnostics,
+    };
+}
+function pushMethodDeclaration(declarations, name, line, lineNumber) {
+    const kind = "method";
+    declarations.push({
+        name,
+        kind,
+        exported: EXPLICIT_MODIFIER_PATTERN.exec(line)?.[1] === "public",
+        line: lineNumber,
+    });
+}
+function countChar(line, ch) {
+    let count = 0;
+    for (let i = 0; i < line.length; i++) {
+        if (line[i] === ch)
+            count += 1;
+    }
+    return count;
+}
+// ---------------------------------------------------------------------------
+// Comment/string stripping (heuristic, not a tokenizer). Strips `//` line
+// comments and `/* ... */` block comments (which may span multiple
+// lines), and blanks out the contents of `"..."` and `'...'` literals
+// (escape-aware) so a brace/quote character inside a string or comment can
+// never be misread as real code structure. Does not give Java 15+ text
+// blocks (`"""..."""`) special multi-line handling -- see this file's
+// header comment.
+// ---------------------------------------------------------------------------
+function buildLogicalLines(content) {
+    const rawLines = content.split(/\r\n|\r|\n/);
+    const logical = [];
+    let inBlockComment = false;
+    for (const rawLine of rawLines) {
+        logical.push(stripLine(rawLine));
+    }
+    return { logical, hadUnterminatedBlockComment: inBlockComment };
+    function stripLine(line) {
+        let result = "";
+        let i = 0;
+        while (i < line.length) {
+            if (inBlockComment) {
+                const closeIdx = line.indexOf("*/", i);
+                if (closeIdx === -1)
+                    return result;
+                inBlockComment = false;
+                i = closeIdx + 2;
+                continue;
+            }
+            const ch = line[i];
+            if (ch === "/" && line[i + 1] === "/")
+                return result;
+            if (ch === "/" && line[i + 1] === "*") {
+                inBlockComment = true;
+                i += 2;
+                continue;
+            }
+            if (ch === '"' || ch === "'") {
+                const quote = ch;
+                let j = i + 1;
+                while (j < line.length) {
+                    if (line[j] === "\\") {
+                        j += 2;
+                        continue;
+                    }
+                    if (line[j] === quote) {
+                        j += 1;
+                        break;
+                    }
+                    j += 1;
+                }
+                i = j;
+                continue;
+            }
+            result += ch;
+            i += 1;
+        }
+        return result;
+    }
+}