@toolbaux/guardian 0.1.4 → 0.1.6

package/dist/commands/context.js

@@ -12,11 +12,20 @@ export async function runContext(options) {
         loadArchitectureDiff(inputDir),
         loadHeatmap(inputDir)
     ]);
+    // Load structural intelligence if available
+    let si;
+    try {
+        const siPath = path.join(inputDir, "structural-intelligence.json");
+        const siRaw = await fs.readFile(siPath, "utf8");
+        si = JSON.parse(siRaw);
+    }
+    catch { /* not available */ }
     const content = renderContextBlock(architecture, ux, {
         focusQuery: options.focus,
         maxLines: normalizeMaxLines(options.maxLines),
         diff,
-        heatmap
+        heatmap,
+        structuralIntelligence: si
     });
     if (!options.output) {
         console.log(content);

package/dist/commands/generate.js

@@ -144,7 +144,7 @@ function renderAiContextMarkdown(architecture, ux, options) {
     }
     lines.push(renderContextBlock(architecture, ux, {
         focusQuery: options?.focusQuery,
-        maxLines: options?.maxLines ?? 80,
+        maxLines: options?.maxLines ?? 200,
         structuralIntelligence: options?.structuralIntelligence
     }));
     lines.push("");

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/context-block.js

@@ -8,7 +8,36 @@ export function renderContextBlock(architecture, ux, options) {
     lines.push("");
     lines.push(`**Backend:** ${ormModels.length} ORM models + ${schemaModels} schemas · ${architecture.endpoints.length} endpoints · ${architecture.modules.length} modules`);
     lines.push(`**Frontend:** ${ux.components.length} components · ${ux.pages.length} pages`);
+    // Show all roots if multi-root project
+    const roots = architecture.project.roots;
+    if (roots && roots.length > 2) {
+        lines.push(`**Roots:** ${roots.join(", ")}`);
+    }
     lines.push("");
+    // Module map with key exports — the most useful section for AI context
+    const modulesWithExports = architecture.modules.filter(m => m.exports.length > 0 || m.files.length > 0);
+    if (modulesWithExports.length > 0) {
+        lines.push("### Module Map");
+        for (const mod of modulesWithExports) {
+            const allSymbols = mod.exports.flatMap(e => e.symbols).filter(Boolean);
+            const topSymbols = allSymbols.slice(0, 6);
+            const symbolStr = topSymbols.length > 0
+                ? ` — exports: ${topSymbols.join(", ")}${allSymbols.length > 6 ? ` (+${allSymbols.length - 6} more)` : ""}`
+                : ` — ${mod.files.length} files`;
+            const epCount = mod.endpoints.length > 0 ? ` · ${mod.endpoints.length} endpoints` : "";
+            lines.push(`- **${mod.id}** (${mod.layer})${epCount}${symbolStr}`);
+        }
+        lines.push("");
+    }
+    // Cross-module dependencies
+    const crossEdges = architecture.dependencies.module_graph.filter(e => e.from !== e.to);
+    if (crossEdges.length > 0) {
+        lines.push("### Module Dependencies");
+        for (const edge of crossEdges.slice(0, 10)) {
+            lines.push(`- ${edge.from} → ${edge.to}`);
+        }
+        lines.push("");
+    }
     const couplingFiles = pickTopCouplingFiles(architecture, options?.heatmap, 5);
     if (couplingFiles.length > 0) {
         lines.push("### High-Coupling Files");
@@ -103,11 +132,9 @@ export function renderContextBlock(architecture, ux, options) {
         }
     }
     lines.push("<!-- /guardian:context -->");
-    const maxLines = options?.maxLines ?? 120;
-    if (lines.length <= maxLines) {
-        return lines.join("\n");
-    }
-    return [...lines.slice(0, maxLines - 2), "- context truncated for line budget", "<!-- /guardian:context -->"].join("\n");
+    // No global truncation — each section self-limits via .slice().
+    // Every section is guaranteed to appear with at least a few entries.
+    return lines.join("\n");
 }
 function tokenize(value) {
     return value

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.6",
   "type": "module",
   "description": "Architectural intelligence for codebases. Verify that AI-generated code matches your architectural intent.",
   "keywords": [
@@ -41,7 +41,8 @@
   },
   "scripts": {
     "build": "tsc -p tsconfig.json",
-    "prepublishOnly": "npm run build",
+    "prepublishOnly": "npm run test:critical && npm run build",
+    "test:critical": "vitest run tests/critical/",
     "dev": "tsx src/cli.ts",
     "start": "node dist/cli.js",
     "typecheck": "tsc -p tsconfig.json --noEmit",