@groma/scanner-csharp 0.1.0 → 0.1.2

package/README.md

@@ -27,7 +27,7 @@ See the [shared configuration contract](../creating-a-plugin.md#scanner-settings
 
 Run `dotnet restore Library.csproj` from that input directory, then run `groma scan` from the repository root. Restore uses the project's normal NuGet settings and credentials. On macOS, use a relative restore input from its directory so `/var` and `/private/var` aliases do not enter one restore graph as separate project paths.
 
-Install a prepared local package with `groma scanner add /path/to/csharp-scanner-package`. Release publication is separate from local qualification. The package also exports `checkCSharpReadiness(repositoryRoot, settings)`, used through the same input/tool checks as scanning. It returns the selected input and SDK version; successful readiness does not prove dependency restore or compilation. A missing worker means the package needs preparation; missing tooling or compilation errors must be fixed before scanning can replace architecture evidence.
+Install a prepared local package with `groma scanner add /path/to/csharp-scanner-package`. Release publication is separate from local qualification. The package also exports `checkCSharpReadiness(repositoryRoot, { input })`, used through the same input/tool checks as scanning. It returns the selected input and SDK version; successful readiness does not prove dependency restore or compilation. A missing worker means the package needs preparation; missing tooling or compilation errors must be fixed before scanning can replace architecture evidence.
 
 ## Supported input and evidence
 
@@ -35,14 +35,14 @@ The selected qualification example is FluentValidation 12.0.0, commit `5365d9294
 
 Inputs are SDK-style `.csproj`, `.sln`, and `.slnx` files. When input is omitted, one root solution takes precedence over root projects. Multiple candidates require explicit selection. Standard .NET, Web and Worker SDK project headers are accepted, but this is not general framework qualification. Mixed-language graphs, legacy project formats, multiple target-framework contexts, and a file shared by multiple loaded project contexts are rejected.
 
-Each physical C# source has one inventory record. Generated `bin` and `obj` sources are excluded. Roslyn resolves overloads, generic methods, extensions, partial implementations and direct calls. Virtual, interface and delegate dispatch retain uncertainty where the runtime provider is not established. Implicit calls, initializers, generated operations, receiver/delegate value flow, dependency injection and network protocols are not resolved.
+Each physical C# source inside the repository has one inventory record. Generated `bin` and `obj` sources are excluded. SDK and package source files outside the repository remain compiler context, including validation, but do not produce file or operation evidence. Project references must stay inside the repository. Roslyn resolves overloads, generic methods, extensions, partial implementations and direct calls. Virtual, interface and delegate dispatch retain uncertainty where the runtime provider is not established. Implicit calls, initializers, generated operations, receiver/delegate value flow, dependency injection and network protocols are not resolved.
 
 Solutions and projects are source roots, with each project linked to its solution
 when a solution is selected. File records identify their project root. A directly
 selected project and its loaded project references are top-level source roots.
 Root membership and operations are temporary evidence. They are not C4 components or proof of business collaborations. Core owns curated source membership and relationship selection; ordinary Markdown readers retain readable descriptions and links under the existing OKF application profile. This plugin introduces no architecture metadata or map level.
 
-`settings` also accepts `configuration` (default `Debug`), `maxProjects` (128), `maxFiles` (20000), and `timeoutSeconds` (120). Exceeded limits fail the scan; they never publish truncated evidence. Any enabled scanner failure prevents reconciliation and preserves the prior map.
+`settings` also accepts `configuration` (default `Debug`), `maxProjects` (128), `maxFiles` (20000), and `timeoutSeconds` (120). Exceeded limits fail the scan; they never publish truncated evidence. A failed scanner preserves its saved evidence; other scanners can still update the map.
 
 ## Contributor package build
 
@@ -53,3 +53,13 @@ bun scripts/package-csharp-scanner.ts
 ```
 
 The build bundles the adapter and publishes a framework-dependent worker into the package. It has no installation scripts and does not include a private SDK. Run the Roslyn tests with `dotnet test plugins/scanners/csharp/dotnet/test/Groma.CSharpScanner.Tests.csproj`.
+
+## Nested projects
+
+From the repository root, the scanner finds tracked and unignored `.sln`, `.slnx`
+and `.csproj` files. Solutions are loaded first. Project roots returned by Roslyn
+prevent a solution member or project reference from being scanned again as a
+standalone input. Independent projects are scanned as additional inputs. Each
+input selects its own installed SDK; all evidence paths stay relative to the
+repository. `settings.input` still selects one explicit solution or project.
+Any selected input failure fails the C# observation. Other scanners can still update the map.

package/dist/index.js

@@ -1,8 +1,86 @@
 // @bun
-// plugins/scanners/csharp/src/adapter.ts
-import { access } from "fs/promises";
+// plugins/scanners/csharp/src/index.ts
+import path4 from "path";
+
+// plugins/scanners/csharp/src/config.ts
+import { stat } from "fs/promises";
 import path2 from "path";
-import { fileURLToPath } from "url";
+
+// plugins/scanners/projects.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+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 projectFiles(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) && !file.split("/").some((part) => excluded.has(part)) && existsSync(path.join(root, file))))].sort();
+}
+
+// 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));
+}
 
 // packages/scanner/src/index.ts
 function compare(...values) {
@@ -258,60 +336,43 @@ function sourcePosition(position) {
   return { position: Number(position) };
 }
 
-// plugins/scanners/csharp/src/config.ts
-import { readdir, stat } from "fs/promises";
-import path from "path";
-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)
+// plugins/scanners/observations.ts
+function combineObservations(parts) {
+  if (!parts.length)
     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 roots = [];
+  const files = new Map;
+  const operations = [];
+  const invocations = [];
+  const diagnostics = [];
+  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) })));
+    diagnostics.push(...observation.diagnostics);
   }
