@toolbaux/guardian 0.1.20 → 0.1.22

package/dist/commands/mcp-serve.js

@@ -311,30 +311,63 @@ async function search(args) {
     // Frontend pages: match path or component
     const pages = (d.frontend_pages || []).filter((p) => p.path?.toLowerCase().includes(q) || p.component?.toLowerCase().includes(q) ||
         p.api_calls?.some((c) => c.toLowerCase().includes(q))).slice(0, 5).map((p) => `${p.path} → ${p.component}`);
-    // Functions: search literal_index (tactic:simp, sorry, string patterns) + function names
+    // Functions: ranked search across names, literals, calls — capped at 10 to prevent flooding
     const fnHits = [];
     const fi = await loadFuncIntel();
     if (fi) {
-        // Literal index: exact key match + partial key match
+        // Build a field map: file → field names (augments fn hits with model fields)
+        const fileToFields = new Map();
+        for (const m of Object.values(d.model_registry || {})) {
+            if (!m.file)
+                continue;
+            const existing = fileToFields.get(m.file) ?? [];
+            fileToFields.set(m.file, [...existing, ...(m.fields ?? [])]);
+        }
+        const scored = [];
+        const seen = new Set();
+        for (const fn of (fi.functions ?? [])) {
+            const nameNorm = (fn.name ?? "").toLowerCase();
+            const fileNorm = (fn.file ?? "").toLowerCase();
+            const callsNorm = (fn.calls ?? []).map((c) => c.toLowerCase());
+            const litsNorm = [...(fn.stringLiterals ?? []), ...(fn.regexPatterns ?? [])].map((l) => l.toLowerCase());
+            let score = 0;
+            if (nameNorm === q)
+                score = 1.0;
+            else if (nameNorm.includes(q))
+                score = 0.7;
+            else if (callsNorm.some((c) => c.includes(q)))
+                score = 0.5;
+            else if (litsNorm.some((l) => l.includes(q)))
+                score = 0.3;
+            else if (fileNorm.includes(q))
+                score = 0.2;
+            if (score > 0) {
+                scored.push({ fn, score });
+                seen.add(`${fn.file}:${fn.name}`);
+            }
+        }
+        // Also surface literal_index hits not already captured
         const litIndex = fi.literal_index ?? {};
         for (const [key, hits] of Object.entries(litIndex)) {
-            if (key.includes(q)) {
-                for (const h of hits.slice(0, 3)) {
-                    fnHits.push(`${h.function} [${h.file}:${h.line}] (lit:${key})`);
-                }
+            if (!key.includes(q))
+                continue;
+            for (const h of hits) {
+                const uid = `${h.file}:${h.function}`;
+                if (seen.has(uid))
+                    continue;
+                seen.add(uid);
+                const fn = fi.functions.find((f) => f.file === h.file && f.name === h.function);
+                scored.push({ fn: fn ?? { name: h.function, file: h.file, lines: [h.line, h.line], calls: [], stringLiterals: [], regexPatterns: [] }, score: 0.25 });
             }
-            if (fnHits.length >= 10)
-                break;
         }
-        // Function names: match by name
-        if (fnHits.length < 10) {
-            for (const fn of (fi.functions ?? [])) {
-                if (fn.name?.toLowerCase().includes(q)) {
-                    fnHits.push(`${fn.name} [${fn.file}:${fn.lines?.[0]}]`);
-                    if (fnHits.length >= 10)
-                        break;
-                }
-            }
+        // Sort by score desc, take top 10
+        scored.sort((a, b) => b.score - a.score);
+        const projectRoot = process.cwd();
+        for (const { fn } of scored.slice(0, 10)) {
+            const relFile = fn.file?.startsWith("/") ? require("path").relative(projectRoot, fn.file) : fn.file;
+            const fields = fileToFields.get(fn.file) ?? [];
+            const fieldSuffix = fields.length > 0 ? ` fields:${fields.slice(0, 5).join(",")}` : "";
+            fnHits.push(`${fn.name} [${relFile}:${fn.lines?.[0]}]${fieldSuffix}`);
         }
     }
     return compact({

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.22",
   "type": "module",
   "description": "Architectural intelligence for codebases. Verify that AI-generated code matches your architectural intent.",
   "keywords": [