@toolbaux/guardian 0.1.4 → 0.1.5

package/dist/config.js

@@ -7,6 +7,7 @@ const DEFAULT_CONFIG = {
         root: "",
         backendRoot: "",
         frontendRoot: "",
+        roots: [],
         discovery: {
             enabled: true
         },
@@ -137,6 +138,11 @@ function normalizeConfig(input, configDir) {
         project.root = resolveMaybe(project.root) ?? "";
         project.backendRoot = resolveMaybe(project.backendRoot) ?? "";
         project.frontendRoot = resolveMaybe(project.frontendRoot) ?? "";
+        if (Array.isArray(project.roots) && configDir) {
+            project.roots = project.roots
+                .filter((r) => typeof r === "string" && r.trim().length > 0)
+                .map(r => path.resolve(configDir, r));
+        }
         normalized.project = project;
     }
     if (input.python) {
@@ -271,6 +277,7 @@ function mergeConfig(base, override) {
             root: override.project?.root ?? base.project?.root ?? "",
             backendRoot: override.project?.backendRoot ?? base.project?.backendRoot ?? "",
             frontendRoot: override.project?.frontendRoot ?? base.project?.frontendRoot ?? "",
+            roots: mergeArrays(base.project?.roots, override.project?.roots),
             discovery: {
                 enabled: override.project?.discovery?.enabled ??
                     base.project?.discovery?.enabled ??

package/dist/extract/index.js

@@ -28,8 +28,20 @@ export async function buildSnapshots(options) {
     const reportedFrontendRoot = formatOutputPath(resolvedFrontendRoot);
     const reportedWorkspaceRoot = formatOutputPath(workspaceRoot);
     const config = resolvedProject.config;
-    const backend = await analyzeBackend(resolvedBackendRoot, config, workspaceRoot);
-    const frontend = await analyzeFrontend(resolvedFrontendRoot, config);
+    // Analyze all roots — run both analyzers on each root, then merge
+    const allRoots = resolvedProject.roots;
+    const backendResults = [];
+    const frontendResults = [];
+    for (const root of allRoots) {
+        const [be, fe] = await Promise.all([
+            analyzeBackend(root, config, workspaceRoot),
+            analyzeFrontend(root, config)
+        ]);
+        backendResults.push(be);
+        frontendResults.push(fe);
+    }
+    const backend = mergeBackendAnalyses(backendResults, allRoots, workspaceRoot);
+    const frontend = mergeFrontendAnalyses(frontendResults, allRoots, workspaceRoot);
     const projectRoot = workspaceRoot;
     const runtime = await analyzeRuntime(workspaceRoot, config);
     const projectName = deriveProjectName(resolvedBackendRoot);
@@ -82,6 +94,7 @@ export async function buildSnapshots(options) {
             workspace_root: reportedWorkspaceRoot,
             backend_root: reportedBackendRoot,
             frontend_root: reportedFrontendRoot,
+            roots: resolvedProject.roots.map(formatOutputPath),
             resolution_source: resolvedProject.resolutionSource,
             entrypoints: backend.entrypoints
         },
@@ -305,6 +318,97 @@ async function buildFunctionTestCoverage(params) {
         };
     });
 }
+function mergeBackendAnalyses(results, roots, workspaceRoot) {
+    if (results.length === 1)
+        return results[0];
+    // Prefix module IDs with root-relative path so they're globally unique
+    for (let i = 0; i < results.length; i++) {
+        const rootLabel = path.relative(workspaceRoot, roots[i]).replace(/\\/g, "/");
+        const idMap = new Map();
+        for (const mod of results[i].modules) {
+            const newId = `${rootLabel}/${mod.id}`;
+            idMap.set(mod.id, newId);
+            mod.id = newId;
+            mod.path = `${rootLabel}/${mod.path}`;
+        }
+        // Remap references in graph edges, endpoints, etc.
+        for (const edge of results[i].moduleGraph) {
+            edge.from = idMap.get(edge.from) ?? edge.from;
+            edge.to = idMap.get(edge.to) ?? edge.to;
+        }
+        for (const ep of results[i].endpoints) {
+            if (ep.module && idMap.has(ep.module)) {
+                ep.module = idMap.get(ep.module);
+            }
+        }
+        for (const cycle of results[i].circularDependencies) {
+            for (let j = 0; j < cycle.length; j++) {
+                cycle[j] = idMap.get(cycle[j]) ?? cycle[j];
+            }
+        }
+        results[i].orphanModules = results[i].orphanModules.map(m => idMap.get(m) ?? m);
+        const newUsage = {};
+        for (const [key, value] of Object.entries(results[i].moduleUsage)) {
+            newUsage[idMap.get(key) ?? key] = value;
+        }
+        results[i].moduleUsage = newUsage;
+    }
+    const moduleUsage = {};
+    for (const r of results) {
+        for (const [key, value] of Object.entries(r.moduleUsage)) {
+            moduleUsage[key] = (moduleUsage[key] ?? 0) + value;
+        }
+    }
+    // Merge testCoverage: combine arrays across all roots
+    const mergedCoverage = { ...results[0].testCoverage };
+    mergedCoverage.untested_source_files = [...mergedCoverage.untested_source_files];
+    mergedCoverage.test_files_missing_source = [...mergedCoverage.test_files_missing_source];
+    mergedCoverage.coverage_map = [...mergedCoverage.coverage_map];
+    for (let i = 1; i < results.length; i++) {
+        const tc = results[i].testCoverage;
+        mergedCoverage.untested_source_files.push(...tc.untested_source_files);
+        mergedCoverage.test_files_missing_source.push(...tc.test_files_missing_source);
+        mergedCoverage.coverage_map.push(...tc.coverage_map);
+    }
+    return {
+        modules: results.flatMap(r => r.modules),
+        moduleGraph: results.flatMap(r => r.moduleGraph),
+        fileGraph: results.flatMap(r => r.fileGraph),
+        endpoints: results.flatMap(r => r.endpoints),
+        dataModels: results.flatMap(r => r.dataModels),
+        enums: results.flatMap(r => r.enums),
+        constants: results.flatMap(r => r.constants),
+        endpointModelUsage: results.flatMap(r => r.endpointModelUsage),
+        tasks: results.flatMap(r => r.tasks),
+        circularDependencies: results.flatMap(r => r.circularDependencies),
+        orphanModules: results.flatMap(r => r.orphanModules),
+        orphanFiles: results.flatMap(r => r.orphanFiles),
+        moduleUsage,
+        unusedExports: results.flatMap(r => r.unusedExports),
+        unusedEndpoints: results.flatMap(r => r.unusedEndpoints),
+        entrypoints: results.flatMap(r => r.entrypoints),
+        duplicateFunctions: results.flatMap(r => r.duplicateFunctions),
+        similarFunctions: results.flatMap(r => r.similarFunctions),
+        testCoverage: mergedCoverage,
+        tests: results.flatMap(r => r.tests)
+    };
+}
+function mergeFrontendAnalyses(results, _roots, _workspaceRoot) {
+    if (results.length === 1)
+        return results[0];
+    return {
+        files: results.flatMap(r => r.files),
+        pages: results.flatMap(r => r.pages),
+        apiCalls: results.flatMap(r => r.apiCalls),
+        uxPages: results.flatMap(r => r.uxPages),
+        components: results.flatMap(r => r.components),
+        componentGraph: results.flatMap(r => r.componentGraph),
+        fileGraph: results.flatMap(r => r.fileGraph),
+        orphanFiles: results.flatMap(r => r.orphanFiles),
+        unusedExports: results.flatMap(r => r.unusedExports),
+        tests: results.flatMap(r => r.tests)
+    };
+}
 function findCommonRoot(paths) {
     if (paths.length === 0) {
         return process.cwd();

package/dist/project-discovery.js

@@ -53,16 +53,22 @@ export async function resolveProjectPaths(options) {
         (await chooseBackendRoot(workspaceRoot));
     const frontendRoot = explicitFrontend ??
         (await chooseFrontendRoot(workspaceRoot));
+    // Build unified roots list: backendRoot + frontendRoot + any extra from config
+    const configRoots = (config.project?.roots ?? []).map(r => path.resolve(r));
+    const allRoots = [...new Set([backendRoot, frontendRoot, ...configRoots].filter(Boolean))];
     return {
         workspaceRoot,
         backendRoot,
         frontendRoot,
+        roots: allRoots,
         resolutionSource,
         config
     };
 }
 export function logResolvedProjectPaths(resolved) {
-    console.log(`Guardian roots (${resolved.resolutionSource}): workspace=${resolved.workspaceRoot} backend=${resolved.backendRoot} frontend=${resolved.frontendRoot}`);
+    const extra = resolved.roots.filter(r => r !== resolved.backendRoot && r !== resolved.frontendRoot);
+    const extraMsg = extra.length > 0 ? ` +${extra.length} roots` : "";
+    console.log(`Guardian roots (${resolved.resolutionSource}): workspace=${resolved.workspaceRoot} backend=${resolved.backendRoot} frontend=${resolved.frontendRoot}${extraMsg}`);
 }
 async function chooseBackendRoot(workspaceRoot) {
     const candidates = await discoverBackendCandidates(workspaceRoot);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@toolbaux/guardian",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "Architectural intelligence for codebases. Verify that AI-generated code matches your architectural intent.",
   "keywords": [