-  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 findCSharpInput(root, selected) {
-  if (selected !== undefined)
-    return validateInput(root, selected);
-  const files = (await readdir(root, { withFileTypes: true })).filter((entry) => entry.isFile()).map((entry) => entry.name).sort();
-  const solutions = files.filter((file) => /\.slnx?$/i.test(file));
-  const candidates = solutions.length ? solutions : files.filter((file) => /\.csproj$/i.test(file));
-  if (candidates.length > 1)
-    throw new Error(`Several C# scan inputs exist; set settings.input on the csharp entry in scanners.json: ${candidates.join(", ")}`);
-  return candidates.length ? path.resolve(root, candidates[0]) : undefined;
-}
-async function validateInput(root, selected) {
-  const full = path.resolve(root, selected);
-  const relative = path.relative(root, full);
-  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.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;
+  return createScanObservation({
+    scanner: parts[0].observation.scanner,
+    roots,
+    files: [...files.values()],
+    operations,
+    invocations,
+    diagnostics
+  });
 }
 
+// plugins/scanners/csharp/src/adapter.ts
+import { access } from "fs/promises";
+import path3 from "path";
+import { fileURLToPath } from "url";
+
 // plugins/scanners/csharp/src/process.ts
 import { spawn } from "child_process";
 function stopTree(child) {
@@ -390,13 +451,13 @@ async function requireWorker(file = workerDll) {
   }
 }
 async function prepareCSharpScan(repositoryRoot, settings, dotnet, worker) {
-  const root = path2.resolve(repositoryRoot);
+  const root = path3.resolve(repositoryRoot);
   const config = parseCSharpSettings(settings);
-  const input = await findCSharpInput(root, config.input);
-  if (!input)
-    throw new Error("No C# input was selected. Set settings.input on the csharp entry in scanners.json or disable the csharp scanner.");
+  if (!config.input)
+    throw new Error("C# analysis requires a selected project or solution input.");
+  const input = await validateInput(root, config.input);
   await requireWorker(worker);
-  const options = { cwd: path2.dirname(input), timeoutSeconds: config.timeoutSeconds };
+  const options = { cwd: path3.dirname(input), timeoutSeconds: config.timeoutSeconds };
   let sdkVersion;
   try {
     sdkVersion = (await run(dotnet, ["--version"], options)).stdout.trim();
@@ -425,7 +486,7 @@ async function scanCSharpSource(repositoryRoot, settings = {}, dotnet = process.
     String(config.maxProjects),
     "--max-files",
     String(config.maxFiles)
-  ], { cwd: path2.dirname(input), timeoutSeconds: config.timeoutSeconds });
+  ], { cwd: path3.dirname(input), timeoutSeconds: config.timeoutSeconds });
   return parseScanObservation(stdout);
 }
 
@@ -446,10 +507,27 @@ var scanner = {
     ].map((pattern) => pattern.replace(/[a-z]/g, (letter) => `[${letter}${letter.toUpperCase()}]`)),
     exclude: ["**/[bB][iI][nN]/**", "**/[oO][bB][jJ]/**"]
   },
-  checkReadiness: async (root, settings) => {
-    await checkCSharpReadiness(root, settings);
+  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 });
   },
-  scan: scanCSharpSource
+  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);
+  }
 };
 var src_default = scanner;
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groma/scanner-csharp",
-  "version": "0.1.0",
+  "version": "0.1.2",
   "private": false,
   "type": "module",
   "license": "MIT",
@@ -35,8 +35,7 @@
           }
         ],
         "compatibility": {
-          "groma": "^0.3.0",
-          "technologyVersions": {}
+          "groma": "^0.3.0"
         }
       }
     }