openings 0.1.41 → 0.1.43

package/.codex-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "openings",
-  "version": "0.1.41",
+  "version": "0.1.43",
   "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.41",
+  "version": "0.1.43",
   "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/index.ts

@@ -16,7 +16,7 @@ export const companies: Company[] = Object.entries(companyData).map(([slug, valu
 }));
 
 export const catalog = createCatalog({ companies });
-export { createCatalog } from "./catalog.ts";
+export { createCatalog, searchJobs } from "./catalog.ts";
 export { EXPERIENCE_VERSION, experienceLabel, experienceMatches, normalizeJobExperience, statedExperience, titleExperience, type Experience } from "./experience.ts";
 export { matchesSearchTerms, searchHaystack, searchTerms, searchTokens } from "./text-match.ts";
 export type { Catalog } from "./catalog.ts";

package/src/text-match.ts

@@ -6,12 +6,34 @@
 /** 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.
+ * A first version dropped only plurals, and a coverage panel measured the cost: of 598 results it removed,
+ * roughly 42 were genuine false matches and the rest were real roles whose titles used another form.
+ * Suffixes come off longest first, then a trailing "e", so engineer/engineering and develop/developer/development
+ * all land on one stem. Technology names carrying + or # are never touched.
+ */
+const SUFFIXES = ["ment", "ing", "or", "er", "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 "engineering" stops at "engineer" while "engineer" goes on to "engine" and the two never meet.
+  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.length > 4 && word.endsWith("e") ? word.slice(0, -1) : word;
 }
 
+/** Words written as one in some titles and two in others; the index carries both readings. */
+const COMPOUNDS = [["full", "stack"], ["front", "end"], ["back", "end"], ["dev", "ops"], ["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 +44,16 @@ 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));
+  // "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.41";
+export const VERSION = "0.1.43";