@groma/scanner-rust 0.1.0 → 0.1.1

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@groma/scanner-rust",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Rust project evidence through established semantic tooling.",
   "private": false,
   "type": "module",
   "license": "MIT",
   "os": [
-    "win32",
     "linux",
-    "darwin"
+    "darwin",
+    "win32"
   ],
   "cpu": [
     "arm64",
@@ -42,8 +42,7 @@
           }
         ],
         "compatibility": {
-          "groma": "^0.3.0",
-          "technologyVersions": {}
+          "groma": "^0.3.0"
         }
       }
     }

package/src/index.js

@@ -1,6 +1,6 @@
 // plugins/scanners/rust/src/index.ts
 import { fileURLToPath } from "node:url";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // packages/scanner/src/index.ts
 function compare(...values) {
@@ -256,12 +256,73 @@ function sourcePosition(position) {
   return { position: Number(position) };
 }
 
+// plugins/scanners/observations.ts
+function combineObservations(parts) {
+  if (!parts.length)
+    return;
+  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);
+  }
+  return createScanObservation({
+    scanner: parts[0].observation.scanner,
+    roots,
+    files: [...files.values()],
+    operations,
+    invocations,
+    diagnostics
+  });
+}
+
 // plugins/scanners/rust/src/project.ts
-import { execFile } from "node:child_process";
+import { execFile as execFile2 } from "node:child_process";
 import { access } from "node:fs/promises";
