@groma/scanner-go 0.1.0 → 0.1.1

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@groma/scanner-go",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Go project evidence through Go language tooling.",
   "private": false,
   "type": "module",
   "license": "MIT",
   "os": [
-    "win32",
     "linux",
-    "darwin"
+    "darwin",
+    "win32"
   ],
   "cpu": [
     "arm64",
@@ -35,10 +35,7 @@
           }
         ],
         "compatibility": {
-          "groma": "^0.3.0",
-          "technologyVersions": {
-            "go": "1.20.0"
-          }
+          "groma": "^0.3.0"
         }
       }
     }

package/src/index.js

@@ -1,9 +1,39 @@
 // @bun
-// plugins/scanners/go/src/adapter.ts
+// plugins/scanners/go/src/index.ts
+import path5 from "path";
+
+// plugins/scanners/projects.ts
 import { execFile } from "child_process";
-import { access, realpath } from "fs/promises";
+import { existsSync } from "fs";
 import path from "path";
-import { fileURLToPath } from "url";
+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/project-scanner.ts
+import path3 from "path";
+
+// plugins/scanners/observations.ts
+import path2 from "path";
 
 // packages/scanner/src/index.ts
 function compare(...values) {
@@ -259,11 +289,85 @@ function sourcePosition(position) {
   return { position: Number(position) };
 }
 
+// plugins/scanners/observations.ts
+function relocateObservation(observation, directory) {
+  const file = (value) => path2.posix.normalize(path2.posix.join(directory, value));
+  return {
+    ...observation,
+    roots: observation.roots.map((root) => ({ ...root, ...root.file ? { file: file(root.file) } : {} })),
+    files: observation.files.map((source) => ({ ...source, file: file(source.file) })),
+    operations: observation.operations?.map((operation) => ({ ...operation, file: file(operation.file) })),
+    invocations: observation.invocations?.map((call) => ({
+      ...call,
+      ...call.binding ? { binding: { ...call.binding, file: file(call.binding.file) } } : {}
+    })),
+    diagnostics: observation.diagnostics.map((item) => ({ ...item, ...item.file ? { file: file(item.file) } : {} }))
+  };
+}
+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/project-scanner.ts
+function projectScanner(scanner, select) {
+  return {
+    ...scanner,
+    checkReadiness: async (root, settings = {}) => {
+      const projects = await select(root, settings);
+      if (!projects.length)
+        throw new Error(`${scanner.id}: No supported project declaration was found.`);
+      for (const project of projects)
+        await scanner.checkReadiness?.(project, settings);
+    },
+    scan: async (root, settings = {}) => {
+      const parts = [];
+      for (const project of await select(root, settings)) {
+        const observation = await scanner.scan(project, settings);
+        const key = path3.relative(root, project).split(path3.sep).join("/");
+        if (observation)
+          parts.push({ key, observation: relocateObservation(observation, key) });
+      }
+      return combineObservations(parts);
+    }
+  };
+}
+
 // plugins/scanners/go/src/adapter.ts
+import { execFile as execFile2 } from "child_process";
+import { access, realpath } from "fs/promises";
+import path4 from "path";
+import { fileURLToPath } from "url";
 var packagedWorker = fileURLToPath(new URL(`../dist/${process.platform}-${process.arch}/worker${process.platform === "win32" ? ".exe" : ""}`, import.meta.url));
 function run(command, args, root, env = process.env) {
   return new Promise((resolve, reject) => {
-    execFile(command, args, {
+    execFile2(command, args, {
       cwd: root,
       env,
       encoding: "utf8",
@@ -293,13 +397,10 @@ async function checkGoReadiness(repositoryRoot, options = {}) {
   } catch (error) {
     throw new Error(`GO_TOOLCHAIN_MISSING: Install the project's Go toolchain and add its bin directory to PATH (Go 1.27.1 for the qualified example). ${error}`);
   }
-  if (context.GOWORK && context.GOWORK !== "off") {
-    throw new Error("GO_PROJECT_SCOPE: This scanner supports one root module. Select the supported module with GOWORK=off; workspace analysis is not qualified.");
-  }
-  if (context.GOMOD !== path.join(root, "go.mod")) {
-    throw new Error("GO_PROJECT_SCOPE: Run Groma at the supported Go module root containing go.mod.");
+  if (context.GOMOD !== path4.join(root, "go.mod")) {
+    throw new Error("GO_PROJECT_SCOPE: The selected project must contain go.mod.");
   }
-  env.PATH = `${path.join(context.GOROOT, "bin")}${path.delimiter}${process.env.PATH ?? ""}`;
+  env.PATH = `${path4.join(context.GOROOT, "bin")}${path4.delimiter}${process.env.PATH ?? ""}`;
   try {
     await run(options.go ?? "go", ["list", "-mod=readonly", "-deps", "./..."], root, env);
   } catch (error) {
@@ -317,7 +418,7 @@ async function scanGoSource(repositoryRoot, options = {}) {
 }
 
 // plugins/scanners/go/src/index.ts
-var src_default = {
+var scanner = {
   id: "go",
   watch: { include: ["**/*.go", "**/go.mod", "**/go.sum", "**/go.work"], exclude: [] },
   checkReadiness: async (root) => {
@@ -325,6 +426,7 @@ var src_default = {
   },
   scan: scanGoSource
 };
+var src_default = projectScanner(scanner, async (root) => (await projectFiles(root, (file) => path5.posix.basename(file) === "go.mod")).map((file) => path5.dirname(path5.join(root, file))));
 export {
   src_default as default
 };