@squinch/core 0.1.1 → 0.2.0

package/dist/api.d.ts

@@ -36,6 +36,17 @@ export declare function iconsUsedBy(files: ProjectFile[] | string): {
  *  them and a result of only `azure/key-vaults` reads as proof that
  *  `azure/key-vault` doesn't exist) can look them up via `packInfo`. */
 export declare function searchIcons(query: string, pack?: string): string[];
+/** The same search, saying how it matched. `relaxed: true` means no icon
+ *  matched every word, so the hits are the closest partial matches instead —
+ *  callers that print for an agent loop label them (`no exact match —
+ *  closest:`), because near-misses answer the question and an empty list
+ *  forces a second pass with different words. Measured before ranking
+ *  existed: `rag` returned eighteen sto*rag*e rows with `sys/rag` dead last,
+ *  and "message queue" / "object storage" returned nothing at all. */
+export declare function searchIconsDetailed(query: string, pack?: string): {
+    hits: string[];
+    relaxed: boolean;
+};
 export type { ProjectFile };
 export type * from "./model/types.js";
 export { HUES } from "./model/types.js";

package/dist/api.js

@@ -69,6 +69,16 @@ export function iconsUsedBy(files) {
  *  them and a result of only `azure/key-vaults` reads as proof that
  *  `azure/key-vault` doesn't exist) can look them up via `packInfo`. */
 export function searchIcons(query, pack) {
+    return searchIconsDetailed(query, pack).hits;
+}
+/** The same search, saying how it matched. `relaxed: true` means no icon
+ *  matched every word, so the hits are the closest partial matches instead —
+ *  callers that print for an agent loop label them (`no exact match —
+ *  closest:`), because near-misses answer the question and an empty list
+ *  forces a second pass with different words. Measured before ranking
+ *  existed: `rag` returned eighteen sto*rag*e rows with `sys/rag` dead last,
+ *  and "message queue" / "object storage" returned nothing at all. */
+export function searchIconsDetailed(query, pack) {
     // Vendors are inconsistent about number — Azure has "Container Registries"
     // and "Data Factories" where everyone searches "container registry" and
     // "data factory" — so both sides are singularized before comparing.
@@ -97,20 +107,46 @@ export function searchIcons(query, pack) {
         }
     }
     const words = rawWords.map(stem);
-    const hits = [];
+    const joined = words.join(" ");
+    const scored = [];
     for (const name of allPackNames()) {
         if (packFilter && name !== packFilter)
             continue;
-        const aliases = packInfo(name)?.aliases ?? {};
         const haystack = (id) => norm(`${id} ${iconTitle(name, id) ?? ""}`);
-        const matched = new Set(iconIds(name).filter((id) => words.every((w) => haystack(id).includes(w))));
-        for (const id of [...matched].sort()) {
-            if (aliases[id] && matched.has(aliases[id]))
-                continue; // canonical covers it
-            hits.push(`${name}/${id}`);
+        const matchedIds = new Set(iconIds(name).filter((id) => words.some((w) => haystack(id).includes(w)) || !words.length));
+        for (const id of matchedIds) {
+            const hay = haystack(id);
+            const hayWords = new Set(hay.split(" "));
+            scored.push({
+                hit: `${name}/${id}`,
+                exact: joined && norm(id) === joined ? 1 : 0,
+                whole: words.length && words.every((w) => hayWords.has(w)) ? 1 : 0,
+                matched: words.filter((w) => hay.includes(w)).length,
+            });
         }
     }
-    return hits.sort();
+    // One row per icon: an alias row is dropped only when its canonical is in
+    // the SAME result list. Checking the broader matched set instead deduped
+    // `sys/vector-search` (a full match) against a canonical that had only
+    // matched one word and was not being returned at all.
+    const dedupe = (list) => {
+        const present = new Set(list.map((s) => s.hit));
+        return list.filter((s) => {
+            const name = s.hit.slice(0, s.hit.indexOf("/"));
+            const id = s.hit.slice(s.hit.indexOf("/") + 1);
+            const canonical = (packInfo(name)?.aliases ?? {})[id];
+            return !(canonical && present.has(`${name}/${canonical}`)); // canonical covers it
+        });
+    };
+    const rank = (list) => dedupe(list)
+        .sort((a, b) => b.exact - a.exact || b.whole - a.whole || b.matched - a.matched || (a.hit < b.hit ? -1 : 1))
+        .map((s) => s.hit);
+    const full = scored.filter((s) => s.matched === words.length);
+    if (full.length || !words.length)
+        return { hits: rank(full), relaxed: false };
+    // Nothing matched every word: fall back to partial matches, best first.
+    // Capped — the point is a next move, not a directory listing.
+    return { hits: rank(scored).slice(0, 12), relaxed: true };
 }
 // the one colour vocabulary, for editors that complete it and tests that sweep it
 export { HUES } from "./model/types.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@squinch/core",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "description": "The Squinch engine: parse, model, layout and deterministic SVG rendering for architecture diagrams as code.",
   "keywords": [
     "architecture",
@@ -33,11 +33,11 @@
     "@lezer/lr": "^1.4.10",
     "elkjs": "^0.12.0",
     "fast-xml-parser": "^5.10.1",
-    "@squinch/pack-aws": "0.1.1",
-    "@squinch/pack-logos": "0.1.1",
-    "@squinch/pack-sys": "0.1.1",
-    "@squinch/pack-k8s": "0.1.1",
-    "@squinch/pack-azure": "0.1.1"
+    "@squinch/pack-aws": "0.2.0",
+    "@squinch/pack-azure": "0.2.0",
+    "@squinch/pack-k8s": "0.2.0",
+    "@squinch/pack-logos": "0.2.0",
+    "@squinch/pack-sys": "0.2.0"
   },
   "devDependencies": {
     "@fontsource/ibm-plex-mono": "^5.3.0",