@groma/scanner-csharp 0.1.4 → 0.2.0

package/README.md

@@ -31,44 +31,84 @@ only: scanner evidence, OKF records and C4 boundaries are unchanged.
 
 ## Source inputs
 
-The scanner discovers tracked and unignored SDK-style `.csproj`, `.sln` and
-`.slnx` files. Solutions are selected before their projects; local project
-references are loaded once. Set `settings.input` on the existing C# scanner
-entry to select one project or solution relative to the repository root.
-
-An in-memory Roslyn workspace reads project XML and authored C# files.
-Unconditional language options, compile includes/removes, implicit usings and
-local project references supply context. The scanner's runtime supplies base
-.NET declarations. It does not run MSBuild, evaluate imported or conditional
-build settings, restore packages, or execute source generators. Standard .NET,
-Web and Worker SDK headers are accepted; this is not general framework analysis.
-
-Generated `bin` and `obj` files are excluded. A physical source file cannot
-belong to several selected project contexts. Project references must stay
-inside the repository. Mixed-language graphs and legacy projects are unsupported.
-Invalid syntax fails a scan. Missing external types produce diagnostics while
+The scanner reads the `.csproj`, `.sln` and `.slnx` files among its files, and
+every project among them that they reference, and loads each project once,
+however many solutions list it. Set `settings.input` on the existing C# scanner
+entry to select one of those projects or solutions, with the projects it
+references, relative to the repository root. To explain a file without an owner,
+the scanner lists every C# source its include list names, before exclusions: a
+project may compile any repository file, so this never leaves out a file a scan
+reads.
+
+An in-memory Roslyn workspace reads project XML and authored C# files. The
+nearest `Directory.Build.props`, the project file, and the files either imports
+by a path the scanner can expand supply their unconditional properties and items
+in document order: the language version, `DefineConstants`, `ImplicitUsings`
+and `Using` items, `AllowUnsafeBlocks`, `OutputType`, and `Compile` includes and
+removes. A value may use `$(Name)` for a property read before it. In a property
+value an unset property is empty, as in MSBuild, while an item or import path
+that names one stays unknown. Conditions, targets, property functions and SDK
+files are not evaluated. The scanner's runtime supplies base .NET declarations.
+It does not run MSBuild, restore packages, or execute source generators.
+
+Every SDK-style project is read, whatever its SDK: .NET, Web, Worker, Razor,
+Blazor WebAssembly, Aspire AppHost or an explicit `Sdk` import. Projects in
+other languages are skipped. A C# project that is not SDK-style is skipped with
+a `CSHARP_UNSUPPORTED_PROJECT` warning. Project references follow the SDK: they
+are transitive.
+
+The package declares default [include and exclude lists](../index.md#selecting-source-files).
+The include list names C# sources (`**/*.cs`), projects (`**/*.csproj`),
+solutions (`**/*.sln` and `**/*.slnx`) and MSBuild files (`**/*.props` and
+`**/*.targets`), each extension in any letter case. MSBuild files are only a
+project's build context; the list names them so that a change to one triggers a
+scan. The exclude list names build output (`bin` and `obj`, in any letter case),
+test code (folders named `test` or `tests` in either initial case, folders whose
+names end in `Tests`, and `*.Test` folders), and generated files
+(`*.Designer.cs`, `*.g.cs`, `*.g.i.cs` and `*.generated.cs`). A source, project
+or solution outside the scanner's files is never read, whether a solution, a
+reference or `settings.input` names it, so a declaration that only such a file
+provides is reported as missing where code uses it. An included project's
+nearest `Directory.Build.props` and the files it imports are read as MSBuild
+reads them, even when excluded. Which files a project compiles stays built in.
+
+For executable projects, Roslyn's resolved entry point supplies an execution fact
+with its source file, project declaration, assembly name and the project's own
+compiled source files. Referenced projects remain separate source units. An
+explicit `OutputType`, in any case, takes precedence; the Web and Worker SDKs
+default to `Exe`; otherwise top-level statements, which C# accepts only in an
+executable, make the project one. Core applies the
+[shared container-placement rule](../evidence.md#execution-entries-and-container-placement).
+Solutions and library projects alone do not imply containers.
+
+A source file that several projects compile belongs to each of them. It is
+analyzed once, in the context of the first project by path. Invalid syntax fails
+a scan. Missing external types produce warnings located by file and line, while
 local declarations and supported operations remain available.
 
 ## Evidence
 
 Partial class declarations in separate authored files are proposed as one source
 unit when Roslyn identifies the same class in the same project. Each file must
-contain only that type, and every declaration must qualify. Same-name classes
-in other namespaces or projects are independent. Files containing additional
-types remain separate source evidence. This does not associate Razor, XAML, or
-generated source.
+declare only that type, apart from the types nested in it, and every declaration
+must qualify. The primary is the file named after the class, else the file with
+the shortest name. Same-name classes in other namespaces or projects are
+independent. Files containing additional types remain separate source evidence.
+This does not associate Razor, XAML, or generated source.
 
 Core creates one component with all member Code references, attaches newly
 discovered unowned partial files, and retains curated ownership on repeat scans.
-Conflicting owners produce review diagnostics.
-The existing C# source watcher includes new partial files. No project restore,
-build, or source-generator execution is needed.
+Conflicting owners produce review diagnostics. No project restore, build, or
+source-generator execution is needed.
 
 Roslyn resolves local overloads, generic methods, extensions, partial
-implementations and direct calls. Calls with type errors, virtual dispatch,
-interfaces and delegates retain uncertainty. Implicit calls, initializers,
-generated operations, receiver/delegate value flow, dependency injection and
-network protocols are not resolved.
+implementations and direct calls. Virtual dispatch and interface calls retain
+uncertainty. Calls with type errors, and calls that reach no repository
+operation, such as calls into packages, the framework or delegates, are not
+reported. A lambda is an operation unless a call that binds converts it to an
+expression tree. Implicit calls, initializers, generated operations,
+receiver/delegate value flow, dependency injection and network protocols are
+not resolved.
 
 Solutions and projects supply source roots and file membership. They are not
 C4 components or proof of business collaborations. Core owns curated membership
@@ -76,10 +116,10 @@ and relationship selection; ordinary Markdown readers see the existing OKF
 records and Code links. The scanner adds no map level or architecture metadata.
 
 Settings also accept `configuration` (default `Debug`), `maxProjects` (128),
-`maxFiles` (20000) and `timeoutSeconds` (120). Configuration selects the source
-DEBUG/TRACE symbols; it does not execute a build configuration. Limits fail
-rather than publish truncated evidence. Failed scanners retain their saved
-evidence while other scanners can update the map.
+`maxFiles` (20000) and `timeoutSeconds` (120), which apply to the whole scan.
+Configuration selects the source DEBUG/TRACE symbols; it does not execute a
+build configuration. Limits fail rather than publish truncated evidence. Failed
+scanners retain their saved evidence while other scanners can update the map.
 
 Run `dotnet test plugins/scanners/csharp/dotnet/test/Groma.CSharpScanner.Tests.csproj`
 for Roslyn tests. Fixtures are scanned without restore. The packaged test
@@ -97,7 +137,8 @@ project, restoring packages or building.
   in the file or inside its namespaces are types. Enums and delegates have no
   members.
 - A type's members are the methods, interface method signatures, constructors,
-  finalizers and operators declared in its body, each overload separately.
+  finalizers and operators declared in its body, including the methods of its
+  C# 14 extension blocks, each overload separately.
   Constructors are named after the type and finalizers `~Type`; operators are
   named like `operator +` or `implicit operator int`.
 
@@ -174,11 +215,13 @@ Endpoints:
 - a controller is a public, top-level, non-generic, non-abstract class declared
   in one place, named `*Controller`, marked `[Controller]` or deriving from
   `ControllerBase` or `Controller`, and not `[NonController]`, counting the
-  attributes of its bases. A controller also serves the public methods and
-  `[Route]` prefixes of its bases, so one with a base between it and
-  `ControllerBase` that declares a public method or a `[Route]`, or that the
-  source does not declare, reports nothing. An action is a public, non-static,
-  non-generic method with a body and without `[NonAction]`.
+  attributes of its bases. Its class prefixes are the `[Route]` attributes of
+  the most derived class that declares any, as ASP.NET Core reads them, even
+  when that base is declared in a referenced project. A controller also serves
+  the public methods of its bases, so one with a base between it and
+  `ControllerBase` that declares a public method, or that the source does not
+  declare, reports nothing. An action is a public, non-static, non-generic
+  method with a body and without `[NonAction]`.
 - minimal APIs: `MapGet`, `MapPost`, `MapPut`, `MapDelete`, `MapPatch`, and
   `MapMethods` with literal methods, on a `MapGroup` chain or on the
   application: the result of `Build()` or `WebApplication.Create()`, or any
@@ -187,10 +230,12 @@ Endpoints:
 
 Requests:
 
-- `HttpClient` calls, recognized by the receiver's own type: the `GetAsync`,
-  `GetStringAsync`, `GetFromJsonAsync`, `PostAsync`, `PostAsJsonAsync`,
-  `PutAsync`, `PatchAsync` and `DeleteAsync` families, and `SendAsync` with a
-  `new HttpRequestMessage(HttpMethod.Get, url)`.
+- `HttpClient` calls, recognized by the receiver's own type or as the client
+  `IHttpClientFactory.CreateClient` returns, directly or held by a local: the
+  `GetAsync`, `GetStringAsync`, `GetFromJsonAsync`, `PostAsync`,
+  `PostAsJsonAsync`, `PutAsync`, `PatchAsync` and `DeleteAsync` families, and
+  `SendAsync` with a `new HttpRequestMessage(HttpMethod.Get, url)` written in
+  the call or held by a local the file never assigns again.
 - declarative client interfaces such as Refit: `[Get]`, `[Post]`, `[Put]`,
   `[Delete]`, `[Patch]`, `[Head]` and `[Options]` on an interface method. Such
   a method has no body, so its request declares the operation itself.

package/dist/index.js

@@ -1,90 +1,8 @@
 // @bun
-// plugins/scanners/csharp/src/index.ts
-import { readFile } from "fs/promises";
-import path4 from "path";
-
-// plugins/scanners/csharp/src/config.ts
-import { stat } from "fs/promises";
-import path2 from "path";
-
-// plugins/scanners/projects.ts
-import { execFile } from "child_process";
-import { existsSync } from "fs";
+// plugins/scanners/csharp/src/adapter.ts
+import { access } from "fs/promises";
 import path from "path";
-import { promisify } from "util";
-var execute = promisify(execFile);
-var excluded = new Set([
-  ".git",
-  "node_modules",
-  "vendor",
-  "target",
-  "dist",
-  "build",
-  "bin",
-  "obj",
-  ".gradle",
-  ".angular",
-  "coverage",
-  "generated",
-  "groma",
-  ".groma"
-]);
-async function repositoryFiles(root, matches) {
-  const { stdout } = await execute("git", ["-C", root, "ls-files", "-z", "--cached", "--others", "--exclude-standard"], { maxBuffer: 64 * 1024 * 1024 });
-  return [...new Set(stdout.split("\x00").filter((file) => file && matches(file) && existsSync(path.join(root, file))))].sort();
-}
-function projectFiles(root, matches) {
-  return repositoryFiles(root, (file) => matches(file) && !file.split("/").some((part) => excluded.has(part)));
-}
-
-// plugins/scanners/csharp/src/config.ts
-var defaults = { configuration: "Debug", maxProjects: 128, maxFiles: 20000, timeoutSeconds: 120 };
-var configName = "csharp scanner settings";
-function positiveInteger(value, key, fallback) {
-  if (value === undefined)
-    return fallback;
-  if (!Number.isSafeInteger(value) || Number(value) < 1)
-    throw new Error(`${configName}: ${key} must be a positive integer`);
-  return Number(value);
-}
-function optionalText(value, key) {
-  if (value === undefined)
-    return;
-  if (typeof value !== "string" || !value.trim())
-    throw new Error(`${configName}: ${key} must be nonempty text`);
-  return value;
-}
-function parseCSharpSettings(config = {}) {
-  for (const key of Object.keys(config)) {
-    if (!["input", ...Object.keys(defaults)].includes(key))
-      throw new Error(`${configName}: unknown setting ${key}`);
-  }
-  const input = optionalText(config.input, "input");
-  const configuration = optionalText(config.configuration, "configuration");
-  return {
-    ...input === undefined ? {} : { input },
-    configuration: configuration ?? defaults.configuration,
-    maxProjects: positiveInteger(config.maxProjects, "maxProjects", defaults.maxProjects),
-    maxFiles: positiveInteger(config.maxFiles, "maxFiles", defaults.maxFiles),
-    timeoutSeconds: positiveInteger(config.timeoutSeconds, "timeoutSeconds", defaults.timeoutSeconds)
-  };
-}
-async function validateInput(root, selected) {
-  const full = path2.resolve(root, selected);
-  const relative = path2.relative(root, full);
-  if (relative === ".." || relative.startsWith(`..${path2.sep}`) || path2.isAbsolute(relative))
-    throw new Error("C# scan input must stay inside the repository");
-  if (!/\.(?:csproj|slnx?)$/i.test(full) || !(await stat(full)).isFile())
-    throw new Error("C# input must be an existing .csproj, .sln, or .slnx file");
-  return full;
-}
-async function csharpInputs(root, settings) {
-  const config = parseCSharpSettings(settings);
-  if (config.input)
-    return [await validateInput(root, config.input)];
-  const files = await projectFiles(root, (file) => /\.(?:csproj|slnx?)$/i.test(file));
-  return [...files.filter((file) => /\.slnx?$/i.test(file)), ...files.filter((file) => /\.csproj$/i.test(file))].map((file) => path2.resolve(root, file));
-}
+import { createRequire } from "module";
 
 // packages/scanner/src/values.ts
 function object(value, label) {
@@ -240,6 +158,7 @@ function createScanObservation(input) {
     roots,
     files,
     ...sourceUnits(input.sourceUnits, filePaths),
+    ...entryPoints(input.entryPoints, filePaths),
     ...operationEvidence(input, filePaths),
     ...httpEvidence(input.httpEndpoints, input.httpRequests, input.operations && new Set(input.operations.map((operation) => operation.id))),
     diagnostics: [...new Map(input.diagnostics.map((diagnostic) => [
@@ -250,6 +169,29 @@ function createScanObservation(input) {
     })
   };
 }
+function entryPoints(input, paths) {
+  if (input === undefined)
+    return {};
+  const entries = array(input, "entryPoints").map((value) => {
+    const entry = object(value, "entry point");
+    const files = [...new Set(array(entry.files, "entry point.files").map((file) => string(file, "entry point.file")))].sort();
+    for (const file of files) {
+      if (!paths.has(file))
+        throw new Error(`entry point references unknown file: ${file}`);
+    }
+    const file = string(entry.file, "entry point.file");
+    if (!files.includes(file))
+      throw new Error(`entry point must include its own source file: ${file}`);
+    return {
+      file,
+      declaration: string(entry.declaration, "entry point.declaration"),
+      name: string(entry.name, "entry point.name"),
+      files
+    };
+  });
+  const key = (entry) => compare(entry.file, entry.declaration, entry.name, ...entry.files);
+  return { entryPoints: [...new Map(entries.map((entry) => [key(entry), entry])).values()].sort((a, b) => key(a).localeCompare(key(b))) };
+}
 function sourceUnits(input, paths) {
   if (input === undefined)
     return {};
@@ -312,6 +254,7 @@ function parseScanObservation(source) {
     ...parseOperations(value),
     httpEndpoints: value.httpEndpoints,
     httpRequests: value.httpRequests,
+    entryPoints: value.entryPoints,
     ...sourceUnits(value.sourceUnits, new Set(array(value.files, "files").map((entry) => string(object(entry, "file").file, "file.file")))),
     roots: array(value.roots, "roots").map((entry) => {
       const root = object(entry, "root");
@@ -456,52 +399,39 @@ function sourcePosition(position) {
   return { position: Number(position) };
 }
 
-// plugins/scanners/observations.ts
-function combineObservations(parts) {
-  if (!parts.length)
+// plugins/scanners/csharp/src/config.ts
+var defaults = { configuration: "Debug", maxProjects: 128, maxFiles: 20000, timeoutSeconds: 120 };
+var configName = "csharp scanner settings";
+function positiveInteger(value, key, fallback) {
+  if (value === undefined)
+    return fallback;
+  if (!Number.isSafeInteger(value) || Number(value) < 1)
+    throw new Error(`${configName}: ${key} must be a positive integer`);
+  return Number(value);
+}
+function optionalText(value, key) {
+  if (value === undefined)
     return;
-  const roots = [];
-  const files = new Map;
-  const operations = [];
-  const invocations = [];
-  const diagnostics = [];
-  const sourceUnits = [];
-  const httpEndpoints = [];
-  const httpRequests = [];
-  for (const { key, observation } of parts) {
-    const id = (value) => JSON.stringify([key, value]);
-    roots.push(...observation.roots.map((root) => ({ ...root, id: id(root.id), ...root.parent ? { parent: id(root.parent) } : {} })));
-    for (const source of observation.files) {
-      const combined = files.get(source.file) ?? { file: source.file, roots: [], symbols: [] };
-      combined.roots.push(...source.roots.map(id));
-      combined.symbols.push(...source.symbols.map((symbol) => ({ ...symbol, id: id(symbol.id) })));
-      files.set(source.file, combined);
-    }
-    operations.push(...(observation.operations ?? []).map((operation) => ({ ...operation, id: id(operation.id) })));
-    invocations.push(...(observation.invocations ?? []).map((call) => ({ ...call, source: id(call.source), targets: call.targets.map(id) })));
-    httpEndpoints.push(...(observation.httpEndpoints ?? []).map((endpoint) => ({ ...endpoint, operation: id(endpoint.operation) })));
-    httpRequests.push(...(observation.httpRequests ?? []).map((request) => ({ ...request, operation: id(request.operation) })));
-    diagnostics.push(...observation.diagnostics);
-    sourceUnits.push(...observation.sourceUnits ?? []);
+  if (typeof value !== "string" || !value.trim())
+    throw new Error(`${configName}: ${key} must be nonempty text`);
+  return value;
+}
+function parseCSharpSettings(config = {}) {
+  for (const key of Object.keys(config)) {
+    if (!["input", ...Object.keys(defaults)].includes(key))
+      throw new Error(`${configName}: unknown setting ${key}`);
   }
-  return createScanObservation({
-    scanner: parts[0].observation.scanner,
-    roots,
-    files: [...files.values()],
-    operations,
-    invocations,
-    diagnostics,
-    ...parts.some((part) => part.observation.sourceUnits !== undefined) ? { sourceUnits } : {},
-    ...parts.some((part) => part.observation.httpEndpoints !== undefined) ? { httpEndpoints } : {},
-    ...parts.some((part) => part.observation.httpRequests !== undefined) ? { httpRequests } : {}
-  });
+  const input = optionalText(config.input, "input");
+  const configuration = optionalText(config.configuration, "configuration");
+  return {
+    ...input === undefined ? {} : { input },
+    configuration: configuration ?? defaults.configuration,
+    maxProjects: positiveInteger(config.maxProjects, "maxProjects", defaults.maxProjects),
+    maxFiles: positiveInteger(config.maxFiles, "maxFiles", defaults.maxFiles),
+    timeoutSeconds: positiveInteger(config.timeoutSeconds, "timeoutSeconds", defaults.timeoutSeconds)
+  };
 }
 
-// plugins/scanners/csharp/src/adapter.ts
-import { access } from "fs/promises";
-import path3 from "path";
-import { createRequire } from "module";
-
 // plugins/scanners/csharp/src/process.ts
 import { spawn } from "child_process";
 function stopTree(child) {
@@ -573,47 +503,44 @@ function run(command, args, options) {
 }
 
 // plugins/scanners/csharp/src/adapter.ts
-async function requireWorker(file) {
+async function requireWorker() {
   try {
-    const manifest = file ? undefined : createRequire(import.meta.url).resolve(`@groma/scanner-csharp-${process.platform}-${process.arch}/package.json`);
-    const worker = file ?? path3.join(path3.dirname(manifest), "worker", `Groma.CSharpScanner${process.platform === "win32" ? ".exe" : ""}`);
+    const manifest = createRequire(import.meta.url).resolve(`@groma/scanner-csharp-${process.platform}-${process.arch}/package.json`);
+    const worker = path.join(path.dirname(manifest), "worker", `Groma.CSharpScanner${process.platform === "win32" ? ".exe" : ""}`);
     await access(worker);
     return worker;
   } catch {
     throw new Error("C# runtime package is missing. Reinstall the scanner with optional dependencies enabled; contributors run bun scripts/package-csharp-scanner.ts.");
   }
 }
-async function prepareCSharpScan(repositoryRoot, settings, worker) {
-  const root = path3.resolve(repositoryRoot);
+function csharpInventory(root, config, files) {
+  const projects = files.filter((file) => /\.(?:csproj|slnx?)$/i.test(file));
+  const input = config.input && path.relative(root, path.resolve(root, config.input)).split(path.sep).join("/");
+  const inputs = input ? projects.filter((file) => file === input) : projects;
+  return inputs.length ? { files, inputs } : undefined;
+}
+async function checkCSharpReadiness(repositoryRoot, settings, files) {
+  if (csharpInventory(path.resolve(repositoryRoot), parseCSharpSettings(settings), files) === undefined)
+    throw new Error("No C# project or solution was found. The C# scanner reads the SDK-style .csproj projects among its files and the .sln or .slnx files that list them, or only the one settings.input names.");
+  await requireWorker();
+}
+async function scanCSharpSource(repositoryRoot, settings, files) {
+  const root = path.resolve(repositoryRoot);
   const config = parseCSharpSettings(settings);
-  if (!config.input)
-    throw new Error("C# analysis requires a selected project or solution input.");
-  const input = await validateInput(root, config.input);
-  const executable = await requireWorker(worker);
-  return { root, config, input, executable };
-}
-async function checkCSharpReadiness(repositoryRoot, settings = {}, worker) {
-  const { input } = await prepareCSharpScan(repositoryRoot, settings, worker);
-  return { input };
-}
-async function scanCSharpSource(repositoryRoot, settings = {}, worker) {
-  const { root, config, input, executable } = await prepareCSharpScan(repositoryRoot, settings, worker);
-  const { stdout } = await run(executable, [
-    input,
-    "--root",
-    root,
-    "--configuration",
-    config.configuration,
-    "--max-projects",
-    String(config.maxProjects),
-    "--max-files",
-    String(config.maxFiles)
-  ], { cwd: path3.dirname(input), timeoutSeconds: config.timeoutSeconds });
+  const inventory = csharpInventory(root, config, files);
+  if (inventory === undefined)
+    return;
+  const request = JSON.stringify({ root, ...inventory, configuration: config.configuration, maxProjects: config.maxProjects, maxFiles: config.maxFiles });
+  const { stdout } = await run(await requireWorker(), ["--scan"], { cwd: root, timeoutSeconds: config.timeoutSeconds, input: request });
   return parseScanObservation(stdout);
 }
+async function listCSharpSources(repositoryRoot, settings, candidates) {
+  const inventory = csharpInventory(path.resolve(repositoryRoot), parseCSharpSettings(settings), candidates);
+  return inventory?.files.filter((file) => /\.cs$/i.test(file)) ?? [];
+}
 async function readCSharpOutline(repositoryRoot, references, settings = {}) {
   const worker = await requireWorker();
-  const root = path3.resolve(repositoryRoot);
+  const root = path.resolve(repositoryRoot);
   const { stdout } = await run(worker, ["--outline"], {
     cwd: root,
     timeoutSeconds: parseCSharpSettings(settings).timeoutSeconds,
@@ -623,62 +550,14 @@ async function readCSharpOutline(repositoryRoot, references, settings = {}) {
 }
 
 // plugins/scanners/csharp/src/index.ts
-async function solutionProjects(input) {
-  if (/\.csproj$/i.test(input))
-    return [input];
-  const source = await readFile(input, "utf8");
-  return [...source.matchAll(/"([^"]+\.csproj)"|Path="([^"]+\.csproj)"/gi)].map((match) => path4.resolve(path4.dirname(input), (match[1] ?? match[2]).split("\\").join("/")));
-}
 var scanner = {
   id: "csharp",
-  watch: {
-    include: [
-      "**/*.cs",
-      "**/*.csproj",
-      "**/*.sln",
-      "**/*.slnx",
-      "**/*.props",
-      "**/*.targets",
-      "**/global.json",
-      "**/nuget.config",
-      "**/packages.lock.json"
-    ].map((pattern) => pattern.replace(/[a-z]/g, (letter) => `[${letter}${letter.toUpperCase()}]`)),
-    exclude: ["**/[bB][iI][nN]/**", "**/[oO][bB][jJ]/**"]
-  },
-  checkReadiness: async (root, settings = {}) => {
-    const inputs = await csharpInputs(root, settings);
-    if (!inputs.length)
-      throw new Error("No C# project or solution was found.");
-    for (const input of inputs)
-      await checkCSharpReadiness(root, { ...settings, input });
-  },
+  checkReadiness: checkCSharpReadiness,
   readCodeStructure: readCSharpOutline,
-  listSourceFiles: async (root, settings = {}) => {
-    const directories = [];
-    for (const input of await csharpInputs(root, settings)) {
-      for (const project of await solutionProjects(input)) {
-        directories.push(path4.relative(root, path4.dirname(project)).split(path4.sep).join("/"));
-      }
-    }
-    return projectFiles(root, (file) => /\.cs$/i.test(file) && !file.split("/").some((part) => /^(?:bin|obj)$/i.test(part)) && directories.some((directory) => directory === "" || file.startsWith(`${directory}/`)));
-  },
-  scan: async (root, settings = {}) => {
-    const parts = [];
-    const covered = new Set;
-    for (const input of await csharpInputs(root, settings)) {
-      if (covered.has(input))
-        continue;
-      const observation = await scanCSharpSource(root, { ...settings, input });
-      for (const project of observation.roots)
-        if (project.file)
-          covered.add(path4.resolve(root, project.file));
-      parts.push({ key: path4.relative(root, input).split(path4.sep).join("/"), observation });
-    }
-    return combineObservations(parts);
-  }
+  listSourceFiles: listCSharpSources,
+  scan: scanCSharpSource
 };
 var src_default = scanner;
 export {
-  checkCSharpReadiness,
   src_default as default
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groma/scanner-csharp",
-  "version": "0.1.4",
+  "version": "0.2.0",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -8,7 +8,7 @@
     "type": "git",
     "url": "https://github.com/MrLesk/Groma.md.git"
   },
-  "description": "C# project evidence through Roslyn and MSBuild.",
+  "description": "C# project evidence through Roslyn.",
   "publishConfig": {
     "access": "public"
   },
@@ -28,16 +28,36 @@
     "x64"
   ],
   "optionalDependencies": {
-    "@groma/scanner-csharp-darwin-arm64": "0.1.4",
-    "@groma/scanner-csharp-linux-arm64": "0.1.4",
-    "@groma/scanner-csharp-linux-x64": "0.1.4",
-    "@groma/scanner-csharp-win32-arm64": "0.1.4",
-    "@groma/scanner-csharp-win32-x64": "0.1.4"
+    "@groma/scanner-csharp-darwin-arm64": "0.2.0",
+    "@groma/scanner-csharp-linux-arm64": "0.2.0",
+    "@groma/scanner-csharp-linux-x64": "0.2.0",
+    "@groma/scanner-csharp-win32-arm64": "0.2.0",
+    "@groma/scanner-csharp-win32-x64": "0.2.0"
   },
   "groma": {
     "scanner": {
       "id": "csharp",
       "entry": "./dist/index.js",
+      "include": [
+        "**/*.[cC][sS]",
+        "**/*.[cC][sS][pP][rR][oO][jJ]",
+        "**/*.[sS][lL][nN]",
+        "**/*.[sS][lL][nN][xX]",
+        "**/*.[pP][rR][oO][pP][sS]",
+        "**/*.[tT][aA][rR][gG][eE][tT][sS]"
+      ],
+      "exclude": [
+        "[bB][iI][nN]/",
+        "[oO][bB][jJ]/",
+        "[tT]est/",
+        "[tT]ests/",
+        "*Tests/",
+        "*.Test/",
+        "*.[dD]esigner.cs",
+        "*.g.cs",
+        "*.g.i.cs",
+        "*.generated.cs"
+      ],
       "discovery": {
         "technologies": [
           "csharp"
@@ -58,7 +78,7 @@
           }
         ],
         "compatibility": {
-          "groma": ">=0.3.0"
+          "groma": ">=0.5.0"
         }
       }
     }