openings 0.1.42 → 0.1.44

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "Find evidence-grounded jobs, including relevant roles you may not have searched for, without accounts or API keys.",
   "author": { "name": "Openings contributors" },
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.42",
+  "version": "0.1.44",
   "description": "A free, candidate-safe job-search substrate for AI agents",
   "license": "MIT",
   "repository": { "type": "git", "url": "git+https://github.com/abhay-avagama/hiring-agent.git" },

package/src/text-match.ts

@@ -6,12 +6,38 @@
 /** Everything outside this set separates tokens, so "full-stack" and "full stack" agree. */
 const SEPARATORS = /[^a-z0-9.+#]+/g;
 
-/** A trailing plural "s" is dropped on both sides, so "engineers" and "engineer" meet in the middle. */
+/**
+ * Word forms are reduced on both sides, because a candidate typing "engineer" means "Engineering" too.
+ * Only plurals and "-ing" come off. A wider rule was measured and withdrawn: stripping "er" and "ment" merged
+ * agent nouns with activity nouns, so "developer" reached 378 Business and Corporate Development titles and
+ * "engineer" reached Search Engine Optimization. Word-form overlap helps retrieval, but these are different jobs.
+ * Technology names carrying + or # are never touched.
+ */
+const SUFFIXES = ["ing", "s"];
 function stem(token: string): string {
   if (token.length < 4 || /[+#]/.test(token)) return token;
-  return token.endsWith("s") && !token.endsWith("ss") ? token.slice(0, -1) : token;
+  let word = token;
+  // Reduce repeatedly, or "engineerings" stops one form short of "engineer".
+  for (let pass = 0; pass < 3; pass += 1) {
+    const before = word;
+    for (const suffix of SUFFIXES) {
+      if (word.length - suffix.length >= 4 && word.endsWith(suffix) && !(suffix === "s" && word.endsWith("ss"))) {
+        word = word.slice(0, -suffix.length);
+        break;
+      }
+    }
+    if (word === before) break;
+  }
+  return word;
 }
 
+/** Words written as one in some titles and two in others; the index carries both readings. */
+/** Written as one word, these are read as two as well, but never joined the other way: joining "Dev" and "Ops" in
+ * "Clin Dev Ops" produced a DevOps match for Clinical Development Operations. */
+const SPLIT_ONLY = [["dev", "ops"], ["web", "ops"], ["fin", "tech"]].map(([left, right]) => ({ left: left!, right: right!, joined: `${left}${right}` }));
+
+const COMPOUNDS = [["full", "stack"], ["front", "end"], ["back", "end"], ["data", "base"], ["work", "flow"]].map(([left, right]) => ({ left: left!, right: right!, joined: `${left}${right}` }));
+
 export function searchTokens(text: string): string[] {
   return text.toLocaleLowerCase().replace(SEPARATORS, " ").split(" ")
     .map((token) => token.replace(/^\.+/, "").replace(/\.+$/, ""))
@@ -22,10 +48,18 @@ export function searchTokens(text: string): string[] {
 /** The text a job is matched against, padded so a term only matches a whole token. A dotted name is also
  * indexed by its parts, so "node" finds "Node.js" while "node.js" still does. */
 export function searchHaystack(text: string): string {
-  const indexed = new Set<string>();
-  for (const token of searchTokens(text)) {
-    indexed.add(token);
-    if (token.includes(".")) for (const part of token.split(".")) if (part) indexed.add(stem(part));
+  const tokens = searchTokens(text);
+  const indexed = new Set<string>(tokens);
+  for (const token of tokens) if (token.includes(".")) for (const part of token.split(".")) if (part) indexed.add(stem(part));
+  // A word written as one is also read as two, which is always safe: the title really does contain both parts.
+  for (const { left, right, joined } of SPLIT_ONLY) if (indexed.has(stem(joined))) { indexed.add(stem(left)); indexed.add(stem(right)); }
+  // "Fullstack" and "Full Stack" are the same job: index each reading so either spelling finds both.
+  for (const { left, right, joined } of COMPOUNDS) {
+    const leftStem = stem(left); const rightStem = stem(right); const joinedStem = stem(joined);
+    if (indexed.has(joinedStem)) { indexed.add(leftStem); indexed.add(rightStem); }
+    for (let index = 0; index + 1 < tokens.length; index += 1) {
+      if (tokens[index] === leftStem && tokens[index + 1] === rightStem) indexed.add(joinedStem);
+    }
   }
   return ` ${[...indexed].join(" ")} `;
 }

package/src/version.ts

@@ -1 +1 @@
-export const VERSION = "0.1.42";
+export const VERSION = "0.1.44";