zigsm 1.4.1 → 1.4.2

package/dist/std.js

@@ -743,6 +743,36 @@ function setInputString(s) {
 let inMemoryEmbeddingCache = null;
 let cachedSourceTextIndex = null;
 let cachedSourceTextRef = null;
+function countWordHits(text, words) {
+    let hits = 0;
+    for (const word of words) {
+        if (text.includes(word))
+            hits++;
+    }
+    return hits;
+}
+function scoreDeclMatch(decl, queryLower, queryWords) {
+    const nameLower = decl.name.toLowerCase();
+    const pathLower = decl.path.toLowerCase();
+    let score = 0;
+    if (nameLower === queryLower)
+        score += 1000;
+    else if (nameLower.startsWith(queryLower))
+        score += 700;
+    else if (nameLower.includes(queryLower))
+        score += 450;
+    if (pathLower.includes(queryLower))
+        score += 150;
+    if (score === 0 && queryWords.length > 0) {
+        const searchable = `${nameLower} ${decl.preview.toLowerCase()} ${pathLower}`;
+        const wordHits = countWordHits(searchable, queryWords);
+        if (wordHits === queryWords.length)
+            score += 300;
+        else if (wordHits > 0)
+            score += wordHits * 80;
+    }
+    return score;
+}
 async function initWasmRuntime(wasmPath, stdSources) {
     const fs = await import("node:fs");
     const wasmBytes = typeof wasmPath === "string" ? fs.readFileSync(wasmPath) : wasmPath;
@@ -888,34 +918,55 @@ function buildSourceTextIndex(stdSources) {
 function fallbackSearchStdLib(stdSources, query, limit) {
     const index = buildSourceTextIndex(stdSources);
     const queryLower = query.toLowerCase().trim();
-    const scored = index.decls
-        .map((decl) => {
-        const nameLower = decl.name.toLowerCase();
-        const pathLower = decl.path.toLowerCase();
-        let score = 0;
-        if (nameLower === queryLower)
-            score += 1000;
-        else if (nameLower.startsWith(queryLower))
-            score += 700;
-        else if (nameLower.includes(queryLower))
-            score += 450;
-        if (pathLower.includes(queryLower))
-            score += 150;
-        return { decl, score };
-    })
+    const queryWords = queryLower.split(/\s+/).filter(Boolean);
+    const declScored = index.decls
+        .map((decl) => ({ decl, score: scoreDeclMatch(decl, queryLower, queryWords) }))
         .filter((item) => item.score > 0)
         .sort((a, b) => b.score - a.score);
+    const contentMatches = [];
+    if (declScored.length < limit) {
+        for (const file of index.files) {
+            const lines = file.text.split("\n");
+            for (let lineIndex = 0; lineIndex < lines.length; lineIndex++) {
+                const wordHits = countWordHits(lines[lineIndex].toLowerCase(), queryWords);
+                if (wordHits === queryWords.length) {
+                    contentMatches.push({
+                        path: file.path,
+                        line: lineIndex + 1,
+                        preview: lines[lineIndex].trim().slice(0, 120),
+                        score: 200 + wordHits * 30,
+                    });
+                }
+                if (contentMatches.length >= limit * 3)
+                    break;
+            }
+            if (contentMatches.length >= limit * 3)
+                break;
+        }
+        contentMatches.sort((a, b) => b.score - a.score);
+    }
     let markdown = `# Search Results\n\nQuery: "${query}"\n\n`;
     markdown += `_Fallback mode: text index (parser-incompatible Zig version)_\n\n`;
-    if (scored.length === 0) {
+    if (declScored.length === 0 && contentMatches.length === 0) {
         markdown += "No results found.";
         return markdown;
     }
-    const limited = scored.slice(0, limit);
-    markdown += `Found ${scored.length} results (showing ${limited.length}):\n\n`;
-    for (let i = 0; i < limited.length; i++) {
-        const entry = limited[i].decl;
-        markdown += `- std.${entry.name} (${entry.path}:${entry.line})\n`;
+    if (declScored.length > 0) {
+        const limited = declScored.slice(0, limit);
+        markdown += `Found ${declScored.length} declaration matches (showing ${limited.length}):\n\n`;
+        for (let i = 0; i < limited.length; i++) {
+            const entry = limited[i].decl;
+            markdown += `- std.${entry.name} (${entry.path}:${entry.line})\n`;
+        }
+    }
+    if (contentMatches.length > 0 && declScored.length < limit) {
+        const remaining = limit - declScored.length;
+        const limited = contentMatches.slice(0, remaining);
+        markdown += `\nContent matches:\n\n`;
+        for (let i = 0; i < limited.length; i++) {
+            const entry = limited[i];
+            markdown += `- ${entry.path}:${entry.line} — \`${entry.preview}\`\n`;
+        }
     }
     return markdown;
 }
@@ -934,17 +985,7 @@ function fallbackGetStdLibItem(stdSources, name, getSourceFile) {
     const target = name.split(".").pop()?.trim() || name.trim();
     const targetLower = target.toLowerCase();
     const ranked = index.decls
-        .map((decl) => {
-        const declLower = decl.name.toLowerCase();
-        let score = 0;
-        if (declLower === targetLower)
-            score += 1000;
-        else if (declLower.startsWith(targetLower))
-            score += 700;
-        else if (declLower.includes(targetLower))
-            score += 450;
-        return { decl, score };
-    })
+        .map((decl) => ({ decl, score: scoreDeclMatch(decl, targetLower, [targetLower]) }))
         .filter((item) => item.score > 0)
         .sort((a, b) => b.score - a.score);
     if (ranked.length === 0) {

package/dist/tools.js

@@ -67,15 +67,26 @@ function getBuiltinFunctionTool(builtinFunctions) {
                     ],
                 };
             }
+            const queryBare = queryLower.replace(/@/g, "");
+            const queryWords = queryBare.split(/\s+/).filter(Boolean);
             const scoredFunctions = builtinFunctions.map((fn) => {
                 const funcLower = fn.func.toLowerCase();
+                const funcBare = funcLower.replace(/^@/, "");
                 let score = 0;
-                if (funcLower === queryLower)
+                if (funcLower === queryLower || funcBare === queryBare)
                     score += 1000;
                 else if (funcLower.startsWith(queryLower))
                     score += 500;
                 else if (funcLower.includes(queryLower))
                     score += 300;
+                if (score === 0 && queryWords.length > 0) {
+                    const searchable = `${funcBare} ${fn.docs.toLowerCase()} ${fn.signature.toLowerCase()}`;
+                    const wordHits = queryWords.filter((w) => searchable.includes(w)).length;
+                    if (wordHits === queryWords.length)
+                        score += 200;
+                    else if (wordHits > 0)
+                        score += wordHits * 60;
+                }
                 if (score > 0)
                     score += Math.max(0, 50 - fn.func.length);
                 return { ...fn, score };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "zigsm",
-  "version": "1.4.1",
+  "version": "1.4.2",
   "type": "module",
   "bin": {
     "zsm": "dist/mcp.js"