+import path2 from "node:path";
+import { promisify as promisify2 } from "node:util";
+
+// plugins/scanners/projects.ts
+import { execFile } from "node:child_process";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import { promisify } from "node: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/rust/src/project.ts
+var execute2 = promisify2(execFile2);
 async function exists(file) {
   try {
     await access(file);
@@ -272,59 +333,81 @@ async function exists(file) {
 }
 function manifestAt(root, settings) {
   if (settings.manifest === undefined)
-    return path.join(root, "Cargo.toml");
+    return path2.join(root, "Cargo.toml");
   if (typeof settings.manifest !== "string") {
     throw new Error("RUST_PROJECT_SELECTION: Set settings.manifest on the rust entry in scanners.json to a Cargo.toml path.");
   }
-  return path.resolve(root, settings.manifest);
+  return path2.resolve(root, settings.manifest);
 }
-async function readRustProject(root, settings, options) {
+async function readRustProject(root, settings, options, workspace = false) {
   const manifest = manifestAt(root, settings);
   if (!await exists(manifest)) {
     throw new Error("RUST_PROJECT_MISSING: Select an existing Cargo.toml with settings.manifest on the rust entry in scanners.json.");
   }
   let metadata;
   try {
-    const result = await execute(options.cargo ?? "cargo", ["metadata", "--format-version", "1", "--offline", "--locked", "--manifest-path", manifest], { cwd: root, maxBuffer: 64 * 1024 * 1024 });
+    const result = await execute2(options.cargo ?? "cargo", ["metadata", "--format-version", "1", "--offline", "--locked", "--manifest-path", manifest], { cwd: path2.dirname(manifest), maxBuffer: 64 * 1024 * 1024 });
     metadata = JSON.parse(result.stdout);
   } catch (error) {
     throw new Error(`RUST_CARGO_NOT_READY: Install the project's Rust toolchain, then run cargo fetch --manifest-path "${manifest}" to prepare its lockfile and dependencies. ${error}`);
   }
   const packageAtManifest = metadata.packages.find((pkg) => pkg.manifest_path === manifest);
-  const packages = packageAtManifest ? [packageAtManifest] : metadata.packages.filter((pkg) => metadata.workspace_members.includes(pkg.id));
+  const packages = packageAtManifest && !workspace ? [packageAtManifest] : metadata.packages.filter((pkg) => metadata.workspace_members.includes(pkg.id));
   const targets = packages.flatMap((pkg) => pkg.targets).filter((target) => target.kind.some((kind) => kind === "lib" || kind === "bin")).map((target) => target.src_path).sort();
   if (!targets.length)
     throw new Error("RUST_TARGET_MISSING: The selected Cargo project needs a library or binary target.");
-  return { root, manifest, name: packageAtManifest?.name ?? path.basename(path.dirname(manifest)), targets };
+  return { root, manifest, name: packageAtManifest?.name ?? path2.basename(path2.dirname(manifest)), targets };
 }
 async function checkRustToolchain(root, options) {
   try {
-    await execute(options.cargo ?? "cargo", ["--version"], { cwd: root });
-    const result = await execute(options.rustc ?? "rustc", ["--print", "sysroot"], { cwd: root });
-    const library = path.join(result.stdout.trim(), "lib/rustlib/src/rust/library");
+    await execute2(options.cargo ?? "cargo", ["--version"], { cwd: root });
+    const result = await execute2(options.rustc ?? "rustc", ["--print", "sysroot"], { cwd: root });
+    const library = path2.join(result.stdout.trim(), "lib/rustlib/src/rust/library");
     if (!await exists(library))
       throw new Error("Rust standard library sources are missing.");
   } catch (error) {
     throw new Error(`RUST_TOOLCHAIN_MISSING: Install the project's Rust toolchain with Cargo and rustc, and add its standard library sources with rustup component add rust-src. ${error}`);
   }
 }
+async function rustProjects(root, settings, options = {}) {
+  if (settings.manifest !== undefined)
+    return [manifestAt(root, settings)];
+  const selected = new Set;
+  const covered = new Set;
+  for (const file of await projectFiles(root, (file) => path2.posix.basename(file) === "Cargo.toml")) {
+    const manifest = path2.resolve(root, file);
+    if (covered.has(manifest))
+      continue;
+    const { stdout } = await execute2(options.cargo ?? "cargo", ["metadata", "--no-deps", "--format-version", "1", "--offline", "--locked", "--manifest-path", manifest], { cwd: path2.dirname(manifest), maxBuffer: 64 * 1024 * 1024 });
+    const metadata = JSON.parse(stdout);
+    selected.add(path2.join(metadata.workspace_root, "Cargo.toml"));
+    for (const pkg of metadata.packages)
+      if (metadata.workspace_members.includes(pkg.id))
+        covered.add(pkg.manifest_path);
+    covered.add(path2.join(metadata.workspace_root, "Cargo.toml"));
+  }
+  return [...selected].sort();
+}
 
 // plugins/scanners/rust/src/index.ts
 var executable = fileURLToPath(new URL(`../dist/bin/${process.platform}-${process.arch}/groma-rust-scanner${process.platform === "win32" ? ".exe" : ""}`, import.meta.url));
-async function checkRustReadiness(repositoryRoot, settings = {}, options = {}) {
-  const root = path2.resolve(repositoryRoot);
+async function checkRustReadiness(repositoryRoot, settings = {}, options = {}, workspace = false) {
+  const root = path3.resolve(repositoryRoot);
   const worker = options.worker ?? executable;
   if (!await exists(worker)) {
     throw new Error("RUST_WORKER_MISSING: Install the packaged Rust scanner, or build it with bun plugins/scanners/rust/build.ts.");
   }
-  await checkRustToolchain(root, options);
-  return { input: await readRustProject(root, settings, options), worker };
+  await checkRustToolchain(path3.dirname(path3.resolve(root, typeof settings.manifest === "string" ? settings.manifest : "Cargo.toml")), options);
+  return { input: await readRustProject(root, settings, options, workspace), worker };
 }
 async function scanRustSource(repositoryRoot, settings = {}, options = {}) {
   const { input, worker } = await checkRustReadiness(repositoryRoot, settings, options);
+  return runRust(input, worker);
+}
+async function runRust(input, worker) {
   try {
-    const pending = execute(worker, [], {
-      cwd: input.root,
+    const pending = execute2(worker, [], {
+      cwd: path3.dirname(input.manifest),
       encoding: "utf8",
       timeout: 120000,
       maxBuffer: 64 * 1024 * 1024,
@@ -351,10 +434,23 @@ var scanner = {
     ],
     exclude: ["**/target/**", "**/node_modules/**", "**/.git/**", "**/vendor/**", "**/dist/**"]
   },
-  checkReadiness: async (root, settings) => {
-    await checkRustReadiness(root, settings);
+  checkReadiness: async (root, settings = {}) => {
+    const projects = await rustProjects(root, settings);
+    if (!projects.length)
+      throw new Error("RUST_PROJECT_MISSING: No Cargo.toml was found.");
+    for (const manifest of projects)
+      await checkRustReadiness(root, { ...settings, manifest }, {}, settings.manifest === undefined);
   },
-  scan: scanRustSource
+  scan: async (root, settings = {}) => {
+    const parts = [];
+    for (const manifest of await rustProjects(root, settings)) {
+      const options = { ...settings, manifest };
+      const { input, worker } = await checkRustReadiness(root, options, {}, settings.manifest === undefined);
+      const observation = await runRust(input, worker);
+      parts.push({ key: path3.relative(root, manifest).split(path3.sep).join("/"), observation });
+    }
+    return combineObservations(parts);
+  }
 };
 var src_default = scanner;
 export {