@toolbaux/guardian 0.1.20 → 0.1.21

package/dist/commands/search.js

@@ -11,6 +11,7 @@ export async function runSearch(options) {
     const heatmap = await loadHeatmap(inputDir);
     const funcIntel = await loadFunctionIntelligence(inputDir);
     const types = normalizeTypes(options.types);
+    const projectRoot = options.projectRoot ?? process.cwd();
     const matches = searchSnapshots({
         architecture,
         ux,
@@ -18,6 +19,8 @@ export async function runSearch(options) {
         types,
         heatmap,
         funcIntel,
+        projectRoot,
+        topN: options.topN ?? 10,
     });
     const content = renderSearchMarkdown(options.query, matches);
     if (options.output) {
@@ -113,7 +116,7 @@ function scoreItem(queryTokens, item) {
     return Math.min(1, total / queryTokens.length);
 }
 function searchSnapshots(params) {
-    const { architecture, ux, query, types, heatmap, funcIntel } = params;
+    const { architecture, ux, query, types, heatmap, funcIntel, projectRoot, topN } = params;
     const queryTokens = tokenize(query);
     const matches = [];
     const pageUsage = buildComponentPageUsage(ux);
@@ -243,16 +246,23 @@ function searchSnapshots(params) {
     }
     if (types.has("functions") && funcIntel) {
         const queryTokens = tokenize(query);
-        // 1. Name match — function / theorem name contains a query token
-        for (const fn of funcIntel.functions) {
-            const score = scoreItem(queryTokens, {
-                name: fn.name,
-                file: fn.file,
-                text: [...fn.stringLiterals, ...fn.regexPatterns, ...fn.calls, fn.language],
-            });
-            if (score <= 0)
+        const fnMatches = [];
+        // Build a map: file → model field names (feature 3 — field augmentation)
+        const fileToFields = new Map();
+        for (const model of architecture.data_models) {
+            if (!model.file)
                 continue;
-            const lineRange = `${fn.lines[0]}–${fn.lines[1]}`;
+            const existing = fileToFields.get(model.file) ?? [];
+            fileToFields.set(model.file, [...existing, ...model.fields]);
+        }
+        // Helper: relativize a path if it looks absolute
+        const relativize = (filePath) => {
+            if (!path.isAbsolute(filePath))
+                return filePath;
+            return path.relative(projectRoot, filePath);
+        };
+        // Helper: build detail lines for a function hit
+        const buildDetail = (fn, relFile) => {
             const detail = [];
             if (fn.stringLiterals.length > 0) {
                 detail.push(`Literals: ${formatList(fn.stringLiterals.slice(0, 3).map((l) => `"${l.slice(0, 60)}"`), 3)}`);
@@ -263,42 +273,71 @@ function searchSnapshots(params) {
             if (fn.calls.length > 0) {
                 detail.push(`Calls: ${formatList(fn.calls, 5)}`);
             }
-            matches.push({
+            // Feature 3 — append model field names for the file this function lives in
+            const fields = fileToFields.get(fn.file) ?? fileToFields.get(relFile);
+            if (fields && fields.length > 0) {
+                detail.push(`Model fields: ${formatList(fields.slice(0, 8), 8)}`);
+            }
+            return detail;
+        };
+        // 1. Name match — function / theorem name contains a query token
+        for (const fn of funcIntel.functions) {
+            const score = scoreItem(queryTokens, {
+                name: fn.name,
+                file: fn.file,
+                text: [...fn.stringLiterals, ...fn.regexPatterns, ...fn.calls, fn.language],
+            });
+            if (score <= 0)
+                continue;
+            const relFile = relativize(fn.file);
+            const lineRange = `${fn.lines[0]}–${fn.lines[1]}`;
+            const detail = buildDetail(fn, relFile);
+            fnMatches.push({
                 type: "functions",
                 name: `${fn.name} (${fn.language})`,
                 score,
                 markdown: [
-                    `**${fn.name}** · ${fn.file}:${lineRange} · ${fn.language}${fn.isAsync ? " · async" : ""}`,
+                    `**${fn.name}** · ${relFile}:${lineRange} · ${fn.language}${fn.isAsync ? " · async" : ""}`,
                     ...detail,
                 ],
             });
         }
         // 2. Literal index match — query token appears in a function's string/regex literals
-        // (additive: surfaces functions whose body contains the queried literal even if
-        // the function name itself doesn't match)
+        // Uses proper scoreItem() ranking instead of hardcoded 0.6 to prevent noise flooding.
         for (const tok of queryTokens) {
             const hits = funcIntel.literal_index[tok.toLowerCase()];
             if (!hits)
                 continue;
             for (const hit of hits) {
                 // Skip if we already emitted this function via name match above
-                if (matches.some((m) => m.type === "functions" && m.name.startsWith(hit.function + " ("))) {
+                if (fnMatches.some((m) => m.type === "functions" && m.name.startsWith(hit.function + " ("))) {
                     continue;
                 }
                 const fn = funcIntel.functions.find((f) => f.file === hit.file && f.name === hit.function);
                 if (!fn)
                     continue;
-                matches.push({
+                const score = scoreItem(queryTokens, {
+                    name: fn.name,
+                    file: fn.file,
+                    text: [...fn.stringLiterals, ...fn.regexPatterns, ...fn.calls, fn.language],
+                });
+                const relFile = relativize(fn.file);
+                const detail = buildDetail(fn, relFile);
+                fnMatches.push({
                     type: "functions",
                     name: `${fn.name} (${fn.language})`,
-                    score: 0.6,
+                    score: Math.max(score, 0.2), // floor at 0.2 so literal hits still surface but rank below name matches
                     markdown: [
-                        `**${fn.name}** · ${fn.file}:${fn.lines[0]}–${fn.lines[1]} · ${fn.language}`,
+                        `**${fn.name}** · ${relFile}:${fn.lines[0]}–${fn.lines[1]} · ${fn.language}`,
                         `Matched literal/pattern containing "${tok}"`,
+                        ...detail,
                     ],
                 });
             }
         }
+        // Feature 2 — rank by score, cap at topN to prevent context flooding
+        fnMatches.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
+        matches.push(...fnMatches.slice(0, topN));
     }
     return matches.sort((a, b) => b.score - a.score || a.name.localeCompare(b.name));
 }

package/package.json

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