@keyline-icons/cli 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@keyline-icons/cli",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Search Keyline Icons and copy them into your project from the terminal.",
   "license": "MIT",
   "publishConfig": {

package/src/index.mjs

@@ -22,7 +22,7 @@ import { existsSync } from "node:fs"
 const data = JSON.parse(
   await readFile(new URL("../icons.json", import.meta.url), "utf8")
 )
-const { icons, styles } = data
+const { icons, styles, keywords = {} } = data
 const NAMES = Object.keys(icons)
 const VERSION = "0.1.0"
 
@@ -66,7 +66,15 @@ function parseArgs(argv) {
       const key = alias[k] ?? k
       if (inline !== undefined) flags[key] = inline
       else if (key === "help" || key === "version") flags[key] = true
-      else if (argv[i + 1] && !argv[i + 1].startsWith("-"))
+      else if (
+        argv[i + 1] &&
+        // A bare negative number is a value, not a flag. Without this `-l -3`
+        // read `-3` as its own short flag, left `limit` set to `true`, and fell
+        // back to the default, so it showed 25 results while `--limit=-3`
+        // clamped to 1. No name in the set starts with a digit, so nothing else
+        // can be caught by it.
+        (!argv[i + 1].startsWith("-") || /^-\d+(\.\d+)?$/.test(argv[i + 1]))
+      )
         flags[key] = argv[++i]
       else flags[key] = true
     } else positional.push(a)
@@ -94,7 +102,8 @@ function svgFor(name, style) {
 
 /** Kept in step with `@keyline-icons/mcp`, which carries the reasoning. */
 function wordsOf(query) {
-  const identifier = /[a-z][A-Z]/.test(query)
+  const identifier =
+    /[a-z][A-Z]/.test(query) || /^[A-Z][A-Za-z]*\d+$/.test(query)
   const split = identifier
     ? query
         .replace(/([a-z0-9])([A-Z])/g, "$1 $2")
@@ -112,6 +121,27 @@ function wordsOf(query) {
  * for "check-circle" when the icon is `circle-check`. Kept in step with the
  * copy in `@keyline-icons/mcp`, which carries the full reasoning.
  */
+/**
+ * The words a name can be found by: the name itself, plus whatever is written
+ * about it.
+ *
+ * Keywords are keyed by base name, because one component set in Figma covers
+ * all three containers, so `square-arrow-down` reads `arrow-down`'s words. The
+ * prefix only counts when that base exists: `circle-half` is a shape in its own
+ * right and there is no `half` for it to contain.
+ *
+ * Searched as one string rather than as a separate tier, which is what lets a
+ * query take a word from each: "help circle" finds `circle-question` because
+ * `circle` is in the name and `help` is in the words. Matching the whole query
+ * against one keyword, which is what this used to do, could never do that.
+ */
+function keywordsFor(name) {
+  const m = /^(square|circle)-(.+)$/.exec(name)
+  return keywords[m && icons[m[2]] ? m[2] : name] || []
+}
+
+const haystackFor = (name) => `${name} ${keywordsFor(name).join(" ")}`
+
 function search(query, style, limit) {
   const q = query.toLowerCase().trim()
   const words = wordsOf(query)
@@ -120,13 +150,17 @@ function search(query, style, limit) {
   return NAMES.filter(
     (n) =>
       (!style || icons[n][style]) &&
-      (n.includes(q) || words.every((w) => n.includes(w)))
+      (n.includes(q) ||
+        words.every((w) => n.includes(w)) ||
+        words.every((w) => haystackFor(n).includes(w)))
   )
     .map((n) => {
       const i = n.indexOf(q)
       const rank =
         i === -1
-          ? 4
+          ? words.every((w) => n.includes(w))
+            ? 4
+            : 5
           : n === q
             ? 0
             : n.startsWith(q)
@@ -144,8 +178,16 @@ function search(query, style, limit) {
     .map((h) => h.n)
 }
 
+/**
+ * The longest query worth answering. Kept in step with `@keyline-icons/mcp`,
+ * which carries the reasoning: `nearest` costs O(query x name) per name, so the
+ * caller sets the price, and a 200KB query took ten seconds here too.
+ */
+const MAX_QUERY = 200
+
 /** Only reached when a name misses, so it can afford to walk every name. */
 function nearest(name) {
+  if (name.length > MAX_QUERY) return []
   const q = name.toLowerCase()
   const hit = search(q, null, 5)
   if (hit.length) return hit
@@ -236,11 +278,18 @@ const commands = {
   search({ flags, positional }) {
     const query = positional.join(" ")
     if (!query) die("search needs a query. Try: keyline-icons search arrow")
+    if (query.length > MAX_QUERY)
+      die(
+        `that query is ${query.length} characters. The longest name in the set ` +
+          `is under 40, so anything over ${MAX_QUERY} is refused.`
+      )
     const style = flags.style ? styleOf(flags) : null
-    const limit = Math.min(
-      Math.max(parseInt(flags.limit ?? "25", 10) || 25, 1),
-      200
-    )
+    /* `|| 25` turned every falsy limit into the default, which swallowed `0`
+       along with the genuinely unusable ones: `--limit=0` should clamp up to 1,
+       the way `--limit=-3` does, rather than quietly show 25. Only a value that
+       is not a number at all earns the default. */
+    const raw = parseInt(flags.limit ?? "25", 10)
+    const limit = Math.min(Math.max(Number.isNaN(raw) ? 25 : raw, 1), 200)
     const hits = search(query, style, limit)
     if (!hits.length) {
       const near = nearest(query)
@@ -298,7 +347,10 @@ if (flags.version) {
 }
 if (flags.help || !positional.length) {
   commands.help()
-  process.exit(positional.length ? 0 : 1)
+  // Both print the same text and only one of them is a failure. Asking for help
+  // succeeded; running with no command did not. `--help` exiting non-zero stops
+  // any `set -e` script that offers its own usage line.
+  process.exit(flags.help ? 0 : 1)
 }
 
 const name = positional.shift()