@groma/scanner-vue 0.1.0 → 0.1.1

package/README.md

@@ -2,7 +2,7 @@
 
 The Vue scanner adds single-file component (SFC) event bindings to Groma's
 TypeScript scanner evidence. Install the project's dependencies using its
-package manager and lockfile. The scanner reads the root `tsconfig.json`;
+package manager and lockfile. The scanner reads each selected project's `tsconfig.json`;
 it does not install dependencies or execute application code.
 
 ```sh
@@ -65,3 +65,13 @@ owns that interpretation. No new architecture metadata is added.
 
 See [validation](validation.md) for the pinned project and executed release
 checks. This prototype package name does not imply public publication.
+
+## Nested projects
+
+Run Groma from the repository root. The scanner finds package declarations in
+tracked and unignored files, including nested apps and libraries. Dependencies,
+dev dependencies, peer dependencies and optional dependencies identify framework
+projects. Each compiler uses that project's configuration and installed dependencies;
+imported source in sibling repository libraries keeps its original source path.
+Readiness checks all selected projects. A project error fails the complete scan.
+Source and nested package/configuration changes use the shared scanner watch flow.

package/dist/index.js

@@ -208497,12 +208497,54 @@ var import_typescript3 = __toESM(require_typescript(), 1);
 var import_typescript = __toESM(require_typescript2(), 1);
 var import_language_core = __toESM(require_language_core2(), 1);
 var import_typescript2 = __toESM(require_typescript(), 1);
-import { existsSync, readFileSync } from "fs";
+import { existsSync as existsSync2, readFileSync } from "fs";
 import { createRequire } from "module";
+import path2 from "path";
+
+// plugins/scanners/projects.ts
+import { execFile } from "child_process";
+import { existsSync } from "fs";
+import { readFile } 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 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();
+}
+function hasDependency(manifest, dependency) {
+  return ["dependencies", "devDependencies", "peerDependencies", "optionalDependencies"].some((section) => typeof manifest[section]?.[dependency] === "string");
+}
+async function frameworkProjects(root, dependency) {
+  const projects = [];
+  for (const file of await projectFiles(root, (file) => path.posix.basename(file) === "package.json")) {
+    const manifest = JSON.parse(await readFile(path.join(root, file), "utf8"));
+    if (hasDependency(manifest, dependency))
+      projects.push(path.dirname(path.join(root, file)));
+  }
+  return projects;
+}
+
+// plugins/scanners/vue/src/project.ts
 var vueTypeScript = import_typescript2.default;
 function relative(root, file) {
-  return path.relative(root, file).split(path.sep).join("/");
+  return path2.relative(root, file).split(path2.sep).join("/");
 }
 function nodeAt(node, position) {
   let result = node;
@@ -208528,9 +208570,9 @@ class VueProject {
   options;
   language;
   plugin;
-  constructor(root) {
-    this.root = root;
-    const configFile = path.join(root, "tsconfig.json");
+  constructor(root, repositoryRoot = root) {
+    this.root = repositoryRoot;
+    const configFile = path2.join(root, "tsconfig.json");
     const config = import_typescript2.default.readJsonConfigFile(configFile, import_typescript2.default.sys.readFile);
     const vue = import_language_core.createParsedCommandLine(vueTypeScript, import_typescript2.default.sys, configFile);
     this.options = vue.vueOptions;
@@ -208597,18 +208639,18 @@ class VueProject {
 `).length;
   }
 }
-function vueProject(root) {
-  const manifestFile = path.join(root, "package.json");
-  if (!existsSync(manifestFile))
+function vueProject(root, repositoryRoot = root) {
+  const manifestFile = path2.join(root, "package.json");
+  if (!existsSync2(manifestFile))
     return;
   const manifest = JSON.parse(readFileSync(manifestFile, "utf8"));
-  if (!manifest.dependencies?.vue && !manifest.devDependencies?.vue)
+  if (!hasDependency(manifest, "vue"))
     return;
   try {
     createRequire(manifestFile).resolve("vue/package.json");
-    return { manifest, project: new VueProject(root) };
+    return { manifest, project: new VueProject(root, repositoryRoot) };
   } catch (error) {
-    throw new Error(`VUE_PROJECT_PREPARATION: Install project dependencies with its declared package manager and lockfile; ensure root tsconfig.json and Vue sources are valid. ${error}`);
+    throw new Error(`VUE_PROJECT_PREPARATION: Install project dependencies with its declared package manager and lockfile; ensure project tsconfig.json and Vue sources are valid. ${error}`);
   }
 }
 
@@ -208782,9 +208824,53 @@ class VueEvidence {
   }
 }
 
+// plugins/scanners/vue/src/index.ts
+import path3 from "path";
+
+// 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/vue/src/index.ts
 async function scanVue(root) {
-  const prepared = vueProject(root);
+  const parts = [];
+  for (const project of await frameworkProjects(root, "vue")) {
+    const observation = await scanVueProject(project, root);
+    if (observation)
+      parts.push({ key: relative(root, project), observation });
+  }
+  return combineObservations(parts);
+}
+async function scanVueProject(projectRoot, root) {
+  const prepared = vueProject(projectRoot, root);
   if (!prepared)
     return;
   const { manifest, project } = prepared;
@@ -208797,7 +208883,7 @@ async function scanVue(root) {
   const files = project.files.map((source) => ({ file: relative(root, source.fileName), symbols: [] }));
   return createScanObservation({
     scanner: { id: "vue", technology: "typescript/vue", engine: "@vue/language-core", engineVersion: "3.3.11" },
-    roots: [{ id: "vue-project", kind: "package", name: manifest.name, file: "package.json" }],
+    roots: [{ id: "vue-project", kind: "package", name: manifest.name, file: relative(root, path3.join(projectRoot, "package.json")) }],
     files: files.map((file) => ({ ...file, roots: ["vue-project"] })),
     operations: [...evidence.operations.values()],
     invocations: evidence.invocations,
@@ -208806,10 +208892,13 @@ async function scanVue(root) {
 }
 var src_default = {
   id: "vue",
-  watch: { include: ["**/*.vue", "**/*.ts", "tsconfig.json", "package.json"], exclude: [] },
+  watch: { include: ["**/*.vue", "**/*.ts", "**/tsconfig*.json", "**/package.json"], exclude: [] },
   checkReadiness: async (root) => {
-    if (!vueProject(root))
-      throw new Error("VUE_PROJECT_REQUIRED: Select a project with vue in its root package.json, or disable the vue scanner.");
+    const projects = await frameworkProjects(root, "vue");
+    if (!projects.length)
+      throw new Error("VUE_PROJECT_REQUIRED: No Vue project declaration was found.");
+    for (const project of projects)
+      vueProject(project, root);
   },
   scan: scanVue
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@groma/scanner-vue",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Complementary Vue framework evidence; a dependency declaration does not verify runtime use.",
   "private": false,
   "type": "module",
@@ -25,10 +25,7 @@
           }
         ],
         "compatibility": {
-          "groma": "^0.3.0",
-          "technologyVersions": {
-            "vue": "3.5.18 || 3.5.42"
-          }
+          "groma": "^0.3.0"
         }
       }
     }